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

uint8_tshiftIn::read() {	int8_t i;	uint8_t data = 0;	if ( m_order == MSBFIRST ) {		for ( i = 7; i >= 0; --i ) {			// Read the data to the input pin			data |= ( (uint8_t) m_gpio->read( m_pins[ DATA_PIN ] ) ) << i;			// Toggle the clock			strobe();		}	} else {		for ( i = 0; i < 8; ++i ) {			// Read the data to the input pin			data |= ( (uint8_t) m_gpio->read( m_pins[ DATA_PIN ] ) ) << i;			// Toggle the clock			strobe();		}	}	return data;}

/* *  Send RF packet */void CC1101_Radio::sendPacket( uint8_t type, uint8_t addr = 0, uint8_t* payload = 0, uint8_t payload_length = 0 ){	uint8_t buffer[61];	uint16_t delay;	for ( uint8_t i = 0; i < 61; i++ )		buffer[i] = 0;	buffer[0] = payload_length + 2;	buffer[1] = addr;	buffer[2] = type;	for ( uint8_t j = 0; j < payload_length; j++ )		buffer[j + 3] = payload[j];	strobe( CC1101_SIDLE ); // Set radio idle	strobe( CC1101_SFTX );  // Flush the TXFIFO	for ( delay = 0; delay <= 10000; delay++ );	// Write the data into the TXFIFO	multi_register_access( CC1101_TXFIFO, CC1101_WRITE_BURST, ( uint8_t* )buffer, payload_length + 3 );	for ( delay = 0; delay <= 10000; delay++ );	strobe( CC1101_STX );   // Set radio to transmit}

/*---------------------------------------------------------------------------*/static voidcheck_txfifo(void){  uint8_t b;  b = txbytes();  if((b & 0x80) != 0 ||    state() == CC1101_STATUS_STATE_TXFIFO_UNDERFLOW) {    /* Acknowledge TX FIFO underflow. */    strobe(CC1101_SFTX);    strobe(CC1101_SRX);  }}

int CC1101::recv(uint8_t& src, uint8_t& port, void* buf, size_t len, uint32_t ms){  // Check if we need to wait for a message  uint8_t size;  if (!m_avail) {    // Fix: Use wakeup on radio to reduce power during wait    uint32_t start = RTC::millis();    if (read_status().mode == IDLE_MODE) {      strobe(SFRX);      strobe(SRX);    }    do {      while (!m_avail && ((ms == 0) || (RTC::since(start) < ms))) yield();      if (!m_avail) return (-2);      spi.begin(this);      loop_until_bit_is_clear(PIN, Board::MISO);      size = read(RXBYTES);      spi.end();    } while ((size & RXBYTES) == 0);  }  m_avail = false;  // Read the payload size and check against buffer length  spi.begin(this);  loop_until_bit_is_clear(PIN, Board::MISO);  size = read(RXFIFO) - 3;  if (size > len) {    spi.end();    strobe(SIDLE);    strobe(SFRX);    return (-1);  }  // Read the frame (dest, src, payload)  m_dest = read(RXFIFO);  src = read(RXFIFO);  port = read(RXFIFO);  read(RXFIFO, buf, size);  spi.end();  // Read the link quality status  spi.begin(this);  loop_until_bit_is_clear(PIN, Board::MISO);  read(RXFIFO, &m_recv_status, sizeof(m_recv_status));  spi.end();  // Fix: Add possible address checking for robustness  return (size);}

/*---------------------------------------------------------------------------*/static voidflushrx(void){  restart_input();  LOCK_SPI();  if(state() == CC1101_STATE_RXFIFO_OVERFLOW) {    strobe(CC1101_SFRX);  }  strobe(CC1101_SIDLE);  BUSYWAIT_UNTIL((state() == CC1101_STATE_IDLE), RTIMER_SECOND / 10);  strobe(CC1101_SFRX);  strobe(CC1101_SRX);  RELEASE_SPI();}

/*---------------------------------------------------------------------------*/static intcc2520_prepare(const void *payload, unsigned short payload_len){  uint8_t total_len;  GET_LOCK();  PRINTF("cc2520: sending %d bytes/n", payload_len);  /*int i;  for(i = 0; i < payload_len;i++)	  printf("%x",((uint8_t *) payload)[i]);  printf("/n");*/  RIMESTATS_ADD(lltx);  /* Wait for any previous transmission to finish. */  /*  while(status() & BV(CC2520_TX_ACTIVE));*/  /* Write packet to TX FIFO. */  strobe(CC2520_INS_SFLUSHTX);  total_len = payload_len + FOOTER_LEN;  CC2520_WRITE_FIFO_BUF(&total_len, 1);  CC2520_WRITE_FIFO_BUF(payload, payload_len);  RELEASE_LOCK();  return 0;}

/*---------------------------------------------------------------------------*/static intcc2420_prepare(const void *payload, unsigned short payload_len){  uint8_t total_len;#if CC2420_CONF_CHECKSUM  uint16_t checksum;#endif /* CC2420_CONF_CHECKSUM */  GET_LOCK();  PRINTF("cc2420: sending %d bytes/n", payload_len);  RIMESTATS_ADD(lltx);  /* Wait for any previous transmission to finish. */  /*  while(status() & BV(CC2420_TX_ACTIVE));*/  /* Write packet to TX FIFO. */  strobe(CC2420_SFLUSHTX);#if CC2420_CONF_CHECKSUM  checksum = crc16_data(payload, payload_len, 0);#endif /* CC2420_CONF_CHECKSUM */  total_len = payload_len + AUX_LEN;  CC2420_WRITE_FIFO_BUF(&total_len, 1);  CC2420_WRITE_FIFO_BUF(payload, payload_len);#if CC2420_CONF_CHECKSUM  CC2420_WRITE_FIFO_BUF(&checksum, CHECKSUM_LEN);#endif /* CC2420_CONF_CHECKSUM */  RELEASE_LOCK();  return 0;}

/*---------------------------------------------------------------------------*/intcc2520_set_channel(int c){  uint16_t f;  GET_LOCK();  /*   * Subtract the base channel (11), multiply by 5, which is the   * channel spacing. 357 is 2405-2048 and 0x4000 is LOCK_THR = 1.   */  channel = c;  f = MIN_CHANNEL + ((channel - MIN_CHANNEL) * CHANNEL_SPACING);  /*   * Writing RAM requires crystal oscillator to be stable.   */  BUSYWAIT_UNTIL((status() & (BV(CC2520_XOSC16M_STABLE))), RTIMER_SECOND / 10);  /* Wait for any transmission to end. */  BUSYWAIT_UNTIL(!(status() & BV(CC2520_TX_ACTIVE)), RTIMER_SECOND / 10);  /* Define radio channel (between 11 and 25) */  setreg(CC2520_FREQCTRL, f);  /* If we are in receive mode, we issue an SRXON command to ensure     that the VCO is calibrated. */  if(receive_on) {    strobe(CC2520_INS_SRXON);  }  RELEASE_LOCK();  return 1;}

boolCC1101::begin(const void* config){  // Reset the device  m_cs.pulse(30);  DELAY(30);  strobe(SRES);  DELAY(300);  // Upload the configuration. Check for default configuration  spi.begin(this);  loop_until_bit_is_clear(PIN, Board::MISO);  write_P(IOCFG2, 	  config ? (const uint8_t*) config : CC1101::config, 	  CONFIG_MAX);  spi.end();  // Adjust configuration with instance specific state  uint16_t sync = hton(m_addr.network);  spi.begin(this);  loop_until_bit_is_clear(PIN, Board::MISO);  write(PATABLE, 0x60);  write(CHANNR, m_channel);  write(ADDR, m_addr.device);  write(SYNC1, &sync, sizeof(sync));  spi.end();  // Initiate device driver state and enable interrupt handler  m_avail = false;  spi.attach(this);  m_irq.enable();  return (true);}

int CC1101::send(uint8_t dest, uint8_t port, const iovec_t* vec){  // Sanity check the payload size  if (vec == NULL) return (-1);  size_t len = iovec_size(vec);  if (len > PAYLOAD_MAX) return (-1);  // Wait for the device to become idle before writing the frame  await(IDLE_MODE);  // Write frame header(length, dest, src, port)  spi.begin(this);  loop_until_bit_is_clear(PIN, Board::MISO);  write(TXFIFO, len + 3);  write(TXFIFO, dest);  write(TXFIFO, m_addr.device);  write(TXFIFO, port);  spi.end();  // Write frame payload  for (const iovec_t* vp = vec; vp->buf != NULL; vp++) {    spi.begin(this);    loop_until_bit_is_clear(PIN, Board::MISO);    write(TXFIFO, vp->buf, vp->size);    spi.end();  }  // Trigger the transmit  strobe(STX);  return (len);}

int phandler(){   int status; int c;   struct para *p = &printer;   printf("printer interrupt!/n");   status = in_byte(p->port+1);   if (status & 0x08){                // test for noERROR only      if (p->room.value == PLEN){     // pbuf[] empty, nothing to print 	 //out_byte(p->port+2, 0x0C); // turn off printer interrupts         V(&p->done);                 // tell task print is DONE         p->printing = 0;             // is no longer printing         goto out;      }      // p->pbuf[] not empty ==> print next char      c = p->pbuf[p->tail++] & 0x7F;      p->tail %= PLEN;      out_byte(p->port, c);          // print the char      strobe(p);      V(&p->room);                         goto out;   }   // abnormal printer status: should handle it but ignored hereout:   out_byte(0x20, 0x20);             // re-enable the 8259}

static void sendData (const int data, const int chip){  digitalWrite     (chip, 0) ;  digitalWriteByte (data) ;  strobe           () ;  digitalWrite     (chip, 1) ;}

static intdeep_sleep(void){  strobe(CC2420_SXOSCOFF);  completely_off = 1;  return 1;}

SinkComponent::SinkComponent(QWidget *parent) :    QWidget(parent),    ui(new Ui::SinkComponent),    alarm(this),    count(0){    ui->setupUi(this);    ui->comboBox->addItem("Seconds", QVariant(1));    ui->comboBox->addItem("Minutes", QVariant(60));    ui->buttonStart->setIcon(QIcon::fromTheme("media-playback-start"));    setEveryLabel(ui->spinAmount->value());    setDurationLabel(ui->spinSeconds->value());    label_count = new QLabel();    label_prompt = new QLabel();    ui->statusBar->addWidget(label_prompt);    ui->statusBar->addWidget(label_count);    connect(ui->spinAmount, SIGNAL(valueChanged(int)), ui->dialAmount, SLOT(setValue(int)));    connect(ui->spinSeconds, SIGNAL(valueChanged(int)), ui->dialSeconds, SLOT(setValue(int)));    connect(ui->dialAmount, SIGNAL(valueChanged(int)), ui->spinAmount, SLOT(setValue(int)));    connect(ui->dialSeconds, SIGNAL(valueChanged(int)), ui->spinSeconds, SLOT(setValue(int)));    connect(ui->spinAmount, SIGNAL(valueChanged(int)), this, SLOT(setEveryLabel(int)));    connect(ui->spinSeconds, SIGNAL(valueChanged(int)), this, SLOT(setDurationLabel(int)));    connect(ui->buttonStart, SIGNAL(toggled(bool)), this, SLOT(buttonToggled(bool)));    connect(&alarm, SIGNAL(timeout()), this, SLOT(strobe()));    connect(ui->comboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(resetTimer()));}

/*---------------------------------------------------------------------------*/intcc2420_set_channel(int c){  uint16_t f;  GET_LOCK();  /*   * Subtract the base channel (11), multiply by 5, which is the   * channel spacing. 357 is 2405-2048 and 0x4000 is LOCK_THR = 1.   */  channel = c;  f = 5 * (c - 11) + 357 + 0x4000;  /*   * Writing RAM requires crystal oscillator to be stable.   */  BUSYWAIT_UNTIL((status() & (BV(CC2420_XOSC16M_STABLE))), RTIMER_SECOND / 10);  /* Wait for any transmission to end. */  BUSYWAIT_UNTIL(!(status() & BV(CC2420_TX_ACTIVE)), RTIMER_SECOND / 10);  setreg(CC2420_FSCTRL, f);  /* If we are in receive mode, we issue an SRXON command to ensure     that the VCO is calibrated. */  if(receive_on) {    strobe(CC2420_SRXON);  }  RELEASE_LOCK();  return 1;}

uint8_t NESpad_Buttons(NESpad *pad){  strobe(pad);  digitalWrite(pad->m_clock,LOW);  byte ret = digitalRead(pad->m_data)     | (shiftIn(pad->m_data, pad->m_clock, LSBFIRST) << 1);  return ~ret;}

/*---------------------------------------------------------------------------*/intcc2420_init(void){  uint16_t reg;  {    int s = splhigh();    cc2420_arch_init();		/* Initalize ports and SPI. */    DISABLE_FIFOP_INT();    FIFOP_INT_INIT();    splx(s);  }  /* Turn on voltage regulator and reset. */  SET_VREG_ACTIVE();  //clock_delay(250); OK  SET_RESET_ACTIVE();  clock_delay(127);  SET_RESET_INACTIVE();  //clock_delay(125); OK  /* Turn on the crystal oscillator. */  strobe(CC2420_SXOSCON);  /* Turn on/off automatic packet acknowledgment and address decoding. */  reg = getreg(CC2420_MDMCTRL0);  reg |= 0x40; /* XXX CCA mode 1 */  #if CC2420_CONF_AUTOACK  reg |= AUTOACK | ADR_DECODE;#else  reg &= ~(AUTOACK | ADR_DECODE);#endif /* CC2420_CONF_AUTOACK */  setreg(CC2420_MDMCTRL0, reg);  /* Change default values as recomended in the data sheet, */  /* correlation threshold = 20, RX bandpass filter = 1.3uA. */  setreg(CC2420_MDMCTRL1, CORR_THR(20));  reg = getreg(CC2420_RXCTRL1);  reg |= RXBPF_LOCUR;  setreg(CC2420_RXCTRL1, reg);  /* Set the FIFOP threshold to maximum. */  setreg(CC2420_IOCFG0, FIFOP_THR(127));  /* Turn off "Security enable" (page 32). */  reg = getreg(CC2420_SECCTRL0);  reg &= ~RXFIFO_PROTECTION;  setreg(CC2420_SECCTRL0, reg);  cc2420_set_pan_addr(0xffff, 0x0000, NULL);  cc2420_set_channel(26);  process_start(&cc2420_process, NULL);  return 1;}

byte NESpad::buttons(void){  byte ret = 0;  byte i;  strobe();  for (i = 0; i < 8; i++) {    ret |= shiftin() << i;  }  return ~ret;}

int SNESpad::buttons(void){  int ret = 0;  byte i;  strobe();  for (i = 0; i < 16; i++) {    ret |= shiftin() << i;  }  return ~ret;}

static voidon(void){  ENERGEST_ON(ENERGEST_TYPE_LISTEN);  PRINTF("on/n");  receive_on = 1;  ENABLE_FIFOP_INT();  strobe(CC2420_SRXON);  flushrx();}

static voidon(void){  CC2520_ENABLE_FIFOP_INT();  strobe(CC2520_INS_SRXON);  BUSYWAIT_UNTIL(status() & (BV(CC2520_XOSC16M_STABLE)), RTIMER_SECOND / 100);  ENERGEST_ON(ENERGEST_TYPE_LISTEN);  receive_on = 1;}

int nRF24L01::reset(){    flushTx();    flushRx();    uint8_t status1 = strobe(NRF24L01_FF_NOP);    uint8_t status2 = readReg(NRF24L01_07_STATUS);    setTxRxMode(TXRX_OFF);#ifdef EMULATOR    return 1;#endif    return (status1 == status2 && (status1 & 0x0f) == 0x0e);}

/*---------------------------------------------------------------------------*/voidcc2420_ugly_hack_send_only_one_symbol(void){  uint8_t len;  GET_LOCK();  /* Write packet to TX FIFO. */  strobe(CC2420_SFLUSHTX);  len = 1;  FASTSPI_WRITE_FIFO(&len, 1);  FASTSPI_WRITE_FIFO(&len, 1);  strobe(CC2420_STXON);  while(!SFD_IS_1);  /* Turn radio off immediately after sending the first symbol. */  strobe(CC2420_SRFOFF);  RELEASE_LOCK();  return;}

// ----------------------------------------------------------------------------//void DefinitionWriter::visit( Channel* channel ){    TiXmlElement channel_element( "channel" );    add_attribute( channel_element, "index", (DWORD)channel->m_channel_offset );    add_attribute( channel_element, "type", (LPCSTR)channel->convertChannelTypeToText( channel->m_type ) );    add_attribute( channel_element, "color", channel->isColor() );    add_attribute( channel_element, "blackout", channel->canBlackout() );    if ( channel->m_default_value )        add_attribute( channel_element, "value", channel->m_default_value );    if ( channel->m_pixel_index )        add_attribute( channel_element, "pixel", channel->m_pixel_index );    if ( channel->m_home_value )        add_attribute( channel_element, "home_value", channel->m_home_value );    if ( channel->m_head_number )        add_attribute( channel_element, "head", channel->m_head_number );    // Add dimmer    if ( channel->isDimmer() ) {        TiXmlElement dimmer( "dimmer" );        add_attribute( dimmer, "strobe", channel->m_dimmer_can_strobe );        add_attribute( dimmer, "lowest_intensity", channel->m_lowest_intensity );        add_attribute( dimmer, "highest_intensity", channel->m_highest_intensity );        add_attribute( dimmer, "off_intensity", channel->m_off_intensity );        channel_element.InsertEndChild( dimmer );    }	// Add strobe	if ( channel->isStrobe() ) {		TiXmlElement strobe( "strobe" );		add_attribute( strobe, "speed_slow", channel->m_strobe_slow );		add_attribute( strobe, "speed_fast", channel->m_strobe_fast );		add_attribute( strobe, "off", channel->m_strobe_off );	}    add_text_element( channel_element, "name", channel->m_name );    if ( channel->m_ranges.size() > 0 && channel->m_type != CHNLT_PAN && channel->m_type != CHNLT_TILT ) {        TiXmlElement ranges( "ranges" );        visit_array<ChannelValueRangeArray>( ranges, channel->m_ranges );        channel_element.InsertEndChild( ranges );    }    if ( channel->m_angles.size() > 0 ) {        TiXmlElement angles( "angles" );        visit_array<ChannelAngleArray>( angles, channel->m_angles );        channel_element.InsertEndChild( angles );    }    getParent().InsertEndChild( channel_element );}

static voidoff(void){  PRINTF("off/n");  receive_on = 0;    /* Wait for transmission to end before turning radio off. */  while(status() & BV(CC2420_TX_ACTIVE));    strobe(CC2420_SRFOFF);  DISABLE_FIFOP_INT();  ENERGEST_OFF(ENERGEST_TYPE_LISTEN);}

void SinkComponent::resetTimer(){    this->alarm.stop();    int row = ui->comboBox->currentIndex();    if (row < 0)        row = 0;    int secs = ui->comboBox->itemData(row).toInt();    secs *= ui->spinSeconds->value();    // fire timer handler immediately    strobe();    // also set timer to fire the handler every second    alarm.start(secs * 1000);}

void SHT1x::connection_reset(void){    int i;    pinMode(_data,OUTPUT);    pinMode(_sck,OUTPUT);    digitalWrite(_data,HIGH);    digitalWrite(_sck,LOW);    for (i=0; i<9; i++)    {        strobe();    }    start_sequence();}

static voidon(void){  if(completely_off) {    completely_off = 0;    powerup();    configure();  }  CC2420_ENABLE_FIFOP_INT();  strobe(CC2420_SRXON);  BUSYWAIT_UNTIL(status() & (BV(CC2420_XOSC16M_STABLE)), RTIMER_SECOND / 100);  ENERGEST_ON(ENERGEST_TYPE_LISTEN);  receive_on = 1;}