void SPI0_Handler(void) { uint16_t us_data; uint32_t us_tx_data; uint8_t p_pcs; uint32_t status = spi_read_status(_spi_base); if (status & SPI_SR_RDRF) { if ( spi_read( _spi_base, &us_data, &p_pcs ) == SPI_OK ) { // store received byte fifo_push_uint8(_this->_spi_rx_fifo_desc, us_data); // If handler defined - call it with instance and received byte. if (_this->_call_back) { _this->_call_back(_this, (uint8_t)us_data); } } } if (status & SPI_SR_TDRE) { // more bytes to send? if ( fifo_pull_uint32(_this->_spi_tx_fifo_desc, &us_tx_data) == FIFO_OK ) { _spi_base->SPI_TDR = us_tx_data; } else { // No // Disable SPI TX interrupt spi_disable_interrupt(_spi_base, SPI_IDR_TDRE); _spi_active = 0; } } }
void bfin_get_num_params(volatile u32* num) { u16 x; app_pause(); // command spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, MSG_GET_NUM_PARAMS_COM); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); print_dbg("\r\n : spi_write MSG_GET_NUM_PARAMS"); // read num spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); //dont care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); *num = (u8)(x & 0xff); print_dbg("\r\n : spi_read numparams: "); print_dbg_ulong(*num); app_resume(); }
uint8_t pfio_read_input(void) { // XOR by 0xFF so we get the right outputs. // before a turned off input would read as 1, // confusing developers. return spi_read(INPUT_PORT) ^ 0xFF; }
void platform_wifi_spi_rx_dma_irq(void) { uint8_t junk1; uint16_t junk2; pdc_packet_t pdc_spi_packet = { 0, 1 }; Pdc* spi_pdc = spi_get_pdc_base( wifi_spi.port ); uint32_t status = spi_read_status( wifi_spi.port ); uint32_t mask = spi_read_interrupt_mask( wifi_spi.port ); if ( ( mask & SPI_IMR_RXBUFF ) && ( status & SPI_SR_RXBUFF ) ) { pdc_disable_transfer( spi_pdc, PERIPH_PTCR_RXTDIS | PERIPH_PTCR_TXTDIS ); pdc_rx_init( spi_pdc, &pdc_spi_packet, NULL ); pdc_tx_init( spi_pdc, &pdc_spi_packet, NULL ); spi_disable_interrupt( wifi_spi.port, SPI_IER_RXBUFF ); } if ( ( mask & SPI_IMR_ENDTX ) && ( status & SPI_SR_ENDTX ) ) { pdc_disable_transfer( spi_pdc, PERIPH_PTCR_TXTDIS ); pdc_tx_init( spi_pdc, &pdc_spi_packet, NULL ); spi_disable_interrupt( wifi_spi.port, SPI_IER_ENDTX ); /* Clear SPI RX data in a SPI send sequence */ spi_read( wifi_spi.port, &junk2, &junk1); } mico_rtos_set_semaphore( &spi_transfer_finished_semaphore ); }
//芯片探测 int w25qxx_probe(void) { uint32_t i; uint16_t id; uint8_t buf[4]; buf[0] = W25X_ManufactDeviceID; buf[1] = 0; buf[2] = 0; buf[3] = 0; /* read id */ spi_write(&device, buf, 4, false); spi_read(&device, buf, 2, true); id = ((buf[0]<<8) + buf[1]); W25QXX_TRACE("ID:%d\r\n", id); //see if we find a match for(i = 0; i< ARRAY_SIZE(w25qxx_attr_table);i++) { if(w25qxx_attr_table[i].id == id) { // find a match w25qxx_type.name = w25qxx_attr_table[i].name; w25qxx_type.id = w25qxx_attr_table[i].id; w25qxx_type.size = w25qxx_attr_table[i].size; w25qxx_power_up(); buf[0] = w25qxx_read_sr(); W25QXX_TRACE("SR:0x%X\r\n", buf[0]); buf[0] = w25qxx_read_sr2(); W25QXX_TRACE("SR2:0x%X\r\n", buf[0]); // enable full access to all memory regin, something like unlock chip. w25qxx_write_sr(0x00); return SPI_EOK; } } return SPI_ERROR; }
/*----------------------------------------------------------------------*/ static void eeprom_get_status_reg(u8 *status) { spi_chip_select(ENABLE); spi_write(RDSR_CMD); *status = spi_read(); spi_chip_select(DISABLE); }
/*----------------------------------------------------------------------*/ unsigned char spi_eeprom_read(u16 address, u16 nbytes, u8 *dest) { u8 status; u16 cnt = 0; int i = 0; do { i++; eeprom_get_status_reg(&status); } while((status & (1<<RDY)) && (i < max_ee_busy_loop)); if (i == max_ee_busy_loop) return (status); /* eeprom ready */ if (!(status & (1<<RDY))) { spi_chip_select(ENABLE); /* read op */ spi_write(READ_CMD); spi_write((u8)(address >> 8)); /* MSB byte First */ spi_write((u8)(address & 0x00FF)); /* LSB byte */ while (cnt < nbytes) { *(dest++) = spi_read(); cnt++; } status = 0; /* deassert cs */ spi_chip_select(DISABLE); }
int main(void) { int counter = 0; uint16_t rx_value = 0x42; /* Setup Rx/Tx buffers for USART */ buffer_init(send_buffer,BUFFER_SIZE); buffer_init(receive_buffer,BUFFER_SIZE); clock_setup(); gpio_setup(); usart_setup(); usart_print_string("SPI-DMA Test\n\r"); spi_setup(); while (1) { gpio_toggle(GPIOA, GPIO1); #ifdef LOOPBACK /* Print what is going to be sent on the SPI bus */ usart_print_string("Sending packet "); usart_print_int(counter); usart_print_string("\n\r"); spi_send(SPI1, (uint8_t) counter); rx_value = spi_read(SPI1); usart_print_string("Received packet "); usart_print_int(rx_value); usart_print_string("\n\r"); counter++; #else /* This is a 1-byte "reset" command to SD card */ spi_send(SPI1, 0x40); spi_send(SPI1, 0x00); spi_send(SPI1, 0x00); spi_send(SPI1, 0x00); spi_send(SPI1, 0x00); spi_send(SPI1, 0x95); /* Read the byte that just came in (use a loopback between MISO and MOSI * to get the same byte back) */ rx_value = spi_read(SPI1); #endif } return 0; }
// get parameter value s32 bfin_get_param(u8 idx) { ParamValueCommon pval; u16 x; app_pause(); // command spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, MSG_GET_PARAM_COM); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); // idx spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, idx); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); /// read value spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); // don't care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pval.asByte[0] = (u8)x; spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); // don't care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pval.asByte[1] = (u8)x; spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); // don't care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pval.asByte[2] = (u8)x; spi_selectChip(BFIN_SPI, BFIN_SPI_NPCS); spi_write(BFIN_SPI, 0); // don't care spi_read(BFIN_SPI, &x); spi_unselectChip(BFIN_SPI, BFIN_SPI_NPCS); pval.asByte[3] = (u8)x; app_resume(); return pval.asInt; }
//芯片读 static uint8_t w25qxx_read_sr2(void) { uint8_t buf[1]; buf[0] = W25X_ReadStatusReg2; spi_write(&device, buf, 1, false); //false = 保持片选,继续发送 spi_read(&device, buf, 1, true); return buf[0]; }
static void accel_sensor_write_reg(spi_chip_t * chip, uint8_t reg_base) { if (spi_lock_dev(chip->spi_dev) <0) return; spi_write(chip, reg_base); //printf("Writing %#x\r\n", ((reg_base + 1) << 8) | 0x8000 | ((value >> 8) & 0xff)); spi_read(chip); spi_unlock_dev(chip->spi_dev); }
ssize_t spi_get(struct spi_driver_t *self_p, uint8_t *data_p) { ASSERTN(self_p != NULL, EINVAL); ASSERTN(data_p != NULL, EINVAL); return (spi_read(self_p, data_p, 1)); }
static inline uint32_t ms5611_convert_pressure(void) { uint32_t data; spi_select(); spi_write(0x48); //highest resolution option spi_deselect(); //delay_ms(10); delay_ms(10); spi_select(); spi_write(0x00); data = ((uint32_t)spi_read())<<16; data+= ((uint32_t)spi_read())<<8; data+= ((uint32_t)spi_read()); spi_deselect(); delay_ms(1); return data; }
void ICACHE_FLASH_ATTR as3935_set_tuning_capacitor(uint8_t cap){ HSPI_INIT_STUF; as3935.x8.d8=spi_read(8); as3935.x8.a8.TUN_CAP=cap; os_printf("\nsetting tun cap to: %d, %d\n",tuncaplookuptable[cap],cap ); spi_write(8,as3935.x8.d8); }
// perform a conversion on all 4 channels static void adc_convert(u16 (*dst)[4]) { #if 1 #else u16 cmd, val; // data into AD7923 is a left-justified 12-bit value in a 16-bit word // so, always lshift the command before sending cmd = ( AD7923_CMD_BASE ) << 4; spi_selectChip(ADC_SPI, ADC_SPI_NPCS); spi_write(ADC_SPI, cmd); spi_unselectChip(ADC_SPI, ADC_SPI_NPCS); // get channel 0, setup channel 1 cmd = ( AD7923_CMD_BASE | AD7923_CTL_ADD0 ) << 4; spi_selectChip(ADC_SPI, ADC_SPI_NPCS); spi_write(ADC_SPI, cmd); spi_read(ADC_SPI, &val); spi_unselectChip(ADC_SPI, ADC_SPI_NPCS); (*dst)[0] = val & 0xfff; // get channel 1, setup channel 2 cmd = ( AD7923_CMD_BASE | AD7923_CTL_ADD1 ) << 4; spi_selectChip(ADC_SPI, ADC_SPI_NPCS); spi_write(ADC_SPI, cmd); spi_read(ADC_SPI, &val); spi_unselectChip(ADC_SPI, ADC_SPI_NPCS); (*dst)[1] = val & 0xfff; // get channel 2, setup channel 3 cmd = ( AD7923_CMD_BASE | AD7923_CTL_ADD1 | AD7923_CTL_ADD0 ) << 4; spi_selectChip(ADC_SPI, ADC_SPI_NPCS); spi_write(ADC_SPI, cmd); spi_read(ADC_SPI, &val); spi_unselectChip(ADC_SPI, ADC_SPI_NPCS); (*dst)[2] = val & 0xfff; // get channel 3, dummy write cmd = ( AD7923_CMD_BASE ) << 4; spi_selectChip(ADC_SPI, ADC_SPI_NPCS); spi_write(ADC_SPI, cmd); spi_read(ADC_SPI, &val); spi_unselectChip(ADC_SPI, ADC_SPI_NPCS); (*dst)[3] = val & 0xfff; #endif }
void test_spi_baud_rate_change(void) { delay_ms(1); uint16_t data1 = 0b0101011101001001; spi_set_selector_bit_length(SPI0, SPI_SELECTOR_0, SPI_BITS_16); spi_set_selector_clk_polarity(SPI0, SPI_SELECTOR_0, SPI_POLARITY_LOW); spi_set_selector_clk_phase(SPI0, SPI_SELECTOR_0, SPI_PHASE_LOW); // test case begin spi_set_selector_baud_rate(SPI0, SPI_SELECTOR_0, 1); spi_write(SPI0, data1); // We send both bytes as 16 consecutive bits delay_ms(1); TEST_ASSERT_EQUAL_HEX32(data1, spi_read(SPI0)); // new test spi_set_selector_baud_rate(SPI0, SPI_SELECTOR_0, 2); spi_write(SPI0, data1); // We send both bytes as 16 consecutive bits delay_ms(1); TEST_ASSERT_EQUAL_HEX32(data1, spi_read(SPI0)); }
/* * Reads an int24 from the MS5611 address `adr`, stores it to `d`. */ static void ms5611_read_s24(uint8_t adr, int32_t* d) { uint32_t data_received; //To store result uint8_t adc_adr = 0x00; //Command to read ADC from baro spi_enable(MS5611_SPID); // The SPI peripheral is enabled. // CHIBIOS spiSelect(&MS5611_SPID); spi_send8(MS5611_SPID, adr); // Data is written to the SPI interface after the previous write transfer has finished. //TODO: Sleep for 1 ms /* * Wait for conversion to complete. There doesn't appear to be any way * to do this without timing it, unfortunately. * * If we just watch the clock we'll consume enormous CPU time for little * gain. Instead we'll sleep for "roughly" 1ms and then wait until at least * the desired 0.6ms have passed. */ spi_send8(MS5611_SPID, adc_adr); // Asks the device to send the results from the ADC. data_received = spi_read(MS5611_SPID); //A ADC_READ command returns a 3 byte result *d = data_received; /* //OLD CODE: uint8_t adc_adr = 0x00, rx[3]; int32_t t0; */ /* Start conversion */ //spiSelect(&MS5611_SPID); //spiSend(&MS5611_SPID, 1, (void*)&adr); /* * Wait for conversion to complete. There doesn't appear to be any way * to do this without timing it, unfortunately. * * If we just watch the clock we'll consume enormous CPU time for little * gain. Instead we'll sleep for "roughly" 1ms and then wait until at least * the desired 0.6ms have passed. */ // t0 = halGetCounterValue(); //chThdSleepMilliseconds(1); //while(halGetCounterValue() - t0 < US2RTT(600)) { // chThdYield(); //} /* Deassert CS */ //spiUnselect(&MS5611_SPID); /* Read ADC result */ // spiSelect(&MS5611_SPID); // spiSend(&MS5611_SPID, 1, (void*)&adc_adr); // spiReceive(&MS5611_SPID, 3, (void*)rx); //spiUnselect(&MS5611_SPID); // *d = rx[0] << 16 | rx[1] << 8 | rx[2]; }
static mrb_value mrb_rs_gyro_initialize(mrb_state *mrb, mrb_value self) { //TODO update default value with parameters // gpio 7, 8, 9, 10, 11 unsigned int ra; unsigned int ra2; unsigned int rcv_data = 0; ra=GET32(AUX_ENABLES); ra|=2; //enable spi0 PUT32(AUX_ENABLES,ra); ra=GET32(GPFSEL0); ra&=~(7<<27); //gpio9 //MISO ra|=4<<27; //alt0 //ra|=1<<27; //output ra&=~(7<<24); //gpio8 //CE0 ra|=4<<24; //alt0 ra&=~(7<<21); //gpio7 //CE1; not used //ra|=4<<21; //alt0 ra|=1<<21; //output PUT32(GPFSEL0,ra); ra=GET32(GPFSEL1); ra&=~(7<<0); //gpio10 //MOSI ra|=4<<0; //alt0 ra&=~(7<<3); //gpio11 //SCLK ra|=4<<3; //alt0 PUT32(GPFSEL1,ra); *SPI_CONTROL = 0; *SPI_CONTROL &= ~(1 << SPI_CS_CSPOL0); //LOW *SPI_CONTROL &= ~((1 << SPI_CS_CS0) | (1 << SPI_CS_CS1));//CS0 // clear send/receive buffer *SPI_CONTROL |= (1 << SPI_CS_CLEAR_RX) | (1 << SPI_CS_CLEAR_TX); *SPI_CONTROL |= SPI_CS_MODE_00; *SPI_CLK = 128; // read "Who am I" reg(0x0F) for test rcv_data = spi_read(0x0F); // 0xD4 is collect if(rcv_data != 0xd4){ return mrb_false_value(); } // delay 500msec for(ra2=0;ra2<0x500000;ra2++) dummy(ra2); spi_write(0x20, 0xCF); spi_write(0x23, (0x01000000)); // delay 500msec for(ra2=0;ra2<0x500000;ra2++) dummy(ra2); return self; }
void RTC_read_alarm(){ int8 RTC_buffer; RTC_buffer = 0; setup_spi(SPI_MASTER|SPI_MODE_0_0|SPI_CLK_DIV_16); output_bit(RTC_CS, ENABLE); RTC_buffer = spi_read(0x0A); RTC_Al_Mon_Reg = spi_read(RTC_buffer); RTC_Al_DOM_Reg = spi_read(RTC_buffer); RTC_Al_Hr_Reg = spi_read(RTC_buffer); RTC_Al_Min_Reg = spi_read(RTC_buffer); RTC_Al_Sec_Reg = spi_read(RTC_buffer); RTC_Flags_Reg = spi_read(RTC_buffer); output_bit(RTC_CS, DISABLE); RTC_Al_Mon_Reg = RTC_Al_Mon_Reg & 0b00011111; RTC_Al_Mon_Reg = Bcd2Dec(RTC_Al_Mon_Reg); RTC_Al_DOM_Reg = RTC_Al_DOM_Reg & 0b00111111; RTC_Al_DOM_Reg = Bcd2Dec(RTC_Al_DOM_Reg); RTC_Al_Hr_Reg = RTC_Al_Hr_Reg & 0b00111111; RTC_Al_Hr_Reg = Bcd2Dec(RTC_Al_Hr_Reg); RTC_Al_Min_Reg = RTC_Al_Min_Reg & 0b01111111; RTC_Al_Min_Reg = Bcd2Dec(RTC_Al_Min_Reg); RTC_Al_Sec_Reg = RTC_Al_Sec_Reg & 0b01111111; RTC_Al_Sec_Reg = Bcd2Dec(RTC_Al_Sec_Reg); }
/******************************************************************************* * The Chip Erase function will erase all bits (0xFF) in the array. * * While the device is executing the chipErase() function, the WriteInProcess() * macro can be read to determine when the Chip Erase function is complete. * *******************************************************************************/ void EEPROM_chipErase(){ unsigned short r_data = 0; unsigned char r_pcs; _EEPROM_wren(); spi_write(SPI, CE, spi_get_pcs(3), 1); while((spi_read_status(SPI) & SPI_SR_RDRF) == 0); spi_read(SPI, (uint16_t*) &r_data, (uint8_t*) &r_pcs); }
uint8_t enc28j60_readOp(enc28j60_connection* c, uint8_t op, uint8_t address) { uint8_t ret; spi_cs_on(c->cs_pin); // issue read command spi_write(op | (address & ADDR_MASK)); // read data ret = spi_read(); // do dummy read if needed (for mac and mii, see datasheet page 29) if(address & 0x80) ret = spi_read(); // release CS spi_cs_off(c->cs_pin); return ret; }
int spidata_read(unsigned char * buffer, int len) { int result = spi_read(ctx2050_data_dev, buffer, len); if (result < 0) { printk(PREFIX "data read fail %d\n", result); } return result; }
//读Y坐标的数据 uint32_t ads7843_readY(int * value) { uint8_t buf[2]; buf[0] = ADS7843_CMD_READ_Y; spi_write(&device, buf, 1, false); spi_read(&device, buf, 2, true); *value = ((buf[0]<<8) + buf[1])>>4; //12bit mode return SPI_EOK; }
void ssp_isr(void){ if(spi_data_is_in()) { disable_interrupts(INT_SSP); x = spi_read();//Leitura do Valor recebido pela comunicação printf(lcd_putc, "\f Hex %x \n",x); //Escreve no display o valor recebido em Hexa printf(lcd_putc, "\Long1 %d",x); //Escreve no display o valor recebido em Long enable_interrupts(INT_SSP); } }
static uint8_t w25qxx_read_sr(void) { uint8_t buf[1]; buf[0] = W25X_ReadStatusReg; spi_write(&device, buf, 1, false); //false = 保持片选,继续发送 spi_read(&device, buf, 1, true); W25QXX_TRACE("W25QXX BUSY\r\n", buf[0]); return buf[0]; }
static int sd_generic_read(struct sd_host *host, u8 opcode, u32 arg, void *data, size_t len, int token) { struct sd_command *cmd = &host->cmd; u16 crc, calc_crc = 0xffff; u8 *d; size_t l; int retval; /* build raw command */ sd_cmd(cmd, opcode, arg); /* select card, send command and wait for response */ retval = sd_start_command(host, cmd); if (retval < 0) goto out; if (retval != 0x00) { retval = -EIO; goto out; } /* wait for read token, then read data */ retval = sd_read_data(host, data, len, token); if (retval < 0) goto out; /* read trailing crc */ spi_read(host, &crc, sizeof(crc)); retval = 0; /* FIXME, rewrite this a bit */ { calc_crc = 0; d = data; l = len; while (l-- > 0) calc_crc = crc_xmodem_update(calc_crc, *d++); if (calc_crc != crc) retval = -EIO; } out: /* burn extra cycles and deselect card */ sd_end_command(host); if (retval < 0) { DBG("read, offset=%u, len=%d\n", arg, len); DBG("crc=%04x, calc_crc=%04x, %s\n", crc, calc_crc, (retval < 0) ? "failed" : "ok"); } return retval; }
/* * Driver read function * * This function uses a generic SPI read to read values from the Pmod. * It will only read full values, so if the length from user space is * not a multiple of 2, it will read up to length - 1 bytes. * * Function can possibly error out if: * The mutex cannot be locked * spi_read fails on the first read * * Otherwise, the function returns the number of successful values read, * each with a size of 2 bytes. So for instance, if 13 bytes are read, * the function will return 12, indicating 6 values were read successfully * from the pmod. Additionally, if copy_to_user cannot successfully * copy everything, the number of successfully copied full values (2 bytes) * will be returned. * * We use goto in this function because there are multiple exit points, * and it prevents us from having to call mutex_unlock() for the mutex * each time. */ static ssize_t pmodad1_read(struct file *fp, char __user *buffer, size_t length, loff_t *offset) { int status; /* spi_read return value */ int num_reads; /* Number of values to read from Pmod */ int i; ssize_t retval; /* Function return value */ ssize_t ret; /* copy_to_user return value */ unsigned short buf; /* Temporary storage for each read value */ struct pmodad1_device *dev; dev = fp->private_data; status = 0; num_reads = length/2; if (mutex_lock_interruptible(&dev->mutex)) { retval = -ERESTARTSYS; goto lock_err; } if (buffer == NULL) { retval = -EINVAL; goto read_out; } for (i = 0; i < num_reads; i++) { /* Use generic SPI read */ status = spi_read(dev->spi, &buf, 2); if (status) break; /* Change endianness of result, if necessary * The result from the Pmod hardware is big endian, * whereas Microblaze and other CPU architectures are * little endian. */ dev->val_buf[i] = be16_to_cpu(buf) & 0x0FFF; // only 12 bits matters } if (i == 0) { dev_err(&dev->spi->dev, "SPI read failure: %d\n", status); retval = status; goto read_out; } /* * Only copy full values (2 bytes) in the case of a user space length * that is not a multiple of 2. */ ret = copy_to_user((void *)buffer, (void *)dev->val_buf, i*2); retval = num_reads*2 - (ret + (ret % 2)); read_out: mutex_unlock(&dev->mutex); lock_err: return retval; }
/** Write a byte out in master mode and receive a value * * @param[in] obj The SPI peripheral to use for sending * @param[in] value The value to send * @return Returns the value received during send */ int spi_master_write(spi_t *obj, int value){ spi_status_t status=spi_write(obj->spi.spi_base,(uint16_t)value,obj->spi.cs,SPI_LAST); if(status ==SPI_OK){ uint16_t data; status =spi_read(obj->spi.spi_base,&data,&obj->spi.cs); if(status == SPI_OK) return data; } return 0; }
aj_spi_status AJ_SPI_READ(Spi* p_spi, uint8_t* us_data, uint8_t* p_pcs) { aj_spi_status status; uint16_t data; status = spi_read(p_spi, &data, p_pcs); AJ_ASSERT(status == SPI_OK); *us_data = data & 0xFF; // AJ_InfoPrintf(("=R= %02x\n", (*us_data) & 0xFF)); return status; }
/************************************* the reset of software **************************************/ void software_reset(void) { spi_write_command(0x0780); while (!(0x02&spi_read(INTERRUPT_STATUS_2))); //RF23B_init_parameter(); //while (!((1<<ICHIPRDY)&spi_read(INTERRUPT_STATUS_2))); /*#ifdef ODMIERZANIE_CZASU typ_czasu temp=czasomierz; do { #ifdef _RFM_NIRQ if(!_RFM_NIRQ) #else if(spi_read(INTERRUPT_STATUS_2)&(1<<ICHIPRDY)) #endif { ItStatus1 = spi_read(INTERRUPT_STATUS_1); ItStatus2 = spi_read(INTERRUPT_STATUS_2); return; } } while (czasomierz<=(temp+6)); #else unsigned char j; for(j=0;j<250;j++) //200us~600us #ifdef _RFM_NIRQ if(!_RFM_NIRQ) #else if(spi_read(INTERRUPT_STATUS_2)&(1<<ICHIPRDY)) #endif { ItStatus1 = spi_read(0x03); ItStatus2 = spi_read(0x04); return; } #endif //hardware_reset(); //hardware reset */ to_ready_mode(); while (!((1<<ICHIPRDY)&spi_read(INTERRUPT_STATUS_2))); }