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

//display function.Write to full-screen.void TM1637::display(int8_t DispData[]){  int8_t SegData[4];  uint8_t i;  for(i = 0;i < 4;i ++)  {    SegData[i] = DispData[i];  }  coding(SegData);  start();          //start signal sent to TM1637 from MCU  writeByte(ADDR_AUTO);//  stop();           //  start();          //  writeByte(Cmd_SetAddr);//  for(i=0;i < 4;i ++)  {    writeByte(SegData[i]);        //  }  stop();           //  start();          //  writeByte(Cmd_DispCtrl);//  stop();           //}

void digitalWritePiFaceSpecial (int pin, int value){    uint8_t mask = 1 << pin ;    uint8_t old ;    old = readByte (GPIOA) ;    if (value == 0)        old &= (~mask) ;    else        old |=   mask ;    writeByte (GPIOA, old) ;}

void mcp23016::begin(bool protocolInitOverride) {	if (!protocolInitOverride && !_error){		Wire.begin();		#if ARDUINO >= 157			Wire.setClock(400000UL); // Set I2C frequency to 400kHz		#else			TWBR = ((F_CPU / 400000UL) - 16) / 2; // Set I2C frequency to 400kHz		#endif	}		delay(100);	writeByte(IOCON,0b00000000);//read datasheet for details!	_gpioDirection = 0xFFFF;//all in	_gpioState = 0x0000;//all low }

// Display function.Write to full-screen.void TM1637::display(int8_t disp_data[]){  int8_t seg_data[DIGITS];  uint8_t i;  for (i = 0; i < DIGITS; i++)    seg_data[i] = disp_data[i];  coding(seg_data);  start();              // Start signal sent to TM1637 from MCU  writeByte(ADDR_AUTO); // Command1: Set data  stop();  start();  writeByte(cmd_set_addr); // Command2: Set address (automatic address adding)  for (i = 0; i < DIGITS; i++)    writeByte(seg_data[i]); // Transfer display data (8 bits x num_of_digits)  stop();  start();  writeByte(cmd_disp_ctrl); // Control display  stop();}

TextLCD::TextLCD(PinName rs, PinName e, PinName d4, PinName d5,                 PinName d6, PinName d7, LCDType type) : _rs(rs),        _e(e), _d(d4, d5, d6, d7),        _type(type) {    _e  = 1;    _rs = 0;            // command mode    wait(0.015);        // Wait 15ms to ensure powered up    // send "Display Settings" 3 times (Only top nibble of 0x30 as we've got 4-bit bus)    for (int i=0; i<3; i++) {        writeByte(0x3);        wait(0.00164);  // this command takes 1.64ms, so wait for it    }    writeByte(0x2);     // 4-bit mode    wait(0.000040f);    // most instructions take 40us    writeCommand(0x28); // Function set 001 BW N F - -    writeCommand(0x0C);    writeCommand(0x6);  // Cursor Direction and Display Shift : 0000 01 CD S (CD 0-left, 1-right S(hift) 0-no, 1-yes    cls();}

CSymbol* CData::addVariable (const int &scope, const std::string &name, const int &type, int size, const int &address){   if (size == 0) {      size = getTypeSize(type);   }   CSymbol *symbol = new CSymbol (scope, name, type, size, CSymbol::VAR, address);   _symbols.push_back(symbol);   if (type == CSymbol::STRING) {      // Para strings constantes e variaveis eh necessario indicar a categoria      writeByte(CSymbol::VAR);   }   //_data += symbol->getBinary();   for (int i=0; i < symbol->getTypeSize(); i++) {      // TODO: horrivel :-)      writeByte ('/0');   }   return symbol;}

/* * packetPing(): send Ping heart beat data to OneNet *  */edp_pkt *packetPing(){  int32 remainlen = 0x00;  edp_pkt* pkt;  if((pkt = packetCreate()) == NULL)    return NULL;  /* msg type */  writeByte(pkt, PINGREQ);  /* remain len */  writeRemainlen(pkt, remainlen);   return pkt;}

void DDS::setFreq(double frequency){  //enter frequency as Hz  if(frequency > 40000000){      Serial.println("Frequency is set Higher than board can output");      Serial.println("Setting to Maximum Freq ");      frequency = 40000000;  }    #ifdef DEBUG    Serial.print("Freq: ");    Serial.print(frequency);    Serial.println(" Hz");      #endif    int32_t freq = frequency * 4294967295 / 125000000;  // note 125 MHz clock on 9850  for (int b = 0; b < 4; b++, freq>>=8) {    writeByte(freq & 0xFF);  }  writeByte(0x000);   // Final control byte  pulseHigh(FU_UD);  // Done!  Should see output  }

void CDMRTX::process(){  if (m_state == DMRTXSTATE_IDLE)    return;  if (m_poLen == 0U) {    switch (m_state) {      case DMRTXSTATE_SLOT1:        createData(0U);        m_state = DMRTXSTATE_CACH2;        break;      case DMRTXSTATE_CACH2:        createCACH(1U, 0U);        m_state = DMRTXSTATE_SLOT2;        break;      case DMRTXSTATE_SLOT2:        createData(1U);        m_state = DMRTXSTATE_CACH1;        break;              default:        createCACH(0U, 1U);        m_state = DMRTXSTATE_SLOT1;        break;    }  }  if (m_poLen > 0U) {    uint16_t space = io.getSpace();        while (space > (4U * DMR_RADIO_SYMBOL_LENGTH) && space < 1000U) {      uint8_t c = m_poBuffer[m_poPtr];      uint8_t m = m_markBuffer[m_poPtr];      m_poPtr++;      writeByte(c, m);      space -= 4U * DMR_RADIO_SYMBOL_LENGTH;            if (m_poPtr >= m_poLen) {        m_poPtr = 0U;        m_poLen = 0U;        return;      }    }  }}

// Read the thermocouple temperature either in Degree Celsius or Fahrenheit. Internally,// the conversion takes place in the background within 155 ms, or longer depending on the// number of samples in each reading (see CR1).// Returns the temperature, or an error (FAULT_OPEN, FAULT_VOLTAGE or NO_MAX31856)double	MAX31856::readThermocouple(byte unit){    double temperature;    long data;    // Select the MAX31856 chip    digitalWrite(_cs, LOW);    // Read data starting with register 0x0c    writeByte(READ_OPERATION(0x0c));    // Read 4 registers    data = readData();    // Deselect MAX31856 chip    digitalWrite(_cs, HIGH);    // If there is no communication from the IC then data will be all 1's because    // of the internal pullup on the data line (INPUT_PULLUP)    if (data == 0xFFFFFFFF)        return NO_MAX31856;    // If the value is zero then the temperature could be exactly 0.000 (rare), or    // the IC's registers are uninitialized.    if (data == 0 && verifyMAX31856() == NO_MAX31856)        return NO_MAX31856;    // Was there an error?    if (data & SR_FAULT_OPEN)        temperature = FAULT_OPEN;    else if (data & SR_FAULT_UNDER_OVER_VOLTAGE)        temperature = FAULT_VOLTAGE;    else {        // Strip the unused bits and the Fault Status Register        data = data >> 13;        // Negative temperatures have been automagically handled by the shift above :-)        // Convert to Celsius        temperature = (double) data * 0.0078125;	        // Convert to Fahrenheit if desired        if (unit == FAHRENHEIT)            temperature = (temperature * 9.0/5.0)+ 32;    }    // Return the temperature    return (temperature);}

void Sensor::playMelody(unsigned char* song, int length){			for(int i = 0; i<length; i+=2)	{		if(song[i+1] != 100)		{			writeByte(ID, BUZZER_DATA_TIME, 254);			writeByte(ID, BUZZER_DATA_NOTE, song[i+1]);			usleep(40000*song[i]);		}		else		{			writeByte(ID, BUZZER_DATA_TIME, 0);			usleep(40000*song[i]);		}						}	writeByte(ID, BUZZER_DATA_TIME, 0);	}

static int _wiringPiSetupPiFace (void){  if ((spiFd = open (spiDevice, O_RDWR)) < 0)    return -1 ;// Set SPI parameters//	Why are we doing a read after write?//	I don't know - just blindliy copying an example elsewhere... -GH-  if (ioctl (spiFd, SPI_IOC_WR_MODE, &spiMode) < 0)    return -1 ;  if (ioctl (spiFd, SPI_IOC_RD_MODE, &spiMode) < 0)    return -1 ;  if (ioctl (spiFd, SPI_IOC_WR_BITS_PER_WORD, &spiBPW) < 0)    return -1 ;  if (ioctl (spiFd, SPI_IOC_RD_BITS_PER_WORD, &spiBPW) < 0)    return -1 ;  if (ioctl (spiFd, SPI_IOC_WR_MAX_SPEED_HZ, &spiSpeed) < 0)    return -1 ;  if (ioctl (spiFd, SPI_IOC_RD_MAX_SPEED_HZ, &spiSpeed) < 0)    return -1 ;// Setup the MCP23S17  writeByte (IOCON, IOCON_INIT) ;  writeByte (IODIRA, 0x00) ;	// Port A -> Outputs  writeByte (IODIRB, 0xFF) ;	// Port B -> Inputs  return 0 ;}

void myDigitalWrite (struct wiringPiNodeStruct *node, int pin, int value){  uint8_t mask, old ;  pin -= node->pinBase ;  mask = 1 << pin ;  old  = readByte (MCP23x17_GPIOA) ;  if (value == 0)    old &= (~mask) ;  else    old |=   mask ;  writeByte (MCP23x17_GPIOA, old) ;}

int mcp23s17Setup (const int pinBase, const int spiPort, const int devId){  int    x ;  struct wiringPiNodeStruct *node ;  if ((x = wiringPiSPISetup (spiPort, MCP_SPEED)) < 0)    return x ;  writeByte (spiPort, devId, MCP23x17_IOCON,  IOCON_INIT | IOCON_HAEN) ;  writeByte (spiPort, devId, MCP23x17_IOCONB, IOCON_INIT | IOCON_HAEN) ;  node = wiringPiNewNode (pinBase, 16) ;  node->data0           = spiPort ;  node->data1           = devId ;  node->pinMode         = myPinMode ;  node->pullUpDnControl = myPullUpDnControl ;  node->digitalRead     = myDigitalRead ;  node->digitalWrite    = myDigitalWrite ;  node->data2           = readByte (spiPort, devId, MCP23x17_OLATA) ;  node->data3           = readByte (spiPort, devId, MCP23x17_OLATB) ;  return 0 ;}

void SX1509::keypad(byte rows, byte columns, unsigned int sleepTime, byte scanTime, byte debounceTime){	unsigned int tempWord;	byte tempByte;		// If clock hasn't been set up, set it to internal 2MHz	if (_clkX == 0)		clock(INTERNAL_CLOCK_2MHZ);		// Set regDir 0:7 outputs, 8:15 inputs:	tempWord = readWord(REG_DIR_B);	for (int i=0; i<rows; i++)		tempWord &= ~(1<<i);	for (int i=8; i<(columns * 2); i++)		tempWord |= (1<<i);	writeWord(REG_DIR_B, tempWord);		// Set regOpenDrain on 0:7:	tempByte = readByte(REG_OPEN_DRAIN_A);	for (int i=0; i<rows; i++)		tempByte |= (1<<i);	writeByte(REG_OPEN_DRAIN_A, tempByte);		// Set regPullUp on 8:15:	tempByte = readByte(REG_PULL_UP_B);	for (int i=0; i<columns; i++)		tempByte |= (1<<i);	writeByte(REG_PULL_UP_B, tempByte);		// Debounce Time must be less than scan time	debounceTime = constrain(debounceTime, 1, 64);	scanTime = constrain(scanTime, 1, 128);	if (debounceTime >= scanTime)	{		debounceTime = scanTime >> 1; // Force debounceTime to be less than scanTime	}

void pullUpDnControlPiFaceSpecial (int pin, int pud){  uint8_t mask = 1 << pin ;  uint8_t old ;  old = readByte (GPPUB) ;  if (pud == PUD_UP)    old |=   mask ;  else    old &= (~mask) ;  writeByte (GPPUB, old) ;}

void MAX7219PrintTimer(unsigned long n){	if ((n>100)||(n==0))	{		writeByte(digit0,DASH);		writeByte(digit1,DASH);		writeByte(digit2,DASH);		writeByte(digit5,DASH);		return;	}	writeByte(digit0, DASH);	writeByte(digit1,n % 10);	writeByte(digit2,n / 10);	writeByte(digit5, DASH);}

 void LCD4884::writeChar(unsigned char c, char mode) {   unsigned char line;   unsigned char *pFont;   byte ch;      pFont = (unsigned char*) font6_8;   c -= 32;      for(line = 0; line < 6; line++)   {     ch = pgm_read_byte(pFont + c * 6 + line);     writeByte( (mode==MENU_NORMAL) ? ch : (ch ^ 0xff), 1);   } }

voidEnc28J60Network::memblock_mv_cb(uint16_t dest, uint16_t src, uint16_t len){  //as ENC28J60 DMA is unable to copy single bytes:  if (len == 1)    {      writeByte(dest,readByte(src));    }  else    {      // calculate address of last byte      len += src - 1;      /*  1. Appropriately program the EDMAST, EDMAND       and EDMADST register pairs. The EDMAST       registers should point to the first byte to copy       from, the EDMAND registers should point to the       last byte to copy and the EDMADST registers       should point to the first byte in the destination       range. The destination range will always be       linear, never wrapping at any values except from       8191 to 0 (the 8-Kbyte memory boundary).       Extreme care should be taken when       programming the start and end pointers to       prevent a never ending DMA operation which       would overwrite the entire 8-Kbyte buffer.       */      writeRegPair(EDMASTL, src);      writeRegPair(EDMADSTL, dest);      if ((src <= RXSTOP_INIT)&& (len > RXSTOP_INIT))len -= (RXSTOP_INIT-RXSTART_INIT);      writeRegPair(EDMANDL, len);      /*       2. If an interrupt at the end of the copy process is       desired, set EIE.DMAIE and EIE.INTIE and       clear EIR.DMAIF.       3. Verify that ECON1.CSUMEN is clear. */      writeOp(ENC28J60_BIT_FIELD_CLR, ECON1, ECON1_CSUMEN);      /* 4. Start the DMA copy by setting ECON1.DMAST. */      writeOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_DMAST);      // wait until runnig DMA is completed      while (readOp(ENC28J60_READ_CTRL_REG, ECON1) & ECON1_DMAST);    }}

uint8_t initMPU(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t source){	uint8_t b = 0;	readByte(devAddr, regAddr, &b);	msDelay(2);	uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);	source <<= (bitStart - length + 1);	// shift data into correct position	source &= mask;	// zero all non-important bits in data	b &= ~(mask); // zero all important bits in existing byte	b |= source; // combine data with existing byte	writeByte(devAddr, regAddr, b);	return b;}

void OutBuffer::writenl(){#if _WIN32#if M_UNICODE    write4(0x000A000D);         // newline is CR,LF on Microsoft OS's#else    writeword(0x0A0D);          // newline is CR,LF on Microsoft OS's#endif#else#if M_UNICODE    writeword('/n');#else    writeByte('/n');#endif#endif}

boolean SFE_TSL2561::setInterruptControl(unsigned char control, unsigned char persist)// Sets up interrupt operations// If control = 0, interrupt output disabled// If control = 1, use level interrupt, see setInterruptThreshold()// If persist = 0, every integration cycle generates an interrupt// If persist = 1, any value outside of threshold generates an interrupt// If persist = 2 to 15, value must be outside of threshold for 2 to 15 integration cycles// Returns true (1) if successful, false (0) if there was an I2C error// (Also see getError() below){    // Place control and persist bits into proper location in interrupt control register    if (writeByte(TSL2561_REG_INTCTL,((control | 0B00000011) << 4) & (persist | 0B00001111)))        return(true);    return(false);}

/** send instruction packet */void AX12::sendPacket (byte _id, byte datalength, byte instruction, byte* data) {    byte checksum = 0;    writeByte (0xFF);    writeByte (0xFF);    checksum += writeByte (_id);    checksum += writeByte (datalength + 2);    checksum += writeByte (instruction);    for (byte f=0; f<datalength; f++) {     // data = parámetros      checksum += writeByte (data[f]);    }    // checksum =    writeByte (~checksum);    serialHandle->listen();}

bool EEPROMClassEx::updateBit(int address, uint8_t bit, bool value) {	  if (bit> 7) return false; 	  	  byte byteValInput  = readByte(address);	  byte byteValOutput = byteValInput;	  	  // Set bit	  if (value) {	    		byteValOutput |= (1 << bit);  //Set bit to 1	  } else {			    byteValOutput &= !(1 << bit); //Set bit to 0	  }	  // Store if different from input	  if (byteValOutput!=byteValInput) {		writeByte(address, byteValOutput);	  	  }}

/**** Function: setHeaterState(byte state)* Description: Set heater state* Params: state - Heater state setting* Returns: 0 if state was successfully written, 1 if not***/byte Si7020::setHeaterState(byte state){	byte result = 0;	byte regValue = 0;		result = readByte(SI7020_CMD_WRITE_RHT_USER_REG, &regValue);		if (result == 0)	{		regValue &= (~SI7020_HEATER_MASK); // Clear resolution bits		regValue |= (state & SI7020_HEATER_MASK); // Set new resolution bits				result = writeByte(SI7020_CMD_WRITE_RHT_USER_REG, regValue); // Write new value to register	}		return result;}

/** Read 64 bit unique ROM code. * * @return 0 if no timeout has occured. */int DS18B20::readROM(){  int result = reset();  if (0 == result)  {    writeByte(0x33); // Read ROM    // read 64 bit unique code    for (unsigned int i = 0; i < 8; i++)    {      _romCode[i] = readByte();    }  }  return result;}

bool I2CSingleByteMasterPollingFeature::setBits(uint8_t address,uint8_t mask) const {    uint8_t value;    // read current register value    if(!readByte(address,value))        return false;    // set the bits    value|=mask;    // write back to the register    return writeByte(address,value);}

uint32_t TBinaryProtocol::writeMessageBegin(const std::string& name,                                            const TMessageType messageType,                                            const int32_t seqid) {  if (strict_write_) {    int32_t version = (VERSION_1) | ((int32_t)messageType);    uint32_t wsize = 0;    wsize += writeI32(version);    wsize += writeString(name);    wsize += writeI32(seqid);    return wsize;  } else {    uint32_t wsize = 0;    wsize += writeString(name);    wsize += writeByte((int8_t)messageType);    wsize += writeI32(seqid);    return wsize;  }}

	void Buffer::write16(uint16_t value)	{		if (position % 8)		{			if (position + 16 > size * 8)			{				data = (char*)realloc(data, bytes(position + 16));				size = bytes(position + 16);			}			writeByte(value >> 8);			position += 8;			writeByte(value & 0xFF);			position += 8;		}		else		{			// We are on an even position			if (position / 8 + 2 > size)