source: trunk/fw_g473rct/SES/src/modbus.c @ 24

Last change on this file since 24 was 24, checked in by f.jahn, 3 days ago

Shunt Temperatursensor aktiviert
File size: 19.8 KB
Line 
1/*
2 * modbus.c
3 *
4 * Created: 03.09.2012 08:39:20
5 *  Author: Falko
6 */ 
7
8
9
10#if MODBUS_SUPPORT == TRUE
11 
12  #include "modbus.h"
13  //#include "stm32g4xx_hal.h"
14  #include "main.h"
15  //#include "stm32g0xx_hal_tim.h"
16  //#include "stm32_hal_legacy.h"
17  #include <stdio.h>
18  // ---------------------------------------------------------
19  // -------------------- MODUL DEFINES ----------------------
20  // ---------------------------------------------------------
21
22
23               
24
25  #define MODBUS_BROADCAST_ADDRESS        0x00
26  #define FC_READ_COILS                   0x01
27  #define FC_READ_HOLDING_REGISTERS       0x03
28  #define FC_WRITE_SINGLE_REGISTER        0x06
29  #define FC_WRITE_MULTIPLE_REGISTER      0x10
30
31  /* Protocol exceptions */
32  #define ILLEGAL_FUNCTION                0x01
33  #define ILLEGAL_DATA_ADDRESS            0x02
34  #define ILLEGAL_DATA_VALUE              0x03
35  #define SLAVE_DEVICE_FAILURE            0x04
36  #define SERVER_FAILURE                    0x04
37  #define ACKNOWLEDGE                     0x05
38  #define SLAVE_DEVICE_BUSY               0x06
39  #define SERVER_BUSY                     0x06
40  #define NEGATIVE_ACKNOWLEDGE            0x07
41  #define MEMORY_PARITY_ERROR             0x08
42  #define GATEWAY_PROBLEM_PATH            0x0A
43  #define GATEWAY_PROBLEM_TARGET            0x0B
44
45  /* Local Error codes */
46  #define INVALID_CRC                     -1
47
48  // Position der Daten im Rx String
49  #define OFFSET_SLAVE_ADRESS             0x00
50  #define OFFSET_FUNCTION_CODE            0x01
51  #define OFFSET_START_ADRESS_HI          0x02
52  #define OFFSET_START_ADRESS_LO          0x03
53  #define OFFSET_NO_OF_REGISTERS_HI       0x04
54  #define OFFSET_NO_OF_REGISTERS_LO       0x05
55
56  #define MIN_NUMBER_OF_REGISTERS_FC3     0x01
57  #define MAX_NUMBER_OF_REGISTERS_FC3     0x7D
58  #define MIN_NUMBER_OF_REGISTERS_FC16    0x01
59  #define MAX_NUMBER_OF_REGISTERS_FC16    0x7B
60
61  #ifdef DEBUG
62    #define RESPONSE_TIMEOUT                300 // * 1ms
63  #else
64    #define RESPONSE_TIMEOUT                1000 // * 1ms
65  #endif
66
67  #define FAST_BAUDRATE_INTERFRAME_DELAY_us   (1750UL)
68  // --- Externe Variablen --------------------------------------------
69  extern  modbus_t modbusData;
70  extern  sys_data_t sys_data;
71
72
73  // --- Private Funktions Prototypen --------------------------------------------
74 
75                    void    mbUartInit                      (modbus_t * mb_data,UART_HandleTypeDef * usart, uint32_t baudrate,  uint32_t parityMode,  uint32_t stopBits , uint32_t nrOfBitsPerChar);
76                uint16_t    mbCrc16                         (uint8_t *buf, uint32_t len);
77                    void    mbSend                          (modbus_t * mb_data );
78                uint32_t    mbSlaveReadHoldingRegisters     (uint8_t * response_string, uint8_t *msg, uint32_t tx_position, uint8_t deviceID);
79                uint32_t    mbSlaveWriteMultipleRegisters   (uint8_t * response_string, uint8_t *msg,    uint32_t tx_position, uint32_t deviceID);
80                uint32_t    mbSlaveWriteSingleRegister      (uint8_t * response_string,uint8_t *msg,uint32_t tx_position, uint32_t deviceID);
81                uint32_t    mbSlaveResponseException        (uint8_t* response_string, uint32_t function_code, uint32_t exception_code,uint32_t tx_position) ;
82static HAL_StatusTypeDef    RS485_ModbusEx_Init             (UART_HandleTypeDef *huart, uint32_t Polarity, uint32_t AssertionTime, uint32_t DeassertionTime, uint32_t charReceiveTimeout);
83static              void    UART_TxISR_8BIT                 (UART_HandleTypeDef *huart);
84
85  // --- GEMEINSAME MODBUS FUNKTIONEN --------------------------------------------
86  // Diese Funktionen werden sowohl von Modbus Master als auch Modbus Slave verwendet
87
88  /*
89    *
90    * @brief  Diese Funktion Initialisert die Modbus Datenstrukturen und die Hardware
91    *
92    * Das Modbus Modul bentigt einen UART und einen Timer pro Modbus Anschluss
93    * Die Funktion erfordert eine vorhandene Callback funktion namens HAL_UART_MspInit
94    * In dieser muss:
95    * - Der UART CLK eingeschaltet werden
96    * - Die Pins initialisert werden (Alternate Port Funktion)
97    * - Der NVIC Interrupt eingeschaltet werden
98    * @param  mb_data : Datenstruktur zur Aufnahme aller Daten
99    * @param  baudrate : Bautrate
100    * @param  parityMode : Parity, mglich ist UART_PARITY_ODD, UART_PARITY_EVEN, UART_PARITY_NONE. Default ist lt. Modbus Standart EVEN
101    * @param  usart : Timer Modul, z.B. USART1
102    * @retval None
103  */
104  void mbInit(modbus_t* mb_data, uint32_t baudrate, uint32_t parityMode, uint16_t stopBits, UART_HandleTypeDef* usart)
105  {
106    uint32_t numberOfBitsPerChar;
107    //uint32_t stopBits;
108
109    if (stopBits < 1U || stopBits > 2U) stopBits = 1U;
110
111
112    // Berechne Anzahl der Bits per Char
113    numberOfBitsPerChar = NUMBER_OF_STARTBITS + NUMBER_OF_DATABITS + stopBits;
114    if ((parityMode == MODBUS_UART_PARITY_EVEN) || (parityMode == MODBUS_UART_PARITY_ODD)) 
115    {
116      numberOfBitsPerChar +=1; 
117    }
118     
119    mbUartInit(mb_data,usart, baudrate, parityMode, stopBits, numberOfBitsPerChar);
120
121    // Datenstrukturen zurcksetzen
122    mb_data->last_query_function_code         =   0;
123    mb_data->last_query_tcp_id.w              =   0;
124    mb_data->last_query_number_of_register.w  =   0;
125    mb_data->current_query                    =   MB_QUERY_NOTHING;
126    mb_data->last_query_slave_adress          =   0;
127    mb_data->last_query_start_adress.w        =   0;
128    mb_data->last_query_timeout               =   false;
129  }
130
131  /*
132    *
133    * @brief  Diese Funktion Initialisert die Modbus UART Hardware
134    *
135    * @param  mb_data : Datenstruktur zur Aufnahme aller Daten
136    * @param  usart : UART Modul, z.B. USART1
137    * @param  baudrate : UART BAUD
138    * @param  parityMmode : Parity, mglich ist:
139              UART_PARITY_ODD, UART_PARITY_EVEN, UART_PARITY_NONE.
140              Default ist lt. Modbus Standart EVEN
141    * @param  stopBits : Anzahl der Stop Bits, lt Modbus Standart
142    *         2 Stop Bits bei Parity None, ansonsten 2 Stop Bits
143    * @retval None   
144  */
145  void mbUartInit(modbus_t * mb_data,UART_HandleTypeDef * usart, uint32_t baudrate,  uint32_t parityMode,  uint32_t stopBits , uint32_t nrOfBitsPerChar)
146  {
147    //--- Uart Init ------------------------------------------------------------
148    mb_data->uart      = usart;
149   
150    // Baudrate
151    mb_data->uart->Init.BaudRate   = baudrate;
152
153    // Parity Mode // Word length
154    if(parityMode == MODBUS_UART_PARITY_EVEN)
155    {
156       mb_data->uart->Init.Parity = UART_PARITY_EVEN;
157       mb_data->uart->Init.WordLength = UART_WORDLENGTH_9B;
158    } 
159    else if(parityMode == MODBUS_UART_PARITY_ODD)
160    {
161       mb_data->uart->Init.Parity = UART_PARITY_ODD;
162       mb_data->uart->Init.WordLength = UART_WORDLENGTH_9B;
163    }
164    else
165    {
166       mb_data->uart->Init.Parity = UART_PARITY_NONE;
167       mb_data->uart->Init.WordLength = UART_WORDLENGTH_8B;
168    }
169
170    // Stopbits
171    if (stopBits == 1)
172    { 
173      mb_data->uart->Init.StopBits = UART_STOPBITS_1;
174    }
175    else
176    {
177      mb_data->uart->Init.StopBits = UART_STOPBITS_2;
178    }
179
180        if (HAL_UART_Init(mb_data->uart) != HAL_OK)
181        {
182          Error_Handler();
183        }
184       
185       
186        HAL_UART_EnableReceiverTimeout( usart);
187        HAL_UART_ReceiverTimeout_Config(usart,  3.5 * nrOfBitsPerChar);
188        SET_BIT(usart->Instance->CR1, USART_CR1_RTOIE); 
189
190
191    if(HAL_UART_Receive_DMA(mb_data->uart, mb_data->rx_buffer, RXBUFFERSIZE) != HAL_OK)
192    {
193      printf("uart error \n\r");
194      while(1)
195      {
196      }     
197    }   
198  }
199
200
201
202void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
203{
204    modbusData.mb_rx_frame_complete = 1;
205    modbusData.setRxLed = false;
206        modbusData.rx_head = huart->RxXferSize - __HAL_DMA_GET_COUNTER(huart->hdmarx);
207       
208
209  if (huart->ErrorCode == HAL_UART_ERROR_RTO)
210  {
211
212        // printf("MB RTO Event! \n\r");
213        // Kein Fehler, normale Funktion
214  }
215  if (huart->ErrorCode == HAL_UART_ERROR_FE)
216  {
217        printf("MB FE Error! \n\r");
218  }
219 
220  if (huart->ErrorCode == HAL_UART_ERROR_PE)
221  {
222        printf("MB PE Error! \n\r");
223  }
224
225  if (huart->ErrorCode == HAL_UART_ERROR_NE)
226  {
227        printf("MB NE Error! \n\r");
228  }
229
230  if (huart->ErrorCode == HAL_UART_ERROR_DMA)
231  {
232        printf("MB DMA Error! \n\r");
233  }
234
235  if (huart->ErrorCode == HAL_UART_ERROR_DMA)
236  {
237        printf("MB DMA Error! \n\r");
238  }
239
240  if (huart->ErrorCode == HAL_UART_ERROR_ORE)
241  {
242        printf("MB ORE Error! \n\r");
243  }
244
245
246 
247  if(HAL_UART_Receive_DMA(huart, huart->pRxBuffPtr, RXBUFFERSIZE) != HAL_OK)
248   {
249     printf("Uart Error bei neustart nach Fehler \n\r");
250  //   while(1)
251  //   {
252  //   }     
253   }   
254 
255}
256
257//void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
258//{
259//  //printf("MB rxEvent!RX=%d \n\r",Size);
260//  modbusData.setRxLed = true;
261
262//  modbusData.mb_rx_frame_complete = 1;
263//  modbusData.rx_head= Size +1;
264
265//  if(HAL_UART_Receive_DMA(huart, huart->pRxBuffPtr, RXBUFFERSIZE) != HAL_OK)
266//   {
267//     printf("uart error \n\r");
268//  //   while(1)
269//  //   {
270//  //   }     
271//   }   
272 
273
274//}
275
276void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
277{
278  //printf("uart complete \n\r");
279  modbusData.current_query = MB_QUERY_NOTHING;
280
281}
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303  void mbSend(modbus_t * mb_data )
304  {   
305    mb_data->current_query = MB_QUERY_SEND_DATA;
306    HAL_UART_Transmit_DMA(mb_data->uart, mb_data->tx_buffer, mb_data->tx_head);
307  }
308
309  void mbClearTxBuffer(modbus_t * mb_data)
310  {
311    mb_data->tx_head = 0;
312  }
313
314
315
316  // Compute the MODBUS RTU CRC
317  uint16_t mbCrc16 ( uint8_t *buf, uint32_t len)
318  {
319    uint16_t crc = 0xFFFF;
320
321    for (uint32_t pos = 0; pos < len; pos++) 
322    {
323      crc ^= (uint16_t)buf[pos];          // XOR byte into least sig. byte of crc
324   
325      for (int i = 8; i != 0; i--) 
326      {    // Loop over each bit
327        if ((crc & 0x0001) != 0) 
328        {      // If the LSB is set
329                crc >>= 1;                    // Shift right and XOR 0xA001
330                crc ^= 0xA001;
331        }
332        else                            // Else LSB is not set
333        {
334                crc >>= 1;                    // Just shift right
335        }
336      }
337    }                                   
338 
339    // Note, this number has low and high bytes swapped, so use it accordingly (or swap bytes)
340    return crc; 
341  }
342
343  /* If CRC is correct returns msg_length else returns INVALID_CRC */
344  int mbCheckCrc16( uint8_t *msg, const int msg_length) 
345  {
346    int ret;
347    uint16_t crc_calc;
348    uint16_t crc_received;
349
350    crc_calc = mbCrc16(msg, msg_length - 2);
351    crc_received = (msg[msg_length - 1] << 8) | msg[msg_length - 2];
352
353    // Check CRC of msg
354    if (crc_calc == crc_received) {
355            ret = msg_length;
356    } else {
357            ret = INVALID_CRC;
358    }
359    return ret;
360  }
361
362  uint32_t mbAppendCrc16(uint8_t * buffer, uint32_t tx_position)
363  {
364    uint16_t crc = mbCrc16( buffer , tx_position);
365 
366    uint8_t l_crc = (uint8_t) (crc & 0x00FF) ;
367    uint8_t h_crc = (uint8_t) (crc >> 8);
368    buffer[tx_position] = l_crc;
369    tx_position++;
370    buffer[tx_position] = h_crc; 
371    tx_position++;
372    return tx_position; 
373  }
374
375  /************************************************************************************************************
376  Function: mb_get_frame_complete
377  Purpose:  Rckabe ob Frame komplett empfangen wurde
378  *************************************************************************************************************/
379  bool mbGetFrameComplete(modbus_t * mb_data)
380  {
381          return mb_data->mb_rx_frame_complete;
382  }
383
384  void mbClearRxFrame(modbus_t * mb_data)
385  {
386    // Wieder bei 0 im buffer anfangen
387    mb_data->rx_head = 0;
388 
389    // keine Daten mehr vorhanden
390    mb_data->mb_rx_frame_complete=false; 
391  }
392
393
394  // --------------------- SLAVE FUNCTIONS ---------------------------------------     
395
396#define SEND_TO_SLAVES_BUFFER_COUNT 1000
397//static TASK_MODBUS_MASTER_Message_t xMessage[255];
398//static TASK_MODBUS_MASTER_Message_t *pxMessage;
399static bword_t values[SEND_TO_SLAVES_BUFFER_COUNT];
400static uint32_t y;
401static uint32_t z;
402
403  uint32_t mbSlaveCheckModbusRtuQuery(modbus_t * mb_data)
404  {
405    uint32_t message_lengh;
406    uint8_t *modbus_rx_message;
407    modbus_rx_message = mb_data->rx_buffer;
408    message_lengh= mb_data->rx_head;
409    uint32_t slave_adress;
410    slave_adress = modbus_rx_message[0];
411 
412    if (message_lengh < 5) //Mindestens 5 Zeichen (Slave Adress + Function Code + 2x CRC
413    {
414      mbClearRxFrame(mb_data);
415      return 0;
416    } 
417 
418    // Prfe CRC
419    if (mbCheckCrc16(modbus_rx_message,message_lengh) == INVALID_CRC)
420    {
421      mbClearRxFrame(mb_data);
422      return 0;
423    }
424
425    if  (slave_adress == MODBUS_BROADCAST_ADDRESS)
426    {
427
428      return  RESPOND_TO_QUERY; 
429    } 
430    /* auf richtige Slave Adresse checken ansonsten nicht antworten*/
431    else if (slave_adress == sys_data.s.parameter.slave_address)
432    {
433      return RESPOND_TO_QUERY;
434    }
435   
436    mbClearRxFrame(mb_data);
437    return 0;
438  }
439
440  void mbSlaveProcessRtuQuery(modbus_t * mb_data)
441  {
442    uint32_t tx_position=0; //die _Nchste_ Position in der Zeichen eingefgt werden mssen
443    uint8_t *modbus_rx_message;
444    modbus_rx_message = &mb_data->rx_buffer[0];
445
446    //Vorbereiten auf neues senden
447    mbClearTxBuffer(mb_data);
448 
449    //mb_data->tx_buffer[0] = sys_data.s.vmGreenview.s.lb_slave_adress;
450    mb_data->tx_buffer[0] = *modbus_rx_message;
451    tx_position++;
452    tx_position = mbSlaveProcessPdu(mb_data->tx_buffer , modbus_rx_message,tx_position, *modbus_rx_message);
453 
454    tx_position = mbAppendCrc16(mb_data->tx_buffer ,tx_position);       
455    mb_data->tx_head=tx_position;
456    mbSend(mb_data);   
457    mbClearRxFrame(mb_data);   
458  }
459
460  uint32_t mbSlaveProcessPdu (uint8_t* response_string,    uint8_t * msg,    uint32_t tx_position,     uint8_t deviceID)
461  {
462    uint32_t function_code;
463    uint32_t ret;
464   
465    function_code = msg[OFFSET_FUNCTION_CODE];
466
467    switch (function_code)
468    {
469      case FC_READ_HOLDING_REGISTERS:
470      ret= mbSlaveReadHoldingRegisters(response_string, msg,tx_position, deviceID);
471      break;
472   
473      case FC_WRITE_SINGLE_REGISTER:
474      ret = mbSlaveWriteSingleRegister(response_string, msg,tx_position, deviceID);
475      break;
476   
477      case FC_WRITE_MULTIPLE_REGISTER:
478      ret=mbSlaveWriteMultipleRegisters(response_string, msg,tx_position, deviceID);
479      break;
480   
481      default:
482      ret=mbSlaveResponseException(response_string,function_code,ILLEGAL_FUNCTION,tx_position);
483      break;
484    }
485 
486    return ret;
487  }
488
489
490  uint32_t mbSlaveReadHoldingRegisters( uint8_t * response_string, uint8_t *msg, uint32_t tx_position, uint8_t deviceID)
491  {
492    uint32_t start_adress;
493    uint32_t adress;
494    uint32_t number_of_registers;
495
496    /*stimmt die device ID mit der eigenen berein*/
497    if((deviceID != sys_data.s.parameter.slave_address) && (deviceID != 0))
498    {
499       return mbSlaveResponseException(response_string,FC_WRITE_SINGLE_REGISTER,GATEWAY_PROBLEM_TARGET,tx_position);
500    }
501
502    start_adress = (msg[OFFSET_START_ADRESS_HI] << 8) + msg[OFFSET_START_ADRESS_LO];
503    number_of_registers = ( msg[OFFSET_NO_OF_REGISTERS_HI] << 8) + msg[OFFSET_NO_OF_REGISTERS_LO];
504 
505    if ((number_of_registers < MIN_NUMBER_OF_REGISTERS_FC3) || (number_of_registers > MAX_NUMBER_OF_REGISTERS_FC3) )
506    {
507      return mbSlaveResponseException(response_string,FC_READ_HOLDING_REGISTERS,ILLEGAL_DATA_VALUE,tx_position);
508    }
509 
510    if (start_adress+number_of_registers-1 > MAX_ADRESS) 
511    {
512      return mbSlaveResponseException(response_string, FC_READ_HOLDING_REGISTERS,ILLEGAL_DATA_ADDRESS,tx_position);
513    }   
514
515    response_string[tx_position] = FC_READ_HOLDING_REGISTERS;                                                                                   // FUNCTION CODE
516    tx_position++;
517    response_string[tx_position] = number_of_registers * 2;                                                                                             // Bytes
518    tx_position++;
519
520    for(adress=start_adress;adress < (start_adress + number_of_registers);adress++)
521    {
522      /*Daten aus dem Speicher senden*/
523      response_string[tx_position] = sys_data.mb[adress].b[1];
524      tx_position++;
525      response_string[tx_position] = sys_data.mb[adress].b[0];
526      tx_position++;
527    }
528 
529    return tx_position;
530  }
531
532
533  uint32_t mbSlaveWriteMultipleRegisters(uint8_t * response_string, uint8_t *msg, uint32_t tx_position, uint32_t deviceID)
534  {
535   
536    uint32_t start_adress;
537    uint32_t number_of_registers;
538    uint32_t adress;
539    uint32_t offset;
540
541    /*stimmt die device ID mit der eigenen berein*/
542    if((deviceID != sys_data.s.parameter.slave_address) && (deviceID != 0))
543    {
544       return mbSlaveResponseException(response_string,FC_WRITE_SINGLE_REGISTER,GATEWAY_PROBLEM_TARGET,tx_position);
545    }
546
547    start_adress = (msg[OFFSET_START_ADRESS_HI] << 8) + msg[OFFSET_START_ADRESS_LO];
548    number_of_registers = ( msg[OFFSET_NO_OF_REGISTERS_HI] << 8) + msg[OFFSET_NO_OF_REGISTERS_LO];
549    offset=7;
550
551    if ((number_of_registers < MIN_NUMBER_OF_REGISTERS_FC16) || (number_of_registers > MAX_NUMBER_OF_REGISTERS_FC16) )
552    {
553      return mbSlaveResponseException(response_string, FC_WRITE_MULTIPLE_REGISTER,ILLEGAL_DATA_VALUE,tx_position);
554    }
555
556    if (start_adress+number_of_registers-1 > MAX_ADRESS) 
557    {
558      return mbSlaveResponseException(response_string, FC_WRITE_MULTIPLE_REGISTER,ILLEGAL_DATA_ADDRESS,tx_position);
559    }
560   
561    /*Daten in Gertespeicher schreiben*/
562    for(adress=start_adress;adress < (start_adress + number_of_registers);adress++)
563    { 
564      sys_data.mb[adress].b[1] = msg[offset];
565      sys_data.mb[adress].b[0] = msg[offset+1];
566      offset+=2;
567    }
568
569    response_string[tx_position] = FC_WRITE_MULTIPLE_REGISTER; // FUNCTION CODE - 1 byte
570    tx_position++;
571    response_string[tx_position] = start_adress >> 8; 
572    tx_position++;
573    response_string[tx_position] = (uint8_t ) ( start_adress  & 0x00FF); // start adresse 2 byte
574    tx_position++;
575    response_string[tx_position] = number_of_registers >> 8; 
576    tx_position++;
577    response_string[tx_position] = (uint8_t ) ( number_of_registers  & 0x00FF); // Anzahl Register 2 byte
578    tx_position++;
579    return tx_position;
580  }
581
582
583  uint32_t mbSlaveWriteSingleRegister(uint8_t * response_string,uint8_t *msg,uint32_t tx_position, uint32_t deviceID)
584  {
585 
586    uint32_t adress;
587
588    /*stimmt die device ID mit der eigenen berein*/
589    if((deviceID != sys_data.s.parameter.slave_address) && (deviceID != 0))
590    {
591       return mbSlaveResponseException(response_string,FC_WRITE_SINGLE_REGISTER,GATEWAY_PROBLEM_TARGET,tx_position);
592    }
593
594    adress = (msg[2] << 8) + msg[3];
595
596    if (adress >  MAX_ADRESS) 
597    {
598      return mbSlaveResponseException(response_string,FC_WRITE_SINGLE_REGISTER,ILLEGAL_DATA_ADDRESS,tx_position);
599    }   
600
601    /*schreibe Daten in eigenen Speicher*/
602    sys_data.mb[adress].b[1] = msg[4];
603    sys_data.mb[adress].b[0] = msg[5];
604
605    response_string[tx_position]= FC_WRITE_SINGLE_REGISTER; // FUNCTION CODE
606    tx_position++;
607    response_string[tx_position]= adress >> 8; 
608    tx_position++;
609    response_string[tx_position]= (uint8_t ) ( adress  & 0x00FF);
610   
611    tx_position++;
612    response_string[tx_position]= msg[4]; 
613    tx_position++;
614    response_string[tx_position]= msg[5];
615    tx_position++;
616
617    return tx_position;
618  }
619
620
621  uint32_t mbSlaveResponseException(uint8_t* response_string, uint32_t function_code, uint32_t exception_code,uint32_t tx_position ) 
622  {
623    function_code += 0x80;
624    response_string[tx_position] = function_code; //  FUNCTION CODE
625    tx_position++;
626    response_string[tx_position] = exception_code; //
627    tx_position++;
628    return tx_position;
629  }
630
631
632  //---------------------------- UNKNOWN -----------------------------------------
633  //-                                                                            -
634  //------------------------------------------------------------------------------
635
636#endif
637       
Note: See TracBrowser for help on using the repository browser.