(<*--BLOCK_SECTION

[MODBUS_BUS]
[MODBUS_TYPE]
[MODBUS_SERIAL_USE_EXT_INT]
[MODBUS_SERIAL_RX_BUFFER_SIZE]
[MODBUS_SERIAL_RX_PIN]
[MODBUS_SERIAL_TX_PIN]
[MODBUS_SERIAL_ENABLE_PIN]
[MODBUS_SERIAL_RX_ENABLE]
[MODBUS_SERIAL_BAUD]
[MODBUS_OUR_ADDRESS]
[MODBUS_REMOTE_ADDRESS]
[MODBUS_INCLUDE]

[!__main]
  [MODBUS_INIT]
  [MODBUS_SLAVE_EXAMPLE]
  [MODBUS_MASTER_EXAMPLE]
[main__!]
--*>)

(<*--CODE_SECTION

\\$001 contains only SERIAL at the moment
\\This shouldn't even be an option for now
||MODBUS_BUS||
_BEGIN_
#define MODBUS_BUS $001
_END_

\\$001 contains MASTER or SLAVE
||MODBUS_TYPE||
_BEGIN_
#define MODBUS_TYPE $001
_END_

\\*FIXME* Needs RDA2 stuff from Nandini
||MODBUS_SERIAL_USE_EXT_INT||
_BEGIN_
#define MODBUS_SERIAL_USE_EXT_INT TRUE
_END_

\\$001 can be any number technically
\\It's only limited by the amount of RAM
\\on the chip
||MODBUS_SERIAL_RX_BUFFER_SIZE||
_BEGIN_
#define MODBUS_SERIAL_RX_BUFFER_SIZE $001
_END_

\\$001 is a PIN
||MODBUS_SERIAL_RX_PIN||
_BEGIN_
#define MODBUS_SERIAL_RX_PIN $001
_END_

\\$001 is a PIN
||MODBUS_SERIAL_TX_PIN||
_BEGIN_
#define MODBUS_SERIAL_TX_PIN $001
_END_

\\$001 is a PIN
||MODBUS_SERIAL_ENABLE_PIN||
_BEGIN_
#define MODBUS_SERIAL_ENABLE_PIN $001
_END_

\\$001 is a PIN
||MODBUS_SERIAL_RX_ENABLE||
_BEGIN_
#define MODBUS_SERIAL_RX_ENABLE $001
_END_

\\$001 is the Baud Rate
||MODBUS_SERIAL_BAUD||
_BEGIN_
#define MODBUS_SERIAL_BAUD $001
_END_

\\*FIXME* Only print if slave
||MODBUS_OUR_ADDRESS||
_BEGIN_
#define MODBUS_OUR_ADDRESS $001
_END_

\\*FIXME* Only print if master
||MODBUS_REMOTE_ADDRESS||
_BEGIN_
#define MODBUS_REMOTE_ADDRESS $001
_END_

||MODBUS_INCLUDE||
_BEGIN_
#include "modbus.c"
_END_

||MODBUS_INIT||
_BEGIN_
   modbus_init();
_END_

\\Depends on MODBUS_TYPE == SLAVE
||MODBUS_SLAVE_EXAMPLE||
_BEGIN_
   fprintf(SLAVE_PC, "\n\rReady...");

   while(TRUE)
   {
      while(!modbus_serial_receive(FALSE));
      fprintf(SLAVE_PC, "\n\rBus Active");

      if((respond = (modbus_rx.address == MODBUS_OUR_ADDRESS)) || modbus_rx.address == 0)
      {
         fprintf(SLAVE_PC, "\n\rRequest for us");
         fprintf(SLAVE_PC, "\n\rFunction: %X", modbus_rx.func);
         switch(modbus_rx.func)
         {
            case 0x01:
               if(respond)
               {
                  //read the coils
               }
               break;
            case 0x02:
               if(respond)
               {
                  //read discrete inputs
               }
               break;
            case 0x03:
               if(respond)
               {
                  //read holding registers
               }
               break;
            case 0x04:
               if(respond)
               {
                  //read input registers
               }
               break;
            case 0x05:
               break;
            case 0x06:
               break;
            case 0x07:
               break;
            case 0x08:
               if(respond) {diagnostics_rsp(MODBUS_OUR_ADDRESS,
                              make16(modbus_rx.data[0],modbus_rx.data[1]),
                              make16(modbus_rx.data[2], modbus_rx.data[3]));}
               fprintf(SLAVE_PC, "\n\rResetting...");
               reset_cpu();
               break;
         }
      }
   }
_END_

\\Depends on MODBUS_TYPE == MASTER
||MODBUS_MASTER_EXAMPLE||
_BEGIN_
   if(!(diagnostics(MODBUS_REMOTE_ADDRESS, 0x01, 0x00)))
   {
      fprintf(PC, "\n\rAddy: %X",  modbus_rx.address);
      fprintf(PC, "\n\rFunc: %X",  modbus_rx.func);
      fprintf(PC, "\n\rData Length: %u",  modbus_rx.len);
      fprintf(PC, "\n\rData:");
      for(i=0; i < (modbus_rx.len); ++i)
         fprintf(PC, "\n\r%X", modbus_rx.data[i]);
   }
   else
   {
      fprintf(PC, "\n\r<-**Exception %X**->", modbus_rx.error);
   }
_END_


-->