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

u8 NFC_Module::InListPassiveTarget(u8 *buf, u8 brty,                                   u8 len, u8 *idata, u8 maxtg){    nfc_buf[0] = PN532_COMMAND_INLISTPASSIVETARGET;    nfc_buf[1] = maxtg;    nfc_buf[2] = brty;    if(len){        memcpy(nfc_buf+3, idata, len);    }    if(!write_cmd_check_ack(nfc_buf, 3+len)){        return 0;    }#ifdef PN532DEBUG    puthex(nfc_buf, 3+len);    Serial.println();#endif//	puthex(nfc_buf, 3+len);//    Serial.println();	    /** "Waiting for IRQ (indicates card presence)" */    wait_ready();	wait_ready();	wait_ready();#ifdef PN532DEBUG	Serial.print(" Found Card./n");#endif    read_dt(nfc_buf,40);//	puthex(nfc_buf, nfc_buf[3]+6);//    Serial.println();    if(nfc_buf[NFC_FRAME_ID_INDEX-1] != 0xD5){        return 0;    }	    puthex(nfc_buf, nfc_buf[3]+6);    Serial.println();    if(nfc_buf[NFC_FRAME_ID_INDEX] != (PN532_COMMAND_INLISTPASSIVETARGET+1)){        return 0;    }//    if(nfc_buf[NFC_FRAME_ID_INDEX+1]!=1){//#ifdef PN532DEBUG//        Serial.println(nfc_buf[NFC_FRAME_ID_INDEX+1],DEC);//#endif//        return 0;//    }    if(brty == PN532_BRTY_ISO14443A){        /** UUID length */        buf[0] = nfc_buf[12];        for(u8 i=1; i<5; i++){            buf[i] = nfc_buf[12+i];        }    }else{        buf[0] = nfc_buf[3];        memcpy(buf, nfc_buf+5, nfc_buf[3]);    }    return 1;}

u8 NFC_Module::P2PInitiatorTxRx(u8 *t_buf, u8 t_len, u8 *r_buf, u8 *r_len){//    wait_ready();//    wait_ready();    wait_ready(15);    nfc_buf[0] = PN532_COMMAND_INDATAEXCHANGE;    nfc_buf[1] = 0x01; // logical number of the relevant target    memcpy(nfc_buf+2, t_buf, t_len);    if(!write_cmd_check_ack(nfc_buf, t_len+2)){        return 0;    }#ifdef PN532_P2P_DEBUG    Serial.println("Initiator DataExchange sent.");#endif    wait_ready(200);    read_dt(nfc_buf, 60);    if(nfc_buf[5] != 0xD5){        return 0;    }#ifdef PN532_P2P_DEBUG    Serial.println("Initiator DataExchange Get.");#endif    if(nfc_buf[NFC_FRAME_ID_INDEX] != (PN532_COMMAND_INDATAEXCHANGE+1)){#ifdef PN532_P2P_DEBUG        puthex(nfc_buf, nfc_buf[3]+7);        Serial.println("Send data failed");#endif        return 0;    }    if(nfc_buf[NFC_FRAME_ID_INDEX+1]){#ifdef PN532_P2P_DEBUG        Serial.print("InExchangeData Error:");        puthex(nfc_buf, nfc_buf[3]+7);        Serial.println();#endif        return 0;    }#ifdef PN532_P2P_DEBUG    puthex(nfc_buf, nfc_buf[3]+7);    Serial.println();#endif    /** return read data */    *r_len = nfc_buf[3]-3;    memcpy(r_buf, nfc_buf+8, *r_len);    return 1;}

void freq_scan(int mode, int forced_mono){	double freq = 87.5;	unsigned char stereo, level_adc;	int count = 0;	struct _radio_station {		double freq;		unsigned char stereo;	} radio_station[MAX_STATION];	set_freq(freq, HCC_DEFAULT, SNC_DEFAULT, forced_mono, 1, 0);	wait_ready();	do {		if (search(1, mode, forced_mono)) break;		get_status(&freq, &stereo, &level_adc);		if (freq >= 108.0) break;		radio_station[count].freq = freq;		radio_station[count].stereo = stereo;		printf("%2d : %3.1f MHz %s /tSignal Strength:%d/15/n", count + 1, freq, stereo ? "stereo" : "mono", level_adc);		count++;	} while(freq < 108.0 && count < MAX_STATION);	printf("Total %d radio stations/n", count);	if (count > 0)		set_freq(radio_station[0].freq, HCC_DEFAULT, SNC_DEFAULT, forced_mono, 0, 0);}

void set_freq(double freq, int hcc, int snc, unsigned char forcd_mono, int mute, int standby){	unsigned char radio[5] = {0};	frequencyB = 4 * (freq * 1000000 + 225000) / 32768; //calculating PLL word	frequencyH = frequencyB >> 8;	frequencyL = frequencyB & 0xFF;	radio[0] = frequencyH; //FREQUENCY H	if (mute) radio[0] |= 0x80;	radio[1] = frequencyL; //FREQUENCY L	radio[2] = 0xB0; //3 byte (0xB0): high side LO injection is on,.	if (forcd_mono) radio[2] |= 0x08;	radio[3] = 0x10; // Xtal is 32.768 kHz	if (freq < 87.5) radio[3] |= 0x20;	if (hcc) radio[3] |= 0x04;	if (snc) radio[3] |= 0x02;	if (standby) radio[3] |= 0x40;	radio[4] = 0x40; // deemphasis is 75us in Korea and US	write(fd, radio, 5);	if (standby) return;	save_freq(freq);	if (wait_ready() < 0) {		fprintf(stderr, "Fail to tune!/n");		return;	}}

bool flush_cache (ata_probe_type *ata_probe){//  select_device (ata_probe);    system_port_out_u8 (ATA_COMMAND_REGISTER(ata_probe->base_port),                      ATA_COMMAND_FLUSH_CACHE);  return wait_ready (ata_probe, ATA_STATE_BUSY);}

/*---------------------------------------------------------------------------*/intxmem_pread(void *_p, int size, unsigned long offset){  unsigned char *p = _p;  const unsigned char *end = p + size;  int s;  wait_ready();  ENERGEST_ON(ENERGEST_TYPE_FLASH_READ);  s = splhigh();  SPI_FLASH_ENABLE();  spi_tx(SPI_FLASH_INS_READ);  spi_tx(offset >> 16);	/* MSB */  spi_tx(offset >> 8);  spi_tx(offset >> 0);	/* LSB */    FASTSPI_CLEAR_RX();  for(; p < end; p++) {    unsigned char u;    FASTSPI_RX(u);    *p = ~u;  }  SPI_FLASH_DISABLE();  splx(s);  ENERGEST_OFF(ENERGEST_TYPE_FLASH_READ);  return size;}

void middle_duty(){	if(mode==0)	{		wait_ready();	}else if(mode==7)	{		unlock();	}else if(mode==1)	{		take_off();	}else if(mode==2)	{		go();	}else if(mode==3)	{		throw_ball();	}else if(mode==4)	{		back();	}else if(mode==5)	{		drop();	}	else if(mode==6)	{		lock();	}	ready_3++;}

staticBOOL xmit_datablock (	uchar *buff,	/* 512 byte data block to be transmitted */	uchar token			/* Data/Stop token */){	uchar resp, wc;	ushort crc;	if (wait_ready() != 0xFF) return FALSE;	spi_w(token);					/* Xmit data token */	if (token != 0xFD) {	/* Is data token */		crc = crc16(buff, 512);	// calc CRC16		wc = 0;		do {							/* Xmit the 512 byte data block to MMC */			spi_w(*buff++);			spi_w(*buff++);		} while (--wc);		spi_w((uchar)(crc >> 8));	// put CRC16 high		spi_w((uchar)crc);		// put CRC16 low		resp = spi_r();				/* Reveive data response */		if ((resp & 0x1F) != 0x05)		/* If not accepted, return with error */			return FALSE;	}

u8 NFC_Module::MifareWriteBlock(u8 block, u8 *buf){    nfc_buf[0] = PN532_COMMAND_INDATAEXCHANGE;    nfc_buf[1] = 1; // logical number of the relevant target    nfc_buf[2] = MIFARE_CMD_WRITE;    nfc_buf[3] = block;    memcpy(nfc_buf+4, buf, 16);    if(!write_cmd_check_ack(nfc_buf, 20)){        return 0;    }    wait_ready();    read_dt(nfc_buf, 26);    if(nfc_buf[NFC_FRAME_ID_INDEX] != (PN532_COMMAND_INDATAEXCHANGE+1)){#ifdef PN532DEBUG        puthex(nfc_buf, 20);        Serial.println("Authentication fail.");#endif        return 0;    }    if(nfc_buf[NFC_FRAME_ID_INDEX+1]){        return 0;    }    return 1;}

int nand_write(unsigned int nand_start, unsigned char * buf, unsigned int len){	unsigned long count = 0;	unsigned long addr  = nand_start;	int i = nand_start % 2048;		nand_select();	while (count < len)	{		nand_cmd(0x80);		nand_send_addr(addr);		for (; i < 2048 && count < len; i++)		{			nand_send_data(buf[count++]);			addr++;		}		nand_cmd(0x10);		wait_ready();		i = 0;			}	nand_deselect();	}

void lcdData(unsigned char cmd){    wait_ready();    CMD_RS1(); // data    lcdWriteData(cmd);    pulse_e();}

/*---------------------------------------------------------------------------*/static const char *program_page(unsigned long offset, const unsigned char *p, int nbytes){  const unsigned char *end = p + nbytes;  int s;  wait_ready();  write_enable();  s = splhigh();  SPI_FLASH_ENABLE();    spi_tx(SPI_FLASH_INS_PP);  spi_tx(offset >> 16);	/* MSB */  spi_tx(offset >> 8);  spi_tx(offset >> 0);	/* LSB */  for(; p < end; p++) {    spi_tx(~*p);  }  SPI_FLASH_DISABLE();  splx(s);  return p;}

bool DevSPIMem_AT::erase_chip(){  write_enable();  spi.send1b( Cmd::ER_C );  bool r = wait_ready();  return r;}

void lcdCmd(unsigned char cmd){    wait_ready();    CMD_RS0(); // controll command    lcdWriteData(cmd);    pulse_e();}

/*---------------------------------------------------------------------------*/intxmem_pread(void *_p, int size, unsigned long offset){  unsigned char *p = _p;  const unsigned char *end = p + size;  int s;  wait_ready();  ENERGEST_ON(ENERGEST_TYPE_FLASH_READ);  s = splhigh();  SPI_FLASH_ENABLE();  SPI_WRITE_FAST(SPI_FLASH_INS_READ);  SPI_WRITE_FAST(offset >> 16);	/* MSB */  SPI_WRITE_FAST(offset >> 8);  SPI_WRITE_FAST(offset >> 0);	/* LSB */  SPI_WAITFORTx_ENDED();    SPI_FLUSH();  for(; p < end; p++) {    unsigned char u;    SPI_READ(u);    *p = ~u;  }  SPI_FLASH_DISABLE();  splx(s);  ENERGEST_OFF(ENERGEST_TYPE_FLASH_READ);  return size;}

static int xmit_datablock (	/* 1:OK, 0:Failed */	const BYTE *buff,	/* Ponter to 512 byte data to be sent */	BYTE token			/* Token */){	BYTE resp;		printf("xmit_datablock: inside");	if (!wait_ready(500)) {		printf("xmit_datablock: not ready");		return 0;		/* Wait for card ready */	}	printf("xmit_datablock: ready");	TM_SPI_Send(FATFS_SPI, token);					/* Send token */	if (token != 0xFD) {				/* Send data if token is other than StopTran */		xmit_spi_multi(buff, 512);		/* Data */		TM_SPI_Send(FATFS_SPI, 0xFF); TM_SPI_Send(FATFS_SPI, 0xFF);	/* Dummy CRC */		resp = TM_SPI_Send(FATFS_SPI, 0xFF);				/* Receive data resp */		if ((resp & 0x1F) != 0x05)		/* Function fails if the data packet was not accepted */			return 0;	}	return 1;}

static void cmd_write_ip(const char *filename){	FILE *f;	// we need 512 bytes to InfoPage and 3 extra bytes to command	uint8_t buf[512 + 3] = {0};	if (check_rdismb()) {		fprintf(stderr, "flash memory is protected/n");		exit(EXIT_FAILURE);	}	buf[0] = PROGRAM;	buf[1] = 0x00; // address	buf[2] = 0x00;	f = fopen(filename, "r");	if (!f) {		fprintf(stderr, "can't open %s to read/n", filename);		exit(EXIT_FAILURE);	}	fread(buf + 3, sizeof(buf) - 3, 1, f);	fclose(f);	enable_infen();	enable_wen();	printf("writing InfoPage/n");	if (!spi_transfer(buf, sizeof(buf))) {		fprintf(stderr, "something wrong writing InfoPage/n");		exit(EXIT_FAILURE);	}	wait_ready();}

int xmit_datablock(const BYTE *buff, BYTE token){  BYTE resp;  UINT bc = 512;  if (wait_ready() != 0xFF)    return 0;  xfer_spi(token);	        /* Xmit a token */  if (token != 0xFD)  {                         /* Not StopTran token */    do    { /* Xmit the 512 byte data block to the MMC */      xfer_spi(*buff++);      xfer_spi(*buff++);    } while (bc -= 2);    xfer_spi(0xFF);  /* CRC (Dummy) */    xfer_spi(0xFF);    resp = xfer_spi(0xff);      /* Receive a data response */    if ((resp & 0x1F) != 0x05)  /* If not accepted, return with error */      return 0;  }  return 1;}

bool device_reset (ata_probe_type *ata_probe){//  select_device (ata_probe);    system_port_out_u8 (ATA_COMMAND_REGISTER(ata_probe->base_port),                      ATA_COMMAND_DEVICE_RESET);  return wait_ready (ata_probe, ATA_STATE_BUSY);}

bool check_power_mode (ata_probe_type *ata_probe){//  select_device (ata_probe);    system_port_out_u8 (ATA_COMMAND_REGISTER(ata_probe->base_port),                      ATA_COMMAND_CHECK_POWER_MODE);  return wait_ready (ata_probe, ATA_STATE_BUSY);}

bool get_media_status (ata_probe_type *ata_probe){//  select_device (ata_probe);    system_port_out_u8 (ATA_COMMAND_REGISTER(ata_probe->base_port),                      ATA_COMMAND_GET_MEDIA_STATUS);  return wait_ready (ata_probe, ATA_STATE_BUSY);}

staticvoid power_off (void){	SELECT();				/* Wait for card ready */	wait_ready();	DESELECT();	(void)spi_r();	Stat |= STA_NOINIT;		/* Set STA_NOINIT */}

static SANE_Statusget_image_status (Tamarack_Scanner *s){  uint8_t result[12];  SANE_Status status;  size_t len;  int busy;#if 1  do    {      len = sizeof (result);      status = sanei_scsi_cmd (s->fd, get_status, sizeof (get_status),			    result, &len);      if ((status != SANE_STATUS_GOOD) && (status != SANE_STATUS_DEVICE_BUSY))	return status;      busy = (result[2] != 8) || (status == SANE_STATUS_DEVICE_BUSY);      if (busy)	usleep (100000);      if (!s->scanning)	return do_cancel (s);    }  while (busy);#else  /* XXX Test if this works one day... */  wait_ready (s);#endif  len = sizeof (result);  status = sanei_scsi_cmd (s->fd, get_status, sizeof (get_status),			   result, &len);  if ((status != SANE_STATUS_GOOD) && (status != SANE_STATUS_DEVICE_BUSY))    return status;    s->params.bytes_per_line =     result[ 8] | (result[ 7] << 8) | (result[6] << 16);  s->params.lines =     result[11] | (result[10] << 8) | (result[9] << 16);  switch (s->mode) {  case DITHERED:  case THRESHOLDED:    s->params.pixels_per_line = 8 * s->params.bytes_per_line;    break;  case GREYSCALE:  case TRUECOLOR:    s->params.pixels_per_line =     s->params.bytes_per_line;    break;  }  DBG(1, "get_image_status: bytes_per_line=%d, lines=%d/n",      s->params.bytes_per_line, s->params.lines);  return SANE_STATUS_GOOD;}

static void cmd_write_flash(const char *filename){	FILE *fd;	// maximum hexfile data per line is 255, plus 3 bytes for cmd and addr	uint8_t buffer[255 + 3] = {0};	uint8_t orig[255 + 3] = {0};	uint8_t comp[255 + 3] = {0};	int count;	uint16_t address;	if (check_rdismb()) {		fprintf(stderr, "flash memory is protected/n");		exit(EXIT_FAILURE);	}	disable_infen();	fd = fopen(filename, "r");	if (!fd) {		fprintf(stderr, "can't open %s to read/n", filename);		exit(EXIT_FAILURE);	}	while ((count = hexfile_getline(fd, &address, buffer + 3,						sizeof(buffer) - 3)) > 0) {		enable_wen();		memcpy(orig, buffer + 3, count);		buffer[0] = PROGRAM;		buffer[1] = address >> 8;		buffer[2] = address & 0xff;		printf("writing %i bytes at 0x%04hx.../n", count, address);		if (!spi_transfer(buffer, count + 3)) {			fprintf(stderr, "SPI error/n");			fclose(fd);			exit(EXIT_FAILURE);		}		wait_ready();		comp[0] = READ;		comp[1] = address >> 8;		comp[2] = address & 0xff;		if (!spi_transfer(comp, count + 3)) {			fprintf(stderr, "SPI error/n");			fclose(fd);			exit(EXIT_FAILURE);		}		if (memcmp(orig, comp + 3, count)) {			fprintf(stderr, "error checking memory/n");			fclose(fd);			exit(EXIT_FAILURE);		}	}	fclose(fd);}

/**************************************************************************//** * @brief Select the card and wait ready * @return 1:Successful, 0:Timeout *****************************************************************************/int select(void){  CS_LOW();  if (wait_ready() != 0xFF)  {    deselect();    return 0;  }  return 1;}

static void power_off (void){	SELECT();				/* Wait for card ready */	wait_ready();	release_spi();	SSP2CON1bits.SSPEN = 0;				/* Disable SPI1 */	return;}