File content as of revision 9:ef0ca2f8a8a6:

/******************************************************************************
 *
 * File:                ModbusMaster.cpp
 * Desciption:          source for the ICE Modbus Master
 *
 *****************************************************************************/
#include "global.h"
#include <stdio.h>
#include "BLEDataHandler.h"
#include "ModbusMaster.h"
#include "MbedJSONValue.h"

/*****************************************************************************
 * Function:             ModbusMaster
 * Description:          entry point for the Modbus Master
 *
 * @param                (IN) args (user-defined arguments)
 * @return               none
 *****************************************************************************/

void ModbusMaster(void const *args)
{
    printf("\r%s has started...\n", __func__);
    char scratch_buf[1024];
    MbedJSONValue json_value;

    // configure modbus registers based in all files that start with "input"
    std::vector<mDot::mdot_file> file_list = GLOBAL_mdot->listUserFiles();
    for (std::vector<mDot::mdot_file>::iterator i = file_list.begin(); i != file_list.end(); ++i) {
        if( strncmp( i->name, "input", strlen("input")) == 0 ) {

            printf("\r(%d)FOUND INPUT FILE: %s\n", __LINE__, i->name);

            bool status = GLOBAL_mdot->readUserFile(i->name, (void *)scratch_buf, 1024);
            if( status != true ) {
                printf("\r(%d)read file failed, status=%d\n", __LINE__, status);
            } else {
                printf("\r(%d)Read File SUCCESS: %s\n", __LINE__, scratch_buf );
            }

            parse( json_value, scratch_buf );

            std::string id = json_value["id"].get<std::string>().c_str();
            ModbusRegisterMap[id].name = json_value["name"].get<std::string>().c_str();
            ModbusRegisterMap[id].units = json_value["units"].get<std::string>().c_str();
            ModbusRegisterMap[id].min = json_value["min"].get<double>();
            ModbusRegisterMap[id].max = json_value["max"].get<double>();
            ModbusRegisterMap[id].node = json_value["node"].get<int>();
            ModbusRegisterMap[id].reg = json_value["reg"].get<int>();
            ModbusRegisterMap[id].rtype = json_value["rtype"].get<int>();
            ModbusRegisterMap[id].type = json_value["type"].get<int>();
            ModbusRegisterMap[id].fmt = json_value["fmt"].get<std::string>().c_str();

        }
    }

    // read modbus registers that have been configured.
    while ( true ) {

        std::map<std::string, ModbusRegister>::iterator iter;
        for (iter = ModbusRegisterMap.begin(); iter != ModbusRegisterMap.end(); ++iter) {
//            SendModbusCommand(iter->first.node,(uint16_t)iter->first.reg,13);
        }
    }
}


volatile char       modbus_buffer_char;
volatile bool       modbus_interrupt_complete = false;

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
volatile uint8_t    modbus_input_buffer_counter = 0;

//Frame crc calucation
uint16_t modbus_crc(uint8_t* buf, int len)
{
    uint16_t crc = 0xFFFF;

    for (int pos = 0; pos < len; pos++) {
        crc ^= (uint16_t)buf[pos];          // XOR byte into least sig. byte of crc

        for (int i = 8; i != 0; i--) {
            // Loop over each bit
            if ((crc & 0x0001) != 0) {
                // If the LSB is set
                crc >>= 1;                    // Shift right and XOR 0xA001
                crc ^= 0xA001;
            } else                          // Else LSB is not set
                crc >>= 1;                    // Just shift right
        }
    }
    // Note, this number has low and high bytes swapped, so use it accordingly (or swap bytes)
    return crc;
}

RawSerial modbus(PA_2, PA_3);
DigitalOut modbus_enable0(PB_0);
DigitalOut modbus_enable1(PB_1);

void modbus_init( uint16_t baudRate )
{
    modbus.baud(baudRate);
    modbus.attach(&modbus_recv, RawSerial::RxIrq);
}

//call back when character goes into RX buffer for RS485 modbus
void modbus_recv()
{

    if (modbus.readable()) {
        modbus_buffer_char = modbus.getc();
        if (modbus_input_buffer_counter == 0 && modbus_buffer_char == 0x00) {
            modbus_input_buffer_counter = 0;
        } else {
            modbus_input_buffer[modbus_input_buffer_counter] = modbus_buffer_char;
            modbus_input_buffer_counter++;
        }
    }

    if (modbus_input_buffer_counter > modbus_input_buffer[2] + 4) {
        modbus_interrupt_complete = true;
        modbus_input_buffer_counter = 0;
    }
}

// Read modbus master frame
void SendModbusCommand(uint8_t slave_address, uint16_t firstReg, uint16_t noRegs)
{
    uint8_t L1V[8] = {slave_address, 0x04, 0x00, 0x02, 0x00, 0x02, 0xD1, 0x16};

    L1V[2] = (firstReg >> 8) & 0xFF;
    L1V[3] = firstReg & 0xFF;
    L1V[4] = (noRegs >> 8) & 0xFF;
    L1V[5] = noRegs & 0xFF;
    L1V[6] = modbus_crc(L1V,6) & 0xFF;
    L1V[7] = (modbus_crc(L1V,6)>>8) & 0xFF;

    modbus_enable0 = 1;
    modbus_enable1 = 1;

    for (uint8_t i = 0; i < 8; i++)
        modbus.putc(L1V[i]);

    wait_ms(2);
    modbus_enable0 = 0;
    modbus_enable1 = 0;

}

bool mbInterruptComplete()
{
    if (modbus_interrupt_complete) {
        modbus_interrupt_complete = false;
        return true;
    } else {
        return false;
    }
}

bool mbFluGetData( MB_FLU_VALUES *flu_values )
{
    MR_REGISTER_FLOAT trasar;
    MR_REGISTER_FLOAT tag;
    MR_REGISTER_FLOAT rz;
    MR_REGISTER_FLOAT rs;
    MR_REGISTER_FLOAT tra_back;
    MR_REGISTER_FLOAT turb;
    MR_REGISTER_WORD cf;
//    MR_REGISTER_WORD crc;

    if (mbInterruptComplete() != true ) {
        return false;
    }

//    printf("Address: %d, Function: %d, No Regs: %d, \r\n",modbus_input_buffer[0],modbus_input_buffer[1],modbus_input_buffer[2]/2);
//
//    printf("Data: %x%x,%x%x,%x%x,%x%x,%x%x,%x%x,\r\n%x%x,%x%x,%x%x,%x%x,%x%x,%x%x,\r\n%x%x\r\n",
//            modbus_input_buffer[3],modbus_input_buffer[4], modbus_input_buffer[5],modbus_input_buffer[6],       // Trasar
//            modbus_input_buffer[7],modbus_input_buffer[8], modbus_input_buffer[9],modbus_input_buffer[10],      // Tag
//            modbus_input_buffer[11],modbus_input_buffer[12], modbus_input_buffer[13],modbus_input_buffer[14],   // Rz
//            modbus_input_buffer[15],modbus_input_buffer[16], modbus_input_buffer[17],modbus_input_buffer[18],   // Rs
//            modbus_input_buffer[19],modbus_input_buffer[20], modbus_input_buffer[21],modbus_input_buffer[22],   // TraBack
//            modbus_input_buffer[23],modbus_input_buffer[24], modbus_input_buffer[25],modbus_input_buffer[26],   // TraBack
//            modbus_input_buffer[27],modbus_input_buffer[28]);                                                   // Cf
//    printf("CRC: %x%x\r\n",modbus_input_buffer[29], modbus_input_buffer[30]);

    trasar.b.lo_lo = modbus_input_buffer[4];
    trasar.b.lo_hi = modbus_input_buffer[3];
    trasar.b.hi_lo = modbus_input_buffer[6];
    trasar.b.hi_hi = modbus_input_buffer[5];
//    printf("Trasar=%2.2f, 0x%x, 0x%x\r\n",trasar.f, trasar.w.lo, trasar.w.hi);
    flu_values->trasar = trasar.f;

    tag.b.lo_lo = modbus_input_buffer[8];
    tag.b.lo_hi = modbus_input_buffer[7];
    tag.b.hi_lo = modbus_input_buffer[10];
    tag.b.hi_hi = modbus_input_buffer[9];
//    printf("tag=%2.2f, 0x%x, 0x%x\r\n",tag.f, tag.w.lo, tag.w.hi);
    flu_values->tag = tag.f;

    rz.b.lo_lo = modbus_input_buffer[12];
    rz.b.lo_hi = modbus_input_buffer[11];
    rz.b.hi_lo = modbus_input_buffer[14];
    rz.b.hi_hi = modbus_input_buffer[13];
//    printf("rz=%2.2f, 0x%x, 0x%x\r\n",rz.f, rz.w.lo, rz.w.hi);
    flu_values->rz = rz.f;

    rs.b.lo_lo = modbus_input_buffer[16];
    rs.b.lo_hi = modbus_input_buffer[15];
    rs.b.hi_lo = modbus_input_buffer[18];
    rs.b.hi_hi = modbus_input_buffer[17];
//    printf("rs=%2.2f, 0x%x, 0x%x\r\n",rs.f, rs.w.lo, rs.w.hi);
    flu_values->rs = rs.f;

    tra_back.b.lo_lo = modbus_input_buffer[20];
    tra_back.b.lo_hi = modbus_input_buffer[19];
    tra_back.b.hi_lo = modbus_input_buffer[22];
    tra_back.b.hi_hi = modbus_input_buffer[21];
//    printf("tra_back=%2.2f, 0x%x, 0x%x\r\n",tra_back.f, tra_back.w.lo, tra_back.w.hi);
    flu_values->tra_back = tra_back.f;

    turb.b.lo_lo = modbus_input_buffer[24];
    turb.b.lo_hi = modbus_input_buffer[23];
    turb.b.hi_lo = modbus_input_buffer[26];
    turb.b.hi_hi = modbus_input_buffer[25];
//    printf("turb=%2.2f, 0x%x, 0x%x\r\n",turb.f, turb.w.lo, turb.w.hi);
    flu_values->turb = turb.f;

    cf.b.lo = modbus_input_buffer[28];
    cf.b.hi = modbus_input_buffer[27];
//    printf("cf=%d, 0x%x,\r\n",cf.w, cf.w);
    flu_values->cf = cf.w;

//    crc.b.lo = modbus_input_buffer[30]; crc.b.hi = modbus_input_buffer[29];
//    printf("crc=%d, 0x%x,\r\n",crc.w, crc.w);

    return true;
}

bool mbTconGetData( MB_TCON_VALUES *tcon_values )
{
    MR_REGISTER_INT tcon_cal;
    MR_REGISTER_INT tcon_cmp;
    MR_REGISTER_INT tcon_2pt;
    MR_REGISTER_INT tcon_freq;
    MR_REGISTER_INT rtd_degC;
    MR_REGISTER_INT rtd_cal;
    MR_REGISTER_INT rtd_raw;

    if (mbInterruptComplete() != true ) {
        return false;
    }

//    printf("Address: %d, Function: %d, No Regs: %d, \r\n",modbus_input_buffer[0],modbus_input_buffer[1],modbus_input_buffer[2]/2);
//
//    printf("Data: %x%x,%x%x,    %x%x,%x%x,    %x%x,%x%x,\r\n%x%x,%x%x,    %x%x,%x%x,    %x%x,%x%x\r\n",
//            modbus_input_buffer[3],modbus_input_buffer[4], modbus_input_buffer[5],modbus_input_buffer[6],       // tcon_cal
//            modbus_input_buffer[7],modbus_input_buffer[8], modbus_input_buffer[9],modbus_input_buffer[10],      // tcon_cmp
//            modbus_input_buffer[11],modbus_input_buffer[12], modbus_input_buffer[13],modbus_input_buffer[14],   // tcon_2pt
//            modbus_input_buffer[15],modbus_input_buffer[16], modbus_input_buffer[17],modbus_input_buffer[18],   // rtd_degC
//            modbus_input_buffer[19],modbus_input_buffer[20], modbus_input_buffer[21],modbus_input_buffer[22],   // rtd_cal
//            modbus_input_buffer[23],modbus_input_buffer[24], modbus_input_buffer[25],modbus_input_buffer[26]);  // rtd_raw
//    printf("CRC: %x%x\r\n",modbus_input_buffer[27], modbus_input_buffer[28]);

    rtd_raw.b.lo_lo = modbus_input_buffer[4];
    rtd_raw.b.lo_hi = modbus_input_buffer[3];
    rtd_raw.b.hi_lo = modbus_input_buffer[6];
    rtd_raw.b.hi_hi = modbus_input_buffer[5];
//    printf("rtd_raw=%d M Ohm, 0x%x, 0x%x\r\n",rtd_raw.i, rtd_raw.w.lo, rtd_raw.w.hi);
    tcon_values->rtd_raw = rtd_raw.i;

    rtd_cal.b.lo_lo = modbus_input_buffer[8];
    rtd_cal.b.lo_hi = modbus_input_buffer[7];
    rtd_cal.b.hi_lo = modbus_input_buffer[10];
    rtd_cal.b.hi_hi = modbus_input_buffer[9];
//    printf("rtd_cal=%d M Ohm, 0x%x, 0x%x\r\n",rtd_cal.i, rtd_cal.w.lo, rtd_cal.w.hi);
    tcon_values->rtd_cal = rtd_cal.i;

    rtd_degC.b.lo_lo = modbus_input_buffer[12];
    rtd_degC.b.lo_hi = modbus_input_buffer[11];
    rtd_degC.b.hi_lo = modbus_input_buffer[14];
    rtd_degC.b.hi_hi = modbus_input_buffer[13];
//    printf("rtd_degC=%2.2f C, 0x%x, 0x%x\r\n",(rtd_degC.i/1000.0), rtd_degC.w.lo, rtd_degC.w.hi);
    tcon_values->rtd_degC = (rtd_degC.i/1000.0);

    tcon_freq.b.lo_lo = modbus_input_buffer[16];
    tcon_freq.b.lo_hi = modbus_input_buffer[15];
    tcon_freq.b.hi_lo = modbus_input_buffer[18];
    tcon_freq.b.hi_hi = modbus_input_buffer[17];
//    printf("tcon_freq=%d Hz, 0x%x, 0x%x\r\n",tcon_freq.i, tcon_freq.w.lo, tcon_freq.w.hi);
    tcon_values->tcon_freq = tcon_freq.i;

    tcon_2pt.b.lo_lo = modbus_input_buffer[20];
    tcon_2pt.b.lo_hi = modbus_input_buffer[19];
    tcon_2pt.b.hi_lo = modbus_input_buffer[22];
    tcon_2pt.b.hi_hi = modbus_input_buffer[21];
//    printf("tcon_2pt=%d uS, 0x%x, 0x%x\r\n",tcon_2pt.i, tcon_2pt.w.lo, tcon_2pt.w.hi);
    tcon_values->tcon_2pt = tcon_2pt.i;

    tcon_cmp.b.lo_lo = modbus_input_buffer[20];
    tcon_cmp.b.lo_hi = modbus_input_buffer[19];
    tcon_cmp.b.hi_lo = modbus_input_buffer[22];
    tcon_cmp.b.hi_hi = modbus_input_buffer[21];
//    printf("tcon_cmp=%d uS, 0x%x, 0x%x\r\n",tcon_cmp.i, tcon_cmp.w.lo, tcon_cmp.w.hi);
    tcon_values->tcon_cmp = tcon_cmp.i;

    tcon_cal.b.lo_lo = modbus_input_buffer[20];
    tcon_cal.b.lo_hi = modbus_input_buffer[19];
    tcon_cal.b.hi_lo = modbus_input_buffer[22];
    tcon_cal.b.hi_hi = modbus_input_buffer[21];
//    printf("tcon_cal=%d, 0x%x, 0x%x\r\n",tcon_cal.i, tcon_cal.w.lo, tcon_cal.w.hi);
    tcon_values->tcon_cal = tcon_cal.i;

    return true;
}