Ejemplo n.º 1
0
void RTTeensyLink::processReceivedMessage()
{
    RTTEENSYLINK_MESSAGE*
    message;                          // a pointer to the message part of the frame
    int identityLength;
    int suffixLength;

    message = &
              (m_RXFrameBuffer.message);                   // get the message pointer

    switch (message->messageType) {
    case RTTEENSYLINK_MESSAGE_POLL:
    case RTTEENSYLINK_MESSAGE_ECHO:
        RTTeensyLinkConvertIntToUC2(RTTEENSYLINK_MY_ADDRESS, message->messageAddress);
        sendFrame(&(m_RXFrameBuffer),
                  m_RXFrameBuffer.messageLength);   // just send the frame back as received
        break;

    case RTTEENSYLINK_MESSAGE_IDENTITY:
        identityLength = strlen(RTTeensyLinkConfig.identity);
        suffixLength = strlen(m_identitySuffix);

        memcpy(message->data, RTTeensyLinkConfig.identity,
               identityLength + 1);    // copy in identity

        if ((identityLength + suffixLength) < RTTEENSYLINK_DATA_MAX_LEN - 1) {
            memcpy(message->data + identityLength, m_identitySuffix,
                   suffixLength + 1); // copy in suffix
        } else {
            suffixLength = 0;
        }

        RTTeensyLinkConvertIntToUC2(RTTEENSYLINK_MY_ADDRESS, message->messageAddress);
        message->data[RTTEENSYLINK_DATA_MAX_LEN - 1] =
            0;     // make sure zero terminated if it was truncated
        sendFrame(&(m_RXFrameBuffer),
                  RTTEENSYLINK_MESSAGE_HEADER_LEN + identityLength + suffixLength + 1);
        break;

    default:
        if (message->messageType < RTTEENSYLINK_MESSAGE_CUSTOM) {   // illegal code
            message->data[0] = RTTEENSYLINK_RESPONSE_ILLEGAL_COMMAND;
            message->data[1] = message->messageType;        // this is the offending code
            message->messageType = RTTEENSYLINK_MESSAGE_ERROR;
            RTTeensyLinkConvertIntToUC2(RTTEENSYLINK_MY_ADDRESS, message->messageAddress);
            sendFrame(&(m_RXFrameBuffer), RTTEENSYLINK_MESSAGE_HEADER_LEN + 2);
            break;
        }

        processCustomMessage(message->messageType, message->messageParam, message->data,
                             m_RXFrameBuffer.messageLength -
                             RTTEENSYLINK_MESSAGE_HEADER_LEN);   // see if anyone wants to process it
        break;
    }
}
Ejemplo n.º 2
0
void RTArduLink::processHostMessage()
{
    RTARDULINK_MESSAGE *message;                            // a pointer to the message part of the frame
    int identityLength;
    int suffixLength;
    unsigned int address;

    message = &(m_hostPort->RXFrameBuffer.message);         // get the message pointer
    address = RTArduLinkConvertUC2ToUInt(message->messageAddress);

    if (address == RTARDULINK_BROADCAST_ADDRESS) {          // need to forward to downstream ports also
        for (int i = RTARDULINK_HOST_PORT + 1; i < RTARDULINKHAL_MAX_PORTS; i++) {
            if (m_ports[i].inUse)
                sendFrame(m_ports + i, &(m_hostPort->RXFrameBuffer), m_hostPort->RXFrameBuffer.messageLength);
        }
    }
    if ((address == RTARDULINK_MY_ADDRESS) || (address == RTARDULINK_BROADCAST_ADDRESS)) {  // it's for me
        switch (message->messageType)
        {
            case RTARDULINK_MESSAGE_POLL:
            case RTARDULINK_MESSAGE_ECHO:
                RTArduLinkConvertIntToUC2(RTARDULINK_MY_ADDRESS, message->messageAddress);
                sendFrame(m_hostPort, &(m_hostPort->RXFrameBuffer), m_hostPort->RXFrameBuffer.messageLength);   // just send the frame back as received
                break;

            case RTARDULINK_MESSAGE_IDENTITY:
                identityLength = strlen(RTArduLinkHALConfig.identity);
                suffixLength = strlen(m_identitySuffix);

                memcpy(message->data, RTArduLinkHALConfig.identity, identityLength + 1);    // copy in identity

                if ((identityLength + suffixLength) < RTARDULINK_DATA_MAX_LEN - 1) {
                    memcpy(message->data + identityLength, m_identitySuffix, suffixLength + 1); // copy in suffix
                } else {
                    suffixLength = 0;
                }
                RTArduLinkConvertIntToUC2(RTARDULINK_MY_ADDRESS, message->messageAddress);
                message->data[RTARDULINK_DATA_MAX_LEN - 1] = 0;     // make sure zero terminated if it was truncated
                sendFrame(m_hostPort, &(m_hostPort->RXFrameBuffer), RTARDULINK_MESSAGE_HEADER_LEN + identityLength + suffixLength + 1);
                break;

            default:
                if (message->messageType < RTARDULINK_MESSAGE_CUSTOM) {	// illegal code
                    message->data[0] = RTARDULINK_RESPONSE_ILLEGAL_COMMAND;
                    message->data[1] = message->messageType;        // this is the offending code
                    message->messageType = RTARDULINK_MESSAGE_ERROR;
                    RTArduLinkConvertIntToUC2(RTARDULINK_MY_ADDRESS, message->messageAddress);
                    sendFrame(m_hostPort, &(m_hostPort->RXFrameBuffer), RTARDULINK_MESSAGE_HEADER_LEN + 2);
                    break;
                }
                processCustomMessage(message->messageType, message->messageParam, message->data,
                        m_hostPort->RXFrameBuffer.messageLength - RTARDULINK_MESSAGE_HEADER_LEN);	// see if anyone wants to process it
                break;
        }
        return;
    }

    if (address >= RTARDULINKHAL_MAX_PORTS) {               // need to pass it to the first subsystem
        if (!m_ports[RTARDULINK_DAISY_PORT].inUse)
            return;                                         // there is no daisy chain port
        RTArduLinkConvertIntToUC2(address - RTARDULINKHAL_MAX_PORTS, message->messageAddress); // adjust the address
        sendFrame(m_ports +RTARDULINK_DAISY_PORT, &(m_hostPort->RXFrameBuffer), m_hostPort->RXFrameBuffer.messageLength);
        return;
    }

    // if get here, needs to go to a local subsystem port

    if (m_ports[address].inUse) {
        RTArduLinkConvertIntToUC2(0, message->messageAddress);     // indicates that the target should process it
        sendFrame(m_ports + address, &(m_hostPort->RXFrameBuffer), m_hostPort->RXFrameBuffer.messageLength);
    }
}