PageRenderTime 50ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 0ms

/tags/v2-29/mh/lib/Serial_Item.pm

#
Perl | 512 lines | 303 code | 43 blank | 166 comment | 62 complexity | 4db9719db7453181e12b022cce27e020 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, GPL-3.0 
    

  1. use strict;
    2. 

  2. 

  3. package Serial_Item;
    4. 

  4. 

  5. @Serial_Item::ISA = ('Generic_Item');
    6. 

  6. 

  7. my (%serial_items_by_id);
    8. 

  8. 

  9. sub reset {
    10. 

  10.     undef %serial_items_by_id;   # Reset on code re-load
    11. 

  11. }
    12. 

  12. 

  13. sub serial_items_by_id {
    14. 

  14.     my($id) = @_;
    15. 

  15.     return unless $serial_items_by_id{$id};
    16. 

  16.     return @{$serial_items_by_id{$id}};
    17. 

  17. }
    18. 

  18.                                 # For backward compatability, return just the first item
    19. 

  19. sub serial_item_by_id {
    20. 

  20.     my($id) = @_;
    21. 

  21.     my @refs = &serial_items_by_id($id);
    22. 

  22.     return $refs[0];
    23. 

  23. }
    24. 

  24. 

  25. sub new {
    26. 

  26.     my ($class, $id, $state, $port_name) = @_;
    27. 

  27.     my $self = {state => ''};
    28. 

  28. #   print "\n\nWarning: duplicate ID codes on different Serial_Item objects:\n " .
    29. 

  29. #         "id=$id state=$state states=@{${$serial_item_by_id{$id}}{states}}\n\n" if $serial_item_by_id{$id};
    30. 

  30.     $$self{port_name} = $port_name;
    31. 

  31.     &add($self, $id, $state);
    32. 

  32.     bless $self, $class;
    33. 

  33.     $self->set_interface($port_name) if $id and $id =~ /^X/;
    34. 

  34.     return $self;
    35. 

  35. }
    36. 

  36. sub add {
    37. 

  37.     my ($self, $id, $state) = @_;
    38. 

  38.                                 # Allow for Serial_Item's without states
    39. 

  39.     $state = 'default_state' unless defined $state;
    40. 

  40. 

  41.     $$self{state_by_id}{$id} = $state if $id;
    42. 

  42.     $$self{id_by_state}{$state} = $id;
    43. 

  43.     push(@{$$self{states}}, $state);
    44. 

  44.     push(@{$serial_items_by_id{$id}}, $self) if $id;
    45. 

  45. }
    46. 

  46. 

  47. sub is_started {
    48. 

  48.     my ($self) = @_;
    49. 

  49.     my $port_name = $self->{port_name};
    50. 

  50.     return ($main::Serial_Ports{$port_name}{object}) ? 1 : 0;
    51. 

  51. }
    52. 

  52. sub is_stopped {
    53. 

  53.     my ($self) = @_;
    54. 

  54.     my $port_name = $self->{port_name};
    55. 

  55.     return ($main::Serial_Ports{$port_name}{object}) ? 0 : 1;
    56. 

  56. }
    57. 

  57. 

  58.                                 # Try to do a 'new' ... object is not kept, even if new is sucessful
    59. 

  59.                                 #   - not sure if there is a better way to test if a port is available
    60. 

  60.                                 #     Hopefully this is not too wasteful
    61. 

  61. sub is_available {
    62. 

  62.     my ($self) = @_;
    63. 

  63. 

  64.     my $port_name = $self->{port_name};
    65. 

  65.     my $port = $main::Serial_Ports{$port_name}{port};
    66. 

  66.     print "testing port $port ... ";
    67. 

  67. 

  68.     my $sp_object;
    69. 

  69. 

  70.                                 # Use the 2nd parm of '1' to indicate this do a test open
    71. 

  71.                                 #  - Modified Win32::SerialPort so it does not compilain if New/open fails
    72. 

  72.     if (( $main::OS_win and $sp_object = new Win32::SerialPort($port, 1))or 
    73. 

  73.         (!$main::OS_win and $sp_object = new Device::SerialPort($port))) {
    74. 

  74.         print " available\n";
    75. 

  75.         $sp_object->close;
    76. 

  76.         return 1;
    77. 

  77.     }
    78. 

  78.     else {
    79. 

  79.         print " not available\n";
    80. 

  80.         return 0;
    81. 

  81.     }
    82. 

  82. }
    83. 

  83. 

  84. sub start {
    85. 

  85.     my ($self) = @_;
    86. 

  86.     my $port_name = $self->{port_name};
    87. 

  87.     print "Starting port $port_name on port $main::Serial_Ports{$port_name}{port}\n";
    88. 

  88.     if ($main::Serial_Ports{$port_name}{object}) {
    89. 

  89.         print "Port $port_name is already started\n";
    90. 

  90.         return;
    91. 

  91.     }
    92. 

  92.     if ($port_name) {
    93. 

  93.         if (&main::serial_port_open($port_name)) {
    94. 

  94.             print "Port $port_name was re-opened\n";
    95. 

  95.         }
    96. 

  96.         else {
    97. 

  97.             print "Serial_Item start failed for port $port_name\n";
    98. 

  98.         }
    99. 

  99.     }
    100. 

  100.     else {
    101. 

  101.         print "Error in Serial_Item start:  no port name for object=$self\n";
    102. 

  102.     }
    103. 

  103. }
    104. 

  104. 

  105. sub stop {
    106. 

  106.     my ($self) = @_;
    107. 

  107.     my $port_name = $self->{port_name};
    108. 

  108.     my $sp_object = $main::Serial_Ports{$port_name}{object};
    109. 

  109.     if ($sp_object) {
    110. 

  110. 

  111.         my $port = $main::Serial_Ports{$port_name}{port};
    112. 

  112. #       &Win32::SerialPort::debug(1);
    113. 

  113.         if ($sp_object->close) {
    114. 

  114.             print "Port $port_name on port $port was closed\n";
    115. 

  115.         }
    116. 

  116.         else {
    117. 

  117.             print "Serial_Item stop failed for port $port_name\n";
    118. 

  118.         }
    119. 

  119.                                 # Delete the ports, even if it didn't close, so we can do 
    120. 

  120.                                 # starts again without a 'port reuse' message.
    121. 

  121.         delete $main::Serial_Ports{$port_name}{object};
    122. 

  122.         delete $main::Serial_Ports{object_by_port}{$port};
    123. 

  123. #       &Win32::SerialPort::debug(0);
    124. 

  124.     }
    125. 

  125.     else {
    126. 

  126.         print "Error in Serial_Item stop for port $port_name: Port is not started\n";
    127. 

  127.     }
    128. 

  128. }
    129. 

  129. 

  130. sub said {
    131. 

  131.     my $port_name = $_[0]->{port_name};
    132. 

  132.     my $datatype  = $main::Serial_Ports{$port_name}{datatype};
    133. 

  133.     
    134. 

  134.     my $data;
    135. 

  135.     if ($datatype and $datatype eq 'raw') {
    136. 

  136.         $data = $main::Serial_Ports{$port_name}{data};
    137. 

  137.         $main::Serial_Ports{$port_name}{data} = '';
    138. 

  138.     }
    139. 

  139.     else {
    140. 

  140.         $data = $main::Serial_Ports{$port_name}{data_record};
    141. 

  141.         $main::Serial_Ports{$port_name}{data_record} = ''; # Maybe this should be reset in main loop??
    142. 

  142.     }
    143. 

  143.     return $data;
    144. 

  144. }
    145. 

  145. 

  146. sub set_data {
    147. 

  147.     my ($self, $data) = @_;
    148. 

  148.     my $port_name = $self->{port_name};
    149. 

  149.     my $datatype  = $main::Serial_Ports{$port_name}{datatype};
    150. 

  150.     if ($datatype eq 'raw') {
    151. 

  151.         $main::Serial_Ports{$port_name}{data} = $data;
    152. 

  152.     }
    153. 

  153.     else {
    154. 

  154.         $main::Serial_Ports{$port_name}{data_record} = $data;
    155. 

  155.     }
    156. 

  156. }
    157. 

  157. 

  158. sub set_receive {
    159. 

  159.     my ($self, $state) = @_;
    160. 

  160.     &Generic_Item::set_states_for_next_pass($self, $state);
    161. 

  161. }
    162. 

  162. 

  163. sub set_dtr {
    164. 

  164.     my ($self, $state) = @_;
    165. 

  165.     my $port_name = $self->{port_name};
    166. 

  166.     if (my $serial_port = $main::Serial_Ports{$port_name}{object}) {
    167. 

  167.         $main::Serial_Ports{$port_name}{object}->dtr_active($state);
    168. 

  168.         print "Serial_port $port_name dtr set to $state\n" if $main::config_parms{debug} eq 'serial';
    169. 

  169.     }
    170. 

  170.     else {
    171. 

  171.         print "Error, serial port set_dtr for $port_name failed, port has not been set\n";
    172. 

  172.     }
    173. 

  173. }
    174. 

  174. sub set_rts {
    175. 

  175.     my ($self, $state) = @_;
    176. 

  176.     my $port_name = $self->{port_name};
    177. 

  177.     if (my $serial_port = $main::Serial_Ports{$port_name}{object}) {
    178. 

  178.         $main::Serial_Ports{$port_name}{object}->rts_active($state);
    179. 

  179.         print "Serial_port $port_name rts set to $state\n" if $main::config_parms{debug} eq 'serial';
    180. 

  180.     }
    181. 

  181.     else {
    182. 

  182.         print "Error, serial port set_rts for $port_name failed, port has not been set\n";
    183. 

  183.     }
    184. 

  184. }
    185. 

  185. 

  186. 

  187. sub set {
    188. 

  188.     my ($self, $state) = @_;
    189. 

  189.                                 # Allow for Serial_Item's without states
    190. 

  190.     $state = 'default_state' unless defined $state; 
    191. 

  191. 

  192.     &Generic_Item::set_states_for_next_pass($self, $state);
    193. 

  193. 

  194.     return unless %main::Serial_Ports;
    195. 

  195. 

  196.     my $serial_id;
    197. 

  197.     if (defined $self->{id_by_state}{$state}) {
    198. 

  198.         $serial_id = $self->{id_by_state}{$state};
    199. 

  199.     }
    200. 

  200.     else {
    201. 

  201.         $serial_id = $state;
    202. 

  202.     }
    203. 

  203.     my $serial_data = $serial_id;
    204. 

  204. 

  205.     my $port_name = $self->{port_name};
    206. 

  206. 

  207.     print "Serial_Item: port=$port_name self=$self state=$state data=$serial_data interface=$$self{interface}\n" 
    208. 

  208.         if $main::config_parms{debug} eq 'serial';
    209. 

  209. 

  210.     return if $main::Save{mode} eq 'offline';
    211. 

  211. 

  212.     my $interface = $$self{interface};
    213. 

  213.     $interface = 'none' unless $interface;
    214. 

  214.     if ($interface eq 'cm11') {
    215. 

  215.                                 # Allow for xx% (e.g. 1% -> &P1)
    216. 

  216.         if ($serial_data =~ /(\d+)%/) {
    217. 

  217.             $serial_data = '&P' . int ($1 * 63 / 100 + 0.5);
    218. 

  218.         }
    219. 

  219.                                 # Make sure that &P codes have the house code prefixed
    220. 

  220.                                 #  - e.g. device A1 -> A&P1
    221. 

  221.         if ($serial_data =~ /^&P/) {
    222. 

  222.             $serial_data = substr($self->{x10_id}, 1, 1) . $serial_data;
    223. 

  223.         }
    224. 

  224.                                 # If code is &P##, prefix with item code.
    225. 

  225.                                 #  - e.g. A&P1 -> A1A&P1
    226. 

  226.         if (substr($serial_data, 1, 1) eq '&') {
    227. 

  227.             $serial_data = $self->{x10_id} . $serial_data;
    228. 

  228.         }
    229. 

  229.                                 # Allow for:
    230. 

  230.                                 # - Extended data will have & starting the function code 
    231. 

  231.                                 #   e.g. XO7&P23 -> Device O7 to Preset Dim code 23
    232. 

  232.                                 # - Bright/dim on house codes: e.g. XA+20 (but not XA1A+20)
    233. 

  233. #        if (length $serial_data > 3 and substr($serial_data, 3, 1) eq '&' or
    234. 

  234. #            $serial_data =~ /^\S\S[\+\-]/) {
    235. 

  235. #            &ControlX10::CM11::send($main::Serial_Ports{cm11}{object}, substr($serial_data, 1));
    236. 

  236. #        }
    237. 

  237.                                 # Normal data ... call once for the Unit code, once for the Function code
    238. 

  238. #        else {
    239. 

  239.             &ControlX10::CM11::send($main::Serial_Ports{cm11}{object}, substr($serial_data, 1, 2));
    240. 

  240.             &ControlX10::CM11::send($main::Serial_Ports{cm11}{object}, substr($serial_data, 3)) if length($serial_data) > 3;
    241. 

  241. #        }
    242. 

  242.     }
    243. 

  243.     elsif ($interface eq 'cm17') {
    244. 

  244.                                 # cm17 wants XA1K, not XA1AK
    245. 

  245.         substr($serial_data, 3, 1) = '';
    246. 

  246.         &ControlX10::CM17::send($main::Serial_Ports{cm17}{object}, substr($serial_data, 1));
    247. 

  247.     }
    248. 

  248.     elsif ($interface eq 'homevision') {
    249. 

  249.         print "Using homevision to send: $serial_data\n";
    250. 

  250.         &Homevision::send($main::Serial_Ports{Homevision}{object}, $serial_data);
    251. 

  251.     }
    252. 

  252.     elsif ($interface eq 'homebase') {
    253. 

  253.         print "Using homebase to send: $serial_data\n";
    254. 

  254.         &HomeBase::send_X10($main::Serial_Ports{HomeBase}{object}, substr($serial_data, 1, 2));
    255. 

  255.         &HomeBase::send_X10($main::Serial_Ports{HomeBase}{object}, substr($serial_data, 3)) if length($serial_data) > 2;
    256. 

  256.     }
    257. 

  257.     elsif ($interface eq 'houselinc') {
    258. 

  258.         print "Using houselinc to send: $serial_data\n";
    259. 

  259.         &HouseLinc::send_X10($main::Serial_Ports{HouseLinc}{object}, $serial_data);
    260. 

  260.     }
    261. 

  261.     elsif ($interface eq 'marrick') {
    262. 

  262.         print "Using marrick to send: $serial_data\n";
    263. 

  263.         &Marrick::send_X10($main::Serial_Ports{Marrick}{object}, $serial_data);
    264. 

  264.     }
    265. 

  265.     elsif ($interface eq 'ncpuxa') {
    266. 

  266.         print "Using ncpuxa to send: $serial_data\n";
    267. 

  267.         &ncpuxa_mh::send($main::config_parms{ncpuxa_port}, $serial_data);
    268. 

  268.     }
    269. 

  269.     else {
    270. 

  270.         $port_name = 'Homevision' if !$port_name and $main::Serial_Ports{Homevision}{object}; #Since it's multifunction, it should be default
    271. 

  271.         $port_name = 'weeder'  if !$port_name and $main::Serial_Ports{weeder}{object};
    272. 

  272.         $port_name = 'serial1' if !$port_name and $main::Serial_Ports{serial1}{object};
    273. 

  273.         $port_name = 'serial2' if !$port_name and $main::Serial_Ports{serial2}{object};
    274. 

  274. #       print "\$port_name is $port_name\n\$main::Serial_Ports{Homevision}{object} is $main::Serial_Ports{Homevision}{object}\n";
    275. 

  275.         unless ($port_name) {
    276. 

  276.             print "Error, serial set called, but no serial port found: data=$serial_data\n";
    277. 

  277.             return;
    278. 

  278.         }
    279. 

  279.         unless ($main::Serial_Ports{$port_name}{object}) {
    280. 

  280.             print "Error, serial port for $port_name has not been set: data=$serial_data\n";
    281. 

  281.             return;
    282. 

  282.         }
    283. 

  283.         
    284. 

  284.                                 # Weeder table does not match what we defined in CM11,CM17,X10_Items.pm
    285. 

  285.                                 #  - Dim -> L, Bright -> M,  AllOn -> I, AllOff -> H
    286. 

  286.         if ($port_name eq 'weeder' and
    287. 

  287.             my ($device, $house, $command) = $serial_data =~ /^X(\S\S)(\S)(\S+)/) {
    288. 

  288. 

  289.                                 # Allow for +-xx%
    290. 

  290.             my $dim_amount = 3;
    291. 

  291.             if ($command =~ /[\+\-]\d+/) {
    292. 

  292.                 $dim_amount = int(10 * abs($command) / 100); # about 10 levels to 100%
    293. 

  293.                 $command = ($command > 0) ? 'L' : 'M';
    294. 

  294.             }
    295. 

  295.                 
    296. 

  296.             if ($command eq 'M') {
    297. 

  297.                 $command =  'L' . (($house . 'L') x $dim_amount);
    298. 

  298.             }
    299. 

  299.             elsif ($command eq 'L') {
    300. 

  300.                 $command =  'M' . (($house . 'M') x $dim_amount);
    301. 

  301.             }
    302. 

  302.             elsif ($command eq 'O') {
    303. 

  303.                 $command =  'I';
    304. 

  304.             }
    305. 

  305.             elsif ($command eq 'P') {
    306. 

  306.                 $command =  'H';
    307. 

  307.             }
    308. 

  308.             $serial_data = 'X' . $device . $house . $command;
    309. 

  309. 

  310. 				# Give weeder a chance to do the previous command
    311. 

  311. 				# Surely there must be a better way!
    312. 

  312.             select undef, undef, undef, 1.2;
    313. 

  313.         }
    314. 

  314. 

  315.         if (lc($port_name) eq 'homevision') {
    316. 

  316.             &Homevision::send($main::Serial_Ports{Homevision}{object}, $serial_data);
    317. 

  317.         }
    318. 

  318.         else {
    319. 

  319.             my $datatype  = $main::Serial_Ports{$port_name}{datatype};
    320. 

  320.             $serial_data .= "\r" unless $datatype and $datatype eq 'raw';
    321. 

  321.             my $results = $main::Serial_Ports{$port_name}{object}->write($serial_data);
    322. 

  322.             
    323. 

  323. #           &main::print_log("serial port=$port_name out=$serial_data results=$results") if $main::config_parms{debug} eq 'serial';
    324. 

  324.             print "serial port=$port_name out=$serial_data results=$results\n" if $main::config_parms{debug} eq 'serial';
    325. 

  325.         }
    326. 

  326.     }
    327. 

  327. 

  328.                                 # Check for X10 All-on All-off house codes
    329. 

  329.     if ($serial_data =~ /^X(\S)([OP])$/) {
    330. 

  330.         print "X10: mh set House code $1 set to $2\n" if $main::config_parms{debug} eq 'X10';
    331. 

  331.         my $state = ($2 eq 'O') ? 'on' : 'off';
    332. 

  332.         &X10_Item::set_by_housecode($1, $state);
    333. 

  333.     }
    334. 

  334.                                 # Check for other items with the same codes
    335. 

  335.                                 #  - If found, set them to the same state
    336. 

  336.     if ($serial_items_by_id{$serial_id} and my @refs = @{$serial_items_by_id{$serial_id}}) {
    337. 

  337.         for my $ref (@refs) {
    338. 

  338.             next if $ref eq $self;
    339. 

  339.                                 # Only compare between items on the same port
    340. 

  340.             my $port_name1 = ($self->{port_name} or ' ');
    341. 

  341.             my $port_name2 = ($ref ->{port_name} or ' ');
    342. 

  342.             next unless $port_name1 eq $port_name2;
    343. 

  343. 

  344.             print "Serial_Item: Setting duplicate state: id=$serial_id item1=$$self{object_name} item2=$$ref{object_name}\n" 
    345. 

  345.                 if $main::config_parms{debug} eq 'serial';
    346. 

  346.             if ($state = $$ref{state_by_id}{$serial_id}) {
    347. 

  347.                 $ref->set_receive($state);
    348. 

  348.             }
    349. 

  349.             else {
    350. 

  350.                 $ref->set_receive($serial_id);
    351. 

  351.             }
    352. 

  352.         }
    353. 

  353.     }
    354. 

  354. 

  355. }    
    356. 

  356. 

  357. sub set_interface {
    358. 

  358.     my ($self, $interface) = @_;
    359. 

  359.                                 # Set the default interface
    360. 

  360.     unless ($interface) {
    361. 

  361.         if ($main::Serial_Ports{cm11}{object}) {
    362. 

  362.             $interface = 'cm11';
    363. 

  363.         }
    364. 

  364.         elsif ($main::Serial_Ports{cm17}{object}) {
    365. 

  365.             $interface = 'cm17';
    366. 

  366.         }
    367. 

  367.         elsif ($main::Serial_Ports{Homevision}{object}) {
    368. 

  368.             $interface = 'homevision';
    369. 

  369.         }
    370. 

  370.         elsif ($main::Serial_Ports{HomeBase}{object}) {
    371. 

  371.             $interface = 'homebase';
    372. 

  372.         }
    373. 

  373.         elsif ($main::Serial_Ports{HouseLinc}{object}) {
    374. 

  374.             $interface = 'houselinc';
    375. 

  375.         }
    376. 

  376.         elsif ($main::Serial_Ports{Marrick}{object}) {
    377. 

  377.             $interface = 'marrick';
    378. 

  378.         }
    379. 

  379.         elsif ($main::config_parms{ncpuxa_port}) {
    380. 

  380.             $interface = 'ncpuxa';
    381. 

  381.         }
    382. 

  382. 

  383.     }
    384. 

  384.     $$self{interface} = lc($interface) if $interface;
    385. 

  385. }
    386. 

  386. 

  387. 

  388. #
    389. 

  389. # $Log$
    390. 

  390. # Revision 1.41  2000/10/01 23:29:40  winter
    391. 

  391. # - 2.29 release
    392. 

  392. #
    393. 

  393. # Revision 1.40  2000/09/09 21:19:11  winter
    394. 

  394. # - 2.28 release
    395. 

  395. #
    396. 

  396. # Revision 1.39  2000/08/19 01:22:36  winter
    397. 

  397. # - 2.27 release
    398. 

  398. #
    399. 

  399. # Revision 1.38  2000/06/24 22:10:54  winter
    400. 

  400. # - 2.22 release.  Changes to read_table, tk_*, tie_* functions, and hook_ code
    401. 

  401. #
    402. 

  402. # Revision 1.37  2000/05/27 16:40:10  winter
    403. 

  403. # - 2.20 release
    404. 

  404. #
    405. 

  405. # Revision 1.36  2000/05/06 16:34:32  winter
    406. 

  406. # - 2.15 release
    407. 

  407. #
    408. 

  408. # Revision 1.35  2000/03/10 04:09:01  winter
    409. 

  409. # - Add Ibutton support and more web changes
    410. 

  410. #
    411. 

  411. # Revision 1.34  2000/02/13 03:57:27  winter
    412. 

  412. #  - 2.00 release.  New web server interface
    413. 

  413. #
    414. 

  414. # Revision 1.33  2000/02/12 06:11:37  winter
    415. 

  415. # - commit lots of changes, in preperation for mh release 2.0
    416. 

  416. #
    417. 

  417. # Revision 1.32  2000/01/27 13:42:42  winter
    418. 

  418. # - update version number
    419. 

  419. #
    420. 

  420. # Revision 1.31  2000/01/19 13:23:29  winter
    421. 

  421. # - add yucky delay to Weeder X10 xmit
    422. 

  422. #
    423. 

  423. # Revision 1.30  2000/01/02 23:47:43  winter
    424. 

  424. # - add Device:: to as Serilport check.  Use 10, not 7, increments in weeder dim
    425. 

  425. #
    426. 

  426. # Revision 1.29  1999/12/09 03:00:21  winter
    427. 

  427. # - added Weeder bright/dim support
    428. 

  428. #
    429. 

  429. # Revision 1.28  1999/11/08 02:16:17  winter
    430. 

  430. # - Move X10 stuff to X10_Items.pm.  Fix close method
    431. 

  431. #
    432. 

  432. # Revision 1.27  1999/11/02 14:51:36  winter
    433. 

  433. # - delete port in any case in stop method
    434. 

  434. #
    435. 

  435. # Revision 1.26  1999/10/31 14:49:04  winter
    436. 

  436. # - added X10 &P## preset dim option and X10_Lamp item
    437. 

  437. #
    438. 

  438. # Revision 1.25  1999/10/27 12:42:27  winter
    439. 

  439. # - add delete to serial_ports_by_port in sub close
    440. 

  440. #
    441. 

  441. # Revision 1.24  1999/10/09 20:36:49  winter
    442. 

  442. # - add call to set_interface in first new method.  Change to ControlX10
    443. 

  443. #
    444. 

  444. # Revision 1.23  1999/10/02 22:41:10  winter
    445. 

  445. # - move interface stuff to set_interface, so we can use for x10_appliances also
    446. 

  446. #
    447. 

  447. # Revision 1.22  1999/09/27 03:16:32  winter
    448. 

  448. # - move cm11 to HomeAutomation dir
    449. 

  449. #
    450. 

  450. # Revision 1.21  1999/09/12 16:57:07  winter
    451. 

  451. # - point to new cm17 path
    452. 

  452. #
    453. 

  453. # Revision 1.20  1999/08/30 00:23:30  winter
    454. 

  454. # - add set_dtr set_rts.  Add check on loop_count
    455. 

  455. #
    456. 

  456. # Revision 1.19  1999/08/02 02:24:21  winter
    457. 

  457. # - Add STATUS state
    458. 

  458. #
    459. 

  459. # Revision 1.18  1999/06/27 20:12:09  winter
    460. 

  460. # - add CM17 support
    461. 

  461. #
    462. 

  462. # Revision 1.17  1999/06/20 22:32:43  winter
    463. 

  463. # - check for raw datatype on writes
    464. 

  464. #
    465. 

  465. # Revision 1.16  1999/04/29 12:25:20  winter
    466. 

  466. # - add House all on/off states
    467. 

  467. #
    468. 

  468. # Revision 1.15  1999/03/21 17:35:36  winter
    469. 

  469. # - add datatype raw
    470. 

  470. #
    471. 

  471. # Revision 1.14  1999/03/12 04:30:24  winter
    472. 

  472. # - add start, stop, and set_receive methods
    473. 

  473. #
    474. 

  474. # Revision 1.13  1999/02/16 02:06:57  winter
    475. 

  475. # - add homebase send errata
    476. 

  476. #
    477. 

  477. # Revision 1.12  1999/02/08 03:50:25  winter
    478. 

  478. # - re-enable serial writes!  Bug introduced in last install.
    479. 

  479. #
    480. 

  480. # Revision 1.11  1999/02/08 00:30:54  winter
    481. 

  481. # - make serial port prints depend on debug parm
    482. 

  482. #
    483. 

  483. # Revision 1.10  1999/01/30 19:55:45  winter
    484. 

  484. # - add more checks for blank objects, so we don't abend
    485. 

  485. #
    486. 

  486. # Revision 1.9  1999/01/23 16:23:43  winter
    487. 

  487. # - change the Serial_Port object to match Socket_Port format
    488. 

  488. #
    489. 

  489. # Revision 1.8  1999/01/13 14:11:03  winter
    490. 

  490. # - add some more debug records
    491. 

  491. #
    492. 

  492. # Revision 1.7  1999/01/07 01:55:40  winter
    493. 

  493. # - add 5% increments on X10_Item
    494. 

  494. #
    495. 

  495. # Revision 1.6  1998/12/10 14:34:19  winter
    496. 

  496. # - fix empty state case
    497. 

  497. #
    498. 

  498. # Revision 1.5  1998/12/07 14:33:27  winter
    499. 

  499. # - add dim level support.  Allow for arbitrary set commands.
    500. 

  500. #
    501. 

  501. # Revision 1.4  1998/11/15 22:04:26  winter
    502. 

  502. # - add support for generic serial ports
    503. 

  503. #
    504. 

  504. # Revision 1.3  1998/09/12 22:13:14  winter
    505. 

  505. # - added HomeBase call
    506. 

  506. #
    507. 

  507. # Revision 1.2  1998/08/29 20:46:36  winter
    508. 

  508. # - allow for cm11 interface
    509. 

  509. #
    510. 

  510. #
    511. 

  511. 

  512. 1;
    513. 

  513.