bool sumhInit(rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig, rcReadRawDataPtr *callback) { UNUSED(rxConfig); if (callback) *callback = sumhReadRawRC; rxRuntimeConfig->channelCount = SUMH_MAX_CHANNEL_COUNT; serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_RX_SERIAL); if (!portConfig) { return false; } #ifdef TELEMETRY bool portShared = telemetryCheckRxPortShared(portConfig); #else bool portShared = false; #endif sumhPort = openSerialPort(portConfig->identifier, FUNCTION_RX_SERIAL, sumhDataReceive, SUMH_BAUDRATE, portShared ? MODE_RXTX : MODE_RX, SERIAL_NOT_INVERTED); #ifdef TELEMETRY if (portShared) { telemetrySharedPort = sumhPort; } #endif return sumhPort != NULL; }
void initHoTTTelemetry(void) { portConfig = findSerialPortConfig(FUNCTION_TELEMETRY_HOTT); hottPortSharing = determinePortSharing(portConfig, FUNCTION_TELEMETRY_HOTT); initialiseMessages(); }
bool gpsMagDetect(mag_t *mag) { if (!(feature(FEATURE_GPS) && gpsProviders[gpsState.gpsConfig->provider].hasCompass)) return false; if (gpsProviders[gpsState.gpsConfig->provider].type == GPS_TYPE_SERIAL && (!findSerialPortConfig(FUNCTION_GPS))) { return false; } mag->init = gpsMagInit; mag->read = gpsMagRead; return true; }
void gpsInit(serialConfig_t *initialSerialConfig, gpsConfig_t *initialGpsConfig) { gpsState.serialConfig = initialSerialConfig; gpsState.gpsConfig = initialGpsConfig; gpsState.baudrateIndex = 0; gpsStats.errors = 0; gpsStats.timeouts = 0; gpsResetSolution(); // init gpsData structure. if we're not actually enabled, don't bother doing anything else gpsState.autoConfigStep = 0; gpsState.lastMessageMs = millis(); gpsSetState(GPS_UNKNOWN); if (gpsProviders[gpsState.gpsConfig->provider].type == GPS_TYPE_BUS) { gpsSetState(GPS_INITIALIZING); return; } if (gpsProviders[gpsState.gpsConfig->provider].type == GPS_TYPE_SERIAL) { serialPortConfig_t * gpsPortConfig = findSerialPortConfig(FUNCTION_GPS); if (!gpsPortConfig) { featureClear(FEATURE_GPS); } else { while (gpsToSerialBaudRate[gpsState.baudrateIndex] != gpsPortConfig->gps_baudrateIndex) { gpsState.baudrateIndex++; if (gpsState.baudrateIndex >= GPS_BAUDRATE_COUNT) { gpsState.baudrateIndex = 0; break; } } portMode_t mode = gpsProviders[gpsState.gpsConfig->provider].portMode; // no callback - buffer will be consumed in gpsThread() gpsState.gpsPort = openSerialPort(gpsPortConfig->identifier, FUNCTION_GPS, NULL, baudRates[gpsToSerialBaudRate[gpsState.baudrateIndex]], mode, SERIAL_NOT_INVERTED); if (!gpsState.gpsPort) { featureClear(FEATURE_GPS); } else { gpsSetState(GPS_INITIALIZING); return; } } } }
void gpsInit(serialConfig_t *initialSerialConfig, gpsConfig_t *initialGpsConfig) { serialConfig = initialSerialConfig; gpsData.baudrateIndex = 0; gpsData.errors = 0; gpsData.timeouts = 0; memset(gpsPacketLog, 0x00, sizeof(gpsPacketLog)); gpsConfig = initialGpsConfig; // init gpsData structure. if we're not actually enabled, don't bother doing anything else gpsSetState(GPS_UNKNOWN); gpsData.lastMessage = millis(); serialPortConfig_t *gpsPortConfig = findSerialPortConfig(FUNCTION_GPS); if (!gpsPortConfig) { featureClear(FEATURE_GPS); return; } while (gpsInitData[gpsData.baudrateIndex].baudrateIndex != gpsPortConfig->gps_baudrateIndex) { gpsData.baudrateIndex++; if (gpsData.baudrateIndex >= GPS_INIT_DATA_ENTRY_COUNT) { gpsData.baudrateIndex = DEFAULT_BAUD_RATE_INDEX; break; } } portMode_t mode = MODE_RXTX; // only RX is needed for NMEA-style GPS #if !defined(COLIBRI_RACE) || !defined(LUX_RACE) if (gpsConfig->provider == GPS_NMEA) mode &= ~MODE_TX; #endif // no callback - buffer will be consumed in gpsThread() gpsPort = openSerialPort(gpsPortConfig->identifier, FUNCTION_GPS, NULL, gpsInitData[gpsData.baudrateIndex].baudrateIndex, mode, SERIAL_NOT_INVERTED); if (!gpsPort) { featureClear(FEATURE_GPS); return; } // signal GPS "thread" to initialize when it gets to it gpsSetState(GPS_INITIALIZING); }
bool sumdInit(rxRuntimeConfig_t *rxRuntimeConfig, rcReadRawDataPtr *callback) { if (callback) *callback = sumdReadRawRC; rxRuntimeConfig->channelCount = SUMD_MAX_CHANNEL; serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_RX_SERIAL); if (!portConfig) { return false; } serialPort_t *sumdPort = openSerialPort(portConfig->identifier, FUNCTION_RX_SERIAL, sumdDataReceive, SUMD_BAUDRATE, MODE_RX, SERIAL_NOT_INVERTED); return sumdPort != NULL; }
bool sbusInit(const rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig) { static uint16_t sbusChannelData[SBUS_MAX_CHANNEL]; static sbusFrameData_t sbusFrameData; rxRuntimeConfig->channelData = sbusChannelData; rxRuntimeConfig->frameData = &sbusFrameData; sbusChannelsInit(rxConfig, rxRuntimeConfig); rxRuntimeConfig->channelCount = SBUS_MAX_CHANNEL; rxRuntimeConfig->rxRefreshRate = 11000; rxRuntimeConfig->rcFrameStatusFn = sbusFrameStatus; const serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_RX_SERIAL); if (!portConfig) { return false; } #ifdef USE_TELEMETRY bool portShared = telemetryCheckRxPortShared(portConfig); #else bool portShared = false; #endif serialPort_t *sBusPort = openSerialPort(portConfig->identifier, FUNCTION_RX_SERIAL, sbusDataReceive, &sbusFrameData, SBUS_BAUDRATE, portShared ? MODE_RXTX : MODE_RX, SBUS_PORT_OPTIONS | (rxConfig->serialrx_inverted ? 0 : SERIAL_INVERTED) | (rxConfig->halfDuplex ? SERIAL_BIDIR : 0) ); if (rxConfig->rssi_src_frame_errors) { rssiSource = RSSI_SOURCE_FRAME_ERRORS; } #ifdef USE_TELEMETRY if (portShared) { telemetrySharedPort = sBusPort; } #endif return sBusPort != NULL; }
bool sbusInit(rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig, rcReadRawDataPtr *callback) { int b; for (b = 0; b < SBUS_MAX_CHANNEL; b++) sbusChannelData[b] = (16 * rxConfig->midrc) / 10 - 1408; if (callback) *callback = sbusReadRawRC; rxRuntimeConfig->channelCount = SBUS_MAX_CHANNEL; serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_RX_SERIAL); if (!portConfig) { return false; } serialPort_t *sBusPort = openSerialPort(portConfig->identifier, FUNCTION_RX_SERIAL, sbusDataReceive, SBUS_BAUDRATE, MODE_RX, SBUS_PORT_OPTIONS); return sBusPort != NULL; }
bool ibusInit(rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig, rcReadRawDataPtr *callback) { UNUSED(rxConfig); if (callback) *callback = ibusReadRawRC; rxRuntimeConfig->channelCount = IBUS_MAX_CHANNEL; serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_RX_SERIAL); if (!portConfig) { return false; } serialPort_t *ibusPort = openSerialPort(portConfig->identifier, FUNCTION_RX_SERIAL, ibusDataReceive, IBUS_BAUDRATE, MODE_RX, SERIAL_NOT_INVERTED); return ibusPort != NULL; }
bool escSensorInit(void) { serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_ESC_SENSOR); if (!portConfig) { return false; } portOptions_t options = (SERIAL_NOT_INVERTED); // Initialize serial port escSensorPort = openSerialPort(portConfig->identifier, FUNCTION_ESC_SENSOR, escSensorDataReceive, ESC_SENSOR_BAUDRATE, MODE_RX, options); for (int i = 0; i < MAX_SUPPORTED_MOTORS; i = i + 1) { escSensorData[i].dataAge = ESC_DATA_INVALID; } return escSensorPort != NULL; }
bool xBusInit(rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig, rcReadRawDataPtr *callback) { uint32_t baudRate; switch (rxConfig->serialrx_provider) { case SERIALRX_XBUS_MODE_B: rxRuntimeConfig->channelCount = XBUS_CHANNEL_COUNT; xBusFrameReceived = false; xBusDataIncoming = false; xBusFramePosition = 0; baudRate = XBUS_BAUDRATE; xBusFrameLength = XBUS_FRAME_SIZE; xBusChannelCount = XBUS_CHANNEL_COUNT; xBusProvider = SERIALRX_XBUS_MODE_B; break; case SERIALRX_XBUS_MODE_B_RJ01: rxRuntimeConfig->channelCount = XBUS_RJ01_CHANNEL_COUNT; xBusFrameReceived = false; xBusDataIncoming = false; xBusFramePosition = 0; baudRate = XBUS_RJ01_BAUDRATE; xBusFrameLength = XBUS_RJ01_FRAME_SIZE; xBusChannelCount = XBUS_RJ01_CHANNEL_COUNT; xBusProvider = SERIALRX_XBUS_MODE_B_RJ01; break; default: return false; break; } if (callback) { *callback = xBusReadRawRC; } serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_RX_SERIAL); if (!portConfig) { return false; } serialPort_t *xBusPort = openSerialPort(portConfig->identifier, FUNCTION_RX_SERIAL, xBusDataReceive, baudRate, MODE_RX, SERIAL_NOT_INVERTED); return xBusPort != NULL; }
bool sumhInit(const rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig) { UNUSED(rxConfig); rxRuntimeConfig->channelCount = SUMH_MAX_CHANNEL_COUNT; rxRuntimeConfig->rxRefreshRate = 11000; rxRuntimeConfig->rcReadRawFn = sumhReadRawRC; rxRuntimeConfig->rcFrameStatusFn = sumhFrameStatus; serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_RX_SERIAL); if (!portConfig) { return false; } sumhPort = openSerialPort(portConfig->identifier, FUNCTION_RX_SERIAL, sumhDataReceive, SUMH_BAUDRATE, MODE_RX, SERIAL_NOT_INVERTED); return sumhPort != NULL; }
bool ibusInit(const rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig) { UNUSED(rxConfig); rxRuntimeConfig->channelCount = IBUS_MAX_CHANNEL; rxRuntimeConfig->rxRefreshRate = 11000; rxRuntimeConfig->rcReadRawFn = ibusReadRawRC; rxRuntimeConfig->rcFrameStatusFn = ibusFrameStatus; serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_RX_SERIAL); if (!portConfig) { return false; } serialPort_t *ibusPort = openSerialPort(portConfig->identifier, FUNCTION_RX_SERIAL, ibusDataReceive, IBUS_BAUDRATE, MODE_RX, SERIAL_NOT_INVERTED); return ibusPort != NULL; }
void mspSerialAllocatePorts(void) { uint8_t portIndex = 0; serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_MSP); while (portConfig && portIndex < MAX_MSP_PORT_COUNT) { mspPort_t *mspPort = &mspPorts[portIndex]; if (mspPort->port) { portIndex++; continue; } serialPort_t *serialPort = openSerialPort(portConfig->identifier, FUNCTION_MSP, NULL, NULL, baudRates[portConfig->msp_baudrateIndex], MODE_RXTX, SERIAL_NOT_INVERTED); if (serialPort) { bool sharedWithTelemetry = isSerialPortShared(portConfig, FUNCTION_MSP, TELEMETRY_PORT_FUNCTIONS_MASK); resetMspPort(mspPort, serialPort, sharedWithTelemetry); portIndex++; } portConfig = findNextSerialPortConfig(FUNCTION_MSP); } }
void mspSerialAllocatePorts(void) { for(serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_MSP_SERVER | FUNCTION_MSP_CLIENT); portConfig != NULL; portConfig = findNextSerialPortConfig(FUNCTION_MSP_SERVER | FUNCTION_MSP_CLIENT)) { if(isSerialPortOpen(portConfig)) continue; // port is already open // find unused mspPort for this serial mspPort_t *mspPort = mspPortFindFree(); if(mspPort == NULL) { // no mspPort available, give up // this error should be signalized to user (invalid configuration) return; } uint16_t function = portConfig->functionMask & (FUNCTION_MSP_SERVER | FUNCTION_MSP_CLIENT); // assume server unless the function indicates client. uint8_t baudRatesIndex = BAUDRATE_MSP_SERVER; mspPortMode_e mode = MSP_MODE_SERVER; #ifdef USE_MSP_CLIENT if (function & FUNCTION_MSP_CLIENT) { baudRatesIndex = BAUDRATE_MSP_CLIENT; mode = MSP_MODE_CLIENT; } #endif serialPort_t *serialPort = openSerialPort(portConfig->identifier, function, NULL, baudRates[portConfig->baudRates[baudRatesIndex]], MODE_RXTX, SERIAL_NOT_INVERTED); if (serialPort) { resetMspPort(mspPort, serialPort); mspPort->mode = mode; } else { // unexpected error, inform user } } }
bool ibusInit(const rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig) { UNUSED(rxConfig); ibusSyncByte = 0; rxRuntimeConfig->channelCount = IBUS_MAX_CHANNEL; rxRuntimeConfig->rxRefreshRate = 20000; // TODO - Verify speed rxRuntimeConfig->rcReadRawFn = ibusReadRawRC; rxRuntimeConfig->rcFrameStatusFn = ibusFrameStatus; const serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_RX_SERIAL); if (!portConfig) { return false; } #ifdef TELEMETRY bool portShared = isSerialPortShared(portConfig, FUNCTION_RX_SERIAL, FUNCTION_TELEMETRY_IBUS); #else bool portShared = false; #endif rxBytesToIgnore = 0; serialPort_t *ibusPort = openSerialPort(portConfig->identifier, FUNCTION_RX_SERIAL, ibusDataReceive, IBUS_BAUDRATE, portShared ? MODE_RXTX : MODE_RX, SERIAL_NOT_INVERTED | (rxConfig->halfDuplex || portShared ? SERIAL_BIDIR : 0) ); #if defined(TELEMETRY) && defined(TELEMETRY_IBUS) if (portShared) { initSharedIbusTelemetry(ibusPort); } #endif return ibusPort != NULL; }
bool sumdInit(const rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig) { UNUSED(rxConfig); rxRuntimeConfig->channelCount = MIN(SUMD_MAX_CHANNEL, MAX_SUPPORTED_RC_CHANNEL_COUNT); rxRuntimeConfig->rxRefreshRate = 11000; rxRuntimeConfig->rcReadRawFn = sumdReadRawRC; rxRuntimeConfig->rcFrameStatusFn = sumdFrameStatus; const serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_RX_SERIAL); if (!portConfig) { return false; } #ifdef USE_TELEMETRY bool portShared = telemetryCheckRxPortShared(portConfig); #else bool portShared = false; #endif serialPort_t *sumdPort = openSerialPort(portConfig->identifier, FUNCTION_RX_SERIAL, sumdDataReceive, NULL, SUMD_BAUDRATE, portShared ? MODE_RXTX : MODE_RX, (rxConfig->serialrx_inverted ? SERIAL_INVERTED : 0) | (rxConfig->halfDuplex ? SERIAL_BIDIR : 0) ); #ifdef USE_TELEMETRY if (portShared) { telemetrySharedPort = sumdPort; } #endif return sumdPort != NULL; }
void initSmartPortTelemetry(telemetryConfig_t *initialTelemetryConfig) { telemetryConfig = initialTelemetryConfig; portConfig = findSerialPortConfig(FUNCTION_TELEMETRY_SMARTPORT); smartPortPortSharing = determinePortSharing(portConfig, FUNCTION_TELEMETRY_SMARTPORT); }
void initFrSkyTelemetry(telemetryConfig_t *initialTelemetryConfig) { telemetryConfig = initialTelemetryConfig; portConfig = findSerialPortConfig(FUNCTION_TELEMETRY_FRSKY); frskyPortSharing = determinePortSharing(portConfig, FUNCTION_TELEMETRY_FRSKY); }
void initFrSkyTelemetry(void) { portConfig = findSerialPortConfig(FUNCTION_TELEMETRY_FRSKY); frskyPortSharing = determinePortSharing(portConfig, FUNCTION_TELEMETRY_FRSKY); }
void initLtmTelemetry(telemetryConfig_t *initialTelemetryConfig) { telemetryConfig = initialTelemetryConfig; portConfig = findSerialPortConfig(FUNCTION_TELEMETRY_LTM); ltmPortSharing = determinePortSharing(portConfig, FUNCTION_TELEMETRY_LTM); }
void initIbusTelemetry(void) { ibusSerialPortConfig = findSerialPortConfig(FUNCTION_TELEMETRY_IBUS); ibusPortSharing = determinePortSharing(ibusSerialPortConfig, FUNCTION_TELEMETRY_IBUS); ibusTelemetryEnabled = false; }
void initMAVLinkTelemetry(void) { portConfig = findSerialPortConfig(FUNCTION_TELEMETRY_MAVLINK); mavlinkPortSharing = determinePortSharing(portConfig, FUNCTION_TELEMETRY_MAVLINK); }
void initSmartPortTelemetry(void) { portConfig = findSerialPortConfig(FUNCTION_TELEMETRY_SMARTPORT); smartPortPortSharing = determinePortSharing(portConfig, FUNCTION_TELEMETRY_SMARTPORT); }
void initLtmTelemetry(void) { portConfig = findSerialPortConfig(FUNCTION_TELEMETRY_LTM); ltmPortSharing = determinePortSharing(portConfig, FUNCTION_TELEMETRY_LTM); }