HOUSE/290 Comm Engine for CP290


=| Introduction |=

 

This documentation is specifically for the Communications Engine only. It 
documents the settings of this program, shows how to setup a named pipe to 
use a custom client program and how to access functions inside the Comm 
Engine to control the CP290. If you are not writing your own program for 
X-10 control, consult the Help inside HOUSE/290 for program operation 
information.  

This document is also intended for users to help in troubleshooting in case 
of problems and also for programmers who want to access the functions of 
the Comm Engine to control the CP290 with their own REXX program.  

For general operation and troubleshooting, refer to each of the sections 
below. 

Description | Installation | Getting Started | Important Notes | Menu 
Description | Network Operation | Troubleshooting  

For function description and programming information, refer to each of  the 
sections below. 

Comm Engine Function Description | X10LDLL Function Description  


=| Description |=

 

HOUSE/290 ver. 2.0 - Shareware. HOUSE/2 - Home Automation & Security for 
OS/2 using the CP290 interface by X-10.  

HOUSE/290 is an OS/2 version 3.0 and later program to control the home 
automation interface model CP290 made by X-10. HOUSE/290 brings a modern 
graphical user interface to the CP290 and provides a separate REXX-enabled 
and network aware communications engine for this popular X-10 controller. 
Unlike other programs for the CP290, HOUSE/290 will work on Pentium class 
computers.  

The Comm Engine is part of HOUSE/290 and is shareware. Registration is 
available through BMT Micro at www.bmtmicro.com or through the author 
directly. Registration now includes the game Leave-One, a puzzle similar to 
Pegged. See the section How To Register for details.  

The HOUSE/290 Communications Engine has the following features:   

 Communicates to the CP290 via an RS-232 serial port.   

 Acts as a fully REXX-enabled server.   

 Launch up to four user defined programs whenever certain X-10 events are 
detected.   

 Uses named pipe to communicate to H290MAIN.EXE client program or any 
other custom client programs. Sample source for custom programs is 
included.   

 Can be controlled over a network (LAN or peer-to-peer) allowing X-10 home 
control through the CP290 from any workstation.   

 Accepts commands like A1 DIM 60 and translates them into X-10 code for 
the CP290 interface.   

 Full support for all CP290 functions with the exception of graphics 
upload.  

 

Note: In order to fully take advantage of the program's features, you must 
buy the CP290 interface and at least one module. This can be done for 
around $80 total to get you started and it can easily be expanded from that 
point on. See Internet Links for Home Automation for information on home 
control devices.  

X-10 devices are available for most international power configurations. 
Please see Internet Links for Home Automation for information on X-10 
representatives around the world.  


=| Important Notes |=

 

HOUSE/290 is normally started through the H290.EXE executable which 
displays a splash screen and loads the main program (H290MAIN.EXE) and 
communications engine (CP290CE.EXE). If you write your own custom REXX 
program to access the Comm Engine, you may start CP290CE.EXE by itself. To 
run the Comm Engine alone, the following minimum files are required to be 
present: CP290CE.EXE, CP290.INI, CP290CE.HLP, RXASYNC.DLL, X10CPDLL.DLL and 
REXXUTIL.DLL.  

Problem: 

You may experience a growth in swap file under the following circumstances: 
You run another Vispro/REXX compiled program at the same time as HOUSE/290 
(or Comm Engine) AND Object REXX is active. If you repeatedly start and 
exit HOUSE/290 while another Vispro/REXX program is running, the swap file 
keeps growing. You may have to start and exit HOUSE/290 (or Comm Engine) 
5-10 times before you see a growth. The memory is not released until both 
Vispro/REXX-compiled programs are closed. If you close both programs, the 
swap file will return to it's original size. I have been able to duplicate 
this problem with UPS Monitor for OS/2 and the HOUSE/290 main and Comm 
Engine program. This memory leak may not be specific to these programs as 
the source of the problem points to Object REXX. If you use classic REXX, 
this problem will not occur.  


=| Getting Started |=

 

This section describes the various ways that HOUSE/290 and the Comm Engine 
can be applied.  

Default Operation 

Default operation is for operation of the CP290 interface from a single 
computer. HOUSE/290 is set to start-up the Comm Engine in the background. 
All operations can be done through HOUSE/290 and the Comm Engine does in 
most cases not require attention. The Comm Engine can be made visible by 
accessing the windows list (press CRTL-ESC) and showing it by 
right-clicking on it's name. By default, the Comm Engine is automatically 
closed whenever HOUSE/290 is closed.  

Network Operation 

For operation over a LAN or peer-to-peer network, HOUSE/290 needs to be 
configured differently. Install the CP290 at one of the workstations or 
server. Install the Comm Engine at the same computer where you installed 
the CP290. Start up the Comm Engine (CP290CE.EXE) separately from 
HOUSE/290. Leave the Comm Engine running so HOUSE/290 can access it. 
HOUSE/290 can not start-up the Comm Engine over a network, it must be done 
manually. 

Install HOUSE/290 on any other computer on the network. Start up 
H290MAIN.EXE and configure it so the Comm Engine does not start 
automatically. Fill in the computer name where HOUSE/290 can find the Comm 
Engine. After you changed the computer name inside H290MAIN.EXE, you must 
disconnect and then reconnect to the Comm Engine. This will establish 
communications between the two programs.  

Operation with your own REXX Program 

If you want to use your own REXX programs to access the CP290 functions, 
simply start the Comm Engine and use your REXX program to communicate via 
the named pipe to the Comm Engine. Remember that only one program can 
access the named pipe at one time. See the section on REXX Examples for a 
sample REXX program.  


  =| REXX Examples |=

The sample program below shows how to use the Comm Engine's REXX features 
to turn a module on and then off at a certain time. This program is also 
part of the HOUSE/290 distribution and is named TIMEMOD.CMD. More examples 
are included in MODCTRL.CMD which turns on a module as soon as the program 
is run, and RSTCP290.CMD which uploads timer events into the CP290 from a 
pre-defined file. 

These examples require the Comm Engine to be running and connection made to 
the CP290. 


/* TIMEMOD.CMD - Start Module at a certain time, then turn it off at a 
certain time. */

/*        Written by A. Schwarz. See http://home.att.net/~ASchw  */

/*        This is an example to show how to access the HOUSE/290 Comm 
Engine functions. */

/* Load X10LDLL.DLL */
call RxFuncAdd 'X10LLoadFuncs', 'X10LDLL', 'X10LLoadFuncs'
call X10LLoadFuncs 

/* Load REXXUTIL.DLL */
call RxFuncAdd 'SysLoadFuncs', 'RexxUtil', 'SysLoadFuncs'
call SysLoadFuncs 

pipename = '\PIPE\HOUSE290'  /* single backslashes only when using on 
single computer */

/* Note: If running over a network, precede the pipe name with the computer 
name as shown below. */

/* pipename = '\\CLIENT527\PIPE\HOUSE290' */  /* note the _two_ backslashes 
preceding the computer name */

SAY ' ' 
SAY 'This program turns module A1 on and off at a certain time.'
SAY 'The Comm Engine must be running and be connected to'
SAY 'the CP290 for this program to work.'
SAY ' ' 
SAY 'Press C to continue, any other key to exit...'
PARSE PULL keyhit 

IF keyhit <> 'c' & keyhit <> 'C' THEN 
 EXIT 

/* Check if pipe is available and connect to it */
rc = CLOpenPipe(pipename)
IF rc = 0 then 
 DO 
  rc =  CLPeekPipe('0')
  IF Right(rc, 1) = 3 THEN 
   SAY 'Connected to Comm Engine.'
  ELSE 
   DO 
    SAY 'Comm Engine unavailable, closing.'
    rc = CLClosePipe('0')
    SAY 'Press any key to exit...'
    PARSE PULL keyhit 
    Signal ExitError1 
   END 
 END 
ELSE 
 DO 
  SAY 'Comm Engine not available.'
  SAY 'Press any key to exit...'
  PARSE PULL keyhit 
  Signal ExitError1 
 END 

Module = 'A1'  /* module house and device code */
TimeOn = '11:29:00'  /* time in HH:MM:SS to turn A1 on */
TimeOff = '11:29:30'  /* time in HH:MM:SS to turn A1 off */

Waitflag = 0  /* Waitflag = 0 wait for ON time, Waitflag = 1 wait for OFF 
time */

SAY ' ' 
SAY "Waiting to turn " || Module || " on at " || TimeOn 
SAY "Press CTRL-Break to Exit..."

DO FOREVER 

   call SysSleep(1)    /* wait one second */
   CurrentTime = TIME()
   IF CurrentTime = TimeOn & Waitflag = 0 THEN 
    DO
     temp = '}ID1 ' || Module || " ON 0"  /* turn on module */
     rc = CLWritePipe(temp)  /* write data to pipe */
     Loop = 0 
     DO WHILE Loop < 5  /* wait for confirmation */
      call SysSleep(1)    /* wait one second */
      rc = CLPeekPipe('0')  /* peek into pipe */
      PARSE VALUE rc WITH rcPeekNPipe ' ' BytesWait ' ' PipeState 
      IF BytesWait > 0 THEN  /* pipe has data */
       DO
        rc = CLReadPipe('0')  /* read pipe */
        IF POS('{0  }ID1', rc) > 0 THEN  /* no error */
         DO

          SAY rc || Module || ' turned on. Waiting to turn off at ' || 
TimeOff || ' ...'

          Loop = 10 
          Waitflag = 1  /* set flag to wait for turn-off */
         END
        ELSE  /* Comm Engine reports errors */
         DO
          SAY 'Direct command ERROR: ' || rc 
          Signal ExitError 
         END
       END
      Loop = Loop + 1 
     END  /* While Loop */
    END /* IF CurrentTime = TimeOn */

   IF CurrentTime = TimeOff & Waitflag = 1 THEN 
    DO
     temp = '}ID1 ' || Module || " OFF 0"  /* turn off module */
     rc = CLWritePipe(temp)  /* write data to pipe */
     Loop = 0 
     DO WHILE Loop < 5  /* wait for confirmation */
      call SysSleep(1)    /* wait one second */
      rc = CLPeekPipe('0')  /* peek into pipe */
      PARSE VALUE rc WITH rcPeekNPipe ' ' BytesWait ' ' PipeState 
      IF BytesWait > 0 THEN  /* pipe has data */
       DO
        rc = CLReadPipe('0')  /* read pipe */
        IF POS('{0  }ID1', rc) > 0 THEN  /* no error */
         DO
          SAY rc || "Waiting to turn " || Module || " on at " || TimeOn 
          SAY "Press CTRL-Break to Exit..."
          Loop = 10  /* exit the while loop */
          Waitflag = 0  /* set flag to wait for turn-on */
         END
        ELSE  /* Comm Engine reports errors */
         DO
          SAY 'Direct command ERROR: ' || rc 
          Signal ExitError 
         END
       END
      Loop = Loop + 1 
     END  /* While Loop */
    END /* IF CurrentTime = TimeOff */

END 

ExitError:
rc = CLClosePipe('0')

ExitError1:
call X10LDropFuncs 

EXIT 

 


=| Menu Description |=

Describes all menu items available for this program.  


  =| FILE - Show Commands |=

 

This selection toggles the Show Commands on and off. If this menu selection 
is checked, every command sent and received from the Comm Engine will be 
displayed on the main window. Only the last 20 commands will be kept in the 
window. If this menu selection is unchecked, no commands will be displayed 
except when the Comm Engine is first started it will display that the pipe 
has been created. By default, the Show Commands is turned off (unchecked).  


  =| FILE - Configuration |=

 

Brings up the Comm Engine configuration window. 

From that window, you can select the Com Port where the CP290 is connected 
to. If the Auto Connect check box is checked, the Comm Engine will 
automatically connect to the CP290 whenever it is started. By default, Auto 
Connect is off. You can use the command line option to override this 
setting. 

Note:  Communications parameters are fixed for the CP290 at 600 Baud, 8 
data bits, 1 stop bit and no parity.  

If the Minimize on Open check box is checked, the Comm Engine will be 
minimized on start-up. You can go to the windows list (press CTRL-ESC) to 
show a minimized Comm Engine. By default, Minimize on Open is checked. 

Data Logging can be enabled by checking the Auto Event Log box. The Log 
Rate is set to one second by default and sets how often the Comm Engine 
checks for data from the CP290 interface. Log File Size sets the maximum 
log file (HOUSE290.LOG) size in kiloBytes. If the file size exceeds this 
limit, the existing log is copied to the file HOUSE290.000 and a new log is 
started. Any existing HOUSE290.000 file will be overwritten. Note that the 
log only records the switch activations originating from the CP290 itself. 
Other X-10 events are not reported by the CP290. 

Data Logging must be enabled in order for the Event Actions to work. See 
FILE - Event Actions for details.  

The Save button saves all the settings in the CP290CE.INI file and closes 
the window. 

Cancel will abort any changes and close the window. Closing the 
configuration window from the system menu is equivalent to canceling 
changes.  


  =| FILE - Event Actions |=

 

This menu selections allows to schedule up to four programs to be launched 
whenever the Comm Engine senses defined X-10 events.  

IMPORTANT: The X-10 events must be originating from the CP290, either by 
pressing any of the toggle switches on the CP290 or from a timed event 
inside the CP290. The event actions are therefore limited to the same house 
code as the base house code set in the CP290. External X-10 events like 
events from a keychain remote, are NOT sensed by the CP290. That is a 
limitation of the CP290, not HOUSE/290.  

Each of the four event actions can be selected by paging through them using 
the Previous or Next buttons. Each action can be Enabled and you can define 
a house, device and function code which will trigger the action. An action 
can be selected by either typing a program name into the text box or by 
using the Browse button to point to the program. Any executable program may 
be selected. No check for a valid executable file (*.CMD, *.EXE, *.COM, 
*.BAT) is made, only the existence of the file is checked. The command used 
to start the action is simply START. You may precede any start options 
ahead of the program name by simply typing them in. For example, a REXX CMD 
script may be started with the option /C such that the session closes as 
the REXX program has finished. You would enter /C MYREXX.CMD in the text 
field. To start a REXX program minimized you would enter /MIN /C 
MYREXX.CMD. A presentation program is started with the /PM option. The /MIN 
option will not work with PM applications. Remember to keep each option 
separated by spaces. To find more information on the START command, simply 
type HELP START at an OS/2 command prompt.  

If a program requires to be started with optional parameters after the 
program name, then use a REXX CMD file to start it. See the DIAL.CMD 
example below for details.  

The defined action is executed when the following criteria is met: 

  - Logging is enabled. See FILE - Configuration for details.
  - An X-10 event exactly as defined is detected by the Comm Engine.
  - The defined program exists.
 

The Test button can be used to test launch the displayed program. A prompt 
will ask for confirmation. 

The Close button will close the Event Action window and any changes made to 
the settings are automatically saved.  

Here is an example how you can apply the Event Action feature. 

Some newer computers now have a single button internet access. You can do 
that with OS/2 also. Define one of the event actions to start-up a dialer, 
start-up your e-mail program when a connection is made and fetch the mail 
and when done, disconnect from the internet, all from just pressing one 
button on the CP290 or executing a timed event inside the CP290.  

So how is this done? Not all dialers and e-mail clients can be setup for 
this, but I found that Injoy Dialer and PMMail/2 easily provides this. Both 
programs are available at BMT Micro. Inside Injoy, under Misc Options, add 
PMMail/2 to the autostart list and start it at Host Connect. This will 
start PMMail/2 as soon as Injoy is connected to the host. Under Host - 
Change - OK, setup Injoy to timeout in 30 seconds and set the timer to 5 
minutes just in case the timeout setting does not kick in. These settings 
are used to disconnect Injoy from the internet after the mail has been 
fetched. Setup PMMail/2 to Fetch Mail upon start-up. This setting is under 
Account - Account Settings and the Preferences tab. Whenever Injoy starts 
up PMMail/2, it will fetch the e-mail and the dialer will disconnect after 
all mail is downloaded. 

Now setup one Event Action to startup Injoy whenever  for example A1 ON is 
pressed on the CP290. You will have to startup Injoy through a small REXX 
script included with this distribution (DIAL.CMD). Make sure DIAL.CMD is 
called out in the Event Action window as follows: /C D:\HOUSE290\DIAL.CMD 
You may have to edit the path to DIAL.CMD and the path and default host of 
Injoy inside DIAL.CMD on your system.  

That's it. You now can press a single button to fetch your e-mail. No more 
hunting for icons on your desktop. Useful? You decide. It shows what can be 
done with REXX-enablement. Now let your imagination run wild.  


  =| FILE - Exit |=

 

Exits the Comm Engine.  If it was online to the CP290 interface, the 
connection is terminated and the pipe to the client program is flushed and 
closed.  


  =| INTERFACE - Connect |=

 

Opens selected com port to communicate to the CP290 interface. A check mark 
on this menu item will indicate connection status. 

The Comm Engine can be connected to the CP290 through the built-in pipe. 
HOUSE/290 does that with the Connect CP290 menu command. See the section on 
Comm Engine Function Description for information on how to control the 
CP290 interface using your own program.  


  =| INTERFACE - Disconnect |=

 

Closes selected com port to disconnect from the CP290 interface. A check 
mark on this menu item will indicate connection status. 

The Comm Engine can be disconnected from the CP290 through the built-in 
pipe. HOUSE/290 does that with the Disconnect CP290 menu command. See the 
section on Comm Engine Function Description for information on how to 
control the CP290 interface using your own program.  


  =| HELP - Help Contents |=

 

Displays the help contents (but uses the OS/2 index feature). Note that 
help is organized in sections and Help Contents brings up the section 
headings in alphabetical order. I find this a more logical way to organize 
help even if it goes against common OS/2 convention.  


  =| HELP - Product Information |=

 

Product information.  


=| Comm Engine Function Description |=

This section describes all functions available in CP290CE.EXE and how to 
use them. It is only intended for people who want to write their own client 
program to interface to the Comm Engine.  

The Comm Engine acts as a server between the CP290 and H2MAIN.EXE or any 
other client program. It handles CP290 house, device and function code 
translation by accepting commands like A1 ON and translating them to the 
required hex code for the CP290 to understand. These functions and their 
code format are described in the Programmer's manual of the CP290.  

Before the Comm Engine functions can be used within your own REXX program, 
you must load X10LDLL.DLL and setup a pipe. See the section on X10LDLL 
Function Description for information on that subject. 

The command format for the Comm Engine is as follows:  

Note: Curly brackets are used to separate out the various error flags, 
commands and data. This helps in parsing the data and also indicates which 
way the commands are flowing. Opening brackets indicate that the commands 
flow from the Comm Engine to the client and closing brackets indicates the 
flow from the client to the Comm Engine. 

Sending command to the Comm Engine: 

   }command options 

The closing curly bracket indicates that the following command is sent from 
the client to the Comm Engine. The command instructs the Comm Engine what 
operation is to be performed on the Comm Engine itself or on the CP290. 
Sample commands are ID0, CONNECT, MINIMIZE etc. 

The options contain data to set the CP290 or the Comm Engine. Sample 
options are the actual base house code when setting the CP290 house code or 
timer information like 128 NORM UMTWHFS 14:02 A 1&2&3&4&16 ON 0 when 
programming the CP290 timers.  

Receiving command from the Comm Engine: 

   {XX }command {Y {data

Commands sent out to the client by the Comm Engine are a reply to a command 
received by the Comm Engine. The original command is returned with the 
reply in most cases. Because all commands placed on the pipe will be 
buffered, and can therefore be queued to be processed later, it allows for 
easier command identification. 

The XX indicates any possible errors the previous command encountered. For 
example, a zero indicates no error, a one indicates an unsupported command. 
The error field is always padded to two digits and the next closing curly 
bracket is always at position five. 

The command following the closing curly bracket is the original command 
that requested this reply. 

The value of Y may either be zero or one and represents the CP290 status 
bit value of the ACK MESSAGE. From the Programmers Manual it states: The 
STATUS bit is reset to 0 during power up of the Interface and is set to 1 
by download of data from the computer (any commands like ID0, ID1, ID2 or 
ID3). The STATUS bit is used to warn the computer that the interface has 
been powered down. 

For more details on the command structure and samples, see each individual 
command as listed below.  

   ID0 - Set Base House Code 

   ID1 - Direct command (instant on /off)

   ID2 - Set Interface Clock 

   ID3 - Event/graphics upload to interface 

   ID4 - Request Clock and Base House Code 

   ID5 - Request Timer Events 

   ID7 - Diagnostics 

   ID8 - Clear All Timers 


   Comm Engine STATUS 

   Comm Engine SETPORTCOMx 

   Comm Engine CONNECT 

   Comm Engine DISCONNECT 

   Comm Engine CLOSE 

   Comm Engine SHOW 

   Comm Engine MINIMIZE 

 


  =| ID0 - Set Base House Code |=

 

This function sets the base house code of the CP290 and it is used to 
define the house code of the 8 buttons on the interface. The command format 
is as follows: 

   }ID0 HouseCode 
 

HouseCode is any one of the sixteen valid X-10 house codes: A, B, C, D, E, 
F, G, H, I, J, K, L, M, N, O or P.  

The Comm Engine will return the following data:  

   {XX }ID0 {Y

Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.
  XX = 5 command can't be executed because engine is offline.
  XX = 8 invalid data (house code).
  XX = 11 if the CP290 is not responding.

  Y = 0 if the status of the CP290 indicates no data.
  Y = 1 if the status of the CP290 indicates that it has been programmed.

Example: Set base house code to A. 

Command:
    rc = CLWritePipe( '}ID0 A' ) 

Reply:
    {0  }ID0 {1
 


  =| ID1 - Direct command (instant on/off) |=

 

This function controls the modules through the CP290 interface. Note: The 
base house code set in the CP290 does not limit the control of modules set 
to that particular house code. You can send out a C4 ON to turn module C4 
on even though the base house code is set to A. The command format is as 
follows: 

   }ID1 data 
 

data must be of the following format: HouseDeviceCode X10Command DimPercent 
The HouseDeviceCode is any valid X-10 address like A1 or B16. X10Command 
can be ON, OFF or DIM. The DimPercent is an integer between 0 and 100. Do 
not include a percent character. DimPercent is ignored if the module does 
not support dimming. Each of the three variables are separated by a space 
from each other.  

The Comm Engine will return the following data:  

   {XX }ID1 {Y

Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.
  XX = 5 command can't be executed because engine is offline.
  XX = 8 invalid data (house, device, function code or level).
  XX = 11 if the CP290 is not responding.

  Y = 0 if the status of the CP290 indicates no data.
  Y = 1 if the status of the CP290 indicates that it has been programmed.

Example: Turn on appliance module A1. 

Command:
    rc = CLWritePipe( '}ID1 A1 ON 0' ) 

Reply:
    {0  }ID1 {1
 


  =| ID2 - Set Interface Clock |=

 

This function sets the clock of the CP290 according to what the system time 
is set to. The command format is as follows: 

   }ID2
 

No data needs to be supplied with the command.  

The Comm Engine will return the following:  

   {XX }ID2 {Y

Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.
  XX = 5 command can't be executed because engine is offline.
  XX = 11 if the CP290 is not responding.

  Y = 0 if the status of the CP290 indicates no data.
  Y = 1 if the status of the CP290 indicates that it has been programmed.

Example: Set CP290 time to system time. 

Command:
    rc = CLWritePipe( '}ID2' ) 

Reply:
    {0  }ID2 {1
  


  =| ID3 - Event/graphics upload to interface |=

This function programs one of the 128 possible timers into the CP290. Each 
timer can be programmed individually. The graphics upload is not supported 
at this time. The command format is as follows:  

   }ID3 timer mode weekdays time housecode devicecodes function level 
 

The data required to program a timer is as follows: 

  timer = 1 through 128 (the timer number).

  mode = timer mode. Possible values are: NORM = Normal, SEC = Security,
      TOD = Today, TOM = Tomorrow, CLR = Cleared.
      Normal operation sets the timer to work on a weekly cycle 
      at the time and weekdays indicated.
      Security is the same as normal, except that the event time will be 

      different each day and varies in a pseudo random pattern up to one 
hour 

      after the time specified.
      Today setting will operate the timer only today and clear the event 
      from memory at midnight.

      Tomorrow setting will operate the timer only tomorrow and clear the 
event 

      from memory tomorrow at midnight.

      Cleared setting removes that particular timer from the interface 
memory.

  weekdays = the weekdays the timer will operate in the format UMTWHFS 
        where U = SUnday, M = Monday, T = Tuesday, W = Wednesday,
        H = THursday, F = Friday, S = Saturday. Day not used are left out,
        i.e. operating on weekdays only would be MTWHF.

  time = hour and minute when timer will operate. Format is HH:MM
      where HH = hours in 24hr format and MM = minutes.

  housecode = any valid X-10 house code from A - P for which the timer 
        will operate.

  devicecode = any valid X-10 device code from 1 - 16 for which the timer 
         will operate. Several device codes may be sent separated 
         by the ampersand, i.e. 1&2&16

  function = module function to perform at given time.
        Possible values are: ON, OFF and DIM.

  level = the dim percentage the module is set to at the given time.
      Values are 0 to 100. Do not include the percent symbol.

 

The Comm Engine will return the following data:  

   {XX }ID3 timer {Y

Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.
  XX = 5 command can't be executed because engine is offline.

  XX = 8 invalid data (timer number, house, device, function code or 
level).

  XX = 11 if the CP290 is not responding.
  XX = 18 shareware limit of first 30 timers exceeded. CP290 timer limit 
        of 128 timers exceeded if registered version.

  timer = 1 through 128 (the timer number).

  Y = 0 if the status of the CP290 indicates no data.
  Y = 1 if the status of the CP290 indicates that it has been programmed.

  Note: Y is only present if XX = 0.
 

Example: Program timer 4 into the CP290. Timer has to turn off C1 at 
11:30pm every weekday. 

Command:
    rc = CLWritePipe( '}ID3 4 NORM MTWHF 23:30 C 1 OFF 0' ) 

Reply:
    {0  }ID3 4 {1

 


  =| ID4 - Request Clock and Base House Code |=

 

This function requests the clock and base house code settings of the CP290. 
The command format is as follows: 

   }ID4
 

No data needs to be supplied with the command.  

The Comm Engine will return the following:  

   {XX }ID4 {Y 22:58 FRI A 

Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.
  XX = 5 command can't be executed because engine is offline.
  XX = 11 if the CP290 is not responding.

  Y = 0 if the status of the CP290 indicates no data.
  Y = 1 if the status of the CP290 indicates that it has been programmed.

Time, weekday and base house code is attached to the end of this command.

Example: Request CP290 time and base house code. 

Command:
    rc = CLWritePipe( '}ID4' ) 

Reply:
    {0  }ID4 {1 23:58 FRI A 

CP290 time is 23:58 (11:58pm), the weekday is 
set to Friday and the base house code is A.
  


  =| ID5 - Request Timer Events |=

This function reads all 128 timer data from the CP290 at once. Only timer 
data that is valid is returned. Cleared or unrecognized timers are not 
returned. The command format is as follows:  

   }ID5
 

No data needs to be supplied with the command.  

The Comm Engine will return the following data:  

   {XX }ID5 {timer mode weekdays time housecode devicecodes function level 


Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.
  XX = 5 command can't be executed because engine is offline.
  XX = 11 if the CP290 is not responding.
  XX = 19 Comm Engine is reading data from CP290. Each increment 
        corresponds to 100 bytes read and is used to show progress.
  XX = 20 command is still executing, more data to come.

  timer = 1 through 128 (the timer number).

  mode = timer mode. Possible values are: NORM = Normal, SEC = Security,
      TOD = Today, TOM = Tomorrow.
      Normal operation indicates that the timer works on a weekly cycle 
      at the time and weekdays indicated.
      Security is the same as normal, except that the event time will be 

      different each day and varies in a pseudo random pattern up to one 
hour 

      after the time specified.
      Today setting will operate the timer only today and clear the event 
      from memory at midnight.

      Tomorrow setting will operate the timer only tomorrow and clear the 
event 

      from memory tomorrow at midnight.

      Timer data that can not be identified or timers that are cleared, are 
not 

      returned. You can assume that that particular timer is available.

  weekdays = the weekdays the timer will operate in the format UMTWHFS 
        where U = SUnday, M = Monday, T = Tuesday, W = Wednesday,
        H = THursday, F = Friday, S = Saturday. Day not used are left out,
        i.e. operating on weekdays only would be MTWHF.

  time = hour and minute when timer will operate. Format is HH:MM
      where HH = hours in 24hr format and MM = minutes.

  housecode = any valid X-10 house code from A - P for which the timer 
        will operate. Only one house code will be returned.

  devicecode = any valid X-10 device code from 1 - 16 for which the timer 
         will operate. Several device codes may be returned separated 
         by the ampersand, i.e. 1&2&16

  function = module function to perform at given time.
        Possible values are: ON, OFF and DIM.

  level = the dim percentage the module is set to at the given time.
      Values are 0 to 100. Does not include the percent symbol.

 

Example: Request all CP290 timers. 

Command:
    rc = CLWritePipe( '}ID5' ) 

Reply:
    {19 }ID5 {1
    {19 }ID5 {2
    {20 }ID5 {1 NORM UMTWHFS 18:20 A 1&2&3&4&16 ON 0 
    {20 }ID5 {2 NORM UMTWHFS 23:02 A 1&2&3&4&16 OFF 0 
    {20 }ID5 {3 NORM UMTWHFS 18:00 C 1 DIM 80 
    {20 }ID5 {4 NORM UMTWHFS 23:30 C 1 OFF 0 
    ...
    {20 }ID5 {101 NORM MTWHF 23:30 C 2 OFF 0 
    {0  }ID5

Each timer is read sequentially from 1 to 128 and the data is 
returned for each valid timer. Because of the slow communications 
speed and the large amount of data that needs to be read from 
the CP290, this process takes a while to complete. The 
{19 }ID5 {1 data is an indication of the reading process. Each 
increment indicates 100 bytes read from the CP290. Ensure that 
your program reads the pipe during this operation or it may 
eventually over-run and data is lost. Invalid or cleared timers 
are not returned. In the above reply, one can assume that timers 
102 through 128 are available for programming. The command 
{0  }ID5 indicates completion of reading timers.

 


  =| ID7 - Diagnostics |=

 

This function performs a diagnostic internal to the CP290 and takes 12 
seconds to complete. During diagnostics, the CP290 will be unavailable but 
the Comm Engine will queue any other functions. Diagnostics will destroy 
all timer data programmed in the interface. The command format is as 
follows: 

   }ID7
 

No data needs to be supplied with the command.  

The Comm Engine will return the following data:  

   {XX }ID7 {diagstatus

Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.
  XX = 5 command can't be executed because engine is offline.
  XX = 11 if the CP290 is not responding.

  diagstatus = PASSED if the diagnostics passed.
         FAILED if the diagnostics failed.
         ERROR if the CP290 did not respond.

Example: Perform CP290 diagnostics. 

Command:
    rc = CLWritePipe( '}ID7' ) 

Reply (after 12 seconds):
    {0  }ID7 {PASSED
 


  =| ID8 - Clear All Timers |=

This function clears all 128 timers in the CP290. The command format is as 
follows: 

   }ID8
 

No data needs to be supplied with the command.  

The Comm Engine will return the following data:  

   {XX }ID8 {timer CLR 

Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.
  XX = 5 command can't be executed because engine is offline.
  XX = 11 if the CP290 is not responding.
  XX = 20 command is still executing, more data to come.

  timer = 1 through 128 (the number of timer just cleared).

Example: Clear all CP290 timers. 

Command:
    rc = CLWritePipe( '}ID8' ) 

Reply:
    {20 }ID8 {1 CLR 
    {20 }ID8 {2 CLR 
    ...
    {20 }ID8 {128 CLR 
    {0  }ID8

Because clearing all timers takes more than one minute,
this function returns the timer number it just cleared. This can 
be used for a progress indicator. Ensure that your program 
reads the pipe during this operation or it may eventually 
over-run and data is lost.

       


  =| Comm Engine STATUS |=

 

This function requests the Comm Engine online status and com port setting. 
The command format is as follows: 

   }STATUS
 

No data needs to be supplied with the command.  

The Comm Engine will return the following data:  

   {XX }status portname 

Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.

  status = ONLINE if online; OFFLINE if offline.

  portname = COMx where x = 1 through 8 

Example: Get status of Comm Engine. 

Command:
    rc = CLWritePipe( '}STATUS' ) 

Reply:
    {0  }ONLINE COM2 
 


  =| Comm Engine SETPORTCOMx |=

 

This function instructs the Comm Engine to change com port. The Comm Engine 
must be offline for the change to be successful. The command format is as 
follows: 

   }SETPORTCOMx
 

where x is the integer 1 through 8.  

The Comm Engine will return the following data:  

   {XX }command

Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.
  XX = 6 Comm Engine online, cannot change com port.
  XX = 7 invalid com port.

  command = SETPORTCOMx (original command as sent out).

Example: Set com port of Comm Engine to COM5. 

Command:
    rc = CLWritePipe( '}SETPORTCOM5' ) 

Reply:
    {0  }SETPORTCOM5
 


  =| Comm Engine CONNECT |=

 

This function instructs the Comm Engine to connect to the com port. The 
command format is as follows: 

   }CONNECT
 

No data needs to be supplied with the command.  

The Comm Engine will return the following data:  

   {XX }command

Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.
  XX = 2 connect error. RC will be returned in command.

  command = CONNECT (original command as sent out)
       or RC if there was an error.

Example: Connect Com Engine to CP290. 

Command:
    rc = CLWritePipe( '}CONNECT' ) 

Reply:
    {0  }CONNECT
 


  =| Comm Engine DISCONNECT |=

 

This function instructs the Comm Engine to disconnect from the com port. 
The command format is as follows: 

   }DISCONNECT
 

No data needs to be supplied with the command.  

The Comm Engine will return the following data:  

   {XX }command

Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.
  XX = 3 disconnect error. RC will be returned in command.

  command = DISCONNECT (original command as sent out)
              or RC if there was an error.

Example: Disconnect Com Engine from CP290. 

Command:
    rc = CLWritePipe( '}DISCONNECT' ) 

Reply:
    {0  }DISCONNECT
 


  =| Comm Engine CLOSE |=

 

This function closes and terminates the Comm Engine. Connection to the 
CP290 will be closed automatically and the pipe is flushed and closed as 
well. The command format is as follows: 

   }CLOSE
 

No data needs to be supplied with the command.  

The Comm Engine will not return any data.  

Example: Terminate Comm Engine. 

Command:
    rc = CLWritePipe( '}CLOSE' ) 
 


  =| Comm Engine SHOW |=

 

This function restores the Comm Engine from a minimized state. The command 
format is as follows: 

   }SHOW
 

No data needs to be supplied with the command.  

The Comm Engine will return the following data:  

   {XX }command

Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.

  command = SHOW 

 


  =| Comm Engine MINIMIZE |=

 

This function minimizes the Comm Engine. The command format is as follows: 

   }MINIMIZE
 

No data needs to be supplied with the command.  

The Comm Engine will return the following data:  

   {XX }command

Where:

  XX = 0 if there was no error.
  XX = 1 unsupported or illegal command.

  command = MINIMIZE 

 


=| X10LDLL Function Description |=

Describes all functions available in X10LDLL.DLL and how to use them. 

Note: This DLL is used to setup a named pipe to communicate with the Comm 
Engine. The functions listed in this section need to be used only if you 
want to write your own REXX client program to control the Comm Engine. See 
the section on Comm Engine Function Description for information on how to 
control the CP290 interface once the pipe is setup. 

Description of pipe operation. 

The Comm Engine uses a named pipe for interprocess communications. This 
pipe allows two programs to exchange data between each other. These two 
programs may be on the same computer or they may be on different computers 
connected through a LAN or peer-to-peer network. 

To establish connection, the Comm Engine will first create a pipe with the 
fixed name \PIPE\HOUSE290 and place it into a listening mode. The client 
program (H290MAIN.EXE or any other custom program) will then have to open 
the same pipe and peek to check if it connected. From that point on, data 
can be placed on the pipe by either program. All commands are buffered in 
the pipe and the client program must check the pipe for available data and 
read it to prevent buffer overrun and data loss. The buffer size is 4096 
bytes in size and if full will not accept any additional data. Currently no 
error is reported if the buffer is full. 

If two programs are communicating through a pipe, they have exclusive 
access to the pipe. A third program can not connect to the same pipe. To 
free up the pipe, the client program must close the pipe so the Comm Engine 
can make it available to other programs. If a pipe is closed, all data in 
the buffer is flushed. 

For more details on pipe operation and communication to the Comm Engine, 
see the included sample REXX programs.  


   X10LLoadFuncs

   X10LDropFuncs

   CLReadPipe

   CLWritePipe

   CLPeekPipe

   CLOpenPipe

   CLClosePipe
 


  =| X10LLoadFuncs |=

 

This function loads X10LDLL.DLL to be used within your REXX program. A REXX 
program using X10LDLL must contain the following two lines to access other 
functions inside X10LDLL: 

   CALL RXFuncAdd 'X10LLoadFuncs', 'X10LDLL', 'X10LLoadFuncs'
   CALL X10LLoadFuncs 
 

Standard REXX errors are returned for this function, for example: Error 43 
- Routine not found if X10LDLL.DLL can't be found. X10LDLL.DLL must be in 
the current directory or in a directory where the LIBPATH statement points 
to.  


  =| X10LDropFuncs |=

 

This function unloads X10LDLL.DLL from memory. A REXX program using X10LDLL 
must contain the following line to unload X10LDLL: 

   CALL X10LDropFuncs 
 


  =| CLReadPipe |=

 

This function reads the contents of the pipe, one entry at a time. The pipe 
must be open before it can be read. CLPipeRead will first do a DOSPeekNPipe 
call and then read the pipe if the character count is not zero. CLPeekPipe 
should be used to check if any data is available before a CLReadPipe 
command. See CLOpenPipe and CLPeekPipe for details. 

The command is as follows: 

   rc = CLReadPipe( '0' ) 
 

The return value rc is made up of the following information: 

  piperr charcount replypacket 

Piperr is any possible error the read pipe command may have caused. If the 
character count is zero, the piperr returns the value of DOSPeekNPipe. If 
the character count is not zero, piperr returns whatever the DosRead 
returns which can be the following values:  


  0    NO_ERROR
  5    ERROR_ACCESS_DENIED
  6    ERROR_INVALID_HANDLE
  26    ERROR_NOT_DOS_DISK
  33    ERROR_LOCK_VIOLATION
  109   ERROR_BROKEN_PIPE
  234   ERROR_MORE_DATA

 

charcount is the character count of the data just read from the pipe. 

replypacket is the reply the Comm Engine returns in response to one of the 
commands as listed under Comm Engine Function Description.  

Example read from pipe. 

Command:
    rc = CLReadPipe( '0' ) 

Contents of rc:
    0 12 {0  }CONNECT

There were 12 characters read from the pipe which corresponds 
to the data displayed from the opening curly bracket to the T in 
CONNECT. (There are two spaces between the brackets).
 


  =| CLWritePipe |=

 

This function writes to the pipe. The pipe must be open before it can be 
written to. 

The command is as follows: 

   rc = CLWritePipe( command ) 

 Command contains any of the valid Comm Engine commands as listed under 
Comm Engine Function Description.  

The return value rc is the same as what DOSWrite returns and can be the 
following values:  


  0     NO_ERROR
  5     ERROR_ACCESS_DENIED
  6     ERROR_INVALID_HANDLE
  19    ERROR_WRITE_PROTECT
  26    ERROR_NOT_DOS_DISK
  29    ERROR_WRITE_FAULT
  33    ERROR_LOCK_VIOLATION
  109    ERROR_BROKEN_PIPE

 

Example write to pipe. 

Command:
    rc = CLWritePipe( '}ID1 A1 DIM 50' ) 

Contents of rc:
    0

This example instructs the Comm Engine to command the 
CP290 to dim module A1 to 50% using the direct command.
 


  =| CLPeekPipe |=

 

This function checks if any data is available on the pipe to read. Use this 
function before a CLReadPipe command. 

The command is as follows: 

   rc = CLPeekPipe( '0' ) 
 

The return value rc is made up of the following information: 

  piperr charcount pipestate 

Piperr is any possible error the DOSPeekNPipe command may have caused. 
DosPeekNPipe returns the following values:  


  0     NO_ERROR
  230    ERROR_BAD_PIPE
  231    ERROR_PIPE_BUSY
  233    ERROR_PIPE_NOT_CONNECTED

 

charcount is the number of characters available to read from the pipe.  

pipestate is the state the pipe is currently at. Possible values are:  


    1 =  the pipe is disconnected.
    2 =  the pipe is listening for a connection.
    3 =  the pipe is connected.
    4 =  the pipe is closing.

 

Example peek pipe. 

Command:
    rc = CLPeekPipe( '0' ) 

Contents of rc:
    0 12 3 

There are 12 characters available to read 
from the pipe and the pipe is connected.
 


  =| CLOpenPipe |=

 

This function opens the pipe to the Comm Engine.  

The command is as follows if the Comm Engine and the client are running on 
the same computer: 

   pipename = '\PIPE\HOUSE290'
   rc = CLOpenPipe( pipename ) 

For network operation, the pipe name must include the computer name where 
the Comm Engine is running at. In this example, the computer name is 
CLIENT290 and it must be preceded by two back slashes. 

   pipename = '\\CLIENT290\PIPE\HOUSE290'
   rc = CLOpenPipe( pipename ) 
 

This function returns the same values as the API call DosOpen. The values 
of most interest are: 


    0    NO_ERROR
    2    ERROR_FILE_NOT_FOUND
    3    ERROR_PATH_NOT_FOUND
    4    ERROR_TOO_MANY_OPEN_FILES
    5    ERROR_ACCESS_DENIED
    12    ERROR_INVALID_ACCESS
    231   ERROR_PIPE_BUSY

See the example CMD files included for details on how to run a pipe to the 
Comm Engine.  


  =| CLClosePipe |=

 

This function closes the pipe to the Comm Engine.  

The command format is as follows: 

   rc = CLClosePipe( '0' ) 
 

This function returns the same values as the API call DosClose. The values 
of most interest are: 


  0     NO_ERROR
  2     ERROR_FILE_NOT_FOUND
  5     ERROR_ACCESS_DENIED
  6     ERROR_INVALID_HANDLE

See the example CMD files included for details on how to run a pipe to the 
Comm Engine.  


=| Command Line Options |=

 

The following command line options are recognized by CP290CE.EXE: 

  /ComX  Connects to the Com port as specified by X. X ranges from 1 
through 8.

  /Min   Minimizes Comm Engine on start-up.
 

If /ComX is specified, the Comm Engine will over-ride the existing com port 
setting and open the specified port to establish a connection to the CP290.  

To enter the startup options do the following:   

  For Warp 3.0:  Right-click on the CP290CE icon and select Settings. 
Under the Program tab in Optional Parameters enter the startup option.   

  For Warp 4.0:  Right-click on the CP290CE icon and select Properties. 
Under the Program tab in Optional Parameters enter the startup option. 

 

Note: These settings can also be changed from the client program 
H290MAIN.EXE and through the pipe commands.  


=| Troubleshooting |=

 

CP290 Interface Connection Problems. 

If you are having problems connecting to the CP290 interface then follow 
these steps below. 

  

  Make sure the com port setting in the configuration matches the com port 
you use for the interface.   

  Make sure you have all the included files present in your HOUSE290 
directory.   

  If you have Ray Gwinn's SIO com drivers, use the included PMLM (Poor 
Man's Line Monitor) to monitor data exchange between the Comm Engine and 
CP290. Use HOUSE/290 to send out a request to read time for example. The 
CP290 should respond with data. You can observe this data with PMLM and 
that may help in troubleshooting.   

  If you are using Ray Gwinn's SIO com drivers, check if the baud rate is 
locked for the particular com port you are using with the interface. Unlock 
it so the Comm Engine can change the baud rate to 600. From the SIO 
reference, it states:  


   Locked Baud Rate 

   Placing a colon and a baud rate following the communications port, eg 
   (COM1:38400,3F8,IRQ4), causes the port to be locked at that baud rate.
   No program, OS2 or DOS, is allowed to change the baud rate.

  

  Try the standard COM1 or COM2 ports if you have problems with any other 
com ports like COM3 - COM8. Also, remove any serial cable extensions or 
adapters and connect the interface directly to the computer.   

  Try using a different computer or different com port to access the 
CP290.   

  Download my X-10 Comm Tester program from my web page. This program was 
specifically written to help troubleshooting communications problems with 
the CP290 interface.   

  E-mail me and I will try to help you out. (Eventually registering 
HOUSE/290 will give me extra incentive too!).  

 


=| Installation |=

 

Note:  REXX (classic or Object REXX) must be installed on your system for 
this program to work. REXXUTIL.DLL is required. 

HOUSE/290 is distributed as a self-installing executable using PillarSoft's 
SFX Installer. See http://www.pillarsoft.net for more information on that 
product. 

When installing HOUSE/290, simply follow the prompts given. 

Installing this program on your system does not change any of the INI or 
CONFIG.SYS files. 

In rare instances, it may be possible that HOUSE/290 may not find the DLL 
files and abort on start-up. To fix this, simply add the directory where 
you installed HOUSE/290 to the LIBPATH in your CONFIG.SYS. A reboot is 
necessary for the changes to take effect.  

The following files belong to this program:   

 H290.EXE   Splash screen. Starts the executable main program and Comm 
Engine.   

 H290MAIN.EXE   The executable main program, also the client for the Comm 
Engine.   

 CP290CE.EXE   The CP290 Communications Engine, also used as REXX-enabled 
server.   

 CP290CE.HLP   The CP290 Communications Engine help file.   

 HOUSE290.HLP   The main help file.   

 HOUSE290.INI   HOUSE290 configuration file for items like com port, 
battery type and battery installation date. This file will be created the 
first time H290MAIN is run.   

 HOUSE290.SET   Default module and macro set. This file, if present, will 
automatically load whenever HOUSE290 is started up. You can have several of 
these files with the extension SET to keep various module setups. This file 
will be created the first time HOUSE290 is run and you save the module 
setup.   

 SAMPLE.SET   Sample module set to show how HOUSE/290 can be setup.   

 HOUSE290.LOG   A log file that contains all the events as sent by the 
CP290 interface. Events are only logged when the computer is connected to 
the interface and logging is enabled. This is a text file and you can look 
at it with a text editor.   

 TMR290.TXT   Timer image file as last programmed to the CP290 interface. 
This file contains the timer data in text format as last programmed into 
your CP290 interface. This file will be created every time upload is 
successful.   

 VPIBevel.DLL    Bevel object used for modules and macros. Required by 
H290MAIN.EXE only.   

 VPIButtn.DLL    Image button object used for button bar. These two objects 
are part of the VPExtras package. Thanks to Dion Gillard for creating and 
releasing these objects for free! Required by H290MAIN.EXE only.   

 VPOBJ.DLL     Dynamic Link Library required by executables. Required by 
H290MAIN.EXE only.   

 VPUTIL.DLL     Dynamic Link Library required by H290MAIN.EXE only.   

 RXASYNC.DLL   Dynamic Link Library required for serial communications to 
the CP290 interface. This library of serial communications routines is 
included by permission of Crucial Applications (Author: Ian Timms, e-mail: 
itimms@ariel.ucs.unimelb.edu.au). The entire serial communications package, 
including the source code for RXASYNC, is available at my home page or 
other major OS/2 sites by the file name RXASYN20.ZIP. This DLL has been 
packed with LXWARP for smaller size. Required by CP290CE.EXE only.   

 X10CHDLL.DLL     Dynamic Link Library required by H2MAIN.EXE only.   

 X10CPDLL.DLL     Dynamic Link Library required by CP290CE.EXE only.   

 X10LDLL.DLL      Dynamic Link Library required by the sample REXX or 
custom client programs only.   

 H2MODULE.DB     External Module database. Use HOUS2UTL to edit.   

 NORTHA.DAT     Geographical data file for North American locations.   

 EUROPE.DAT     Geographical data file for European locations.   

 OTHER.DAT     Geographical data file for other areas of the world 
locations.   

 REPORT.TXT     Default file name when saving reports to a file.   

 DIAL.CMD     Sample script to startup Injoy dialer through an X-10 event.   

 RSTCP290.CMD     Sample script to restore timers to the CP290. Example to 
show how to access Comm Engine.   

 TIMEMOD.CMD     Sample script that turns a module on and off at a certain 
time. Example to show how to access Comm Engine.   

 MODCTRL.CMD     Sample script that turns on a module. Example to show how 
to access Comm Engine.   

 INSTALL.CMD    Installation program. Creates a HOUSE290 folder on your 
desktop containing all the HOUSE290 objects.   

 UNINSTAL.CMD    Uninstallation program. Removes HOUSE290 completely from 
your system.   

 HISTORY.TXT   History of changes to the program.   

 README.1ST    Program description and installation instructions.   

 BMTORDER.TXT   Order form to register HOUSE/2 or HOUSE/290 through BMT 
Micro.  

 

To remove this program from your system, close the program and execute 
UNINSTAL.CMD from the HOUSE/290 directory. This removes all HOUSE/290 files 
and subdirectory where HOUSE/290 was located in.  


=| Network Operation |=

 

HOUSE/290 uses a named pipe to communicate with the Comm Engine and thus 
allows it to run over a LAN or peer-to-peer network. The requestors on both 
machines must be running for network operation. 

To run HOUSE/290 over a network, do the following: 

Connect the CP290 to one of the peer stations or the server. Install 
HOUSE/290 on that machine and only start-up CP290CE.EXE and configure it 
for the CP290. It is not necessary to have the Comm Engine set to connect, 
this can be controlled over the network with the client program 
H290MAIN.EXE. Install HOUSE/290 on another workstation and only run 
H290MAIN.EXE. Make sure the Auto Load and Auto Unload options are turned 
off. Also, check the windows list to make sure CP290CE.EXE is not loaded 
and minimized on the workstation where you run H290MAIN.EXE. In the 
settings page of H290MAIN.EXE, enter the computer name where the CP290 is 
connected to. Do not use any back slashes when entering the name. Now you 
can connect to the pipe and communicate with the Comm Engine. 

Only one client (H290MAIN.EXE) can communicate with the Comm Engine at any 
one time. If you want to use a third workstation to access the Comm Engine, 
you must disconnect H290MAIN.EXE from the pipe to free up the Comm Engine.  

It is not necessary to map any drives to the client or server machines 
unless HOUSE/290 is executed from the remote machine.  


=| Year 2000 Issues & other Date Problems |=

 

HOUSE/290 version 2.0 is now fully Year 2000 compliant. 

The CP290 interface does not have any Year 2000 problems directly as it 
accepts the date in the form of a weekday only. 

Reprogramming of the interface at the beginning of each year may be 
necessary also if series events are to be executed properly when daylight 
savings time changes over. When HOUSE/290 is started, it checks to see if 
the DST dates are correct. If not, it will ask you if you want to adjust 
them. It will not make adjustments to the preprogrammed series events, you 
have to redo them manually. Depending on the application of HOUSE/290, you 
may be better off to disable DST and always use standard time. Make sure 
the computer is also set to standard time when accessing the interface.  


=| Shareware Limitation |=

 

This shareware program is fully enabled with the exception of the 
following:   

 Registration reminder when exiting.   

 Only timers 1 through 30 (out of 128 possible), can be programmed into 
the CP290.   

 When uploading to the interface, you will be reminded of a possible 
limited number of timer uploads. 

 

The registered version has these limitations removed.  


=| How to Register |=

 

Registration is for life-time, you will NOT be re-charged for any future 
HOUSE/290 versions. Registration also includes the game Leave-One. It's a 
challenging puzzle similar to Pegged. See my website for a screen shot of 
this game.  

If you are a registered user of HOUSE/2 for the CM11A interface, you are 
entitled to a free, registered version of HOUSE/290. Please send me e-mail 
to indicate that you would like the registration key.  

There are two ways you can register HOUSE/290: 

Send e-mail to ASchw@worldnet.att.net to request my mailing address. You 
may then send me a check or money order and I will return the registration 
key. There are two options you can choose from: If you want the HOUSE/290 
program only, the cost is $15.00. If you plan to eventually add the newer 
CM11A to your CP290 controller, you can purchase HOUSE/2 together with 
HOUSE/290 for the price of $30.00 total. Please indicate which option you 
like when requesting mailing address.  

Register through BMT Micro at www.bmtmicro.com. BMT Micro offers a variety 
of purchasing methods, see the file BMTORDER.TXT for details. A 
registration key will be sent to you within usually one day of purchasing 
HOUSE/290. Two options are available: Purchase HOUSE/290 only for $20.00 or 
purchase HOUSE/2 together with HOUSE/290 for $35.00 total. See the BMT 
Micro site for more information.  

Quantity discounts are available. Please e-mail me for details.  

Registration key and instructions on how to enter the key to enable the 
registered features will be given out at registration time.  


=| The Legal Stuff |=

 

HOUSE/290 and Comm Engine for the CP290 are copyright programs by A. 
Schwarz.  

This program is shareware and not free. You may use it for 30 days. After 
that, if you continue using it, you must register to obtain a license. See 
How To Register section on ways to register.  

The shareware version of this program may be distributed electronically as 
long as all files are kept together. The shareware version is recognized by 
the title  Home Automation & Security for OS/2 - Unregistered in the title 
bar of the main program.  

The registered version of HOUSE/290 may not be distributed in any way. Only 
one copy of the registered program (CP290CE.EXE) may be run at one time on 
a computer. In other words, if you have a laptop and a desktop, you may 
copy this program onto both computers but only one instance of the 
CP290CE.EXE program may be run at one time. If there is a possibility that 
two of these programs may be run at the same time, then you must get a 
second license. The client program H290MAIN.EXE only may be run on an 
unlimited number of computers. Contact the author for information on 
quantity discounts.  

Registration gives you many benefits. First of all, it ensures that I will 
continuously update and support this program. Registration will remove all 
restrictions and registration reminders, I will provide prompt technical 
support, implement suggestions to program improvements, enhancements and 
customization (if technically possible but let me add that I can be 
convinced of a lot, but not everything).  

RXASYNC.DLL required for serial communications to the CP290 interface, is a 
library of serial communications routines and is included by permission of 
Crucial Applications (Author: Ian Timms, e-mail: 
itimms@ariel.ucs.unimelb.edu.au). The entire serial communications package, 
including the source code for RXASYNC, is available at my home page or 
other major OS/2 sites by the file name RXASYN20.ZIP  

HOUSE/290 is protected using SecureIt. To get more information on this 
shareware protection program, see http://www.bmtmico.com/catalog/secureit/  

DISCLAIMER 

The author of HOUSE/290 is in no way responsible for any damage this 
program may cause to computer equipment by running this software on it. Use 
HOUSE/290 at your own risk. 

The author of HOUSE/290 also assumes no responsibility of damage to 
property, bodily injury or loss of life as a result of controlling home 
control devices with the HOUSE/290 software.  

For safety reason, I DO NOT recommend to use X-10 devices to control coffee 
pots, space heaters or similar heat-creating appliances.  

Any trademarks mentioned in this document belong to their respective owners 
and the author of HOUSE/290 is not connected in any way to these products 
nor does he endorse any of the products mentioned.  


=| Support |=

 

For HOUSE/2 and HOUSE/290 support, you can contact me directly via e-mail.  

My e-mail address: 

  ASchw@worldnet.att.net 

Visit my home page, "The Warped Code Cellar" at 

  http://home.att.net/~ASchw 

for other information and applications for OS/2 like UPS Monitor for APC 
brand uninterruptible power supplies, Memory Game and Leave One, two 
speech-navigation-enabled games. Also available new is a HOUSE/2 and X-10 
FAQ.  

Monitor my home page regularly for future upgrades of HOUSE/290. This will 
be the place where HOUSE/290 upgrades will be available first.  

This program is also available at the following sites: 

Internet: 

  http://home.att.net/~ASchw 
  http://www.bmtmicro.com 
  http://hobbes.nmsu.edu 
  http://www.os2ss.com  


=| Internet Links for Home Automation |=

 

To get more information on home automation, you can visit any of the sites 
listed here: 

www.x10.com
Homepage of X-10.
This is the manufacturer of X-10 products.

www.x10.com/x10euro.htm
Links to European Representatives of X-10.

www.smarthome.com
Home Automation System, Inc. Vendor carrying large 
selection of home automation devices. Download 
catalog in PDF format, search for part numbers online.

www.hwg-telekom.de
HWG Telekommunikations Systeme GmbH.
X-10 Representative of Germany, Austria and 
Switzerland. The CM11A is available as 
PowerHaus-II in these countries.

www.automationplus.com
Mail order company for home automation devices.

www.asihome.com
Mail order company for home automation devices.

support.tandy.com/support_security/
Radio Shack Support. Follow the X-10 links.
Contains FAQ for home automation devices.

www.hometoys.com
Mailing lists, newsletters, articles and product reviews 
of home automation products and services.

www.homecontrols.com
Large product catalog for home automation devices.
Also carries 220/230V models for international markets.

www.hometeam.com
Information about products and services for home automation.

www.infinet.com/~dhoehnen/ha/list.html
Index of home automation related sites.

www.io.com/~lbs/
Laser Business Systems Ltd. Home Automation dealer in 
the United Kingdom. Lists controllers and modules for many 
other European countries.

 
