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

Last change on this file since 38 was 27, checked in by f.jahn, 8 weeks ago

Fixing project before CubeMX regeneration.
File size: 20.1 KB
RevLine 
[20]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
[26]36  #define SERVER_FAILURE                  0x04
[20]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
[26]43  #define GATEWAY_PROBLEM_TARGET          0x0B
[20]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 --------------------------------------------
[23]69  extern  modbus_t modbusData;
70  extern  sys_data_t sys_data;
[20]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
[23]111
[20]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;
[23]152
[20]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    }
[23]169
[20]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    }
[23]179
180        if (HAL_UART_Init(mb_data->uart) != HAL_OK)
181        {
[27]182          printf("ERROR Uart INIT\r\n");
[23]183          Error_Handler();
184        }
185       
[24]186       
187        HAL_UART_EnableReceiverTimeout( usart);
[26]188        if (baudrate <= 19200)
189        {
190          HAL_UART_ReceiverTimeout_Config(usart,  3.5 * nrOfBitsPerChar);
191        }
192        else
193        {
194      uint32_t fixedDelayInBitDurations = (FAST_BAUDRATE_INTERFRAME_DELAY_us * baudrate) / 1000000UL + 1UL;
195          HAL_UART_ReceiverTimeout_Config(usart, fixedDelayInBitDurations);
196        }
197
198
[24]199        SET_BIT(usart->Instance->CR1, USART_CR1_RTOIE); 
[20]200
[24]201
202    if(HAL_UART_Receive_DMA(mb_data->uart, mb_data->rx_buffer, RXBUFFERSIZE) != HAL_OK)
[20]203    {
204      printf("uart error \n\r");
205      while(1)
206      {
207      }     
208    }   
209  }
210
211
212
[22]213void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
[20]214{
[23]215    modbusData.mb_rx_frame_complete = 1;
216    modbusData.setRxLed = false;
[24]217        modbusData.rx_head = huart->RxXferSize - __HAL_DMA_GET_COUNTER(huart->hdmarx);
218       
[23]219
[22]220  if (huart->ErrorCode == HAL_UART_ERROR_RTO)
[20]221  {
[24]222
223        // printf("MB RTO Event! \n\r");
224        // Kein Fehler, normale Funktion
[20]225  }
[23]226  if (huart->ErrorCode == HAL_UART_ERROR_FE)
227  {
228        printf("MB FE Error! \n\r");
229  }
230 
231  if (huart->ErrorCode == HAL_UART_ERROR_PE)
232  {
233        printf("MB PE Error! \n\r");
234  }
[20]235
[23]236  if (huart->ErrorCode == HAL_UART_ERROR_NE)
237  {
238        printf("MB NE Error! \n\r");
239  }
240
241  if (huart->ErrorCode == HAL_UART_ERROR_DMA)
242  {
243        printf("MB DMA Error! \n\r");
244  }
245
246  if (huart->ErrorCode == HAL_UART_ERROR_DMA)
247  {
248        printf("MB DMA Error! \n\r");
249  }
250
251  if (huart->ErrorCode == HAL_UART_ERROR_ORE)
252  {
253        printf("MB ORE Error! \n\r");
254  }
255
256
[24]257 
258  if(HAL_UART_Receive_DMA(huart, huart->pRxBuffPtr, RXBUFFERSIZE) != HAL_OK)
[22]259   {
[23]260     printf("Uart Error bei neustart nach Fehler \n\r");
[22]261  //   while(1)
262  //   {
263  //   }     
264   }   
265 
[20]266}
267
[24]268//void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
269//{
270//  //printf("MB rxEvent!RX=%d \n\r",Size);
271//  modbusData.setRxLed = true;
[20]272
[24]273//  modbusData.mb_rx_frame_complete = 1;
274//  modbusData.rx_head= Size +1;
[20]275
[24]276//  if(HAL_UART_Receive_DMA(huart, huart->pRxBuffPtr, RXBUFFERSIZE) != HAL_OK)
277//   {
278//     printf("uart error \n\r");
279//  //   while(1)
280//  //   {
281//  //   }     
282//   }   
[22]283 
[20]284
[24]285//}
[20]286
[23]287void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
288{
289  //printf("uart complete \n\r");
290  modbusData.current_query = MB_QUERY_NOTHING;
[20]291
[23]292}
[20]293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
[23]312
313
[20]314  void mbSend(modbus_t * mb_data )
315  {   
316    mb_data->current_query = MB_QUERY_SEND_DATA;
[23]317    HAL_UART_Transmit_DMA(mb_data->uart, mb_data->tx_buffer, mb_data->tx_head);
[20]318  }
319
320  void mbClearTxBuffer(modbus_t * mb_data)
321  {
322    mb_data->tx_head = 0;
323  }
324
325
326
327  // Compute the MODBUS RTU CRC
328  uint16_t mbCrc16 ( uint8_t *buf, uint32_t len)
329  {
330    uint16_t crc = 0xFFFF;
331
332    for (uint32_t pos = 0; pos < len; pos++) 
333    {
334      crc ^= (uint16_t)buf[pos];          // XOR byte into least sig. byte of crc
335   
336      for (int i = 8; i != 0; i--) 
337      {    // Loop over each bit
338        if ((crc & 0x0001) != 0) 
339        {      // If the LSB is set
340                crc >>= 1;                    // Shift right and XOR 0xA001
341                crc ^= 0xA001;
342        }
343        else                            // Else LSB is not set
344        {
345                crc >>= 1;                    // Just shift right
346        }
347      }
348    }                                   
349 
350    // Note, this number has low and high bytes swapped, so use it accordingly (or swap bytes)
351    return crc; 
352  }
353
354  /* If CRC is correct returns msg_length else returns INVALID_CRC */
355  int mbCheckCrc16( uint8_t *msg, const int msg_length) 
356  {
357    int ret;
358    uint16_t crc_calc;
359    uint16_t crc_received;
360
361    crc_calc = mbCrc16(msg, msg_length - 2);
362    crc_received = (msg[msg_length - 1] << 8) | msg[msg_length - 2];
363
364    // Check CRC of msg
365    if (crc_calc == crc_received) {
366            ret = msg_length;
367    } else {
368            ret = INVALID_CRC;
369    }
370    return ret;
371  }
372
373  uint32_t mbAppendCrc16(uint8_t * buffer, uint32_t tx_position)
374  {
375    uint16_t crc = mbCrc16( buffer , tx_position);
376 
377    uint8_t l_crc = (uint8_t) (crc & 0x00FF) ;
378    uint8_t h_crc = (uint8_t) (crc >> 8);
379    buffer[tx_position] = l_crc;
380    tx_position++;
381    buffer[tx_position] = h_crc; 
382    tx_position++;
383    return tx_position; 
384  }
385
386  /************************************************************************************************************
387  Function: mb_get_frame_complete
388  Purpose:  Rckabe ob Frame komplett empfangen wurde
389  *************************************************************************************************************/
390  bool mbGetFrameComplete(modbus_t * mb_data)
391  {
392          return mb_data->mb_rx_frame_complete;
393  }
394
395  void mbClearRxFrame(modbus_t * mb_data)
396  {
397    // Wieder bei 0 im buffer anfangen
398    mb_data->rx_head = 0;
399 
400    // keine Daten mehr vorhanden
401    mb_data->mb_rx_frame_complete=false; 
402  }
403
404
405  // --------------------- SLAVE FUNCTIONS ---------------------------------------     
406
407#define SEND_TO_SLAVES_BUFFER_COUNT 1000
408//static TASK_MODBUS_MASTER_Message_t xMessage[255];
409//static TASK_MODBUS_MASTER_Message_t *pxMessage;
410static bword_t values[SEND_TO_SLAVES_BUFFER_COUNT];
411static uint32_t y;
412static uint32_t z;
413
414  uint32_t mbSlaveCheckModbusRtuQuery(modbus_t * mb_data)
415  {
416    uint32_t message_lengh;
417    uint8_t *modbus_rx_message;
418    modbus_rx_message = mb_data->rx_buffer;
419    message_lengh= mb_data->rx_head;
420    uint32_t slave_adress;
421    slave_adress = modbus_rx_message[0];
422 
423    if (message_lengh < 5) //Mindestens 5 Zeichen (Slave Adress + Function Code + 2x CRC
424    {
425      mbClearRxFrame(mb_data);
426      return 0;
427    } 
428 
429    // Prfe CRC
430    if (mbCheckCrc16(modbus_rx_message,message_lengh) == INVALID_CRC)
431    {
432      mbClearRxFrame(mb_data);
433      return 0;
434    }
435
436    if  (slave_adress == MODBUS_BROADCAST_ADDRESS)
437    {
438
439      return  RESPOND_TO_QUERY; 
440    } 
441    /* auf richtige Slave Adresse checken ansonsten nicht antworten*/
442    else if (slave_adress == sys_data.s.parameter.slave_address)
443    {
444      return RESPOND_TO_QUERY;
445    }
446   
447    mbClearRxFrame(mb_data);
448    return 0;
449  }
450
451  void mbSlaveProcessRtuQuery(modbus_t * mb_data)
452  {
453    uint32_t tx_position=0; //die _Nchste_ Position in der Zeichen eingefgt werden mssen
454    uint8_t *modbus_rx_message;
455    modbus_rx_message = &mb_data->rx_buffer[0];
456
457    //Vorbereiten auf neues senden
458    mbClearTxBuffer(mb_data);
459 
460    //mb_data->tx_buffer[0] = sys_data.s.vmGreenview.s.lb_slave_adress;
461    mb_data->tx_buffer[0] = *modbus_rx_message;
462    tx_position++;
463    tx_position = mbSlaveProcessPdu(mb_data->tx_buffer , modbus_rx_message,tx_position, *modbus_rx_message);
464 
465    tx_position = mbAppendCrc16(mb_data->tx_buffer ,tx_position);       
466    mb_data->tx_head=tx_position;
467    mbSend(mb_data);   
468    mbClearRxFrame(mb_data);   
469  }
470
471  uint32_t mbSlaveProcessPdu (uint8_t* response_string,    uint8_t * msg,    uint32_t tx_position,     uint8_t deviceID)
472  {
473    uint32_t function_code;
474    uint32_t ret;
475   
476    function_code = msg[OFFSET_FUNCTION_CODE];
477
478    switch (function_code)
479    {
480      case FC_READ_HOLDING_REGISTERS:
481      ret= mbSlaveReadHoldingRegisters(response_string, msg,tx_position, deviceID);
482      break;
483   
484      case FC_WRITE_SINGLE_REGISTER:
485      ret = mbSlaveWriteSingleRegister(response_string, msg,tx_position, deviceID);
486      break;
487   
488      case FC_WRITE_MULTIPLE_REGISTER:
489      ret=mbSlaveWriteMultipleRegisters(response_string, msg,tx_position, deviceID);
490      break;
491   
492      default:
493      ret=mbSlaveResponseException(response_string,function_code,ILLEGAL_FUNCTION,tx_position);
494      break;
495    }
496 
497    return ret;
498  }
499
500
501  uint32_t mbSlaveReadHoldingRegisters( uint8_t * response_string, uint8_t *msg, uint32_t tx_position, uint8_t deviceID)
502  {
503    uint32_t start_adress;
504    uint32_t adress;
505    uint32_t number_of_registers;
506
507    /*stimmt die device ID mit der eigenen berein*/
508    if((deviceID != sys_data.s.parameter.slave_address) && (deviceID != 0))
509    {
510       return mbSlaveResponseException(response_string,FC_WRITE_SINGLE_REGISTER,GATEWAY_PROBLEM_TARGET,tx_position);
511    }
512
513    start_adress = (msg[OFFSET_START_ADRESS_HI] << 8) + msg[OFFSET_START_ADRESS_LO];
514    number_of_registers = ( msg[OFFSET_NO_OF_REGISTERS_HI] << 8) + msg[OFFSET_NO_OF_REGISTERS_LO];
515 
516    if ((number_of_registers < MIN_NUMBER_OF_REGISTERS_FC3) || (number_of_registers > MAX_NUMBER_OF_REGISTERS_FC3) )
517    {
518      return mbSlaveResponseException(response_string,FC_READ_HOLDING_REGISTERS,ILLEGAL_DATA_VALUE,tx_position);
519    }
520 
521    if (start_adress+number_of_registers-1 > MAX_ADRESS) 
522    {
523      return mbSlaveResponseException(response_string, FC_READ_HOLDING_REGISTERS,ILLEGAL_DATA_ADDRESS,tx_position);
524    }   
525
526    response_string[tx_position] = FC_READ_HOLDING_REGISTERS;                                                                                   // FUNCTION CODE
527    tx_position++;
528    response_string[tx_position] = number_of_registers * 2;                                                                                             // Bytes
529    tx_position++;
530
531    for(adress=start_adress;adress < (start_adress + number_of_registers);adress++)
532    {
533      /*Daten aus dem Speicher senden*/
534      response_string[tx_position] = sys_data.mb[adress].b[1];
535      tx_position++;
536      response_string[tx_position] = sys_data.mb[adress].b[0];
537      tx_position++;
538    }
539 
540    return tx_position;
541  }
542
543
544  uint32_t mbSlaveWriteMultipleRegisters(uint8_t * response_string, uint8_t *msg, uint32_t tx_position, uint32_t deviceID)
545  {
546   
547    uint32_t start_adress;
548    uint32_t number_of_registers;
549    uint32_t adress;
550    uint32_t offset;
551
552    /*stimmt die device ID mit der eigenen berein*/
553    if((deviceID != sys_data.s.parameter.slave_address) && (deviceID != 0))
554    {
555       return mbSlaveResponseException(response_string,FC_WRITE_SINGLE_REGISTER,GATEWAY_PROBLEM_TARGET,tx_position);
556    }
557
558    start_adress = (msg[OFFSET_START_ADRESS_HI] << 8) + msg[OFFSET_START_ADRESS_LO];
559    number_of_registers = ( msg[OFFSET_NO_OF_REGISTERS_HI] << 8) + msg[OFFSET_NO_OF_REGISTERS_LO];
560    offset=7;
561
562    if ((number_of_registers < MIN_NUMBER_OF_REGISTERS_FC16) || (number_of_registers > MAX_NUMBER_OF_REGISTERS_FC16) )
563    {
564      return mbSlaveResponseException(response_string, FC_WRITE_MULTIPLE_REGISTER,ILLEGAL_DATA_VALUE,tx_position);
565    }
566
567    if (start_adress+number_of_registers-1 > MAX_ADRESS) 
568    {
569      return mbSlaveResponseException(response_string, FC_WRITE_MULTIPLE_REGISTER,ILLEGAL_DATA_ADDRESS,tx_position);
570    }
571   
572    /*Daten in Gertespeicher schreiben*/
573    for(adress=start_adress;adress < (start_adress + number_of_registers);adress++)
574    { 
575      sys_data.mb[adress].b[1] = msg[offset];
576      sys_data.mb[adress].b[0] = msg[offset+1];
577      offset+=2;
578    }
579
580    response_string[tx_position] = FC_WRITE_MULTIPLE_REGISTER; // FUNCTION CODE - 1 byte
581    tx_position++;
582    response_string[tx_position] = start_adress >> 8; 
583    tx_position++;
584    response_string[tx_position] = (uint8_t ) ( start_adress  & 0x00FF); // start adresse 2 byte
585    tx_position++;
586    response_string[tx_position] = number_of_registers >> 8; 
587    tx_position++;
588    response_string[tx_position] = (uint8_t ) ( number_of_registers  & 0x00FF); // Anzahl Register 2 byte
589    tx_position++;
590    return tx_position;
591  }
592
593
594  uint32_t mbSlaveWriteSingleRegister(uint8_t * response_string,uint8_t *msg,uint32_t tx_position, uint32_t deviceID)
595  {
596 
597    uint32_t adress;
598
599    /*stimmt die device ID mit der eigenen berein*/
600    if((deviceID != sys_data.s.parameter.slave_address) && (deviceID != 0))
601    {
602       return mbSlaveResponseException(response_string,FC_WRITE_SINGLE_REGISTER,GATEWAY_PROBLEM_TARGET,tx_position);
603    }
604
605    adress = (msg[2] << 8) + msg[3];
606
607    if (adress >  MAX_ADRESS) 
608    {
609      return mbSlaveResponseException(response_string,FC_WRITE_SINGLE_REGISTER,ILLEGAL_DATA_ADDRESS,tx_position);
610    }   
611
612    /*schreibe Daten in eigenen Speicher*/
613    sys_data.mb[adress].b[1] = msg[4];
614    sys_data.mb[adress].b[0] = msg[5];
615
616    response_string[tx_position]= FC_WRITE_SINGLE_REGISTER; // FUNCTION CODE
617    tx_position++;
618    response_string[tx_position]= adress >> 8; 
619    tx_position++;
620    response_string[tx_position]= (uint8_t ) ( adress  & 0x00FF);
621   
622    tx_position++;
623    response_string[tx_position]= msg[4]; 
624    tx_position++;
625    response_string[tx_position]= msg[5];
626    tx_position++;
627
628    return tx_position;
629  }
630
631
632  uint32_t mbSlaveResponseException(uint8_t* response_string, uint32_t function_code, uint32_t exception_code,uint32_t tx_position ) 
633  {
634    function_code += 0x80;
635    response_string[tx_position] = function_code; //  FUNCTION CODE
636    tx_position++;
637    response_string[tx_position] = exception_code; //
638    tx_position++;
639    return tx_position;
640  }
641
642
643  //---------------------------- UNKNOWN -----------------------------------------
644  //-                                                                            -
645  //------------------------------------------------------------------------------
646
647#endif
648       
Note: See TracBrowser for help on using the repository browser.