Message receive(zmq::socket_t& socket) { std::vector<std::string> address; std::string frame = receiveString(socket); // Do we have an address? while (frame.compare("") != 0) { address.push_back(frame); frame = receiveString(socket); } // address is a stack, so reverse it to get the right way around std::reverse(address.begin(), address.end()); // We've just read the delimiter, so now get subject auto subjectString = receiveString(socket); //the underlying representation is (explicitly) an int so fairly safe Subject subject = (Subject)detail::unserialise<std::uint32_t>(subjectString); std::vector<std::string> data; while (true) { int isMore = 0; size_t moreSize = sizeof(isMore); socket.getsockopt(ZMQ_RCVMORE, &isMore, &moreSize); if (!isMore) break; data.push_back(receiveString(socket)); } return Message(address, subject, data); }
inline void receiveStackTrace(MPI_Comm localComm, MPI_Comm globalComm) { int source0 = getProcId(localComm); receiveString(source0, localComm, globalComm); int source1 = getProcId(localComm) + getProcSize(localComm); receiveString(source1, localComm, globalComm); }
int WalnutCentral::addDevice(BluetoothDeviceAddress address) { char tx[MAX_BUF_SIZE]; char rx[MAX_BUF_SIZE]; int rx_len = 0; String tempStr = "AT+DEVADD=" + address.toString(); tempStr.toCharArray(tx, MAX_BUF_SIZE); #ifdef PRINT_DEBUG_MESSAGES Serial.println(tx); #endif int err_code = sendString(tx, strlen(tx)); if (err_code != 0) { return err_code; } err_code = receiveString(rx, &rx_len); if (err_code != 0) { return err_code; } if (strcmp(rx, "OK") == 0) { return 0; } else { return 1; } }
bool Socket::receive(RawMessage & oMessage) { string aType; string aPayload; string aDest; std::string aMessageData; bool const aReceived = receiveString(aMessageData); if (aReceived) { size_t aEndDestFlag = aMessageData.find( " ", 0 ); if (string::npos != aEndDestFlag) { aDest = aMessageData.substr(0, aEndDestFlag); size_t aEndTypeFlag = aMessageData.find(" ", aEndDestFlag + 1); if ( aEndTypeFlag != string::npos ) { aType = aMessageData.substr( aEndDestFlag + 1, aEndTypeFlag - aEndDestFlag - 1 ); aPayload = aMessageData.substr( aEndTypeFlag + 1 ); } } oMessage._type = aType; oMessage._routingId = aDest; oMessage._payload = aPayload; ORWELL_LOG_DEBUG("Received message : type=" << aType << "- dest=" << aDest << "-"); } return aReceived; }
/** * Checks and changes state of keyring * */ void updateState(void) { unsigned char * command = receiveString(); //Recieve command from serial //command = command[strlen(command)-1] = 0; // STrips last char fro string (line break (\n)) if(!strcmp(command, "LOCK")) { lock(); USART_putstring("LOCK!!"); } else if (!strcmp(command, "UNLOCK") == 1) { unlock(); USART_putstring("UNLOCK!!!!"); } else { USART_putstring("SOMETHING!!!!"); } }
void Client::receiveData(){ if(type == -1) type = readType(); switch(type){ case Constants::STRING: receiveString(); break; case Constants::IMAGE: receiveImage(); break; }; }
// Object class setting! Object::Object(int socketDescriptor):socketDescriptor(socketDescriptor) { tcpSocket=new QTcpSocket; bytesReceived=0; if(!tcpSocket->setSocketDescriptor(socketDescriptor)){ emit error(tcpSocket->error()); return; } qDebug()<<socketDescriptor; QObject::connect(tcpSocket,SIGNAL(readyRead()), this,SLOT(receiveString())); }
int WalnutCentral::startScan() { char tx[MAX_BUF_SIZE]; char rx[MAX_BUF_SIZE]; int rx_len = 0; strcpy(tx, "AT+SCANSTART"); int err_code = sendString(tx, strlen(tx)); if (err_code != 0) { return err_code; } err_code = receiveString(rx, &rx_len); if (err_code != 0) { return err_code; } if (strcmp(rx, "OK") == 0) { return 0; } else { return 1; } }
int WalnutCentral::getAdvertisingMessage(uint8_t deviceIndex) { char tx[MAX_BUF_SIZE] = {0}; char rx[MAX_BUF_SIZE]; int rx_len = 0; sprintf(tx, "AT+ADV=%02d", deviceIndex); int err_code = sendString(tx, strlen(tx)); if (err_code != 0) { return err_code; } err_code = receiveString(rx, &rx_len); if (err_code != 0) { return err_code; } if (strcmp(rx, "OK") == 0) { return 0; } else { return 1; } }
int WalnutCentral::setScanParameters() { char tx[MAX_BUF_SIZE]; char rx[MAX_BUF_SIZE]; int rx_len = 0; strcpy(tx, "AT+SCANSETP=1,0,1760,1680,0"); // strcpy(tx, "AT+SCANSETP=1,0,A0,50,0"); int err_code = sendString(tx, strlen(tx)); if (err_code != 0) { return err_code; } err_code = receiveString(rx, &rx_len); if (err_code != 0) { return err_code; } if (strcmp(rx, "OK") == 0) { return 0; } else { return 1; } }
void command_handler(uint8_t command){ uint16_t wbuf; uint8_t bufh, bufl; float fbuf; char sbuf[10]; switch(command){ /* read temperature in human readable form */ case READ_TEMP: sendByte(command); fbuf = getTemperature( ADC_read() ); floatToString(fbuf, sbuf); sendString(sbuf); sendString(EOM); break; /* read temperature in raw ADC counts */ case READ_TEMP_RAW: sendByte(command); wbuf = ADC_read(); HexToAscii(sbuf, 4, wbuf); sendString(sbuf); sendString(EOM); break; /* set operational voltage @25°C */ case SET_UBIAS_A: // echo the command sendByte(command); // waiting for a 4 character string receiveString(sbuf, 4); sendString(EOM); // set ADC register to given value wbuf = AsciiToHex(sbuf, 4); // max 0x7FF ADC_REG = 0x7FF & wbuf; break; /* set the temperature progression coefficient */ case SET_COEFF: // echo... sendByte(command); // waiting for a 2 character string receiveString(sbuf, 2); sendString(EOM); // Vcoef = AsciiToHex(sbuf, 2); // max value = 0x7F // Vcoef &= 0x7F; break; /* read the calculated adjusted operational voltage */ case READ_UADJ_A: sendByte(command); // get temperature fbuf = getTemperature( ADC_read() ); // calculate temperature adjusted voltage wbuf = calcAdjustedBiasVoltage(fbuf); // create string HexToAscii(sbuf, 5, wbuf); sendString(sbuf); sendString(EOM); break; /* read temperature coefficient */ case READ_COEFF: sendByte(command); sendString(EOM); break; /* print help */ case PRINT_HELP: sendByte(command); sendString("HW Version x.x SW Version 2.0"); sendString(EOM); break; /* print sipm info of module */ case SIPM_INFO: sendByte(command); sendString(EOM); break; case DAC_CAL: sendByte(command); sendString(EOM); break; default: MPPC_status = ADDRESSED; } }
int WalnutCentral::begin(Stream &serial, const int rstPin) { _serial = &serial; _rstPin = rstPin; // Release Reset digitalWrite(rstPin, 0); delay(100); digitalWrite(rstPin, 1); // Wait for boot finished delay(1000); // TODO: Implement command or character to be received when booting up unsigned long startTime = millis(); // bool timedOut = false; // const int RX_BUF_SIZE = 10; // char rx[MAX_BUF_SIZE] = {0}; // int rx_len = 0; // uint8_t i = 0; char tx[MAX_BUF_SIZE]; char rx[MAX_BUF_SIZE]; int rx_len = 0; int err_code; //// while (!_serial->available()) { // while (digitalRead(13) == 0) { // if (millis() - startTime > 30000) { //// timedOut = true; // return 1; // } // } // // while (!_serial->available()) { // if (millis() - startTime > 30000) { //// timedOut = true; // return 1; // } // } // int err_code = receiveString(rx, &rx_len); // if (err_code != 0) { // return err_code; // } //// _serial->setTimeout(1000); //// rx_len = _serial->readBytesUntil('\n', rx, MAX_BUF_SIZE); //// if (rx_len > 1) { //// rx[rx_len-1] = 0; //// rx_len -= 1; //// } // // #ifdef PRINT_DEBUG_MESSAGES // Serial.print("receiveString: -"); // Serial.print(rx); // Serial.print("- nbrOfBytes: "); // Serial.println(rx_len); // #endif // // if ((rx_len == 0) || (strcmp(rx, "B") != 0)) { // // Timeout // return 1; // } // strcpy(tx, "ATZ"); err_code = sendString(tx, strlen(tx)); if (err_code != 0) { return err_code; } err_code = receiveString(rx, &rx_len); if (err_code != 0) { return err_code; } // Check revision // TODO: Implement command on Walnut }
void TubeInterrupt(void) { in_isr = 1; // Check for R1 interrupt if (tubeRead(R1_STATUS) & A_BIT) { if (DEBUG) { printf("R1 irq\r\n"); } unsigned char flag = tubeRead(R1_DATA); if (flag & 0x80) { // Escape in_isr = 0; // The escape handler is called with the escape flag value in R11 // That's with this wrapper achieves _escape_handler_wrapper(flag & 0x40, env->handler[ESCAPE_HANDLER].handler); } else { // Event unsigned char y = receiveByte(R1_ID); unsigned char x = receiveByte(R1_ID); unsigned char a = receiveByte(R1_ID); in_isr = 0; env->handler[EVENT_HANDLER].handler(a, x, y); } } // Check for R4 interrupt if (tubeRead(R4_STATUS) & A_BIT) { if (DEBUG) { printf("R4 irq\r\n"); } unsigned char type = tubeRead(R4_DATA); if (DEBUG) { printf("R4 type = %02x\r\n",type); } if (type == 0xff) { receiveByte(R2_ID); // always 0 // Build the error block ErrorBlock_type *eblk = &isrErrorBlock; eblk->errorNum = receiveByte(R2_ID); receiveString(R2_ID, 0x00, eblk->errorMsg); in_isr = 0; // SWI OS_GenerateError need the error block in R0 OS_GenerateError(eblk); } else { unsigned char id = receiveByte(R4_ID); if (type <= 4 || type == 6 || type == 7) { unsigned char a3 = receiveByte(R4_ID); unsigned char a2 = receiveByte(R4_ID); unsigned char a1 = receiveByte(R4_ID); unsigned char a0 = receiveByte(R4_ID); address = (unsigned char *)((a3 << 24) + (a2 << 16) + (a1 << 8) + a0); if (DEBUG) { printf("Transfer = %02x %02x %08x\r\n", type, id, (unsigned int)address); } } else { if (DEBUG) { printf("Transfer = %02x %02x\r\n", type, id); } } if (type == 5) { // Type 5 : tube release } else { // Every thing else has a sync byte receiveByte(R4_ID); } // The data transfers are done by polling the GPIO bits for IRQ and NMI count = 0; signature = 0; switch (type) { case 0: type_0_data_transfer(); break; case 1: type_1_data_transfer(); break; case 2: type_2_data_transfer(); break; case 3: type_3_data_transfer(); break; case 6: type_6_data_transfer(); break; case 7: type_7_data_transfer(); break; } if (DEBUG) { printf("count = %0x signature = %0x\r\n", count, signature); } } } in_isr = 0; }