void depthProbe::button() { readSerial(true); sendSerial("$\r"); QString popochas = readSerial(false); QMessageBox(QMessageBox::Critical,"Interaction needed",popochas,QMessageBox::Ok).exec(); }
void stk500service::setMode(char mode) { // Execute the 'm' command and switch modes char command[2] = {'m', mode}; if (!writeVerifyRetry(command, sizeof(command))) { throw ProtocolException("Failed to switch SPM mode: No response"); } // Read the address part; send 4 bytes to push it out quint32 address = 0; _handler->getPort()->write("\0\0\0\0" , 4); int recLen = readSerial((char*) &address, sizeof(address)); if (recLen != (int) sizeof(address)) { // Could not get a full response for the switch mode command QString errorMessage = QString("Failed to switch SPM mode: Response too short\n" "Received: %1 bytes").arg(recLen+2); throw ProtocolException(errorMessage); } // Verify address is valid QString addrText = QString("0x%0").arg(QString::number(address*2, 16).toUpper()); if (address == 0) { throw ProtocolException("Failed to switch SPM mode: Function not found. " "Could not locate the firmware section " "used to write to flash memory.\n\n" "The firmware currently on the device does not support " "service updates. Use an ISP programmer to upload the " "right firmware to the device."); } // Debug: print address information qDebug() << "[Service] mode =" << mode << "; spm_addr =" << addrText; }
static DWORD WINAPI pipeDataFrSe(LPVOID pVClient) { char *buf = malloc(PIPE_BUF_SIZE); ClientElem_t *pClient = (ClientElem_t *)pVClient; while (pClient->running) { int nBytesRead; if (!readSerial(pClient, &buf[0], PIPE_BUF_SIZE, &nBytesRead, 1000)) { DBG_PRINT("ERROR uartread pipe %ld, hdl %ld", GetLastError(), pClient->serialHdl); pClient->running = 0; } else if (nBytesRead > 0) { int wrIx = 0; int wrLen = 0; DBG_PRINT("SE-> put %i bytes in buf", nBytesRead); while (nBytesRead > 0 && wrLen >= 0 && pClient->running) { wrLen = rbWrite(&pClient->rbSeSo, &buf[wrIx], nBytesRead, 1000); nBytesRead -= wrLen; wrIx += wrLen; } if (wrLen < 0) { DBG_PRINT("ERROR uartwrbuf pipe"); pClient->running = 0; } } } free(buf); DBG_PRINT("SE->X"); return 0; }
void Everything::run() { updateSensors(); //call each st::Sensor object to refresh data #ifndef DISABLE_SMARTTHINGS SmartThing.run(); //call the ST Shield Library to receive any data from the ST Hub updateNetworkState(); //call the ST Shield Library to update the current zigbee network status between the Shield and Hub #endif #if defined(ENABLE_SERIAL) readSerial(); //read data from the Arduino IDE Serial Monitor window (useful for debugging sometimes) #endif sendStrings(); //send any pending updates to ST Cloud #ifndef DISABLE_REFRESH //Added new check to allow user to disable REFRESH feature - setting is in Constants.h) if ((bTimersPending == 0) && ((millis() - refLastMillis) >= long(Constants::DEV_REFRESH_INTERVAL) * 1000)) //DEV_REFRESH_INTERVAL is set in Constants.h { refLastMillis = millis(); refreshDevices(); //call each st::Device object to refresh data (this is just a safeguard to ensure the state of the Arduino and the ST Cloud stay in synch should an event be missed) } #endif if(debug && millis()%60000==0 && millis()!=lastmillis) { lastmillis = millis(); Serial.print(F("Everything: Free Ram = ")); Serial.println(freeRam()); } }
bool CDVRPTRV3Controller::openModem() { bool ret = false; switch (m_connection) { case CT_USB: ret = m_usb->open(); break; case CT_NETWORK: ret = m_network->open(); break; default: wxLogError(wxT("Invalid connection type: %d"), int(m_connection)); break; } if (!ret) return false; ret = readSerial(); if (!ret) { closeModem(); return false; } ret = setConfig(); if (!ret) { closeModem(); return false; } return true; }
double depthProbe::getRealZero(double X, double Y,bool reset) { port.flush(port_nr); double Zpos=.5; QString comando; QString received = ""; comando = "G00 X"; comando.append(QString::number(X)).append(" Y").append(QString::number(Y)).append("\r"); sendSerial(comando); port.flush(port_nr); pause(50); while(!received.contains("depth")) { Zpos-=0.02; comando = "G00 Z"; comando.append(QString::number(Zpos)).append("\r"); sendSerial(comando); pause(50); received = readSerial(false); } if(reset) port.Reset(port_nr); sendSerial("G00 Z01\r"); pause(2000); return(Zpos); }
// Recieve distance from URM device byte URMSerial::getMeasurement(int& value) { if(!hasReading()) return NOTREADY; if(reqTimeout()) return TIMEOUT; // Read in data readSerial(); // Validate the reading type switch(serialData[Header]) // Three types of command responses. 0x11 is a temperature, 0x22 Distance, 0x33 EEPROM { case COMMAND_DISTANCE: return processDistance(value); break; case COMMAND_TEMP: return processTemperature(value); break; } // Strange return result! distanceRequested = temperatureRequested = false; // This is a bug fix. If an error was returned (conrrupt byte array), reset distance measurements so we can re-request value = 0; return ERROR; }
//-------------------------- void threadedSerial::threadedFunction() { while( isThreadRunning() != 0 ){ if( lock() ){ haveInput[0] = 0; haveInput[1] = 0; haveInput[2] = 0; readSerial(); // this is the threaded serial polling call OSCtime = ofGetElapsedTimeMillis(); if(OSCtime >= (OSCprevTime + OSCsendingInterval) ) { for(int i = 0; i < NUMOSCSENDERS; i++) { if(senderActive[i]) { if(i == resetID){ sendOSC( i, true ); }else{ sendOSC( i, false ); } } } OSCprevTime = OSCtime; } usleep(500); //mac sleeps in microseconds = 1/2 millisecond interval for serialThread unlock(); } } }
bool CloudWatcherController::getCloudWatcherAnswer(char *buffer, int nBlocks) { int r = readSerial(buffer, nBlocks * BLOCK_SIZE); int valid = checkValidMessage(buffer, nBlocks); if (!valid) { return false; } return true; }
// Read data from EEPROM byte URMSerial::read(byte command) { byte ttlCOMMAND[3] = {COMMAND_EEPROMREAD,command,0}; sendCommand(ttlCOMMAND); // Response should be immediate while(!hasReading()); readSerial(); // Return result return ttlCOMMAND[LowByte]; }
bool edfa::setEmission(bool emission){ qDebug() << "Set emission in EDFA object " << emission; if(emission){ EDFAOn(); } else{ EDFAOff(); } qDebug() << readSerial(); //Needed for some reason. Think it is to do with delays. }
float edfa::EDFAReadPh2(){ QString message; if(ready){ writeSerial("Ph 2\r\n"); message=readSerial(); if (message.contains("PDM2: ",Qt::CaseInsensitive)){ message = stripString(message, "PDM2:"); } } return message.toFloat(); }
bool stk500service::writeVerify(const char* data, int dataLen) { // Write _handler->getPort()->write(data, dataLen); // Verify char* tmp = new char[dataLen]; bool success = false; if (readSerial(tmp, dataLen) == dataLen) { success = (memcmp(data, tmp, dataLen) == 0); } delete[] tmp; return success; }
String SerialHandler::checkForCommand(){ buffer += readSerial(); if(buffer.length() > 0){ String cmd = parseCommand(); if(cmd.equals("")){ Serial.print("Free RAM: "); Serial.println(freeRam()); return NO_COMMAND; }else return cmd; }else{ return NO_COMMAND; } }
// Send a request to the URM37 bool URMSerial::write(byte command, byte data) { // WARNING. VERY DANGEROUS. You can set the wrong mode byte ttlCOMMAND[3] = {COMMAND_EEPROMWRITE,command,data}; sendCommand(ttlCOMMAND); // Response should be immediate while(!hasReading()); readSerial(); // Return whether the command was echoed return ttlCOMMAND[0] == serialData[0] && ttlCOMMAND[1] == serialData[1] && ttlCOMMAND[2] == serialData[2]; }
void depthProbe::getZero() { port.flush(port_nr); double Zpos=0; QString comando,num; QString received = ""; while(!received.contains("depth")) { comando="G00 Z"; Zpos-=0.02; comando.append(num.setNum(Zpos)).append("\r"); sendSerial(comando); pause(50); received = readSerial(false); } port.Reset(port_nr); sendSerial("G00 Z01\r"); pause(100); }
bool edfa::replyCheck(){ qDebug() << "In reply check"; if(ready){ qDebug() << "In reply check ready pass"; serial->clear(); serial->write("giberish\r\n"); //send some giberish to get FWC response. serial->waitForBytesWritten(10000); QString message = readSerial(); qDebug() << message; if (message.contains("FWC",Qt::CaseInsensitive)){ return true; } else{ return replyCheck(); } } return false; }
char* readWord() { const unsigned int BUFLEN = 255; char* accumulated = (char*) malloc(BUFLEN); unsigned int location = 0; while (true) { if (Serial.available()) { char incoming = readSerial(); if (incoming == '\n' || incoming == ';') { break; } accumulated[location] = incoming; location ++; } else { delay(2); // arbitrary } } accumulated[location] = '\0'; return accumulated; }
void Serial::run(){ size_t len; unsigned char buf[SERIAL_BUFFER_LENGTH]; int used = 0; int frompos = 0; int topos = 0; if(verbose) std::cout << "starting rx" << std::endl; while(running) { len = readSerial(&buf[topos], SERIAL_BUFFER_LENGTH-topos); topos += len; len = topos-frompos; if(len > 0){ do{ if(verbose){ std::cout << "rx\t"; log(&buf[frompos], len); } if(callback){ used = callback->handle(&buf[frompos], len); }else{ used = len; } if(used == len) frompos = topos = 0; else frompos += used; len = topos-frompos; }while(used > 0 && len > 0); } if(topos >= SERIAL_BUFFER_LENGTH-1){ std::cerr << "buffer overflow!" << std::endl; frompos = topos = 0; } } if(verbose) std::cout << "stopping rx" << std::endl; }
void loop() { readSerial(); // read the values available at the serial port Serial.print(firstValue); // debugging Serial.print("t"); Serial.print(secondValue); Serial.print("t"); Serial.print(thirdValue); Serial.print("t"); //Serial.print(fourthValue); // add these lines if needed Serial.println(); // send a carriage return for debugging if(firstValue > 250){ digitalWrite(LED, HIGH); } else { digitalWrite(LED, LOW); } }
double depthProbe::depthProbeZero() { double half=2.56,level = 0; int i; QString received; sendSerial(QString("G00 Z").append(QString::number(level)).append("\r")); for(i=0;i<8;i++) { received=readSerial(true); half=half/2; if(received.contains("depth")) { level+=half; } else { level-=half; } sendSerial(QString("G00 Z").append(QString::number(level)).append("\r")); } return level; }
bool edfa::getEmission(){ bool emission = false; //This needs to be made better so that the method will return something if no emission is found. QString message; if(ready){ writeSerial("OM\r\n"); message = readSerial(); qDebug() << "get EDFA emission message " << message; if (message.contains("OM ",Qt::CaseInsensitive)){ message = stripString(message, "OM"); qDebug() << "message contains OM"; qDebug() << "New message " << message; } } if(message == "O"){ emission = false; } if(message == "2"){ emission = true; } return emission; }
Dolle_UserApp::Dolle_UserApp(QWidget *parent) : QMainWindow(parent), ui(new Ui::Dolle_UserApp) { ui->setupUi(this); ui->tempLCD->display("-----"); arduino = new QSerialPort(this); serialBuffer = ""; parsed_data = ""; temperature_value = 0.0; humidity_value = 0.0; open_value = "Unknown"; bool arduino_is_available = true; //Declare the Arduino port according to Unix standards //For Windows systems the default port would be "COM3" QString arduino_uno_port_name = "/dev/ttyACM0"; /* Open and configure the arduino port if available */ if(arduino_is_available){ qDebug() << "Found the arduino port...\n"; arduino->setPortName(arduino_uno_port_name); arduino->open(QSerialPort::ReadOnly); arduino->setBaudRate(QSerialPort::Baud9600); arduino->setDataBits(QSerialPort::Data8); arduino->setFlowControl(QSerialPort::NoFlowControl); arduino->setParity(QSerialPort::NoParity); arduino->setStopBits(QSerialPort::OneStop); QObject::connect(arduino, SIGNAL(readyRead()), this, SLOT(readSerial())); }else{ qDebug() << "Couldn't find the correct port for the arduino.\n"; QMessageBox::information(this, "Serial Port Error", "Couldn't open serial port to arduino."); } }
/** * \par Function * readjoystick * \par Description * This function is used to read the handle datas. * \param[in] * None * \par Output * None * \par Return * Returns 0 if no data ready, 1 if data ready. * \par Others * None */ boolean MePS2::readjoystick(void) { boolean result = false; if(millis() - _lasttime > 200) { _isReady = false; _isStart=false; _prevc = 0x00; buffer[2] = buffer[4] = buffer[6] =buffer[8] =0x80; buffer[1] = buffer[3] = buffer[5] =buffer[7] =0x00; } readSerial(); while(_isAvailable) { _lasttime = millis(); unsigned char c = _serialRead & 0xff; if((c == 0x55) && (_isStart == false)) { if(_prevc == 0xff) { _index=1; _isStart = true; } } else { _prevc = c; if(_isStart) { writeBuffer(_index,c); } } _index++; if((_isStart == false) && (_index > 12)) { _index=0; _isStart=false; buffer[2] = buffer[4] = buffer[6] =buffer[8] =0x80; buffer[1] = buffer[3] = buffer[5] =buffer[7] =0x00; } else if(_isStart && (_index > 9)) { uint8_t checksum; checksum = buffer[2]+buffer[3]+buffer[4]+buffer[5]+buffer[6]+buffer[7]+buffer[8]; if(checksum == buffer[9]) { _isReady = true; _isStart = false; _index = 0; result = true; } else { _isStart = false; _index = 0; _prevc = 0x00; _isStart=false; result = false; } } readSerial(); } return result; }
pPrinterSerial::pPrinterSerial(printerType ptype, QObject *parent) : pPrinter(ptype,parent), m_serial(this) { connect(&m_serial,SIGNAL(readyRead()),this,SLOT(readSerial())); }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); _serialPort = new QextSerialPort; connect(_serialPort, SIGNAL(readyRead()), this, SLOT(readSerial())); QStringList serialCommandList; serialCommandList << "node.restart" << "node.dsleep" << "node.info" << "node.chipid" << "node.flashid" << "node.heap" << "node.key" << "node.led" << "node.input" << "node.output" << "node.readvdd33" << "node.compile" << "node.setcpufreq" << "node.restore" << "file.remove" << "file.open" << "file.close" << "file.readline" << "file.writeline" << "file.read" << "file.write" << "file.flush" << "file.seek" << "file.list" << "file.format" << "file.rename" << "file.fsinfo" << "wifi.setmode" << "wifi.getmode" << "wifi.getchannel" << "wifi.setphymode" << "wifi.getphymode" << "wifi.startsmart" << "wifi.stopsmart" << "wifi.sleeptype" << "wifi.sta.getconfig" << "wifi.sta.config" << "wifi.sta.connect" << "wifi.sta.disconnect" << "wifi.sta.autoconnect" << "wifi.sta.getip" << "wifi.sta.setip" << "wifi.sta.getmac" << "wifi.sta.setmac" << "wifi.sta.getap" << "wifi.sta.status" << "wifi.sta.getbroadcast" << "wifi.sta.eventMonReg" << "wifi.sta.eventMonStart" << "wifi.sta.eventMonStop" << "wifi.ap.config" << "wifi.ap.getip" << "wifi.ap.setip" << "wifi.ap.getmac" << "wifi.ap.setmac" << "wifi.ap.getbroadcast" << "tmr.delay" << "tmr.now" << "tmr.alarm" << "tmr.stop" << "tmr.wdclr" << "tmr.time" << "gpio.mode" << "gpio.read" << "gpio.write" << "gpio.trig" << "pwm.setup" << "pwm.close" << "pwm.start" << "pwm.stop" << "pwm.setclock" << "pwm.getclock" << "pwm.setduty" << "pwm.getduty" << "net.createServer" << "net.createConnection" << "net.server:listen" << "net.server:close" << "net.socket:connect" << "net.socket:send" << "net.socket:on" << "net.socket:close" << "net.socket:dns" << "i2c.setup" << "i2c.start" << "i2c.stop" << "i2c.address" << "i2c.write" << "i2c.read" << "adc.read" << "adc.readvdd33" << "uart.setup" << "uart.on" << "uart.write" << "ow.setup" << "ow.reset" << "ow.skip" << "ow.select" << "ow.write" << "ow.write_bytes" << "ow.read" << "ow.read_bytes" << "ow.depower" << "ow.reset_search" << "ow.target_search" << "ow.search" << "ow.crc8" << "ow.check_crc16" << "ow.crc16" << "bit.bnot" << "bit.band" << "bit.bor" << "bit.bxor" << "bit.lshift" << "bit.rshift" << "bit.arshift" << "bit.bit" << "bit.set" << "bit.clear" << "bit.isset" << "bit.isclear" << "spi.setup" << "spi.send" << "spi.recv" << "mqtt.Client" << "mqtt.client:lwt" << "mqtt.client:connect" << "mqtt.client:close" << "mqtt.client:publish" << "mqtt.client:subscribe" << "mqtt.client:on" << "ws2812.writergb" << "cjson.encode" << "cjson.decode" << "crypto.hash" << "crypto.hmac" << "crypto.mask" << "crypto.toHex" << "crypto.toBase64" << "u8g.ssd1306_128x64_i2c" << "u8g.ssd1306_128x64_spi" << "u8g.pcd8544_84x48" << "u8g.disp:begin" << "u8g.disp:drawBitmap" << "u8g.disp:drawBox" << "u8g.disp:drawCircle" << "u8g.disp:drawDisc" << "u8g.disp:drawEllipse" << "u8g.disp:drawFilledEllipse" << "u8g.disp:drawFrame" << "u8g.disp:drawHLine" << "u8g.disp:drawLine" << "u8g.disp:drawPixel" << "u8g.disp:drawRBox" << "u8g.disp:drawRFrame" << "u8g.disp:drawStr" << "u8g.disp:drawStr90" << "u8g.disp:drawStr180" << "u8g.disp:drawStr270" << "u8g.disp:drawTriangle" << "u8g.disp:drawVLine" << "u8g.disp:drawXBM" << "u8g.disp:firstPage" << "u8g.disp:getColorIndex" << "u8g.disp:getFontAscent" << "u8g.disp:getFontDescent" << "u8g.disp:getFontLineSpacing" << "u8g.disp:getHeight" << "u8g.disp:getMode" << "u8g.disp:getWidth" << "u8g.disp:getStrWidth" << "u8g.disp:nextPage" << "u8g.disp:setColorIndex" << "u8g.disp:setDefaultBackgroundColor" << "u8g.disp:setDefaultForegroundColor" << "u8g.disp:setFont" << "u8g.disp:setFontLineSpacingFactor" << "u8g.disp:setFontPosBaseline" << "u8g.disp:setFontPosBottom" << "u8g.disp:setFontPosCenter" << "u8g.disp:setFontPosTop" << "u8g.disp:setFontRefHeightAll" << "u8g.disp:setFontRefHeightExtendedText" << "u8g.disp:setFontRefHeightText" << "u8g.disp:setRot90" << "u8g.disp:setRot180" << "u8g.disp:setRot270" << "u8g.disp:setScale2x2" << "u8g.disp:sleepOn" << "u8g.disp:sleepOff" << "u8g.disp:undoRotation" << "u8g.disp:undoScale" << "dht.read" << "dht.read11" << "dht.readxx"; _serialCommandCompleter = new QCompleter(serialCommandList, this); ui->serialSendComboBox->lineEdit()->setCompleter(_serialCommandCompleter); addEditorWindow(); }
void loop () { if (!initialised && !connected && (lastCheck + 5000 < millis())) { if (WiFi.ready()) { connect("www.apple.com", 80); if (connected) { client.println("GET /library/test/success.html HTTP/1.1"); client.println("Host: www.apple.com"); client.println(); const char *success = "Success"; unsigned int successLocation = 0; while (true) { if (client.available()) { int chr = client.read(); if (success[successLocation] == chr) { successLocation ++; if (successLocation == strlen(success)) { initialised = true; Spark.connect(); Spark.function("digitalread", tinkerDigitalRead); Spark.function("digitalwrite", tinkerDigitalWrite); Spark.function("analogread", tinkerAnalogRead); Spark.function("analogwrite", tinkerAnalogWrite); client.stop(); break; } } else { successLocation = 0; } } else { delay(2); } } } } else { return; } } if (Serial.available()) { if (connected) { int bytes = Serial.available(); for (int i=0; i<bytes; i++) { client.write(readSerial()); } } else { int cmd = readSerial(); switch (cmd) { case 'i': Serial.println("Ready"); break; case 'c': { char* host; char* stringPort; readWord(); // junk space host = readWord(); stringPort = readWord(); connect(host, atol(stringPort)); free(host); free(stringPort); break; } case 'w': { char* ssid; char* password; readWord(); ssid = readWord(); password = readWord(); Serial.print("Wifi credentials set to SSID '"); Serial.print(ssid); Serial.print("' and password '"); Serial.print(password); Serial.println("'"); WiFi.setCredentials(ssid, password); break; } default: Serial.print("Don't know command: "); Serial.write(cmd); Serial.println(); break; } } } if (connected) { int bytes = client.available(); for (int i=0; i<bytes; i++) { Serial.write(client.read()); } if (!client.connected()) { Serial.println(); Serial.println("Disconnecting"); client.stop(); connected = false; } } }
/** * Main program. */ int main() { uchar i, errorCode; uint8_t oldRunning = 0, running; /* Disable the watchdog */ MCUSR = 0; wdt_disable(); /* Read the serial number from flash */ readSerial(); /* Read the flash checksum from EEPROM */ readFlashChecksum(); /* Initialize USB and enable global interrupts */ initUSB(); /* First initialize the PWM so all LEDs are off. */ pwmInit(prescalingIndex); pwmSet(CHANNEL0, 0, 0); pwmSet(CHANNEL1, 0, 0); pwmSet(CHANNEL2, 0, 0); pwmSet(CHANNEL3, 0, 0); pwmSet(CHANNEL4, 0, 0); pwmSet(CHANNEL5, 0, 0); /* Initialize the blinks memory from eeprom */ eeprom_busy_wait(); eeprom_read_block(memory, (uint8_t*) 1, BLINKS_MEM_SIZE); /* Make sure bits 7 is cleared and bit 6 is set */ memory[0] &= 0x7f; memory[0] |= 0x40; /* Initialize blinks */ blinksScript.data = BLINKS_SCRIPT(memory); blinksScript.size = BLINKS_SCRIPT_SIZE; errorCode = 1; /* Infinite program loop */ i = 0; uint16_t shutdown = 0; while ((memory[0] & 0x40) || (--shutdown)) { /* Re-init PWM if needed */ if (prescalingIndex != getPrescalingIndex()) { prescalingIndex = getPrescalingIndex(); pwmInit(prescalingIndex); } /* Process USB events */ usbPoll(); /* Execute special commands */ switch (command) { case CMD_SAVE: eeprom_busy_wait(); eeprom_write_block(memory, (uint8_t*) 1, BLINKS_MEM_SIZE); break; } command = 0; /* Reset script when running flag has changed or an error occurred */ running = BLINKS_FLAGS(memory) & BLINKS_FLAG_RUNNING; if (running != oldRunning || errorCode) { errorCode = blinksReset(blinksScript); oldRunning = running; } /* Execute next step in program when program is running an no error occurred. */ if (running && !errorCode) errorCode = blinksStep(blinksScript); /* Apply channel values */ if (!errorCode) { unsigned char outputs = blinksCountOutputs(blinksScript); unsigned char invert = isInverted(); if (outputs > 0) pwmSet(CHANNEL0, blinksGetOutput(blinksScript, 0), invert); if (outputs > 1) pwmSet(CHANNEL1, blinksGetOutput(blinksScript, 1), invert); if (outputs > 2) pwmSet(CHANNEL2, blinksGetOutput(blinksScript, 2), invert); if (outputs > 3) pwmSet(CHANNEL3, blinksGetOutput(blinksScript, 3), invert); if (outputs > 4) pwmSet(CHANNEL4, blinksGetOutput(blinksScript, 4), invert); if (outputs > 5) pwmSet(CHANNEL5, blinksGetOutput(blinksScript, 5), invert); } /* When this loop has been executed for 100 times then mark the flash as OK */ if ((flashChecksum != FLASH_CHECKSUM) && (i < 100)) { i++; if (i == 100) { flashChecksum = FLASH_CHECKSUM; writeFlashChecksum(); } } } enterBootloader(); return 0; }
int main(int argc, char **argv) { char responseBuf[MAXLEN]; int i; int retval; ser_t serport; char EDFPacket[MAXHEADERLEN]; int EDFLen = MAXHEADERLEN; /// buffer for reading from serial port char smallbuf[PROTOWINDOW]; char *hostname = NULL; char *deviceName = NULL; /// DEFAULTHOST; unsigned short portno = 0; /// DEFAULTPORT; struct timeval when; rprintf("ModEEG Driver v. %s-%s\n", VERSION, OSTYPESTR); rinitNetworking(); /// process command line inputs for (i = 1; argv[i]; ++i) { if (argv[i][0] == '-' && argv[i][1] == 'h') { printHelp(); exit(0); } if (argv[i][0] == '-' && argv[i][1] == 'd') { if (argv[i+1] == NULL) { rprintf("Bad devicename option: %s\nExpected device name as next argument.\n", argv[i]); exit(1); } deviceName = argv[i+1]; i += 1; continue; } if (hostname == NULL) { hostname = argv[i]; continue; } if (portno == 0) { portno = atoi(argv[i]); continue; } } if (deviceName == NULL) deviceName = DEFAULTDEVICE; if (portno == 0) portno = DEFAULTPORT; if (hostname == NULL) hostname = DEFAULTHOST; makeREDFConfig(¤t, &modEEGCfg); writeEDFString(¤t, EDFPacket, &EDFLen); sock_fd = rsocket(); if (sock_fd < 0) { perror("socket"); rexit(1); } setblocking(sock_fd); rprintf("Attempting to connect to nsd at %s:%d\n", hostname, portno); retval = rconnectName(sock_fd, hostname, portno); if (retval != 0) { rprintf("connect error\n"); rexit(1); } rprintf("Socket connected.\n"); fflush(stdout); serport = openSerialPort(deviceName,57600); rprintf("Serial port %s opened.\n", deviceName); writeString(sock_fd, "eeg\n", &ob); mGetOK(sock_fd, &ib); writeString(sock_fd, "setheader ", &ob); writeBytes(sock_fd, EDFPacket, EDFLen, &ob); writeString(sock_fd, "\n", &ob); mGetOK(sock_fd, &ib); updateMaxFd(sock_fd); #ifndef __MINGW32__ updateMaxFd(serport); #endif when.tv_usec = (1000000L / modEEGCfg.chan[0].sampleCount); rprintf("Polling at %d Hertz or %d usec\n", modEEGCfg.chan[0].sampleCount, when.tv_usec); for (;;) { int i, readSerBytes; int retval; fd_set toread; when.tv_sec = 0; when.tv_usec = (1000000L / modEEGCfg.chan[0].sampleCount); FD_ZERO(&toread); FD_SET(sock_fd, &toread); #ifndef __MINGW32__ FD_SET(serport, &toread); #endif retval = rselect_timed(max_fd, &toread, NULL, NULL, &when); readSerBytes = readSerial(serport, smallbuf, PROTOWINDOW); if (readSerBytes < 0) { rprintf("Serial error.\n"); } if (readSerBytes > 0) { for (i = 0; i < readSerBytes; ++i) eatCharacter(smallbuf[i]); } if (FD_ISSET(sock_fd, &toread)) { my_read(sock_fd, responseBuf, MAXLEN, &ib); } if (isEOF(sock_fd, &ib)) { rprintf("Server died, exitting.\n"); exit(0); } } return 0; }
void stk500service::flushData() { char tmp[512]; memset(tmp, 0, sizeof(tmp)); _handler->getPort()->write(tmp, sizeof(tmp)); readSerial(tmp, sizeof(tmp)); }