mbed_unit.cpp

00001 #include "mbed.h"
00002 #include "uart.h"
00003 #include "interpret.h"
00004 #include "mbed_unit.h"
00005 #include "rs232.h"
00006 #include "can.h"
00007 #include "pwm.h"
00008 #include "ana.h"
00009 #include "dido.h"
00010 #include "RS485.h"
00011 
00012 
00013 //---------------------------------------
00014 // Hardware recources
00015 //---------------------------------------
00016 
00017 
00018 DigitalOut K1_Relay(P0_29);
00019 DigitalOut K2_Relay(P0_30);
00020  
00021 
00022 //---------------------------------------
00023 // Prototypes
00024 //---------------------------------------
00025 
00026 
00027 
00028 //---------------------------------------
00029 // Internal variables
00030 //---------------------------------------
00031 
00032 
00033 //---------------------------------------
00034 // External variables
00035 //---------------------------------------
00036 
00037 
00038 
00039 //---------------------------------------
00040 // Global Functions
00041 //---------------------------------------
00042 void MBED_init( void )
00043 {
00044     PWM_init();
00045     RS232_init();
00046     CAN_init();
00047     ANA_init();
00048     DIDO_init();
00049     K1_Relay=0;
00050     K2_Relay=0;
00051 }
00052 
00053 
00054 
00055 // process commands
00056 void MBED_deviceID_process( void )
00057 {
00058     unsigned int temp32U;
00059     int temp32;
00060     char *ptrTempChar;
00061     int i;
00062 
00063     switch( uartBuffer[ INT_BUF_COMMAND ] ) {
00064             //---------------------------
00065         case MBED_SET_RPM_LEVEL_LOW:
00066             //---------------------------
00067         {
00068               if( uartBuffer[INT_BUF_1DATA] ) 
00069                 K1_Relay=1;
00070                   else 
00071                 K1_Relay=0;
00072         
00073             // Generate acknowledge
00074             INT_generateACKFrame(INT_ID_MBED, INT_COM_ACK);
00075             break;
00076         }
00077 
00078 
00079         //---------------------------
00080         case MBED_SET_RPM_LEVEL_HIGH:
00081             //---------------------------
00082         {
00083               if( uartBuffer[INT_BUF_1DATA] ) 
00084                 K2_Relay=1;
00085                   else 
00086                 K2_Relay=0;
00087       
00088             // Generate acknowledge
00089             INT_generateACKFrame(INT_ID_MBED, INT_COM_ACK);
00090             break;
00091 
00092         }
00093 
00094 
00095         //---------------------------
00096         case MBED_SET_PWM_PORT:
00097             //---------------------------
00098         {
00099             // Set output high or low
00100             if( uartBuffer[INT_BUF_1DATA] & (1 << PWM_CH0) ) PWM_setDC(PWM_CH0, 100);
00101             else PWM_setDC(PWM_CH0, 0);
00102             if( uartBuffer[INT_BUF_1DATA] & (1 << PWM_CH1) ) PWM_setDC(PWM_CH1, 100);
00103             else PWM_setDC(PWM_CH1, 0);
00104             if( uartBuffer[INT_BUF_1DATA] & (1 << PWM_CH2) ) PWM_setDC(PWM_CH2, 100);
00105             else PWM_setDC(PWM_CH2, 0);
00106             if( uartBuffer[INT_BUF_1DATA] & (1 << PWM_CH3) ) PWM_setDC(PWM_CH3, 100);
00107             else PWM_setDC(PWM_CH3, 0);
00108             if( uartBuffer[INT_BUF_1DATA] & (1 << PWM_CH4) ) PWM_setDC(PWM_CH4, 100);
00109             else PWM_setDC(PWM_CH4, 0);
00110             if( uartBuffer[INT_BUF_1DATA] & (1 << PWM_CH5) ) PWM_setDC(PWM_CH5, 100);
00111             else PWM_setDC(PWM_CH5, 0);
00112 
00113             // Generate acknowledge
00114             INT_generateACKFrame(INT_ID_MBED, INT_COM_ACK);
00115 
00116             break;
00117         }
00118 
00119 
00120         //---------------------------
00121         case MBED_SET_PWM_FREQ:
00122             //---------------------------
00123         {
00124             // Get frequency data in [Hz]
00125             temp32U = 0;
00126 
00127             temp32U = uartBuffer[INT_BUF_1DATA];
00128             temp32U <<= 8;
00129             temp32U |= (unsigned int)uartBuffer[INT_BUF_1DATA + 1];
00130 
00131             // check limit
00132             if( PWM_updateFreq(temp32U) ) {
00133                 // Generate acknowledge
00134                 INT_generateACKFrame(INT_ID_MBED, INT_COM_ACK);
00135             } else { // outside of supported limit
00136                 // Generate acknowledge
00137                 INT_generateACKFrame(INT_ID_MBED, INT_COM_VAL_NOTVALID);
00138             }
00139 
00140             break;
00141         }
00142 
00143 
00144         //---------------------------
00145         case MBED_SET_PWM_DC:
00146             //---------------------------
00147         {
00148             if( PWM_setDC((int)uartBuffer[INT_BUF_1DATA], (int)uartBuffer[INT_BUF_1DATA + 1]) ) {
00149                 // Generate acknowledge
00150                 INT_generateACKFrame(INT_ID_MBED, INT_COM_ACK);
00151             } else { // outside of supported limit
00152                 // Generate acknowledge
00153                 INT_generateACKFrame(INT_ID_MBED, INT_COM_VAL_NOTVALID);
00154             }
00155             break;
00156 
00157         }
00158 
00159 
00160         //---------------------------
00161         case MBED_WRITE_RS232:
00162             //---------------------------
00163         {
00164             if( RS232_sendData( (char *)&uartBuffer[INT_BUF_1DATA], uartBuffer[INT_BUF_NUM] ) ) {
00165                 INT_generateACKFrame(INT_ID_MBED, INT_COM_ACK);
00166             } else {
00167                 INT_generateACKFrame(INT_ID_MBED, INT_COM_VAL_NOTVALID);
00168             }
00169 
00170             break;
00171         }
00172 
00173 
00174         //---------------------------
00175         case MBED_READ_RS232:
00176             //---------------------------
00177         {
00178             RS232_receiveData( ptrTempChar, &temp32 );
00179 
00180             // Generate acknowledge
00181             uartBuffer[INT_BUF_DEVICEID] = INT_ID_MBED;
00182             uartBuffer[INT_BUF_COMMAND] = INT_COM_ACK;
00183             uartBuffer[INT_BUF_NUM] = temp32;
00184             // copy data over to uart buffer
00185             for( i = 0; i < temp32; i++) {
00186                 uartBuffer[INT_BUF_1DATA + i] = *ptrTempChar;
00187                 ptrTempChar++;
00188             }
00189             UART_handler.bytesToWrite = 3 + temp32;
00190 
00191             break;
00192         }
00193 
00194 
00195         //---------------------------
00196         case MBED_SET_RTSRS232:
00197             //---------------------------
00198         {
00199             RS232_setRTS( (int)uartBuffer[INT_BUF_1DATA] );
00200             INT_generateACKFrame(INT_ID_MBED, INT_COM_ACK);
00201 
00202             break;
00203         }
00204 
00205 
00206         //---------------------------
00207         case MBED_GET_CTSRS232:
00208             //---------------------------
00209         {
00210             // Generate acknowledge
00211             uartBuffer[INT_BUF_DEVICEID] = INT_ID_MBED;
00212             uartBuffer[INT_BUF_COMMAND] = INT_COM_ACK;
00213             uartBuffer[INT_BUF_NUM] = 1;
00214             uartBuffer[INT_BUF_1DATA] = RS232_getCTS();
00215             UART_handler.bytesToWrite = 4;
00216 
00217             break;
00218         }
00219 
00220 
00221         //---------------------------
00222         case MBED_WRITE_CAN:
00223             //---------------------------
00224         {
00225             // Get CAN-ID
00226             temp32 = 0;
00227 
00228             temp32 = uartBuffer[INT_BUF_1DATA];
00229             temp32 <<= 8;
00230             temp32 |= (int)uartBuffer[INT_BUF_1DATA + 1];
00231 
00232             if( CAN_send( temp32, uartBuffer[INT_BUF_1DATA + 2], &uartBuffer[INT_BUF_1DATA + 3] ) ) {
00233                 INT_generateACKFrame(INT_ID_MBED, INT_COM_ACK);
00234             } else {
00235                 INT_generateACKFrame(INT_ID_MBED, INT_COM_VAL_NOTVALID);
00236             }
00237 
00238             break;
00239         }
00240 
00241 
00242         //---------------------------
00243         case MBED_READ_CAN:
00244             //---------------------------
00245         {
00246             // Get CAN-ID
00247             temp32 = 0;
00248 
00249             temp32 = uartBuffer[INT_BUF_1DATA];
00250             temp32 <<= 8;
00251             temp32 |= (int)uartBuffer[INT_BUF_1DATA + 1];
00252 
00253             if( CAN_get( &temp32, &uartBuffer[INT_BUF_1DATA + 2], &uartBuffer[INT_BUF_1DATA + 3] ) ) {
00254                 // Generate acknowledge
00255                 uartBuffer[INT_BUF_DEVICEID] = INT_ID_MBED;
00256                 uartBuffer[INT_BUF_COMMAND] = INT_COM_ACK;
00257                 uartBuffer[INT_BUF_NUM] = 3 + uartBuffer[INT_BUF_1DATA + 2];        //
00258                 uartBuffer[INT_BUF_1DATA] = (char)(0x000000FF & (temp32 >> 8) );    // CAN-ID high byte
00259                 uartBuffer[INT_BUF_1DATA + 1] = (char)(0x000000FF & temp32 );       // CAN-ID low byte
00260 
00261                 UART_handler.bytesToWrite = 6 + uartBuffer[INT_BUF_1DATA + 2];      //
00262             } else {
00263                 // Generate acknowledge, no new data frame
00264                 uartBuffer[INT_BUF_DEVICEID] = INT_ID_MBED;
00265                 uartBuffer[INT_BUF_COMMAND] = INT_COM_ACK;
00266                 uartBuffer[INT_BUF_NUM] = 3;        //
00267                 uartBuffer[INT_BUF_1DATA] = 0;      // CAN-ID high byte
00268                 uartBuffer[INT_BUF_1DATA + 1] = 0 ; // CAN-ID low byte
00269                 uartBuffer[INT_BUF_1DATA + 2] = 0 ; // 0 Data frames
00270                 UART_handler.bytesToWrite = 6;      //
00271             }
00272 
00273             break;
00274         }
00275 
00276 
00277         //---------------------------
00278         case MBED_READ_ADC:
00279             //---------------------------
00280         {
00281             // Get ADC value of channel indicated in uartBuffer[]
00282             temp32U = (unsigned int)ANA_getFiltered( (int)uartBuffer[INT_BUF_1DATA] );
00283             // Generate acknowledge
00284             uartBuffer[INT_BUF_DEVICEID] = INT_ID_MBED;
00285             uartBuffer[INT_BUF_COMMAND] = INT_COM_ACK;
00286             uartBuffer[INT_BUF_NUM] = 3;
00287             // uartBuffer[INT_BUF_1DATA] = KEEP channel number
00288             uartBuffer[INT_BUF_1DATA + 1] = (char)(0x000000FF & (temp32U >> 8) );    // high byte
00289             uartBuffer[INT_BUF_1DATA + 2] = (char)(0x000000FF & temp32U );           // low byte
00290 
00291             UART_handler.bytesToWrite = 6 ;      //
00292 
00293             break;
00294         }
00295 
00296 
00297         //---------------------------
00298         case MBED_SET_RELAY:
00299             //---------------------------
00300         {
00301             if( uartBuffer[INT_BUF_1DATA] ) {
00302                 DIDO_setRelayON();
00303             } else {
00304                 DIDO_setRelayOFF();
00305             }
00306 
00307             INT_generateACKFrame(INT_ID_MBED, INT_COM_ACK);
00308             break;
00309         }
00310 
00311 
00312         //---------------------------
00313         case MBED_SET_DO1:
00314             //---------------------------
00315         {
00316             if( uartBuffer[INT_BUF_1DATA] ) {
00317                 DIDO_setDO1ON();
00318             } else {
00319                 DIDO_setDO1OFF();
00320             }
00321 
00322             INT_generateACKFrame(INT_ID_MBED, INT_COM_ACK);
00323             break;
00324         }
00325 
00326 
00327         //---------------------------
00328         case MBED_SET_DO2:
00329             //---------------------------
00330         {
00331             if( uartBuffer[INT_BUF_1DATA] ) {
00332                 DIDO_setDO2ON();
00333             } else {
00334                 DIDO_setDO2OFF();
00335             }
00336 
00337             INT_generateACKFrame(INT_ID_MBED, INT_COM_ACK);
00338             break;
00339         }
00340 
00341         //---------------------------
00342         case MBED_GET_DI:
00343             //---------------------------
00344         {
00345             temp32U = 0;
00346 
00347             if( DIDO_getDI1() ) {
00348                 temp32U |= (1 << 0);
00349             }
00350 
00351             if( DIDO_getDI2() ) {
00352                 temp32U |= (1 << 1);
00353             }
00354 
00355             if( DIDO_getDI3() ) {
00356                 temp32U |= (1 << 2);
00357             }
00358 
00359             if( DIDO_getDI4() ) {
00360                 temp32U |= (1 << 3);
00361             }
00362 
00363             if( DIDO_getDI5() ) {
00364                 temp32U |= (1 << 4);
00365             }
00366 
00367             // Generate acknowledge
00368             uartBuffer[INT_BUF_DEVICEID] = INT_ID_MBED;
00369             uartBuffer[INT_BUF_COMMAND] = INT_COM_ACK;
00370             uartBuffer[INT_BUF_NUM] = 1;
00371             uartBuffer[INT_BUF_1DATA] = (char)(0x000000FF & temp32U );
00372             UART_handler.bytesToWrite = 4 ;      //
00373 
00374             break;
00375         }
00376 
00377 
00378         //---------------------------
00379         case MBED_WRITE_RS485:
00380             //---------------------------
00381         {
00382             if( RS485_sendData( (char *)&uartBuffer[INT_BUF_1DATA], (int)uartBuffer[INT_BUF_NUM] ) ) {
00383                 INT_generateACKFrame(INT_ID_MBED, INT_COM_ACK);
00384             } else {
00385                 INT_generateACKFrame(INT_ID_MBED, INT_COM_VAL_NOTVALID);
00386             }
00387 
00388             break;
00389         }
00390 
00391 
00392         //---------------------------
00393         case MBED_READ_RS485:
00394             //---------------------------
00395         {
00396             RS485_receiveData( ptrTempChar, (int *)&uartBuffer[INT_BUF_NUM] );
00397 
00398             // Generate acknowledge
00399             uartBuffer[INT_BUF_DEVICEID] = INT_ID_MBED;
00400             uartBuffer[INT_BUF_COMMAND] = INT_COM_ACK;
00401             // copy data over to uart buffer
00402             for( i = 0; i < uartBuffer[INT_BUF_NUM]; i++) {
00403                 uartBuffer[INT_BUF_1DATA + i] = *ptrTempChar;
00404                 ptrTempChar++;
00405             }
00406             UART_handler.bytesToWrite = 3 + uartBuffer[INT_BUF_NUM];
00407 
00408             break;
00409         }
00410 
00411 
00412         //-----------------
00413         default:
00414             //-----------------
00415         {
00416             // Command not supported
00417             INT_generateACKFrame(INT_ID_MBED, INT_COM_COM_NOTSUPP);
00418         }
00419 
00420     }//switch
00421 
00422 }
00423 
00424 //---------------------------------------
00425 // Internal Functions
00426 //---------------------------------------