2010-09-27 09:28:34 +02:00
/**
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* @ addtogroup OpenPilotModules OpenPilot Modules
* @ {
* @ addtogroup TelemetryModule Telemetry Module
* @ brief Main telemetry module
* Starts three tasks ( RX , TX , and priority TX ) that watch event queues
* and handle all the telemetry of the UAVobjects
* @ {
*
* @ file telemetry . c
* @ author The OpenPilot Team , http : //www.openpilot.org Copyright (C) 2010.
* @ brief Telemetry module , handles telemetry and UAVObject updates
* @ see The GNU Public License ( GPL ) Version 3
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*
* This program is free software ; you can redistribute it and / or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation ; either version 3 of the License , or
* ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful , but
* WITHOUT ANY WARRANTY ; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE . See the GNU General Public License
* for more details .
*
* You should have received a copy of the GNU General Public License along
* with this program ; if not , write to the Free Software Foundation , Inc . ,
* 59 Temple Place , Suite 330 , Boston , MA 02111 - 1307 USA
*/
# include "openpilot.h"
2011-06-17 07:13:19 +02:00
# include "telemetry.h"
2010-09-27 09:28:34 +02:00
# include "flighttelemetrystats.h"
# include "gcstelemetrystats.h"
2011-09-28 21:09:19 +02:00
# include "hwsettings.h"
2012-08-25 20:45:43 +02:00
# if defined(PIOS_PACKET_HANDLER)
# include "pipxstatus.h"
# include "packet_handler.h"
# endif
2010-09-27 09:28:34 +02:00
// Private constants
2011-02-01 03:18:35 +01:00
# define MAX_QUEUE_SIZE TELEM_QUEUE_SIZE
2011-02-02 09:57:34 +01:00
# define STACK_SIZE_BYTES PIOS_TELEM_STACK_SIZE
2010-09-27 09:28:34 +02:00
# define TASK_PRIORITY_RX (tskIDLE_PRIORITY + 2)
# define TASK_PRIORITY_TX (tskIDLE_PRIORITY + 2)
# define TASK_PRIORITY_TXPRI (tskIDLE_PRIORITY + 2)
# define REQ_TIMEOUT_MS 250
# define MAX_RETRIES 2
# define STATS_UPDATE_PERIOD_MS 4000
# define CONNECTION_TIMEOUT_MS 8000
// Private types
// Private variables
2011-02-12 23:19:43 +01:00
static uint32_t telemetryPort ;
2010-09-27 09:28:34 +02:00
static xQueueHandle queue ;
2011-02-05 11:52:52 +01:00
# if defined(PIOS_TELEM_PRIORITY_QUEUE)
2010-09-27 09:28:34 +02:00
static xQueueHandle priorityQueue ;
static xTaskHandle telemetryTxPriTaskHandle ;
2011-02-05 11:52:52 +01:00
static void telemetryTxPriTask ( void * parameters ) ;
# else
# define priorityQueue queue
# endif
static xTaskHandle telemetryTxTaskHandle ;
2010-09-27 09:28:34 +02:00
static xTaskHandle telemetryRxTaskHandle ;
static uint32_t txErrors ;
static uint32_t txRetries ;
static uint32_t timeOfLastObjectUpdate ;
2011-06-16 16:35:37 +02:00
static UAVTalkConnection uavTalkCon ;
2010-09-27 09:28:34 +02:00
// Private functions
static void telemetryTxTask ( void * parameters ) ;
static void telemetryRxTask ( void * parameters ) ;
static int32_t transmitData ( uint8_t * data , int32_t length ) ;
static void registerObject ( UAVObjHandle obj ) ;
2012-04-19 03:47:13 +02:00
static void updateObject ( UAVObjHandle obj , int32_t eventType ) ;
2010-09-27 09:28:34 +02:00
static int32_t addObject ( UAVObjHandle obj ) ;
static int32_t setUpdatePeriod ( UAVObjHandle obj , int32_t updatePeriodMs ) ;
static void processObjEvent ( UAVObjEvent * ev ) ;
static void updateTelemetryStats ( ) ;
static void gcsTelemetryStatsUpdated ( ) ;
static void updateSettings ( ) ;
2012-08-25 20:45:43 +02:00
static uint32_t getComPort ( ) ;
# ifdef PIOS_PACKET_HANDLER
static void receivePacketData ( uint8_t * buf , uint8_t len , int8_t rssi , int8_t afc ) ;
# endif
2010-09-27 09:28:34 +02:00
/**
* Initialise the telemetry module
* \ return - 1 if initialisation failed
* \ return 0 on success
*/
2011-06-20 07:35:40 +02:00
int32_t TelemetryStart ( void )
{
2011-07-30 04:31:45 +02:00
// Process all registered objects and connect queue for updates
UAVObjIterate ( & registerObject ) ;
// Listen to objects of interest
GCSTelemetryStatsConnectQueue ( priorityQueue ) ;
2012-08-25 20:45:43 +02:00
// Register to receive data from the radio packet handler.
// This must be after the radio module is initialized.
# ifdef PIOS_PACKET_HANDLER
if ( PIOS_PACKET_HANDLER )
PHRegisterDataHandler ( PIOS_PACKET_HANDLER , receivePacketData ) ;
# endif
2011-07-30 04:31:45 +02:00
2011-06-20 07:35:40 +02:00
// Start telemetry tasks
xTaskCreate ( telemetryTxTask , ( signed char * ) " TelTx " , STACK_SIZE_BYTES / 4 , NULL , TASK_PRIORITY_TX , & telemetryTxTaskHandle ) ;
xTaskCreate ( telemetryRxTask , ( signed char * ) " TelRx " , STACK_SIZE_BYTES / 4 , NULL , TASK_PRIORITY_RX , & telemetryRxTaskHandle ) ;
TaskMonitorAdd ( TASKINFO_RUNNING_TELEMETRYTX , telemetryTxTaskHandle ) ;
TaskMonitorAdd ( TASKINFO_RUNNING_TELEMETRYRX , telemetryRxTaskHandle ) ;
# if defined(PIOS_TELEM_PRIORITY_QUEUE)
xTaskCreate ( telemetryTxPriTask , ( signed char * ) " TelPriTx " , STACK_SIZE_BYTES / 4 , NULL , TASK_PRIORITY_TXPRI , & telemetryTxPriTaskHandle ) ;
TaskMonitorAdd ( TASKINFO_RUNNING_TELEMETRYTXPRI , telemetryTxPriTaskHandle ) ;
# endif
return 0 ;
}
2010-09-27 09:28:34 +02:00
/**
* Initialise the telemetry module
* \ return - 1 if initialisation failed
* \ return 0 on success
*/
int32_t TelemetryInitialize ( void )
{
2011-06-18 18:59:02 +02:00
FlightTelemetryStatsInitialize ( ) ;
GCSTelemetryStatsInitialize ( ) ;
2010-09-27 09:28:34 +02:00
// Initialize vars
timeOfLastObjectUpdate = 0 ;
// Create object queues
queue = xQueueCreate ( MAX_QUEUE_SIZE , sizeof ( UAVObjEvent ) ) ;
2011-02-05 11:52:52 +01:00
# if defined(PIOS_TELEM_PRIORITY_QUEUE)
2010-09-27 09:28:34 +02:00
priorityQueue = xQueueCreate ( MAX_QUEUE_SIZE , sizeof ( UAVObjEvent ) ) ;
2011-02-05 11:52:52 +01:00
# endif
2010-09-27 09:28:34 +02:00
2011-09-28 21:09:19 +02:00
// Update telemetry settings
2011-10-31 22:04:17 +01:00
telemetryPort = PIOS_COM_TELEM_RF ;
HwSettingsInitialize ( ) ;
2011-07-30 04:31:45 +02:00
updateSettings ( ) ;
2010-09-27 09:28:34 +02:00
// Initialise UAVTalk
2011-12-27 18:19:05 +01:00
uavTalkCon = UAVTalkInitialize ( & transmitData ) ;
2011-07-30 04:31:45 +02:00
2010-09-27 09:28:34 +02:00
// Create periodic event that will be used to update the telemetry stats
txErrors = 0 ;
txRetries = 0 ;
2011-10-31 22:04:17 +01:00
UAVObjEvent ev ;
2010-09-27 09:28:34 +02:00
memset ( & ev , 0 , sizeof ( UAVObjEvent ) ) ;
EventPeriodicQueueCreate ( & ev , priorityQueue , STATS_UPDATE_PERIOD_MS ) ;
return 0 ;
}
2011-07-13 05:44:32 +02:00
MODULE_INITCALL ( TelemetryInitialize , TelemetryStart )
2011-06-17 07:13:19 +02:00
2010-09-27 09:28:34 +02:00
/**
* Register a new object , adds object to local list and connects the queue depending on the object ' s
* telemetry settings .
* \ param [ in ] obj Object to connect
*/
static void registerObject ( UAVObjHandle obj )
{
// Setup object for periodic updates
addObject ( obj ) ;
// Setup object for telemetry updates
2012-04-19 03:47:13 +02:00
updateObject ( obj , EV_NONE ) ;
2010-09-27 09:28:34 +02:00
}
/**
* Update object ' s queue connections and timer , depending on object ' s settings
* \ param [ in ] obj Object to updates
*/
2012-04-19 03:47:13 +02:00
static void updateObject ( UAVObjHandle obj , int32_t eventType )
2010-09-27 09:28:34 +02:00
{
UAVObjMetadata metadata ;
2012-02-21 02:45:18 +01:00
UAVObjUpdateMode updateMode ;
2010-09-27 09:28:34 +02:00
int32_t eventMask ;
// Get metadata
UAVObjGetMetadata ( obj , & metadata ) ;
2012-02-21 02:45:18 +01:00
updateMode = UAVObjGetTelemetryUpdateMode ( & metadata ) ;
2010-09-27 09:28:34 +02:00
// Setup object depending on update mode
2012-02-21 02:45:18 +01:00
if ( updateMode = = UPDATEMODE_PERIODIC ) {
2010-09-27 09:28:34 +02:00
// Set update period
setUpdatePeriod ( obj , metadata . telemetryUpdatePeriod ) ;
// Connect queue
2012-04-21 20:59:14 +02:00
eventMask = EV_UPDATED_PERIODIC | EV_UPDATED_MANUAL | EV_UPDATE_REQ ;
2010-09-27 09:28:34 +02:00
if ( UAVObjIsMetaobject ( obj ) ) {
eventMask | = EV_UNPACKED ; // we also need to act on remote updates (unpack events)
}
UAVObjConnectQueue ( obj , priorityQueue , eventMask ) ;
2012-02-21 02:45:18 +01:00
} else if ( updateMode = = UPDATEMODE_ONCHANGE ) {
2010-09-27 09:28:34 +02:00
// Set update period
setUpdatePeriod ( obj , 0 ) ;
// Connect queue
eventMask = EV_UPDATED | EV_UPDATED_MANUAL | EV_UPDATE_REQ ;
if ( UAVObjIsMetaobject ( obj ) ) {
eventMask | = EV_UNPACKED ; // we also need to act on remote updates (unpack events)
}
UAVObjConnectQueue ( obj , priorityQueue , eventMask ) ;
2012-04-19 03:47:13 +02:00
} else if ( updateMode = = UPDATEMODE_THROTTLED ) {
2012-04-21 20:59:14 +02:00
if ( ( eventType = = EV_UPDATED_PERIODIC ) | | ( eventType = = EV_NONE ) ) {
2012-04-22 23:56:26 +02:00
// If we received a periodic update, we can change back to update on change
2012-04-19 03:47:13 +02:00
eventMask = EV_UPDATED | EV_UPDATED_MANUAL | EV_UPDATE_REQ ;
2012-04-22 23:56:26 +02:00
// Set update period on initialization and metadata change
if ( eventType = = EV_NONE )
setUpdatePeriod ( obj , metadata . telemetryUpdatePeriod ) ;
2012-04-19 03:47:13 +02:00
} else {
// Otherwise, we just received an object update, so switch to periodic for the timeout period to prevent more updates
2012-04-21 20:59:14 +02:00
eventMask = EV_UPDATED_PERIODIC | EV_UPDATED_MANUAL | EV_UPDATE_REQ ;
}
if ( UAVObjIsMetaobject ( obj ) ) {
eventMask | = EV_UNPACKED ; // we also need to act on remote updates (unpack events)
}
UAVObjConnectQueue ( obj , priorityQueue , eventMask ) ;
2012-02-21 02:45:18 +01:00
} else if ( updateMode = = UPDATEMODE_MANUAL ) {
2010-09-27 09:28:34 +02:00
// Set update period
setUpdatePeriod ( obj , 0 ) ;
// Connect queue
eventMask = EV_UPDATED_MANUAL | EV_UPDATE_REQ ;
if ( UAVObjIsMetaobject ( obj ) ) {
eventMask | = EV_UNPACKED ; // we also need to act on remote updates (unpack events)
}
UAVObjConnectQueue ( obj , priorityQueue , eventMask ) ;
}
}
/**
* Processes queue events
*/
static void processObjEvent ( UAVObjEvent * ev )
{
UAVObjMetadata metadata ;
2012-04-19 03:47:13 +02:00
UAVObjUpdateMode updateMode ;
2010-09-27 09:28:34 +02:00
FlightTelemetryStatsData flightStats ;
int32_t retries ;
int32_t success ;
if ( ev - > obj = = 0 ) {
updateTelemetryStats ( ) ;
} else if ( ev - > obj = = GCSTelemetryStatsHandle ( ) ) {
gcsTelemetryStatsUpdated ( ) ;
} else {
// Only process event if connected to GCS or if object FlightTelemetryStats is updated
FlightTelemetryStatsGet ( & flightStats ) ;
2012-04-21 20:59:14 +02:00
// Get object metadata
UAVObjGetMetadata ( ev - > obj , & metadata ) ;
updateMode = UAVObjGetTelemetryUpdateMode ( & metadata ) ;
2010-09-27 09:28:34 +02:00
if ( flightStats . Status = = FLIGHTTELEMETRYSTATS_STATUS_CONNECTED | | ev - > obj = = FlightTelemetryStatsHandle ( ) ) {
// Act on event
retries = 0 ;
success = - 1 ;
2012-04-19 03:47:13 +02:00
if ( ev - > event = = EV_UPDATED | | ev - > event = = EV_UPDATED_MANUAL | | ( ( ev - > event = = EV_UPDATED_PERIODIC ) & & ( updateMode ! = UPDATEMODE_THROTTLED ) ) ) {
2012-08-25 20:45:43 +02:00
# ifdef PIOS_PACKET_HANDLER
// Don't send PipXStatus objects over the radio link.
2012-09-08 21:02:00 +02:00
if ( PIOS_PACKET_HANDLER & & ( ev - > obj = = PipXStatusHandle ( ) ) & & ( getComPort ( ) = = 0 ) )
2012-08-25 20:45:43 +02:00
return ;
# endif
2010-09-27 09:28:34 +02:00
// Send update to GCS (with retries)
while ( retries < MAX_RETRIES & & success = = - 1 ) {
2012-02-21 02:45:18 +01:00
success = UAVTalkSendObject ( uavTalkCon , ev - > obj , ev - > instId , UAVObjGetTelemetryAcked ( & metadata ) , REQ_TIMEOUT_MS ) ; // call blocks until ack is received or timeout
2010-09-27 09:28:34 +02:00
+ + retries ;
}
// Update stats
txRetries + = ( retries - 1 ) ;
if ( success = = - 1 ) {
+ + txErrors ;
}
} else if ( ev - > event = = EV_UPDATE_REQ ) {
// Request object update from GCS (with retries)
while ( retries < MAX_RETRIES & & success = = - 1 ) {
2011-06-24 02:08:20 +02:00
success = UAVTalkSendObjectRequest ( uavTalkCon , ev - > obj , ev - > instId , REQ_TIMEOUT_MS ) ; // call blocks until update is received or timeout
2010-09-27 09:28:34 +02:00
+ + retries ;
}
// Update stats
txRetries + = ( retries - 1 ) ;
if ( success = = - 1 ) {
+ + txErrors ;
}
}
// If this is a metaobject then make necessary telemetry updates
if ( UAVObjIsMetaobject ( ev - > obj ) ) {
2012-04-22 23:56:26 +02:00
updateObject ( UAVObjGetLinkedObj ( ev - > obj ) , EV_NONE ) ; // linked object will be the actual object the metadata are for
2010-09-27 09:28:34 +02:00
}
}
2012-04-21 20:59:14 +02:00
if ( ( updateMode = = UPDATEMODE_THROTTLED ) & & ! UAVObjIsMetaobject ( ev - > obj ) ) {
// If this is UPDATEMODE_THROTTLED, the event mask changes on every event.
updateObject ( ev - > obj , ev - > event ) ;
}
2010-09-27 09:28:34 +02:00
}
}
/**
* Telemetry transmit task , regular priority
*/
static void telemetryTxTask ( void * parameters )
{
UAVObjEvent ev ;
// Loop forever
while ( 1 ) {
// Wait for queue message
if ( xQueueReceive ( queue , & ev , portMAX_DELAY ) = = pdTRUE ) {
// Process event
processObjEvent ( & ev ) ;
}
}
}
/**
* Telemetry transmit task , high priority
*/
2011-02-05 11:52:52 +01:00
# if defined(PIOS_TELEM_PRIORITY_QUEUE)
2010-09-27 09:28:34 +02:00
static void telemetryTxPriTask ( void * parameters )
{
UAVObjEvent ev ;
// Loop forever
while ( 1 ) {
// Wait for queue message
if ( xQueueReceive ( priorityQueue , & ev , portMAX_DELAY ) = = pdTRUE ) {
// Process event
processObjEvent ( & ev ) ;
}
}
}
2011-02-05 11:52:52 +01:00
# endif
2010-09-27 09:28:34 +02:00
/**
* Telemetry transmit task . Processes queue events and periodic updates .
*/
static void telemetryRxTask ( void * parameters )
{
// Task loop
while ( 1 ) {
2012-08-25 20:45:43 +02:00
uint32_t inputPort = getComPort ( ) ;
2010-09-27 09:28:34 +02:00
2011-07-29 16:04:55 +02:00
if ( inputPort ) {
// Block until data are available
uint8_t serial_data [ 1 ] ;
uint16_t bytes_to_process ;
2010-09-27 09:28:34 +02:00
2011-07-29 16:04:55 +02:00
bytes_to_process = PIOS_COM_ReceiveBuffer ( inputPort , serial_data , sizeof ( serial_data ) , 500 ) ;
if ( bytes_to_process > 0 ) {
for ( uint8_t i = 0 ; i < bytes_to_process ; i + + ) {
2011-08-17 08:30:32 +02:00
UAVTalkProcessInputStream ( uavTalkCon , serial_data [ i ] ) ;
2011-07-29 16:04:55 +02:00
}
2011-07-26 06:27:03 +02:00
}
2011-07-29 16:04:55 +02:00
} else {
vTaskDelay ( 5 ) ;
2011-07-26 06:27:03 +02:00
}
2010-09-27 09:28:34 +02:00
}
}
/**
* Transmit data buffer to the modem or USB port .
* \ param [ in ] data Data buffer to send
* \ param [ in ] length Length of buffer
2011-12-27 18:19:05 +01:00
* \ return - 1 on failure
* \ return number of bytes transmitted on success
2010-09-27 09:28:34 +02:00
*/
static int32_t transmitData ( uint8_t * data , int32_t length )
{
2012-08-25 20:45:43 +02:00
uint32_t outputPort = getComPort ( ) ;
2010-09-27 09:28:34 +02:00
2011-07-29 16:04:55 +02:00
if ( outputPort ) {
2011-12-27 18:19:05 +01:00
return PIOS_COM_SendBuffer ( outputPort , data , length ) ;
2011-07-29 16:04:55 +02:00
}
2012-08-25 20:45:43 +02:00
# ifdef PIOS_PACKET_HANDLER
if ( PIOS_PACKET_HANDLER )
if ( PHTransmitData ( PIOS_PACKET_HANDLER , data , length ) )
2012-09-04 17:20:51 +02:00
return length ;
2012-08-25 20:45:43 +02:00
# endif
return - 1 ;
2010-09-27 09:28:34 +02:00
}
/**
* Setup object for periodic updates .
* \ param [ in ] obj The object to update
* \ return 0 Success
* \ return - 1 Failure
*/
static int32_t addObject ( UAVObjHandle obj )
{
UAVObjEvent ev ;
// Add object for periodic updates
ev . obj = obj ;
ev . instId = UAVOBJ_ALL_INSTANCES ;
2012-04-21 20:59:14 +02:00
ev . event = EV_UPDATED_PERIODIC ;
2010-09-27 09:28:34 +02:00
return EventPeriodicQueueCreate ( & ev , queue , 0 ) ;
}
/**
* Set update period of object ( it must be already setup for periodic updates )
* \ param [ in ] obj The object to update
* \ param [ in ] updatePeriodMs The update period in ms , if zero then periodic updates are disabled
* \ return 0 Success
* \ return - 1 Failure
*/
static int32_t setUpdatePeriod ( UAVObjHandle obj , int32_t updatePeriodMs )
{
UAVObjEvent ev ;
// Add object for periodic updates
ev . obj = obj ;
ev . instId = UAVOBJ_ALL_INSTANCES ;
2012-04-19 03:47:13 +02:00
ev . event = EV_UPDATED_PERIODIC ;
2010-09-27 09:28:34 +02:00
return EventPeriodicQueueUpdate ( & ev , queue , updatePeriodMs ) ;
}
/**
* Called each time the GCS telemetry stats object is updated .
* Trigger a flight telemetry stats update if a connection is not
* yet established .
*/
static void gcsTelemetryStatsUpdated ( )
{
FlightTelemetryStatsData flightStats ;
GCSTelemetryStatsData gcsStats ;
FlightTelemetryStatsGet ( & flightStats ) ;
GCSTelemetryStatsGet ( & gcsStats ) ;
if ( flightStats . Status ! = FLIGHTTELEMETRYSTATS_STATUS_CONNECTED | | gcsStats . Status ! = GCSTELEMETRYSTATS_STATUS_CONNECTED ) {
updateTelemetryStats ( ) ;
}
}
/**
* Update telemetry statistics and handle connection handshake
*/
static void updateTelemetryStats ( )
{
UAVTalkStats utalkStats ;
FlightTelemetryStatsData flightStats ;
GCSTelemetryStatsData gcsStats ;
uint8_t forceUpdate ;
uint8_t connectionTimeout ;
uint32_t timeNow ;
// Get stats
2011-06-24 02:08:20 +02:00
UAVTalkGetStats ( uavTalkCon , & utalkStats ) ;
UAVTalkResetStats ( uavTalkCon ) ;
2010-09-27 09:28:34 +02:00
// Get object data
FlightTelemetryStatsGet ( & flightStats ) ;
GCSTelemetryStatsGet ( & gcsStats ) ;
// Update stats object
if ( flightStats . Status = = FLIGHTTELEMETRYSTATS_STATUS_CONNECTED ) {
flightStats . RxDataRate = ( float ) utalkStats . rxBytes / ( ( float ) STATS_UPDATE_PERIOD_MS / 1000.0 ) ;
flightStats . TxDataRate = ( float ) utalkStats . txBytes / ( ( float ) STATS_UPDATE_PERIOD_MS / 1000.0 ) ;
flightStats . RxFailures + = utalkStats . rxErrors ;
flightStats . TxFailures + = txErrors ;
flightStats . TxRetries + = txRetries ;
txErrors = 0 ;
txRetries = 0 ;
} else {
flightStats . RxDataRate = 0 ;
flightStats . TxDataRate = 0 ;
flightStats . RxFailures = 0 ;
flightStats . TxFailures = 0 ;
flightStats . TxRetries = 0 ;
txErrors = 0 ;
txRetries = 0 ;
}
// Check for connection timeout
timeNow = xTaskGetTickCount ( ) * portTICK_RATE_MS ;
if ( utalkStats . rxObjects > 0 ) {
timeOfLastObjectUpdate = timeNow ;
}
if ( ( timeNow - timeOfLastObjectUpdate ) > CONNECTION_TIMEOUT_MS ) {
connectionTimeout = 1 ;
} else {
connectionTimeout = 0 ;
}
// Update connection state
forceUpdate = 1 ;
if ( flightStats . Status = = FLIGHTTELEMETRYSTATS_STATUS_DISCONNECTED ) {
// Wait for connection request
if ( gcsStats . Status = = GCSTELEMETRYSTATS_STATUS_HANDSHAKEREQ ) {
flightStats . Status = FLIGHTTELEMETRYSTATS_STATUS_HANDSHAKEACK ;
}
} else if ( flightStats . Status = = FLIGHTTELEMETRYSTATS_STATUS_HANDSHAKEACK ) {
// Wait for connection
if ( gcsStats . Status = = GCSTELEMETRYSTATS_STATUS_CONNECTED ) {
flightStats . Status = FLIGHTTELEMETRYSTATS_STATUS_CONNECTED ;
} else if ( gcsStats . Status = = GCSTELEMETRYSTATS_STATUS_DISCONNECTED ) {
flightStats . Status = FLIGHTTELEMETRYSTATS_STATUS_DISCONNECTED ;
}
} else if ( flightStats . Status = = FLIGHTTELEMETRYSTATS_STATUS_CONNECTED ) {
if ( gcsStats . Status ! = GCSTELEMETRYSTATS_STATUS_CONNECTED | | connectionTimeout ) {
flightStats . Status = FLIGHTTELEMETRYSTATS_STATUS_DISCONNECTED ;
} else {
forceUpdate = 0 ;
}
} else {
flightStats . Status = FLIGHTTELEMETRYSTATS_STATUS_DISCONNECTED ;
}
// Update the telemetry alarm
if ( flightStats . Status = = FLIGHTTELEMETRYSTATS_STATUS_CONNECTED ) {
AlarmsClear ( SYSTEMALARMS_ALARM_TELEMETRY ) ;
} else {
AlarmsSet ( SYSTEMALARMS_ALARM_TELEMETRY , SYSTEMALARMS_ALARM_ERROR ) ;
}
// Update object
FlightTelemetryStatsSet ( & flightStats ) ;
// Force telemetry update if not connected
if ( forceUpdate ) {
FlightTelemetryStatsUpdated ( ) ;
}
}
/**
2011-10-31 22:04:17 +01:00
* Update the telemetry settings , called on startup .
* FIXME : This should be in the TelemetrySettings object . But objects
* have too much overhead yet . Also the telemetry has no any specific
* settings , etc . Thus the HwSettings object which contains the
* telemetry port speed is used for now .
2010-09-27 09:28:34 +02:00
*/
static void updateSettings ( )
{
2012-01-05 05:19:13 +01:00
2011-09-28 21:09:19 +02:00
if ( telemetryPort ) {
// Retrieve settings
uint8_t speed ;
HwSettingsTelemetrySpeedGet ( & speed ) ;
// Set port speed
switch ( speed ) {
case HWSETTINGS_TELEMETRYSPEED_2400 :
PIOS_COM_ChangeBaud ( telemetryPort , 2400 ) ;
break ;
case HWSETTINGS_TELEMETRYSPEED_4800 :
PIOS_COM_ChangeBaud ( telemetryPort , 4800 ) ;
break ;
case HWSETTINGS_TELEMETRYSPEED_9600 :
PIOS_COM_ChangeBaud ( telemetryPort , 9600 ) ;
break ;
case HWSETTINGS_TELEMETRYSPEED_19200 :
PIOS_COM_ChangeBaud ( telemetryPort , 19200 ) ;
break ;
case HWSETTINGS_TELEMETRYSPEED_38400 :
PIOS_COM_ChangeBaud ( telemetryPort , 38400 ) ;
break ;
case HWSETTINGS_TELEMETRYSPEED_57600 :
PIOS_COM_ChangeBaud ( telemetryPort , 57600 ) ;
break ;
case HWSETTINGS_TELEMETRYSPEED_115200 :
PIOS_COM_ChangeBaud ( telemetryPort , 115200 ) ;
break ;
}
}
2010-09-27 09:28:34 +02:00
}
2012-08-25 20:45:43 +02:00
/**
* Determine input / output com port ( USB takes priority over telemetry port )
*/
static uint32_t getComPort ( ) {
# if defined(PIOS_INCLUDE_USB)
if ( PIOS_USB_CheckAvailable ( 0 ) & & PIOS_COM_TELEM_USB )
return PIOS_COM_TELEM_USB ;
else
# endif /* PIOS_INCLUDE_USB */
return telemetryPort ;
}
# ifdef PIOS_PACKET_HANDLER
/**
* Receive a packet
* \ param [ in ] buf The received data buffer
* \ param [ in ] length Length of buffer
*/
static void receivePacketData ( uint8_t * buf , uint8_t len , int8_t rssi , int8_t afc )
{
for ( uint8_t i = 0 ; i < len ; + + i )
UAVTalkProcessInputStream ( uavTalkCon , buf [ i ] ) ;
}
# endif
2010-09-27 09:28:34 +02:00
/**
* @ }
* @ }
*/