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@54:ec1b03064bbd, 2016-09-13 (annotated)

Committer:
davidjhoward
Date:
Tue Sep 13 21:39:11 2016 +0000
Revision:
54:ec1b03064bbd
Parent:
49:0456ee2271be
Child:
57:5f18ae91c7c7
updating

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
jmarkel44 0:65cfa4873284 14 /*****************************************************************************
jmarkel44 0:65cfa4873284 15 * Function: ModbusMaster
jmarkel44 0:65cfa4873284 16 * Description: entry point for the Modbus Master
jmarkel44 0:65cfa4873284 17 *
jmarkel44 0:65cfa4873284 18 * @param (IN) args (user-defined arguments)
jmarkel44 0:65cfa4873284 19 * @return none
jmarkel44 0:65cfa4873284 20 *****************************************************************************/
davidjhoward 42:c703a60993b1 21 char ModbusMasterScratchBuf[1024];
jmarkel44 0:65cfa4873284 22 void ModbusMaster(void const *args)
jmarkel44 0:65cfa4873284 23 {
davidjhoward 31:4b1587034318 24 logInfo("%s ModbusMaster has started...", __func__);
davidjhoward 15:a6ee32969e8e 25 bool status;
davidjhoward 8:abe51ae5ef8b 26 MbedJSONValue json_value;
davidjhoward 54:ec1b03064bbd 27
davidjhoward 54:ec1b03064bbd 28 modbus_init(MB_BAUD_RATE);
davidjhoward 54:ec1b03064bbd 29 osDelay(500);
davidjhoward 54:ec1b03064bbd 30 DigitalOut flu_power(PA_11);
davidjhoward 54:ec1b03064bbd 31 flu_power = 0; // provide power to the modbus
davidjhoward 54:ec1b03064bbd 32 printf("MODBUS INITIALIZED\r\n");
davidjhoward 54:ec1b03064bbd 33
jmarkel44 0:65cfa4873284 34
davidjhoward 39:9287c7d59016 35 while( true ) {
davidjhoward 8:abe51ae5ef8b 36
davidjhoward 42:c703a60993b1 37 logInfo("Top Of Modbus Master Loop");
davidjhoward 42:c703a60993b1 38
davidjhoward 39:9287c7d59016 39 // configure modbus registers based in all files that start with "input"
davidjhoward 39:9287c7d59016 40 std::vector<mDot::mdot_file> file_list = GLOBAL_mdot->listUserFiles();
davidjhoward 39:9287c7d59016 41 for (std::vector<mDot::mdot_file>::iterator i = file_list.begin(); i != file_list.end(); ++i) {
davidjhoward 8:abe51ae5ef8b 42
davidjhoward 42:c703a60993b1 43 if( strncmp( i->name, "input", (strlen("input")-1)) == 0 ) {
davidjhoward 8:abe51ae5ef8b 44
davidjhoward 45:3b9e1923cb15 45 logInfo("(%d)FOUND INPUT FILE: %s", __LINE__, i->name);
davidjhoward 42:c703a60993b1 46
davidjhoward 49:0456ee2271be 47 status = GLOBAL_mdot->readUserFile(i->name, ModbusMasterScratchBuf, 1024);
davidjhoward 39:9287c7d59016 48 if( status != true ) {
davidjhoward 45:3b9e1923cb15 49 logInfo("(%d)read file failed, status=%d", __LINE__, status);
davidjhoward 39:9287c7d59016 50 } else {
davidjhoward 45:3b9e1923cb15 51 logInfo("(%d)Read File SUCCESS: %s", __LINE__, ModbusMasterScratchBuf );
davidjhoward 39:9287c7d59016 52 }
davidjhoward 49:0456ee2271be 53
davidjhoward 42:c703a60993b1 54 parse( json_value, ModbusMasterScratchBuf );
davidjhoward 9:ef0ca2f8a8a6 55
davidjhoward 39:9287c7d59016 56 std::string id = json_value["id"].get<std::string>().c_str();
davidjhoward 39:9287c7d59016 57 ModbusRegisterMap[id].name = json_value["name"].get<std::string>().c_str();
davidjhoward 39:9287c7d59016 58 ModbusRegisterMap[id].units = json_value["units"].get<std::string>().c_str();
davidjhoward 39:9287c7d59016 59 ModbusRegisterMap[id].min = atof(json_value["min"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 60 ModbusRegisterMap[id].max = atof(json_value["max"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 61 ModbusRegisterMap[id].node = atoi(json_value["node"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 62 ModbusRegisterMap[id].reg = atoi(json_value["reg"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 63 ModbusRegisterMap[id].rtype = atoi(json_value["rtype"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 64 ModbusRegisterMap[id].type = atoi(json_value["type"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 65 ModbusRegisterMap[id].size = atoi(json_value["size"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 66 ModbusRegisterMap[id].order = atoi(json_value["order"].get<std::string>().c_str());
davidjhoward 39:9287c7d59016 67 ModbusRegisterMap[id].fmt = json_value["fmt"].get<std::string>().c_str();
davidjhoward 49:0456ee2271be 68 ModbusRegisterMap[id].rfreq = atoi(json_value["rfreq"].get<std::string>().c_str());
davidjhoward 15:a6ee32969e8e 69 }
davidjhoward 4:c35db3946fd8 70 }
davidjhoward 31:4b1587034318 71
davidjhoward 39:9287c7d59016 72 // read modbus registers that have been configured.
davidjhoward 39:9287c7d59016 73 while ( true ) {
davidjhoward 39:9287c7d59016 74
davidjhoward 39:9287c7d59016 75 std::map<std::string, ModbusRegister>::iterator iter;
davidjhoward 39:9287c7d59016 76 for (iter = ModbusRegisterMap.begin(); iter != ModbusRegisterMap.end(); ++iter) {
davidjhoward 42:c703a60993b1 77 logInfo("Reading node=%d, reg=%d, size=%d, order=%d", iter->second.node, iter->second.reg, iter->second.size, iter->second.order );
davidjhoward 39:9287c7d59016 78 SendModbusCommand(iter->second.node, iter->second.reg, iter->second.size);
davidjhoward 39:9287c7d59016 79 osDelay(30);
davidjhoward 39:9287c7d59016 80
davidjhoward 39:9287c7d59016 81 switch( iter->second.type ) {
davidjhoward 39:9287c7d59016 82 case TYPE_32BIT_FLOAT:
davidjhoward 39:9287c7d59016 83 float float_value;
davidjhoward 39:9287c7d59016 84 status = ReadModbus_32bit_float( &float_value, iter->second.order );
davidjhoward 39:9287c7d59016 85 if( status == true ) {
davidjhoward 39:9287c7d59016 86 ModbusRegisterMap[iter->first].float_value = float_value;
davidjhoward 54:ec1b03064bbd 87 logInfo("Modbus Tag:%s value=%2.2f", iter->first.c_str(), float_value );
davidjhoward 54:ec1b03064bbd 88 }
davidjhoward 54:ec1b03064bbd 89 else
davidjhoward 54:ec1b03064bbd 90 {
davidjhoward 54:ec1b03064bbd 91 logInfo("Modbus Read Failed, tag=%s", iter->first.c_str() );
davidjhoward 39:9287c7d59016 92 }
davidjhoward 39:9287c7d59016 93 break;
davidjhoward 39:9287c7d59016 94 case TYPE_32BIT_INT:
davidjhoward 39:9287c7d59016 95 break;
davidjhoward 39:9287c7d59016 96 case TYPE_32BIT_UINT:
davidjhoward 39:9287c7d59016 97 break;
davidjhoward 39:9287c7d59016 98 case TYPE_16BIT_INT:
davidjhoward 39:9287c7d59016 99 break;
davidjhoward 39:9287c7d59016 100 case TYPE_16BIT_UINT:
davidjhoward 39:9287c7d59016 101 break;
davidjhoward 39:9287c7d59016 102 default:
davidjhoward 39:9287c7d59016 103 break;
davidjhoward 39:9287c7d59016 104 }
davidjhoward 39:9287c7d59016 105 }
davidjhoward 39:9287c7d59016 106
davidjhoward 39:9287c7d59016 107 logInfo("Checking for MAIL");
davidjhoward 39:9287c7d59016 108 osEvent evt = ModbusMasterMailBox.get(50);
davidjhoward 39:9287c7d59016 109 if (evt.status == osEventMail) {
davidjhoward 39:9287c7d59016 110 Message_t *mail = (Message_t*)evt.value.p;
davidjhoward 39:9287c7d59016 111 logInfo("Mail Received: Action: %d, New Input File: %s", mail->action, mail->controlFile);
davidjhoward 39:9287c7d59016 112 ModbusMasterMailBox.free(mail);
davidjhoward 39:9287c7d59016 113 ModbusRegisterMap.clear();
davidjhoward 39:9287c7d59016 114 break;
davidjhoward 39:9287c7d59016 115 } else {
davidjhoward 39:9287c7d59016 116 logInfo("No Mail");
davidjhoward 39:9287c7d59016 117 }
davidjhoward 42:c703a60993b1 118 osDelay(5000);
davidjhoward 31:4b1587034318 119 }
jmarkel44 0:65cfa4873284 120 }
davidjhoward 4:c35db3946fd8 121 }
davidjhoward 4:c35db3946fd8 122
davidjhoward 4:c35db3946fd8 123
davidjhoward 4:c35db3946fd8 124 volatile char modbus_buffer_char;
davidjhoward 4:c35db3946fd8 125 volatile bool modbus_interrupt_complete = false;
davidjhoward 4:c35db3946fd8 126
davidjhoward 4:c35db3946fd8 127 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 128 volatile uint8_t modbus_input_buffer_counter = 0;
davidjhoward 4:c35db3946fd8 129
davidjhoward 4:c35db3946fd8 130 //Frame crc calucation
davidjhoward 4:c35db3946fd8 131 uint16_t modbus_crc(uint8_t* buf, int len)
davidjhoward 4:c35db3946fd8 132 {
davidjhoward 4:c35db3946fd8 133 uint16_t crc = 0xFFFF;
davidjhoward 4:c35db3946fd8 134
davidjhoward 4:c35db3946fd8 135 for (int pos = 0; pos < len; pos++) {
davidjhoward 4:c35db3946fd8 136 crc ^= (uint16_t)buf[pos]; // XOR byte into least sig. byte of crc
davidjhoward 4:c35db3946fd8 137
davidjhoward 4:c35db3946fd8 138 for (int i = 8; i != 0; i--) {
davidjhoward 4:c35db3946fd8 139 // Loop over each bit
davidjhoward 4:c35db3946fd8 140 if ((crc & 0x0001) != 0) {
davidjhoward 4:c35db3946fd8 141 // If the LSB is set
davidjhoward 4:c35db3946fd8 142 crc >>= 1; // Shift right and XOR 0xA001
davidjhoward 4:c35db3946fd8 143 crc ^= 0xA001;
davidjhoward 4:c35db3946fd8 144 } else // Else LSB is not set
davidjhoward 4:c35db3946fd8 145 crc >>= 1; // Just shift right
davidjhoward 4:c35db3946fd8 146 }
davidjhoward 4:c35db3946fd8 147 }
davidjhoward 4:c35db3946fd8 148 // Note, this number has low and high bytes swapped, so use it accordingly (or swap bytes)
davidjhoward 4:c35db3946fd8 149 return crc;
davidjhoward 4:c35db3946fd8 150 }
davidjhoward 4:c35db3946fd8 151
davidjhoward 4:c35db3946fd8 152 RawSerial modbus(PA_2, PA_3);
davidjhoward 4:c35db3946fd8 153 DigitalOut modbus_enable0(PB_0);
davidjhoward 4:c35db3946fd8 154 DigitalOut modbus_enable1(PB_1);
davidjhoward 4:c35db3946fd8 155
davidjhoward 4:c35db3946fd8 156 void modbus_init( uint16_t baudRate )
davidjhoward 4:c35db3946fd8 157 {
davidjhoward 4:c35db3946fd8 158 modbus.baud(baudRate);
davidjhoward 4:c35db3946fd8 159 modbus.attach(&modbus_recv, RawSerial::RxIrq);
davidjhoward 4:c35db3946fd8 160 }
davidjhoward 4:c35db3946fd8 161
davidjhoward 4:c35db3946fd8 162 //call back when character goes into RX buffer for RS485 modbus
davidjhoward 4:c35db3946fd8 163 void modbus_recv()
davidjhoward 4:c35db3946fd8 164 {
davidjhoward 4:c35db3946fd8 165
davidjhoward 4:c35db3946fd8 166 if (modbus.readable()) {
davidjhoward 4:c35db3946fd8 167 modbus_buffer_char = modbus.getc();
davidjhoward 4:c35db3946fd8 168 if (modbus_input_buffer_counter == 0 && modbus_buffer_char == 0x00) {
davidjhoward 4:c35db3946fd8 169 modbus_input_buffer_counter = 0;
davidjhoward 4:c35db3946fd8 170 } else {
davidjhoward 4:c35db3946fd8 171 modbus_input_buffer[modbus_input_buffer_counter] = modbus_buffer_char;
davidjhoward 4:c35db3946fd8 172 modbus_input_buffer_counter++;
davidjhoward 4:c35db3946fd8 173 }
davidjhoward 4:c35db3946fd8 174 }
davidjhoward 4:c35db3946fd8 175
davidjhoward 4:c35db3946fd8 176 if (modbus_input_buffer_counter > modbus_input_buffer[2] + 4) {
davidjhoward 4:c35db3946fd8 177 modbus_interrupt_complete = true;
davidjhoward 4:c35db3946fd8 178 modbus_input_buffer_counter = 0;
davidjhoward 4:c35db3946fd8 179 }
davidjhoward 4:c35db3946fd8 180 }
davidjhoward 4:c35db3946fd8 181
davidjhoward 4:c35db3946fd8 182 // Read modbus master frame
davidjhoward 9:ef0ca2f8a8a6 183 void SendModbusCommand(uint8_t slave_address, uint16_t firstReg, uint16_t noRegs)
davidjhoward 4:c35db3946fd8 184 {
davidjhoward 4:c35db3946fd8 185 uint8_t L1V[8] = {slave_address, 0x04, 0x00, 0x02, 0x00, 0x02, 0xD1, 0x16};
davidjhoward 4:c35db3946fd8 186
davidjhoward 4:c35db3946fd8 187 L1V[2] = (firstReg >> 8) & 0xFF;
davidjhoward 4:c35db3946fd8 188 L1V[3] = firstReg & 0xFF;
davidjhoward 4:c35db3946fd8 189 L1V[4] = (noRegs >> 8) & 0xFF;
davidjhoward 4:c35db3946fd8 190 L1V[5] = noRegs & 0xFF;
davidjhoward 4:c35db3946fd8 191 L1V[6] = modbus_crc(L1V,6) & 0xFF;
davidjhoward 4:c35db3946fd8 192 L1V[7] = (modbus_crc(L1V,6)>>8) & 0xFF;
davidjhoward 4:c35db3946fd8 193
davidjhoward 4:c35db3946fd8 194 modbus_enable0 = 1;
davidjhoward 4:c35db3946fd8 195 modbus_enable1 = 1;
davidjhoward 4:c35db3946fd8 196
davidjhoward 4:c35db3946fd8 197 for (uint8_t i = 0; i < 8; i++)
davidjhoward 4:c35db3946fd8 198 modbus.putc(L1V[i]);
davidjhoward 4:c35db3946fd8 199
davidjhoward 4:c35db3946fd8 200 wait_ms(2);
davidjhoward 4:c35db3946fd8 201 modbus_enable0 = 0;
davidjhoward 4:c35db3946fd8 202 modbus_enable1 = 0;
davidjhoward 4:c35db3946fd8 203
davidjhoward 4:c35db3946fd8 204 }
davidjhoward 4:c35db3946fd8 205
davidjhoward 4:c35db3946fd8 206 bool mbInterruptComplete()
davidjhoward 4:c35db3946fd8 207 {
davidjhoward 4:c35db3946fd8 208 if (modbus_interrupt_complete) {
davidjhoward 4:c35db3946fd8 209 modbus_interrupt_complete = false;
davidjhoward 4:c35db3946fd8 210 return true;
davidjhoward 4:c35db3946fd8 211 } else {
davidjhoward 4:c35db3946fd8 212 return false;
davidjhoward 4:c35db3946fd8 213 }
davidjhoward 4:c35db3946fd8 214 }
davidjhoward 4:c35db3946fd8 215
davidjhoward 15:a6ee32969e8e 216 bool ReadModbus_32bit_float( float *float_value, int order )
davidjhoward 4:c35db3946fd8 217 {
davidjhoward 15:a6ee32969e8e 218 MR_REGISTER_32_BIT_FLOAT value;
davidjhoward 31:4b1587034318 219
davidjhoward 4:c35db3946fd8 220 if (mbInterruptComplete() != true ) {
davidjhoward 4:c35db3946fd8 221 return false;
davidjhoward 4:c35db3946fd8 222 }
davidjhoward 4:c35db3946fd8 223
davidjhoward 15:a6ee32969e8e 224 switch( order ) {
davidjhoward 31:4b1587034318 225 case BigEndian:
davidjhoward 15:a6ee32969e8e 226 value.b.lo_lo = modbus_input_buffer[6];
davidjhoward 15:a6ee32969e8e 227 value.b.lo_hi = modbus_input_buffer[5];
davidjhoward 15:a6ee32969e8e 228 value.b.hi_lo = modbus_input_buffer[4];
davidjhoward 15:a6ee32969e8e 229 value.b.hi_hi = modbus_input_buffer[3];
davidjhoward 15:a6ee32969e8e 230 break;
davidjhoward 15:a6ee32969e8e 231 case BigEndianReverseWord:
davidjhoward 15:a6ee32969e8e 232 value.b.lo_lo = modbus_input_buffer[4];
davidjhoward 15:a6ee32969e8e 233 value.b.lo_hi = modbus_input_buffer[3];
davidjhoward 15:a6ee32969e8e 234 value.b.hi_lo = modbus_input_buffer[6];
davidjhoward 15:a6ee32969e8e 235 value.b.hi_hi = modbus_input_buffer[5];
davidjhoward 15:a6ee32969e8e 236 break;
davidjhoward 15:a6ee32969e8e 237 default:
davidjhoward 15:a6ee32969e8e 238 return false;
davidjhoward 15:a6ee32969e8e 239 }
davidjhoward 15:a6ee32969e8e 240 *float_value = value.f;
davidjhoward 4:c35db3946fd8 241 return true;
davidjhoward 4:c35db3946fd8 242 }