/** * Sends a package over given port * (blocking function) * \param[in] port COM port * \param[in] buffer character buffer * \param[in] len buffer length * \return -1 if port not available * \return 0 on success */ int32_t PIOS_COM_SendBuffer(uint32_t com_id, const uint8_t *buffer, uint16_t len) { struct pios_com_dev * com_dev = PIOS_COM_find_dev(com_id); if (!PIOS_COM_validate(com_dev)) { /* Undefined COM port for this board (see pios_board.c) */ return -1; } PIOS_Assert(com_dev->has_tx); int32_t rc; do { rc = PIOS_COM_SendBufferNonBlocking(com_id, buffer, len); #if defined(PIOS_INCLUDE_FREERTOS) if (rc == -2) { /* Make sure the transmitter is running while we wait */ if (com_dev->driver->tx_start) { (com_dev->driver->tx_start)(com_dev->lower_id, fifoBuf_getUsed(&com_dev->tx)); } if (xSemaphoreTake(com_dev->tx_sem, portMAX_DELAY) != pdTRUE) { return -3; } } #endif } while (rc == -2); return len; }
/** * Forward data from UAVTalk out the serial port * \param[in] data Data buffer to send * \param[in] length Length of buffer * \return -1 on failure * \return number of bytes transmitted on success */ static int32_t send_data(uint8_t *data, int32_t length) { if( PIOS_COM_SendBufferNonBlocking(uavorelay_com_id, data, length) < 0) return -1; return length; }
/** * Sends a formatted string (-> printf) over given port * \param[in] port COM port * \param[in] *format zero-terminated format string - 128 characters supported maximum! * \param[in] ... optional arguments, * 128 characters supported maximum! * \return -2 if non-blocking mode activated: buffer is full * caller should retry until buffer is free again * \return 0 on success */ int32_t PIOS_COM_SendFormattedStringNonBlocking(uint8_t port, char *format, ...) { uint8_t buffer[128]; // TODO: tmp!!! Provide a streamed COM method later! va_list args; va_start(args, format); vsprintf((char *)buffer, format, args); return PIOS_COM_SendBufferNonBlocking(port, buffer, (uint16_t)strlen((char *)buffer)); }
/** * Sends a package over given port * (blocking function) * \param[in] port COM port * \param[in] buffer character buffer * \param[in] len buffer length * \return -1 if port not available * \return number of bytes transmitted on success */ int32_t PIOS_COM_SendBuffer(uintptr_t com_id, const uint8_t *buffer, uint16_t len) { struct pios_com_dev * com_dev = (struct pios_com_dev *)com_id; if (!PIOS_COM_validate(com_dev)) { /* Undefined COM port for this board (see pios_board.c) */ return -1; } PIOS_Assert(com_dev->has_tx); uint32_t max_frag_len = fifoBuf_getSize(&com_dev->tx); uint32_t bytes_to_send = len; while (bytes_to_send) { uint32_t frag_size; if (bytes_to_send > max_frag_len) { frag_size = max_frag_len; } else { frag_size = bytes_to_send; } int32_t rc = PIOS_COM_SendBufferNonBlocking(com_id, buffer, frag_size); if (rc >= 0) { bytes_to_send -= rc; buffer += rc; } else { switch (rc) { case -1: /* Device is invalid, this will never work */ return -1; case -2: /* Device is busy, wait for the underlying device to free some space and retry */ /* Make sure the transmitter is running while we wait */ if (com_dev->driver->tx_start) { (com_dev->driver->tx_start)(com_dev->lower_id, fifoBuf_getUsed(&com_dev->tx)); } #if defined(PIOS_INCLUDE_FREERTOS) if (xSemaphoreTake(com_dev->tx_sem, 5000) != pdTRUE) { return -3; } #endif continue; default: /* Unhandled return code */ return rc; } } } return len; }
/** * Transmit data buffer to the modem or USB port. * \param[in] data Data buffer to send * \param[in] length Length of buffer * \return -1 on failure * \return number of bytes transmitted on success */ static int32_t pack_data(uint8_t * data, int32_t length) { if( PIOS_COM_SendBufferNonBlocking(pios_com_overo_id, data, length) < 0) goto fail; overosync->sent_bytes += length; return length; fail: overosync->failed_objects++; return -1; }
/** * Transmit data buffer to the modem or USB port. * \param[in] data Data buffer to send * \param[in] length Length of buffer * \return 0 Success */ static int32_t transmitData(uint8_t * data, int32_t length) { uint32_t outputPort; // Determine input port (USB takes priority over telemetry port) #if defined(PIOS_INCLUDE_USB_HID) if (PIOS_USB_HID_CheckAvailable(0)) { outputPort = PIOS_COM_TELEM_USB; } else #endif /* PIOS_INCLUDE_USB_HID */ { outputPort = telemetryPort; } return PIOS_COM_SendBufferNonBlocking(outputPort, data, length); }
/* long SendBuffer(unsigned char *,unsigned int): sends a buffer content to picoc serial port */ void SystemSendBuffer(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) { if ((PIOS_COM_PICOC) && (Param[0]->Val->Pointer != NULL)) { uint8_t *buffer = Param[0]->Val->Pointer; uint16_t buf_len = Param[1]->Val->UnsignedInteger; ReturnValue->Val->LongInteger = 0; while (buf_len > 0) { int32_t rc = PIOS_COM_SendBufferNonBlocking(PIOS_COM_PICOC, buffer, buf_len); if (rc > 0) { buf_len -= rc; buffer += rc; ReturnValue->Val->LongInteger += rc; } else if (rc == 0) { PIOS_Thread_Sleep(1); } else { ReturnValue->Val->LongInteger = rc; return; } } } else { ReturnValue->Val->LongInteger = -1; } }
/** * Sends a string over given port * \param[in] port COM port * \param[in] str zero-terminated string * \return -1 if port not available * \return -2 buffer is full * caller should retry until buffer is free again * \return 0 on success */ int32_t PIOS_COM_SendStringNonBlocking(uint8_t port, char *str) { return PIOS_COM_SendBufferNonBlocking(port, (uint8_t *)str, (uint16_t)strlen(str)); }
/** * Sends a single character over given port * \param[in] port COM port * \param[in] c character * \return -1 if port not available * \return -2 buffer is full * caller should retry until buffer is free again * \return 0 on success */ int32_t PIOS_COM_SendCharNonBlocking(uint8_t port, char c) { return PIOS_COM_SendBufferNonBlocking(port, (uint8_t *)&c, 1); }
/** * Sends a string over given port * \param[in] port COM port * \param[in] str zero-terminated string * \return -1 if port not available * \return -2 buffer is full * caller should retry until buffer is free again * \return 0 on success */ int32_t PIOS_COM_SendStringNonBlocking(uint32_t com_id, const char *str) { return PIOS_COM_SendBufferNonBlocking(com_id, (uint8_t *)str, (uint16_t)strlen(str)); }
/** * Sends a single character over given port * \param[in] port COM port * \param[in] c character * \return -1 if port not available * \return -2 buffer is full * caller should retry until buffer is free again * \return 0 on success */ int32_t PIOS_COM_SendCharNonBlocking(uint32_t com_id, char c) { return PIOS_COM_SendBufferNonBlocking(com_id, (uint8_t *)&c, 1); }
/** * Processes queue events */ static void processObjEvent(UAVObjEvent * ev) { UAVObjMetadata metadata; // FlightTelemetryStatsData flightStats; // GCSTelemetryStatsData gcsTelemetryStatsData; // int32_t retries; // int32_t success; if (ev->obj == 0) { updateTelemetryStats(); } else if (ev->obj == GCSTelemetryStatsHandle()) { gcsTelemetryStatsUpdated(); } else if (ev->obj == TelemetrySettingsHandle()) { updateSettings(); } else { // Get object metadata UAVObjGetMetadata(ev->obj, &metadata); // If this is a metaobject then make necessary telemetry updates if (UAVObjIsMetaobject(ev->obj)) { updateObject(UAVObjGetLinkedObj(ev->obj)); // linked object will be the actual object the metadata are for } mavlink_message_t msg; mavlink_system.sysid = 20; mavlink_system.compid = MAV_COMP_ID_IMU; mavlink_system.type = MAV_TYPE_FIXED_WING; uint8_t mavClass = MAV_AUTOPILOT_OPENPILOT; AlarmsClear(SYSTEMALARMS_ALARM_TELEMETRY); // Setup type and object id fields uint32_t objId = UAVObjGetID(ev->obj); // uint64_t timeStamp = 0; switch(objId) { case BAROALTITUDE_OBJID: { BaroAltitudeGet(&baroAltitude); pressure.press_abs = baroAltitude.Pressure*10.0f; pressure.temperature = baroAltitude.Temperature*100.0f; mavlink_msg_scaled_pressure_encode(mavlink_system.sysid, mavlink_system.compid, &msg, &pressure); // Copy the message to the send buffer uint16_t len = mavlink_msg_to_send_buffer(mavlinkTxBuf, &msg); // Send buffer PIOS_COM_SendBufferNonBlocking(telemetryPort, mavlinkTxBuf, len); break; } case FLIGHTTELEMETRYSTATS_OBJID: { // FlightTelemetryStatsData flightTelemetryStats; FlightTelemetryStatsGet(&flightStats); // XXX this is a hack to make it think it got a confirmed // connection flightStats.Status = FLIGHTTELEMETRYSTATS_STATUS_CONNECTED; GCSTelemetryStatsGet(&gcsTelemetryStatsData); gcsTelemetryStatsData.Status = GCSTELEMETRYSTATS_STATUS_CONNECTED; // // // //mavlink_msg_heartbeat_send(MAVLINK_COMM_0,mavlink_system.type,mavClass); // mavlink_msg_heartbeat_pack(mavlink_system.sysid, mavlink_system.compid, &msg, mavlink_system.type, mavClass); // // Copy the message to the send buffer // uint16_t len = mavlink_msg_to_send_buffer(mavlinkTxBuf, &msg); // // Send buffer // PIOS_COM_SendBufferNonBlocking(telemetryPort, mavlinkTxBuf, len); break; } case SYSTEMSTATS_OBJID: { FlightStatusData flightStatus; FlightStatusGet(&flightStatus); uint8_t system_state = MAV_STATE_UNINIT; uint8_t base_mode = 0; uint8_t custom_mode = 0; // Set flight mode switch (flightStatus.FlightMode) { case FLIGHTSTATUS_FLIGHTMODE_MANUAL: base_mode |= MAV_MODE_FLAG_MANUAL_INPUT_ENABLED; break; case FLIGHTSTATUS_FLIGHTMODE_POSITIONHOLD: base_mode |= MAV_MODE_FLAG_GUIDED_ENABLED; break; case FLIGHTSTATUS_FLIGHTMODE_STABILIZED1: base_mode |= MAV_MODE_FLAG_STABILIZE_ENABLED; break; case FLIGHTSTATUS_FLIGHTMODE_STABILIZED2: base_mode |= MAV_MODE_FLAG_GUIDED_ENABLED; break; case FLIGHTSTATUS_FLIGHTMODE_STABILIZED3: base_mode |= MAV_MODE_FLAG_AUTO_ENABLED; break; case FLIGHTSTATUS_FLIGHTMODE_VELOCITYCONTROL: base_mode |= MAV_MODE_FLAG_GUIDED_ENABLED; break; default: base_mode |= MAV_MODE_FLAG_MANUAL_INPUT_ENABLED; break; } // Set arming state switch (flightStatus.Armed) { case FLIGHTSTATUS_ARMED_ARMING: case FLIGHTSTATUS_ARMED_ARMED: system_state = MAV_STATE_ACTIVE; base_mode |= MAV_MODE_FLAG_SAFETY_ARMED; break; case FLIGHTSTATUS_ARMED_DISARMED: system_state = MAV_STATE_STANDBY; base_mode &= !MAV_MODE_FLAG_SAFETY_ARMED; break; } // Set HIL if (hilEnabled) base_mode |= MAV_MODE_FLAG_HIL_ENABLED; mavlink_msg_heartbeat_send(MAVLINK_COMM_0, mavlink_system.type, mavClass, base_mode, custom_mode, system_state); SystemStatsData stats; SystemStatsGet(&stats); FlightBatteryStateData flightBatteryData; FlightBatteryStateGet(&flightBatteryData); FlightBatterySettingsData flightBatterySettings; FlightBatterySettingsGet(&flightBatterySettings); uint16_t batteryVoltage = (uint16_t)(flightBatteryData.Voltage*1000.0f); int16_t batteryCurrent = -1; // -1: Not present / not estimated int8_t batteryPercent = -1; // -1: Not present / not estimated // if (flightBatterySettings.SensorCalibrations[FLIGHTBATTERYSETTINGS_SENSORCALIBRATIONS_CURRENTFACTOR] == 0) // { // Factor is zero, sensor is not present // Estimate remaining capacity based on lipo curve batteryPercent = 100.0f*((flightBatteryData.Voltage - 9.6f)/(12.6f - 9.6f)); // } // else // { // // Use capacity and current // batteryPercent = 100.0f*((flightBatterySettings.Capacity - flightBatteryData.ConsumedEnergy) / flightBatterySettings.Capacity); // batteryCurrent = flightBatteryData.Current*100; // } mavlink_msg_sys_status_send(MAVLINK_COMM_0, 0xFF, 0xFF, 0xFF, ((uint16_t)stats.CPULoad*10), batteryVoltage, batteryCurrent, batteryPercent, 0, 0, 0, 0, 0, 0); // // Copy the message to the send buffer // uint16_t len = mavlink_msg_to_send_buffer(mavlinkTxBuf, &msg); // // Send buffer // PIOS_COM_SendBufferNonBlocking(telemetryPort, mavlinkTxBuf, len); break; } case ATTITUDERAW_OBJID: { AttitudeRawGet(&attitudeRaw); // Copy data attitude_raw.xacc = attitudeRaw.accels[ATTITUDERAW_ACCELS_X]; attitude_raw.yacc = attitudeRaw.accels[ATTITUDERAW_ACCELS_Y]; attitude_raw.zacc = attitudeRaw.accels[ATTITUDERAW_ACCELS_Z]; attitude_raw.xgyro = attitudeRaw.gyros[ATTITUDERAW_GYROS_X]; attitude_raw.ygyro = attitudeRaw.gyros[ATTITUDERAW_GYROS_Y]; attitude_raw.zgyro = attitudeRaw.gyros[ATTITUDERAW_GYROS_Z]; attitude_raw.xmag = attitudeRaw.magnetometers[ATTITUDERAW_MAGNETOMETERS_X]; attitude_raw.ymag = attitudeRaw.magnetometers[ATTITUDERAW_MAGNETOMETERS_Y]; attitude_raw.zmag = attitudeRaw.magnetometers[ATTITUDERAW_MAGNETOMETERS_Z]; mavlink_msg_raw_imu_encode(mavlink_system.sysid, mavlink_system.compid, &msg, &attitude_raw); // Copy the message to the send buffer uint16_t len = mavlink_msg_to_send_buffer(mavlinkTxBuf, &msg); // Send buffer PIOS_COM_SendBufferNonBlocking(telemetryPort, mavlinkTxBuf, len); if (hilEnabled) { mavlink_hil_controls_t controls; // Copy data controls.roll_ailerons = 0.1; controls.pitch_elevator = 0.1; controls.yaw_rudder = 0.0; controls.throttle = 0.8; mavlink_msg_hil_controls_encode(mavlink_system.sysid, mavlink_system.compid, &msg, &controls); // Copy the message to the send buffer len = mavlink_msg_to_send_buffer(mavlinkTxBuf, &msg); // Send buffer PIOS_COM_SendBufferNonBlocking(telemetryPort, mavlinkTxBuf, len); } break; } case ATTITUDEMATRIX_OBJID: { AttitudeMatrixGet(&attitudeMatrix); // Copy data attitude.roll = attitudeMatrix.Roll; attitude.pitch = attitudeMatrix.Pitch; attitude.yaw = attitudeMatrix.Yaw; attitude.rollspeed = attitudeMatrix.AngularRates[0]; attitude.pitchspeed = attitudeMatrix.AngularRates[1]; attitude.yawspeed = attitudeMatrix.AngularRates[2]; mavlink_msg_attitude_encode(mavlink_system.sysid, mavlink_system.compid, &msg, &attitude); // Copy the message to the send buffer uint16_t len = mavlink_msg_to_send_buffer(mavlinkTxBuf, &msg); // Send buffer PIOS_COM_SendBufferNonBlocking(telemetryPort, mavlinkTxBuf, len); break; } case GPSPOSITION_OBJID: { GPSPositionGet(&gpsPosition); gps_raw.time_usec = 0; gps_raw.lat = gpsPosition.Latitude*10; gps_raw.lon = gpsPosition.Longitude*10; gps_raw.alt = gpsPosition.Altitude*10; gps_raw.eph = gpsPosition.HDOP*100; gps_raw.epv = gpsPosition.VDOP*100; gps_raw.cog = gpsPosition.Heading*100; gps_raw.satellites_visible = gpsPosition.Satellites; gps_raw.fix_type = gpsPosition.Status; mavlink_msg_gps_raw_int_encode(mavlink_system.sysid, mavlink_system.compid, &msg, &gps_raw); // Copy the message to the send buffer uint16_t len = mavlink_msg_to_send_buffer(mavlinkTxBuf, &msg); // Send buffer PIOS_COM_SendBufferNonBlocking(telemetryPort, mavlinkTxBuf, len); // mavlink_msg_gps_raw_int_send(MAVLINK_COMM_0, gps_raw.usec, gps_raw.lat, gps_raw.lon, gps_raw.alt, gps_raw.eph, gps_raw.epv, gps_raw.hdg, gps_raw.satellites_visible, gps_raw.fix_type, 0); break; } case POSITIONACTUAL_OBJID: { PositionActualData pos; PositionActualGet(&pos); mavlink_local_position_ned_t m_pos; m_pos.time_boot_ms = 0; m_pos.x = pos.North; m_pos.y = pos.East; m_pos.z = pos.Down; m_pos.vx = 0.0f; m_pos.vy = 0.0f; m_pos.vz = 0.0f; mavlink_msg_local_position_ned_encode(mavlink_system.sysid, mavlink_system.compid, &msg, &m_pos); // Copy the message to the send buffer uint16_t len = mavlink_msg_to_send_buffer(mavlinkTxBuf, &msg); // Send buffer PIOS_COM_SendBufferNonBlocking(telemetryPort, mavlinkTxBuf, len); } break; case ACTUATORCOMMAND_OBJID: { mavlink_rc_channels_scaled_t rc; float val; ManualControlCommandRollGet(&val); rc.chan1_scaled = val*1000; ManualControlCommandPitchGet(&val); rc.chan2_scaled = val*1000; ManualControlCommandYawGet(&val); rc.chan3_scaled = val*1000; ManualControlCommandThrottleGet(&val); rc.chan4_scaled = val*1000; ActuatorCommandData act; ActuatorCommandGet(&act); rc.chan5_scaled = act.Channel[0]; rc.chan6_scaled = act.Channel[1]; rc.chan7_scaled = act.Channel[2]; rc.chan8_scaled = act.Channel[3]; ManualControlCommandData cmd; ManualControlCommandGet(&cmd); rc.rssi = ((uint8_t)(cmd.Connected == MANUALCONTROLCOMMAND_CONNECTED_TRUE))*255; rc.port = 0; mavlink_msg_rc_channels_scaled_encode(mavlink_system.sysid, mavlink_system.compid, &msg, &rc); // Copy the message to the send buffer uint16_t len = mavlink_msg_to_send_buffer(mavlinkTxBuf, &msg); // Send buffer PIOS_COM_SendBufferNonBlocking(PIOS_COM_TELEM_RF, mavlinkTxBuf, len); break; } case MANUALCONTROLCOMMAND_OBJID: { mavlink_rc_channels_scaled_t rc; float val; ManualControlCommandRollGet(&val); rc.chan1_scaled = val*1000; ManualControlCommandPitchGet(&val); rc.chan2_scaled = val*1000; ManualControlCommandYawGet(&val); rc.chan3_scaled = val*1000; ManualControlCommandThrottleGet(&val); rc.chan4_scaled = val*1000; rc.chan5_scaled = 0; rc.chan6_scaled = 0; rc.chan7_scaled = 0; rc.chan8_scaled = 0; ManualControlCommandData cmd; ManualControlCommandGet(&cmd); rc.rssi = ((uint8_t)(cmd.Connected == MANUALCONTROLCOMMAND_CONNECTED_TRUE))*255; rc.port = 0; mavlink_msg_rc_channels_scaled_encode(mavlink_system.sysid, mavlink_system.compid, &msg, &rc); // Copy the message to the send buffer uint16_t len = mavlink_msg_to_send_buffer(mavlinkTxBuf, &msg); // Send buffer PIOS_COM_SendBufferNonBlocking(PIOS_COM_TELEM_RF, mavlinkTxBuf, len); break; } default: { //printf("unknown object: %x\n",(unsigned int)objId); break; } } } }
/* * @brief Sends a MAVLink message over UDP */ void mavlink_missionlib_send_message(mavlink_message_t* msg) { uint16_t len = mavlink_msg_to_send_buffer(mavlinkTxBuf, msg); // Send buffer PIOS_COM_SendBufferNonBlocking(telemetryPort, mavlinkTxBuf, len); }
void trans_process(void) { // copy data from comm-port RX buffer to RF packet handler TX buffer, and from RF packet handler RX buffer to comm-port TX buffer // ******************** // decide which comm-port we are using (usart or usb) bool usb_comms = false; // TRUE if we are using the usb port for comms. uint32_t comm_port = PIOS_COM_SERIAL; // default to using the usart comm-port #if defined(PIOS_INCLUDE_USB) if (PIOS_USB_CheckAvailable(0)) { // USB comms is up, use the USB comm-port instead of the USART comm-port usb_comms = true; comm_port = PIOS_COM_TELEM_USB; } #endif // ******************** // check to see if the local communication port has changed (usart/usb) if (trans_previous_com_port == 0 && trans_previous_com_port != comm_port) { // the local communications port has changed .. remove any data in the buffers trans_temp_buffer2_wr = 0; } else if (usb_comms) { // we're using the USB for comms - keep the USART rx buffer empty uint8_t c; while (PIOS_COM_ReceiveBuffer(PIOS_COM_SERIAL, &c, 1, 0) > 0); } trans_previous_com_port = comm_port; // remember the current comm-port we are using // ******************** uint16_t connection_index = 0; // the RF connection we are using // ******************** // send the data received down the comm-port to the RF packet handler TX buffer if (saved_settings.mode == MODE_NORMAL || saved_settings.mode == MODE_STREAM_TX) { // free space size in the RF packet handler tx buffer uint16_t ph_num = ph_putData_free(connection_index); // set the USART RTS handshaking line if (!usb_comms) { if (ph_num < 32 || !ph_connected(connection_index)) SERIAL_RTS_CLEAR; // lower the USART RTS line - we don't have space in the buffer for anymore bytes else SERIAL_RTS_SET; // release the USART RTS line - we have space in the buffer for now bytes } else SERIAL_RTS_SET; // release the USART RTS line // limit number of bytes we will get to the size of the temp buffer if (ph_num > sizeof(trans_temp_buffer1)) ph_num = sizeof(trans_temp_buffer1); // copy data received down the comm-port into our temp buffer register uint16_t bytes_saved = 0; bytes_saved = PIOS_COM_ReceiveBuffer(comm_port, trans_temp_buffer1, ph_num, 0); // put the received comm-port data bytes into the RF packet handler TX buffer if (bytes_saved > 0) { trans_rx_timer = 0; ph_putData(connection_index, trans_temp_buffer1, bytes_saved); } } else { // empty the comm-ports rx buffer uint8_t c; while (PIOS_COM_ReceiveBuffer(comm_port, &c, 1, 0) > 0); } // ******************** // send the data received via the RF link out the comm-port if (saved_settings.mode == MODE_NORMAL || saved_settings.mode == MODE_STREAM_RX) { if (trans_temp_buffer2_wr < sizeof(trans_temp_buffer2)) { // get number of data bytes received via the RF link uint16_t ph_num = ph_getData_used(connection_index); // limit to how much space we have in the temp buffer if (ph_num > sizeof(trans_temp_buffer2) - trans_temp_buffer2_wr) ph_num = sizeof(trans_temp_buffer2) - trans_temp_buffer2_wr; if (ph_num > 0) { // fetch the data bytes received via the RF link and save into our temp buffer ph_num = ph_getData(connection_index, trans_temp_buffer2 + trans_temp_buffer2_wr, ph_num); trans_temp_buffer2_wr += ph_num; } } #if (defined(PIOS_COM_DEBUG) && (PIOS_COM_DEBUG == PIOS_COM_SERIAL)) if (!usb_comms) { // the serial-port is being used for debugging - don't send data down it trans_temp_buffer2_wr = 0; trans_tx_timer = 0; return; } #endif if (trans_temp_buffer2_wr > 0) { // we have data in our temp buffer that needs sending out the comm-port if (usb_comms || (!usb_comms && GPIO_IN(SERIAL_CTS_PIN))) { // we are OK to send the data out the comm-port // send the data out the comm-port int32_t res = PIOS_COM_SendBufferNonBlocking(comm_port, trans_temp_buffer2, trans_temp_buffer2_wr); // this one doesn't work properly with USB :( if (res >= 0) { // data was sent out the comm-port OK .. remove the sent data from the temp buffer trans_temp_buffer2_wr = 0; trans_tx_timer = 0; } else { // failed to send the data out the comm-port #if defined(TRANS_DEBUG) DEBUG_PRINTF("PIOS_COM_SendBuffer %d %d\r\n", trans_temp_buffer2_wr, res); #endif if (trans_tx_timer >= 5000) trans_temp_buffer2_wr = 0; // seems we can't send our data for at least the last 5 seconds - delete it } } } } else { // empty the buffer trans_temp_buffer2_wr = 0; trans_tx_timer = 0; } // ******************** }