Erick / Mbed 2 deprecated ICE_BLE_TEST

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   NaturalTinyShell_ice libmDot-12Sept mbed-rtos mbed

Fork of ICE by Erick

src/ModbusMaster/ModbusMaster.cpp@106:c0ddba334e93, 2016-09-22 (annotated)

Committer:
davidjhoward
Date:
Thu Sep 22 14:49:32 2016 +0000
Revision:
106:c0ddba334e93
Parent:
99:55317f374a94
Child:
107:e900bd138bf3
more updates to logging

Who changed what in which revision?

UserRevisionLine numberNew contents of line
jmarkel44 0:65cfa4873284 1 /******************************************************************************
davidjhoward 4:c35db3946fd8 2 *
jmarkel44 0:65cfa4873284 3 * File: ModbusMaster.cpp
jmarkel44 0:65cfa4873284 4 * Desciption: source for the ICE Modbus Master
jmarkel44 0:65cfa4873284 5 *
jmarkel44 0:65cfa4873284 6 *****************************************************************************/
jmarkel44 0:65cfa4873284 7 #include "global.h"
jmarkel44 0:65cfa4873284 8 #include <stdio.h>
davidjhoward 99:55317f374a94 9 #include <sstream>
davidjhoward 99:55317f374a94 10 #include <iostream>
davidjhoward 31:4b1587034318 11 #include "MTSLog.h"
jmarkel44 0:65cfa4873284 12 #include "BLEDataHandler.h"
davidjhoward 4:c35db3946fd8 13 #include "ModbusMaster.h"
davidjhoward 8:abe51ae5ef8b 14 #include "MbedJSONValue.h"
davidjhoward 99:55317f374a94 15 #include "CloudFileSender.h"
jmarkel44 0:65cfa4873284 16
davidjhoward 81:d45bfa16953a 17 DigitalOut dout1(PC_1);
davidjhoward 81:d45bfa16953a 18 DigitalOut dout2(PA_1);
davidjhoward 81:d45bfa16953a 19
jmarkel44 0:65cfa4873284 20 /*****************************************************************************
jmarkel44 0:65cfa4873284 21 * Function: ModbusMaster
jmarkel44 0:65cfa4873284 22 * Description: entry point for the Modbus Master
jmarkel44 0:65cfa4873284 23 *
jmarkel44 0:65cfa4873284 24 * @param (IN) args (user-defined arguments)
jmarkel44 0:65cfa4873284 25 * @return none
jmarkel44 0:65cfa4873284 26 *****************************************************************************/
davidjhoward 42:c703a60993b1 27 char ModbusMasterScratchBuf[1024];
jmarkel44 0:65cfa4873284 28 void ModbusMaster(void const *args)
jmarkel44 0:65cfa4873284 29 {
davidjhoward 31:4b1587034318 30 logInfo("%s ModbusMaster has started...", __func__);
davidjhoward 15:a6ee32969e8e 31 bool status;
davidjhoward 81:d45bfa16953a 32 bool input;
davidjhoward 82:f3e495a98877 33 bool move_up = true;
davidjhoward 8:abe51ae5ef8b 34 MbedJSONValue json_value;
davidjhoward 81:d45bfa16953a 35
davidjhoward 54:ec1b03064bbd 36 modbus_init(MB_BAUD_RATE);
davidjhoward 54:ec1b03064bbd 37 DigitalOut flu_power(PA_11);
davidjhoward 54:ec1b03064bbd 38 flu_power = 0; // provide power to the modbus
jmarkel44 0:65cfa4873284 39
davidjhoward 39:9287c7d59016 40 while( true ) {
davidjhoward 8:abe51ae5ef8b 41
davidjhoward 39:9287c7d59016 42 // configure modbus registers based in all files that start with "input"
davidjhoward 39:9287c7d59016 43 std::vector<mDot::mdot_file> file_list = GLOBAL_mdot->listUserFiles();
davidjhoward 39:9287c7d59016 44 for (std::vector<mDot::mdot_file>::iterator i = file_list.begin(); i != file_list.end(); ++i) {
davidjhoward 8:abe51ae5ef8b 45
davidjhoward 81:d45bfa16953a 46 input = true;
davidjhoward 81:d45bfa16953a 47 if( (strncmp( i->name, "input", (strlen("input")-1)) == 0) ||
davidjhoward 81:d45bfa16953a 48 (strncmp( i->name, "output", (strlen("output")-1)) == 0)) {
davidjhoward 8:abe51ae5ef8b 49
davidjhoward 81:d45bfa16953a 50 if( (strncmp( i->name, "output", (strlen("output")-1)) == 0) ) {
davidjhoward 81:d45bfa16953a 51 input = false;
davidjhoward 81:d45bfa16953a 52 }
davidjhoward 81:d45bfa16953a 53
davidjhoward 81:d45bfa16953a 54 logInfo("(%d)FOUND FILE: %s", __LINE__, i->name);
davidjhoward 42:c703a60993b1 55
davidjhoward 49:0456ee2271be 56 status = GLOBAL_mdot->readUserFile(i->name, ModbusMasterScratchBuf, 1024);
davidjhoward 39:9287c7d59016 57 if( status != true ) {
davidjhoward 45:3b9e1923cb15 58 logInfo("(%d)read file failed, status=%d", __LINE__, status);
davidjhoward 39:9287c7d59016 59 } else {
davidjhoward 45:3b9e1923cb15 60 logInfo("(%d)Read File SUCCESS: %s", __LINE__, ModbusMasterScratchBuf );
davidjhoward 39:9287c7d59016 61 }
davidjhoward 81:d45bfa16953a 62
davidjhoward 42:c703a60993b1 63 parse( json_value, ModbusMasterScratchBuf );
davidjhoward 9:ef0ca2f8a8a6 64
davidjhoward 39:9287c7d59016 65 std::string id = json_value["id"].get<std::string>().c_str();
davidjhoward 39:9287c7d59016 66 ModbusRegisterMap[id].name = json_value["name"].get<std::string>().c_str();
davidjhoward 39:9287c7d59016 67 ModbusRegisterMap[id].units = json_value["units"].get<std::string>().c_str();
davidjhoward 39:9287c7d59016 68 ModbusRegisterMap[id].min = atof(json_value["min"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 69 ModbusRegisterMap[id].max = atof(json_value["max"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 70 ModbusRegisterMap[id].node = atoi(json_value["node"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 71 ModbusRegisterMap[id].reg = atoi(json_value["reg"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 72 ModbusRegisterMap[id].rtype = atoi(json_value["rtype"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 73 ModbusRegisterMap[id].type = atoi(json_value["type"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 74 ModbusRegisterMap[id].size = atoi(json_value["size"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 75 ModbusRegisterMap[id].order = atoi(json_value["order"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 76 ModbusRegisterMap[id].fmt = json_value["fmt"].get<std::string>().c_str();
davidjhoward 49:0456ee2271be 77 ModbusRegisterMap[id].rfreq = atoi(json_value["rfreq"].get<std::string>().c_str());
davidjhoward 81:d45bfa16953a 78 ModbusRegisterMap[id].input = input;
davidjhoward 82:f3e495a98877 79 ModbusRegisterMap[id].simulated = false;
davidjhoward 15:a6ee32969e8e 80 }
davidjhoward 4:c35db3946fd8 81 }
davidjhoward 31:4b1587034318 82
davidjhoward 39:9287c7d59016 83 // read modbus registers that have been configured.
davidjhoward 39:9287c7d59016 84 while ( true ) {
davidjhoward 39:9287c7d59016 85
davidjhoward 39:9287c7d59016 86 std::map<std::string, ModbusRegister>::iterator iter;
davidjhoward 39:9287c7d59016 87 for (iter = ModbusRegisterMap.begin(); iter != ModbusRegisterMap.end(); ++iter) {
davidjhoward 82:f3e495a98877 88 if( iter->second.simulated == true ) {
davidjhoward 82:f3e495a98877 89 std::map<std::string, SimulateInput>::iterator iter;
davidjhoward 82:f3e495a98877 90 for (iter = SimulateInputMap.begin(); iter != SimulateInputMap.end(); ++iter) {
davidjhoward 82:f3e495a98877 91 if( (SimulateInputMap[iter->first].min == 0) && (SimulateInputMap[iter->first].max == 0) ) {
davidjhoward 82:f3e495a98877 92 ModbusRegisterMap[iter->first].float_value = SimulateInputMap[iter->first].start_value;
davidjhoward 82:f3e495a98877 93 } else {
davidjhoward 82:f3e495a98877 94 if( ModbusRegisterMap[iter->first].float_value >= SimulateInputMap[iter->first].max ) {
davidjhoward 82:f3e495a98877 95 move_up = false;
davidjhoward 82:f3e495a98877 96 ModbusRegisterMap[iter->first].float_value = ModbusRegisterMap[iter->first].float_value - SimulateInputMap[iter->first].step;
davidjhoward 82:f3e495a98877 97 } else if( ModbusRegisterMap[iter->first].float_value <= SimulateInputMap[iter->first].min ) {
davidjhoward 82:f3e495a98877 98 move_up = true;
davidjhoward 82:f3e495a98877 99 ModbusRegisterMap[iter->first].float_value = ModbusRegisterMap[iter->first].float_value + SimulateInputMap[iter->first].step;
davidjhoward 82:f3e495a98877 100 } else {
davidjhoward 82:f3e495a98877 101 if( move_up == true ) {
davidjhoward 82:f3e495a98877 102 ModbusRegisterMap[iter->first].float_value = ModbusRegisterMap[iter->first].float_value + SimulateInputMap[iter->first].step;
davidjhoward 82:f3e495a98877 103 } else {
davidjhoward 82:f3e495a98877 104 ModbusRegisterMap[iter->first].float_value = ModbusRegisterMap[iter->first].float_value - SimulateInputMap[iter->first].step;
davidjhoward 82:f3e495a98877 105 }
davidjhoward 82:f3e495a98877 106 }
davidjhoward 82:f3e495a98877 107 logInfo("simulating input=%s, value=%2.2f",iter->first.c_str(), ModbusRegisterMap[iter->first].float_value);
davidjhoward 82:f3e495a98877 108 }
davidjhoward 82:f3e495a98877 109 }
davidjhoward 82:f3e495a98877 110 continue;
davidjhoward 82:f3e495a98877 111 }
davidjhoward 81:d45bfa16953a 112 logInfo("Processing node=%d, reg=%d, size=%d, order=%d", iter->second.node, iter->second.reg, iter->second.size, iter->second.order );
davidjhoward 39:9287c7d59016 113 SendModbusCommand(iter->second.node, iter->second.reg, iter->second.size);
davidjhoward 57:5f18ae91c7c7 114 Thread::wait(30);
davidjhoward 39:9287c7d59016 115
davidjhoward 39:9287c7d59016 116 switch( iter->second.type ) {
davidjhoward 39:9287c7d59016 117 case TYPE_32BIT_FLOAT:
davidjhoward 39:9287c7d59016 118 float float_value;
davidjhoward 39:9287c7d59016 119 status = ReadModbus_32bit_float( &float_value, iter->second.order );
davidjhoward 39:9287c7d59016 120 if( status == true ) {
davidjhoward 39:9287c7d59016 121 ModbusRegisterMap[iter->first].float_value = float_value;
davidjhoward 54:ec1b03064bbd 122 logInfo("Modbus Tag:%s value=%2.2f", iter->first.c_str(), float_value );
davidjhoward 99:55317f374a94 123 // std::ostringstream log_event;
davidjhoward 99:55317f374a94 124 // log_event << "tag:"<< iter->first.c_str() << " value:" << float_value;
davidjhoward 99:55317f374a94 125 // printf("%s:%d event=%s\r\n",__func__, __LINE__, log_event.str().c_str());
davidjhoward 99:55317f374a94 126 // std::string queue_event( log_event.str().c_str() );
davidjhoward 99:55317f374a94 127 // CloudFileQueueEvent( queue_event );
davidjhoward 106:c0ddba334e93 128 EventReasonStruct_t eventReason;
davidjhoward 106:c0ddba334e93 129 eventReason.eventReason = EVENT_REASON_AUTO;
davidjhoward 106:c0ddba334e93 130 eventReason.controlType = CONTROL_TYPE_INHIBITOR;
davidjhoward 106:c0ddba334e93 131 eventReason.inputValue = float_value;
davidjhoward 106:c0ddba334e93 132 strncpy(eventReason.inputTag, iter->first.c_str(), sizeof(eventReason.inputTag) );
davidjhoward 106:c0ddba334e93 133 eventReason.outputValue = 0.0;
davidjhoward 106:c0ddba334e93 134 strncpy(eventReason.outputTag, "o_rly1", sizeof(eventReason.outputTag) );
davidjhoward 106:c0ddba334e93 135 EventLoggerApi( eventReason );
davidjhoward 81:d45bfa16953a 136 } else {
davidjhoward 54:ec1b03064bbd 137 logInfo("Modbus Read Failed, tag=%s", iter->first.c_str() );
davidjhoward 39:9287c7d59016 138 }
davidjhoward 39:9287c7d59016 139 break;
davidjhoward 39:9287c7d59016 140 case TYPE_32BIT_INT:
davidjhoward 39:9287c7d59016 141 break;
davidjhoward 39:9287c7d59016 142 case TYPE_32BIT_UINT:
davidjhoward 39:9287c7d59016 143 break;
davidjhoward 39:9287c7d59016 144 case TYPE_16BIT_INT:
davidjhoward 39:9287c7d59016 145 break;
davidjhoward 39:9287c7d59016 146 case TYPE_16BIT_UINT:
davidjhoward 39:9287c7d59016 147 break;
davidjhoward 39:9287c7d59016 148 default:
davidjhoward 39:9287c7d59016 149 break;
davidjhoward 39:9287c7d59016 150 }
davidjhoward 82:f3e495a98877 151
davidjhoward 82:f3e495a98877 152 if( iter->second.input == false ) {
davidjhoward 83:0f76cfbb4eba 153 if( iter->second.node == 0 ) {
davidjhoward 83:0f76cfbb4eba 154 logInfo("processing PIN output=%s, reg=%d, value=%d",iter->first.c_str(), ModbusRegisterMap[iter->first].reg, (bool)ModbusRegisterMap[iter->first].float_value);
davidjhoward 83:0f76cfbb4eba 155 if( ModbusRegisterMap[iter->first].reg == 1 ) {
davidjhoward 83:0f76cfbb4eba 156 dout1 = (bool)ModbusRegisterMap[iter->first].float_value;
davidjhoward 83:0f76cfbb4eba 157 } else {
davidjhoward 83:0f76cfbb4eba 158 dout2 = (bool)ModbusRegisterMap[iter->first].float_value;
davidjhoward 83:0f76cfbb4eba 159 }
jmarkel44 88:8a1a2bba8850 160
davidjhoward 81:d45bfa16953a 161 }
davidjhoward 81:d45bfa16953a 162 }
davidjhoward 39:9287c7d59016 163 }
davidjhoward 39:9287c7d59016 164
davidjhoward 39:9287c7d59016 165 osEvent evt = ModbusMasterMailBox.get(50);
davidjhoward 39:9287c7d59016 166 if (evt.status == osEventMail) {
davidjhoward 39:9287c7d59016 167 Message_t *mail = (Message_t*)evt.value.p;
davidjhoward 39:9287c7d59016 168 logInfo("Mail Received: Action: %d, New Input File: %s", mail->action, mail->controlFile);
davidjhoward 39:9287c7d59016 169 ModbusMasterMailBox.free(mail);
davidjhoward 39:9287c7d59016 170 ModbusRegisterMap.clear();
davidjhoward 39:9287c7d59016 171 break;
davidjhoward 39:9287c7d59016 172 }
davidjhoward 57:5f18ae91c7c7 173 Thread::wait(5000);
davidjhoward 31:4b1587034318 174 }
jmarkel44 0:65cfa4873284 175 }
davidjhoward 4:c35db3946fd8 176 }
davidjhoward 4:c35db3946fd8 177
davidjhoward 4:c35db3946fd8 178
davidjhoward 4:c35db3946fd8 179 volatile char modbus_buffer_char;
davidjhoward 4:c35db3946fd8 180 volatile bool modbus_interrupt_complete = false;
davidjhoward 4:c35db3946fd8 181
davidjhoward 4:c35db3946fd8 182 uint8_t modbus_input_buffer[SIZE_MB_BUFFER];// 1byte address + 1 byte function +1 byte number of regs + 12 bytes of data + 2 bytes for crc response frame from slave
davidjhoward 4:c35db3946fd8 183 volatile uint8_t modbus_input_buffer_counter = 0;
davidjhoward 4:c35db3946fd8 184
davidjhoward 4:c35db3946fd8 185 //Frame crc calucation
davidjhoward 4:c35db3946fd8 186 uint16_t modbus_crc(uint8_t* buf, int len)
davidjhoward 4:c35db3946fd8 187 {
davidjhoward 4:c35db3946fd8 188 uint16_t crc = 0xFFFF;
davidjhoward 4:c35db3946fd8 189
davidjhoward 4:c35db3946fd8 190 for (int pos = 0; pos < len; pos++) {
davidjhoward 4:c35db3946fd8 191 crc ^= (uint16_t)buf[pos]; // XOR byte into least sig. byte of crc
davidjhoward 4:c35db3946fd8 192
davidjhoward 4:c35db3946fd8 193 for (int i = 8; i != 0; i--) {
davidjhoward 4:c35db3946fd8 194 // Loop over each bit
davidjhoward 4:c35db3946fd8 195 if ((crc & 0x0001) != 0) {
davidjhoward 4:c35db3946fd8 196 // If the LSB is set
davidjhoward 4:c35db3946fd8 197 crc >>= 1; // Shift right and XOR 0xA001
davidjhoward 4:c35db3946fd8 198 crc ^= 0xA001;
davidjhoward 4:c35db3946fd8 199 } else // Else LSB is not set
davidjhoward 4:c35db3946fd8 200 crc >>= 1; // Just shift right
davidjhoward 4:c35db3946fd8 201 }
davidjhoward 4:c35db3946fd8 202 }
davidjhoward 4:c35db3946fd8 203 // Note, this number has low and high bytes swapped, so use it accordingly (or swap bytes)
davidjhoward 4:c35db3946fd8 204 return crc;
davidjhoward 4:c35db3946fd8 205 }
davidjhoward 4:c35db3946fd8 206
davidjhoward 4:c35db3946fd8 207 RawSerial modbus(PA_2, PA_3);
davidjhoward 57:5f18ae91c7c7 208 DigitalOut mod_de(PB_0);
davidjhoward 57:5f18ae91c7c7 209 DigitalOut mod_re(PB_1);
davidjhoward 4:c35db3946fd8 210
davidjhoward 4:c35db3946fd8 211 void modbus_init( uint16_t baudRate )
davidjhoward 4:c35db3946fd8 212 {
davidjhoward 4:c35db3946fd8 213 modbus.baud(baudRate);
davidjhoward 4:c35db3946fd8 214 modbus.attach(&modbus_recv, RawSerial::RxIrq);
davidjhoward 4:c35db3946fd8 215 }
davidjhoward 4:c35db3946fd8 216
davidjhoward 4:c35db3946fd8 217 //call back when character goes into RX buffer for RS485 modbus
davidjhoward 4:c35db3946fd8 218 void modbus_recv()
davidjhoward 4:c35db3946fd8 219 {
davidjhoward 4:c35db3946fd8 220
davidjhoward 4:c35db3946fd8 221 if (modbus.readable()) {
davidjhoward 4:c35db3946fd8 222 modbus_buffer_char = modbus.getc();
davidjhoward 4:c35db3946fd8 223 if (modbus_input_buffer_counter == 0 && modbus_buffer_char == 0x00) {
davidjhoward 4:c35db3946fd8 224 modbus_input_buffer_counter = 0;
davidjhoward 4:c35db3946fd8 225 } else {
davidjhoward 4:c35db3946fd8 226 modbus_input_buffer[modbus_input_buffer_counter] = modbus_buffer_char;
davidjhoward 4:c35db3946fd8 227 modbus_input_buffer_counter++;
davidjhoward 4:c35db3946fd8 228 }
davidjhoward 4:c35db3946fd8 229 }
davidjhoward 4:c35db3946fd8 230
davidjhoward 4:c35db3946fd8 231 if (modbus_input_buffer_counter > modbus_input_buffer[2] + 4) {
davidjhoward 4:c35db3946fd8 232 modbus_interrupt_complete = true;
davidjhoward 4:c35db3946fd8 233 modbus_input_buffer_counter = 0;
davidjhoward 4:c35db3946fd8 234 }
davidjhoward 4:c35db3946fd8 235 }
davidjhoward 4:c35db3946fd8 236
davidjhoward 4:c35db3946fd8 237 // Read modbus master frame
davidjhoward 9:ef0ca2f8a8a6 238 void SendModbusCommand(uint8_t slave_address, uint16_t firstReg, uint16_t noRegs)
davidjhoward 4:c35db3946fd8 239 {
davidjhoward 4:c35db3946fd8 240 uint8_t L1V[8] = {slave_address, 0x04, 0x00, 0x02, 0x00, 0x02, 0xD1, 0x16};
davidjhoward 4:c35db3946fd8 241
davidjhoward 4:c35db3946fd8 242 L1V[2] = (firstReg >> 8) & 0xFF;
davidjhoward 4:c35db3946fd8 243 L1V[3] = firstReg & 0xFF;
davidjhoward 4:c35db3946fd8 244 L1V[4] = (noRegs >> 8) & 0xFF;
davidjhoward 4:c35db3946fd8 245 L1V[5] = noRegs & 0xFF;
davidjhoward 4:c35db3946fd8 246 L1V[6] = modbus_crc(L1V,6) & 0xFF;
davidjhoward 4:c35db3946fd8 247 L1V[7] = (modbus_crc(L1V,6)>>8) & 0xFF;
davidjhoward 4:c35db3946fd8 248
davidjhoward 57:5f18ae91c7c7 249 mod_de = 1;
davidjhoward 57:5f18ae91c7c7 250 mod_re = 1;
davidjhoward 57:5f18ae91c7c7 251 Thread::wait(1);
davidjhoward 4:c35db3946fd8 252 for (uint8_t i = 0; i < 8; i++)
davidjhoward 4:c35db3946fd8 253 modbus.putc(L1V[i]);
davidjhoward 4:c35db3946fd8 254
davidjhoward 57:5f18ae91c7c7 255 Thread::wait(2);
davidjhoward 57:5f18ae91c7c7 256 mod_de = 0;
davidjhoward 57:5f18ae91c7c7 257 mod_re = 0;
davidjhoward 4:c35db3946fd8 258
davidjhoward 4:c35db3946fd8 259 }
davidjhoward 4:c35db3946fd8 260
davidjhoward 4:c35db3946fd8 261 bool mbInterruptComplete()
davidjhoward 4:c35db3946fd8 262 {
davidjhoward 4:c35db3946fd8 263 if (modbus_interrupt_complete) {
davidjhoward 4:c35db3946fd8 264 modbus_interrupt_complete = false;
davidjhoward 4:c35db3946fd8 265 return true;
davidjhoward 4:c35db3946fd8 266 } else {
davidjhoward 4:c35db3946fd8 267 return false;
davidjhoward 4:c35db3946fd8 268 }
davidjhoward 4:c35db3946fd8 269 }
davidjhoward 4:c35db3946fd8 270
davidjhoward 15:a6ee32969e8e 271 bool ReadModbus_32bit_float( float *float_value, int order )
davidjhoward 4:c35db3946fd8 272 {
davidjhoward 15:a6ee32969e8e 273 MR_REGISTER_32_BIT_FLOAT value;
davidjhoward 31:4b1587034318 274
davidjhoward 4:c35db3946fd8 275 if (mbInterruptComplete() != true ) {
davidjhoward 4:c35db3946fd8 276 return false;
davidjhoward 4:c35db3946fd8 277 }
davidjhoward 4:c35db3946fd8 278
davidjhoward 15:a6ee32969e8e 279 switch( order ) {
davidjhoward 31:4b1587034318 280 case BigEndian:
davidjhoward 15:a6ee32969e8e 281 value.b.lo_lo = modbus_input_buffer[6];
davidjhoward 15:a6ee32969e8e 282 value.b.lo_hi = modbus_input_buffer[5];
davidjhoward 15:a6ee32969e8e 283 value.b.hi_lo = modbus_input_buffer[4];
davidjhoward 15:a6ee32969e8e 284 value.b.hi_hi = modbus_input_buffer[3];
davidjhoward 15:a6ee32969e8e 285 break;
davidjhoward 15:a6ee32969e8e 286 case BigEndianReverseWord:
davidjhoward 15:a6ee32969e8e 287 value.b.lo_lo = modbus_input_buffer[4];
davidjhoward 15:a6ee32969e8e 288 value.b.lo_hi = modbus_input_buffer[3];
davidjhoward 15:a6ee32969e8e 289 value.b.hi_lo = modbus_input_buffer[6];
davidjhoward 15:a6ee32969e8e 290 value.b.hi_hi = modbus_input_buffer[5];
davidjhoward 15:a6ee32969e8e 291 break;
davidjhoward 15:a6ee32969e8e 292 default:
davidjhoward 15:a6ee32969e8e 293 return false;
davidjhoward 15:a6ee32969e8e 294 }
davidjhoward 15:a6ee32969e8e 295 *float_value = value.f;
davidjhoward 4:c35db3946fd8 296 return true;
davidjhoward 4:c35db3946fd8 297 }