SHARE
TWEET

Untitled

a guest Jun 17th, 2019 59 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. void I2C_Timer() {
  2. if(i2cFlag) i2cTimer++;
  3. else i2cTimer = 0;
  4. if(i2cTimer > 3) {
  5.     // Reset I2C
  6.     __HAL_I2C_DISABLE(&hi2c1);
  7.     MX_I2C1_Init();
  8.     bTransferRequest = prevTransferRequest;
  9.     i2cTimer = 0;
  10.     i2cFlag = 0;
  11.     comComplete = 0;
  12.  
  13.     switch(bTransferRequest) {
  14.         case MASTER_REQ_READ:
  15.             if(comCount < 2) {
  16.                 /* If comm fails to complete, restart com to the same board */
  17.                 switch(comIndex) {
  18.                     case 0: case 1: comIndex = 0; break; // Chiller
  19.                     case 2: case 3: comIndex = 2; break; // Discharge
  20.                 }
  21.             }
  22.             else {
  23.                 /* Switching to the next board if prev board comm fails for more than 2 tries */
  24.                 switch(comIndex) {
  25.                     case 0: case 1: comIndex = 2; break; // Chiller
  26.                     case 2: case 3: comIndex = 0; break; // Discharge
  27.                 }
  28.                 comComplete = 1;
  29.                 comCount = 0;
  30.             }
  31.         break;
  32.         case MASTER_REQ_WRITE:
  33.  
  34.         // case MASTER_REQ_MASSWRITE:
  35.     }
  36.     if(comCount == 4) {
  37.  
  38.     }
  39.     comCount++;
  40. }
  41.      
  42. void I2C_Routine(void) {
  43.         if(i2cFlag == 0) {
  44.             switch(bTransferRequest) {
  45.                 if(HAL_I2C_GetState(&hi2c1) == HAL_I2C_STATE_READY) {
  46.                 case MASTER_REQ_READ:
  47.                     switch(comIndex) {
  48.                         case 0:
  49.                             i2cTimerFlag = 1;
  50.                             if(HAL_I2C_Master_Transmit_DMA(&hi2c1, (uint16_t)I2C_ADD_CHILLER, &bTransferRequest, 1)!= HAL_OK) {
  51.                                 /* Error_Handler() function is called when error occurs. */
  52.                                 Error_Handler();                
  53.                             }
  54.                             i2cFlag = 1;
  55.                             comComplete=0;
  56.                             break;
  57.                         case 1:
  58.                             // memset(aRxBuffer, 0, RECEIVE_BYTES);
  59.                             if(HAL_I2C_Master_Receive_DMA(&hi2c1, (uint16_t)I2C_ADD_CHILLER, (uint8_t *)aChillrRxBuffer, CHILLR_RECEIVE_BYTES)!= HAL_OK) {
  60.                                 /* Error_Handler() function is called when error occurs. */
  61.                                 Error_Handler();                
  62.                             }
  63.                             i2cFlag = 1;
  64.                             comComplete = 1;
  65.                             break;
  66.                         case 2:
  67.                             if(HAL_I2C_Master_Transmit_DMA(&hi2c1, (uint16_t)I2C_ADD_DISCHARGE, &bTransferRequest, 1)!= HAL_OK) {
  68.                                 /* Error_Handler() function is called when error occurs. */
  69.                                 Error_Handler();                
  70.                             }
  71.                             i2cFlag = 1;
  72.                             comComplete = 0;
  73.                             break;
  74.                         case 3:
  75.                             if(HAL_I2C_Master_Receive_DMA(&hi2c1, (uint16_t)I2C_ADD_DISCHARGE, (uint8_t *)aDischRxBuffer, DISCH_RECEIVE_BYTES)!= HAL_OK) {
  76.                                 /* Error_Handler() function is called when error occurs. */
  77.                                 Error_Handler();                
  78.                             }
  79.                             i2cFlag = 1;
  80.                             comComplete = 1;
  81.                             break;
  82.                     }
  83.                     prevTransferRequest = MASTER_REQ_READ;
  84.                     bTransferRequest = MASTER_REQ_READ;
  85.                     break;
  86.                 case MASTER_REQ_WRITE:
  87.                     if(i2cWriteParamFlag == SET) {
  88.                         switch(comIndex) {
  89.                             case 0:
  90.                                 comComplete=0;
  91.                                 if(HAL_I2C_Master_Transmit_DMA(&hi2c1, (uint16_t)I2C_Address, &bTransferRequest, 1)!= HAL_OK) {
  92.                                     /* Error_Handler() function is called when error occurs. */
  93.                                     Error_Handler();                
  94.                                 }
  95.                                 i2cFlag = 1;
  96.                                 break;
  97.                             case 1:
  98.                                 if(HAL_I2C_Master_Receive_DMA(&hi2c1, (uint16_t)I2C_Address, &bTransferAck, 1)!= HAL_OK) {
  99.                                     /* Error_Handler() function is called when error occurs. */
  100.                                     Error_Handler();                
  101.                                 }
  102.                                 i2cFlag = 1;
  103.                                 break;
  104.                             case 2:
  105.                                 if(bTransferAck == MASTER_REQ_WRITE) {
  106.                                     while(HAL_I2C_GetState(&hi2c1) == HAL_I2C_STATE_BUSY);
  107.                                     HAL_Delay(20);
  108.                                     if(HAL_I2C_Master_Transmit_DMA(&hi2c1, (uint16_t)I2C_Address, (uint8_t *)aTxBuffer, 3)!= HAL_OK) {
  109.                                         /* Error_Handler() function is called when error occurs. */
  110.                                         Error_Handler();                
  111.                                     }
  112.                                     i2cFlag = 1;
  113.                                     i2cWriteParamFlag = RESET;
  114.                                     comComplete=1;
  115.                                 }
  116.                             }
  117.                     }
  118.                 prevTransferRequest = MASTER_REQ_WRITE;
  119.                 bTransferRequest = MASTER_REQ_READ;
  120.                 break;
  121.                 case MASTER_REQ_MASSWRITE:
  122.                     switch(comIndex) {
  123.                         case 0:
  124.                             if(HAL_I2C_Master_Transmit_DMA(&hi2c1, (uint16_t)I2C_ADD_CHILLER, &bTransferRequest, 1)!= HAL_OK) {
  125.                                 /* Error_Handler() function is called when error occurs. */
  126.                                 Error_Handler();                
  127.                             }
  128.                             i2cFlag = 1;
  129.                             break;
  130.                         case 1:
  131.                             if(HAL_I2C_Master_Transmit_DMA(&hi2c1, (uint16_t)I2C_ADD_CHILLER, (uint8_t *)aMassTxBuffer, CHILLER_TRANSMIT_BYTES)!= HAL_OK) {
  132.                                 /* Error_Handler() function is called when error occurs. */
  133.                                 Error_Handler();                
  134.                             }
  135.                             i2cFlag = 1;
  136.                             break;
  137.                         case 2:
  138.                             if(HAL_I2C_Master_Transmit_DMA(&hi2c1, (uint16_t)I2C_ADD_DISCHARGE, &bTransferRequest, 1)!= HAL_OK) {
  139.                                 /* Error_Handler() function is called when error occurs. */
  140.                                 Error_Handler();                
  141.                             }
  142.                             i2cFlag = 1;
  143.                             break;
  144.                         case 3:
  145.                             if(HAL_I2C_Master_Transmit_DMA(&hi2c1, (uint16_t)I2C_ADD_DISCHARGE, (uint8_t *)aMassTxBuffer, DISCHARGE_TRANSMIT_BYTES)!= HAL_OK) {
  146.                                 /* Error_Handler() function is called when error occurs. */
  147.                                 Error_Handler();                
  148.                             }
  149.                             i2cFlag = 1;
  150.                             break;
  151.                     }
  152.                     prevTransferRequest = MASTER_REQ_MASSWRITE;
  153.                     bTransferRequest = MASTER_REQ_READ;
  154.                     break;
  155.                 }
  156.             }
  157.         }
  158. }
  159.  
  160. void I2C_Read() {
  161.     bTransferRequest = MASTER_REQ_READ;
  162.     comIndex = 0;
  163. }
  164.  
  165.  
  166. void I2C_Write(uint8_t Id) {
  167.     bTransferRequest = MASTER_REQ_WRITE;
  168.     // Id is chiller parameter
  169.     I2C_Address = I2C_ADD_CHILLER;
  170.     aTxBuffer[0] = Id - ChillerStartAddr - 0x98;
  171. // Id is discharge parameter
  172. //  I2C_Address = I2C_ADD_DISCHARGE;
  173. //  aTxBuffer[0] = Id - DichargeStartAddr;
  174.  
  175. //  Discharge and chiller parameter ranges
  176.     EEPROM_Unlock();
  177.     int16_t Val =  EEPROM_ReadParam(Id);
  178.     EEPROM_Lock();
  179.     aTxBuffer[1] = (Val & 0xFF00) >> 8;
  180.     aTxBuffer[2] = (Val & 0x00FF);
  181.     i2cWriteParamFlag = SET;
  182.     comIndex = 0;
  183.     i2cFlag = 0;
  184. }
  185.  
  186. void I2C_MassWrite() {
  187.     bTransferRequest = MASTER_REQ_MASSWRITE;
  188.     comIndex = 0;
  189.     // Fill aMassRxBuffer_Chiller
  190.     // Fill aMassRxBuffer_Discharge
  191. }
  192.  
  193. void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *I2cHandle) {
  194.     switch(bTransferRequest) {
  195.         case MASTER_REQ_READ:
  196.             switch(comIndex) {
  197.                 case 0: comIndex = 1; break;
  198.                 case 2: comIndex = 3; comComplete = 1; break;
  199.             }
  200.         break;
  201.         case MASTER_REQ_WRITE:
  202.             switch(comIndex) {
  203.                 case 0: comIndex = 1; comComplete = 1; break;
  204.                 case 2: comIndex = 0; comComplete = 1; break;
  205.             }
  206.         break;
  207.     }
  208.     // i2cTimer = 0;
  209.     i2cFlag=0;
  210. }
  211.  
  212. void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *I2cHandle) {
  213.     switch(bTransferRequest) {
  214.         case MASTER_REQ_READ:
  215.             switch(comIndex) {
  216.                 case 1:
  217.                     for(uint8_t i = 0, j = 0; i < (i2cChillerParamCount*2) ; i+=2, j++) {
  218.                         uint8_t ValHigh = aChillrRxBuffer[i];
  219.                         uint8_t ValLow = aChillrRxBuffer[i + 1];
  220.                         uint16_t Val = (ValHigh << 8) | ValLow;
  221.                         PARAM_SetVal(i2CChillerArray[j], Val*(0.1));
  222.                     }
  223.                     comIndex = 2; break; // To read Discharge board
  224.                 case 3:
  225.                     for(uint8_t i = 0, j = 0; i < (i2cDichargeParamCount*2) ; i+=2, j++) {
  226.                         uint8_t ValHigh = aDischRxBuffer[i];
  227.                         uint8_t ValLow = aDischRxBuffer[i + 1];
  228.                         uint16_t Val = (ValHigh << 8) | ValLow;
  229.                         PARAM_SetVal(i2CDischrArray[j], Val*(0.1));
  230.                     }
  231.                     comIndex = 0; break; // To read Chiller board
  232.             }
  233.             break;
  234.         case MASTER_REQ_WRITE:
  235.             switch(comIndex) {
  236.                 case 1: comIndex = 2; break;
  237.             }
  238.             break;
  239.     }
  240.     // i2cTimer = 0;
  241.     i2cFlag = 0;
  242. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top