OmronVFD Class Reference

#include <OmronVFD.h>

Inheritance diagram for OmronVFD:

Public Types
enum	E_VFD_DIR { E_VFD_DIR_NONE = 0, E_VFD_DIR_FORWARD = 1, E_VFD_DIR_REVERSE = 2 }
enum	E_VFD_MODE { E_VFD_MODE_NONE = 0, E_VFD_MODE_DIRECT = 1, E_VFD_MODE_MODBUS = 2, E_VFD_MODE_UNKNOWN = 3 }
enum	E_VFD_RETRACT_STATE {   E_VFD_RETRACT_STATE_NONE = 0, E_VFD_RETRACT_STATE_BRAKING = 1, E_VFD_RETRACT_STATE_STOPPED = 2, E_VFD_RETRACT_STATE_REVERSING = 3,   E_VFD_RETRACT_STATE_BRAKE_REVERSING = 4, E_VFD_RETRACT_STATE_RETRACTED = 5 }
enum	E_VFD_RUN_MODE { E_VFD_RUN_MODE_NONE = 0, E_VFD_RUN_MODE_RUN = 1, E_VFD_RUN_MODE_STOP = 2, E_VFD_RUN_MODE_STOP_RETRACT = 3 }
enum	E_VFD_STATE {   E_VFD_STATE_ACCELERATING = 4, E_VFD_STATE_DECELERATING = 2, E_VFD_STATE_RUNNING = 3, E_VFD_STATE_STOPPED = 1,   E_VFD_STATE_ERROR = 8 }

Public Member Functions
uint16_t	configure ()
short	debug ()
short	directDirection ()
uint16_t	forward ()
OmronVFDState *	getVFDState ()
short	info ()
short	loop ()
	OmronVFD (ModbusBridge *_bridge, short _slaveId, Component *_owner)
short	onError (short error)
short	onRawResponse (short size, uint8_t rxBuffer[])
short	onRegisterMethods (Bridge *bridge)
short	onResponse (short error)
short	onStart ()
short	onStop ()
short	read_16 (int addr, int num, int prio=0)
uint16_t	read_coil_single (uint16_t addr)
short	readSingle_16 (int addr, int prio=0)
uint16_t	reverse ()
uint16_t	run ()
uint16_t	setTargetFreq (uint16_t freq)
short	setup ()
bool	skipRead (int slave, int fn, int addr, int num, int prio)
uint16_t	stop ()
uint16_t	updateState ()
uint16_t	write_Bit (uint16_t addr, int on)
uint16_t	write_Single (uint16_t cmd, unsigned int data)

Public Attributes
millis_t	bootTS
Statistic	currentStats
millis_t	debugTS
Pos3Analog *	dir
E_VFD_DIR	direction
millis_t	last
millis_t	mbTS
Pos3Analog *	mode
MotorLoad *	motorLoad
PHApp *	owner
millis_t	readStateTS
POT *	speed

Private Member Functions
short	fromTCP ()
short	modbusLoop ()
short	ping ()
void	updateTCP ()

Private Attributes
short	lastError
uint16_t	lastWriteAddress
uint16_t	lastWriteValue
millis_t	mbInterval
ModbusBridge *	modbus
millis_t	readInterval
E_VFD_RETRACT_STATE	retractState
millis_t	reverseStartTS
E_VFD_RUN_MODE	runMode
millis_t	runTS
short	slaveAddress
OmronVFDState	states [1]
millis_t	stopTS

Detailed Description

Definition at line 83 of file OmronVFD.h.

Member Enumeration Documentation

E_VFD_DIR

enum OmronVFD::E_VFD_DIR

Enumerator
E_VFD_DIR_NONE
E_VFD_DIR_FORWARD
E_VFD_DIR_REVERSE

Definition at line 94 of file OmronVFD.h.

  {
    E_VFD_DIR_NONE = 0,
    E_VFD_DIR_FORWARD = 1,
    E_VFD_DIR_REVERSE = 2,
  } E_VFD_DIR;

E_VFD_MODE

enum OmronVFD::E_VFD_MODE

Enumerator
E_VFD_MODE_NONE
E_VFD_MODE_DIRECT
E_VFD_MODE_MODBUS
E_VFD_MODE_UNKNOWN

Definition at line 86 of file OmronVFD.h.

  {
    E_VFD_MODE_NONE = 0,
    E_VFD_MODE_DIRECT = 1,
    E_VFD_MODE_MODBUS = 2,
    E_VFD_MODE_UNKNOWN = 3
  } E_VFD_MODE;

E_VFD_RETRACT_STATE

enum OmronVFD::E_VFD_RETRACT_STATE

Enumerator
E_VFD_RETRACT_STATE_NONE
E_VFD_RETRACT_STATE_BRAKING
E_VFD_RETRACT_STATE_STOPPED
E_VFD_RETRACT_STATE_REVERSING
E_VFD_RETRACT_STATE_BRAKE_REVERSING
E_VFD_RETRACT_STATE_RETRACTED

Definition at line 109 of file OmronVFD.h.

  {
    E_VFD_RETRACT_STATE_NONE = 0,
    E_VFD_RETRACT_STATE_BRAKING = 1,
    E_VFD_RETRACT_STATE_STOPPED = 2,
    E_VFD_RETRACT_STATE_REVERSING = 3,
    E_VFD_RETRACT_STATE_BRAKE_REVERSING = 4,
    E_VFD_RETRACT_STATE_RETRACTED = 5,
  } E_VFD_RETRACT_STATE;

E_VFD_RUN_MODE

enum OmronVFD::E_VFD_RUN_MODE

Enumerator
E_VFD_RUN_MODE_NONE
E_VFD_RUN_MODE_RUN
E_VFD_RUN_MODE_STOP
E_VFD_RUN_MODE_STOP_RETRACT

Definition at line 101 of file OmronVFD.h.

  {
    E_VFD_RUN_MODE_NONE = 0,
    E_VFD_RUN_MODE_RUN = 1,
    E_VFD_RUN_MODE_STOP = 2,
    E_VFD_RUN_MODE_STOP_RETRACT = 3,
  } E_VFD_RUN_MODE;

E_VFD_STATE

enum OmronVFD::E_VFD_STATE

Enumerator
E_VFD_STATE_ACCELERATING
E_VFD_STATE_DECELERATING
E_VFD_STATE_RUNNING
E_VFD_STATE_STOPPED
E_VFD_STATE_ERROR

Definition at line 119 of file OmronVFD.h.

  {
    E_VFD_STATE_ACCELERATING = 4,
    E_VFD_STATE_DECELERATING = 2,
    E_VFD_STATE_RUNNING = 3,
    E_VFD_STATE_STOPPED = 1,
    E_VFD_STATE_ERROR = 8
  } E_VFD_STATE;

Constructor & Destructor Documentation

OmronVFD()

OmronVFD::OmronVFD ( ModbusBridge *  _bridge, short  _slaveId, Component *  _owner  )

inline

Definition at line 128 of file OmronVFD.h.

                         : ModbusValue<int[]>(MB_W_VFD_RUN, MB_FC::MB_FC_READ_REGISTERS),
                           Component("VFD", COMPONENT_KEY_VFD, Component::COMPONENT_DEFAULT, _owner),
                           modbus(_bridge),
                           mode(NULL),
                           dir(NULL),
                           speed(NULL),
                           slaveAddress(_slaveId)
  {
    // setFlag(OBJECT_RUN_FLAGS::E_OF_DEBUG);
    SBI(nFlags, OBJECT_NET_CAPS::E_NCAPS_MODBUS);
    readStateTS = bootTS = last = mbTS = millis();
    direction = lastError = stopTS = runTS = lastWriteValue = lastWriteAddress = 0;
    runMode = E_VFD_RUN_MODE::E_VFD_RUN_MODE_NONE;
    mbInterval = readInterval = OMRON_MX2_STATE_INTERVAL;
    direction = E_VFD_DIR::E_VFD_DIR_FORWARD;
    setNumberAddresses(4);
    setFunctionCode(MB_FC::MB_FC_READ_REGISTERS);
    setRegisterMode(MB_REGISTER_MODE::E_MB_REGISTER_MODE_READ);
  }

Member Function Documentation

configure()

uint16_t OmronVFD::configure

(

)

Definition at line 65 of file OmronVFD.cpp.

{
    // A001 Frequency reference source = 03 = Modbus
    write_Single(MX2_A001, valA001);
    // A002 Source of the RUN command = 03 = Modbus
    write_Single(MX2_A002, valA002);
    // C026 Relay output function 5 (AL: error signal) = 05
    write_Single(MX2_C026, valC026);
    // A004 setting the maximum frequency
    write_Single(MX2_A004, OMRON_VFD_MAX_FREQ / 10);
}

debug()

short OmronVFD::debug

(

)

Definition at line 259 of file OmronVFD.cpp.

{
    //*stream << this->name << ":" << this->ok();
    modbus->print();
    return false;
}

directDirection()

short OmronVFD::directDirection

(

)

Definition at line 107 of file OmronVFD.cpp.

{
    if (mode && mode->value == Pos3Analog::POS3_DIRECTION::UP)
    {
        if (dir && dir->value)
        {
            return dir->value;
        }
    }
    return 0;
}

forward()

uint16_t OmronVFD::forward

(

)

Definition at line 92 of file OmronVFD.cpp.

{
    direction = E_VFD_DIR::E_VFD_DIR_FORWARD;
    return write_Bit(MX2_SET_DIR, 0);
}

fromTCP()

short OmronVFD::fromTCP ( )

private

Definition at line 235 of file OmronVFDModbus.cpp.

{
    if (modbus->mb->R[9] == 1)
    {
        modbus->mb->R[9] = 0;
        modbus->print();
    }
 
    short ret = E_SKIP;
    if (!directDirection())
    {
        if (modbus->mb->R[MB_W_VFD_RUN] == E_VFD_RUN_MODE::E_VFD_RUN_MODE_RUN)
        {
            onStart();
            write_Bit(MX2_START, 1);
            modbus->mb->R[MB_W_VFD_RUN] = 0;
            runMode = E_VFD_RUN_MODE::E_VFD_RUN_MODE_RUN;
            ret = E_QUEUED;
        }
 
        if (modbus->mb->R[MB_W_VFD_RUN] == E_VFD_RUN_MODE::E_VFD_RUN_MODE_STOP)
        {
            onStop();
            write_Bit(MX2_START, 0);
            owner->onStop(0);
            modbus->mb->R[MB_W_VFD_RUN] = 0;
            runMode = E_VFD_RUN_MODE::E_VFD_RUN_MODE_STOP;
            ret = E_QUEUED;
        }
 
        if (modbus->mb->R[MB_W_VFD_RUN] == E_VFD_RUN_MODE::E_VFD_RUN_MODE_STOP_RETRACT)
        {
            onStop();
            write_Bit(MX2_START, 0);
            owner->onStop(0);
            modbus->mb->R[MB_W_VFD_RUN] = 0;
            runMode = E_VFD_RUN_MODE::E_VFD_RUN_MODE_STOP_RETRACT;
            retractState = E_VFD_RETRACT_STATE::E_VFD_RETRACT_STATE_BRAKING;
            ret = E_QUEUED;
        }
 
        short dir = modbus->mb->R[MB_W_DIRECTION];
        if (dir)
        {
            switch (dir)
            {
            case OmronVFD::E_VFD_DIR::E_VFD_DIR_FORWARD:
                forward();
                ret = E_QUEUED;
                break;
            case OmronVFD::E_VFD_DIR::E_VFD_DIR_REVERSE:
                reverse();
                ret = E_QUEUED;
                break;
            default:
                stop();
                ret = E_QUEUED;
                break;
            }
            modbus->mb->R[MB_W_DIRECTION] = 0;
        }
    }
    if (modbus->mb->R[MB_W_FREQ_TARGET] > 0)
    {
        setTargetFreq(modbus->mb->R[MB_W_FREQ_TARGET]);
        modbus->mb->R[MB_W_FREQ_TARGET] = 0;
        ret = E_QUEUED;
    }
    return ret;
}

getVFDState()

OmronVFDState* OmronVFD::getVFDState ( )

inline

Definition at line 201 of file OmronVFD.h.

  {
    return &states[0];
  }

info()

short OmronVFD::info

(

)

Definition at line 265 of file OmronVFD.cpp.

{
    //*stream << this->name << "\n\t : " SPACE("Pin:" << MOTOR_IDLE_PIN);
    return false;
}

loop()

short OmronVFD::loop

(

)

Definition at line 120 of file OmronVFD.cpp.

{
 
    if (millis() - debugTS > OMRON_MX2_DEBUG_INTERVAL)
    {
        debugTS = now;
    }
 
#ifdef MOTOR_LOAD_PIN
    if (motorLoad)
    {
        currentStats.add(abs(motorLoad->value));
        states[0].max_current = currentStats.maximum();
        if (motorLoad->value > MOTOR_OVERLOAD_RANGE_MIN)
        {
            stop();
            return onError(E_VFD_OVERLOAD);
        }
    }
#endif
    bool hasDirectMode = true;
    if (hasDirectMode && runMode == E_VFD_RUN_MODE::E_VFD_RUN_MODE_STOP_RETRACT)
    {
        short state = states[0].state;
        switch (retractState)
        {
 
        case E_VFD_RETRACT_STATE::E_VFD_RETRACT_STATE_BRAKING:
        {
            if (state == OMRON_STATE_DECELERATING)
            {
            }
            if (state == OMRON_STATE_STOPPED)
            {
                retractState = E_VFD_RETRACT_STATE::E_VFD_RETRACT_STATE_STOPPED;
            }
            break;
        }
        case E_VFD_RETRACT_STATE::E_VFD_RETRACT_STATE_STOPPED:
        {
            reverse();
            run();
            retractState = E_VFD_RETRACT_STATE::E_VFD_RETRACT_STATE_REVERSING;
            reverseStartTS = millis();
            break;
        }
        case E_VFD_RETRACT_STATE::E_VFD_RETRACT_STATE_REVERSING:
        {
            if (now - reverseStartTS > VFD_RETRACT_REVERSE_DURATION)
            {
                stop();
                retractState = E_VFD_RETRACT_STATE::E_VFD_RETRACT_STATE_BRAKE_REVERSING;
            }
            break;
        }
        case E_VFD_RETRACT_STATE::E_VFD_RETRACT_STATE_BRAKE_REVERSING:
        {
            if (state == OMRON_STATE_DECELERATING || OMRON_STATE_STOPPED || OMRON_STATE_RUNNING)
            {
                forward();
                retractState = E_VFD_RETRACT_STATE::E_VFD_RETRACT_STATE_RETRACTED;
                runMode == E_VFD_RUN_MODE::E_VFD_RUN_MODE_NONE;
            }
            break;
        }
        }
    }
 
    /*
    // left direct mode
    if (mode && mode->last_switch && !mode->value)
    {
        mode->last_switch = mode->value;
        if (lastError == E_VFD_OVERLOAD)
        {
            owner->clearError();
        }
        stop();
    }*/
    /*
        // left direct mode
        if (mode && mode->last_switch && !mode->value && dir && !dir->value && dir->last_switch)
        {
            mode->last_switch = mode->value;
            dir->last_switch = dir->value;
            if (lastError == E_VFD_OVERLOAD)
            {
                owner->clearError();
            }
            stop();
        }*/
 
    // cancel retract
    if (hasDirectMode && mode && mode->value && dir && dir->value)
    {
        runMode = E_VFD_RUN_MODE::E_VFD_RUN_MODE_NONE;
        retractState = E_VFD_RETRACT_STATE::E_VFD_RETRACT_STATE_NONE;
    }
 
    // direct mode : control panel
    if (mode && mode->value == Pos3Analog::POS3_DIRECTION::UP)
    {
        // speed
        if (speed && abs(speed->last_value - speed->value) > ANALOG_INPUT_MIN_DT_0)
        {
            speed->last_value = speed->value;
            int dstSpeed = (speed->value * 100 / (ANALOG_INPUT_MAX_LEVEL_0 / 100)) / (OMRON_VFD_MAX_FREQ);
            setTargetFreq(abs(dstSpeed));
        }
 
        // direction
        if (dir && dir->last_switch != dir->value)
        {
 
            dir->last_switch = dir->value;
            switch (dir->value)
            {
            case Pos3Analog::POS3_DIRECTION::UP:
                // Log.notice("VFD: direct %s\n", "forward");
                forward();
                run();
                break;
            case Pos3Analog::POS3_DIRECTION::DOWN:
                //  Log.notice("VFD: direct %s\n", "reverse");
                reverse();
                run();
                break;
            case Pos3Analog::POS3_DIRECTION::MIDDLE:
                //  Log.notice("VFD: direct %s\n", "stop");
                stop();
                break;
            }
        }
    }
 
    modbusLoop();
    return E_OK;
}

modbusLoop()

short OmronVFD::modbusLoop ( )

private

Definition at line 54 of file OmronVFDModbus.cpp.

{
 
    if (millis() - last < OMRON_MX2_LOOP_INTERVAL)
    {
        return E_SKIP;
    }
    if (modbus->qstate() != IDLE)
    {
        return E_SKIP;
    }
 
    last = now;
    updateState();
    fromTCP();
    Query *nextCommand = modbus->nextQueryByState2(QUERY_STATE::QUEUED, id);
    if (!nextCommand)
    {
        return E_SKIP;
    }
    nextCommand->state = QUERY_STATE::PROCESSING;
    nextCommand->ts = now;
    modbus->nextWaitingTime = MODBUS_CMD_WAIT;
    if (debugSend)
    {
        if (now - debugTS > OMRON_MX2_DEBUG_INTERVAL)
        {
            debugTS = now;
            nextCommand->print();
            Serial.println();
        }
    }
 
    modbus->query(
        nextCommand->slave,
        nextCommand->fn,
        nextCommand->addr,
        nextCommand->value,
        id);
}

onError()

short OmronVFD::onError

(

short

error

)

Definition at line 145 of file OmronVFDModbus.cpp.

{
    // 01 : 86 : 21 : 82 : 78
    if (printModbusErrors)
    {
        Log.verboseln("Omron VFD onError : %d : %d", error, readInterval);
    }
    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_VFD_TIMEOUT);
    }
    // App Level Errors
    if (error > E_VFD_CUSTOM)
    {
        switch (error)
        {
        case E_VFD_OVERLOAD:
            lastError = error;
            Log.verboseln("Omron VFD :: Overload Error ! %d", error);
            owner->onError(id, error);
            break;
 
        default:
            break;
        }
        return error;
    }
 
    Query *last = modbus->nextQueryByState(QUERY_STATE::PROCESSING, id);
    if (last)
    {
        last->reset();
    }
    return E_OK;
}

onRawResponse()

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

Definition at line 187 of file OmronVFDModbus.cpp.

{
    if (!size)
    {
        Log.verboseln("OmronVFD::rawResponse - Invalid Size : %d", size);
        return E_OK;
    }
    if (debugReceive)
    {
        // Log.verboseln("OmronVFD::rawResponse - Size : %d", size);
        // printHex(rxBuffer, size);
    }
    if (size == 5)
    {
        Log.verboseln("Error - Modbus, invalid response size : %d", size);
    }
    return ERROR_OK;
}

onRegisterMethods()

short OmronVFD::onRegisterMethods

(

Bridge *

bridge

)

Definition at line 270 of file OmronVFD.cpp.

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

onResponse()

short OmronVFD::onResponse

(

short

error

)

Definition at line 94 of file OmronVFDModbus.cpp.

{
    Query *last = modbus->nextQueryByState2(QUERY_STATE::PROCESSING, id);
    if (!last || last->slave != slaveAddress || last->owner != id)
    {
        return E_SKIP;
    }
    OmronVFDState *state = getVFDState();
    short req = state->queue.val();
 
    switch (req)
    {
    case E_VFD_MB_QUEUE_STATUS:
    {
        states[0].FC = modbus->ModbusSlaveRegisters[0] / 100;
        states[0].status = modbus->ModbusSlaveRegisters[2];
        states[0].state = modbus->ModbusSlaveRegisters[3];
        readInterval = OMRON_MX2_MB_INTERVAL;
        lastError = E_OK;
        state->queue.incr();
        break;
    }/*
    case E_VFD_MB_QUEUE_DIR:
    {
        states[0].direction = modbus->ModbusSlaveRegisters[0];
        readInterval = OMRON_MX2_MB_INTERVAL;
        lastError = E_OK;
        state->queue.incr();
        break;
    }*/
    case E_VFD_MB_QUEUE_AMPS:
    {
        states[0].current = modbus->ModbusSlaveRegisters[0];
        readInterval = OMRON_MX2_MB_INTERVAL;
        lastError = E_OK;
        state->queue.incr();
        break;
    }
    }
 
    if (debugReceive && last->fn == ku8MBWriteSingleRegister)
    {
        last->print();
        modbus->print();
        readInterval = OMRON_MX2_MB_INTERVAL;
        lastError = E_OK;
    }
    last->reset();
    updateTCP();
    return E_OK;
}

onStart()

short OmronVFD::onStart

(

)

Definition at line 30 of file OmronVFD.cpp.

{
 
#ifdef COOLING_RELAY
    digitalWrite(COOLING_RELAY, HIGH);
#endif
#ifdef COOLING_RELAY2
    digitalWrite(COOLING_RELAY2, HIGH);
#endif
#ifdef FEEDSCREW_RELAY
    digitalWrite(FEEDSCREW_RELAY, HIGH);
#endif
 
    //@todo : handle multi errors
    owner->clearError();
    owner->onRun();
    runTS = millis();
    return E_OK;
}

onStop()

short OmronVFD::onStop

(

)

Definition at line 49 of file OmronVFD.cpp.

{
 
#ifdef COOLING_RELAY
    digitalWrite(COOLING_RELAY, 0);
#endif
#ifdef COOLING_RELAY2
    digitalWrite(COOLING_RELAY2, 0);
#endif
#ifdef FEEDSCREW_RELAY
    digitalWrite(FEEDSCREW_RELAY, 0);
#endif
    // owner->clearError();
    stopTS = millis();
    return E_OK;
}

ping()

short OmronVFD::ping ( )

private

Definition at line 205 of file OmronVFDModbus.cpp.

{
    Query *next = modbus->nextQueryByState(DONE);
    if (next)
    {
        next->fn = ku8MBLinkTestOmronMX2Only;
        next->slave = slaveAddress;
        next->value = 1234;
        next->addr = 0;
        next->state = QUERY_STATE::QUEUED;
        next->ts = millis();
        return E_OK;
    }
    return E_QUERY_BUFFER_END;
}

read_16()

short OmronVFD::read_16	(	int	addr,
		int	num,
		int	prio = 0
	)

Definition at line 386 of file OmronVFDModbus.cpp.

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

read_coil_single()

uint16_t OmronVFD::read_coil_single

(

uint16_t

addr

)

Definition at line 324 of file OmronVFDModbus.cpp.

{
    Query *next = modbus->nextQueryByState(DONE);
    if (next)
    {
        next->fn = ku8MBReadCoils;
        next->slave = slaveAddress;
        next->value = 1;
        next->addr = addr;
        next->state = QUERY_STATE::QUEUED;
        next->ts = millis();
        next->owner = id;
        next->prio = MB_QUERY_TYPE_STATUS_POLL_2;
        return E_QUEUED;
    }
    return E_SKIP;
}

readSingle_16()

short OmronVFD::readSingle_16	(	int	addr,
		int	prio = 0
	)

Definition at line 365 of file OmronVFDModbus.cpp.

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

reverse()

uint16_t OmronVFD::reverse

(

)

Definition at line 87 of file OmronVFD.cpp.

{
    direction = E_VFD_DIR::E_VFD_DIR_REVERSE;
    return write_Bit(MX2_SET_DIR, 1);
}

run()

uint16_t OmronVFD::run

(

)

Definition at line 82 of file OmronVFD.cpp.

{
    onStart();
    return write_Bit(MX2_START, 1);
}

setTargetFreq()

uint16_t OmronVFD::setTargetFreq

(

uint16_t

freq

)

Definition at line 97 of file OmronVFD.cpp.

{
    return write_Single(MX2_TARGET_FR, clamp<int>(freq * 100, 0, OMRON_VFD_MAX_FREQ * 100));
}

setup()

short OmronVFD::setup

(

)

Definition at line 101 of file OmronVFD.cpp.

{
    onStop();
    bootTS = millis();
    return E_OK;
}

skipRead()

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

Definition at line 408 of file OmronVFDModbus.cpp.

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

stop()

uint16_t OmronVFD::stop

(

)

Definition at line 76 of file OmronVFD.cpp.

{
    onStop();
    direction = E_VFD_DIR::E_VFD_DIR_NONE;
    return write_Bit(MX2_START, 0);
}

updateState()

uint16_t OmronVFD::updateState

(

)

Definition at line 24 of file OmronVFDModbus.cpp.

{
    if (now - mbTS > mbInterval)
    {
        OmronVFDState *state = getVFDState();
        short req = state->queue.val();
        bool queued = false;
        switch (req)
        {
        case E_VFD_MB_QUEUE_STATUS:
        {
            queued = read_16(1, OMRON_STATUS_POLL_REGISTERS, MB_QUERY_TYPE_STATUS_POLL) == E_QUEUED;
            break;
        }
        case E_VFD_MB_QUEUE_DIR:
        {
            queued = read_coil_single(MX2_C_DIR - 1) == E_QUEUED;
            break;
        }
        case E_VFD_MB_QUEUE_AMPS:
        {
            queued = read_16(MX2_R_TORQUE, 1, MB_QUERY_TYPE_STATUS_POLL) == E_QUEUED;
            break;
        }
        }
        mbTS = now;
        return queued ? E_QUEUED : E_OK;
    }
    return E_SKIP;
}

updateTCP()

void OmronVFD::updateTCP ( )

private

Definition at line 220 of file OmronVFDModbus.cpp.

{
    modbus->mb->R[MB_R_VFD_STATUS] = states[0].status;
    modbus->mb->R[MB_R_VFD_STATE] = states[0].state;
    // modbus->mb->R[MB_R_VFD_DIRECTION] = states[0].direction;
    modbus->mb->R[MB_R_FREQ_TARGET] = states[0].FC;
#ifdef MB_MONITORING_STATUS_VFD_MAX_LOAD
    modbus->mb->R[MB_MONITORING_STATUS_VFD_MAX_LOAD] = states[0].max_current;
    modbus->mb->R[MB_MONITORING_STATUS_VFD_RUN_MODE] = runMode;
    modbus->mb->R[MB_MONITORING_STATUS_VFD_CURRENT] = states[0].current;
    // modbus->mb->R[75] = states[0].status2;
    // modbus->mb->R[76] = states[0].status3;
#endif
    // fromTCP();
}

write_Bit()

uint16_t OmronVFD::write_Bit	(	uint16_t	addr,
		int	on
	)

Definition at line 341 of file OmronVFDModbus.cpp.

{
    Query *same = modbus->nextSame(QUEUED, slaveAddress, addr, ku8MBWriteSingleCoil, on);
    if (same && millis() - same->ts < 300)
    {
    }
 
    Query *next = modbus->nextQueryByState(DONE);
    if (next)
    {
        next->fn = ku8MBWriteSingleCoil;
        next->slave = slaveAddress;
        next->addr = addr;
        next->value = on;
        next->state = QUERY_STATE::QUEUED;
        next->ts = millis();
        next->owner = id;
        next->prio = MB_QUERY_TYPE_CMD;
        lastWriteAddress = addr;
        lastWriteValue = on;
        return E_OK;
    }
    return E_QUERY_BUFFER_END;
}

write_Single()

uint16_t OmronVFD::write_Single	(	uint16_t	cmd,
		unsigned int	data
	)

Definition at line 305 of file OmronVFDModbus.cpp.

{
    Query *next = modbus->nextQueryByState(DONE);
    if (next)
    {
        next->fn = ku8MBWriteSingleRegister;
        next->slave = slaveAddress;
        next->value = data;
        next->addr = addr;
        next->state = QUERY_STATE::QUEUED;
        next->ts = millis();
        next->owner = id;
        next->prio = MB_QUERY_TYPE_CMD;
        lastWriteAddress = addr;
        lastWriteValue = data;
        return E_QUEUED;
    }
    return E_SKIP;
}

Member Data Documentation

bootTS

millis_t OmronVFD::bootTS

Definition at line 190 of file OmronVFD.h.

currentStats

Statistic OmronVFD::currentStats

Definition at line 199 of file OmronVFD.h.

debugTS

millis_t OmronVFD::debugTS

Definition at line 189 of file OmronVFD.h.

dir

Pos3Analog* OmronVFD::dir

Definition at line 197 of file OmronVFD.h.

direction

E_VFD_DIR OmronVFD::direction

Definition at line 207 of file OmronVFD.h.

last

millis_t OmronVFD::last

Definition at line 186 of file OmronVFD.h.

lastError

short OmronVFD::lastError

private

Definition at line 219 of file OmronVFD.h.

lastWriteAddress

uint16_t OmronVFD::lastWriteAddress

private

Definition at line 230 of file OmronVFD.h.

lastWriteValue

uint16_t OmronVFD::lastWriteValue

private

Definition at line 231 of file OmronVFD.h.

mbInterval

millis_t OmronVFD::mbInterval

private

Definition at line 221 of file OmronVFD.h.

mbTS

millis_t OmronVFD::mbTS

Definition at line 188 of file OmronVFD.h.

modbus

ModbusBridge* OmronVFD::modbus

private

Definition at line 210 of file OmronVFD.h.

mode

Pos3Analog* OmronVFD::mode

Definition at line 196 of file OmronVFD.h.

motorLoad

MotorLoad* OmronVFD::motorLoad

Definition at line 198 of file OmronVFD.h.

owner

PHApp* OmronVFD::owner

Definition at line 200 of file OmronVFD.h.

readInterval

millis_t OmronVFD::readInterval

private

Definition at line 220 of file OmronVFD.h.

readStateTS

millis_t OmronVFD::readStateTS

Definition at line 187 of file OmronVFD.h.

retractState

E_VFD_RETRACT_STATE OmronVFD::retractState

private

Definition at line 227 of file OmronVFD.h.

reverseStartTS

millis_t OmronVFD::reverseStartTS

private

Definition at line 224 of file OmronVFD.h.

runMode

E_VFD_RUN_MODE OmronVFD::runMode

private

Definition at line 226 of file OmronVFD.h.

runTS

millis_t OmronVFD::runTS

private

Definition at line 223 of file OmronVFD.h.

slaveAddress

short OmronVFD::slaveAddress

private

Definition at line 211 of file OmronVFD.h.

speed

POT* OmronVFD::speed

Definition at line 195 of file OmronVFD.h.

states

OmronVFDState OmronVFD::states[1]

private

Definition at line 212 of file OmronVFD.h.

stopTS

millis_t OmronVFD::stopTS

private

Definition at line 222 of file OmronVFD.h.

---

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

• OmronVFD.h
• OmronVFD.cpp
• OmronVFDModbus.cpp