main.cpp

00001 #include "mbed.h"
00002 #define PROTOPLATFORM
00003 //#define MBEDPLATFORM
00004 #include "Protocol/modbus.h"
00005 
00006 //LEDs
00007 #define LED_1 (LED1)
00008 #define LED_2 (LED1)
00009 
00010 //Serial(1) rs232
00011 #define RS232_TX (p13)
00012 #define RS232_RX (p14)
00013 
00014 //Serial(2) rs232/ttl/iphone
00015 #define TTL_TX (p28)
00016 #define TTL_RX (p27) 
00017 #define TTL_GND (p26) 
00018 
00019 //Console
00020 #define CONSOLETX (USBTX)
00021 #define CONSOLERX (USBRX)
00022 
00023 
00024 
00025 
00026 //MODBUS STUFF
00027 #define LOOP             1
00028 #define SLAVE         0x01
00029 #define ADDRESS_START    4096
00030 #define ADDRESS_END      4100
00031 
00032 
00033  int nb = ADDRESS_END - ADDRESS_START;;
00034        
00035         uint8_t tab_rq_status[ADDRESS_END - ADDRESS_START];
00036         uint8_t tab_rp_status[ADDRESS_END - ADDRESS_START];
00037         uint16_t tab_rq_registers[ADDRESS_END - ADDRESS_START];
00038         uint16_t tab_rp_registers[ADDRESS_END - ADDRESS_START];
00039         
00040 DigitalOut myled(LED_1);
00041 Serial console_port(CONSOLETX, CONSOLERX);
00042 
00043 Serial serial(RS232_TX,RS232_RX);
00044 
00045 modbus_param_t mb_param;
00046        uint8_t query[MIN_QUERY_LENGTH];
00047         uint8_t response[MAX_MESSAGE_LENGTH];
00048         
00049 void handleInterrupt() {
00050 
00051      int ret;
00052         int nb_fail;
00053         int nb_loop;
00054         int addr;
00055         
00056         
00057            
00058  printf("**");
00059       
00060         
00061         modbus_receive(&mb_param, query, response);
00062    
00063    //      if (ret > 0) {
00064                 int offset;
00065                 int i;
00066 
00067               //  ret = modbus_receive(mb_param, query, response);
00068         
00069                 offset = mb_param.header_length;
00070 
00071                 // If ret is negative, the loop is jumped ! 
00072                 for (i = 0; i < ret; i++) {
00073                         // shift reg hi_byte to temp OR with lo_byte 
00074                         tab_rq_registers[i] = (response[offset + 3 + (i << 1)] << 8) | 
00075                                 response[offset + 4 + (i << 1)];
00076                                 printf("%d -- %d", tab_rq_registers[i],i);     
00077                 }
00078      //   }
00079    
00080    /*
00081                                         for (int i=0; i<nb; i++) {
00082                                                 if (tab_rq_registers[i] != tab_rp_registers[i]) {
00083                                                         printf("ERROR read_holding_registers\n");
00084                                                         printf("Slave = %d, address = %d, value %d (0x%X) != %d (0x%X)\n",
00085                                                                SLAVE, addr,
00086                                                                tab_rq_registers[i], tab_rq_registers[i],
00087                                                                tab_rp_registers[i], tab_rp_registers[i]);
00088                                                         nb_fail++;
00089                                                 }
00090                                         }
00091     */
00092     
00093 }
00094 
00095 void handleInterrupt2() {
00096 
00097 while(serial.readable()) {
00098          printf("<%.2X>", serial.getc());
00099 }
00100 
00101 }
00102 
00103 void modbus_test() {
00104 
00105 
00106      int ret;
00107         int nb_fail;
00108         int nb_loop;
00109         int addr;
00110 
00111          modbus_init_rtu(&mb_param, "/dev/ttyS0", 19200, "none", 8, 1);
00112 
00113         //modbus_set_debug(&mb_param, TRUE);
00114         if (modbus_connect(&mb_param) == -1) {
00115                 printf("ERROR Connection failed\n");
00116                 exit(1);
00117         }
00118 
00119         nb = ADDRESS_END - ADDRESS_START;
00120 
00121 /*
00122         tab_rq_status = (uint8_t *) malloc(nb * sizeof(uint8_t));
00123         memset(tab_rq_status, 0, nb * sizeof(uint8_t));
00124 
00125         tab_rp_status = (uint8_t *) malloc(nb * sizeof(uint8_t));
00126         memset(tab_rp_status, 0, nb * sizeof(uint8_t));
00127 
00128         tab_rq_registers = (uint16_t *) malloc(nb * sizeof(uint16_t));
00129         memset(tab_rq_registers, 0, nb * sizeof(uint16_t));
00130 
00131         tab_rp_registers = (uint16_t *) malloc(nb * sizeof(uint16_t));
00132         memset(tab_rp_registers, 0, nb * sizeof(uint16_t));
00133 */
00134         serial.attach( handleInterrupt2);
00135 
00136         nb_loop = nb_fail = 0;
00137         while (nb_loop++ < LOOP) { 
00138                 for (addr = ADDRESS_START; addr <= ADDRESS_END; addr++) {
00139                         int i;
00140 
00141                         for (i=0; i<nb; i++) {
00142                                 tab_rq_registers[i] = (uint16_t) 44097+i;;
00143                                 tab_rq_status[i] = tab_rq_registers[i] % 2;
00144                         }
00145                         nb = ADDRESS_END - addr;
00146 /*
00147                         ret = preset_multiple_registers(&mb_param, SLAVE,
00148                                                         addr, nb, tab_rq_registers);
00149                         if (ret != nb) {
00150                                 printf("ERROR preset_multiple_registers (%d)\n", ret);
00151                                 printf("Slave = %d, address = %d, nb = %d\n",
00152                                                SLAVE, addr, nb);
00153                                 nb_fail++;
00154                         } else {
00155                         */
00156                       /*
00157                                 ret = read_holding_registers(&mb_param, SLAVE,
00158                                                              addr, nb, tab_rp_registers);
00159                                                              
00160                                                              
00161                                                                printf("HERER");
00162   */
00163   
00164           int ret;
00165         int query_length;
00166    
00167 
00168          query_length = build_query_basis_rtu(SLAVE, FC_READ_HOLDING_REGISTERS, addr, nb, query);
00169         //  query_length = build_query_basis(&mb_param, SLAVE, FC_READ_HOLDING_REGISTERS, addr, nb, query);
00170 
00171         ret = modbus_send(&mb_param, query, query_length);
00172                                
00173                         //}
00174 
00175                 }
00176                         
00177                 printf("Test: ");
00178                 if (nb_fail)
00179                         printf("%d FAILS\n", nb_fail);
00180                 else
00181                         printf("SUCCESS\n");
00182         }
00183       //  handleInterrupt();
00184 /*
00185         free(tab_rq_status);
00186         free(tab_rp_status);                                           
00187         free(tab_rq_registers);
00188         free(tab_rp_registers);
00189 
00190         modbus_close(&mb_param);
00191  */       
00192 }
00193 
00194 
00195 int main() {
00196      myled = 1;
00197     console_port.baud(230400);
00198     serial.baud(57600);
00199     
00200   printf("Starting\n");
00201 
00202 modbus_test();
00203 
00204     while(1) {
00205         myled = 1;
00206         wait(0.2);
00207         myled = 0;
00208         wait(0.2);
00209     }
00210 }