ModbusBridge Class Reference

#include <ModbusBridge.h>

Inheritance diagram for ModbusBridge:

Public Types
enum	FLAGS { DEBUG_RECEIVE = 1, DEBUG_SEND = 2 }

Public Member Functions
void	clearQueue ()
short	debug ()
Mudbus *	getMudbus ()
short	info ()
short	loop ()
short	loop_test ()
short	loopPoll ()
Modbus *	modbus ()
	ModbusBridge (App *owner)
Query *	nextByPrio (uchar state, int prio)
Query *	nextQueryByOwner (uchar state=DONE, int owner=-1)
Query *	nextQueryByState (uchar state=DONE, int owner=-1)
Query *	nextQueryByState2 (uchar state, int owner)
Query *	nextSame (uchar state, short slave, int addr, short fn, int value)
int	numByState (int state=DONE)
int	numSame (uchar state, short slave, int addr, short fn, int value)
int	numSameOwner (uchar state, short slave, int addr, short fn, int value, int owner)
void	print ()
short	qstate ()
short	query (int slave, short function, long start, int coils, Component *_owner, ComponentFnPtr _responseFn)
short	query (int slave, short function, long start, int coils, int _ownerId)
short	queryState ()
void	setDebugSend (bool debug)
short	setup ()
bool	skipRead (int slave, int fn, int addr, int num, int prio)

Public Attributes
PHApp *	app
short	cAddr
short	cFN
int	cNB
short	cSlave
long	debug_flags
Mudbus *	mb
uint16_t	ModbusSlaveRegisters [8]
int	nextWaitingTime
ComponentFnPtr	onError
ComponentRxFn	onMessage
int	ownerId
Query	queries [MAX_QUERY_BUFFER]
ComponentFnPtr	responseFn
Component *	rOwner
millis_t	startTS

Detailed Description

Definition at line 107 of file ModbusBridge.h.

Member Enumeration Documentation

FLAGS

enum ModbusBridge::FLAGS

Enumerator
DEBUG_RECEIVE
DEBUG_SEND

Definition at line 111 of file ModbusBridge.h.

    {
        DEBUG_RECEIVE = 1,
        DEBUG_SEND = 2,
    };

Constructor & Destructor Documentation

ModbusBridge()

ModbusBridge::ModbusBridge ( App *  owner )

inline

Definition at line 117 of file ModbusBridge.h.

                             : Component("ModbusBridge", 1000, Component::COMPONENT_DEFAULT, (Component *)owner),
                               mb(new Mudbus()),
                               app(owner)
    {
        setFlag(OBJECT_RUN_FLAGS::E_OF_DEBUG);
        debug_flags = 1 << DEBUG_RECEIVE;
        nextWaitingTime = 100;
        ownerId = -1;
        owner = NULL;
        responseFn = NULL;
        onError = NULL;
        onMessage = NULL;
    }

Member Function Documentation

clearQueue()

void ModbusBridge::clearQueue

(

)

Definition at line 119 of file ModbusBridge.cpp.

{
    millis_t t = millis();
    for (int i = 0; i < MAX_QUERY_BUFFER; i++)
    {
        if ((queries[i].state == QUEUED ||
             queries[i].state == PROCESSING) &&
            t - queries[i].ts > MODBUS_MAX_LIFESPAN)
        {
            if (debugReset)
            {
                queries[i].print();
                print();
            }
            queries[i].reset();
            continue;
        }
    }
}

debug()

short ModbusBridge::debug

(

)

Definition at line 531 of file ModbusBridge.cpp.

{
    return E_OK;
}

getMudbus()

Mudbus* ModbusBridge::getMudbus ( )

inline

Definition at line 167 of file ModbusBridge.h.

    {
        return mb;
    }

info()

short ModbusBridge::info

(

)

Definition at line 535 of file ModbusBridge.cpp.

{
    return E_OK;
}

loop()

short ModbusBridge::loop

(

)

Definition at line 309 of file ModbusBridge.cpp.

{
    clearQueue();
    loopPoll();
    mb->Run();
    return E_OK;
}

loop_test()

short ModbusBridge::loop_test

(

)

Definition at line 466 of file ModbusBridge.cpp.

{
    switch (_state)
    {
 
    case IDLE:
    {
        return E_OK;
    }
 
    case WAITING:
    {
        if (millis() > WaitingTime)
        {
            _state++; // set to query state
        }
        break;
    }
    case QUERY:
    {
        ModbusQuery[0].u8id = cSlave;                  // slave address
        ModbusQuery[0].u8fct = cFN;                    // function code (this one is registers read)
        ModbusQuery[0].u16RegAdd = cAddr;              // start address in slave
        ModbusQuery[0].u16CoilsNo = cNB;               // number of elements (coils or registers) to read
        ModbusQuery[0].au16reg = ModbusSlaveRegisters; // pointer to a memory array in the CONTROLLINO
        master.query(ModbusQuery[0]);                  // send query (only once)
        _state++;                                      // set to RESPONSE
        break;
    }
    case RESPONSE:
    {
        master.poll();
        if (master.getState() == COM_IDLE)
        {
            int errors = master.getErrCnt();
            if (errors)
            {
                if (rOwner && onError != NULL)
                {
                    (rOwner->*onError)(master.getLastError(), 1);
                    Log.verboseln("MB-Error: %d | Slave=%d | FN=%d", master.getLastError(), cSlave, cFN);
                    master.clearError();
                }
                else
                {
                    Log.errorln("MB-Error::%d", master.getLastError());
                }
                _state = IDLE;
                return E_OK;
            }
 
            long onMessageError = 0;
            if (rOwner && onMessage)
            {
                onMessageError = (rOwner->*onMessage)(master.rxSize, master.rxBuffer);
            }
            (rOwner->*responseFn)(onMessageError, 1);
            WaitingTime = millis() + nextWaitingTime;
            _state = IDLE;
        }
        break;
    }
    }
    return E_OK;
}

loopPoll()

short ModbusBridge::loopPoll

(

)

Definition at line 393 of file ModbusBridge.cpp.

{
    switch (_state)
    {
 
    case IDLE:
    {
        return E_OK;
    }
 
    case WAITING:
    {
        if (millis() > WaitingTime)
        {
            _state = QUERY;
        }
        break;
    }
    case QUERY:
    {
        ModbusQuery[0].u8id = cSlave;                  // slave address
        ModbusQuery[0].u8fct = cFN;                    // function code (this one is registers read)
        ModbusQuery[0].u16RegAdd = cAddr;              // start address in slave
        ModbusQuery[0].u16CoilsNo = cNB;               // number of elements (coils or registers) to read
        ModbusQuery[0].au16reg = ModbusSlaveRegisters; // pointer to a memory array in the CONTROLLINO
        master.query(ModbusQuery[0]);                  // send query (only once)
        _state = RESPONSE;                             // set to RESPONSE
        break;
    }
    case RESPONSE:
    {
        master.poll();
        Component *c = NULL;
 
        if (owner && ownerId)
        {
            c = app->byId(ownerId);
        }
 
        if (master.getState() == COM_IDLE)
        {
            _state = IDLE;
            int errors = master.getErrCnt();
            if (errors)
            {
                if (debugErrors)
                {
                    Log.verboseln("Modbus Error : %d | Slave=%d | FN=%d", master.getLastError(), cSlave, cFN);
                }
                if (c)
                {
                    c->onError(id, master.getLastError());
                }
                master.clearError();
                ownerId = 0;
                return E_OK;
            }
 
            long onMessageError = 0;
            if (c)
            {
                onMessageError = c->onRawResponse(master.rxSize, master.rxBuffer);
                c->onResponse(onMessageError);
            }
            WaitingTime = millis() + nextWaitingTime;
 
            ownerId = 0;
        }
        break;
    }
    }
    return E_OK;
}

modbus()

Modbus * ModbusBridge::modbus

(

)

Definition at line 35 of file ModbusBridge.cpp.

{
    return &master;
}

nextByPrio()

Query * ModbusBridge::nextByPrio	(	uchar	state,
		int	prio
	)

Definition at line 60 of file ModbusBridge.cpp.

{
    Query *oldest;
    for (int i = 0; i < MAX_QUERY_BUFFER; i++)
    {
        if (!oldest)
        {
            oldest = &queries[i];
        }
        if (queries[i].state == state && queries[i].prio == prio)
        {
            oldest = &queries[i];
        }
    }
    return oldest;
}

nextQueryByOwner()

Query * ModbusBridge::nextQueryByOwner	(	uchar	state = DONE,
		int	owner = -1
	)

Definition at line 173 of file ModbusBridge.cpp.

{
    millis_t t = millis();
    Query *oldest = NULL;
    for (int i = 0; i < MAX_QUERY_BUFFER; i++)
    {
        if (queries[i].state == state && queries[i].owner == owner)
        {
 
            if (queries[i].ts == 0)
            {
                queries[i].ts = t;
                continue;
            }
 
            if (queries[i].prio == MB_QUERY_TYPE_CMD && t - queries[i].ts > 300)
            {
                return &queries[i];
            }
 
            if (!oldest)
            {
                oldest = &queries[i];
            }
 
            if (queries[i].ts > oldest->ts)
            {
                oldest = &queries[i];
            }
        }
    }
    return oldest;
}

nextQueryByState()

Query * ModbusBridge::nextQueryByState	(	uchar	state = DONE,
		int	owner = -1
	)

Definition at line 138 of file ModbusBridge.cpp.

{
    if (owner > 0)
    {
        Query *q = nextQueryByOwner(state, owner);
        if (q != NULL)
        {
            return q;
        }
    }
 
    millis_t t = millis();
    Query *oldest = NULL;
    for (int i = 0; i < MAX_QUERY_BUFFER; i++)
    {
        if (queries[i].state == state)
        {
            if (queries[i].prio != MB_QUERY_TYPE_CMD && t - queries[i].ts > 1000)
            {
                return &queries[i];
            }
 
            if (!oldest)
            {
                oldest = &queries[i];
            }
 
            if (queries[i].ts > oldest->ts)
            {
                oldest = &queries[i];
            }
        }
    }
    return oldest;
}

nextQueryByState2()

Query * ModbusBridge::nextQueryByState2	(	uchar	state,
		int	owner
	)

Definition at line 76 of file ModbusBridge.cpp.

{
    Query *ret = NULL;
    for (int i = 0; i < MAX_QUERY_BUFFER; i++)
    {
        if (queries[i].state == state && queries[i].owner == owner)
        {
            if (!ret)
            {
                ret = &queries[i];
            }
 
            if (queries[i].prio > ret->prio)
            {
                ret = &queries[i];
            }
        }
    }
    return ret;
}

nextSame()

Query * ModbusBridge::nextSame	(	uchar	state,
		short	slave,
		int	addr,
		short	fn,
		int	value
	)

Definition at line 206 of file ModbusBridge.cpp.

{
    Query *oldest = NULL;
    for (int i = 0; i < MAX_QUERY_BUFFER; i++)
    {
        if (queries[i].state == state)
        {
            Query *q = &queries[i];
            if (q->addr == addr && q->fn == fn && q->value == value && q->slave == slave)
            {
                if (!oldest)
                {
                    oldest = &queries[i];
                }
                if (queries[i].ts > oldest->ts)
                {
                    oldest = &queries[i];
                }
            }
        }
    }
    return oldest;
}

numByState()

int ModbusBridge::numByState

(

int

state = DONE

)

Definition at line 261 of file ModbusBridge.cpp.

{
    int num = 0;
    for (int i = 0; i < MAX_QUERY_BUFFER; i++)
    {
        if (queries[i].state == state)
        {
            num++;
        }
    }
    return num;
}

numSame()

int ModbusBridge::numSame	(	uchar	state,
		short	slave,
		int	addr,
		short	fn,
		int	value
	)

Definition at line 229 of file ModbusBridge.cpp.

{
    int num = 0;
    for (int i = 0; i < MAX_QUERY_BUFFER; i++)
    {
        if (queries[i].state == state)
        {
            Query *q = &queries[i];
            if (q->addr == addr && q->fn == fn && q->value == value && q->slave == slave)
            {
                num++;
            }
        }
    }
    return num;
}

numSameOwner()

int ModbusBridge::numSameOwner	(	uchar	state,
		short	slave,
		int	addr,
		short	fn,
		int	value,
		int	owner
	)

Definition at line 245 of file ModbusBridge.cpp.

{
    int num = 0;
    for (int i = 0; i < MAX_QUERY_BUFFER; i++)
    {
        if (queries[i].state == state && queries[i].owner == owner)
        {
            Query *q = &queries[i];
            if (q->addr == addr && q->fn == fn && q->value == value && q->slave == slave)
            {
                num++;
            }
        }
    }
    return num;
}

print()

void ModbusBridge::print

(

)

Definition at line 273 of file ModbusBridge.cpp.

{
#ifdef HAS_DEBUG_MODBUS_BRIDGE_PRINT_QUEUE
    Serial.print("----- Queries : --- ");
    Serial.print("Proccessing : ");
    Serial.print(numByState(PROCESSING));
    Serial.print(" | QUEUED : ");
    Serial.print(numByState(QUEUED));
    Serial.print(" | DONE: ");
    Serial.print(numByState(DONE));
    Serial.print(" | ADDR: ");
    Serial.print(cAddr);
    Serial.print(" | FN: ");
    Serial.print(cFN);
    Serial.print(" | NOW : ");
    Serial.print(millis());
    Serial.print("-----\n");
    for (int i = 0; i < MAX_QUERY_BUFFER; i++)
    {
        if (queries[i].state == DONE)
        {
            continue;
        }
        Serial.print(" - ");
        Serial.print(queries[i].id);
        Serial.print(". \t ");
        queries[i].print();
        Serial.print("\n");
    }
#endif
}

qstate()

short ModbusBridge::qstate

(

)

Definition at line 304 of file ModbusBridge.cpp.

{
    return _state;
    // return modbus->getState();
}

query() [1/2]

short ModbusBridge::query	(	int	slave,
		short	function,
		long	start,
		int	coils,
		Component *	_owner,
		ComponentFnPtr	_responseFn
	)

Definition at line 316 of file ModbusBridge.cpp.

{
    if (qstate() != IDLE)
    {
        return WAITING;
    }
 
    cAddr = 0;
    cSlave = slave;
    cFN = function;
    cAddr = start;
    cNB = coils;
    rOwner = _owner;
    responseFn = _responseFn;
#ifdef HAS_DEBUG_MODBUS_BRIDGE_PRINT_QUERY
    if (__debugQuery)
    {
        Serial.print("\n --------------Modbus QUERY --------- SLAVE :  ");
        Serial.print(slave);
        Serial.print(" | FN : ");
        Serial.print(cFN);
        Serial.print(" | NB : ");
        Serial.print(coils);
        Serial.print(" | Address : ");
        Serial.print(cAddr, HEX);
        Serial.print(" | STATE : ");
        Serial.print(_state);
        Serial.print(" | OWNER : ");
        Serial.println(rOwner->id);
        Serial.println(" \n ");
    }
#endif
    _state = WAITING;
 
    return E_OK;
}

query() [2/2]

short ModbusBridge::query	(	int	slave,
		short	function,
		long	start,
		int	coils,
		int	_ownerId
	)

Definition at line 359 of file ModbusBridge.cpp.

{
    if (qstate() != IDLE)
    {
        return WAITING;
    }
 
    cAddr = 0;
    cSlave = slave;
    cFN = function;
    cAddr = start;
    cNB = coils;
    ownerId = _ownerId;
#ifdef HAS_DEBUG_MODBUS_BRIDGE_PRINT_QUERY
    if (__debugQuery)
    {
        Serial.print("\n --------------Modbus QUERY --------- SLAVE :  ");
        Serial.print(slave);
        Serial.print(" | FN : ");
        Serial.print(cFN);
        Serial.print(" | NB : ");
        Serial.print(coils);
        Serial.print(" | Address : ");
        Serial.print(cAddr, HEX);
        Serial.print(" | STATE : ");
        Serial.print(_state);
        Serial.print(" | OWNER : ");
        Serial.println(ownerId);
        Serial.println(" \n ");
    }
#endif
    _state = WAITING;
    return E_OK;
}

queryState()

short ModbusBridge::queryState

(

)

setDebugSend()

void ModbusBridge::setDebugSend

(

bool

debug

)

Definition at line 31 of file ModbusBridge.cpp.

{
    master.debugSend = debug;
}

setup()

short ModbusBridge::setup

(

)

Definition at line 39 of file ModbusBridge.cpp.

{
    master.begin(MODBUS_RS485_BAUDRATE, MODBUS_RS485_PORT);
    master.setTimeOut(MODBUS_RS485_TIMEOUT);
    WaitingTime = millis() + nextWaitingTime;
    _state = IDLE;
    startTS = millis();
 
    // defaults
    for (uchar i = 0; i < MAX_QUERY_BUFFER; i++)
    {
        queries[i].reset();
        queries[i].id = i;
    }
    for (uchar i = 0; i < MODBUS_TCP_MAX_REGISTERS; i++)
    {
        mb->R[i] = MODBUS_TCP_DEFAULT_REGISTER_VALUE;
        mb->C[i] = MODBUS_TCP_DEFAULT_REGISTER_VALUE;
    }
    return E_OK;
}

skipRead()

bool ModbusBridge::skipRead	(	int	slave,
		int	fn,
		int	addr,
		int	num,
		int	prio
	)

Definition at line 96 of file ModbusBridge.cpp.

                                                                         {
    Query *same = nextSame(QUEUED, slave, addr, fn, num);
    if (same && millis() - same->ts < MODBUS_SAME_REQUEST_INTERVAL)
    {
        return true;
    }
 
    if (numByState(DONE) < MODBUS_QUEUE_MIN_FREE)
    {
        return true;
    }
 
    if (numSame(QUEUED, slave, addr, fn, num) >= 1)
    {
        return true;
    }
 
    if (numSame(PROCESSING, slave, addr, fn, num) >= 1)
    {
        return true;
    }
    return false;
}

Member Data Documentation

app

PHApp* ModbusBridge::app

Definition at line 154 of file ModbusBridge.h.

cAddr

short ModbusBridge::cAddr

Definition at line 144 of file ModbusBridge.h.

cFN

short ModbusBridge::cFN

Definition at line 143 of file ModbusBridge.h.

cNB

int ModbusBridge::cNB

Definition at line 145 of file ModbusBridge.h.

cSlave

short ModbusBridge::cSlave

Definition at line 142 of file ModbusBridge.h.

debug_flags

long ModbusBridge::debug_flags

Definition at line 147 of file ModbusBridge.h.

mb

Mudbus* ModbusBridge::mb

Definition at line 166 of file ModbusBridge.h.

ModbusSlaveRegisters

uint16_t ModbusBridge::ModbusSlaveRegisters[8]

Definition at line 131 of file ModbusBridge.h.

nextWaitingTime

int ModbusBridge::nextWaitingTime

Definition at line 165 of file ModbusBridge.h.

onError

ComponentFnPtr ModbusBridge::onError

Definition at line 159 of file ModbusBridge.h.

onMessage

ComponentRxFn ModbusBridge::onMessage

Definition at line 161 of file ModbusBridge.h.

ownerId

int ModbusBridge::ownerId

Definition at line 164 of file ModbusBridge.h.

queries

Query ModbusBridge::queries[MAX_QUERY_BUFFER]

Definition at line 186 of file ModbusBridge.h.

responseFn

ComponentFnPtr ModbusBridge::responseFn

Definition at line 157 of file ModbusBridge.h.

rOwner

Component* ModbusBridge::rOwner

Definition at line 163 of file ModbusBridge.h.

startTS

millis_t ModbusBridge::startTS

Definition at line 187 of file ModbusBridge.h.

---

The documentation for this class was generated from the following files:

• ModbusBridge.h
• ModbusBridge.cpp