mirror of
https://github.com/fhem/fhem-mirror.git
synced 2024-06-17 05:40:11 +00:00
13ceb5cd28
git-svn-id: https://svn.fhem.de/fhem/trunk/fhem@6392 2b470e98-0d58-463d-a4d8-8e2adae1ed80
322 lines
9.9 KiB
Perl
322 lines
9.9 KiB
Perl
########################################################################################
|
|
#
|
|
# OWX_DS2480.pm
|
|
#
|
|
# FHEM module providing hardware dependent functions for the DS9097 interface of OWX
|
|
#
|
|
# Prof. Dr. Peter A. Henning
|
|
# Norbert Truchsess
|
|
#
|
|
# $Id$
|
|
#
|
|
########################################################################################
|
|
#
|
|
# Provides the following methods for OWX
|
|
#
|
|
# Alarms
|
|
# Complex
|
|
# Define
|
|
# Discover
|
|
# Init
|
|
# Reset
|
|
# Verify
|
|
#
|
|
########################################################################################
|
|
|
|
package OWX_DS9097;
|
|
|
|
use strict;
|
|
use warnings;
|
|
use Time::HiRes qw( gettimeofday );
|
|
|
|
use vars qw/@ISA/;
|
|
@ISA='OWX_SER';
|
|
|
|
use ProtoThreads;
|
|
no warnings 'deprecated';
|
|
|
|
sub new($) {
|
|
my ($class,$serial) = @_;
|
|
return bless $serial,$class;
|
|
}
|
|
|
|
########################################################################################
|
|
#
|
|
# Complex - Send match ROM, data block and receive bytes as response
|
|
#
|
|
# Parameter hash = hash of bus master,
|
|
# owx_dev = ROM ID of device
|
|
# data = string to send
|
|
# numread = number of bytes to receive
|
|
#
|
|
# Return response, if OK
|
|
# 0 if not OK
|
|
#
|
|
########################################################################################
|
|
|
|
sub get_pt_execute($$$$) {
|
|
my ($self, $reset, $dev, $writedata, $numread) = @_;
|
|
my $pt_query;
|
|
return PT_THREAD(sub {
|
|
my ($thread) = @_;
|
|
my $select;
|
|
PT_BEGIN($thread);
|
|
$self->reset() if ($reset);
|
|
if (defined $writedata or $numread) {
|
|
#-- has match ROM part
|
|
if( $dev ) {
|
|
#-- 8 byte 1-Wire device address
|
|
my @rom_id;
|
|
#-- from search string to byte id
|
|
$dev=~s/\.//g;
|
|
for(my $i=0;$i<8;$i++){
|
|
$rom_id[$i]=hex(substr($dev,2*$i,2));
|
|
}
|
|
$select=sprintf("\x55%c%c%c%c%c%c%c%c",@rom_id);
|
|
#-- has no match ROM part, issue skip ROM command (0xCC:)
|
|
} else {
|
|
$select="\xCC";
|
|
}
|
|
if (defined $writedata) {
|
|
$select.=$writedata;
|
|
}
|
|
#-- for debugging
|
|
if( $main::owx_async_debug > 1){
|
|
main::Log3($self->{name},5,"OWX_DS9097::pt_execute: Sending out ".unpack ("H*",$select));
|
|
}
|
|
$self->block($select);
|
|
}
|
|
#-- has receive data part
|
|
if( $numread ) {
|
|
$select = "";
|
|
#$numread += length($data);
|
|
for( my $i=0;$i<$numread;$i++){
|
|
$select .= "11111111";
|
|
};
|
|
$pt_query = $self->pt_query($select);
|
|
PT_WAIT_THREAD($pt_query);
|
|
die $pt_query->PT_CAUSE() if ($pt_query->PT_STATE() == PT_ERROR || $pt_query->PT_STATE() == PT_CANCELED);
|
|
my $res = pack "b*",$pt_query->PT_RETVAL();
|
|
main::Log3($self->{name},5,"OWX_DS9097::pt_execute: Receiving ".unpack ("H*",$res)) if( $main::owx_async_debug > 1);
|
|
PT_EXIT($res);
|
|
} else {
|
|
PT_EXIT("");
|
|
}
|
|
PT_END;
|
|
});
|
|
}
|
|
|
|
sub reset() {
|
|
my ( $serial ) = @_;
|
|
|
|
if (defined (my $hwdevice = $serial->{hash}->{USBDev})) {
|
|
|
|
$hwdevice->baudrate(9600);
|
|
$hwdevice->write_settings;
|
|
main::Log3($serial->{name},5, "OWX_DS9097 9600 baud") if ( $main::owx_async_debug > 2 );
|
|
$hwdevice->write("\xF0");
|
|
main::Log3($serial->{name},5, "OWX_DS9097 reset") if ( $main::owx_async_debug > 1 );
|
|
while ($serial->poll()) {};
|
|
$hwdevice->baudrate(115200);
|
|
$hwdevice->write_settings;
|
|
main::Log3($serial->{name},5, "OWX_DS9097 115200 baud") if ( $main::owx_async_debug > 2 );
|
|
}
|
|
}
|
|
|
|
sub block($) {
|
|
my ( $serial, $block ) = @_;
|
|
main::Log3($serial->{name},5, "OWX_DS9097 block: ".unpack "H*",$block) if ( $main::owx_async_debug > 1 );
|
|
foreach my $bit (split //,unpack "b*",$block) {
|
|
$serial->bit($bit);
|
|
}
|
|
}
|
|
|
|
sub bit($) {
|
|
my ( $serial, $bit ) = @_;
|
|
if (defined (my $hwdevice = $serial->{hash}->{USBDev})) {
|
|
my $sp1 = $bit == 1 ? "\xFF" : "\x00";
|
|
main::Log3($serial->{name},5, sprintf("OWX_DS9097 bit: %02x",ord($sp1))) if ( $main::owx_async_debug > 2 );
|
|
$hwdevice->write($sp1);
|
|
} else {
|
|
die "no USBDev";
|
|
}
|
|
}
|
|
|
|
sub pt_query($) {
|
|
my ( $serial, $query ) = @_;
|
|
my @bitsout = split //,$query;
|
|
my $numbits = @bitsout;
|
|
my $bitsin = "";
|
|
my $bit;
|
|
return PT_THREAD(sub {
|
|
my ( $thread ) = @_;
|
|
PT_BEGIN($thread);
|
|
main::Log3($serial->{name},5, "OWX_DS9097 pt_query out: ".$query) if( $main::owx_async_debug );
|
|
while ($serial->poll()) {};
|
|
$serial->{string_raw} = "";
|
|
while (defined ($bit = shift @bitsout)) {
|
|
$serial->bit($bit);
|
|
};
|
|
main::OWX_ASYNC_TaskTimeout($serial->{hash},gettimeofday+main::AttrVal($serial->{name},"timeout",1));
|
|
PT_WAIT_UNTIL(length($serial->{string_raw}) >= $numbits);
|
|
$bitsin = join "", map { ($_ == 0xFF) ? "1" : "0" } unpack "C*",$serial->{string_raw};
|
|
main::Log3($serial->{name},5,"OWX_DS9097 pt_query in: ".$bitsin) if ( $main::owx_async_debug );
|
|
PT_EXIT($bitsin);
|
|
PT_END;
|
|
});
|
|
}
|
|
|
|
sub read() {
|
|
my ($serial) = @_;
|
|
if (defined (my $hwdevice = $serial->{hash}->{USBDev})) {
|
|
my $string_part = $hwdevice->input();
|
|
if (defined $string_part and length($string_part) > 0) {
|
|
$serial->{string_raw} .= $string_part;
|
|
main::Log3($serial->{name},5, "OWX_DS9097 read: Loop no. $serial->{num_reads}, Receiving: ".unpack("H*",$string_part)) if( $main::owx_async_debug > 1 );
|
|
return 1;
|
|
} elsif ($main::owx_async_debug > 2) {
|
|
main::Log3($serial->{name},5, "OWX_DS9097 read: Loop no. $serial->{num_reads}, no data read:");
|
|
foreach my $i (0..6) {
|
|
my ($package, $filename, $line, $subroutine, $hasargs, $wantarray, $evaltext, $is_require, $hints, $bitmask, $hinthash) = caller($i);
|
|
main::Log3($serial->{name},5, "$subroutine $filename $line");
|
|
}
|
|
}
|
|
}
|
|
return undef;
|
|
}
|
|
|
|
sub pt_next ($$) {
|
|
|
|
my ($serial,$context,$mode)=@_;
|
|
|
|
my $id_bit_number = 1;
|
|
my ($pt_query,$search_direction,@search,$query,$result);
|
|
|
|
return PT_THREAD(sub {
|
|
my ( $thread ) = @_;
|
|
PT_BEGIN($thread);
|
|
$serial->reset();
|
|
#-- issue the normal search command \xF0 or the alarm search command \xEC
|
|
if( $mode ne "alarm" ){
|
|
$serial->block("\xF0");
|
|
} else {
|
|
$serial->block("\xEC");
|
|
}
|
|
|
|
#-- Response search data parsing operates bitwise
|
|
|
|
@search = split //, unpack "b64", pack "C8",@{$context->{ROM_ID}};
|
|
|
|
#-- bits < LastDiscrepancy are allready known:
|
|
$query = "";
|
|
$result = "";
|
|
|
|
if ($context->{LastDiscrepancy} > 0) {
|
|
while ( $id_bit_number < $context->{LastDiscrepancy} ) {
|
|
$query.= "11".$search[$id_bit_number-1];
|
|
$id_bit_number++;
|
|
}
|
|
# $id_bit_number now is equal LastDiscrepancy
|
|
if ($id_bit_number < 65) {
|
|
$query.="111";
|
|
$search[$id_bit_number-1] = 1;
|
|
$id_bit_number++;
|
|
}
|
|
}
|
|
|
|
$query.="11" if ($id_bit_number != 57 and $id_bit_number < 65);
|
|
$pt_query = $serial->pt_query($query);
|
|
|
|
while (1) {
|
|
|
|
PT_WAIT_THREAD($pt_query);
|
|
die $pt_query->PT_CAUSE() if ($pt_query->PT_STATE() == PT_ERROR || $pt_query->PT_STATE() == PT_CANCELED);
|
|
my $ret = $pt_query->PT_RETVAL();
|
|
|
|
die "unparsable return of query '$ret'" unless ($ret =~ /(1|0)(1|0)$/);
|
|
$result.=$ret;
|
|
|
|
last if ( $id_bit_number > 64 );
|
|
|
|
if ( $id_bit_number < 65 ) {
|
|
|
|
my $id_bit = $1;
|
|
my $cmp_id_bit = $2;
|
|
|
|
if( ($id_bit == 1) && ($cmp_id_bit == 1) ){
|
|
main::Log3 ($serial->{name},5, "no devices present at id_bit_number=$id_bit_number");
|
|
last;
|
|
}
|
|
if ( $id_bit != $cmp_id_bit ){
|
|
$search_direction = $id_bit;
|
|
} else {
|
|
$search_direction = 0;
|
|
}
|
|
# set or clear the bit in the ROM byte rom_byte_number
|
|
# with mask rom_byte_mask
|
|
$search[$id_bit_number-1] = $search_direction;
|
|
# serial number search direction write bit
|
|
$serial->bit($search_direction);
|
|
$result.="$search_direction";
|
|
|
|
main::Log3 ($serial->{name},5,"id_bit_number: $id_bit_number, search_direction: $search_direction, ROM_ID: ".sprintf("%02X.%02X%02X%02X%02X%02X%02X.%02X",unpack "C8",pack "b64", join "",@search)) if ($main::owx_async_debug);
|
|
|
|
$id_bit_number++;
|
|
last if ($id_bit_number > 64);
|
|
$pt_query = $serial->pt_query("11") unless ( $id_bit_number == 57 );
|
|
}
|
|
#bits 57-64 are CRC and can be calculated from bits 1-56
|
|
if ( $id_bit_number == 57 ) {
|
|
my @crc = (0,unpack("C7", pack ("b64", join ("",@search[0..55]))));
|
|
@search[56..63] = split //,unpack "b8",pack "C1",(main::OWX_CRC(\@crc));
|
|
$query = "";
|
|
while ($id_bit_number < 65) {
|
|
$query.= "11".$search[$id_bit_number-1];
|
|
$id_bit_number++;
|
|
}
|
|
$pt_query = $serial->pt_query($query);
|
|
}
|
|
}
|
|
|
|
die "unexpected length of result: ".length($result).", expected: 192" if (length($result)!=192);
|
|
|
|
my $bit_number = 0;
|
|
my @bits = split //,$result;
|
|
my $last_zero = 0;
|
|
my @found = (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
|
|
|
|
if ($main::owx_async_debug>2) {
|
|
my @results;
|
|
for (my $i=0;$i<64;$i++) {
|
|
push @results,substr($result,$i*3,3);
|
|
}
|
|
main::Log3 ($serial->{name},5,"result: ".join(":",@results));
|
|
main::Log3 ($serial->{name},5,"bits: ".join(",",@bits));
|
|
main::Log3 ($serial->{name},5,"search: ".join(",",@search));
|
|
}
|
|
|
|
while(@bits) {
|
|
my $id_bit = shift @bits;
|
|
my $cmp_id_bit = shift @bits;
|
|
shift @bits;
|
|
if ($id_bit == 1 and $cmp_id_bit == 1) {
|
|
last;
|
|
} elsif ($id_bit == 0 and $cmp_id_bit == 0) {
|
|
if ($search[$bit_number] == 0) {
|
|
$last_zero = $bit_number+1;
|
|
}
|
|
$found[$bit_number] = $search[$bit_number];
|
|
} else {
|
|
$found[$bit_number] = $id_bit;
|
|
}
|
|
$bit_number++;
|
|
}
|
|
@{$context->{ROM_ID}} = unpack "C8", pack "b64", join "",@found;
|
|
$context->{LastDiscrepancy} = $last_zero;
|
|
|
|
main::Log3 ($serial->{name},5,"bit_number: $bit_number, LastDiscrepancy: $last_zero, ROM_ID: ".sprintf("%02X.%02X%02X%02X%02X%02X%02X.%02X",@{$context->{ROM_ID}})) if ($main::owx_async_debug);
|
|
PT_END;
|
|
});
|
|
}
|
|
|
|
1; |