main.cpp

00001 //** An I2C Slave, used for communicating with an I2C Master device 
00002 // ПО платы ВПУ адрес 0x08 - не изменяется
00003 #include <mbed.h>
00004 #include <IO.h>
00005 //#include <timers.h>
00006 #include <types.h>
00007 #include <Package.h>
00008 #define STATUS_OK       1
00009 #define STATUS_ERROR    -1
00010 #define I2C_SLAVE       I2C1
00011 
00012 //Serial pc(USBTX, USBRX);  // tx, rx консоль
00013 Serial pc(PC_6, PC_7);  // tx, rx консоль Serial6
00014 I2CSlave slave(PB_9, PB_8);
00015 char readBuffer[5]; // буфер приема
00016 //char writeBuffer[4]; // буфер передачи
00017 char writeBuffer[]={0,0,1,1};
00018 int errorStatus=STATUS_OK; // статус приема пакета от ЦП
00019 int initMode; // режим инициализации 1 - есть, 0 - нет. 
00020 
00021 HAL_I2C_ErrorTypeDef err_I2C;
00022 HAL_StatusTypeDef    status_I2C;
00023     
00024 I2C_HandleTypeDef      hI2C;
00025 __IO ITStatus UartReady = RESET;
00026 
00027 //SLOT_TABLE slot = {0};
00028 int slot=0x08;
00029 int Counter = 0;
00030 int Error = 0;
00031 int Reset = 0;
00032 PACKAGE_I2C_RX puRX = {0};
00033 PACKAGE_I2C_TX puTX = {0};
00034 PACKAGE_INFO infoPackage =
00035 {
00036     I2C_SIZEBUF_RX,
00037     I2C_SIZEBUF_TX,
00038     FLASH_LIGHT_OFF,
00039     FLASH_LIGHT_OFF,
00040     500,                  // Время мигания
00041     CHANGECONTROL_NONE,
00042     3000                  // Время переключения
00043 };
00044 
00045 
00046 // обработчик принятых данных от ЦП к VPU
00047   void receiveBufferHandler()
00048   {
00049     // проверяем ошибки xor всех байт
00050     if (readBuffer[3]!=(readBuffer[0]^readBuffer[1]^readBuffer[2]))
00051     {
00052         errorStatus=STATUS_ERROR; // ошибка если не сошелся xor
00053         return;
00054     }    
00055     else errorStatus=STATUS_OK;
00056     
00057     // проверяем какой режим - работы или инициализации.
00058     if (readBuffer[0]==0xA5)
00059     {
00060         initMode=0;
00061         // состояние данных из пакета выводим в выходы МК 
00062         //readBuffer[1]=0xEB;readBuffer[2]=0xff;
00063         Out1= readBuffer[1]&1<<0; 
00064         Out2= readBuffer[1]&1<<1;
00065         Out3= readBuffer[1]&1<<2; 
00066         Out4= readBuffer[1]&1<<3;
00067         Out5= readBuffer[1]&1<<4; 
00068         Out6= readBuffer[1]&1<<5;
00069         Out7= readBuffer[1]&1<<6; 
00070         Out8= readBuffer[1]&1<<7; 
00071         Out9= readBuffer[2]&1<<0; 
00072         Out10=readBuffer[2]&1<<1;
00073         Out11=readBuffer[2]&1<<2; 
00074         Out12=readBuffer[2]&1<<3;
00075         Out13=readBuffer[2]&1<<4; 
00076         Out14=readBuffer[2]&1<<5;
00077         Out15=readBuffer[2]&1<<6; 
00078         Out16=readBuffer[2]&1<<7; 
00079     }
00080     else if (readBuffer[0]==0xAB)initMode=1;
00081   }
00082 
00083 // формирователь данных прередаваемых от VPU к ЦП 
00084   void sendBufferHandler()
00085   {
00086     writeBuffer[0]=(In1<<0+In2<<1+In3<<2+In4<<3+In5<<4+In6<<5+In7<<6+In8<<7);
00087     writeBuffer[1]=(In9<<0+In10<<1+In11<<2+In12<<3+In13<<4+In14<<5+In15<<6+In16<<7);
00088     writeBuffer[2]=errorStatus;
00089     writeBuffer[3]=writeBuffer[0]^writeBuffer[1]^writeBuffer[2];
00090   }
00091 
00092 void InitI2C(int Address) {
00093     __HAL_I2C_ENABLE(&hI2C);
00094 
00095 #ifdef MASTER   
00096   hi2c1.Instance = I2C_MASTER;
00097 #else
00098   hI2C.Instance = I2C_SLAVE;
00099 #endif  
00100 
00101 #ifdef HIGH_SPEED_I2C  
00102     hI2C.Init.ClockSpeed = 400000;
00103   hI2C.Init.DutyCycle = I2C_DUTYCYCLE_16_9;
00104 #else
00105     hI2C.Init.ClockSpeed = 100000;
00106   hI2C.Init.DutyCycle = I2C_DUTYCYCLE_2;    
00107 #endif
00108     
00109   hI2C.Init.OwnAddress1 = Address;
00110   hI2C.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
00111   hI2C.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;
00112   hI2C.Init.OwnAddress2 = 0;
00113   hI2C.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;
00114   hI2C.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;
00115 
00116   if (HAL_I2C_Init(&hI2C) != HAL_OK)
00117     {
00118     /* Initialization Error */
00119     pc.printf("Error_init_I2C");
00120     }
00121     //__HAL_I2C_ENABLE_IT(&hi2c1,I2C_IT_BUF);
00122 }
00123 
00124 
00125   int main() 
00126   {   
00127       STEP_ROUTINE step = STEP_INIT;  
00128       FUNCTION_RETURN Result;   
00129       slave.frequency(400000);        //частота шины I2C
00130       slave.address(0x08);             // адрес в сети i2c для этой платы всегда фиксированный.
00131       while (1) 
00132       {       Out16=1;
00133           //sendBufferHandler(); // формирователь того что надо отправить в ЦП
00134           int i = slave.receive();
00135           //pc.printf("i= %d",i);
00136           
00137           switch (step) {
00138                 //case STEP_INIT:
00139                 //{
00140                 //    status_I2C = (HAL_StatusTypeDef)HAL_I2C_GetState(&hI2C);
00141                 //    PrintStatus(status_I2C);
00142                 //    HAL_Delay(5000);
00143                 //} break;
00144                     
00145                 case STEP_RX:
00146                 {
00147                     status_I2C = HAL_I2C_Slave_Receive(&hI2C, (BYTE *)&puRX, infoPackage.sizeRX,100);
00148                     if (status_I2C == HAL_OK)
00149                     {
00150                         Result = PCKG_Check(puRX);
00151                         if (!IsFunctionError(Result))   // Если нет ошибки
00152                         {
00153                             puTX.data.status = PACKAGE_STATUS_SUCCESS;
00154                             switch (Result)
00155                             {
00156                                 case FUNCTION_SUCCESS:
00157                                 {
00158                                     //if (PCKG_LightLamp(puRX,&infoPackage) == SWITCH_ACTIVE)    // Управление лампами
00159                                     //{
00160                                     //    tickLight = HAL_GetTick();   // Обнуляем время, чтобы мигание началось заново
00161                                     //}
00162                                 } break;
00163                                 
00164                                 case FUNCTION_TESTBLINK:
00165                                 {
00166                                     //if (PCKG_TestBlink(&infoPackage) == SWITCH_ACTIVE)    // Управление лампами
00167                                     //{
00168                                     //    tickLight = HAL_GetTick();   // Обнуляем время, чтобы мигание началось заново
00169                                     //}
00170                                 } break;
00171                                 
00172                                 default:
00173                                 {
00174                                 } break;
00175                             }
00176                         }
00177                         else
00178                         {
00179                             puTX.data.status = PACKAGE_STATUS_ERROR;
00180                         }
00181 
00182                         step = STEP_TX;
00183                     }
00184                     else
00185                     {
00186                         step = STEP_RESET;
00187                     }
00188                 } break;
00189                 
00190                 case STEP_TX:
00191                 {
00192                     puTX.data.curGroup1.curRed = 10;
00193                     puTX.data.curGroup1.curYellow = 20;
00194                     puTX.data.curGroup1.curGreen = 30;
00195                     puTX.data.curGroup1.curOutput = 40;
00196                     puTX.data.curGroup2.curRed = 1111;
00197                     puTX.data.curGroup2.curYellow = 2222;
00198                     puTX.data.curGroup2.curGreen = 3333;
00199                     puTX.data.curGroup2.curOutput = 4444;
00200                     puTX.data.checkSum = PCKG_CheckSum(puTX.bytes,infoPackage.sizeTX);
00201                     
00202                     
00203                     status_I2C = HAL_I2C_Slave_Transmit(&hI2C, (BYTE *)&puTX, infoPackage.sizeTX, 100);
00204                     if (status_I2C == HAL_OK)
00205                     {
00206                         //printf("Slave TX = %s\r\n",cBuf);
00207                         //printf("OK\r\n");
00208                         Counter++;
00209                         step = STEP_IDLE;
00210                     }
00211                     else
00212                     {
00213                         //printf("Slave TX = %s\r\n",cBuf);
00214                         //printf("ERROR\r\n");
00215                         Error++;
00216                         step = STEP_RESET;
00217                     }
00218                     //printf("Slave end\r\n");
00219                 } break;
00220                 
00221                 case STEP_RESET:
00222                 {
00223                     //PrintStatus(status);
00224                     //PrintErrStatus(err);                  
00225                     
00226                     HAL_I2C_DeInit(&hI2C);
00227                     InitI2C(slot);
00228                     //printf("DEINIT Success\r\n");
00229                     Reset++;
00230                     step = STEP_IDLE;
00231                 } break;
00232                 
00233                 case STEP_IDLE:
00234                 {
00235                     //for (i=0;i<I2C_SIZEBUF_RX;i++)
00236                     //{
00237                         //printf("%d) 0x%02X\r\n",i,puRX.bytes[1]);
00238                     //}
00239                     
00240                     //pc.printf("Fl = %d\r\n",step );
00241                     
00242                     memset(&puRX,0,infoPackage.sizeRX);
00243                     memset(&puTX,0,infoPackage.sizeTX);
00244                     step = STEP_RX;
00245                 } break;
00246                 
00247                 default:
00248                 {
00249                 } break;
00250             }
00251           for(int i = 0; i < 4; i++) {/*writeBuffer[i] = 0;*/ readBuffer[i]=0;} // Clear buffers      
00252       //for(int i = 0; i < 10; i++) readBuffer[0] = 0;    // Clear readBufferfer
00253       //pc.printf("writeBuffer= %x %x %x %x\r\n",writeBuffer[0],writeBuffer[1],writeBuffer[2],writeBuffer[3]);
00254       //pc.printf("sizeof(writeBuffer)= %d\r\n",sizeof(writeBuffer));
00255       //pc.printf("readBuffer= %x %x %x %x\r\n",readBuffer[0],readBuffer[1],readBuffer[2],readBuffer[3]);
00256       //wait(0.001);
00257       Out1=1;
00258       }    
00259   }