static void hottSendTelemetryData(void) {
if (!hottIsSending) {
hottIsSending = true;
// FIXME temorary workaround for HoTT not working on Hardware serial ports due to hardware/softserial serial port initialisation differences
//serialSetMode(hottPort, MODE_TX);
closeSerialPort(hottPort);
hottPort = openSerialPort(portConfig->identifier, FUNCTION_TELEMETRY_HOTT, NULL, HOTT_BAUDRATE, MODE_TX, SERIAL_NOT_INVERTED);
hottMsgCrc = 0;
return;
}
if (hottMsgRemainingBytesToSendCount == 0) {
hottMsg = NULL;
hottIsSending = false;
// FIXME temorary workaround for HoTT not working on Hardware serial ports due to hardware/softserial serial port initialisation differences
//serialSetMode(hottPort, MODE_RX);
closeSerialPort(hottPort);
hottPort = openSerialPort(portConfig->identifier, FUNCTION_TELEMETRY_HOTT, NULL, HOTT_BAUDRATE, MODE_RX, SERIAL_NOT_INVERTED);
flushHottRxBuffer();
return;
}
--hottMsgRemainingBytesToSendCount;
if(hottMsgRemainingBytesToSendCount == 0) {
hottSerialWrite(hottMsgCrc++);
return;
}
hottMsgCrc += *hottMsg;
hottSerialWrite(*hottMsg++);
}
void ConsoleWindow::openSerialPort(const QString portName)
{
if (portName.isEmpty()) return;
settings->selectPortName(portName);
if (serial->isOpen()) {
if (serial->portName().compare(portName) != 0) {
closeSerialPort();
openSerialPort();
}
} else {
openSerialPort();
}
}
void TMainForm::openMyCom()
{
m_fd = openSerialPort();
if (m_fd < 0) {
QMessageBox::warning(this, tr("Error"), tr("Fail to open serial port!"));
return ;
}
::write(m_fd,"AT+CNMI=2,1,0,0,0\r",strlen("AT+CNMI=2,1,0,0,0\r"));
sleep(1);
speedComboBox->setEnabled(false);
dataBitsComboBox->setEnabled(false);
parityComboBox->setEnabled(false);
stopBitsComboBox->setEnabled(false);
portNameComboBox->setEnabled(false);
ok_Btn->setEnabled(false);
call_Btn->setEnabled(true);
mess_Btn->setEnabled(true);
allmess_Btn->setEnabled(true);
m_notifier = new QSocketNotifier(m_fd, QSocketNotifier::Read, this);
connect (m_notifier, SIGNAL(activated(int)), this, SLOT(remoteDataIncoming()));
}
//Move X - Move X axis motor variable steps
//Input: Number of Steps
//Output: 0 for failure, 1 for success
// 2010/06/30: Added backlash compensation when stepper turns around -ADE
int stepperDriver::MoveX(int steps)
{
int temp; //Added to handle backlash compensation when stepper changes direciton
steps = -steps; //Axis is inverted with hardware setup
temp = steps;
//Check if stepper is changing directions. If so compensate for backlash in motors.
if ((iLastMoveX * steps)<0)
{
if (steps < 0)
temp = steps - BACKLASH_COMPENSATION_X;
else
temp = steps + BACKLASH_COMPENSATION_X;
}
iLastMoveX = steps;
//Build command string
char command[25] = "F,C,I1M";
char buf[10];
itoa(temp,buf,10); //convert steps to buffer string
strcat(command,buf); //append amount of steps to string
strcat(command,",R"); //append run component of command
//Output to Port
openSerialPort();
PortSendCommands(command);
WaitForVXM();
closeSerialPort();
yCo+=steps;
return 0;
}
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;
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
monitor = new PortMonitor(this);
//przyciski
connect(ui->pushButtonConnect,SIGNAL(clicked()),monitor,SLOT(openSerialPort()));
connect(ui->pushButtonPreferences,SIGNAL(clicked()),monitor->settings,SLOT(show()));
connect(ui->pushButtonDisconnect,SIGNAL(clicked()),monitor,SLOT(closeSerialPort()));
//sygnały wysyłane, przez monitor portu
connect(monitor,SIGNAL(newDataArrived(QByteArray)),this,SLOT(showData(QByteArray)));
connect(monitor,SIGNAL(newLeftVerticaTriggerValue(int)),ui->verticalSliderLeftVerticalTrigger,SLOT(setValue(int)));
connect(monitor,SIGNAL(newLeftHorizontalTriggerValue(int)),ui->horizontalSliderLeftHorizontalTrigger,SLOT(setValue(int)));
connect(monitor,SIGNAL(newRightVerticaTriggerValue(int)),ui->verticalSliderRightVerticalTrigger,SLOT(setValue(int)));
connect(monitor,SIGNAL(newRightHorizontalTriggerValue(int)),ui->horizontalSliderRightHorizontalTrigger,SLOT(setValue(int)));
connect(monitor,SIGNAL(newLeftTriggerString(QString)),ui->labelLeftTrigger,SLOT(setText(QString)));
connect(monitor,SIGNAL(newRightTriggerString(QString)),ui->labelRightTrigger,SLOT(setText(QString)));
//dostosowanie kontrolek
ui->verticalSliderLeftVerticalTrigger->setMinimum(-100);
ui->verticalSliderLeftVerticalTrigger->setMaximum(100);
ui->verticalSliderRightVerticalTrigger->setMinimum(-100);
ui->verticalSliderRightVerticalTrigger->setMaximum(100);
ui->horizontalSliderLeftHorizontalTrigger->setMinimum(-100);
ui->horizontalSliderLeftHorizontalTrigger->setMaximum(100);
ui->horizontalSliderRightHorizontalTrigger->setMinimum(-100);
ui->horizontalSliderRightHorizontalTrigger->setMaximum(100);
}
/**
* @brief Widget::Widget
* @param parent
*/
Widget::Widget(QWidget *parent)
: QWidget(parent)
,serialPort(new QSerialPort(this))
,serialPortStatusBar(new QStatusBar())
,serialPortLabel(new QLabel(tr("Serial port:")))
,serialPortComboBox(new QComboBox())
,serialPortBaudRateLabel(new QLabel(tr("Baud Rate:")))
,serialPortBaudRateComboBox(new QComboBox())
,serialPortDataBitsLabel(new QLabel(tr("Data Bits:")))
,serialPortDataBisComboBox(new QComboBox())
,serialPortParityLabel(new QLabel(tr("Parity:")))
,serialPortParityComboBox(new QComboBox())
,serialPortStopBitsLabel(new QLabel(tr("Stop Bits:")))
,serialPortStopBitsComboBox(new QComboBox())
,serialPortFlowControlLabel(new QLabel(tr("Flow Control:")))
,serialPortFlowControlComboBox(new QComboBox())
,closeOrOpenSerialPortBtn(new QPushButton(tr("Open Serial Port")))
,senderBtn(new QPushButton(tr("Send")))
,serialPortTextBrowser(new QTextBrowser())
,serialPortLineEdit(new QLineEdit())
{
setWindowIcon(QIcon(":/new/Icon/ICON"));
setWindowTitle(tr("SerialCOM Assistant"));
setUI();
openSerialPort();
activeSignalAndSlot();
}
gpsEnablePassthroughResult_e gpsEnablePassthrough(void)
{
if (gpsData.state != GPS_RECEIVING_DATA)
return GPS_PASSTHROUGH_NO_GPS;
serialPort_t *gpsPassthroughPort = findOpenSerialPort(FUNCTION_GPS_PASSTHROUGH);
if (gpsPassthroughPort) {
waitForSerialPortToFinishTransmitting(gpsPassthroughPort);
serialSetBaudRate(gpsPassthroughPort, serialConfig->gps_passthrough_baudrate);
} else {
gpsPassthroughPort = openSerialPort(FUNCTION_GPS_PASSTHROUGH, NULL, serialConfig->gps_passthrough_baudrate, MODE_RXTX, SERIAL_NOT_INVERTED);
if (!gpsPassthroughPort) {
return GPS_PASSTHROUGH_NO_SERIAL_PORT;
}
}
LED0_OFF;
LED1_OFF;
while(1) {
if (serialTotalBytesWaiting(gpsPort)) {
LED0_ON;
serialWrite(gpsPassthroughPort, serialRead(gpsPort));
LED0_OFF;
}
if (serialTotalBytesWaiting(gpsPassthroughPort)) {
LED1_ON;
serialWrite(gpsPort, serialRead(gpsPassthroughPort));
LED1_OFF;
}
}
return GPS_PASSTHROUGH_ENABLED;
}
MainWindow::MainWindow()
{
//QMainWindow(parent),
messages = new char;
//free(messages),messages = NULL;
//messages[0] = '1';
first = new bool;
first = true;
serial = new QSerialPort(this);
settings = new SettingsDialog;
// Création et disposition des widgets de la fenêtre
etatServeur = new QLabel;
boutonQuitter = new QPushButton(tr("Quitter"));
buttonUartConnect = new QPushButton(tr("Open Uart"));
buttonUartDisconnect = new QPushButton(tr("Close Uart"));
buttonSettings = new QPushButton(tr("Uart Settings"));
buttona = new QPushButton(tr("1"));
connect(buttona, SIGNAL(clicked()), this, SLOT(open1()));
connect(buttonUartConnect, SIGNAL(clicked()), this, SLOT(openSerialPort()));
connect(buttonUartDisconnect, SIGNAL(clicked()), this, SLOT(closeSerialPort()));
connect(boutonQuitter, SIGNAL(clicked()), qApp, SLOT(quit()));
connect(buttonSettings, SIGNAL(clicked()), settings, SLOT(show()));
connect(serial, SIGNAL(readyRead()), this, SLOT(readData()));
QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(etatServeur);
layout->addWidget(buttona);
layout->addWidget(buttonSettings);
layout->addWidget(buttonUartConnect);
layout->addWidget(buttonUartDisconnect);
layout->addWidget(boutonQuitter);
setLayout(layout);
setWindowTitle(tr("ZeroChat - Serveur"));
// Gestion du serveur
serveur = new QTcpServer(this);
if (!serveur->listen(QHostAddress::Any, 50885)) // Démarrage du serveur sur toutes les IP disponibles et sur le port 50585
{
// Si le serveur n'a pas été démarré correctement
etatServeur->setText(tr("Le serveur n'a pas pu être démarré. Raison :<br />") + serveur->errorString());
}
else
{
// Si le serveur a été démarré correctement
etatServeur->setText(tr("Le serveur a été démarré sur le port <strong>") + QString::number(serveur->serverPort()) + tr("</strong>.<br />Des clients peuvent maintenant se connecter."));
connect(serveur, SIGNAL(newConnection()), this, SLOT(nouvelleConnexion()));
}
tailleMessage = 0;
}
void cliInit(serialConfig_t *serialConfig)
{
cliPort = findOpenSerialPort(FUNCTION_CLI);
if (!cliPort) {
cliPort = openSerialPort(FUNCTION_CLI, NULL, serialConfig->cli_baudrate, MODE_RXTX, SERIAL_NOT_INVERTED);
}
}
void MainWindow::initSerialPort(){
Terminal *serial1 = new Terminal;
serial1->terminalInitialisation();
QObject::connect(SerialConnectButton, SIGNAL(clicked()), serial1, SLOT(on_bouton_serial_connexion_clicked()));
QObject::connect(serial1,SIGNAL(openSerialPortTerminal()),this,SLOT(openSerialPort()));
QObject::connect(serial1,SIGNAL(closeSerialPortTerminal()),this,SLOT(closeSerialPort()));
}
//Move Up - Move Motor 2 +1000 steps
//Input: None
//Output: 0 for failure, 1 for success
int stepperDriver::MoveUp()
{
int temp = openSerialPort(); //add error code if needed
temp = PortSendCommands("F,C,I2M1000,R"); //Move Motor 2 +5 steps
temp = WaitForVXM(); //Wait for VMX program to finish
temp = closeSerialPort();
yCo+=1000;
return temp;
}
int main(int argc, const char * argv[]) {
int port;
port = openSerialPort("/dev/tty....");
initConnection(port);
initListener();
return 0;
}
void MainWindow::initActionsConnections()
{
connect(ui->actionConnect, SIGNAL(triggered()), this, SLOT(openSerialPort()));
connect(ui->actionDisconnect, SIGNAL(triggered()), this, SLOT(closeSerialPort()));
connect(ui->actionQuit, SIGNAL(triggered()), this, SLOT(close()));
connect(ui->actionConfigure, SIGNAL(triggered()), settings, SLOT(show()));
connect(ui->actionClear, SIGNAL(triggered()), console, SLOT(clear()));
connect(ui->actionAbout, SIGNAL(triggered()), this, SLOT(about()));
connect(ui->actionAboutQt, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
}
void HexySerial::onSettingsChanged()
{
{
QSignalBlocker(this);
closeSerialPort();
openSerialPort();
settings->hide();
//version();
writeData("\n");
}
emit settingsChanged();
}
void MainWindow::on_pushButtonConnect_clicked()
{
if (serialPort->isOpen())
{
closeSerialPort();
ui->pushButtonConnect->setText(QStringLiteral("Connect"));
}
else if(openSerialPort())
{
ui->pushButtonConnect->setText(QStringLiteral("Disconnect"));
}
}
void CheckOption::printInfo()
{
update();
emit shouldupdate();
seriport_print=openSerialPort("/dev/ttySAC2");
if (seriport_print < 0) {
warning->setText("Fail to open serial port!");
warning->move(200,200);
warning->show();
}
QString Reallyserinumber;
if(weatherSaved)//if saved;
Reallyserinumber=serialNumber;
else
Reallyserinumber="";
inputUserName=*MyInputUsername;
char *print;
print=(char *)malloc(500*sizeof(char));
int printlength;
int i;
strcpy(print,"\nMagiCare RTR-FS100 打印报告");
strcat(print,"\n");
strcat(print,"\n");
strcat(print,"\n签名：");
strcat(print,"\n检测结果(a.u.)：");
strcat(print,data.toUtf8().data());
strcat(print,"\n检测项目：");
strcat(print,ui->comboBox->currentText().toUtf8().data());
strcat(print,"\n年龄：");
strcat(print,ui->lineEdit_Age->text().toUtf8().data());
strcat(print,"\n性别：");
strcat(print,ui->comboBox_gender->currentText().toUtf8().data());
strcat(print,"\n姓名：");
strcat(print,ui->lineEdit_Name->text().toUtf8().data());
strcat(print,"\n检测编号：");
strcat(print,ui->lineEdit_ID->text().toUtf8().data());
strcat(print,"\n批次号：");
strcat(print,ui->lineEdit_Bach->text().toUtf8().data());//no need to show Serialnumber
strcat(print,"\n时间：");
strcat(print,CurrentDate.time().toString().toUtf8().data());
strcat(print,"\n日期：");
strcat(print,YearDate.toUtf8().data());
strcat(print,"\n");
strcat(print,"\n");
strcat(print,"\n");
strcat(print,"\n");
printlength=strlen(print);
miniPrintWriteUnicode(seriport_print,print);
}
void configureFrSkyTelemetryPort(void)
{
if (!portConfig) {
return;
}
frskyPort = openSerialPort(portConfig->identifier, FUNCTION_TELEMETRY_FRSKY, NULL, FRSKY_BAUDRATE, FRSKY_INITIAL_PORT_MODE, telemetryConfig->telemetry_inversion ? SERIAL_INVERTED : SERIAL_NOT_INVERTED);
if (!frskyPort) {
return;
}
frskyTelemetryEnabled = true;
}
int main()
{
int fd=openSerialPort();
for(int i=0; i<100; i++) testLoopback(fd,i);
close(fd);
return 0;
}
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;
}
}
}
}
bool sbusInit(rxConfig_t *rxConfig, rxRuntimeConfig_t *rxRuntimeConfig, rcReadRawDataPtr *callback)
{
int b;
sBusPort = openSerialPort(FUNCTION_SERIAL_RX, sbusDataReceive, SBUS_BAUDRATE, (portMode_t)(MODE_RX | MODE_SBUS), SERIAL_INVERTED);
for (b = 0; b < SBUS_MAX_CHANNEL; b++)
sbusChannelData[b] = (1.6f * rxConfig->midrc) - 1408;
if (callback)
*callback = sbusReadRawRC;
rxRuntimeConfig->channelCount = SBUS_MAX_CHANNEL;
return sBusPort != NULL;
}
void configureLtmTelemetryPort(void)
{
if (!portConfig) {
return;
}
baudRate_e baudRateIndex = portConfig->telemetry_baudrateIndex;
if (baudRateIndex == BAUD_AUTO) {
baudRateIndex = BAUD_19200;
}
ltmPort = openSerialPort(portConfig->identifier, FUNCTION_TELEMETRY_LTM, NULL, baudRates[baudRateIndex], TELEMETRY_LTM_INITIAL_PORT_MODE, SERIAL_NOT_INVERTED);
if (!ltmPort)
return;
ltmEnabled = true;
}
void configureHoTTTelemetryPort(void)
{
if (!portConfig) {
return;
}
hottPort = openSerialPort(portConfig->identifier, FUNCTION_TELEMETRY_HOTT, NULL, HOTT_BAUDRATE, HOTT_INITIAL_PORT_MODE, SERIAL_NOT_INVERTED);
if (!hottPort) {
return;
}
hottTelemetryEnabled = true;
}
void EasyTransferPi::begin(uint8_t *ptr, uint8_t lenght, qint32 baudRate)
{
address=ptr;
size=lenght;
isDataRecieved=FALSE;
baud=baudRate;
rx_array_inx=0;
rx_buffer=(uint8_t*)malloc(size+1);
portManager=new SerialPortManager();
connect(portManager, SIGNAL(eventDataRecieved(QByteArray&)), this, SLOT(onDataIncoming(QByteArray&)));
connect(portManager,SIGNAL(eventConnectionEstablished()),this,SLOT(onConnected()));
openSerialPort();
}
int main(int argc, char **argv)
{
char deviceFilePath[MAXPATHLEN];
int fileDescriptor;
int c;
int bCont; // flag for continuous operation
struct sigaction act;
opterr = 0;
while ((c=getopt(argc, argv, "cd:h")) != -1) {
switch (c) {
case 'c': bCont = 1; break;
case 'd': strcpy(deviceFilePath, optarg); break;
case 'h': printHelp(); return 1;
case '?': if (optopt=='d')
fprintf(stderr, "Option -%c requires an argument.\n", optopt);
else if (isprint (optopt))
fprintf(stderr, "Unknown option '-%c'.\n", optopt);
else
fprintf(stderr, "Unknown option character '\\x%x'.\n", optopt);
return 1;
default: abort();
}
}
act.sa_handler = intHandler;
sigaction(SIGINT, &act, NULL); // catch Ctrl-C
//printf ("dev: %s\n", deviceFilePath);
if (!deviceFilePath[0])
{
printf("No serial device found. Did you specify the '-d /dev/device' option?\n");
return EX_UNAVAILABLE;
}
fileDescriptor = openSerialPort(deviceFilePath);
if (fileDescriptor == -1)
{
return EX_IOERR;
}
if (!(readSerialData(fileDescriptor, bCont))) {
printf("Could not read data.\n");
}
closeSerialPort(fileDescriptor);
// printf("Modem port closed.\n");
return EX_OK;
}
void BuzzerControl::serialGo(bool state) {
if (state) {
QString serialPort = serialPortList->currentText();
start->setText("Disconnect");
emit openSerialPort(serialPort);
serialPortList->setEnabled(false);
refresh->setEnabled(false);
} else {
start->setText("Connect");
emit closeSerialPort();
serialPortList->setEnabled(true);
refresh->setEnabled(true);
}
}
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);
}
/***********************************************************************************************************************
int main(int argc, char **argv)
program entry point, expects the serial port name as a command line argument
***********************************************************************************************************************/
int main(int argc, char **argv)
{
// store the port parameters
char* portName;
int serialPort;
// parse the command line arguments
if(argc != 2)
{
printf("USAGE: %s <port_name> \n", argv[0]);
return 0;
}
portName = argv[1];
// attempt to open the serial port
serialPort = openSerialPort(portName);
// check to see if we connected successfully
if(serialPort == -1)
{
printf("unable to open serial port %s \n", portName);
return(0);
}
printf("%s opened successfully!\n", portName);
// continuously check for received serial data
int numBytes = 0;
while(1)
{
// check for received serial data
numBytes = numBytes + pollSerialPort(serialPort);
// send a packet
sendPacket(serialPort, 0x01, 0x02, 0x03);
// stop listening for data once we receive 100 bytes
if(numBytes >= 100)
{
break;
}
// sleep for 20ms (20*1000 microseconds)
usleep(20*1000);
}
// close the serial port
closeSerialPort(serialPort);
}
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;
}
