Advertisement
Guest User

Modbus 8 bit cpu

a guest
Nov 21st, 2019
129
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 6.07 KB | None | 0 0
  1. #include <SI_EFM8UB2_Register_Enums.h>
  2.  
  3. #define UART_BUFFERSIZE 64
  4. uint8_t UART_Buffer[UART_BUFFERSIZE];
  5. extern uint8_t UART_Buffer_Size;
  6. uint8_t UART_Input_First;
  7. uint8_t UART_Output_First;
  8. extern uint8_t TX_Ready;
  9. extern char Byte;
  10.  
  11.  
  12. /* Supported function codes */
  13. #define _READ_HOLDING_REGISTERS 0x03
  14. #define _WRITE_MULTIPLE_REGISTERS 0x10
  15.  
  16. char Chip_Address;
  17.  
  18. // Port0 1-7 inputs
  19. SI_SBIT(IN1, SFR_P0, 1);                // IN1 = '0' means on
  20. SI_SBIT(IN2, SFR_P0, 2);
  21. SI_SBIT(IN3, SFR_P0, 3);
  22. SI_SBIT(IN4, SFR_P0, 4);
  23. SI_SBIT(IN5, SFR_P0, 5);
  24. SI_SBIT(IN6, SFR_P0, 6);
  25. SI_SBIT(IN7, SFR_P0, 7);
  26. // Port1 1-7 inputs
  27. SI_SBIT(IN1, SFR_P1, 1);                // IN1 = '0' means on
  28. SI_SBIT(IN2, SFR_P1, 2);
  29. SI_SBIT(IN3, SFR_P1, 3);
  30. SI_SBIT(IN4, SFR_P1, 4);
  31. SI_SBIT(IN5, SFR_P1, 5);
  32. SI_SBIT(IN6, SFR_P1, 6);
  33. SI_SBIT(IN7, SFR_P1, 7);
  34. // Port2 1-7 outputs
  35. SI_SBIT(OUT1, SFR_P2, 1);
  36. SI_SBIT(OUT2, SFR_P2, 2);
  37. SI_SBIT(OUT3, SFR_P2, 3);
  38. SI_SBIT(OUT4, SFR_P2, 4);
  39. SI_SBIT(OUT5, SFR_P2, 5);
  40. SI_SBIT(OUT6, SFR_P2, 6);
  41. SI_SBIT(OUT7, SFR_P2, 7);
  42. // Port3 1-7 outputs
  43. SI_SBIT(OUT1, SFR_P3, 1);
  44. SI_SBIT(OUT2, SFR_P3, 2);
  45. SI_SBIT(OUT3, SFR_P3, 3);
  46. SI_SBIT(OUT4, SFR_P3, 4);
  47. SI_SBIT(OUT5, SFR_P3, 5);
  48. SI_SBIT(OUT6, SFR_P3, 6);
  49. SI_SBIT(OUT7, SFR_P3, 7);
  50.  
  51. static void DO_Request_Message(){   // I have to do a requet message based on the things i do?
  52.    
  53. }
  54. static void Check_GPIO_Status(){
  55.     uint8_t GPIO_STATUS_Input_P0 = SFR_P0;  // I have to put the gpio statuses together to be able to send back to master on request.
  56.     uint8_t GPIO_STATUS_Input_P1 = SFR_P1;
  57.     uint8_t GPIO_STATUS_Output_P2 = SFR_P2;
  58.     uint8_t GPIO_STATUS_Output_P3 = SFR_P3;
  59. }
  60.  
  61. static void Toggle_IO_Pins(uint8_t Data){       // Need to toggle the I/O pins based on the master request
  62.     //Data[0] tells us from where should i start to toggle the pins ( in theory )
  63.     //Data[1] tells us how many pins should i toggle ( in theory )
  64. }
  65. static int Check_Chip_Address(uint8_t Msg_Address){         // ADRESS BASED ON THE P0.1-P0.4 GPIOS
  66.     char Address1, Address2, Address3, Address4;            // This function is not okay.
  67.     Address1 = IN1;                                         // I have to read the input gpio statuses and match it with a 8 bit variable
  68.     Address2 = IN2;
  69.     Address3 = IN3;
  70.     Address4 = IN4;
  71.     Chip_Address = Address1;
  72.     Chip_Address += Address2;
  73.     Chip_Address += Address3;
  74.     Chip_Address += Address4;
  75.     if(Chip_Address == Msg_Address){
  76.         return 1;
  77.     }else{
  78.         return -1;
  79.     }
  80. }
  81.  
  82. static uint16_t Crc_Check(uint8_t *req, uint8_t req_length)
  83. {
  84.     uint8_t j;
  85.     uint16_t crc;
  86.     crc = 0xFFFF;
  87.     while (req_length--) {
  88.         crc = crc ^ *req++;
  89.         for (j = 0; j < 8; j++) {
  90.             if (crc & 0x0001)
  91.                 crc = (crc >> 1) ^ 0xA001;
  92.             else
  93.                 crc = crc >> 1;
  94.         }
  95.     }
  96.     return (crc << 8 | crc >> 8);
  97. }
  98.  
  99. static int check_integrity(uint8_t *msg, uint8_t msg_length)
  100. {
  101.     uint16_t crc_calculated;
  102.     uint16_t crc_received;
  103.     if (msg_length < 2)
  104.         return -1;
  105.     crc_calculated = Crc_Check(msg, msg_length - 2);
  106.     crc_received = (msg[msg_length - 2] << 8) | msg[msg_length - 1];
  107.  
  108.     /* Check CRC of msg */
  109.     if (crc_calculated == crc_received) {
  110.         return msg_length;
  111.     } else {
  112.         return -1;
  113.     }
  114. }
  115.  
  116. static void Check_Message(){
  117.     uint8_t Address,Code;
  118.     uint8_t Data[2];
  119.     uint8_t Crc[2];
  120.     int k = 0;
  121.     int i = 0;
  122.     // Get the whole message in separate variables for further analization
  123.     for(i = 0; i < UART_Input_First;i++){
  124.         if (i <= 2){
  125.             Address = UART_Buffer[i];
  126.         }
  127.         else if (i <= 4){
  128.             Code = UART_Buffer[i];
  129.         }
  130.         else if (i <= 8){
  131.             if(i <= 6){
  132.                 Data[0] = UART_Buffer[i];
  133.             }else{
  134.                 Data[1] = UART_Buffer[i];
  135.             }
  136.         }else{
  137.             Crc[k] = UART_Buffer[i];
  138.             k++;
  139.         }
  140.     }
  141.     // Checking the separated variables
  142.     if(Check_Chip_Address(Address) != -1){                  // Check if Message is ours.
  143.         if(check_integrity(Crc,UART_Buffer_Size) != -1){    // Check if no errors on crc
  144.             if(Code == _READ_HOLDING_REGISTERS){
  145.                 /** MASTER WANTS TO READ THE GPIOS **/
  146.                 Check_GPIO_Status();
  147.             }else if(Code == _WRITE_MULTIPLE_REGISTERS){
  148.                 /** MASTER WANTS TO TOGGLE THE GPIOS **/
  149.                 Toggle_IO_Pins(Data);
  150.             }
  151.             DO_Request_Message();
  152.         }
  153.     }
  154. }
  155.  
  156. //-----------------------------------------------------------------------------
  157. // SCON0::RI (Receive Interrupt Flag)
  158. // SCON0::TI (Transmit Interrupt Flag)
  159. //-----------------------------------------------------------------------------
  160. SI_INTERRUPT(UART0_ISR, UART0_IRQn)
  161. {
  162.     if (SCON0_RI == 1)
  163.        {
  164.           if( UART_Buffer_Size == 0)  {         // If new word is entered
  165.              UART_Input_First = 0;
  166.           }
  167.           SCON0_RI = 0;                         // Clear interrupt flag
  168.           Byte = SBUF0;                         // Read a character from UART
  169.           if (UART_Buffer_Size < UART_BUFFERSIZE)
  170.           {
  171.              UART_Buffer[UART_Input_First] = Byte; // Store in array
  172.  
  173.              UART_Buffer_Size++;                // Update array's size
  174.  
  175.              UART_Input_First++;                // Update counter
  176.           }else{
  177.               Check_Message();                  // Get the whole message and brake it into pieces
  178.           }
  179.        }
  180.  
  181.  
  182.  /** ECHO BACK THE MESSAGES **/
  183.  
  184. if (SCON0_TI == 1)                              // Check if transmit flag is set
  185.    {
  186.       SCON0_TI = 0;                             // Clear interrupt flag
  187.       if (UART_Buffer_Size != 1)                // If buffer not empty
  188.       {
  189.          // If a new word is being output
  190.          if ( UART_Buffer_Size == UART_Input_First ) {
  191.               UART_Output_First = 0;
  192.          }
  193.          // Store a character in the variable byte
  194.          Byte = UART_Buffer[UART_Output_First];
  195.          if ((Byte >= 0x61) && (Byte <= 0x7A)) { // If upper case letter
  196.             Byte -= 32;
  197.          }
  198.          SBUF0 = Byte;                          // Transmit to Hyperterminal
  199.          UART_Output_First++;                   // Update counter
  200.          UART_Buffer_Size--;                    // Decrease array size
  201.       }
  202.       else
  203.       {
  204.          UART_Buffer_Size = 0;                  // Set the array size to 0
  205.          TX_Ready = 1;                          // Indicate transmission complete
  206.       }
  207.    }
  208. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement