DriverStation::DriverStation()
{
    m_init = false;

    /* Initialize private members */
    m_client      = new DS_Client;
    m_netConsole  = new DS_NetConsole;
    m_elapsedTime = new DS_ElapsedTime;
    m_manager     = new DS_ProtocolManager;
    m_protocol    = Q_NULLPTR;

    /* Update internal values and notify object on robot status events */
    connect (m_manager, SIGNAL (codeChanged            (bool)),
             this,        SLOT (updateRobotStatus      (bool)));
    connect (m_manager, SIGNAL (communicationsChanged  (DS_CommStatus)),
             this,        SLOT (updateRobotStatus      (DS_CommStatus)));
    connect (m_manager, SIGNAL (controlModeChanged     (DS_ControlMode)),
             this,        SLOT (resetElapsedTimer      (DS_ControlMode)));
    connect (m_manager, SIGNAL (codeChanged            (bool)),
             this,      SIGNAL (codeChanged            (bool)));
    connect (m_manager, SIGNAL (communicationsChanged  (DS_CommStatus)),
             this,      SIGNAL (communicationsChanged  (DS_CommStatus)));
    connect (m_manager, SIGNAL (controlModeChanged     (DS_ControlMode)),
             this,      SIGNAL (controlModeChanged     (DS_ControlMode)));
    connect (m_manager, SIGNAL (diskUsageChanged       (int)),
             this,      SIGNAL (diskUsageChanged       (int)));
    connect (m_manager, SIGNAL (ramUsageChanged        (int)),
             this,      SIGNAL (ramUsageChanged        (int)));
    connect (m_manager, SIGNAL (cpuUsageChanged        (int)),
             this,      SIGNAL (cpuUsageChanged        (int)));
    connect (m_manager, SIGNAL (voltageChanged         (QString)),
             this,      SIGNAL (voltageChanged         (QString)));
    connect (m_manager, SIGNAL (voltageBrownoutChanged (bool)),
             this,      SIGNAL (voltageBrownoutChanged (bool)));
    connect (m_manager, SIGNAL (CANInfoReceived        (DS_CAN)),
             this,      SIGNAL (CANInfoReceived        (DS_CAN)));
    connect (m_manager, SIGNAL (emergencyStopped       (void)),
             this,      SIGNAL (emergencyStopped       (void)));
    connect (m_manager, SIGNAL (fmsChanged             (bool)),
             this,      SIGNAL (fmsChanged             (bool)));

    /* Stop timer when the communications status changes */
    connect (m_manager,     SIGNAL (communicationsChanged (DS_CommStatus)),
             m_elapsedTime,   SLOT (stopTimer()));

    /* Robot information has changed */
    connect (m_manager, SIGNAL (libVersionChanged (QString)),
             this,      SIGNAL (libVersionChanged (QString)));
    connect (m_manager, SIGNAL (rioVersionChanged (QString)),
             this,      SIGNAL (rioVersionChanged (QString)));
    connect (m_manager, SIGNAL (pcmVersionChanged (QString)),
             this,      SIGNAL (pcmVersionChanged (QString)));
    connect (m_manager, SIGNAL (pdpVersionChanged (QString)),
             this,      SIGNAL (pdpVersionChanged (QString)));

    /* Sync robot address and calculated IPs automatically */
    connect (m_manager, SIGNAL (robotAddressChanged (QString)),
             m_client,  SLOT   (setRobotAddress     (QString)));

    /* Update the elapsed time text automatically */
    connect (m_elapsedTime, SIGNAL (elapsedTimeChanged (QString)),
             this,          SIGNAL (elapsedTimeChanged (QString)));

    /* New NetConsole message received */
    connect (m_netConsole,  SIGNAL (newMessage (QString)),
             this,          SIGNAL (newMessage (QString)));

    /* Send and read robot packets */
    connect (m_client,  SIGNAL (dataReceived     (QByteArray)),
             this,        SLOT (readRobotPacket  (QByteArray)));
    connect (DS_Timers::getInstance(), SIGNAL    (timeout20()),
             this,                       SLOT    (sendClientPacket()));
}
Example #2
0
/**
 * Polls for new LibDS events and emits Qt signals as appropiate.
 * This function is called every 5 milliseconds.
 */
void DriverStation::processEvents()
{
    DS_Event event;
    while (DS_PollEvent (&event)) {
        switch (event.type) {
        case DS_FMS_COMMS_CHANGED:
            emit fmsAddressChanged();
            emit fmsCommunicationsChanged (event.fms.connected);
            break;
        case DS_RADIO_COMMS_CHANGED:
            emit radioAddressChanged();
            emit radioCommunicationsChanged (event.radio.connected);
            break;
        case DS_NETCONSOLE_NEW_MESSAGE:
            emit newMessage (QString::fromUtf8 (event.netconsole.message));
            break;
        case DS_ROBOT_ENABLED_CHANGED:
            emit enabledChanged (event.robot.enabled);
            break;
        case DS_ROBOT_MODE_CHANGED:
            emit controlModeChanged (controlMode());
            break;
        case DS_ROBOT_COMMS_CHANGED:
            emit robotAddressChanged();
            emit robotCommunicationsChanged (event.robot.connected);
            break;
        case DS_ROBOT_CODE_CHANGED:
            emit robotCodeChanged (event.robot.code);
            break;
        case DS_ROBOT_VOLTAGE_CHANGED:
            emit voltageChanged (event.robot.voltage);
            break;
        case DS_ROBOT_CAN_UTIL_CHANGED:
            emit canUsageChanged (event.robot.can_util);
            break;
        case DS_ROBOT_CPU_INFO_CHANGED:
            emit cpuUsageChanged (event.robot.cpu_usage);
            break;
        case DS_ROBOT_RAM_INFO_CHANGED:
            emit ramUsageChanged (event.robot.ram_usage);
            break;
        case DS_ROBOT_DISK_INFO_CHANGED:
            emit diskUsageChanged (event.robot.disk_usage);
            break;
        case DS_ROBOT_STATION_CHANGED:
            emit stationChanged();
            emit allianceChanged (teamAlliance());
            emit positionChanged (teamPosition());
            break;
        case DS_ROBOT_ESTOP_CHANGED:
            emit emergencyStoppedChanged (event.robot.estopped);
            break;
        case DS_STATUS_STRING_CHANGED:
            emit statusChanged (QString::fromUtf8 (DS_GetStatusString()));
            break;
        default:
            break;
        }
    }

    QTimer::singleShot (5, Qt::CoarseTimer, this, SLOT (processEvents()));
}