main.cpp

00001 #include "mbed.h"
00002 #include "watchdog.h"
00003 #include "USBHID.h"
00004 #include "ByteOperations.h"
00005 #include "USBHIDProtocol.h"
00006 
00007 #define VERSION 0x01
00008 
00009 
00010 // define all I/O
00011 DigitalOut led1(LED1);
00012 DigitalOut led2(LED2);
00013 DigitalOut led3(LED3);
00014 DigitalOut led4(LED4);
00015 DigitalIn digIn1(p6);
00016 DigitalIn digIn2(p7);
00017 DigitalIn digIn3(p8);
00018 DigitalIn digIn4(p9);
00019 DigitalIn digIn5(p10);
00020 DigitalIn digIn6(p11);
00021 DigitalIn digIn7(p12);
00022 DigitalIn digIn8(p13);
00023 //DigitalIn digIn9(p13);
00024 //DigitalIn digIn10(p14);
00025 DigitalOut digOut1(p21);
00026 DigitalOut digOut2(p22);
00027 DigitalOut digOut3(p23);
00028 DigitalOut digOut4(p24);
00029 DigitalOut digOut5(p25);
00030 DigitalOut digOut6(p26);
00031 DigitalOut digOut7(p27);
00032 DigitalOut digOut8(p28);
00033 AnalogIn anIn1(p16);
00034 AnalogIn anIn2(p17);
00035 AnalogIn anIn3(p19);
00036 AnalogIn anIn4(p20);
00037 AnalogOut anOut(p18);
00038 
00039 //Serial pc(USBTX, USBRX); 
00040 
00041 USBHID *hid;
00042 HID_REPORT send_report __attribute__((aligned (4))); // Aligned for fast access
00043 HID_REPORT recv_report __attribute__((aligned (4))); // Aligned for fast access
00044 
00045 
00046 /**
00047  * @brief   Clear buffer contents
00048  * @note    Requires 4 byte alignement of data
00049  * @param[in] c   Pointer to @p HID_REPORT.
00050  */
00051 void empty_report(HID_REPORT *data){
00052     register uint32_t *p = (uint32_t *)data->data;
00053     for( register int i=0; i<((sizeof(HID_REPORT)-1)/4); i++ ){
00054         *p = 0xFFFFFFFF;
00055         p++;
00056     }
00057 }
00058 
00059 
00060 int main(void)
00061 {
00062     uint16_t channel;
00063     uint16_t value;
00064         
00065     // USB Initialize   
00066     static USBHID hid_object(64, 64);
00067     hid = &hid_object;
00068     send_report.length = 64;
00069         
00070     //pc.printf("Start of main\n");
00071     
00072     // Ready
00073     while(1){
00074         // insert idle time, since we cant be running USB stuff all the time
00075         wait_us(5000);      
00076 
00077         //try to read a msg
00078         if(hid->readNB(&recv_report)){
00079             // Data packet received, start parsing
00080             int irx=0;
00081             int itx=0;
00082 
00083             send_report.data[itx++] = recv_report.data[0];
00084 
00085             switch ( recv_report.data[irx++] ){
00086                 case    CMD_SYS_CHECK       :
00087                     send_report.data[itx++] =  VERSION;
00088                 break;
00089                 
00090                 case    CMD_SYS_RESET       : 
00091                       // Soft reset
00092                         empty_report(&recv_report);
00093                 break;
00094 
00095                 case    CMD_LED_OFF         :
00096                     // CMD_LED_OFF              Args, byte led 1..4
00097                     channel = recv_report.data[irx++];
00098                     switch (channel){
00099                         case 1:
00100                             led1 = 1;    // inverted led
00101                             break;
00102                         case 2:
00103                             led2 = 1;    // inverted led
00104                             break;
00105                         case 3:
00106                             led3 = 0;    // inverted led
00107                             break;
00108                         case 4:
00109                             led4 = 0;    // inverted led
00110                             break;
00111                         default: 
00112                             send_report.data[0] =   0xFF;   //Failure
00113                     }
00114                 break;
00115 
00116                 case    CMD_LED_ON          :
00117                     // CMD_LED_ON               Args, byte led 1..4
00118                     channel = recv_report.data[irx++];
00119                     switch (channel){
00120                         case 1:
00121                             led1 = 0;    // inverted led
00122                             break;
00123                         case 2:
00124                             led2 = 0;    // inverted led
00125                             break;
00126                         case 3:
00127                             led3 = 1;    // inverted led
00128                             break;
00129                         case 4:
00130                             led4 = 1;    // inverted led
00131                             break;
00132                         default: 
00133                             send_report.data[0] =   0xFF;   //Failure
00134                     }
00135                 break;
00136 
00137                 case    CMD_READ_DIG_INPUT  :
00138                     // CMD_READ_DIG_INPUT           Args, byte channel, return int
00139                     channel = recv_report.data[irx++];
00140                     value = 0;
00141                     switch (channel){
00142                         case 1:
00143                             value = digIn1.read();
00144                             break;
00145                         case 2:
00146                             value = digIn2.read();
00147                             break;
00148                         case 3:
00149                             value = digIn3.read();
00150                             break;
00151                         case 4:
00152                             value = digIn4.read();
00153                             break;
00154                         case 5:
00155                             value = digIn5.read();
00156                             break;
00157                         case 6:
00158                             value = digIn6.read();
00159                             break;
00160                         case 7:
00161                             value = digIn7.read();
00162                             break;
00163                         case 8:
00164                             value = digIn8.read();
00165                             break;
00166                         default: 
00167                             send_report.data[0] =   0xFF;   //Failure
00168                     }
00169                     write_16_to_8(&itx, send_report.data, value);                  
00170                 break;
00171 
00172                 case    CMD_READ_ALL_DIG_INPUTS  :
00173                     // CMD_READ_ALL_DIG_INPUTS      No args, return int
00174                     value = 0;
00175                     value = digIn1.read();
00176                     value |= ((digIn2.read() & 1) << 1);
00177                     value |= ((digIn3.read() & 1) << 2);
00178                     value |= ((digIn4.read() & 1) << 3);
00179                     value |= ((digIn5.read() & 1) << 4);
00180                     value |= ((digIn6.read() & 1) << 5);
00181                     value |= ((digIn7.read() & 1) << 6);
00182                     value |= ((digIn8.read() & 1) << 7);
00183                     write_16_to_8(&itx, send_report.data, value);                  
00184                 break;
00185 
00186                 case    CMD_READ_DIG_OUTPUT  :
00187                     // CMD_READ_DIG_OUTPUT          Args, byte channel, return int
00188                     channel = recv_report.data[irx++];
00189                     value = 0;
00190                     switch (channel){
00191                         case 1:
00192                             value = digOut1.read();
00193                             break;
00194                         case 2:
00195                             value = digOut2.read();
00196                             break;
00197                         case 3:
00198                             value = digOut3.read();
00199                             break;
00200                         case 4:
00201                             value = digOut4.read();
00202                             break;
00203                         case 5:
00204                             value = digOut5.read();
00205                             break;
00206                         case 6:
00207                             value = digOut6.read();
00208                             break;
00209                         case 7:
00210                             value = digOut7.read();
00211                             break;
00212                         case 8:
00213                             value = digOut8.read();
00214                             break;
00215                         default: 
00216                             send_report.data[0] =   0xFF;   //Failure
00217                     }
00218                     write_16_to_8(&itx, send_report.data, value);                  
00219                 break;
00220 
00221                 case    CMD_READ_ALL_DIG_OUTPUTS  :
00222                     // CMD_READ_ALL_DIG_OUTPUTS     No args, return int
00223                     value = 0;
00224                     value = digOut1.read();
00225                     value |= ((digOut2.read() & 1) << 1);
00226                     value |= ((digOut3.read() & 1) << 2);
00227                     value |= ((digOut4.read() & 1) << 3);
00228                     value |= ((digOut5.read() & 1) << 4);
00229                     value |= ((digOut6.read() & 1) << 5);
00230                     value |= ((digOut7.read() & 1) << 6);
00231                     value |= ((digOut8.read() & 1) << 7);
00232                     write_16_to_8(&itx, send_report.data, value);                  
00233                 break;
00234 
00235                 case    CMD_WRITE_DIG_OUTPUT  :
00236                     // CMD_WRITE_DIG_OUTPUT         Args, byte channel, int value
00237                     channel = recv_report.data[irx++];
00238                     value = recv_report.data[irx++];
00239                     switch (channel){
00240                         case 1:
00241                             digOut1.write(!(value & 1));
00242                             break;
00243                         case 2:
00244                             digOut2.write(!(value & 1));
00245                             break;
00246                         case 3:
00247                             digOut3.write(value & 1);
00248                             break;
00249                         case 4:
00250                             digOut4.write(value & 1);
00251                             break;
00252                         case 5:
00253                             digOut5.write(value & 1);
00254                             break;
00255                         case 6:
00256                             digOut6.write(value & 1);
00257                             break;
00258                         case 7:
00259                             digOut7.write(value & 1);
00260                             break;
00261                         case 8:
00262                             digOut8.write(value & 1);
00263                             break;
00264                         default: 
00265                             send_report.data[0] =   0xFF;   //Failure
00266                     }
00267                 break;
00268 
00269                 case    CMD_WRITE_ALL_DIG_OUTPUTS  :
00270                     // CMD_WRIE_ALL_DIG_OUTPUTS     Args, byte output value
00271                     uint16_t value = recv_report.data[irx++];
00272                     digOut1.write(value & 1);
00273                     digOut2.write((value >> 1) & 1);
00274                     digOut3.write((value >> 2) & 1);
00275                     digOut4.write((value >> 3) & 1);
00276                     digOut5.write((value >> 4) & 1);
00277                     digOut6.write((value >> 5) & 1);
00278                     digOut7.write((value >> 6) & 1);
00279                     digOut8.write((value >> 7) & 1);
00280                 break;
00281 
00282                 case    CMD_READ_ANALOG_INPUT  :
00283                     // CMD_READ_ANALOG_INPUT        Args, byte channel, return int
00284                     channel = recv_report.data[irx++];
00285                     //pc.printf("Channel %d\n", channel);
00286                     switch (channel){
00287                         case 1:
00288                             uint16_t value = anIn1.read_u16();
00289                             write_16_to_8(&itx, send_report.data, value);  
00290                             //pc.printf("Value %d\n", value );
00291                             break;
00292                         case 2:
00293                             value = anIn2.read_u16();
00294                             write_16_to_8(&itx, send_report.data, value);  
00295                             break;
00296                         case 3:
00297                             value = anIn3.read_u16();
00298                             write_16_to_8(&itx, send_report.data, value);  
00299                             break;
00300                         case 4:
00301                             value = anIn4.read_u16();
00302                             write_16_to_8(&itx, send_report.data, value);  
00303                             break;
00304                         default: 
00305                             send_report.data[0] =   0xFF;   //Failure
00306                     }                            
00307                 break;
00308 
00309                 case    CMD_WRITE_ANALOG_OUTPUT  :
00310                     // CMD_WRITE_ANALOG_OUTPUT      Args, int value
00311                     value = read_8_to_16(&irx, recv_report.data);
00312                     anOut.write_u16(value);
00313                 break;
00314 
00315                 case 0xEE   : {
00316                     hid->sendNB(&send_report);  
00317                     WatchDog_us bello(100);
00318                     }
00319                 break;
00320 
00321                 default:
00322                     send_report.data[0] =   0xFF;   //Failure
00323                 break;
00324             } // Switch 
00325             // Return command + optional new args
00326             hid->send(&send_report);
00327             // 0xFF unused bytes
00328             empty_report(&recv_report);         
00329             empty_report(&send_report);
00330         }       // if packet
00331     } // While
00332 }
00333