Erick / Mbed 2 deprecated ICE-F412

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:   mbed-rtos mbed

ICE-Application/src/ModbusMaster/ModbusMaster.cpp@1:b2e90cda7a5a, 2017-01-24 (annotated)

Committer:
jmarkel44
Date:
Tue Jan 24 19:06:45 2017 +0000
Revision:
1:b2e90cda7a5a
Parent:
0:61364762ee0e 
Port from IAR F412 project

Who changed what in which revision?

UserRevisionLine numberNew contents of line
jmarkel44 0:61364762ee0e 1 /******************************************************************************
jmarkel44 0:61364762ee0e 2 *
jmarkel44 0:61364762ee0e 3 * File: ModbusMaster.cpp
jmarkel44 0:61364762ee0e 4 * Desciption: source for the ICE Modbus Master
jmarkel44 0:61364762ee0e 5 *
jmarkel44 0:61364762ee0e 6 *****************************************************************************/
jmarkel44 0:61364762ee0e 7 #include "global.h"
jmarkel44 0:61364762ee0e 8 #include <stdio.h>
jmarkel44 0:61364762ee0e 9 #include "BLEDataHandler.h"
jmarkel44 0:61364762ee0e 10 #include "ModbusMaster.h"
jmarkel44 0:61364762ee0e 11 #include "ModbusMasterApi.h"
jmarkel44 0:61364762ee0e 12 #include "CloudDataHandler.h"
jmarkel44 0:61364762ee0e 13 #include "LoggerApi.h"
jmarkel44 0:61364762ee0e 14 #include "mod.h"
jmarkel44 0:61364762ee0e 15 #include "cJSON.h"
jmarkel44 0:61364762ee0e 16 #include "rtc.h"
jmarkel44 0:61364762ee0e 17 #include "rtos.h"
jmarkel44 0:61364762ee0e 18 #include "mbed.h"
jmarkel44 0:61364762ee0e 19 #include "v7_execute.h"
jmarkel44 0:61364762ee0e 20 #include "utilities.h"
jmarkel44 0:61364762ee0e 21
jmarkel44 0:61364762ee0e 22 DigitalOut dout1(PB_0);
jmarkel44 0:61364762ee0e 23 DigitalOut dout2(PB_1);
jmarkel44 0:61364762ee0e 24 DigitalIn flow_switch(PC_12);
jmarkel44 0:61364762ee0e 25 DigitalIn dinp2(PC_11);
jmarkel44 0:61364762ee0e 26
jmarkel44 0:61364762ee0e 27 /*****************************************************************************
jmarkel44 0:61364762ee0e 28 * Function: ModbusMaster
jmarkel44 0:61364762ee0e 29 * Description: entry point for the Modbus Master
jmarkel44 0:61364762ee0e 30 *
jmarkel44 0:61364762ee0e 31 * @param (IN) args (user-defined arguments)
jmarkel44 0:61364762ee0e 32 * @return none
jmarkel44 0:61364762ee0e 33 *****************************************************************************/
jmarkel44 0:61364762ee0e 34 //std::map<std::string,VirtualCommand> VirtualCommandMap;
jmarkel44 0:61364762ee0e 35
jmarkel44 0:61364762ee0e 36 std::map<std::string, VirtualCommand> VirtualCommandMap;
jmarkel44 0:61364762ee0e 37 std::map<std::string, ExecuteJavaScript> ExecuteJavaScriptMap;
jmarkel44 0:61364762ee0e 38 std::map<std::string, HoldingRegister> HoldingRegisterMap;
jmarkel44 0:61364762ee0e 39
jmarkel44 0:61364762ee0e 40 void LoadModbusConfigFile( char *fileName );
jmarkel44 0:61364762ee0e 41 void UpdateSimulatedInput( std::map<std::string, ModbusRegister>::iterator &modMap );
jmarkel44 0:61364762ee0e 42 void UpdateVirtualRegister( std::map<std::string, ModbusRegister>::iterator &modMap );
jmarkel44 0:61364762ee0e 43 void ReadModbusRegister( std::map<std::string, ModbusRegister>::iterator &modMap );
jmarkel44 0:61364762ee0e 44 void ExecuteRegisterCommand( std::string ioString, std::string Command );
jmarkel44 0:61364762ee0e 45 void ExecuteRegisterOperation( std::map<std::string, VirtualCommand>::iterator &cmdMap );
jmarkel44 0:61364762ee0e 46 void UpdateOutputRegister( std::map<std::string, ModbusRegister>::iterator &modMap );
jmarkel44 0:61364762ee0e 47
jmarkel44 0:61364762ee0e 48 char ModbusMasterScratchBuf[MAX_FILE_SIZE];
jmarkel44 0:61364762ee0e 49 void ModbusMaster(void const *args)
jmarkel44 0:61364762ee0e 50 {
jmarkel44 0:61364762ee0e 51 printf("%s ModbusMaster has started...", __func__);
jmarkel44 0:61364762ee0e 52 bool SignaledMain = false;
jmarkel44 0:61364762ee0e 53 std::map<std::string, ModbusRegister>::iterator modMap;
jmarkel44 0:61364762ee0e 54
jmarkel44 0:61364762ee0e 55 mod_init();
jmarkel44 0:61364762ee0e 56 DigitalOut mod_power(PA_8);
jmarkel44 0:61364762ee0e 57 mod_power = 0; // provide power to the modbus
jmarkel44 0:61364762ee0e 58
jmarkel44 0:61364762ee0e 59 #ifdef EXECUTE_SCRIPT
jmarkel44 0:61364762ee0e 60 v7_Create_Engine();
jmarkel44 0:61364762ee0e 61 #endif
jmarkel44 0:61364762ee0e 62
jmarkel44 0:61364762ee0e 63 #ifdef LOAD_PERSISTENT_CONFIGURATIONS
jmarkel44 0:61364762ee0e 64 std::vector<std::string>::iterator file;
jmarkel44 0:61364762ee0e 65 std::vector<std::string> file_list;
jmarkel44 0:61364762ee0e 66 file_list = GLOBAL_mdot->listUserFiles();
jmarkel44 0:61364762ee0e 67 for(file = file_list.begin(); file != file_list.end(); ++file) {
jmarkel44 0:61364762ee0e 68 // printf("%s:%d: filename:%s\r\n", __func__, __LINE__, file->c_str() );
jmarkel44 0:61364762ee0e 69 LoadModbusConfigFile( (char *)file->c_str() );
jmarkel44 0:61364762ee0e 70 }
jmarkel44 0:61364762ee0e 71 #endif
jmarkel44 0:61364762ee0e 72
jmarkel44 0:61364762ee0e 73 while ( true ) {
jmarkel44 0:61364762ee0e 74 for (modMap = ModbusRegisterMap.begin(); modMap != ModbusRegisterMap.end(); ++modMap) {
jmarkel44 0:61364762ee0e 75 if( modMap->second.simulated == true ) {
jmarkel44 0:61364762ee0e 76 UpdateSimulatedInput( modMap );
jmarkel44 0:61364762ee0e 77 continue;
jmarkel44 0:61364762ee0e 78 } else if( modMap->second.node != 0 ) {
jmarkel44 0:61364762ee0e 79 ReadModbusRegister( modMap );
jmarkel44 0:61364762ee0e 80 } else if( (modMap->second.node == 0) && (modMap->second.regType == REG_TYPE_INPUT) ) {
jmarkel44 0:61364762ee0e 81 // printf("processing PIN input=%s, reg=%d, value=%d",modMap->first.c_str(), ModbusRegisterMap[modMap->first].reg, (bool)RegisterValueMap[modMap->first].float_value);
jmarkel44 0:61364762ee0e 82 if( ModbusRegisterMap[modMap->first].reg == 1 ) {
jmarkel44 0:61364762ee0e 83 // digital input
jmarkel44 0:61364762ee0e 84 RegisterValueMap[modMap->first].float_value = (float)flow_switch.read();
jmarkel44 0:61364762ee0e 85 } else {
jmarkel44 0:61364762ee0e 86 RegisterValueMap[modMap->first].float_value = (float)dinp2.read();
jmarkel44 0:61364762ee0e 87 }
jmarkel44 0:61364762ee0e 88 } else if( modMap->second.regType == REG_TYPE_VINPUT ) {
jmarkel44 0:61364762ee0e 89 UpdateVirtualRegister( modMap );
jmarkel44 0:61364762ee0e 90 }
jmarkel44 0:61364762ee0e 91 }
jmarkel44 0:61364762ee0e 92
jmarkel44 0:61364762ee0e 93 // now that all of the modbus registers are updated we can execute the register commands.
jmarkel44 0:61364762ee0e 94 #ifdef EXECUTE_SCRIPT
jmarkel44 0:61364762ee0e 95 std::map<std::string, ExecuteJavaScript>::iterator jsMap;
jmarkel44 0:61364762ee0e 96 for (jsMap = ExecuteJavaScriptMap.begin(); jsMap != ExecuteJavaScriptMap.end(); ++jsMap) {
jmarkel44 0:61364762ee0e 97 // printf("%s:%d: %s\r\n", __func__, __LINE__, Util_getHeapData().c_str());
jmarkel44 0:61364762ee0e 98 v7_Execute_Script( jsMap->second.script, jsMap->second.argv );
jmarkel44 0:61364762ee0e 99 }
jmarkel44 0:61364762ee0e 100 #else
jmarkel44 0:61364762ee0e 101 for (modMap = ModbusRegisterMap.begin(); modMap != ModbusRegisterMap.end(); ++modMap) {
jmarkel44 0:61364762ee0e 102 ExecuteRegisterCommand( modMap->first, modMap->second.cmd );
jmarkel44 0:61364762ee0e 103 }
jmarkel44 0:61364762ee0e 104 #endif
jmarkel44 0:61364762ee0e 105
jmarkel44 0:61364762ee0e 106 // now that all of the inputs and virtuals have been updated, go through the outputs.
jmarkel44 0:61364762ee0e 107 for (modMap = ModbusRegisterMap.begin(); modMap != ModbusRegisterMap.end(); ++modMap) {
jmarkel44 0:61364762ee0e 108 if( modMap->second.regType == REG_TYPE_OUTPUT ) {
jmarkel44 0:61364762ee0e 109 UpdateOutputRegister( modMap );
jmarkel44 0:61364762ee0e 110 }
jmarkel44 0:61364762ee0e 111 }
jmarkel44 0:61364762ee0e 112
jmarkel44 0:61364762ee0e 113 osEvent evt = ModbusMasterMailBox.get(50);
jmarkel44 0:61364762ee0e 114 if (evt.status == osEventMail) {
jmarkel44 0:61364762ee0e 115 ModbusMasterReq_t *mail = (ModbusMasterReq_t*)evt.value.p;
jmarkel44 0:61364762ee0e 116 if( mail->action == ACTION_EXEC_CMD ) {
jmarkel44 0:61364762ee0e 117 printf("Mail Received: Action: %d, Executing Command: %s\r\n", mail->action, mail->msg);
jmarkel44 0:61364762ee0e 118 ModbusMasterExecCmd( mail->replyThread, mail->msg );
jmarkel44 0:61364762ee0e 119 } else {
jmarkel44 0:61364762ee0e 120 printf("Mail Received: Action: %d, New Input File: %s\r\n", mail->action, mail->msg);
jmarkel44 0:61364762ee0e 121 LoadModbusConfigFile( mail->msg );
jmarkel44 0:61364762ee0e 122 }
jmarkel44 0:61364762ee0e 123 ModbusMasterMailBox.free(mail);
jmarkel44 0:61364762ee0e 124 }
jmarkel44 0:61364762ee0e 125 if( SignaledMain == false ) {
jmarkel44 0:61364762ee0e 126 SignaledMain = true;
jmarkel44 0:61364762ee0e 127 osSignalSet(mainThreadId, sig_output_continue);
jmarkel44 0:61364762ee0e 128 }
jmarkel44 0:61364762ee0e 129 Thread::wait(5000);
jmarkel44 0:61364762ee0e 130 }
jmarkel44 0:61364762ee0e 131 }
jmarkel44 0:61364762ee0e 132
jmarkel44 0:61364762ee0e 133 bool ReadModbus_32bit_float( float *float_value, int order, unsigned char *rd_buf )
jmarkel44 0:61364762ee0e 134 {
jmarkel44 0:61364762ee0e 135 MR_REGISTER_32_BIT_FLOAT value;
jmarkel44 0:61364762ee0e 136
jmarkel44 0:61364762ee0e 137 switch( order ) {
jmarkel44 0:61364762ee0e 138 case BigEndian:
jmarkel44 0:61364762ee0e 139 value.b.lo_lo = rd_buf[3];
jmarkel44 0:61364762ee0e 140 value.b.lo_hi = rd_buf[2];
jmarkel44 0:61364762ee0e 141 value.b.hi_lo = rd_buf[1];
jmarkel44 0:61364762ee0e 142 value.b.hi_hi = rd_buf[0];
jmarkel44 0:61364762ee0e 143 break;
jmarkel44 0:61364762ee0e 144 case BigEndianReverseWord:
jmarkel44 0:61364762ee0e 145 value.b.lo_lo = rd_buf[1];
jmarkel44 0:61364762ee0e 146 value.b.lo_hi = rd_buf[0];
jmarkel44 0:61364762ee0e 147 value.b.hi_lo = rd_buf[3];
jmarkel44 0:61364762ee0e 148 value.b.hi_hi = rd_buf[2];
jmarkel44 0:61364762ee0e 149 break;
jmarkel44 0:61364762ee0e 150 default:
jmarkel44 0:61364762ee0e 151 printf("%s:%d: order not supported\r\n",__func__,__LINE__);
jmarkel44 0:61364762ee0e 152 return false;
jmarkel44 0:61364762ee0e 153 }
jmarkel44 0:61364762ee0e 154 // printf("0x%x 0x%x 0x%x 0x%x (%2.4f)\r\n", value.b.hi_hi, value.b.hi_lo, value.b.lo_hi, value.b.lo_lo, value.f);
jmarkel44 0:61364762ee0e 155 *float_value = value.f;
jmarkel44 0:61364762ee0e 156 return true;
jmarkel44 0:61364762ee0e 157 }
jmarkel44 0:61364762ee0e 158
jmarkel44 0:61364762ee0e 159 bool WriteModbus_32bit_float( float float_value, int order, unsigned char *xmt_buf )
jmarkel44 0:61364762ee0e 160 {
jmarkel44 0:61364762ee0e 161 MR_REGISTER_32_BIT_FLOAT value;
jmarkel44 0:61364762ee0e 162
jmarkel44 0:61364762ee0e 163 value.f = float_value;
jmarkel44 0:61364762ee0e 164
jmarkel44 0:61364762ee0e 165 switch( order ) {
jmarkel44 0:61364762ee0e 166 case BigEndian:
jmarkel44 0:61364762ee0e 167 xmt_buf[3] = value.b.lo_lo;
jmarkel44 0:61364762ee0e 168 xmt_buf[2] = value.b.lo_hi;
jmarkel44 0:61364762ee0e 169 xmt_buf[1] = value.b.hi_lo;
jmarkel44 0:61364762ee0e 170 xmt_buf[0] = value.b.hi_hi;
jmarkel44 0:61364762ee0e 171 break;
jmarkel44 0:61364762ee0e 172 case BigEndianReverseWord:
jmarkel44 0:61364762ee0e 173 xmt_buf[1] = value.b.lo_lo;
jmarkel44 0:61364762ee0e 174 xmt_buf[0] = value.b.lo_hi;
jmarkel44 0:61364762ee0e 175 xmt_buf[3] = value.b.hi_lo;
jmarkel44 0:61364762ee0e 176 xmt_buf[2] = value.b.hi_hi;
jmarkel44 0:61364762ee0e 177 break;
jmarkel44 0:61364762ee0e 178 default:
jmarkel44 0:61364762ee0e 179 printf("%s:%d: order not supported\r\n",__func__,__LINE__);
jmarkel44 0:61364762ee0e 180 return false;
jmarkel44 0:61364762ee0e 181 }
jmarkel44 0:61364762ee0e 182 printf("%s:%d: 0x%x 0x%x 0x%x 0x%x (%2.4f)\r\n",__func__,__LINE__, value.b.hi_hi, value.b.hi_lo, value.b.lo_hi, value.b.lo_lo, value.f);
jmarkel44 0:61364762ee0e 183 return true;
jmarkel44 0:61364762ee0e 184 }
jmarkel44 0:61364762ee0e 185
jmarkel44 0:61364762ee0e 186 bool WriteModbus_Multiple( std::vector<uint16_t> XmtData, int order, unsigned char *xmt_buf )
jmarkel44 0:61364762ee0e 187 {
jmarkel44 0:61364762ee0e 188 MR_REGISTER_32_BIT_FLOAT value;
jmarkel44 0:61364762ee0e 189
jmarkel44 0:61364762ee0e 190 // std::vector<uint16_t>::iterator iter;
jmarkel44 0:61364762ee0e 191 // for (iter = XmtData.begin(); iter != XmtData.end(); ++iter) {
jmarkel44 0:61364762ee0e 192 // log_event << "{\"t\":"<< "\"" << iter->c_str() << "\"," << "\"v\":"<< "\"" << ModbusRegisterMap[*iter].float_value<< "\"},";
jmarkel44 0:61364762ee0e 193 // }
jmarkel44 0:61364762ee0e 194
jmarkel44 0:61364762ee0e 195 switch( order ) {
jmarkel44 0:61364762ee0e 196 case BigEndian:
jmarkel44 0:61364762ee0e 197 xmt_buf[3] = value.b.lo_lo;
jmarkel44 0:61364762ee0e 198 xmt_buf[2] = value.b.lo_hi;
jmarkel44 0:61364762ee0e 199 xmt_buf[1] = value.b.hi_lo;
jmarkel44 0:61364762ee0e 200 xmt_buf[0] = value.b.hi_hi;
jmarkel44 0:61364762ee0e 201 break;
jmarkel44 0:61364762ee0e 202 case BigEndianReverseWord:
jmarkel44 0:61364762ee0e 203 xmt_buf[1] = value.b.lo_lo;
jmarkel44 0:61364762ee0e 204 xmt_buf[0] = value.b.lo_hi;
jmarkel44 0:61364762ee0e 205 xmt_buf[3] = value.b.hi_lo;
jmarkel44 0:61364762ee0e 206 xmt_buf[2] = value.b.hi_hi;
jmarkel44 0:61364762ee0e 207 break;
jmarkel44 0:61364762ee0e 208 default:
jmarkel44 0:61364762ee0e 209 printf("%s:%d: order not supported\r\n",__func__,__LINE__);
jmarkel44 0:61364762ee0e 210 return false;
jmarkel44 0:61364762ee0e 211 }
jmarkel44 0:61364762ee0e 212 printf("%s:%d: 0x%x 0x%x 0x%x 0x%x (%2.4f)\r\n",__func__,__LINE__, value.b.hi_hi, value.b.hi_lo, value.b.lo_hi, value.b.lo_lo, value.f);
jmarkel44 0:61364762ee0e 213 return true;
jmarkel44 0:61364762ee0e 214 }
jmarkel44 0:61364762ee0e 215
jmarkel44 0:61364762ee0e 216 bool ReadModbus_32bit_int( int32_t *int32_value, int order, unsigned char *rd_buf )
jmarkel44 0:61364762ee0e 217 {
jmarkel44 0:61364762ee0e 218 MR_REGISTER_32BIT_INT value;
jmarkel44 0:61364762ee0e 219
jmarkel44 0:61364762ee0e 220 switch( order ) {
jmarkel44 0:61364762ee0e 221 case BigEndian:
jmarkel44 0:61364762ee0e 222 value.b.lo_lo = rd_buf[3];
jmarkel44 0:61364762ee0e 223 value.b.lo_hi = rd_buf[2];
jmarkel44 0:61364762ee0e 224 value.b.hi_lo = rd_buf[1];
jmarkel44 0:61364762ee0e 225 value.b.hi_hi = rd_buf[0];
jmarkel44 0:61364762ee0e 226 break;
jmarkel44 0:61364762ee0e 227 case BigEndianReverseWord:
jmarkel44 0:61364762ee0e 228 value.b.lo_lo = rd_buf[1];
jmarkel44 0:61364762ee0e 229 value.b.lo_hi = rd_buf[0];
jmarkel44 0:61364762ee0e 230 value.b.hi_lo = rd_buf[3];
jmarkel44 0:61364762ee0e 231 value.b.hi_hi = rd_buf[2];
jmarkel44 0:61364762ee0e 232 break;
jmarkel44 0:61364762ee0e 233 default:
jmarkel44 0:61364762ee0e 234 printf("%s:%d: order not supported\r\n",__func__,__LINE__);
jmarkel44 0:61364762ee0e 235 return false;
jmarkel44 0:61364762ee0e 236 }
jmarkel44 0:61364762ee0e 237 // printf("0x%x 0x%x 0x%x 0x%x (%d)\r\n", value.b.hi_hi, value.b.hi_lo, value.b.lo_hi, value.b.lo_lo, value.i);
jmarkel44 0:61364762ee0e 238 *int32_value = value.i;
jmarkel44 0:61364762ee0e 239 return true;
jmarkel44 0:61364762ee0e 240 }
jmarkel44 0:61364762ee0e 241
jmarkel44 0:61364762ee0e 242 bool WriteModbus_32bit_int( int32_t int32_value, int order, unsigned char *xmt_buf )
jmarkel44 0:61364762ee0e 243 {
jmarkel44 0:61364762ee0e 244 MR_REGISTER_32BIT_INT value;
jmarkel44 0:61364762ee0e 245
jmarkel44 0:61364762ee0e 246 value.i = int32_value;
jmarkel44 0:61364762ee0e 247
jmarkel44 0:61364762ee0e 248 switch( order ) {
jmarkel44 0:61364762ee0e 249 case BigEndian:
jmarkel44 0:61364762ee0e 250 xmt_buf[3] = value.b.lo_lo;
jmarkel44 0:61364762ee0e 251 xmt_buf[2] = value.b.lo_hi;
jmarkel44 0:61364762ee0e 252 xmt_buf[1] = value.b.hi_lo;
jmarkel44 0:61364762ee0e 253 xmt_buf[0] = value.b.hi_hi;
jmarkel44 0:61364762ee0e 254 break;
jmarkel44 0:61364762ee0e 255 case BigEndianReverseWord:
jmarkel44 0:61364762ee0e 256 xmt_buf[1] = value.b.lo_lo;
jmarkel44 0:61364762ee0e 257 xmt_buf[0] = value.b.lo_hi;
jmarkel44 0:61364762ee0e 258 xmt_buf[3] = value.b.hi_lo;
jmarkel44 0:61364762ee0e 259 xmt_buf[2] = value.b.hi_hi;
jmarkel44 0:61364762ee0e 260 break;
jmarkel44 0:61364762ee0e 261 default:
jmarkel44 0:61364762ee0e 262 printf("%s:%d: order not supported\r\n",__func__,__LINE__);
jmarkel44 0:61364762ee0e 263 return false;
jmarkel44 0:61364762ee0e 264 }
jmarkel44 0:61364762ee0e 265 printf("%s:%d: 0x%x 0x%x 0x%x 0x%x (%d)\r\n", __func__, __LINE__, value.b.hi_hi, value.b.hi_lo, value.b.lo_hi, value.b.lo_lo, value.i);
jmarkel44 0:61364762ee0e 266 return true;
jmarkel44 0:61364762ee0e 267 }
jmarkel44 0:61364762ee0e 268
jmarkel44 0:61364762ee0e 269 bool WriteModbus_16bit_int( int16_t int16_value, int order, unsigned char *xmt_buf )
jmarkel44 0:61364762ee0e 270 {
jmarkel44 0:61364762ee0e 271 MR_REGISTER_16BIT_INT value;
jmarkel44 0:61364762ee0e 272
jmarkel44 0:61364762ee0e 273 value.w = int16_value;
jmarkel44 0:61364762ee0e 274
jmarkel44 0:61364762ee0e 275 switch( order ) {
jmarkel44 0:61364762ee0e 276 case BigEndian:
jmarkel44 0:61364762ee0e 277 case BigEndianReverseWord:
jmarkel44 0:61364762ee0e 278 xmt_buf[1] = value.b.lo;
jmarkel44 0:61364762ee0e 279 xmt_buf[0] = value.b.hi;
jmarkel44 0:61364762ee0e 280 break;
jmarkel44 0:61364762ee0e 281 default:
jmarkel44 0:61364762ee0e 282 printf("%s:%d: order not supported\r\n",__func__,__LINE__);
jmarkel44 0:61364762ee0e 283 return false;
jmarkel44 0:61364762ee0e 284 }
jmarkel44 0:61364762ee0e 285 printf("%s:%d: 0x%x 0x%x (%d)\r\n", __func__,__LINE__, value.b.hi, value.b.lo, value.w);
jmarkel44 0:61364762ee0e 286 return true;
jmarkel44 0:61364762ee0e 287 }
jmarkel44 0:61364762ee0e 288
jmarkel44 0:61364762ee0e 289 void ModbusMasterExecCmd( ThreadName_t replyTo, char *cmd )
jmarkel44 0:61364762ee0e 290 {
jmarkel44 0:61364762ee0e 291 bool status;
jmarkel44 0:61364762ee0e 292 int ret;
jmarkel44 0:61364762ee0e 293 int node, func, sreg, nreg, dtype, order;
jmarkel44 0:61364762ee0e 294 float value;
jmarkel44 0:61364762ee0e 295 unsigned char rd_buf[16];
jmarkel44 0:61364762ee0e 296 std::vector<uint16_t> XmtData;
jmarkel44 0:61364762ee0e 297
jmarkel44 0:61364762ee0e 298 printf("%s:%d: command=%s\r\n", __func__, __LINE__, cmd );
jmarkel44 0:61364762ee0e 299
jmarkel44 0:61364762ee0e 300 cJSON * root = cJSON_Parse(cmd);
jmarkel44 0:61364762ee0e 301 std::string id = cJSON_GetObjectItem(root,"id")->valuestring;
jmarkel44 0:61364762ee0e 302 if ( cJSON_HasObjectItem(root, "holding") ) {
jmarkel44 0:61364762ee0e 303
jmarkel44 0:61364762ee0e 304 std::string key = cJSON_GetObjectItem(root,"holding")->valuestring;
jmarkel44 0:61364762ee0e 305 node = HoldingRegisterMap[key].node;
jmarkel44 0:61364762ee0e 306 sreg = HoldingRegisterMap[key].sreg;
jmarkel44 0:61364762ee0e 307 nreg = HoldingRegisterMap[key].nreg;
jmarkel44 0:61364762ee0e 308 order = HoldingRegisterMap[key].order;
jmarkel44 0:61364762ee0e 309 func = MODBUS_WRITE_MULTIPLE_HOLDING;
jmarkel44 0:61364762ee0e 310 dtype = TYPE_MULTI_BYTE;
jmarkel44 0:61364762ee0e 311 printf("%s:%d: HOLDING REGISTER COMMAND, tag=%s, node=%d, sreg=%d, nreg=%d, order=%d, func=%d\r\n", __func__,__LINE__, key.c_str(), node, sreg, nreg, order, func);
jmarkel44 0:61364762ee0e 312 cJSON *data = cJSON_GetObjectItem(root, "data");
jmarkel44 0:61364762ee0e 313 for ( int i = 0; i < cJSON_GetArraySize(data); ++i ) {
jmarkel44 0:61364762ee0e 314 cJSON *item = cJSON_GetArrayItem(data, i);
jmarkel44 0:61364762ee0e 315 uint16_t item_value = atoi(cJSON_GetObjectItem(item, "v")->valuestring);
jmarkel44 0:61364762ee0e 316 XmtData.push_back(item_value);
jmarkel44 0:61364762ee0e 317 printf("Pushing data: %d\r\n",item_value);
jmarkel44 0:61364762ee0e 318 }
jmarkel44 0:61364762ee0e 319 } else {
jmarkel44 0:61364762ee0e 320 node = atoi(cJSON_GetObjectItem(root,"node")->valuestring);
jmarkel44 0:61364762ee0e 321 func = atoi(cJSON_GetObjectItem(root,"func")->valuestring);
jmarkel44 0:61364762ee0e 322 sreg = atoi(cJSON_GetObjectItem(root,"sreg")->valuestring);
jmarkel44 0:61364762ee0e 323 nreg = atoi(cJSON_GetObjectItem(root,"nreg")->valuestring);
jmarkel44 0:61364762ee0e 324 dtype = atoi(cJSON_GetObjectItem(root,"dtype")->valuestring);
jmarkel44 0:61364762ee0e 325 order = atoi(cJSON_GetObjectItem(root,"order")->valuestring);
jmarkel44 0:61364762ee0e 326 value = atof(cJSON_GetObjectItem(root,"value")->valuestring);
jmarkel44 0:61364762ee0e 327 if( dtype == TYPE_MULTI_BYTE ) {
jmarkel44 0:61364762ee0e 328 if ( cJSON_HasObjectItem(root, "data") ) {
jmarkel44 0:61364762ee0e 329 cJSON *data = cJSON_GetObjectItem(root, "data");
jmarkel44 0:61364762ee0e 330 for ( int i = 0; i < cJSON_GetArraySize(data); ++i ) {
jmarkel44 0:61364762ee0e 331 cJSON *item = cJSON_GetArrayItem(data, i);
jmarkel44 0:61364762ee0e 332 uint16_t item_value = atoi(cJSON_GetObjectItem(item, "v")->valuestring);
jmarkel44 0:61364762ee0e 333 XmtData.push_back(item_value);
jmarkel44 0:61364762ee0e 334 printf("Pushing data: %d\r\n",item_value);
jmarkel44 0:61364762ee0e 335 }
jmarkel44 0:61364762ee0e 336 } else {
jmarkel44 0:61364762ee0e 337 printf("NO DATA FOR WRITE MULTIPLE HOLDING REGISTERS\r\n");
jmarkel44 0:61364762ee0e 338 ReplyToHandler( replyTo, id, DATA_ARRAY_MISSING, 0 );
jmarkel44 0:61364762ee0e 339 return;
jmarkel44 0:61364762ee0e 340 }
jmarkel44 0:61364762ee0e 341 }
jmarkel44 0:61364762ee0e 342 }
jmarkel44 0:61364762ee0e 343 cJSON_Delete(root);
jmarkel44 0:61364762ee0e 344
jmarkel44 0:61364762ee0e 345 switch( func ) {
jmarkel44 0:61364762ee0e 346 case MOD_FUNC_GET_HREG: // read holding register
jmarkel44 0:61364762ee0e 347 case MOD_FUNC_GET_IREG: // read input register
jmarkel44 0:61364762ee0e 348 ret = mod_read(node, func, sreg, nreg, rd_buf);
jmarkel44 0:61364762ee0e 349 if( ret != MOD_ERROR_NONE ) {
jmarkel44 0:61364762ee0e 350 ReplyToHandler( replyTo, id, ret, 0 );
jmarkel44 0:61364762ee0e 351 printf("CMD: %s:%d: %s failed, errflag=%d\r\n", __func__, __LINE__, id.c_str(), ret );
jmarkel44 0:61364762ee0e 352 break;
jmarkel44 0:61364762ee0e 353 }
jmarkel44 0:61364762ee0e 354 switch( dtype ) {
jmarkel44 0:61364762ee0e 355 case TYPE_32BIT_FLOAT: {
jmarkel44 0:61364762ee0e 356 float float_value;
jmarkel44 0:61364762ee0e 357 status = ReadModbus_32bit_float( &float_value, order, rd_buf );
jmarkel44 0:61364762ee0e 358 if( status == true ) {
jmarkel44 0:61364762ee0e 359 printf("CMD: %s:%d: %s value=%2.4f\r\n", __func__, __LINE__, id.c_str(), float_value );
jmarkel44 0:61364762ee0e 360 ret = SUCCESS;
jmarkel44 0:61364762ee0e 361 } else {
jmarkel44 0:61364762ee0e 362 printf("CMD: %s:%d: %s failed\r\n", __func__, __LINE__, id.c_str() );
jmarkel44 0:61364762ee0e 363 ret = ORDER_NOT_SUPPORTED;
jmarkel44 0:61364762ee0e 364 }
jmarkel44 0:61364762ee0e 365 ReplyToHandler( replyTo, id, ret, float_value );
jmarkel44 0:61364762ee0e 366 break;
jmarkel44 0:61364762ee0e 367 }
jmarkel44 0:61364762ee0e 368 case TYPE_32BIT_INT:
jmarkel44 0:61364762ee0e 369 case TYPE_32BIT_UINT: {
jmarkel44 0:61364762ee0e 370 int32_t int32_value;
jmarkel44 0:61364762ee0e 371 status = ReadModbus_32bit_int( &int32_value, order, rd_buf );
jmarkel44 0:61364762ee0e 372 if( status == true ) {
jmarkel44 0:61364762ee0e 373 printf("CMD: %s:%d: %s value=%d\r\n", __func__, __LINE__, id.c_str(), int32_value );
jmarkel44 0:61364762ee0e 374 ret = SUCCESS;
jmarkel44 0:61364762ee0e 375 } else {
jmarkel44 0:61364762ee0e 376 printf("CMD: %s:%d: %s failed\r\n", __func__, __LINE__, id.c_str() );
jmarkel44 0:61364762ee0e 377 ret = ORDER_NOT_SUPPORTED;
jmarkel44 0:61364762ee0e 378 }
jmarkel44 0:61364762ee0e 379 ReplyToHandler( replyTo, id, ret, (float)int32_value );
jmarkel44 0:61364762ee0e 380 break;
jmarkel44 0:61364762ee0e 381 }
jmarkel44 0:61364762ee0e 382 case TYPE_16BIT_INT:
jmarkel44 0:61364762ee0e 383 case TYPE_16BIT_UINT:
jmarkel44 0:61364762ee0e 384 break;
jmarkel44 0:61364762ee0e 385 default:
jmarkel44 0:61364762ee0e 386 break;
jmarkel44 0:61364762ee0e 387 }
jmarkel44 0:61364762ee0e 388 break;
jmarkel44 0:61364762ee0e 389 case MOD_FUNC_SET_HREG: // write holding register
jmarkel44 0:61364762ee0e 390 case MOD_FUNC_SET_HREGS: // write multiple registers (only supports 2 right now)
jmarkel44 0:61364762ee0e 391 case MOD_FUNC_SET_COIL: { // write coil
jmarkel44 0:61364762ee0e 392 unsigned char xmt_buf[10];
jmarkel44 0:61364762ee0e 393 switch( dtype ) {
jmarkel44 0:61364762ee0e 394 case TYPE_32BIT_FLOAT: {
jmarkel44 0:61364762ee0e 395 status = WriteModbus_32bit_float( value, order, xmt_buf );
jmarkel44 0:61364762ee0e 396 if( status != true ) {
jmarkel44 0:61364762ee0e 397 printf("CMD: %s:%d: %s failed\r\n", __func__, __LINE__, id.c_str() );
jmarkel44 0:61364762ee0e 398 return;
jmarkel44 0:61364762ee0e 399 }
jmarkel44 0:61364762ee0e 400 printf("%s:%d: 0x%x 0x%x 0x%x 0x%x\r\n", __func__,__LINE__, xmt_buf[0], xmt_buf[1], xmt_buf[2], xmt_buf[3]);
jmarkel44 0:61364762ee0e 401 break;
jmarkel44 0:61364762ee0e 402 }
jmarkel44 0:61364762ee0e 403 case TYPE_32BIT_INT:
jmarkel44 0:61364762ee0e 404 case TYPE_32BIT_UINT: {
jmarkel44 0:61364762ee0e 405 status = WriteModbus_32bit_int( (int32_t)value, order, xmt_buf );
jmarkel44 0:61364762ee0e 406 if( status != true ) {
jmarkel44 0:61364762ee0e 407 printf("CMD: %s:%d: %s failed\r\n", __func__, __LINE__, id.c_str() );
jmarkel44 0:61364762ee0e 408 return;
jmarkel44 0:61364762ee0e 409 }
jmarkel44 0:61364762ee0e 410 break;
jmarkel44 0:61364762ee0e 411 }
jmarkel44 0:61364762ee0e 412 case TYPE_16BIT_INT:
jmarkel44 0:61364762ee0e 413 case TYPE_16BIT_UINT:
jmarkel44 0:61364762ee0e 414 status = WriteModbus_16bit_int( (int16_t)value, order, xmt_buf );
jmarkel44 0:61364762ee0e 415 if( status != true ) {
jmarkel44 0:61364762ee0e 416 printf("CMD: %s:%d: %s failed\r\n", __func__, __LINE__, id.c_str() );
jmarkel44 0:61364762ee0e 417 return;
jmarkel44 0:61364762ee0e 418 }
jmarkel44 0:61364762ee0e 419 printf("%s:%d: 0x%x 0x%x\r\n", __func__,__LINE__, xmt_buf[0], xmt_buf[1]);
jmarkel44 0:61364762ee0e 420 break;
jmarkel44 0:61364762ee0e 421 case TYPE_MULTI_BYTE :
jmarkel44 0:61364762ee0e 422 printf("CMD: %s:%d: WRITE MULTI-BYTE NOT IMPLEMENTED\r\n", __func__, __LINE__ );
jmarkel44 0:61364762ee0e 423 ReplyToHandler( replyTo, id, UNKNOWN_OPERATION, 0 );
jmarkel44 0:61364762ee0e 424 return;
jmarkel44 0:61364762ee0e 425 //break;
jmarkel44 0:61364762ee0e 426 default:
jmarkel44 0:61364762ee0e 427 printf("CMD: %s:%d: %s NOT IMPLEMENTED\r\n", __func__, __LINE__, id.c_str() );
jmarkel44 0:61364762ee0e 428 return;
jmarkel44 0:61364762ee0e 429 }
jmarkel44 0:61364762ee0e 430 printf("%s:%d: 0x%x 0x%x 0x%x 0x%x\r\n", __func__,__LINE__, xmt_buf[0], xmt_buf[1], xmt_buf[2], xmt_buf[3]);
jmarkel44 0:61364762ee0e 431 ret = mod_write(node, func, sreg, nreg, xmt_buf);
jmarkel44 0:61364762ee0e 432 if( ret != MOD_ERROR_NONE ) {
jmarkel44 0:61364762ee0e 433 printf("CMD: %s:%d: %s failed, errflag=%d\r\n", __func__, __LINE__, id.c_str(), ret );
jmarkel44 0:61364762ee0e 434 } else {
jmarkel44 0:61364762ee0e 435 printf("CMD: %s:%d: %s wrote to modbus func=%d reg=%d value=%2.4f, errflag=%d\r\n", __func__, __LINE__, id.c_str(), func, sreg, value, ret );
jmarkel44 0:61364762ee0e 436 }
jmarkel44 0:61364762ee0e 437 ReplyToHandler( replyTo, id, ret, 0 );
jmarkel44 0:61364762ee0e 438 break;
jmarkel44 0:61364762ee0e 439 }
jmarkel44 0:61364762ee0e 440 default:
jmarkel44 0:61364762ee0e 441 printf("CMD: %s:%d: %s failed, errflag=%d\r\n", __func__, __LINE__, id.c_str(), ret );
jmarkel44 0:61364762ee0e 442 ReplyToHandler( replyTo, id, UNKNOWN_OPERATION, 0 );
jmarkel44 0:61364762ee0e 443 break;
jmarkel44 0:61364762ee0e 444 }
jmarkel44 0:61364762ee0e 445 }
jmarkel44 0:61364762ee0e 446
jmarkel44 0:61364762ee0e 447 void LoadModbusConfigFile( char *fileName )
jmarkel44 0:61364762ee0e 448 {
jmarkel44 0:61364762ee0e 449 bool status;
jmarkel44 0:61364762ee0e 450 RegisterType_t regType;
jmarkel44 0:61364762ee0e 451
jmarkel44 0:61364762ee0e 452 // printf("%s:%d: Loading Config file: %s\r\n", __func__, __LINE__, fileName);
jmarkel44 0:61364762ee0e 453
jmarkel44 0:61364762ee0e 454 if( (strncmp( fileName, "cmd_", (strlen("cmd_")-1)) == 0) ) {
jmarkel44 0:61364762ee0e 455 status = GLOBAL_mdot->readUserFile(fileName, ModbusMasterScratchBuf, MAX_FILE_SIZE);
jmarkel44 0:61364762ee0e 456 if( status != true ) {
jmarkel44 0:61364762ee0e 457 printf("(%d)read file failed, status=%d\r\n", __LINE__, status);
jmarkel44 0:61364762ee0e 458 return;
jmarkel44 0:61364762ee0e 459 }
jmarkel44 0:61364762ee0e 460
jmarkel44 0:61364762ee0e 461 cJSON * root = cJSON_Parse(ModbusMasterScratchBuf);
jmarkel44 0:61364762ee0e 462 std::string id = cJSON_GetObjectItem(root,"id")->valuestring;
jmarkel44 0:61364762ee0e 463 VirtualCommandMap[id].Constant = atof(cJSON_GetObjectItem(root,"Constant")->valuestring);
jmarkel44 0:61364762ee0e 464 VirtualCommandMap[id].Operator = cJSON_GetObjectItem(root,"Operator")->valuestring;
jmarkel44 0:61364762ee0e 465 VirtualCommandMap[id].Operand = cJSON_GetObjectItem(root,"Operand")->valuestring;
jmarkel44 0:61364762ee0e 466 printf("Loaded command file: id=%s, Operand=%s, Operator=%s, Constant=%.4f\r\n", id.c_str(), VirtualCommandMap[id].Operand.c_str(), VirtualCommandMap[id].Operator.c_str(), VirtualCommandMap[id].Constant);
jmarkel44 0:61364762ee0e 467 cJSON_Delete(root);
jmarkel44 0:61364762ee0e 468 return;
jmarkel44 0:61364762ee0e 469 }
jmarkel44 0:61364762ee0e 470
jmarkel44 0:61364762ee0e 471 if( (strncmp( fileName, "vreg_", (strlen("vreg_")-1)) == 0) ) {
jmarkel44 0:61364762ee0e 472 printf("Loading Virtual Register File: %s\r\n", fileName);
jmarkel44 0:61364762ee0e 473 status = GLOBAL_mdot->readUserFile(fileName, ModbusMasterScratchBuf, MAX_FILE_SIZE);
jmarkel44 0:61364762ee0e 474 if( status != true ) {
jmarkel44 0:61364762ee0e 475 printf("(%d)read file failed, status=%d\r\n", __LINE__, status);
jmarkel44 0:61364762ee0e 476 return;
jmarkel44 0:61364762ee0e 477 }
jmarkel44 0:61364762ee0e 478
jmarkel44 0:61364762ee0e 479 cJSON * root = cJSON_Parse(ModbusMasterScratchBuf);
jmarkel44 0:61364762ee0e 480 std::string id = cJSON_GetObjectItem(root,"id")->valuestring;
jmarkel44 0:61364762ee0e 481 RegisterValueMap[id].float_value = atof(cJSON_GetObjectItem(root,"value")->valuestring);
jmarkel44 0:61364762ee0e 482 RegisterValueMap[id].errflag = 0;
jmarkel44 0:61364762ee0e 483 printf("Loaded Virtual Register file: id=%s, value=%.4f\r\n", id.c_str(), RegisterValueMap[id].float_value);
jmarkel44 0:61364762ee0e 484 cJSON_Delete(root);
jmarkel44 0:61364762ee0e 485 return;
jmarkel44 0:61364762ee0e 486 }
jmarkel44 0:61364762ee0e 487
jmarkel44 0:61364762ee0e 488 #ifdef EXECUTE_SCRIPT
jmarkel44 0:61364762ee0e 489 if( (strncmp( fileName, "js_", (strlen("js_")-1)) == 0) ) {
jmarkel44 0:61364762ee0e 490 printf("Loading JavaScript file: %s\r\n", fileName);
jmarkel44 0:61364762ee0e 491 status = GLOBAL_mdot->readUserFile(fileName, ModbusMasterScratchBuf, MAX_FILE_SIZE);
jmarkel44 0:61364762ee0e 492 if( status != true ) {
jmarkel44 0:61364762ee0e 493 printf("(%d)read file failed, status=%d\r\n", __LINE__, status);
jmarkel44 0:61364762ee0e 494 return;
jmarkel44 0:61364762ee0e 495 }
jmarkel44 0:61364762ee0e 496 v7_Load_Script( (const char *)ModbusMasterScratchBuf );
jmarkel44 0:61364762ee0e 497 // printf("Loaded function: %s\r\n", ModbusMasterScratchBuf);
jmarkel44 0:61364762ee0e 498 return;
jmarkel44 0:61364762ee0e 499 }
jmarkel44 0:61364762ee0e 500
jmarkel44 0:61364762ee0e 501 if( (strncmp( fileName, "exe_js_", (strlen("exe_js_")-1)) == 0) ) {
jmarkel44 0:61364762ee0e 502 printf("Loading JavaScript Execution file: %s\r\n", fileName);
jmarkel44 0:61364762ee0e 503 status = GLOBAL_mdot->readUserFile(fileName, ModbusMasterScratchBuf, MAX_FILE_SIZE);
jmarkel44 0:61364762ee0e 504 if( status != true ) {
jmarkel44 0:61364762ee0e 505 printf("(%d)read file failed, status=%d\r\n", __LINE__, status);
jmarkel44 0:61364762ee0e 506 return;
jmarkel44 0:61364762ee0e 507 }
jmarkel44 0:61364762ee0e 508 cJSON * root = cJSON_Parse(ModbusMasterScratchBuf);
jmarkel44 0:61364762ee0e 509 std::string id = cJSON_GetObjectItem(root,"id")->valuestring;
jmarkel44 0:61364762ee0e 510 ExecuteJavaScriptMap[id].script = cJSON_GetObjectItem(root, "script")->valuestring;
jmarkel44 0:61364762ee0e 511 cJSON *args = cJSON_GetObjectItem(root, "args");
jmarkel44 0:61364762ee0e 512 printf("%s:%d: Number of array items: %d\r\n", __func__, __LINE__, cJSON_GetArraySize(args) );
jmarkel44 0:61364762ee0e 513 for ( int i = 0; i < cJSON_GetArraySize(args); ++i ) {
jmarkel44 0:61364762ee0e 514 cJSON *item = cJSON_GetArrayItem(args, i);
jmarkel44 0:61364762ee0e 515 ExecuteJavaScriptMap[id].argv[i] = cJSON_GetObjectItem(item, "arg")->valuestring;
jmarkel44 0:61364762ee0e 516 // printf("Pushing tag data %s\r\n", cJSON_GetObjectItem(item, "arg")->valuestring);
jmarkel44 0:61364762ee0e 517 }
jmarkel44 0:61364762ee0e 518 printf("Loaded JavaScript Execute File: id=%s, script=%s, argv0=%s, argv0=%s, argv0=%s, argv0=%s\r\n", id.c_str(), ExecuteJavaScriptMap[id].script.c_str(), ExecuteJavaScriptMap[id].argv[0].c_str(),ExecuteJavaScriptMap[id].argv[1].c_str(),ExecuteJavaScriptMap[id].argv[2].c_str(),ExecuteJavaScriptMap[id].argv[3].c_str() );
jmarkel44 0:61364762ee0e 519 cJSON_Delete(root);
jmarkel44 0:61364762ee0e 520 return;
jmarkel44 0:61364762ee0e 521 }
jmarkel44 0:61364762ee0e 522 #endif
jmarkel44 0:61364762ee0e 523
jmarkel44 0:61364762ee0e 524 if( (strncmp( fileName, "hold", (strlen("hold")-1)) == 0) ) {
jmarkel44 0:61364762ee0e 525 status = GLOBAL_mdot->readUserFile(fileName, ModbusMasterScratchBuf, MAX_FILE_SIZE);
jmarkel44 0:61364762ee0e 526 if( status != true ) {
jmarkel44 0:61364762ee0e 527 printf("(%d)read file failed, status=%d\r\n", __LINE__, status);
jmarkel44 0:61364762ee0e 528 return;
jmarkel44 0:61364762ee0e 529 }
jmarkel44 0:61364762ee0e 530
jmarkel44 0:61364762ee0e 531 cJSON * root = cJSON_Parse(ModbusMasterScratchBuf);
jmarkel44 0:61364762ee0e 532 std::string id = cJSON_GetObjectItem(root,"id")->valuestring;
jmarkel44 0:61364762ee0e 533 HoldingRegisterMap[id].node = atoi(cJSON_GetObjectItem(root,"node")->valuestring);
jmarkel44 0:61364762ee0e 534 HoldingRegisterMap[id].sreg = atoi(cJSON_GetObjectItem(root,"sreg")->valuestring);
jmarkel44 0:61364762ee0e 535 HoldingRegisterMap[id].nreg = atoi(cJSON_GetObjectItem(root,"nreg")->valuestring);
jmarkel44 0:61364762ee0e 536 HoldingRegisterMap[id].order = atoi(cJSON_GetObjectItem(root,"order")->valuestring);
jmarkel44 0:61364762ee0e 537 printf("Loaded holding register: id=%s, node=%d, sreg=%d, nreg=%d, order=%d\r\n", id.c_str(), HoldingRegisterMap[id].node, HoldingRegisterMap[id].sreg, HoldingRegisterMap[id].nreg, HoldingRegisterMap[id].order);
jmarkel44 0:61364762ee0e 538 cJSON_Delete(root);
jmarkel44 0:61364762ee0e 539 return;
jmarkel44 0:61364762ee0e 540 }
jmarkel44 0:61364762ee0e 541
jmarkel44 0:61364762ee0e 542 regType = REG_TYPE_NONE;
jmarkel44 0:61364762ee0e 543
jmarkel44 0:61364762ee0e 544 if( (strncmp( fileName, "input", (strlen("input")-1)) == 0) ) {
jmarkel44 0:61364762ee0e 545 regType = REG_TYPE_INPUT;
jmarkel44 0:61364762ee0e 546 } else if( (strncmp( fileName, "output", (strlen("output")-1)) == 0) ) {
jmarkel44 0:61364762ee0e 547 regType = REG_TYPE_OUTPUT;
jmarkel44 0:61364762ee0e 548 } else if( (strncmp( fileName, "vinput", (strlen("vinput")-1)) == 0) ) {
jmarkel44 0:61364762ee0e 549 regType = REG_TYPE_VINPUT;
jmarkel44 0:61364762ee0e 550 } else if( (strncmp( fileName, "voutput", (strlen("voutput")-1)) == 0) ) {
jmarkel44 0:61364762ee0e 551 regType = REG_TYPE_VOUTPUT;
jmarkel44 0:61364762ee0e 552 }
jmarkel44 0:61364762ee0e 553
jmarkel44 0:61364762ee0e 554 if( regType != REG_TYPE_NONE ) {
jmarkel44 0:61364762ee0e 555 status = GLOBAL_mdot->readUserFile(fileName, ModbusMasterScratchBuf, MAX_FILE_SIZE);
jmarkel44 0:61364762ee0e 556 if( status != true ) {
jmarkel44 0:61364762ee0e 557 printf("(%d)read file failed, status=%d", __LINE__, status);
jmarkel44 0:61364762ee0e 558 return;
jmarkel44 0:61364762ee0e 559 } else {
jmarkel44 0:61364762ee0e 560 // printf("(%s:%d)loading File: %s\r\n", __func__, __LINE__, fileName );
jmarkel44 0:61364762ee0e 561 // printf("%s:%d:Loaded:%s\r\n", __func__, __LINE__, ModbusMasterScratchBuf );
jmarkel44 0:61364762ee0e 562 }
jmarkel44 0:61364762ee0e 563
jmarkel44 0:61364762ee0e 564 cJSON * root = cJSON_Parse(ModbusMasterScratchBuf);
jmarkel44 0:61364762ee0e 565 if( !cJSON_HasObjectItem(root,"id") )
jmarkel44 0:61364762ee0e 566 {
jmarkel44 0:61364762ee0e 567 printf("%s:%d: INVALID JSON STRING\r\n", __func__,__LINE__);
jmarkel44 0:61364762ee0e 568 return;
jmarkel44 0:61364762ee0e 569 }
jmarkel44 0:61364762ee0e 570 std::string id = cJSON_GetObjectItem(root,"id")->valuestring;
jmarkel44 0:61364762ee0e 571 ModbusRegisterMap[id].min = atof(cJSON_GetObjectItem(root,"min")->valuestring);
jmarkel44 0:61364762ee0e 572 ModbusRegisterMap[id].max = atof(cJSON_GetObjectItem(root,"max")->valuestring);
jmarkel44 0:61364762ee0e 573 ModbusRegisterMap[id].node = atoi(cJSON_GetObjectItem(root,"node")->valuestring);
jmarkel44 0:61364762ee0e 574 ModbusRegisterMap[id].reg = atoi(cJSON_GetObjectItem(root,"reg")->valuestring);
jmarkel44 0:61364762ee0e 575 ModbusRegisterMap[id].rtype = atoi(cJSON_GetObjectItem(root,"rtype")->valuestring);
jmarkel44 0:61364762ee0e 576 ModbusRegisterMap[id].type = atoi(cJSON_GetObjectItem(root,"type")->valuestring);
jmarkel44 0:61364762ee0e 577 ModbusRegisterMap[id].size = atoi(cJSON_GetObjectItem(root,"size")->valuestring);
jmarkel44 0:61364762ee0e 578 ModbusRegisterMap[id].order = atoi(cJSON_GetObjectItem(root,"order")->valuestring);
jmarkel44 0:61364762ee0e 579 ModbusRegisterMap[id].rfreq = atoi(cJSON_GetObjectItem(root,"rfreq")->valuestring);
jmarkel44 0:61364762ee0e 580 ModbusRegisterMap[id].regType = regType;
jmarkel44 0:61364762ee0e 581 ModbusRegisterMap[id].simulated = false;
jmarkel44 0:61364762ee0e 582 RegisterValueMap[id].errflag = 0;
jmarkel44 0:61364762ee0e 583 ModbusRegisterMap[id].cmd = cJSON_GetObjectItem(root,"cmd")->valuestring;
jmarkel44 0:61364762ee0e 584 cJSON_Delete(root);;
jmarkel44 0:61364762ee0e 585 }
jmarkel44 0:61364762ee0e 586 return;
jmarkel44 0:61364762ee0e 587 }
jmarkel44 0:61364762ee0e 588
jmarkel44 0:61364762ee0e 589 void UpdateSimulatedInput( std::map<std::string, ModbusRegister>::iterator &modMap )
jmarkel44 0:61364762ee0e 590 {
jmarkel44 0:61364762ee0e 591 if ( SimulateInputMap[modMap->first].errflag ) {
jmarkel44 0:61364762ee0e 592 RegisterValueMap[modMap->first].errflag = SimulateInputMap[modMap->first].errflag;
jmarkel44 0:61364762ee0e 593 } else {
jmarkel44 0:61364762ee0e 594 RegisterValueMap[modMap->first].errflag = 0;
jmarkel44 0:61364762ee0e 595 }
jmarkel44 0:61364762ee0e 596 // printf("\r\nsimulating input=%s, min=%2.4f, max=%2.4f, start_value=%2.4f, up_step=%2.4f, down_step=%2.4f moving_up=%d\r\n",modMap->first.c_str(), SimulateInputMap[modMap->first].min, SimulateInputMap[modMap->first].max, SimulateInputMap[modMap->first].start_value, SimulateInputMap[modMap->first].up_step, SimulateInputMap[modMap->first].down_step, SimulateInputMap[modMap->first].moving_up);
jmarkel44 0:61364762ee0e 597 if( (SimulateInputMap[modMap->first].min == 0) && (SimulateInputMap[modMap->first].max == 0) ) {
jmarkel44 0:61364762ee0e 598 RegisterValueMap[modMap->first].float_value = SimulateInputMap[modMap->first].start_value;
jmarkel44 0:61364762ee0e 599 // printf("simulating input=%s, value=%2.4f\r\n",modMap->first.c_str(), RegisterValueMap[modMap->first].float_value);
jmarkel44 0:61364762ee0e 600 } else {
jmarkel44 0:61364762ee0e 601 if( RegisterValueMap[modMap->first].float_value >= SimulateInputMap[modMap->first].max ) {
jmarkel44 0:61364762ee0e 602 SimulateInputMap[modMap->first].moving_up = false;
jmarkel44 0:61364762ee0e 603 // printf("simulating down input=%s, value=%2.4f - %2.4f\r\n",modMap->first.c_str(), RegisterValueMap[modMap->first].float_value, SimulateInputMap[modMap->first].down_step);
jmarkel44 0:61364762ee0e 604 RegisterValueMap[modMap->first].float_value = RegisterValueMap[modMap->first].float_value - SimulateInputMap[modMap->first].down_step;
jmarkel44 0:61364762ee0e 605 } else if( RegisterValueMap[modMap->first].float_value <= SimulateInputMap[modMap->first].min ) {
jmarkel44 0:61364762ee0e 606 SimulateInputMap[modMap->first].moving_up = true;
jmarkel44 0:61364762ee0e 607 // printf("simulating up input=%s, value=%2.4f + %2.4f\r\n",modMap->first.c_str(), RegisterValueMap[modMap->first].float_value, SimulateInputMap[modMap->first].up_step);
jmarkel44 0:61364762ee0e 608 RegisterValueMap[modMap->first].float_value = RegisterValueMap[modMap->first].float_value + SimulateInputMap[modMap->first].up_step;
jmarkel44 0:61364762ee0e 609 } else {
jmarkel44 0:61364762ee0e 610 if( SimulateInputMap[modMap->first].moving_up == true ) {
jmarkel44 0:61364762ee0e 611 // printf("continue simulate up input=%s, value=%2.4f + %2.4f\r\n",modMap->first.c_str(), RegisterValueMap[modMap->first].float_value, SimulateInputMap[modMap->first].up_step);
jmarkel44 0:61364762ee0e 612 RegisterValueMap[modMap->first].float_value = RegisterValueMap[modMap->first].float_value + SimulateInputMap[modMap->first].up_step;
jmarkel44 0:61364762ee0e 613 } else {
jmarkel44 0:61364762ee0e 614 // printf("continue simulate down input=%s, value=%2.4f - %2.4f\r\n",modMap->first.c_str(), RegisterValueMap[modMap->first].float_value, SimulateInputMap[modMap->first].down_step);
jmarkel44 0:61364762ee0e 615 RegisterValueMap[modMap->first].float_value = RegisterValueMap[modMap->first].float_value - SimulateInputMap[modMap->first].down_step;
jmarkel44 0:61364762ee0e 616 }
jmarkel44 0:61364762ee0e 617 }
jmarkel44 0:61364762ee0e 618 // printf("simulating input=%s, value=%2.4f\r\n\r\n",modMap->first.c_str(), RegisterValueMap[modMap->first].float_value);
jmarkel44 0:61364762ee0e 619 }
jmarkel44 0:61364762ee0e 620 }
jmarkel44 0:61364762ee0e 621
jmarkel44 0:61364762ee0e 622 void UpdateVirtualRegister( std::map<std::string, ModbusRegister>::iterator &modMap )
jmarkel44 0:61364762ee0e 623 {
jmarkel44 0:61364762ee0e 624 }
jmarkel44 0:61364762ee0e 625
jmarkel44 0:61364762ee0e 626 void ReadModbusRegister( std::map<std::string, ModbusRegister>::iterator &modMap )
jmarkel44 0:61364762ee0e 627 {
jmarkel44 0:61364762ee0e 628 bool status;
jmarkel44 0:61364762ee0e 629 unsigned char rd_buf[16];
jmarkel44 0:61364762ee0e 630 memset( rd_buf, 0, 16 );
jmarkel44 0:61364762ee0e 631 // printf("Processing Input: tag=%s, node=%d, reg=%d, size=%d, order=%d", modMap->first.c_str(), modMap->second.node, modMap->second.reg, modMap->second.size, modMap->second.order );
jmarkel44 0:61364762ee0e 632 int ret = mod_read(modMap->second.node, modMap->second.rtype, modMap->second.reg, modMap->second.size, rd_buf);
jmarkel44 0:61364762ee0e 633 switch( modMap->second.type ) {
jmarkel44 0:61364762ee0e 634 case TYPE_32BIT_FLOAT:
jmarkel44 0:61364762ee0e 635 float float_value;
jmarkel44 0:61364762ee0e 636 if( ret != MOD_ERROR_NONE ) {
jmarkel44 0:61364762ee0e 637 RegisterValueMap[modMap->first].errflag = ret;
jmarkel44 0:61364762ee0e 638 break;
jmarkel44 0:61364762ee0e 639 }
jmarkel44 0:61364762ee0e 640 status = ReadModbus_32bit_float( &float_value, modMap->second.order, rd_buf );
jmarkel44 0:61364762ee0e 641 if( status == true ) {
jmarkel44 0:61364762ee0e 642 RegisterValueMap[modMap->first].float_value = float_value;
jmarkel44 0:61364762ee0e 643 RegisterValueMap[modMap->first].errflag = 0;
jmarkel44 0:61364762ee0e 644 // printf("Modbus Tag:%s value=%2.4f", modMap->first.c_str(), float_value );
jmarkel44 0:61364762ee0e 645 } else {
jmarkel44 0:61364762ee0e 646 RegisterValueMap[modMap->first].errflag = 1000;
jmarkel44 0:61364762ee0e 647 // printf("Modbus Read Failed, tag=%s", modMap->first.c_str() );
jmarkel44 0:61364762ee0e 648 }
jmarkel44 0:61364762ee0e 649 break;
jmarkel44 0:61364762ee0e 650 case TYPE_32BIT_INT:
jmarkel44 0:61364762ee0e 651 int32_t int32_value;
jmarkel44 0:61364762ee0e 652 if( ret != MOD_ERROR_NONE ) {
jmarkel44 0:61364762ee0e 653 RegisterValueMap[modMap->first].errflag = ret;
jmarkel44 0:61364762ee0e 654 break;
jmarkel44 0:61364762ee0e 655 }
jmarkel44 0:61364762ee0e 656 status = ReadModbus_32bit_int( &int32_value, modMap->second.order, rd_buf );
jmarkel44 0:61364762ee0e 657 if( status == true ) {
jmarkel44 0:61364762ee0e 658 RegisterValueMap[modMap->first].float_value = int32_value;
jmarkel44 0:61364762ee0e 659 RegisterValueMap[modMap->first].errflag = 0;
jmarkel44 0:61364762ee0e 660 printf("Modbus Tag:%s value=%2.4f", modMap->first.c_str(), RegisterValueMap[modMap->first].float_value );
jmarkel44 0:61364762ee0e 661 } else {
jmarkel44 0:61364762ee0e 662 RegisterValueMap[modMap->first].errflag = 1000;
jmarkel44 0:61364762ee0e 663 printf("Modbus Read Failed, tag=%s", modMap->first.c_str() );
jmarkel44 0:61364762ee0e 664 }
jmarkel44 0:61364762ee0e 665 break;
jmarkel44 0:61364762ee0e 666 case TYPE_32BIT_UINT:
jmarkel44 0:61364762ee0e 667 break;
jmarkel44 0:61364762ee0e 668 case TYPE_16BIT_INT:
jmarkel44 0:61364762ee0e 669 break;
jmarkel44 0:61364762ee0e 670 case TYPE_16BIT_UINT:
jmarkel44 0:61364762ee0e 671 break;
jmarkel44 0:61364762ee0e 672 default:
jmarkel44 0:61364762ee0e 673 break;
jmarkel44 0:61364762ee0e 674 }
jmarkel44 0:61364762ee0e 675 }
jmarkel44 0:61364762ee0e 676
jmarkel44 0:61364762ee0e 677 void ExecuteRegisterCommand( std::string ioTag, std::string Command )
jmarkel44 0:61364762ee0e 678 {
jmarkel44 0:61364762ee0e 679 if( Command.size() == 0 ) {
jmarkel44 0:61364762ee0e 680 return;
jmarkel44 0:61364762ee0e 681 }
jmarkel44 0:61364762ee0e 682 // printf("Executing Register Commnand: %s for %s\r\n",Command.c_str(), ioTag.c_str());
jmarkel44 0:61364762ee0e 683 float operandValue = 0;
jmarkel44 0:61364762ee0e 684 float ioTagValue = RegisterValueMap[ioTag].float_value;
jmarkel44 0:61364762ee0e 685 if( VirtualCommandMap[Command].Operand.size() != 0 ) {
jmarkel44 0:61364762ee0e 686 operandValue = RegisterValueMap[VirtualCommandMap[Command].Operand].float_value;
jmarkel44 0:61364762ee0e 687 }
jmarkel44 0:61364762ee0e 688 float constantValue = VirtualCommandMap[Command].Constant;
jmarkel44 0:61364762ee0e 689
jmarkel44 0:61364762ee0e 690 switch( VirtualCommandMap[Command].Operator.c_str()[0] ) {
jmarkel44 0:61364762ee0e 691 case '=':
jmarkel44 0:61364762ee0e 692 if( VirtualCommandMap[Command].Operand.size() == 0 ) {
jmarkel44 0:61364762ee0e 693 RegisterValueMap[ioTag].float_value = constantValue;
jmarkel44 0:61364762ee0e 694 } else {
jmarkel44 0:61364762ee0e 695 RegisterValueMap[ioTag].float_value = operandValue;
jmarkel44 0:61364762ee0e 696 }
jmarkel44 0:61364762ee0e 697 // printf("Setting tag=%s, equal to (value=%2.4f)\r\n", ioTag.c_str(), ModbusRegisterMap[ioTag].float_value );
jmarkel44 0:61364762ee0e 698 break;
jmarkel44 0:61364762ee0e 699 case '*': {
jmarkel44 0:61364762ee0e 700 if( VirtualCommandMap[Command].Operand.size() == 0 ) {
jmarkel44 0:61364762ee0e 701 RegisterValueMap[ioTag].float_value = ioTagValue * constantValue;
jmarkel44 0:61364762ee0e 702 // printf("Setting tag=%s, equal to (%2.4f*%2.4f) = %2.4f\r\n", ioTag.c_str(), ioTagValue, constantValue, ModbusRegisterMap[ioTag].float_value );
jmarkel44 0:61364762ee0e 703 } else {
jmarkel44 0:61364762ee0e 704 RegisterValueMap[ioTag].float_value = ioTagValue * operandValue;
jmarkel44 0:61364762ee0e 705 // printf("Setting tag=%s, equal to (%2.4f*%2.4f) = %2.4f\r\n", ioTag.c_str(), ioTagValue, operandValue, ModbusRegisterMap[ioTag].float_value );
jmarkel44 0:61364762ee0e 706 }
jmarkel44 0:61364762ee0e 707 break;
jmarkel44 0:61364762ee0e 708 }
jmarkel44 0:61364762ee0e 709 case '/': {
jmarkel44 0:61364762ee0e 710 if( VirtualCommandMap[Command].Operand.size() == 0 ) {
jmarkel44 0:61364762ee0e 711 // constant operation
jmarkel44 0:61364762ee0e 712 RegisterValueMap[ioTag].float_value = ioTagValue / constantValue;
jmarkel44 0:61364762ee0e 713 // printf("Setting tag=%s, equal to (%2.4f/%2.4f) = %2.4f\r\n", ioTag.c_str(), ioTagValue, constantValue, ModbusRegisterMap[ioTag].float_value );
jmarkel44 0:61364762ee0e 714 } else if( operandValue != 0 ) {
jmarkel44 0:61364762ee0e 715 RegisterValueMap[ioTag].float_value = ioTagValue / operandValue;
jmarkel44 0:61364762ee0e 716 // printf("Setting tag=%s, equal to (%2.4f/%2.4f) = %2.4f\r\n", ioTag.c_str(), ioTagValue, operandValue, ModbusRegisterMap[ioTag].float_value );
jmarkel44 0:61364762ee0e 717 } else {
jmarkel44 0:61364762ee0e 718 // printf("NOT DOING DIVIDE BY ZERO\r\n");
jmarkel44 0:61364762ee0e 719 }
jmarkel44 0:61364762ee0e 720 break;
jmarkel44 0:61364762ee0e 721 }
jmarkel44 0:61364762ee0e 722 case '+': {
jmarkel44 0:61364762ee0e 723 if( VirtualCommandMap[Command].Operand.size() == 0 ) {
jmarkel44 0:61364762ee0e 724 RegisterValueMap[ioTag].float_value = ioTagValue + constantValue;
jmarkel44 0:61364762ee0e 725 // printf("Setting tag=%s, equal to (%2.4f+%2.4f) = %2.4f\r\n", ioTag.c_str(), ioTagValue, constantValue, ModbusRegisterMap[ioTag].float_value );
jmarkel44 0:61364762ee0e 726 } else {
jmarkel44 0:61364762ee0e 727 RegisterValueMap[ioTag].float_value = ioTagValue + operandValue;
jmarkel44 0:61364762ee0e 728 // printf("Setting tag=%s, equal to (%2.4f+%2.4f) = %2.4f\r\n", ioTag.c_str(), ioTagValue, operandValue, ModbusRegisterMap[ioTag].float_value );
jmarkel44 0:61364762ee0e 729 }
jmarkel44 0:61364762ee0e 730 break;
jmarkel44 0:61364762ee0e 731 }
jmarkel44 0:61364762ee0e 732 case '-': {
jmarkel44 0:61364762ee0e 733 if( VirtualCommandMap[Command].Operand.size() == 0 ) {
jmarkel44 0:61364762ee0e 734 RegisterValueMap[ioTag].float_value = ioTagValue - constantValue;
jmarkel44 0:61364762ee0e 735 // printf("Setting tag=%s, equal to (%2.4f-%2.4f) = %2.4f\r\n", ioTag.c_str(), ioTagValue, constantValue, ModbusRegisterMap[ioTag].float_value );
jmarkel44 0:61364762ee0e 736 } else {
jmarkel44 0:61364762ee0e 737 RegisterValueMap[ioTag].float_value = ioTagValue - operandValue;
jmarkel44 0:61364762ee0e 738 // printf("Setting tag=%s, equal to (%2.4f-%2.4f) = %2.4f\r\n", ioTag.c_str(), ioTagValue, operandValue, ModbusRegisterMap[ioTag].float_value );
jmarkel44 0:61364762ee0e 739 }
jmarkel44 0:61364762ee0e 740 break;
jmarkel44 0:61364762ee0e 741 }
jmarkel44 0:61364762ee0e 742 default:
jmarkel44 0:61364762ee0e 743 printf("OPERATION NOT SUPPORTED: %s\r\n", VirtualCommandMap[Command].Operator.c_str());
jmarkel44 0:61364762ee0e 744 break;
jmarkel44 0:61364762ee0e 745 }
jmarkel44 0:61364762ee0e 746 }
jmarkel44 0:61364762ee0e 747
jmarkel44 0:61364762ee0e 748 void UpdateOutputRegister( std::map<std::string, ModbusRegister>::iterator &modMap )
jmarkel44 0:61364762ee0e 749 {
jmarkel44 0:61364762ee0e 750 bool status;
jmarkel44 0:61364762ee0e 751 int ret;
jmarkel44 0:61364762ee0e 752
jmarkel44 0:61364762ee0e 753 if( modMap->second.node == 0) {
jmarkel44 0:61364762ee0e 754 if( ModbusRegisterMap[modMap->first].reg == 1 ) {
jmarkel44 0:61364762ee0e 755 dout1 = (bool)((int)RegisterValueMap[modMap->first].float_value&0x1);
jmarkel44 0:61364762ee0e 756 } else {
jmarkel44 0:61364762ee0e 757 dout2 = (bool)((int)RegisterValueMap[modMap->first].float_value&0x1);
jmarkel44 0:61364762ee0e 758 }
jmarkel44 0:61364762ee0e 759 } else {
jmarkel44 0:61364762ee0e 760 unsigned char xmt_buf[10];
jmarkel44 0:61364762ee0e 761
jmarkel44 0:61364762ee0e 762 switch( ModbusRegisterMap[modMap->first].type ) {
jmarkel44 0:61364762ee0e 763 case TYPE_32BIT_FLOAT: {
jmarkel44 0:61364762ee0e 764 status = WriteModbus_32bit_float( RegisterValueMap[modMap->first].float_value, ModbusRegisterMap[modMap->first].order, xmt_buf );
jmarkel44 0:61364762ee0e 765 if( status != true ) {
jmarkel44 0:61364762ee0e 766 printf("CMD: %s:%d: failed\r\n", __func__, __LINE__);
jmarkel44 0:61364762ee0e 767 return;
jmarkel44 0:61364762ee0e 768 }
jmarkel44 0:61364762ee0e 769 printf("%s:%d: 0x%x 0x%x 0x%x 0x%x\r\n", __func__,__LINE__, xmt_buf[0], xmt_buf[1], xmt_buf[2], xmt_buf[3]);
jmarkel44 0:61364762ee0e 770 break;
jmarkel44 0:61364762ee0e 771 }
jmarkel44 0:61364762ee0e 772 case TYPE_32BIT_INT:
jmarkel44 0:61364762ee0e 773 case TYPE_32BIT_UINT: {
jmarkel44 0:61364762ee0e 774 status = WriteModbus_32bit_int( ((int32_t)RegisterValueMap[modMap->first].float_value&0x1), ModbusRegisterMap[modMap->first].order, xmt_buf );
jmarkel44 0:61364762ee0e 775 if( status != true ) {
jmarkel44 0:61364762ee0e 776 printf("CMD: %s:%d: failed\r\n", __func__, __LINE__ );
jmarkel44 0:61364762ee0e 777 return;
jmarkel44 0:61364762ee0e 778 }
jmarkel44 0:61364762ee0e 779 break;
jmarkel44 0:61364762ee0e 780 }
jmarkel44 0:61364762ee0e 781 case TYPE_16BIT_INT:
jmarkel44 0:61364762ee0e 782 case TYPE_16BIT_UINT:
jmarkel44 0:61364762ee0e 783 status = WriteModbus_16bit_int( ((int16_t)RegisterValueMap[modMap->first].float_value&0x1), ModbusRegisterMap[modMap->first].order, xmt_buf );
jmarkel44 0:61364762ee0e 784 if( status != true ) {
jmarkel44 0:61364762ee0e 785 printf("CMD: %s:%d: failed\r\n", __func__, __LINE__ );
jmarkel44 0:61364762ee0e 786 return;
jmarkel44 0:61364762ee0e 787 }
jmarkel44 0:61364762ee0e 788 printf("%s:%d: 0x%x 0x%x\r\n", __func__,__LINE__, xmt_buf[0], xmt_buf[1]);
jmarkel44 0:61364762ee0e 789 break;
jmarkel44 0:61364762ee0e 790 default:
jmarkel44 0:61364762ee0e 791 printf("CMD: %s:%d: NOT IMPLEMENTED\r\n", __func__, __LINE__ );
jmarkel44 0:61364762ee0e 792 return;
jmarkel44 0:61364762ee0e 793 }
jmarkel44 0:61364762ee0e 794 printf("%s:%d: 0x%x 0x%x 0x%x 0x%x\r\n", __func__,__LINE__, xmt_buf[0], xmt_buf[1], xmt_buf[2], xmt_buf[3]);
jmarkel44 0:61364762ee0e 795 ret = mod_write(ModbusRegisterMap[modMap->first].node, ModbusRegisterMap[modMap->first].rtype, ModbusRegisterMap[modMap->first].reg, ModbusRegisterMap[modMap->first].size, xmt_buf);
jmarkel44 0:61364762ee0e 796 if( ret != MOD_ERROR_NONE ) {
jmarkel44 0:61364762ee0e 797 printf("CMD: %s:%d: failed, errflag=%d\r\n", __func__, __LINE__, ret );
jmarkel44 0:61364762ee0e 798 } else {
jmarkel44 0:61364762ee0e 799 printf("CMD: %s:%d: wrote to modbus func=%d reg=%d value=%2.4f, errflag=%d\r\n", __func__, __LINE__, ModbusRegisterMap[modMap->first].rtype, ModbusRegisterMap[modMap->first].reg, RegisterValueMap[modMap->first].float_value, ret );
jmarkel44 0:61364762ee0e 800 }
jmarkel44 0:61364762ee0e 801 }
jmarkel44 0:61364762ee0e 802 }