OmronPID Class Reference

#include <OmronPID.h>

Inheritance diagram for OmronPID:

Public Member Functions
short	debug ()
short	info ()
bool	isHeatingUp ()
bool	isRunning ()
virtual short	loop ()
short	modbusLoop ()
OmronState *	nextToUpdate ()
OmronState *	nextToUpdate2 ()
	OmronPID (ModbusBridge *_bridge, short _slaveStart)
short	onError (short error)
short	onRawResponse (short size, uint8_t rxBuffer[])
short	onRegisterMethods (Bridge *bridge)
short	onResponse (short error)
void	printStates ()
short	queryResponse (short error)
short	responseFn (short error)
void	runAll ()
void	setAllSP (int sp)
virtual short	setup ()
void	stopAll ()
void	testPIDs ()

Public Attributes
Vector< Query >	queries

Protected Member Functions
void	initPIDS ()

Private Member Functions
int	eachPID (short fn, int addr, int value)
int	eachPIDW (int addr, int value)
short	fromTCP ()
OmronState *	pidBySlave (int slave)
void	print ()
short	read10_16 (int slaveAddress, int addr, int prio)
void	resetStates ()
int	singlePID (int slave, short fn, int addr, int value)
int	singlePIDW (int slave, int addr, int value)
void	updateState ()
void	updateTCP ()

Private Attributes
millis_t	d0TS
short	lastError
ModbusBridge *	modbus
ShiftRegister< uchar, E_PID_MB_M_QUEUE_LENGTH >	queue
millis_t	readInterval
short	slaveStart
millis_t	startTS
OmronState	states [NB_OMRON_PIDS]

Detailed Description

Definition at line 108 of file OmronPID.h.

Constructor & Destructor Documentation

OmronPID()

OmronPID::OmronPID ( ModbusBridge *  _bridge, short  _slaveStart  )

inline

Definition at line 111 of file OmronPID.h.

                              : Component("OmronPID", COMPONENT_KEY_PID_0, Component::COMPONENT_DEFAULT, NULL),
                                modbus(_bridge),
                                slaveStart(_slaveStart),
                                queue({E_PID_MB_M_QUEUE_PID_0,
                                       E_PID_MB_M_QUEUE_PID_1}),
                                ModbusValue<int[]>(_slaveStart)
  {
    // setFlag(OBJECT_RUN_FLAGS::E_OF_DEBUG);
    SBI(nFlags, OBJECT_NET_CAPS::E_NCAPS_MODBUS);
    d0TS = startTS = millis();
    lastError = E_OK;
    readInterval = OMRON_PID_UPDATE_INTERVAL;
    setFunctionCode(MB_FC::MB_FC_READ_REGISTERS);
    setAddress(MB_REGISTER_OFFSET_TC);
    setNumberAddresses(MB_REGISTER_OFFSET_TC_RANGE * NB_OMRON_PIDS);
    setRegisterMode(MB_REGISTER_MODE::E_MB_REGISTER_MODE_READ);
  }

Member Function Documentation

debug()

short OmronPID::debug

(

)

Definition at line 39 of file OmronPID.cpp.

{
    Log.verboseln("Omron PID  :: debug %d", id);
    modbus->print();
    printStates();
    return false;
}

eachPID()

int OmronPID::eachPID ( short  fn, int  addr, int  value  )

private

Definition at line 119 of file OmronPID.cpp.

{
    for (short i = 0; i < NB_OMRON_PIDS; i++)
    {
        Query *next = modbus->nextQueryByState(DONE);
        if (next)
        {
            next->fn = fn;
            next->slave = states[i].slaveID;
            next->value = value;
            next->addr = addr;
            next->state = QUERY_STATE::QUEUED;
            next->owner = id;
        }
        else
        {
            Log.errorln("Omron-PID::eachPID : no buffer free");
        }
    }
    return E_OK;
}

eachPIDW()

int OmronPID::eachPIDW ( int  addr, int  value  )

private

Definition at line 115 of file OmronPID.cpp.

{
    return eachPID(ku8MBWriteSingleRegister, addr, value);
}

fromTCP()

short OmronPID::fromTCP ( )

private

Definition at line 271 of file OmronPIDModbus.cpp.

{
    millis_t t = now;
    short ret = E_SKIP;
    for (short i = 0; i < NB_OMRON_PIDS; i++)
    {
        switch (i)
        {
        case 0:
        {
            if (modbus->mb->R[MB_W_PID_1_SP] > 0)
            {
                short temp = clamp<short>(modbus->mb->R[MB_W_PID_1_SP], 0, OMRON_PID_MAX_TEMPERATURE);
                singlePID(states[i].slaveID, ku8MBWriteSingleRegister, OR_E5_SWR::OR_E5_SWR_SP, temp);
                modbus->mb->R[MB_W_PID_1_SP] = 0;
                ret = E_QUEUED;
            }
            break;
        }
        case 1:
        {
 
            if (modbus->mb->R[MB_W_PID_2_SP] > 0)
            {
                short temp = clamp<short>(modbus->mb->R[MB_W_PID_2_SP], 0, OMRON_PID_MAX_TEMPERATURE);
                singlePID(states[i].slaveID, ku8MBWriteSingleRegister, OR_E5_SWR::OR_E5_SWR_SP, temp);
                modbus->mb->R[MB_W_PID_2_SP] = 0;
                ret = E_QUEUED;
            }
            break;
        }
        case 2:
        {
            if (modbus->mb->R[MB_W_PID_3_SP])
            {
                short temp = clamp<short>(modbus->mb->R[MB_W_PID_3_SP], 0, OMRON_PID_MAX_TEMPERATURE);
                singlePID(states[i].slaveID, ku8MBWriteSingleRegister, OR_E5_SWR::OR_E5_SWR_SP, temp);
                modbus->mb->R[MB_W_PID_3_SP] = 0;
                ret = E_QUEUED;
            }
            break;
        }
        }
    }
    return ret;
}

info()

short OmronPID::info

(

)

Definition at line 46 of file OmronPID.cpp.

{
    return false;
}

initPIDS()

void OmronPID::initPIDS ( )

protected

Definition at line 50 of file OmronPID.cpp.

{
    for (short i = 0; i < NB_OMRON_PIDS; i++)
    {
        states[i].slaveID = slaveStart + i;
        states[i].idx = i;
        states[i].lastUpdated = millis();
        states[i].lastWritten = millis();
        states[i].flags = OmronState::FLAGS::DIRTY;
    }
}

isHeatingUp()

bool OmronPID::isHeatingUp

(

)

Definition at line 165 of file OmronPID.cpp.

{
    bool ret = false;
    for (short i = 0; i < NB_OMRON_PIDS; i++)
    {
        if (states[i].isHeating())
        {
            return true;
        }
    }
    return ret;
}

isRunning()

bool OmronPID::isRunning

(

)

Definition at line 177 of file OmronPID.cpp.

{
    bool ret = false;
    for (short i = 0; i < NB_OMRON_PIDS; i++)
    {
        if (states[i].isRunning())
        {
            return true;
        }
    }
    return ret;
}

loop()

short OmronPID::loop ( )

virtual

Definition at line 34 of file OmronPID.cpp.

{
    modbusLoop();
    return E_OK;
}

modbusLoop()

short OmronPID::modbusLoop

(

)

Definition at line 69 of file OmronPIDModbus.cpp.

{
    if (modbus->qstate() != IDLE)
        return E_SKIP;
 
    if (millis() - last < OMRON_PID_UPDATE_INTERVAL)
        return E_SKIP;
 
    last = now;
    fromTCP();
    updateState();
    Query *nextCommand = modbus->nextQueryByState2(QUERY_STATE::QUEUED, id);
    if (!nextCommand)
        return E_SKIP;
 
    if (printModbus)
        modbus->print();
 
    nextCommand->state = QUERY_STATE::PROCESSING;
    nextCommand->ts = millis();
    modbus->nextWaitingTime = MODBUS_CMD_WAIT;    
    if (_debugQueryState)
    {
        if (millis() - d0TS > 1000)
        {
            Log.verboseln("OmronPID::loop : Query Modbus : Slave=%d | FN=%d | Addr=%d | Nb=%d",
                          nextCommand->slave,
                          nextCommand->fn,
                          nextCommand->addr,
                          nextCommand->value);
 
            nextCommand->print();
            Serial.println();
            d0TS = now;
        }
    }
    
 
    modbus->query(
        nextCommand->slave,
        nextCommand->fn,
        nextCommand->addr,
        nextCommand->value,
        id);
 
    return E_OK;
}

nextToUpdate()

OmronState * OmronPID::nextToUpdate

(

)

Definition at line 29 of file OmronPIDModbus.cpp.

{
    OmronState *oldest = NULL;
    for (short i = 0; i < NB_OMRON_PIDS; i++)
    {
        OmronState *c = &states[i];
        if (c->flags == OmronState::FLAGS::UPDATING &&
            millis() - c->lastUpdated > (1000 * 2))
        {
            c->flags == OmronState::FLAGS::DIRTY;
        }
        if (c->flags == OmronState::FLAGS::UPDATING)
        {
            continue;
        }
        if (!oldest)
        {
            oldest = c;
        }
        if (c != oldest && c->lastUpdated < oldest->lastUpdated)
        {
            oldest = c;
        }
    }
    return oldest;
}

nextToUpdate2()

OmronState * OmronPID::nextToUpdate2

(

)

Definition at line 26 of file OmronPIDModbus.cpp.

                                   {
    return pidBySlave(queue.val());
}

onError()

short OmronPID::onError

(

short

error

)

Definition at line 238 of file OmronPIDModbus.cpp.

{
    if (printMBErrors)
    {
        Log.verboseln("Omron PID :: onError %d : %d", error, readInterval);
    }
    Query *last = modbus->nextQueryByState(QUERY_STATE::PROCESSING, id);
    if (last)
    {
        last->reset();
    }
    else
    {
        Log.errorln("Omron PID :: onError - can't find last query! ");
    }
    resetStates();
 
    // Modbus Errors
    if (error == ERR_MODBUS_TIMEOUT && lastError == ERR_MODBUS_TIMEOUT)
    {
        readInterval += MB_POLL_RETRY_STEP;
    }
 
    lastError = error;
 
    readInterval = clamp<millis_t>(readInterval, 0, MB_MAX_POLL_INTERVAL);
    if (readInterval == MB_MAX_POLL_INTERVAL)
    {
        owner->onError(id, E_PID_TIMEOUT);
    }
 
    return E_OK;
}

onRawResponse()

short OmronPID::onRawResponse	(	short	size,
		uint8_t	rxBuffer[]
	)

Definition at line 138 of file OmronPIDModbus.cpp.

{
    Query *current = modbus->nextQueryByState(PROCESSING, id);
    if (debugRawResponse)
    {
        Log.verboseln("OmronPID::rawResponse : size=%d | %X", size, rxBuffer);
    }
    if (current)
    {
        switch (current->fn)
        {
        case ku8MBWriteSingleRegister:
        {
 
            if (size == 5 && rxBuffer[1] == OR_E5_RESPONSE_CODE::OR_COMMAND_ERROR)
            {
                Serial.print("------ \n Command Error: ");
                Serial.print(rxBuffer[2]);
                Serial.print(" : ");
                switch (rxBuffer[2])
                {
                case OR_E5_ERROR::VARIABLE_ADDRESS_ERROR:
                {
                    Serial.println(OR_E_MSG_INVALID_ADDRESS);
                    break;
                }
                case OR_E5_ERROR::VARIABLE_RANGE_ERROR:
                {
                    Serial.println(OR_E_MSG_INVALID_RANGE);
                    break;
                }
                case OR_E5_ERROR::VARIABLE_OPERATION_ERROR:
                {
                    Serial.println(OR_E_MSG_OPERATION_ERROR);
                    break;
                }
                }
                Serial.println("\n------");
                return rxBuffer[2];
            }
 
            if (size == 8 && (rxBuffer[0] != current->slave || rxBuffer[2] != current->addr))
            {
                return OR_COMMAND_ERROR;
            }
            break;
        }
        }
    }
    return ERROR_OK;
}

onRegisterMethods()

short OmronPID::onRegisterMethods

(

Bridge *

bridge

)

Definition at line 23 of file OmronPID.cpp.

{
 
    bridge->registerMemberFunction(id, this, C_STR("testPIDs"), (ComponentFnPtr)&OmronPID::testPIDs);
    bridge->registerMemberFunction(id, this, C_STR("debug"), (ComponentFnPtr)&OmronPID::debug);
    /*
    bridge->registerMemberFunction(id, this, C_STR("info"), (ComponentFnPtr)&OmronPID::info);
    bridge->registerMemberFunction(id, this, C_STR("debug"), (ComponentFnPtr)&OmronPID::debug);
    */
    return E_OK;
}

onResponse()

short OmronPID::onResponse

(

short

error

)

Definition at line 189 of file OmronPIDModbus.cpp.

{
    Query *last = modbus->nextQueryByState2(QUERY_STATE::PROCESSING, id);
    if (!last || last->owner != id)
    {
        return E_SKIP;
    }
    
    OmronState *state = pidBySlave(last->slave);
    if (!state)
    {
        Log.warningln("Omron-PID :: invalid slave : %d", last->slave);
        modbus->print();
        return E_NO_SUCH_PID;
    }
 
    if (last->fn == ku8MBWriteSingleRegister)
    {
        last->reset();
        state->flags = OmronState::FLAGS::UPDATED;
        state->lastWritten = now;
        lastError = E_OK;
        readInterval = OMRON_PID_UPDATE_INTERVAL;
        return E_OK;
    }
 
    if (last->fn == ku8MBReadHoldingRegisters)
    {
        state->lastDT = now - state->lastUpdated;
        state->lastUpdated = millis();
        state->statusHigh = modbus->ModbusSlaveRegisters[2];
        state->statusLow = modbus->ModbusSlaveRegisters[3];
        state->pv = modbus->ModbusSlaveRegisters[1];
        state->sp = modbus->ModbusSlaveRegisters[5];
        state->flags = OmronState::FLAGS::UPDATED;
        state->state = state->isHeating() ? 1 : 0;
        lastError = E_OK;
        readInterval = OMRON_PID_UPDATE_INTERVAL;
        if (printPIDUpdates)
        {
            Log.verboseln("Omron-PID :: Updated Slave : %d : ", state->slaveID);
            state->print();
        }
        queue.incr();
    }
    last->reset();
    updateTCP();
    return E_OK;
}

pidBySlave()

OmronState * OmronPID::pidBySlave ( int  slave )

private

Definition at line 335 of file OmronPIDModbus.cpp.

{
    for (short i = 0; i < NB_OMRON_PIDS; i++)
    {
        if (states[i].slaveID == slave)
        {
            return &states[i];
        }
    }
    return NULL;
}

print()

void OmronPID::print ( )

private

Definition at line 61 of file OmronPID.cpp.

{
    printStates();
}

printStates()

void OmronPID::printStates

(

)

Definition at line 189 of file OmronPID.cpp.

{
    for (short i = 0; i < NB_OMRON_PIDS; i++)
    {
        states[i].print();
    }
}

queryResponse()

short OmronPID::queryResponse

(

short

error

)

Definition at line 326 of file OmronPIDModbus.cpp.

{
    Query *last = modbus->nextQueryByState2(QUERY_STATE::PROCESSING, id);
    if (last)
    {
        last->state = QUERY_STATE::DONE;
    }
    return E_OK;
}

read10_16()

short OmronPID::read10_16 ( int  slaveAddress, int  addr, int  prio  )

private

Definition at line 116 of file OmronPIDModbus.cpp.

{
    if (modbus->skipRead(slaveAddress, ku8MBReadHoldingRegisters, addr, OMRON_PID_READ_STATUS_REGISTERS, prio))
    {
        return E_SKIP;
    }
    Query *next = modbus->nextQueryByState(DONE);
    if (next != NULL)
    {
        next->reset();
        next->fn = ku8MBReadHoldingRegisters;
        next->slave = slaveAddress;
        next->value = OMRON_PID_READ_STATUS_REGISTERS;
        next->addr = addr;
        next->state = QUERY_STATE::QUEUED;
        next->prio = prio;
        next->owner = id;
        next->ts = millis();
        return E_QUEUED;
    }
    return E_SKIP;
}

resetStates()

void OmronPID::resetStates ( )

private

Definition at line 158 of file OmronPID.cpp.

{
    for (short i = 0; i < NB_OMRON_PIDS; i++)
    {
        states[i].flags = OmronState::FLAGS::UPDATED;
    }
}

responseFn()

short OmronPID::responseFn

(

short

error

)

runAll()

void OmronPID::runAll

(

)

Definition at line 144 of file OmronPID.cpp.

{
    eachPID(ku8MBWriteSingleRegister, 0, OR_E5_CMD::OR_E5_RUN);
}

setAllSP()

void OmronPID::setAllSP

(

int

sp

)

Definition at line 148 of file OmronPID.cpp.

{
    eachPID(ku8MBWriteSingleRegister, OR_E5_SWR::OR_E5_SWR_SP, sp);
}

setup()

short OmronPID::setup ( )

virtual

Definition at line 152 of file OmronPID.cpp.

{
    initPIDS();
    return E_OK;
}

singlePID()

int OmronPID::singlePID ( int  slave, short  fn, int  addr, int  value  )

private

Definition at line 70 of file OmronPID.cpp.

{
    // Query *same = modbus->nextSame(QUEUED, slave, addr, fn, value);
    if (modbus->numByState(DONE) < 2 && fn != ku8MBWriteSingleRegister)
    {
        Log.verboseln("OmronPID::singlePID : failed : no buffer");
        return false;
    }
    if (modbus->numSame(QUEUED, slave, addr, fn, value) > 2)
    {
        Log.verboseln("OmronPID::singlePID : failed : num same");
        return false;
    }
 
    OmronState *pid = pidBySlave(slave);
    if (!pid)
    {
        Log.errorln("Omron-PID::singlePID : invalid PID : %d", slave);
        return E_NO_SUCH_PID;
    }
 
    Query *next = modbus->nextQueryByState(DONE);
    if (!next)
    {
        Log.verboseln("OmronPID::singlePID : failed : no free query");
        return E_OK;
    }
    next->fn = fn;
    next->slave = pid->slaveID;
    next->value = value;
    next->addr = addr;
    next->state = QUERY_STATE::QUEUED;
    next->owner = id;
    next->ts = millis();
    pid->flags = OmronState::FLAGS::UPDATING;
    if (fn == ku8MBWriteSingleRegister)
    {
        next->prio = MB_QUERY_TYPE_CMD;
    }
    else
    {
        next->prio = MB_QUERY_TYPE_STATUS_POLL;
    }
    return E_OK;
}

singlePIDW()

int OmronPID::singlePIDW ( int  slave, int  addr, int  value  )

private

Definition at line 65 of file OmronPID.cpp.

{
    singlePID(slave, ku8MBWriteSingleRegister, addr, value);
    return E_OK;
}

stopAll()

void OmronPID::stopAll

(

)

Definition at line 140 of file OmronPID.cpp.

{
    eachPID(ku8MBWriteSingleRegister, 0, OR_E5_CMD::OR_E5_STOP);
}

testPIDs()

void OmronPID::testPIDs

(

)

Definition at line 14 of file OmronPID.cpp.

{
    // setAllSP(15);
    // runAll();
    //  stopAll();
    //  singlePIDW(2, OR_E5_SWR::OR_E5_SWR_SP, 300);
    //  singlePIDW(1, 5000, 20);
    //  singlePID(1, ku8MBWriteSingleRegister, 0, OR_E5_CMD::OR_E5_AT_EXCECUTE);
}

updateState()

void OmronPID::updateState ( )

private

Definition at line 55 of file OmronPIDModbus.cpp.

{
    OmronState *next = nextToUpdate2();
    if (next != NULL)
    {
        modbus->nextWaitingTime = MODBUS_CMD_WAIT;
        next->flags = OmronState::FLAGS::UPDATING;
        next->lastUpdated = millis();
        if(_debugQuery){
            Log.verboseln("OmronPID::updateState : Slave=%d", next->slaveID);
        }
        read10_16(next->slaveID, 0, MB_QUERY_TYPE_STATUS_POLL);
    }
}

updateTCP()

void OmronPID::updateTCP ( )

private

Definition at line 317 of file OmronPIDModbus.cpp.

{
    for (int i = 0; i < NB_OMRON_PIDS; i++)
    {
        modbus->mb->R[MB_REGISTER_OFFSET_TC + 0 + (i * MB_REGISTER_OFFSET_TC_RANGE)] = states[i].pv;
        modbus->mb->R[MB_REGISTER_OFFSET_TC + 1 + (i * MB_REGISTER_OFFSET_TC_RANGE)] = states[i].sp;
        modbus->mb->R[MB_REGISTER_OFFSET_TC + 2 + (i * MB_REGISTER_OFFSET_TC_RANGE)] = states[i].state;
    }
}

Member Data Documentation

d0TS

millis_t OmronPID::d0TS

private

Definition at line 192 of file OmronPID.h.

lastError

short OmronPID::lastError

private

Definition at line 174 of file OmronPID.h.

modbus

ModbusBridge* OmronPID::modbus

private

Definition at line 171 of file OmronPID.h.

queries

Vector<Query> OmronPID::queries

Definition at line 164 of file OmronPID.h.

queue

ShiftRegister<uchar, E_PID_MB_M_QUEUE_LENGTH> OmronPID::queue

private

Definition at line 195 of file OmronPID.h.

readInterval

millis_t OmronPID::readInterval

private

Definition at line 190 of file OmronPID.h.

slaveStart

short OmronPID::slaveStart

private

Definition at line 173 of file OmronPID.h.

startTS

millis_t OmronPID::startTS

private

Definition at line 191 of file OmronPID.h.

states

OmronState OmronPID::states[NB_OMRON_PIDS]

private

Definition at line 170 of file OmronPID.h.

---

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

• OmronPID.h
• OmronPID.cpp
• OmronPIDModbus.cpp