Smart Ventilation Motor Monitoring System Project on Labview

3.1 Hardware Control Logic

1. MAX33040D4 STB pin set HIGH on startup to exit low-power standby
2. UART hardware pins D0(RX)/D1(TX) connect directly to MAX33040 differential CAN physical layer

3.2 The library with GPIＯpin simulation for CAN 

#include "MAX33040_CAN.h"

// ============================================
// ============================================
static MAX33040_CAN* _instance = NULL;


// ============================================
MAX33040_CAN::MAX33040_CAN(uint8_t txPin, uint8_t rxPin)
    : _txPin(txPin)
    , _rxPin(rxPin)
    , _speed(DEFAULT_CAN_SPEED)
    , _txState(CAN_STATE_IDLE)
    , _txActive(false)
    , _rxState(CAN_STATE_IDLE)
    , _rxReady(false)
    , _rxQueueHead(0)
    , _rxQueueTail(0)
    , _errorCount(0) {
}


// ============================================
bool MAX33040_CAN::begin(uint32_t speed) {
    _speed = speed;
    
    // 初始化引脚
    pinMode(_txPin, OUTPUT);
    digitalWrite(_txPin, HIGH);  // CAN recessive
    
    pinMode(_rxPin, INPUT);  
    
   
    _instance = this;

    _txState = CAN_STATE_IDLE;
    _txActive = false;
    _rxState = CAN_STATE_IDLE;
    _rxReady = false;
    _rxQueueHead = 0;
    _rxQueueTail = 0;
    _errorCount = 0;
    
    attachInterrupt(CAN_RX_INT, []() {
        if (_instance) {
            _instance->interruptHandler();
        }
    }, CHANGE);  
    
    return true;
}


// ============================================
uint8_t MAX33040_CAN::calcCRC(const CANFrame& frame) {

    uint16_t crc = 0;
    

    for (int i = 10; i >= 0; i--) {
        bool bit = (frame.id >> i) & 1;
        bool newBit = bit ^ ((crc >> 14) & 1);
        crc = (crc << 1) & 0x7FFF;
        if (newBit) {
            crc ^= 0x4599;  
        }
    }

    for (int i = 3; i >= 0; i--) {
        bool bit = (frame.dlc >> i) & 1;
        bool newBit = bit ^ ((crc >> 14) & 1);
        crc = (crc << 1) & 0x7FFF;
        if (newBit) {
            crc ^= 0x4599;
        }
    }
    

    for (uint8_t j = 0; j < frame.dlc; j++) {
        for (int i = 7; i >= 0; i--) {
            bool bit = (frame.data[j] >> i) & 1;
            bool newBit = bit ^ ((crc >> 14) & 1);
            crc = (crc << 1) & 0x7FFF;
            if (newBit) {
                crc ^= 0x4599;
            }
        }
    }
    
    return (uint8_t)(crc >> 7);  
}


// ============================================
void MAX33040_CAN::txIdle() {
    digitalWrite(_txPin, HIGH);  // Recessive
}

void MAX33040_CAN::txDominant() {
    digitalWrite(_txPin, LOW);  // Dominant
}


void MAX33040_CAN::writeBit(bool bit) {
    if (bit) {
        txIdle();
    } else {
        txDominant();
    }
}


// ============================================
bool MAX33040_CAN::sendFrame(const CANFrame& frame) {
    if (_txActive) {
        return false;  
    }
    

    _txFrame = frame;
    if (_txFrame.dlc > 8) _txFrame.dlc = 8;
 
    _txState = CAN_STATE_RECV_SOF;
    _txActive = true;
    _txBitCount = 0;
    _txByteIndex = 0;
    _txBitIndex = 0;
    _txStartTime = micros();
   
    txDominant();
    
    return true;
}


// ============================================
bool MAX33040_CAN::sendAccelData(const AccelData& accel) {
    CANFrame frame;
    
    frame.id = CAN_ID_ACCEL_DATA;
    frame.dlc = 12;  
    

    uint8_t* px = (uint8_t*)&accel.x;
    uint8_t* py = (uint8_t*)&accel.y;
    uint8_t* pz = (uint8_t*)&accel.z;
    

    for (int i = 0; i < 4; i++) {
        frame.data[i] = px[i];
    }
  
    for (int i = 0; i < 4; i++) {
        frame.data[4 + i] = py[i];
    }

    for (int i = 0; i < 4; i++) {
        frame.data[8 + i] = pz[i];
    }
    
    frame.dlc = 12;
    
    return sendFrame(frame);
}


// ============================================
void MAX33040_CAN::updateTxState() {
    if (!_txActive) return;
    
    uint32_t bitTime = 1000000UL / _speed;
    uint32_t now = micros();
    uint32_t elapsed = now - _txStartTime;
    
    uint8_t bitNum = elapsed / bitTime;
    
    while (bitNum > _txBitCount) {
   
        bool txBit = HIGH;
        
        switch (_txState) {
            case CAN_STATE_RECV_SOF: {
                _txState = CAN_STATE_RECV_ID;
                _txBitCount++;
                _txBitIndex = 10;
                break;
            }
            
            case CAN_STATE_RECV_ID: {
                txBit = (_txFrame.id >> _txBitIndex) & 1;
                if (_txBitIndex == 0) {
                    _txState = CAN_STATE_RECV_RTR;
                }
                _txBitIndex--;
                break;
            }
            
            case CAN_STATE_RECV_RTR: {

                _txState = CAN_STATE_RECV_DLC;
                _txBitIndex = 3;
                break;
            }
            
            case CAN_STATE_RECV_DLC: {
                txBit = (_txFrame.dlc >> _txBitIndex) & 1;
                if (_txBitIndex == 0) {
                    _txState = CAN_STATE_RECV_DATA;
                    _txByteIndex = 0;
                    _txBitIndex = 7;
                } else {
                    _txBitIndex--;
                }
                break;
            }
            
            case CAN_STATE_RECV_DATA: {
                if (_txByteIndex < _txFrame.dlc) {
                    txBit = (_txFrame.data[_txByteIndex] >> _txBitIndex) & 1;
                    if (_txBitIndex == 0) {
                        _txByteIndex++;
                        _txBitIndex = 7;
                        if (_txByteIndex >= _txFrame.dlc) {
                            _txState = CAN_STATE_RECV_CRC;
                            _txBitIndex = 14;
                            _crcAccum = calcCRC(_txFrame);
                        }
                    } else {
                        _txBitIndex--;
                    }
                }
                break;
            }
            
            case CAN_STATE_RECV_CRC: {
                txBit = (_crcAccum >> _txBitIndex) & 1;
                if (_txBitIndex == 0) {
                    _txState = CAN_STATE_RECV_ACK;
                } else {
                    _txBitIndex--;
                }
                break;
            }
            
            case CAN_STATE_RECV_ACK: {

                _txState = CAN_STATE_RECV_EOF;
                _txBitCount = 0;
                break;
            }
            
            case CAN_STATE_RECV_EOF: {

                _txState = CAN_STATE_IDLE;
                _txActive = false;
                txIdle();
                return;
            }
            
            default:
                _txActive = false;
                txIdle();
                return;
        }
        

        writeBit(txBit);
        _txBitCount++;
    }
}

// ============================================
void MAX33040_CAN::interruptHandler() {
    static uint32_t lastTime = 0;
    static uint8_t lastState = HIGH;
    
    uint32_t now = micros();
    uint8_t currentState = digitalRead(_rxPin);
    
    if (currentState == lastState) return;
    
    uint32_t delta = now - lastTime;
    lastTime = now;
    lastState = currentState;
    
    uint32_t bitTime = 1000000UL / _speed;
    
  
    uint8_t bits = delta / bitTime;
    if (bits == 0) bits = 1;
    
    bool bit = (currentState == HIGH);  
    static uint8_t bitBuffer[32];
    static uint8_t bitIndex = 0;
    static bool inFrame = false;
    
    if (!inFrame && !bit && _rxState == CAN_STATE_IDLE) {
        inFrame = true;
        _rxState = CAN_STATE_RECV_ID;
        _rxBitCount = 1;
        _rxByteIndex = 0;
        _rxBitIndex = 10;
        bitIndex = 0;
        _crcAccum = 0;
        memset(&_rxFrame, 0, sizeof(_rxFrame));
        return;
    }
    
    if (!inFrame) return;
    

    for (uint8_t i = 0; i < min(bits, (uint8_t)8); i++) {
        bitBuffer[bitIndex++] = bit;
        
        if (bitIndex >= 11 + 1 + 4 + 8 * 8 + 15 + 2 + 7) {
        
            parseReceivedFrame(bitBuffer);
            inFrame = false;
            _rxState = CAN_STATE_IDLE;
            return;
        }
    }
}


void MAX33040_CAN::parseReceivedFrame(uint8_t* buffer) {
    uint8_t idx = 0;
 
    idx++;
    

    _rxFrame.id = 0;
    for (int i = 10; i >= 0; i--) {
        _rxFrame.id |= (buffer[idx++] & 1) << i;
    }
    
   
    idx++;
   
    _rxFrame.dlc = 0;
    for (int i = 3; i >= 0; i--) {
        _rxFrame.dlc |= (buffer[idx++] & 1) << i;
    }
    if (_rxFrame.dlc > 8) _rxFrame.dlc = 8;
    

    for (uint8_t b = 0; b < _rxFrame.dlc; b++) {
        _rxFrame.data[b] = 0;
        for (int i = 7; i >= 0; i--) {
            _rxFrame.data[b] |= (buffer[idx++] & 1) << i;
        }
    }
    
  
    _rxQueue[_rxQueueHead] = _rxFrame;
    _rxQueueHead = (_rxQueueHead + 1) % 2;
    _rxReady = true;
}


bool MAX33040_CAN::available() {
    return _rxReady;
}


bool MAX33040_CAN::readFrame(CANFrame& frame) {
    if (!_rxReady) return false;
    
    frame = _rxQueue[_rxQueueTail];
    _rxQueueTail = (_rxQueueTail + 1) % 2;
    
    if (_rxQueueHead == _rxQueueTail) {
        _rxReady = false;
    }
    
    return true;
}

bool MAX33040_CAN::getAccelData(AccelData& accel) {
    CANFrame frame;
    
    if (!readFrame(frame)) {
        return false;
    }
    
    if (frame.dlc < 12) {
        _errorCount++;
        return false;
    }
    
    uint8_t* px = (uint8_t*)&accel.x;
    uint8_t* py = (uint8_t*)&accel.y;
    uint8_t* pz = (uint8_t*)&accel.z;
    
    for (int i = 0; i < 4; i++) {
        px[i] = frame.data[i];
        py[i] = frame.data[4 + i];
        pz[i] = frame.data[8 + i];
    }
    
    return true;
}

1. Initialize custom CAN library + MAX33040
2. Continuous poll for incoming CAN frames
3. If valid IMU CAN ID detected: unpack all X/Y/Z float values
4. Format serial CSV string, transmit over Uno Q USB UART

There are NI LINX support best fit for this project, but only support Arduino Uno, so it can not be used for the moment.

• NI-VISA driver installed
• Close Arduino IDE Serial Monitor before running LabVIEW (prevents COM port lock conflict)
• Record Uno Q assigned COM port number in Windows Device Manager, COM 23 for this case,

4.2 Complete VI Modular Design 

- VISA Serial Initialization

1. Front Panel Controls: COM Port String Input, Baud Rate (115200 match Uno Q serial), Parity=None, Data Bits=8, Stop Bits=1
2. Block Diagram: VISA Configure Serial Port → VISA Flush Buffer (clear stale CAN/UART garbage data)
3. Error cluster wired sequentially for full fault tracking

While Loop Real-Time VISA Read Core

1. VISA Read function (read buffer length = 128 bytes, enough for full IMU serial frame)
2. Conditional structure: Only process data if received byte count > 0
3. String cleaning subVI: Strip \r\n line terminators

IMU Serial String Parsing (Extract X/Y/Z Floats)

1. String Split by comma delimiter → string array,ax,ay,az,
2. Array index validation (array length =7 before conversion, reject broken partial frames)
3. String-to-number conversion for 3 float outputs: ax,ay,az

Graphical Visualization & AI Anomaly Detection

1. Real-Time Waveform Chart: 6 trace curves (Accel X/Y/Z ), scrolling live motion plot
2. Python AI integration (advanced)
   
   

5 Summary

The Labview is perfect for industrial line supervision and the CAN is typical choice for industrial communication over Vehicles. All the kits is enough for this design, but misuse of port and library put off the progress. 

This is how the project proposed and how to implement the idea. There are still more to improve for the Industrial line in operation.