bool labPort::openPort( const QString& portName ) { if( _closeTimer.isActive() ) { emit portError( "Port is still closing, please retry!" ); return false; } if( _port.isOpen() ) { _port.clear(); _port.close(); } _port.clearError(); _closing = false; _port.setPortName( portName ); _msgToSend.clear(); if( !_port.open( QSerialPort::ReadWrite ) ) { emit portError( "Unable to open port!" ); return false; } if( _initTimeoutMs > 0 ) { _initTimer.start( _initTimeoutMs ); } _initValueCounter = 0; getInitValues(); return true; }
void elFlowPort::decodeMsg( const QByteArray& msg ) { elFlowAnswer answer = _protocol.interpretAnswer( msg.toStdString() ); if( answer.type == elFlowAnswerType::elFlowError ) { emit portError( "Invalid answer!" ); } else if( answer.type == elFlowAnswerType::protocolError ) { emit portError( "Protocol error!" ); } else if( answer.type == elFlowAnswerType::elFlowStatus ) { if( answer.text.find( "no error" ) == std::string::npos ) { emit portError( QString::fromStdString( answer.text ) ); } } else if( answer.type == elFlowAnswerType::elFlowValue ) { showParameter( answer.paramNum, answer.value, answer.text ); } else { emit portError( "Warning: unhandled answer type!" ); } }
void eaps8000UsbUICharWindow::connectPortFunctions() { connect( &_port, SIGNAL( initSuccessful( QString ) ), this, SLOT( initFinished( QString ) ) ); connect( &_port, SIGNAL( portError( QString ) ), this, SLOT( portError( QString ) ) ); connect( &_port, SIGNAL( newVoltage( double ) ), this, SLOT( voltageUpdate( double ) ) ); connect( &_port, SIGNAL( newCurrent( double ) ), this, SLOT( currentUpdate( double ) ) ); connect( &_port, SIGNAL( newPower( double ) ), this, SLOT( powerUpdate( double ) ) ); }
void elFlowWindow::connectPortFunctions() { connect( &_port, SIGNAL( initSuccessful( QString ) ), this, SLOT( initFinished( QString ) ) ); connect( &_port, SIGNAL( portError( QString ) ), this, SLOT( portError( QString ) ) ); connect( &_port, SIGNAL( newFlow( double ) ), this, SLOT( flowUpdate( double ) ) ); connect( &_port, SIGNAL( newTemperature( double ) ), this, SLOT( temperatureUpdate( double ) ) ); connect( &_port, SIGNAL( newPressure( double ) ), this, SLOT( pressureUpdate( double ) ) ); }
void thermocouplePort::noAnswerReceived() { if( _msgToSend.size() == 0 || _expectedAnswer.size() == 0 ) { _msgToSend.clear(); _expectedAnswer.clear(); return; } if( _sendCounter < TRIES_SEND_MSG ) { _sendCounter++; sendMsg( _msgToSend[0].toStdString().c_str(), _msgToSend[0].size(), false ); _checkForAnswerTimer.start( _writingPauseMs*2 ); } else { if( !_closing ) { emit portError( "No answer after several requests!" ); } _sendCounter = 0; _msgToSend.erase( _msgToSend.begin() ); _expectedAnswer.erase( _expectedAnswer.begin() ); _answerPending = -1; if( _msgToSend.size() > 0 ) { _checkForAnswerTimer.start( _writingPauseMs*2 ); } } }
void labPort::timeToSendMsg() { if( _closing ) { return; } if( !_port.isOpen() ) { emit portError( "Port not open (writing failed)!" ); return; } if( _msgToSend.size() > 0 ) { LOG(INFO) << "write " << _msgToSend[0].size() << " bytes:"; for( int i = 0; i < _msgToSend[0].size(); i++ ) { char c = _msgToSend[0].at( i ); LOG(INFO) << "write (dec): " << static_cast<int>( reinterpret_cast<unsigned char&>( c ) ); } _port.write( _msgToSend[0].data(), _msgToSend[0].size() ); _msgToSend.erase( _msgToSend.begin() ); } if( _msgToSend.size() > 0 ) { _sendTimer.start( _writingPauseMs ); } else { _sendTimer.stop(); } }
/** * Read a number of bytes from the interface. * * @param data Pointer to the data byte array to write the bytes to * @param maxLength The maximum number of bytes to write **/ void SerialLink::readBytes() { if (!validateConnection()) return; if (mode_port) // ESC32 special data read mode return readEsc32Tele(); const qint64 maxLength = 2048; char data[maxLength]; qint64 numBytes = 0, rBytes = 0; dataMutex.lock(); while ((numBytes = port->bytesAvailable())) { /* Read as much data in buffer as possible without overflow */ rBytes = numBytes; if(maxLength < rBytes) rBytes = maxLength; if (port->read(data, rBytes) == -1) { // -1 result means error emit portError(); if (!m_linkLossExpected) emit communicationError(this->getName(), tr("Could not read data - link %1 is disconnected!").arg(this->getName())); return; } QByteArray b(data, rBytes); emit bytesReceived(this, b); bitsReceivedTotal += rBytes * 8; } dataMutex.unlock(); }
SerialLink::SerialLink(QString portname, int baudRate, bool hardwareFlowControl, bool parity, int dataBits, int stopBits) : port(0), portSettings(PortSettings()), portOpenMode(QIODevice::ReadWrite), portVendorId(0), portProductId(0), bitsSentTotal(0), bitsSentShortTerm(0), bitsSentCurrent(0), bitsSentMax(0), bitsReceivedTotal(0), bitsReceivedShortTerm(0), bitsReceivedCurrent(0), bitsReceivedMax(0), connectionStartTime(0), ports(new QVector<QString>()), waitingToReconnect(0), m_reconnectDelayMs(0), m_linkLossExpected(false), m_stopp(false), mode_port(false), countRetry(0), maxLength(0), rows(0), cols(0), firstRead(0) { portEnumerator = new QextSerialEnumerator(); portEnumerator->setUpNotifications(); QObject::connect(portEnumerator, SIGNAL(deviceDiscovered(const QextPortInfo &)), this, SLOT(deviceDiscovered(const QextPortInfo &))); QObject::connect(portEnumerator, SIGNAL(deviceRemoved(const QextPortInfo &)), this, SLOT(deviceRemoved(const QextPortInfo &))); getCurrentPorts(); // Setup settings this->porthandle = portname.trimmed(); if (!ports->contains(porthandle)) porthandle = ""; // Set unique ID and add link to the list of links this->id = getNextLinkId(); int par = parity ? (int)PAR_EVEN : (int)PAR_NONE; int fc = hardwareFlowControl ? (int)FLOW_HARDWARE : (int)FLOW_OFF; setBaudRate(baudRate); setFlowType(fc); setParityType(par); setDataBitsType(dataBits); setStopBitsType(stopBits); setTimeoutMillis(-1); // -1 means do not block on serial read/write. Do not use zero. setReconnectDelayMs(10); // default 10ms before reconnecting to M4, after detecting that COM port is back // Set the port name name = this->porthandle.length() ? this->porthandle : tr("Serial Link ") + QString::number(getId()); QObject::connect(this, SIGNAL(portError()), this, SLOT(disconnect())); }
void labPort::initTimeout() { _initTimer.stop(); if( _initValueCounter < _numInitValues ) { emit portError( "Initialization timeout!" ); } }
// add connection (canvas request) bool model::Network::connect(XPort *outport, XPort *inport) { // check outport if (!outport) { return portError(outport, "[Network::connect()] outport is null: "); } if (!inport) { return portError(inport, "[Network::connect()] inport is null."); } // obtain and check xmas inport and outport Output *xmas_outport = dynamic_cast<Output *>(outport->getPort()); Input *xmas_inport = dynamic_cast<Input *>(inport->getPort()); bool success = connect(xmas_outport, xmas_inport); emit outport->connectedChanged(); emit inport->connectedChanged(); return success; }
void labPort::checkInTimeCount() { if( _closing ) { return; } if( _inTimeValueCounter < _numInTimeValues ) { emit portError( "Value not read!" ); } _inTimeValueCounter = 0; }
// remove connection (canvas request) bool model::Network::disconnect(XPort *outport, XPort *inport) { // check outport if (!outport) { return portError(outport, "[Network::disconnect()] outport is null: "); } if (!inport) { return portError(inport, "[Network::disconnect()] inport is null."); } // check outport for being xmas outport to inport Output *xmas_outport = dynamic_cast<Output *>(outport->getPort()); Input *xmas_inport = dynamic_cast<Input *>(inport->getPort()); if (xmas_outport != nullptr && xmas_inport != nullptr) { if (disconnect(xmas_outport, xmas_inport)) { emit outport->connectedChanged(); emit inport->connectedChanged(); return true; } } emit outport->connectedChanged(); emit inport->connectedChanged(); return false; }
void SerialLink::deviceRemoved(const QextPortInfo &pi) { bool isValid = isPortHandleValid(); if (!isValid && pi.vendorID == SERIAL_AQUSB_VENDOR_ID && pi.productID == SERIAL_AQUSB_PRODUCT_ID) waitingToReconnect = MG::TIME::getGroundTimeNow(); if (!port || !port->isOpen() || isValid) return; emit portError(); if (!m_linkLossExpected) emit communicationError(this->getName(), tr("Link %1 unexpectedly disconnected!").arg(this->porthandle)); }
void SerialLink::writeBytes(const char* data, qint64 size) { if (!validateConnection()) return; int b = port->write(data, size); if (b > 0) { // Increase write counter bitsSentTotal += b * 8; } else if (b == -1) { emit portError(); if (!m_linkLossExpected) emit communicationError(this->getName(), tr("Could not send data - error on link %1").arg(this->porthandle)); } }
bool SerialLink::validateConnection() { bool ok = this->isConnected() && (!port->lastError() || (port->lastError() == E_READ_FAILED && SERIAL_IS_BUGGY_CP210x)); if (ok && (portOpenMode & QIODevice::ReadOnly) && !port->isReadable()) ok = false; if (ok && (portOpenMode & QIODevice::WriteOnly) && !port->isWritable()) ok = false; if(!ok) { emit portError(); if (!m_linkLossExpected) emit communicationError(this->getName(), tr("Link %1 unexpectedly disconnected!").arg(this->porthandle)); qWarning() << ok << port->lastError() << port->errorString(); return false; } return true; }
void elFlowPort::setValue( setValueType type, double value, bool autoAdjust ) { _autoAdjust = autoAdjust; if( type == setValueType::setTypeNone ) { return; } else if( type == setValueType::setTypeFlow ) { sendCmd( _protocol.getFlowValueSetCmd( value ) ); } else { emit portError( "Unknown value to set!" ); } }
void thermocouplePort::updateValues() { checkInTimeCount(); if( _expectedAnswer.size() != 0 ) { _expectedAnswer.clear(); if( !_closing ) { emit portError( "Answer missing!" ); } } if( _emitProbeTemperature || _emitAmbientTemperature ) { getTemperatures(); } }
bool eapsUta12Port::checkAnswerFormat( QByteArray msg, unsigned char* msgValues ) { if( msg.size() != MESSAGE_LENGTH ) { emit portError( "Invalid answer length!" ); return false; } for( int i = 0; i < MESSAGE_LENGTH; i++ ) { msgValues[i] = (unsigned char) msg.at( i ); } if( !checkMsgBytes( msgValues ) ) { LOG(INFO) << "eaps uta 12 check bytes wrong!"; return false; } return true; }
void eapsUta12Port::setValue( setValueType type, double value, bool autoAdjust ) { _setValueType = type; if( type == setValueType::setTypeNone ) { return; } _autoAdjust = autoAdjust; if( type == setValueType::setTypeVoltage ) { LOG(INFO) << "eaps uta 12 set voltage: " << value << " adjust: " << autoAdjust; _setVoltage = value; _lastVoltage = value; setVoltage( value ); } else if( type == setValueType::setTypeCurrent ) { LOG(INFO) << "eaps uta 12 set current: " << value << " adjust: " << autoAdjust; _setCurrent = value; _lastCurrent = value; setCurrent( value ); } else if( type == setValueType::setTypePowerByVoltage || type == setValueType::setTypePowerByCurrent ) { LOG(INFO) << "eaps uta 12 set power: " << value << " adjust: " << autoAdjust << " by voltage: " << (type == setValueType::setTypePowerByVoltage); _setPower = value; _lastPower = value; if( _lastVoltage > 0.0 && _lastCurrent > 0.0 ) { double resistance = _lastVoltage/_lastCurrent; if( type == setValueType::setTypePowerByVoltage ) { setVoltage( std::sqrt( value*resistance ) ); } else if( type == setValueType::setTypePowerByCurrent ) { setCurrent( std::sqrt( value/resistance ) ); } } else { emit portError( "Measure before setting power!" ); } } else if( type == setValueType::setTypeResistanceByVoltage || type == setValueType::setTypeResistanceByCurrent ) { LOG(INFO) << "eaps uta 12 set resistance: " << value << " adjust: " << autoAdjust << " by voltage: " << (type == setValueType::setTypeResistanceByVoltage); _setResistance = value; if( _lastVoltage > 0.0 && _lastCurrent > 0.0 && _lastResistance > 0.0 ) { if( type == setValueType::setTypeResistanceByVoltage ) { setVoltage( _lastVoltage* std::sqrt( _setResistance/_lastResistance ) ); } else if( type == setValueType::setTypeResistanceByCurrent ) { setCurrent( _lastCurrent* std::sqrt( _setResistance/_lastResistance ) ); } } else { emit portError( "Measure before setting power!" ); } } }
void labPort::signalError( const QSerialPort::SerialPortError& error ) { switch( error ) { case 0: return; // no error case 1: emit portError( "Device not found!" ); break; case 2: emit portError( "No Permission!" ); break; case 3: emit portError( "Error when opening an already opened device!" ); break; case 4: emit portError( "Parity error!" ); break; case 5: emit portError( "Framing error!" ); break; case 6: emit portError( "Break condition error!" ); break; case 7: emit portError( "Writing error!" ); break; case 8: emit portError( "Reading error!" ); break; case 9: emit portError( "A resource is no longer available!" ); break; case 10: emit portError( "Unsupported operation!" ); break; case 11: emit portError( "Unknown error!" ); break; case 12: emit portError( "Timeout!" ); break; case 13: emit portError( "Device not open!" ); break; default: emit portError( "Unspecified error!" ); break; } }
ui->CB_int2Atten->addItems(SL_ext_atten); SL_ext_atten.clear(); SL_ext_atten << "0.0" << "3.0" << "6.0" << "9.0"; ui->CB_int1Atten->addItems(SL_ext_atten); QRegExp fRegex ("^[1]{0,1}[0-9]{4,4}[.]{1,1}[0-9]{0,6}$"); QRegExpValidator *fValidator = new QRegExpValidator(fRegex, this); ui->LE_freq->setValidator(fValidator); connect(ui->PB_start,SIGNAL(clicked()),this,SLOT(portStart())); connect(ui->PB_stop,SIGNAL(clicked()),this,SLOT(protStop())); connect(ui->PB_refresh,SIGNAL(clicked()),this,SLOT(protRefresh())); connect(ui->PB_freq, SIGNAL(clicked()), this, SLOT(send_freq())); connect(protocol_inst, SIGNAL(portInfo(QString)), this, SLOT(setInfo(QString))); connect(protocol_inst, SIGNAL(portError(QString)), this, SLOT(setError(QString))); } Generator::~Generator() { delete ui; } void Generator::portStart(void) { if(protocol_inst->start(ui->CB_comList->currentText(),ui->CB_baudList->currentText().toUInt())) { setInfo("Device started."); } else {
void thermocouplePort::receivedMsg( QByteArray msg ) { if( msg.isNull() ) { return; } msg.replace( 0x0A, "" ).replace( 0x0B, "" ).replace( 0x0D, "" ) .replace( 0x11, "" ).replace( 0x13, "" ) .replace( 0x3C, "" ).replace( 0x3E, "" ); // < and > - dont know why this is sent ... if( msg.isEmpty() ) { return; } if( _expectedAnswer.size() == 0 ) { if( _sendCounter != 0 ) { return; } emit portError( "Unexpected answer!" ); return; } _answerPending = 0; if( _expectedAnswer[0] == CMD_ID ) { if( _idStringSet ) { bool conversionSuccessful = false; int version = msg.toInt( &conversionSuccessful ); if( conversionSuccessful && version > 90615 ) { _probeTemperatureOnly = false; } _initValueCounter++; emit initSuccessful( _idString ); } else { _idStringSet = true; _idString = msg; _initValueCounter++; } } else if( _expectedAnswer[0] == CMD_PROBE_TEMPERATURE ) { bool conversionSuccessful = false; double probeTemperatureCelsius = msg.toDouble( &conversionSuccessful ); if( conversionSuccessful ) { if( _emitProbeTemperature ) { if( probeTemperatureCelsius > MAX_TEMPERATURE || probeTemperatureCelsius < -MAX_TEMPERATURE ) { emit portError( "Out of range!" ); } else { emit newProbeTemperature( probeTemperatureCelsius ); } } } else { emit portError( "Could not get temperature from answer!" ); } } else if( _expectedAnswer[0] == CMD_BOTH_TEMPERATURES ) { bool conversion1Successful = false; bool conversion2Successful = false; double probeTemperatureFahrenheit = msg.left( msg.indexOf( "," ) ) .toDouble( &conversion1Successful ); double ambientTemperatureFahrenheit = msg.mid( msg.indexOf( "," ) + 1 ) .toDouble( &conversion2Successful ); if( conversion1Successful && conversion2Successful ) { int tProbeCelsius = fahrenheitToCelsius( probeTemperatureFahrenheit ); int tAmbientCelsius = fahrenheitToCelsius( ambientTemperatureFahrenheit ); if( _emitProbeTemperature ) { if( tProbeCelsius > MAX_TEMPERATURE || tProbeCelsius < -MAX_TEMPERATURE ) { emit portError( "Out of range!" ); } else { emit newProbeTemperature( tProbeCelsius ); } } if( _emitAmbientTemperature ) { if( tAmbientCelsius > MAX_TEMPERATURE || tAmbientCelsius < -MAX_TEMPERATURE ) { emit portError( "Out of range!" ); } else { emit newAmbientTemperature( tAmbientCelsius ); } } } else { emit portError( "Could not get temperatures from answer!" ); } } else if( _expectedAnswer[0] == CMD_OTHER ) { } else { emit portError( "Undefined answer!" ); } _expectedAnswer.erase( _expectedAnswer.begin() ); }
void eapsUta12Port::receivedMsg( QByteArray msg ) { unsigned char msgValues[MESSAGE_LENGTH]; if( !checkAnswerFormat( msg, msgValues ) ) { return; } switch( msgValues[3] ) { case 0x1F: { answerSetVoltage(); break; } case 0x2F: { answerGetVoltage( msgValues ); break; } case 0x3F: { answerSetCurrent(); break; } case 0x4F: { answerGetCurrent( msgValues ); break; } case 0x5F: { answerSetStatus(); break; } case 0x6F: { answerGetStatus( msgValues ); break; } case 0x7F: { answerSetIdString(); break; } case 0x8F: { answerGetIdString( msg ); break; } case 0x9F: { answerEcho( msgValues ); break; } case 0xAF: { answerError( msgValues ); break; } case 0xEF: { answerSetIdn(); break; } case 0xFF: { answerGetIdn( msgValues ); break; } case 0x48: { answerGetMaxValues( msgValues ); break; } case 0xC8: { answerSetUserText(); break; } case 0xD8: { answerGetUserText( msg ); break; } default: emit portError( "Unknown answer!" ); break; } }
void eapsUta12Port::answerError( unsigned char* msgValues ) { emit portError( "Communication error! (" + QString::number( msgValues[5] ) + ")" ); }