自学教程：C++ writePacket函数代码示例

static intbrl_construct (BrailleDisplay *brl, char **parameters, const char *device) {  if (!isSerialDevice(&device)) {     unsupportedDevice(device);     return 0;  }  if ((serialDevice = serialOpenDevice(device))) {    if (serialRestartDevice(serialDevice, serialBaud)) {      static const unsigned char request[] = {BNO_DESCRIBE};      charactersPerSecond = serialBaud / 10;      if (writePacket(brl, request, sizeof(request)) != -1) {        while (serialAwaitInput(serialDevice, 100)) {          ResponsePacket response;          int size = getPacket(&response);          if (size) {            if (response.data.code == BNI_DESCRIBE) {              statusCells = response.data.values.description.statusCells;              brl->textColumns = response.data.values.description.textCells;              brl->textRows = 1;              brl->keyBindings = "keys";              if ((statusCells == 5) && (brl->textColumns == 30)) {                statusCells -= 2;                brl->textColumns += 2;              }              dataCells = brl->textColumns * brl->textRows;              cellCount = statusCells + dataCells;              makeOutputTable(dotsTable_ISO11548_1);              makeInputTable();              if ((cellBuffer = malloc(cellCount))) {                memset(cellBuffer, 0, cellCount);                statusArea = cellBuffer;                dataArea = statusArea + statusCells;                refreshCells(brl);                persistentKeyboardMode = KBM_NAVIGATE;                temporaryKeyboardMode = persistentKeyboardMode;                persistentRoutingOperation = BRL_BLK_ROUTE;                temporaryRoutingOperation = persistentRoutingOperation;                return 1;              } else {                logSystemError("cell buffer allocation");              }            } else {              logUnexpectedPacket(response.bytes, size);            }          }        }      }    }    serialCloseDevice(serialDevice);    serialDevice = NULL;  }  return 0;}

void Driver::cleanComChannel(){    try    {        writePacket(reinterpret_cast<uint8_t const*>("/r"), 1, 100);        readConfigurationAck();    }    catch (std::runtime_error e) {}}

bool SeaNet::isFullDuplex(int timeout){    std::vector<uint8_t> packet = SeaNetPacket::createPaket(device_type,mtSendBBUser);    writePacket(&packet[0],packet.size());    waitForPacket(mtBBUserData,timeout);    BBUserData settings;    sea_net_packet.decodeBBUserData(settings);    return settings.full_duplex;}

voidDebugNet::writeBreakpointHit(uint32_t coreId, uint32_t userData){   auto pak = new DebugPacketBpHit();   pak->coreId = coreId;   pak->userData = userData;   populateDebugPauseInfo(pak->info);   writePacket(pak);}

static voidloopTruthTable(TruthTable truthset[]){    for(int i = 0; truthset[i].packet != NULL; i++)    {        writePacket(&truthset[i]);    }}

void secPack(int fd, void *secpack) {    LOG(LOGLEVEL_INFO, "Sending secpack.../n");    writePacket(fd, 0x204, secpack, 0x800);    char buffer[PACKET_SIZE(SECPACK_REPLY_PACKET_SIZE)];    size_t rlength = readPacket(fd, WRITE_TIMEOUT, buffer, sizeof(buffer));    SecpackReplyPacket *reply = verifyPacket(buffer, rlength);    LOG(LOGLEVEL_DEBUG, "Secpack returns: unknown1=%d unknown2=0x%x/n", reply ? reply->unknown1 : 0, reply ? reply->unknown2 : 0);}

void seekBaseband(int fd, unsigned int offset) {    LOG(LOGLEVEL_INFO, "Seeking to 0x%08x.../n", offset);    writePacket(fd, 0x802, &offset, sizeof(offset));    char buffer[PACKET_SIZE(SEEK_REPLY_PACKET_SIZE)];    size_t length = readPacket(fd, DEFAULT_TIMEOUT, buffer, sizeof(buffer));    LOG(LOGLEVEL_DEBUG, "Seek returns:/n");    LOGDO(LOGLEVEL_DEBUG, printBuffer(verifyPacket(buffer, length), SEEK_REPLY_PACKET_SIZE));}

	void resume()	{		assert(paused);		paused = false;		ZhttpResponsePacket p;		p.type = ZhttpResponsePacket::KeepAlive;		writePacket(p);	}

// Send a Midi PROGRAM CHANGE message to given channel, with program ID 0-127void USBMidi::sendProgramChange(unsigned int channel, unsigned int program){    outPacket.p.cable=DEFAULT_MIDI_CABLE;    outPacket.p.cin=CIN_PROGRAM_CHANGE;    outPacket.p.midi0=MIDIv1_PROGRAM_CHANGE |(channel & 0x0f);    outPacket.p.midi1=program;    writePacket(outPacket.i);    }

// Returns a packet read from the serial connectionARCPOPacket& readPacket(ARCPOPacket& pPacket) {    char vReadChar;    boolean vStarterRead = false;    mPacketRead = false;    if (Serial.available() > 0) {        //wait to make sure everything will be there        //at 9600 bps, one need (1/9600) * 8 bits * 64 byte = 0.053 sec. We wait 0.1 sec to be sure.        delay(100);        while(Serial.available() > 0) {            vReadChar = Serial.read();            //search the start            if (vReadChar == '$') {                vStarterRead = true;            }            else {                //confirm the start                if (vStarterRead && vReadChar == '*') {                    vStarterRead = false;                    pPacket = readPacketInternal(pPacket);                    mPacketRead = true;                }                else {                    //crap in  the buffer, clean until next starter or empty                    vStarterRead = false;                }            }        }    }#ifdef ARCPO_Lib_DEBUGMODE    else {        Serial.print ("DBG: readPacket : no data => ");        Serial.println ((int)Serial.available());    }#endif    if (mPacketRead && pPacket.ExpectAcknowledge == 1) {#ifdef ARCPO_Lib_DEBUGMODE        Serial.print ("Acknowledgement -->");#endif        //acknowledge packet        ARCPOPacket vPacketAck;        vPacketAck.ID = pPacket.ID;        vPacketAck.Type = 255;        vPacketAck.SubType = 255;        vPacketAck.ExpectAcknowledge = 255;        vPacketAck.Content[0] = 'A';        vPacketAck.Content[1] = 'C';        vPacketAck.Content[2] = 'K';        vPacketAck.Content[3] = 0;        writePacket(vPacketAck);    }    return pPacket;}

	void pause()	{		assert(!doReq);		pausing = true;		ZhttpResponsePacket p;		p.type = ZhttpResponsePacket::HandoffStart;		writePacket(p);	}

/* * Acknowledge a received packet */static void ackPacket(uint8_t ack  /* ack return value */                      ){    gPacket.data[PACKET_DESTINATION] = gPacket.data[PACKET_SOURCE];    gPacket.data[PACKET_SOURCE] = gPacket.myAddr;    gPacket.data[PACKET_COMMAND] = ack;    gPacket.length = 6;    writePacket();}

static intwriteLocation (BrailleDisplay *brl) {  unsigned char packet[2];  unsigned char *byte = packet;  *byte++ = statusCells[gscScreenCursorRow];  *byte++ = statusCells[gscScreenCursorColumn];  return writePacket(brl, packet, byte-packet);}

	void respond()	{		state = Connected;		ZhttpResponsePacket out;		out.code = responseCode;		out.reason = responseReason;		out.headers = responseHeaders;		writePacket(out);	}

void endSecPack(int fd) {    LOG(LOGLEVEL_INFO, "Ending secpack.../n");    unsigned short unknown = 0;    writePacket(fd, 0x205, &unknown, sizeof(unknown));    char buffer[PACKET_SIZE(sizeof(unsigned short))];    size_t rlength = readPacket(fd, DEFAULT_TIMEOUT, buffer, sizeof(buffer));    unsigned short *ret = verifyPacket(buffer, rlength);    LOG(LOGLEVEL_DEBUG, "End secpack returns: %d/n", ret ? *ret : 0);}

bool PcapFileWriterDevice::writePackets(const RawPacketVector& packets){	for (RawPacketVector::ConstVectorIterator iter = packets.begin(); iter != packets.end(); iter++)	{		if (!writePacket(**iter))			return false;	}	return true;}

int ModbusClientV1::SetNumberOfBalls(int numOfBalls){	RSPacket::PacketStruct p =	{ 0 };	fillTheCommonPacketHeader(p, RS_CMD_SET_NUM_OF_BALLS);	p.data[0] = numOfBalls;	if (writePacket(&p, RS_PACKET_HEADER_SIZE + 2)			== (RS_PACKET_HEADER_SIZE + 2))		return 0;	return -1;}

void writeBaseband(int fd, void *data, size_t length) {    LOG(LOGLEVEL_STATUS, "Writing %lu bytes to flash.../n", length);    writePacket(fd, 0x804, data, length);    char buffer[PACKET_SIZE(sizeof(unsigned short))];    size_t rlength = readPacket(fd, WRITE_TIMEOUT, buffer, sizeof(buffer));    unsigned short *ret = verifyPacket(buffer, rlength);    if (ret && *ret) {        LOG(LOGLEVEL_ERROR, "Write returns error: %d/n", *ret);    }}

int clientVerifyFile(BIO *conn, char *filename) {	//check our records	FILERECORD *record = getRecord(filename);	if(record == NULL) {		fprintf(stderr, "No records stored for %s/n", filename);		return -1;	}	//see if we have an "unused" salt and digest on record	int index = record->hashIndex[0];	if(index == NUM_HASHES) {		fprintf(stderr, "All stored digests for this file have been consumed./n");		fprintf(stderr, "Type /"refresh %s/" to download the file and generate new digests./n", filename);		return -1;	}	unsigned char *hash = record->hashData[index];	unsigned char *salt = hash + HASH_LENGTH;	//send the code which triggers the server to call serverVerifyFile()	if(writeInt(conn, VERIFY_FILE_CODE) == -1) return -1;	//send the filename	if(writeString(conn, filename) < 1) return -1;	//send the salt	if(writePacket(conn, (char *)salt, SALT_LENGTH) < 1) return -1;	//wait for the server to indicate if a digest is coming or not	int status = readInt(conn);	//if the file does not exist	if(status == 5) return 5;	//if server failed to calculate digest	if(status == -1) return -1;		//receive the digest	char serverHash[MD5_DIGEST_LENGTH];	status = readPacket(conn, serverHash, sizeof(serverHash));	if(status < 1) return -1;		//check it against our stored digest	if(memcmp(serverHash, hash, sizeof(serverHash)) != 0) {		printf("The file digest does not match our records./n");	}	else printf("The file digest matches our records./n");	++index;	printf("You have consumed %d of %d stored digests./n", index, NUM_HASHES);	//update the hashIndex for this file	updateHashIndex(filename, index);		return 0;}

static intwriteVisualText (BrailleDisplay *brl) {  unsigned char bytes[brl->textColumns];  int i;  for (i=0; i<brl->textColumns; ++i) {    wchar_t character = visualText[i];    bytes[i] = iswLatin1(character)? character: '?';  }  return writePacket(brl, 2, bytes, brl->textColumns);}