void at45_read(uint16_t addr, uint8_t pagemode) { at45_busywait(); spi_select(CS_AT45); spi_txrx(AT45_CMD_AREAD); spi_txrx(addr>>7); spi_txrx(addr<<1); spi_txrx(0); spi_txrx(0); spi_txrx(0); spi_txrx(0); spi_txrx(0); if(!pagemode) return; for(addr=0; addr < 264; addr++) answer[addr] = spi_txrx(0); spi_select(0); }
/* TODO: timeout */ void at45_busywait(void) { uint8_t status; do { spi_select(CS_AT45); spi_txrx(AT45_CMD_STATUS); status = spi_txrx(0); spi_select(0); } while (!(status & AT45_STATE_READY)); }
void sx1276_cfg_write_data(sx1276_cfg_reg_t r, uint8_t *d, uint8_t s) { spi_select(ENABLE); spi_send(r | 0x80); while(s) { spi_send(*d); d++; s--; } spi_select(DISABLE); }
void sx1276_cfg_read_data(sx1276_cfg_reg_t r, uint8_t *d, uint8_t s) { spi_select(ENABLE); spi_send(r & 0x7F); while(s) { *d = spi_send(0x00); d++; s--; } spi_select(DISABLE); }
void eeprom_page_write(unsigned long addr, unsigned char* buf, unsigned char len) { spi_select(EEPROM_SS_PORT, EEPROM_SS_PIN); _delay_us(10); spi_write(EEPROM_WRITE); // byte write // wyœlij adres 24-bitowy spi_write( (addr >> 16) & 0xff); spi_write( (addr >> 8) & 0xff); spi_write( addr & 0xff); // wyœlij bajty do zapisania for (unsigned char i=0; i < len; i++) spi_write(buf[i]); spi_unselect(EEPROM_SS_PORT, EEPROM_SS_PIN); //_delay_ms(2);_delay_ms(2);_delay_ms(2);_delay_ms(2); // Twc = 6ms // czekaj na zakoñczenie operacji zapisu (Twc=6ms) while ( (eeprom_status() & 0x01) ) // Write In Progress (WIP) _delay_ms(1); return; }
static void cfi_send_command( struct cfi *cfi, char cmd, int *addr, char *buf, int len, int write) { int spi = cfi->spi; int i; cfi_led(1); spi_select(spi); spi_transfer(spi, cmd); if (addr) { spi_transfer(spi, *addr >> 16); spi_transfer(spi, *addr >> 8); spi_transfer(spi, *addr); } if (buf) { for(i=0;i < len; i++) { if (write) { spi_transfer(spi, *buf++); } else { *buf++ = spi_transfer(spi, 0x00); } } } spi_deselect(spi); cfi_led(0); }
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 mcp2515_request_to_send(int reg) { spi_select(); spi_transmit(reg); spi_deselect(); }
void reset_sequence_ms5611 (void) { spi_select(); //selects the MS5611 MS5611_SPI.DATA = MS5611_RESET; while(!(MS5611_SPI.STATUS>>7)); spi_deselect(); delay_ms(1); }
void at45_write(uint16_t addr, uint8_t *data) { at45_busywait(); spi_select(CS_AT45); spi_txrx(AT45_CMD_APROG); spi_txrx(addr>>7); spi_txrx(addr<<1); spi_txrx(0); for(addr=0; addr < 264; addr++) spi_txrx(data[addr]); spi_select(0); }
void mcp2515_reset() { spi_select(); spi_transmit(MCP_RESET); spi_deselect(); }
uint8_t flash_read_status(){ uint8_t status; spi_select(); spi_out_byte(FLASH_READ_STATUS); status = spi_in_byte(); spi_deselect(); return status; }
void eeprom_enable_write(unsigned char enable) { spi_select(EEPROM_SS_PORT, EEPROM_SS_PIN); _delay_us(10); spi_write( (enable == 1 ? EEPROM_WREN : EEPROM_WRDI) ); // enable / disable write spi_unselect(EEPROM_SS_PORT, EEPROM_SS_PIN); }
void platform_spi_select( spi_userdata *spi, int is_select ) { spi_set_speed(spi->spi, spi->speed); spi_clr_and_set(spi->spi, spi->mode); if (is_select) { spi_select(spi->spi); } else { spi_deselect(spi->spi); } }
void flash_erase_chip(){ flash_unprotect(); spi_select(); spi_out_byte(FLASH_ERASE_CHIP); spi_deselect(); flash_wait_complete(); flash_protect(); }
void flash_erase_sector(int sector){ flash_unprotect(sector); spi_select(); spi_out_byte(FLASH_ERASE_SECTOR); flash_send_address((sector * PAGE_SIZE) + 1); spi_deselect(); flash_wait_complete(); flash_protect(sector); }
void flash_read(uint8_t* buf, uint32_t addr, size_t size){ spi_select(); spi_out_byte(FLASH_READ); flash_send_address(addr); int i; for(i = 0; i < size; i++){ buf[i] = spi_in_byte(); } spi_deselect(); }
void mcp2515_write(char addr, char data) { spi_select(); spi_transmit(MCP_WRITE); spi_transmit(addr); spi_transmit(data); spi_deselect(); }
char mcp2515_read_status() { char output; spi_select(); spi_transmit(MCP_READ); spi_transmit(MCP_CANSTAT); output = spi_receive(); spi_deselect(); return output; }
void mcp2515_bit_modify(char addr, char mask_byte, char data) { spi_select(); spi_transmit(MCP_BITMOD); spi_transmit(addr); spi_transmit(mask_byte); spi_transmit(data); spi_deselect(); }
void flash_write_page(uint8_t* buf, int page){ flash_unprotect(); spi_select(); spi_out_byte(FLASH_PROG_PAGE); flash_send_address(page * PAGE_SIZE); int i; for(i = 0; i < PAGE_SIZE; i++){ spi_out_byte(buf[i]); } spi_deselect(); flash_wait_complete(); }
void eeprom_93c06_enable_write(int en) { unsigned char trash; unsigned char op = (en ? SPI_OP_93C06_EWEN_MASK : SPI_OP_93C06_EWDS_MASK); spi_select(); eeprom_93c06_start_bit(); spi_transmit(op, &trash); spi_deselect(); }
char mcp2515_read (char addr){ char result; spi_select(); spi_transmit(MCP_READ); spi_transmit(addr); result = spi_receive(); spi_deselect(); return result; }
void ms5611_prom_read (void) { for( int i = 0; i < 6; i++ ){ delay_ms(1); spi_select(); spi_write(0xA2 + (i*2) ); coeff[i] = ((uint16_t)spi_read())<<8; coeff[i]+= ((uint16_t)spi_read()); spi_deselect(); delay_ms(1); //printf("C%d:\t%u\n", i, coeff[i]); } }
void flash_init(){ spi_init(); spi_select(); spi_out_byte(FLASH_READ_ID); flash_id = spi_in_byte() << 16; flash_id |= spi_in_byte() << 8; flash_id |= spi_in_byte(); flash_size = 1 << (flash_id & 0xFF); printf("JEDEC ID: %06X, size: %u bytes\n", (unsigned int)flash_id, flash_size); spi_deselect(); }
unsigned char eeprom_status() { spi_select(EEPROM_SS_PORT, EEPROM_SS_PIN); _delay_us(10); spi_write(EEPROM_RDSR); // read status register // wyœlij bajt do zapisania unsigned char status = spi_read(); spi_unselect(EEPROM_SS_PORT, EEPROM_SS_PIN); return status; }
static uint8_t flash_read_status_register() { uint8_t status, out = SPI_FLASH_READ_STATUS; // if we fail to get the bus, then fake a Write-In-Progress if (!spi_select(SPI_DEVICE_P5Q)) { return P5Q_WIP; } spi_write(&out, 1); spi_read(&status, 1); spi_release(); // shell_printf("st %x", status); return status; }
void eeprom_93c06_write_short(unsigned char addr, unsigned short data) { unsigned char trash; spi_select(); eeprom_93c06_start_bit(); spi_transmit(SPI_OP_93C06_WRITE_MASK | SPI_93C06_ADDR_MASK(addr), &trash); spi_transmit(SPI_93C06_WRITE_DATA_BYTE1(data), &trash); spi_transmit(SPI_93C06_WRITE_DATA_BYTE2(data), &trash); spi_deselect(); /* Operation takes 2ms to be guaranteed. */ msleep(2); }
void eeprom_chip_erase() { eeprom_enable_write(1); spi_select(EEPROM_SS_PORT, EEPROM_SS_PIN); _delay_us(10); spi_write(EEPROM_CE); // chip erase spi_unselect(EEPROM_SS_PORT, EEPROM_SS_PIN); // czekaj na zakoñczenie operacji kasowania while ( (eeprom_status() & 0x01) ) // Write In Progress (WIP) _delay_ms(1); eeprom_enable_write(1); }
// Set each LEDs on or off state from a 16-bit value. // // LED d1 = bit 1 // LED d2 = bit 2 // // etc, in the pattern: // // 1 2 3 4 // 5 6 7 8 // 9 10 11 12 // 13 14 15 16 // void led_set_state(uint16_t new_state) { // If no lights have changed, transmit nothing. This saves bandwidth on // the SPI bus for more important things. if (g_led_state == new_state) return; spi_select(SPI_SLAVE_LED); // Pull LAT low // Transmit Most Significant Byte first. spi_transmit(new_state >> 8); spi_transmit(new_state & 0xff); // Latch the result to the LEDs by pulsing high. //PORTB |= LED_LATCH; //PORTB &= ~LED_LATCH; spi_select_none(); // Pull LAT high // record the state. g_led_state = new_state; }