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@189:546b04f89b19, 2016-10-05 (annotated)

Committer:
davidjhoward
Date:
Wed Oct 05 21:51:01 2016 +0000
Revision:
189:546b04f89b19
Parent:
188:d35a74bf4e92
Child:
190:af7ab603c9fe
mask relay float value to get correct bool value

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 31:4b1587034318 9 #include "MTSLog.h"
jmarkel44 0:65cfa4873284 10 #include "BLEDataHandler.h"
davidjhoward 4:c35db3946fd8 11 #include "ModbusMaster.h"
davidjhoward 8:abe51ae5ef8b 12 #include "MbedJSONValue.h"
jmarkel44 0:65cfa4873284 13
davidjhoward 81:d45bfa16953a 14 DigitalOut dout1(PC_1);
davidjhoward 81:d45bfa16953a 15 DigitalOut dout2(PA_1);
davidjhoward 148:ee3cbaafe355 16 DigitalIn flow_switch(PA_0);
davidjhoward 148:ee3cbaafe355 17 DigitalIn dinp2(PC_13);
davidjhoward 81:d45bfa16953a 18
jmarkel44 0:65cfa4873284 19 /*****************************************************************************
jmarkel44 0:65cfa4873284 20 * Function: ModbusMaster
jmarkel44 0:65cfa4873284 21 * Description: entry point for the Modbus Master
jmarkel44 0:65cfa4873284 22 *
jmarkel44 0:65cfa4873284 23 * @param (IN) args (user-defined arguments)
jmarkel44 0:65cfa4873284 24 * @return none
jmarkel44 0:65cfa4873284 25 *****************************************************************************/
davidjhoward 149:950c90425f7c 26 std::map<std::string,VirtualCommand> VirtualCommandMap;
davidjhoward 149:950c90425f7c 27
jmarkel44 177:9ec90c8e3ce1 28 char ModbusMasterScratchBuf[MAX_FILE_SIZE];
jmarkel44 0:65cfa4873284 29 void ModbusMaster(void const *args)
jmarkel44 0:65cfa4873284 30 {
davidjhoward 31:4b1587034318 31 logInfo("%s ModbusMaster has started...", __func__);
davidjhoward 15:a6ee32969e8e 32 bool status;
davidjhoward 149:950c90425f7c 33 RegisterType_t regType;
davidjhoward 81:d45bfa16953a 34
davidjhoward 54:ec1b03064bbd 35 modbus_init(MB_BAUD_RATE);
davidjhoward 54:ec1b03064bbd 36 DigitalOut flu_power(PA_11);
davidjhoward 54:ec1b03064bbd 37 flu_power = 0; // provide power to the modbus
jmarkel44 0:65cfa4873284 38
davidjhoward 39:9287c7d59016 39 while( true ) {
davidjhoward 8:abe51ae5ef8b 40
davidjhoward 173:acfb464a4aec 41 MbedJSONValue json_value;
davidjhoward 173:acfb464a4aec 42
davidjhoward 39:9287c7d59016 43 // configure modbus registers based in all files that start with "input"
davidjhoward 39:9287c7d59016 44 std::vector<mDot::mdot_file> file_list = GLOBAL_mdot->listUserFiles();
davidjhoward 39:9287c7d59016 45 for (std::vector<mDot::mdot_file>::iterator i = file_list.begin(); i != file_list.end(); ++i) {
davidjhoward 149:950c90425f7c 46 if( (strncmp( i->name, "vcmd", (strlen("input")-1)) == 0) ) {
jmarkel44 177:9ec90c8e3ce1 47 status = GLOBAL_mdot->readUserFile(i->name, ModbusMasterScratchBuf, MAX_FILE_SIZE);
davidjhoward 149:950c90425f7c 48 if( status != true ) {
davidjhoward 149:950c90425f7c 49 logInfo("(%d)read file failed, status=%d", __LINE__, status);
davidjhoward 149:950c90425f7c 50 } else {
davidjhoward 151:9d47fe5ba805 51 logInfo("(%s:%d)loading File: %s", __func__, __LINE__, i->name );
davidjhoward 149:950c90425f7c 52 }
davidjhoward 8:abe51ae5ef8b 53
davidjhoward 149:950c90425f7c 54 parse( json_value, ModbusMasterScratchBuf );
davidjhoward 162:5e8948b8044d 55
davidjhoward 149:950c90425f7c 56 std::string id = json_value["id"].get<std::string>().c_str();
davidjhoward 149:950c90425f7c 57 VirtualCommandMap[id].constant = atof(json_value["constant"].get<std::string>().c_str());
davidjhoward 149:950c90425f7c 58 VirtualCommandMap[id].opl = json_value["opl"].get<std::string>().c_str();
davidjhoward 149:950c90425f7c 59 VirtualCommandMap[id].opr = json_value["opr"].get<std::string>().c_str();
davidjhoward 149:950c90425f7c 60 VirtualCommandMap[id].op = json_value["op"].get<std::string>().c_str();
davidjhoward 151:9d47fe5ba805 61 logInfo("Processd virtual command file: id=%s", id.c_str());
davidjhoward 149:950c90425f7c 62 continue;
davidjhoward 149:950c90425f7c 63 }
davidjhoward 149:950c90425f7c 64
davidjhoward 149:950c90425f7c 65 regType = REG_TYPE_NONE;
davidjhoward 149:950c90425f7c 66
davidjhoward 149:950c90425f7c 67 if( (strncmp( i->name, "input", (strlen("input")-1)) == 0) ) {
davidjhoward 149:950c90425f7c 68 regType = REG_TYPE_INPUT;
davidjhoward 149:950c90425f7c 69 } else if( (strncmp( i->name, "output", (strlen("output")-1)) == 0) ) {
davidjhoward 149:950c90425f7c 70 regType = REG_TYPE_OUTPUT;
davidjhoward 149:950c90425f7c 71 } else if( (strncmp( i->name, "vinput", (strlen("vinput")-1)) == 0) ) {
davidjhoward 149:950c90425f7c 72 regType = REG_TYPE_VINPUT;
davidjhoward 149:950c90425f7c 73 } else if( (strncmp( i->name, "voutput", (strlen("voutput")-1)) == 0) ) {
davidjhoward 149:950c90425f7c 74 regType = REG_TYPE_VOUTPUT;
davidjhoward 149:950c90425f7c 75 }
davidjhoward 149:950c90425f7c 76
davidjhoward 149:950c90425f7c 77 if( regType != REG_TYPE_NONE ) {
davidjhoward 81:d45bfa16953a 78
jmarkel44 177:9ec90c8e3ce1 79 status = GLOBAL_mdot->readUserFile(i->name, ModbusMasterScratchBuf, MAX_FILE_SIZE);
davidjhoward 39:9287c7d59016 80 if( status != true ) {
davidjhoward 45:3b9e1923cb15 81 logInfo("(%d)read file failed, status=%d", __LINE__, status);
davidjhoward 39:9287c7d59016 82 } else {
davidjhoward 151:9d47fe5ba805 83 logInfo("(%s:%d)loading File: %s", __func__, __LINE__, i->name );
davidjhoward 39:9287c7d59016 84 }
davidjhoward 81:d45bfa16953a 85
davidjhoward 42:c703a60993b1 86 parse( json_value, ModbusMasterScratchBuf );
davidjhoward 9:ef0ca2f8a8a6 87
davidjhoward 39:9287c7d59016 88 std::string id = json_value["id"].get<std::string>().c_str();
davidjhoward 39:9287c7d59016 89 ModbusRegisterMap[id].name = json_value["name"].get<std::string>().c_str();
davidjhoward 39:9287c7d59016 90 ModbusRegisterMap[id].units = json_value["units"].get<std::string>().c_str();
davidjhoward 39:9287c7d59016 91 ModbusRegisterMap[id].min = atof(json_value["min"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 92 ModbusRegisterMap[id].max = atof(json_value["max"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 93 ModbusRegisterMap[id].node = atoi(json_value["node"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 94 ModbusRegisterMap[id].reg = atoi(json_value["reg"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 95 ModbusRegisterMap[id].rtype = atoi(json_value["rtype"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 96 ModbusRegisterMap[id].type = atoi(json_value["type"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 97 ModbusRegisterMap[id].size = atoi(json_value["size"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 98 ModbusRegisterMap[id].order = atoi(json_value["order"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 99 ModbusRegisterMap[id].fmt = json_value["fmt"].get<std::string>().c_str();
davidjhoward 49:0456ee2271be 100 ModbusRegisterMap[id].rfreq = atoi(json_value["rfreq"].get<std::string>().c_str());
davidjhoward 149:950c90425f7c 101 ModbusRegisterMap[id].regType = regType;
davidjhoward 82:f3e495a98877 102 ModbusRegisterMap[id].simulated = false;
davidjhoward 148:ee3cbaafe355 103 ModbusRegisterMap[id].valid = true;
davidjhoward 149:950c90425f7c 104 if( (regType == REG_TYPE_VINPUT) || (regType == REG_TYPE_VOUTPUT) ) {
davidjhoward 149:950c90425f7c 105 ModbusRegisterMap[id].vcmd = json_value["vcmd"].get<std::string>().c_str();
davidjhoward 149:950c90425f7c 106 }
davidjhoward 15:a6ee32969e8e 107 }
davidjhoward 4:c35db3946fd8 108 }
davidjhoward 162:5e8948b8044d 109
davidjhoward 151:9d47fe5ba805 110 osSignalSet(mainThreadId, sig_output_continue);
davidjhoward 31:4b1587034318 111
davidjhoward 39:9287c7d59016 112 // read modbus registers that have been configured.
davidjhoward 39:9287c7d59016 113 while ( true ) {
davidjhoward 39:9287c7d59016 114
davidjhoward 39:9287c7d59016 115 std::map<std::string, ModbusRegister>::iterator iter;
davidjhoward 39:9287c7d59016 116 for (iter = ModbusRegisterMap.begin(); iter != ModbusRegisterMap.end(); ++iter) {
davidjhoward 82:f3e495a98877 117 if( iter->second.simulated == true ) {
davidjhoward 181:e2c982c94e98 118 // printf("\r\nsimulating input=%s, min=%2.2f, max=%2.2f, start_value=%2.2f, up_step=%2.2f, down_step=%2.2f moving_up=%d\r\n",iter->first.c_str(), SimulateInputMap[iter->first].min, SimulateInputMap[iter->first].max, SimulateInputMap[iter->first].start_value, SimulateInputMap[iter->first].up_step, SimulateInputMap[iter->first].down_step, SimulateInputMap[iter->first].moving_up);
davidjhoward 176:492cfa856521 119 if( (SimulateInputMap[iter->first].min == 0) && (SimulateInputMap[iter->first].max == 0) ) {
davidjhoward 176:492cfa856521 120 ModbusRegisterMap[iter->first].float_value = SimulateInputMap[iter->first].start_value;
davidjhoward 181:e2c982c94e98 121 // printf("simulating input=%s, value=%2.2f\r\n",iter->first.c_str(), ModbusRegisterMap[iter->first].float_value);
davidjhoward 176:492cfa856521 122 } else {
davidjhoward 176:492cfa856521 123 if( ModbusRegisterMap[iter->first].float_value >= SimulateInputMap[iter->first].max ) {
davidjhoward 179:a31ea334e2b7 124 SimulateInputMap[iter->first].moving_up = false;
davidjhoward 181:e2c982c94e98 125 // printf("simulating down input=%s, value=%2.2f - %2.2f\r\n",iter->first.c_str(), ModbusRegisterMap[iter->first].float_value, SimulateInputMap[iter->first].down_step);
davidjhoward 176:492cfa856521 126 ModbusRegisterMap[iter->first].float_value = ModbusRegisterMap[iter->first].float_value - SimulateInputMap[iter->first].down_step;
davidjhoward 176:492cfa856521 127 } else if( ModbusRegisterMap[iter->first].float_value <= SimulateInputMap[iter->first].min ) {
davidjhoward 179:a31ea334e2b7 128 SimulateInputMap[iter->first].moving_up = true;
davidjhoward 181:e2c982c94e98 129 // printf("simulating up input=%s, value=%2.2f + %2.2f\r\n",iter->first.c_str(), ModbusRegisterMap[iter->first].float_value, SimulateInputMap[iter->first].up_step);
davidjhoward 176:492cfa856521 130 ModbusRegisterMap[iter->first].float_value = ModbusRegisterMap[iter->first].float_value + SimulateInputMap[iter->first].up_step;
davidjhoward 82:f3e495a98877 131 } else {
davidjhoward 179:a31ea334e2b7 132 if( SimulateInputMap[iter->first].moving_up == true ) {
davidjhoward 181:e2c982c94e98 133 // printf("continue simulate up input=%s, value=%2.2f + %2.2f\r\n",iter->first.c_str(), ModbusRegisterMap[iter->first].float_value, SimulateInputMap[iter->first].up_step);
davidjhoward 150:4db35c8234b4 134 ModbusRegisterMap[iter->first].float_value = ModbusRegisterMap[iter->first].float_value + SimulateInputMap[iter->first].up_step;
davidjhoward 82:f3e495a98877 135 } else {
davidjhoward 181:e2c982c94e98 136 // printf("continue simulate down input=%s, value=%2.2f - %2.2f\r\n",iter->first.c_str(), ModbusRegisterMap[iter->first].float_value, SimulateInputMap[iter->first].down_step);
davidjhoward 176:492cfa856521 137 ModbusRegisterMap[iter->first].float_value = ModbusRegisterMap[iter->first].float_value - SimulateInputMap[iter->first].down_step;
davidjhoward 82:f3e495a98877 138 }
davidjhoward 82:f3e495a98877 139 }
davidjhoward 181:e2c982c94e98 140 // printf("simulating input=%s, value=%2.2f\r\n\r\n",iter->first.c_str(), ModbusRegisterMap[iter->first].float_value);
davidjhoward 82:f3e495a98877 141 }
davidjhoward 82:f3e495a98877 142 continue;
davidjhoward 82:f3e495a98877 143 }
davidjhoward 148:ee3cbaafe355 144
davidjhoward 147:105bcf234f81 145 if( iter->second.node != 0 ) {
davidjhoward 148:ee3cbaafe355 146
davidjhoward 149:950c90425f7c 147 logInfo("Processing Input: tag=%s, node=%d, reg=%d, size=%d, order=%d", iter->first.c_str(), iter->second.node, iter->second.reg, iter->second.size, iter->second.order );
davidjhoward 147:105bcf234f81 148 SendModbusCommand(iter->second.node, iter->second.reg, iter->second.size);
davidjhoward 147:105bcf234f81 149 Thread::wait(30);
davidjhoward 147:105bcf234f81 150 switch( iter->second.type ) {
davidjhoward 147:105bcf234f81 151 case TYPE_32BIT_FLOAT:
davidjhoward 147:105bcf234f81 152 float float_value;
davidjhoward 147:105bcf234f81 153 status = ReadModbus_32bit_float( &float_value, iter->second.order );
davidjhoward 147:105bcf234f81 154 if( status == true ) {
davidjhoward 147:105bcf234f81 155 ModbusRegisterMap[iter->first].float_value = float_value;
davidjhoward 148:ee3cbaafe355 156 ModbusRegisterMap[iter->first].valid = true;
davidjhoward 148:ee3cbaafe355 157 // logInfo("Modbus Tag:%s value=%2.2f", iter->first.c_str(), float_value );
davidjhoward 147:105bcf234f81 158 } else {
davidjhoward 148:ee3cbaafe355 159 ModbusRegisterMap[iter->first].valid = false;
davidjhoward 148:ee3cbaafe355 160 // logInfo("Modbus Read Failed, tag=%s", iter->first.c_str() );
davidjhoward 147:105bcf234f81 161 }
davidjhoward 147:105bcf234f81 162 break;
davidjhoward 147:105bcf234f81 163 case TYPE_32BIT_INT:
davidjhoward 186:16912aa18c2a 164 int32_t int32_value;
davidjhoward 186:16912aa18c2a 165 status = ReadModbus_32bit_int( &int32_value, iter->second.order );
davidjhoward 186:16912aa18c2a 166 if( status == true ) {
davidjhoward 186:16912aa18c2a 167 ModbusRegisterMap[iter->first].float_value = int32_value;
davidjhoward 186:16912aa18c2a 168 ModbusRegisterMap[iter->first].valid = true;
davidjhoward 186:16912aa18c2a 169 logInfo("Modbus Tag:%s value=%2.2f", iter->first.c_str(), ModbusRegisterMap[iter->first].float_value );
davidjhoward 186:16912aa18c2a 170 } else {
davidjhoward 186:16912aa18c2a 171 ModbusRegisterMap[iter->first].valid = false;
davidjhoward 186:16912aa18c2a 172 logInfo("Modbus Read Failed, tag=%s", iter->first.c_str() );
davidjhoward 186:16912aa18c2a 173 }
davidjhoward 147:105bcf234f81 174 break;
davidjhoward 147:105bcf234f81 175 case TYPE_32BIT_UINT:
davidjhoward 147:105bcf234f81 176 break;
davidjhoward 147:105bcf234f81 177 case TYPE_16BIT_INT:
davidjhoward 147:105bcf234f81 178 break;
davidjhoward 147:105bcf234f81 179 case TYPE_16BIT_UINT:
davidjhoward 147:105bcf234f81 180 break;
davidjhoward 147:105bcf234f81 181 default:
davidjhoward 147:105bcf234f81 182 break;
davidjhoward 147:105bcf234f81 183 }
davidjhoward 39:9287c7d59016 184 }
davidjhoward 82:f3e495a98877 185
davidjhoward 149:950c90425f7c 186 if( (iter->second.node == 0) && (iter->second.regType == REG_TYPE_OUTPUT) ) {
davidjhoward 148:ee3cbaafe355 187 // logInfo("processing PIN output=%s, reg=%d, value=%d",iter->first.c_str(), ModbusRegisterMap[iter->first].reg, (bool)ModbusRegisterMap[iter->first].float_value);
davidjhoward 148:ee3cbaafe355 188 if( ModbusRegisterMap[iter->first].reg == 1 ) {
davidjhoward 189:546b04f89b19 189 dout1 = (bool)((int)ModbusRegisterMap[iter->first].float_value&0x1);
davidjhoward 148:ee3cbaafe355 190 } else {
davidjhoward 189:546b04f89b19 191 dout2 = (bool)((int)ModbusRegisterMap[iter->first].float_value&0x1);
davidjhoward 148:ee3cbaafe355 192 }
davidjhoward 148:ee3cbaafe355 193 }
davidjhoward 149:950c90425f7c 194 if( (iter->second.node == 0) && (iter->second.regType == REG_TYPE_INPUT) ) {
davidjhoward 148:ee3cbaafe355 195 // logInfo("processing PIN input=%s, reg=%d, value=%d",iter->first.c_str(), ModbusRegisterMap[iter->first].reg, (bool)ModbusRegisterMap[iter->first].float_value);
davidjhoward 148:ee3cbaafe355 196 if( ModbusRegisterMap[iter->first].reg == 1 ) {
davidjhoward 148:ee3cbaafe355 197 // digital input
davidjhoward 148:ee3cbaafe355 198 ModbusRegisterMap[iter->first].float_value = (float)flow_switch.read();
davidjhoward 148:ee3cbaafe355 199 } else {
davidjhoward 148:ee3cbaafe355 200 ModbusRegisterMap[iter->first].float_value = (float)dinp2.read();
davidjhoward 81:d45bfa16953a 201 }
davidjhoward 81:d45bfa16953a 202 }
davidjhoward 39:9287c7d59016 203 }
davidjhoward 39:9287c7d59016 204
davidjhoward 149:950c90425f7c 205 // now update all of the virtual registers
davidjhoward 149:950c90425f7c 206 for (iter = ModbusRegisterMap.begin(); iter != ModbusRegisterMap.end(); ++iter) {
davidjhoward 149:950c90425f7c 207 if( (ModbusRegisterMap[iter->first].regType != REG_TYPE_VINPUT) && (ModbusRegisterMap[iter->first].regType != REG_TYPE_VOUTPUT) ) {
davidjhoward 149:950c90425f7c 208 continue;
davidjhoward 149:950c90425f7c 209 }
davidjhoward 149:950c90425f7c 210 logInfo("Processing Virtual Input: vcmd:%s, tag:%s, opl:%s, opr:%s, op:%s, constant:%.4f", iter->second.vcmd.c_str(), iter->first.c_str(),
davidjhoward 149:950c90425f7c 211 VirtualCommandMap[iter->second.vcmd].opl.c_str(),
davidjhoward 149:950c90425f7c 212 VirtualCommandMap[iter->second.vcmd].opr.c_str(),
davidjhoward 149:950c90425f7c 213 VirtualCommandMap[iter->second.vcmd].op.c_str(),
davidjhoward 149:950c90425f7c 214 VirtualCommandMap[iter->second.vcmd].constant
davidjhoward 149:950c90425f7c 215 );
davidjhoward 149:950c90425f7c 216 switch( VirtualCommandMap[iter->second.vcmd].op.c_str()[0] ) {
davidjhoward 149:950c90425f7c 217 case '=':
davidjhoward 149:950c90425f7c 218 ModbusRegisterMap[iter->first].float_value = ModbusRegisterMap[VirtualCommandMap[iter->second.vcmd].opl].float_value;
davidjhoward 149:950c90425f7c 219 logInfo("Setting tag=%s, equal to (value=%2.2f)", iter->first.c_str(),
jmarkel44 169:c503848823aa 220 //VirtualCommandMap[iter->second.vcmd].opl.c_str(),
davidjhoward 149:950c90425f7c 221 ModbusRegisterMap[VirtualCommandMap[iter->second.vcmd].opl].float_value
davidjhoward 149:950c90425f7c 222 );
davidjhoward 149:950c90425f7c 223 break;
davidjhoward 149:950c90425f7c 224 case '*':
davidjhoward 162:5e8948b8044d 225 ModbusRegisterMap[iter->first].float_value =
davidjhoward 162:5e8948b8044d 226 ModbusRegisterMap[VirtualCommandMap[iter->second.vcmd].opl].float_value *
davidjhoward 162:5e8948b8044d 227 ModbusRegisterMap[VirtualCommandMap[iter->second.vcmd].opr].float_value;
davidjhoward 162:5e8948b8044d 228 logInfo("Setting tag=%s, equal to (%2.2f*%2.2f) = %2.2f", iter->first.c_str(),
jmarkel44 169:c503848823aa 229 //VirtualCommandMap[iter->second.vcmd].opl.c_str(),
davidjhoward 162:5e8948b8044d 230 ModbusRegisterMap[VirtualCommandMap[iter->second.vcmd].opl].float_value,
davidjhoward 162:5e8948b8044d 231 ModbusRegisterMap[VirtualCommandMap[iter->second.vcmd].opr].float_value,
davidjhoward 162:5e8948b8044d 232 ModbusRegisterMap[iter->first].float_value
davidjhoward 162:5e8948b8044d 233 );
davidjhoward 149:950c90425f7c 234 case '/':
davidjhoward 162:5e8948b8044d 235 if( ModbusRegisterMap[VirtualCommandMap[iter->second.vcmd].opr].float_value != 0 ) {
davidjhoward 162:5e8948b8044d 236 ModbusRegisterMap[iter->first].float_value =
davidjhoward 162:5e8948b8044d 237 ModbusRegisterMap[VirtualCommandMap[iter->second.vcmd].opl].float_value /
davidjhoward 162:5e8948b8044d 238 ModbusRegisterMap[VirtualCommandMap[iter->second.vcmd].opr].float_value;
davidjhoward 162:5e8948b8044d 239 logInfo("Setting tag=%s, equal to (%2.2f/%2.2f) = %2.2f", iter->first.c_str(),
jmarkel44 169:c503848823aa 240 //VirtualCommandMap[iter->second.vcmd].opl.c_str(),
davidjhoward 162:5e8948b8044d 241 ModbusRegisterMap[VirtualCommandMap[iter->second.vcmd].opl].float_value,
davidjhoward 162:5e8948b8044d 242 ModbusRegisterMap[VirtualCommandMap[iter->second.vcmd].opr].float_value,
davidjhoward 162:5e8948b8044d 243 ModbusRegisterMap[iter->first].float_value
davidjhoward 162:5e8948b8044d 244 );
davidjhoward 162:5e8948b8044d 245 } else {
davidjhoward 162:5e8948b8044d 246 logInfo("NOT DOING DIVIDE BY ZERO");
davidjhoward 162:5e8948b8044d 247 }
davidjhoward 162:5e8948b8044d 248 break;
davidjhoward 149:950c90425f7c 249 case '+':
davidjhoward 149:950c90425f7c 250 case '-':
davidjhoward 149:950c90425f7c 251 default:
davidjhoward 149:950c90425f7c 252 break;
davidjhoward 149:950c90425f7c 253 }
davidjhoward 149:950c90425f7c 254 }
davidjhoward 149:950c90425f7c 255
davidjhoward 39:9287c7d59016 256 osEvent evt = ModbusMasterMailBox.get(50);
davidjhoward 39:9287c7d59016 257 if (evt.status == osEventMail) {
davidjhoward 39:9287c7d59016 258 Message_t *mail = (Message_t*)evt.value.p;
davidjhoward 39:9287c7d59016 259 logInfo("Mail Received: Action: %d, New Input File: %s", mail->action, mail->controlFile);
davidjhoward 39:9287c7d59016 260 ModbusMasterMailBox.free(mail);
davidjhoward 39:9287c7d59016 261 ModbusRegisterMap.clear();
davidjhoward 39:9287c7d59016 262 break;
davidjhoward 39:9287c7d59016 263 }
davidjhoward 57:5f18ae91c7c7 264 Thread::wait(5000);
davidjhoward 31:4b1587034318 265 }
jmarkel44 0:65cfa4873284 266 }
davidjhoward 4:c35db3946fd8 267 }
davidjhoward 4:c35db3946fd8 268
davidjhoward 4:c35db3946fd8 269
davidjhoward 4:c35db3946fd8 270 volatile char modbus_buffer_char;
davidjhoward 4:c35db3946fd8 271 volatile bool modbus_interrupt_complete = false;
davidjhoward 4:c35db3946fd8 272
davidjhoward 4:c35db3946fd8 273 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 274 volatile uint8_t modbus_input_buffer_counter = 0;
davidjhoward 4:c35db3946fd8 275
davidjhoward 4:c35db3946fd8 276 //Frame crc calucation
davidjhoward 4:c35db3946fd8 277 uint16_t modbus_crc(uint8_t* buf, int len)
davidjhoward 4:c35db3946fd8 278 {
davidjhoward 4:c35db3946fd8 279 uint16_t crc = 0xFFFF;
davidjhoward 4:c35db3946fd8 280
davidjhoward 4:c35db3946fd8 281 for (int pos = 0; pos < len; pos++) {
davidjhoward 4:c35db3946fd8 282 crc ^= (uint16_t)buf[pos]; // XOR byte into least sig. byte of crc
davidjhoward 4:c35db3946fd8 283
davidjhoward 4:c35db3946fd8 284 for (int i = 8; i != 0; i--) {
davidjhoward 4:c35db3946fd8 285 // Loop over each bit
davidjhoward 4:c35db3946fd8 286 if ((crc & 0x0001) != 0) {
davidjhoward 4:c35db3946fd8 287 // If the LSB is set
davidjhoward 4:c35db3946fd8 288 crc >>= 1; // Shift right and XOR 0xA001
davidjhoward 4:c35db3946fd8 289 crc ^= 0xA001;
davidjhoward 4:c35db3946fd8 290 } else // Else LSB is not set
davidjhoward 4:c35db3946fd8 291 crc >>= 1; // Just shift right
davidjhoward 4:c35db3946fd8 292 }
davidjhoward 4:c35db3946fd8 293 }
davidjhoward 4:c35db3946fd8 294 // Note, this number has low and high bytes swapped, so use it accordingly (or swap bytes)
davidjhoward 4:c35db3946fd8 295 return crc;
davidjhoward 4:c35db3946fd8 296 }
davidjhoward 4:c35db3946fd8 297
davidjhoward 4:c35db3946fd8 298 RawSerial modbus(PA_2, PA_3);
davidjhoward 57:5f18ae91c7c7 299 DigitalOut mod_de(PB_0);
davidjhoward 57:5f18ae91c7c7 300 DigitalOut mod_re(PB_1);
davidjhoward 4:c35db3946fd8 301
davidjhoward 4:c35db3946fd8 302 void modbus_init( uint16_t baudRate )
davidjhoward 4:c35db3946fd8 303 {
davidjhoward 4:c35db3946fd8 304 modbus.baud(baudRate);
davidjhoward 4:c35db3946fd8 305 modbus.attach(&modbus_recv, RawSerial::RxIrq);
davidjhoward 4:c35db3946fd8 306 }
davidjhoward 4:c35db3946fd8 307
davidjhoward 4:c35db3946fd8 308 //call back when character goes into RX buffer for RS485 modbus
davidjhoward 4:c35db3946fd8 309 void modbus_recv()
davidjhoward 4:c35db3946fd8 310 {
davidjhoward 4:c35db3946fd8 311
davidjhoward 4:c35db3946fd8 312 if (modbus.readable()) {
davidjhoward 4:c35db3946fd8 313 modbus_buffer_char = modbus.getc();
davidjhoward 4:c35db3946fd8 314 if (modbus_input_buffer_counter == 0 && modbus_buffer_char == 0x00) {
davidjhoward 4:c35db3946fd8 315 modbus_input_buffer_counter = 0;
davidjhoward 4:c35db3946fd8 316 } else {
davidjhoward 4:c35db3946fd8 317 modbus_input_buffer[modbus_input_buffer_counter] = modbus_buffer_char;
davidjhoward 4:c35db3946fd8 318 modbus_input_buffer_counter++;
davidjhoward 4:c35db3946fd8 319 }
davidjhoward 4:c35db3946fd8 320 }
davidjhoward 4:c35db3946fd8 321
davidjhoward 4:c35db3946fd8 322 if (modbus_input_buffer_counter > modbus_input_buffer[2] + 4) {
davidjhoward 4:c35db3946fd8 323 modbus_interrupt_complete = true;
davidjhoward 4:c35db3946fd8 324 modbus_input_buffer_counter = 0;
davidjhoward 4:c35db3946fd8 325 }
davidjhoward 4:c35db3946fd8 326 }
davidjhoward 4:c35db3946fd8 327
davidjhoward 4:c35db3946fd8 328 // Read modbus master frame
davidjhoward 9:ef0ca2f8a8a6 329 void SendModbusCommand(uint8_t slave_address, uint16_t firstReg, uint16_t noRegs)
davidjhoward 4:c35db3946fd8 330 {
davidjhoward 4:c35db3946fd8 331 uint8_t L1V[8] = {slave_address, 0x04, 0x00, 0x02, 0x00, 0x02, 0xD1, 0x16};
davidjhoward 4:c35db3946fd8 332
davidjhoward 4:c35db3946fd8 333 L1V[2] = (firstReg >> 8) & 0xFF;
davidjhoward 4:c35db3946fd8 334 L1V[3] = firstReg & 0xFF;
davidjhoward 4:c35db3946fd8 335 L1V[4] = (noRegs >> 8) & 0xFF;
davidjhoward 4:c35db3946fd8 336 L1V[5] = noRegs & 0xFF;
davidjhoward 4:c35db3946fd8 337 L1V[6] = modbus_crc(L1V,6) & 0xFF;
davidjhoward 4:c35db3946fd8 338 L1V[7] = (modbus_crc(L1V,6)>>8) & 0xFF;
davidjhoward 4:c35db3946fd8 339
davidjhoward 57:5f18ae91c7c7 340 mod_de = 1;
davidjhoward 57:5f18ae91c7c7 341 mod_re = 1;
davidjhoward 57:5f18ae91c7c7 342 Thread::wait(1);
davidjhoward 4:c35db3946fd8 343 for (uint8_t i = 0; i < 8; i++)
davidjhoward 4:c35db3946fd8 344 modbus.putc(L1V[i]);
davidjhoward 4:c35db3946fd8 345
davidjhoward 57:5f18ae91c7c7 346 Thread::wait(2);
davidjhoward 57:5f18ae91c7c7 347 mod_de = 0;
davidjhoward 57:5f18ae91c7c7 348 mod_re = 0;
davidjhoward 4:c35db3946fd8 349
davidjhoward 4:c35db3946fd8 350 }
davidjhoward 4:c35db3946fd8 351
davidjhoward 4:c35db3946fd8 352 bool mbInterruptComplete()
davidjhoward 4:c35db3946fd8 353 {
davidjhoward 4:c35db3946fd8 354 if (modbus_interrupt_complete) {
davidjhoward 4:c35db3946fd8 355 modbus_interrupt_complete = false;
davidjhoward 4:c35db3946fd8 356 return true;
davidjhoward 4:c35db3946fd8 357 } else {
davidjhoward 4:c35db3946fd8 358 return false;
davidjhoward 4:c35db3946fd8 359 }
davidjhoward 4:c35db3946fd8 360 }
davidjhoward 4:c35db3946fd8 361
davidjhoward 15:a6ee32969e8e 362 bool ReadModbus_32bit_float( float *float_value, int order )
davidjhoward 4:c35db3946fd8 363 {
davidjhoward 15:a6ee32969e8e 364 MR_REGISTER_32_BIT_FLOAT value;
davidjhoward 31:4b1587034318 365
davidjhoward 4:c35db3946fd8 366 if (mbInterruptComplete() != true ) {
davidjhoward 4:c35db3946fd8 367 return false;
davidjhoward 4:c35db3946fd8 368 }
davidjhoward 4:c35db3946fd8 369
davidjhoward 15:a6ee32969e8e 370 switch( order ) {
davidjhoward 31:4b1587034318 371 case BigEndian:
davidjhoward 15:a6ee32969e8e 372 value.b.lo_lo = modbus_input_buffer[6];
davidjhoward 15:a6ee32969e8e 373 value.b.lo_hi = modbus_input_buffer[5];
davidjhoward 15:a6ee32969e8e 374 value.b.hi_lo = modbus_input_buffer[4];
davidjhoward 15:a6ee32969e8e 375 value.b.hi_hi = modbus_input_buffer[3];
davidjhoward 15:a6ee32969e8e 376 break;
davidjhoward 15:a6ee32969e8e 377 case BigEndianReverseWord:
davidjhoward 15:a6ee32969e8e 378 value.b.lo_lo = modbus_input_buffer[4];
davidjhoward 15:a6ee32969e8e 379 value.b.lo_hi = modbus_input_buffer[3];
davidjhoward 15:a6ee32969e8e 380 value.b.hi_lo = modbus_input_buffer[6];
davidjhoward 15:a6ee32969e8e 381 value.b.hi_hi = modbus_input_buffer[5];
davidjhoward 15:a6ee32969e8e 382 break;
davidjhoward 15:a6ee32969e8e 383 default:
davidjhoward 15:a6ee32969e8e 384 return false;
davidjhoward 15:a6ee32969e8e 385 }
davidjhoward 188:d35a74bf4e92 386 // printf("0x%x 0x%x 0x%x 0x%x (%2.2f)\r\n", value.b.hi_hi, value.b.hi_lo, value.b.lo_hi, value.b.lo_lo, value.f);
davidjhoward 15:a6ee32969e8e 387 *float_value = value.f;
davidjhoward 4:c35db3946fd8 388 return true;
davidjhoward 4:c35db3946fd8 389 }
davidjhoward 186:16912aa18c2a 390
davidjhoward 186:16912aa18c2a 391 bool ReadModbus_32bit_int( int32_t *int32_value, int order )
davidjhoward 186:16912aa18c2a 392 {
davidjhoward 186:16912aa18c2a 393 MR_REGISTER_32BIT_INT value;
davidjhoward 186:16912aa18c2a 394
davidjhoward 186:16912aa18c2a 395 if (mbInterruptComplete() != true ) {
davidjhoward 186:16912aa18c2a 396 return false;
davidjhoward 186:16912aa18c2a 397 }
davidjhoward 186:16912aa18c2a 398
davidjhoward 186:16912aa18c2a 399 switch( order ) {
davidjhoward 186:16912aa18c2a 400 case BigEndian:
davidjhoward 186:16912aa18c2a 401 value.b.lo_lo = modbus_input_buffer[6];
davidjhoward 186:16912aa18c2a 402 value.b.lo_hi = modbus_input_buffer[5];
davidjhoward 186:16912aa18c2a 403 value.b.hi_lo = modbus_input_buffer[4];
davidjhoward 186:16912aa18c2a 404 value.b.hi_hi = modbus_input_buffer[3];
davidjhoward 186:16912aa18c2a 405 break;
davidjhoward 186:16912aa18c2a 406 case BigEndianReverseWord:
davidjhoward 186:16912aa18c2a 407 value.b.lo_lo = modbus_input_buffer[4];
davidjhoward 186:16912aa18c2a 408 value.b.lo_hi = modbus_input_buffer[3];
davidjhoward 186:16912aa18c2a 409 value.b.hi_lo = modbus_input_buffer[6];
davidjhoward 186:16912aa18c2a 410 value.b.hi_hi = modbus_input_buffer[5];
davidjhoward 186:16912aa18c2a 411 break;
davidjhoward 186:16912aa18c2a 412 default:
davidjhoward 186:16912aa18c2a 413 return false;
davidjhoward 186:16912aa18c2a 414 }
davidjhoward 188:d35a74bf4e92 415 // 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);
davidjhoward 186:16912aa18c2a 416 *int32_value = value.i;
davidjhoward 186:16912aa18c2a 417 return true;
davidjhoward 186:16912aa18c2a 418 }