File content as of revision 4:c35db3946fd8:

/******************************************************************************
 *
 * File:                ModbusMaster.cpp
 * Desciption:          source for the ICE Modbus Master
 *
 *****************************************************************************/
#include "global.h"
#include <stdio.h>
#include "BLEDataHandler.h"
#include "ModbusMaster.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__);

    while ( true ) {
        // Send request to Fluorometer
        printf("\rsending request to FLU\n");
        modbus_read_L1V(1,9,13);
        // Wait 30mS
        printf("\rsent request to FLU\n");
        osDelay(30);
        printf("\rgetting TRASAR readings\n");
        // Read data from Fluorometer
        MB_FLU_VALUES flu_values;
        if( mbFluGetData( &flu_values ) == false ) {
            printf("\rCould not get TRASAR readings, power cycle\n");
            DigitalOut flu_power(PA_11);
            flu_power = 1; // turn modbus power off
            osDelay(1000);
            flu_power = 0; // provide power to the modbus
            flu_values.trasar = 0.0;
            osDelay(5000);
            return;
        }
    }
}


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 modbus_read_L1V(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;
}