bool mpu6000WriteRegister(uint8_t reg, uint8_t data)
{
ENABLE_MPU6000;
spiTransferByte(MPU6000_SPI_INSTANCE, reg);
spiTransferByte(MPU6000_SPI_INSTANCE, data);
DISABLE_MPU6000;
return true;
}
void mmcCommandNoWait(u08 cmd, u32 arg) {
// send command
spiTransferByte(cmd | 0x40);
spiTransferByte(arg>>24);
spiTransferByte(arg>>16);
spiTransferByte(arg>>8);
spiTransferByte(arg);
spiTransferByte(0x95); // crc valid only for MMC_GO_IDLE_STATE
// end command
}
void set_avr_bank(uint8_t val) {
SPI_SS_HIGH();
FPGA_SS_LOW();
spiTransferByte(0x00); // SET ADDRESS
spiTransferByte(val * 0x20); // select chip
spiTransferByte(0x00); // select chip
spiTransferByte(0x00); // select chip
FPGA_SS_HIGH();
SPI_SS_LOW();
}
void cc2420WriteFifo(u08* data, u16 nBytes)
{
// assert chip select
cbi(PORTB, CC2420_PIN_CS);
// send command
spiTransferByte(CC2420_TXFIFO);
while(nBytes--)
spiTransferByte(*data++);
// release chip select
sbi(PORTB, CC2420_PIN_CS);
}
void cc2420DumpFifo(u16 nBytes)
{
// assert chip select
cbi(PORTB, CC2420_PIN_CS);
// send command
spiTransferByte(CC2420_RXFIFO | 0x40);
while(nBytes--)
spiTransferByte(0x00);
// release chip select
sbi(PORTB, CC2420_PIN_CS);
}
u08 spieepromReadStatus(void)
{
u08 status;
// cbi(PORTB,0);
// send command
spiTransferByte(SPIEEPROM_CMD_RDSR);
// get status register value
status = spiTransferByte(0xFF);
// sbi(PORTB,0);
return status;
}
bool mpu9250WriteRegister(uint8_t reg, uint8_t data)
{
ENABLE_MPU9250;
delayMicroseconds(1);
spiTransferByte(MPU9250_SPI_INSTANCE, reg);
spiTransferByte(MPU9250_SPI_INSTANCE, data);
DISABLE_MPU9250;
delayMicroseconds(1);
return true;
}
void ads7870WriteReg(u08 reg, u08 value)
{
// assert chip select
cbi(ADS7870_CS_PORT, ADS7870_CS_PIN);
// issue reg write command
spiTransferByte(ADS7870_REG_WRITE | reg);
// write data
spiTransferByte(value);
// release chip select
sbi(ADS7870_CS_PORT, ADS7870_CS_PIN);
}
void cc2420WriteRam(u16 addr, u08* data, u16 nBytes)
{
// assert chip select
cbi(PORTB, CC2420_PIN_CS);
// send command
spiTransferByte(0x80|addr);
spiTransferByte((addr>>1) & 0xC0);
while(nBytes--)
spiTransferByte(*data++);
// release chip select
sbi(PORTB, CC2420_PIN_CS);
}
/**
* sendCommand - send a command to the SD card
* @command : command to be sent
* @parameter: parameter to be sent
* @deselect : Flags if the card should be deselected afterwards
*
* This function calculates the correct CRC7 for the command and
* parameter and transmits all of it to the SD card. If requested
* the card will be deselected afterwards.
*/
int mmc::sendCommand(const byte command,
const uint32_t parameter,
const byte deselect) {
union {
unsigned long l;
unsigned char c[4];
}
long2char;
byte i,crc,errorcount;
uint16_t counter;
long2char.l = parameter;
crc = crc7update(0 , 0x40+command);
crc = crc7update(crc, long2char.c[3]);
crc = crc7update(crc, long2char.c[2]);
crc = crc7update(crc, long2char.c[1]);
crc = crc7update(crc, long2char.c[0]);
crc = (crc << 1) | 1;
errorcount = 0;
while (errorcount < CONFIG_SD_AUTO_RETRIES) {
// Select card
SPI_SS_LOW();
// Transfer command
spiTransferByte(0x40+command);
spiTransferLong(parameter);
spiTransferByte(crc);
// Wait for a valid response
counter = 0;
do {
i = spiTransferByte(0xff);
counter++;
}
while (i & 0x80 && counter < 0x1000);
// Check for CRC error
// can't reliably retry unless deselect is allowed
if (deselect && (i & STATUS_CRC_ERROR)) {
// uart_putc('x');
deselectCard();
errorcount++;
continue;
}
if (deselect) deselectCard();
break;
}
return i;
}
void cc2420WriteReg(u08 addr, u16 data)
{
// assert chip select
cbi(PORTB, CC2420_PIN_CS);
// send command
spiTransferByte(addr);
// write data
spiTransferByte(data>>8);
spiTransferByte(data);
// release chip select
sbi(PORTB, CC2420_PIN_CS);
}
unsigned short spiflashGetID(void)
{
unsigned short id;
SPIFLASH_ASSERT_CS;
spiTransferByte(SPIFLASH_CMD_RDID);
id = spiTransferByte(0x00)<<8;
id |= spiTransferByte(0x00);
SPIFLASH_RELEASE_CS;
return id;
}
u08 ads7870ReadReg(u08 reg)
{
u08 data;
// assert chip select
cbi(ADS7870_CS_PORT, ADS7870_CS_PIN);
// issue reg read command
spiTransferByte(ADS7870_REG_READ | reg);
// read data
data = spiTransferByte(0x00);
// release chip select
sbi(ADS7870_CS_PORT, ADS7870_CS_PIN);
// return data
return data;
}
void spieepromWriteByte(u32 memAddr, u08 data)
{
// wait for any previous write to complete
while(spieepromReadStatus() & SPIEEPROM_STATUS_WIP);
// cbi(PORTB,0);
// send command
spiTransferByte(SPIEEPROM_CMD_WRITE);
// send address
spiTransferByte(memAddr>>8);
spiTransferByte(memAddr&0x00FF);
// send data to be written
spiTransferByte(data);
// sbi(PORTB,0);
}
u08 spieepromReadByte(u32 memAddr)
{
u08 data;
// cbi(PORTB,0);
// send command
spiTransferByte(SPIEEPROM_CMD_READ);
// send address
spiTransferByte(memAddr>>8);
spiTransferByte(memAddr&0x00FF);
// read contents of memory address
data = spiTransferByte(0xFF);
// return data
return data;
// sbi(PORTB,0);
}
void max7456_write_nvm(uint8_t char_address, uint8_t *font_data) {
uint8_t x;
#ifdef MAX7456_DMA_CHANNEL_TX
while (dma_transaction_in_progress);
#endif
while (max7456_lock);
max7456_lock = 1;
ENABLE_MAX7456;
// disable display
max7456_send(VM0_REG, video_signal_type);
max7456_send(MAX7456ADD_CMAH, char_address); // set start address high
for(x = 0; x < 54; x++) {
max7456_send(MAX7456ADD_CMAL, x); //set start address low
max7456_send(MAX7456ADD_CMDI, font_data[x]);
#ifdef LED0_TOGGLE
LED0_TOGGLE;
#else
LED1_TOGGLE;
#endif
}
// transfer 54 bytes from shadow ram to NVM
max7456_send(MAX7456ADD_CMM, WRITE_NVR);
// wait until bit 5 in the status register returns to 0 (12ms)
while ((spiTransferByte(MAX7456_SPI_INSTANCE, MAX7456ADD_STAT) & STATUS_REG_NVR_BUSY) != 0);
max7456_send(VM0_REG, video_signal_type | 0x0C);
DISABLE_MAX7456;
max7456_lock = 0;
}
void spiflashRead(unsigned long addr, unsigned long nbytes, unsigned char *data)
{
// begin read
SPIFLASH_ASSERT_CS;
// issue read command
spiTransferByte(SPIFLASH_CMD_READ);
// send address
spiTransferByte(addr>>16);
spiTransferByte(addr>>8);
spiTransferByte(addr>>0);
// read data
while(nbytes--)
*data++ = spiTransferByte(0x00);
// end read
SPIFLASH_RELEASE_CS;
}
void _mmcEnableCS(void) {
cbi(MMC_CS_PORT,MMC_CS_PIN);
spiTransferByte(0xFF);
}
void spieepromWriteDisable(void)
{
// cbi(PORTB,0);
// send command
spiTransferByte(SPIEEPROM_CMD_WRDI);
// sbi(PORTB,0);
}
void set_avr_mapper(uint8_t val) {
SPI_SS_HIGH();
FPGA_SS_LOW();
spiTransferByte(0x30 | (val & 0x0f));
FPGA_SS_HIGH();
SPI_SS_LOW();
}
static void mpu6500ReadRegister(uint8_t reg, uint8_t *data, int length)
{
ENABLE_MPU6500;
spiTransferByte(MPU6500_SPI_INSTANCE, reg | 0x80); // read transaction
spiTransfer(MPU6500_SPI_INSTANCE, data, NULL, length);
DISABLE_MPU6500;
}
/**
* Send the given command byte to the device.
*/
static void m25p16_performOneByteCommand(uint8_t command)
{
ENABLE_M25P16;
spiTransferByte(M25P16_SPI_INSTANCE, command);
DISABLE_M25P16;
}
void cc2420Command(u08 cmd)
{
// assert chip select
cbi(PORTB, CC2420_PIN_CS);
// send command
spiTransferByte(cmd);
// release chip select
sbi(PORTB, CC2420_PIN_CS);
}
bool mpu9250ReadRegister(uint8_t reg, uint8_t length, uint8_t *data)
{
ENABLE_MPU9250;
spiTransferByte(MPU9250_SPI_INSTANCE, reg | 0x80); // read transaction
spiTransfer(MPU9250_SPI_INSTANCE, data, NULL, length);
DISABLE_MPU9250;
return true;
}
// --------------------------------------------------------------------------
NRF24_STATUS_t nrf24GetStatus(void)
{
u_nrf24_reg_t status;
NRF24_CSN_LOW();
status.byte = spiTransferByte(spi, NRF24_CMD_NOP);
NRF24_CSN_HIGH();
return (status.STATUS);
}
byte mmc::readSectors(byte *buffer, uint32_t sector, byte count) {
byte sec,res,tmp,errorcount;
uint16_t crc,recvcrc;
for (sec=0;sec<count;sec++) {
errorcount = 0;
while (errorcount < CONFIG_SD_AUTO_RETRIES) {
res = sendCommand(READ_SINGLE_BLOCK, (sector+sec) << 9, 0);
if (res != 0) {
SPI_SS_HIGH();
disk_state = DISK_ERROR;
return RES_ERROR;
}
// Wait for data token
if (!sdResponse(0xFE)) {
SPI_SS_HIGH();
disk_state = DISK_ERROR;
return RES_ERROR;
}
uint16_t i;
// Get data
crc = 0;
for (i=0; i<512; i++) {
tmp = spiTransferByte(0xff);
*(buffer++) = tmp;
}
// Check CRC
recvcrc = (spiTransferByte(0xFF) << 8) + spiTransferByte(0xFF);
break;
}
deselectCard();
if (errorcount >= CONFIG_SD_AUTO_RETRIES) return RES_ERROR;
}
return RES_OK;
}
static char sdResponse(byte expected)
{
unsigned short count = 0x0FFF;
while ((spiTransferByte(0xFF) != expected) && count )
count--;
// If count didn't run out, return success
return (count != 0);
}
static char sdWaitWriteFinish(void)
{
unsigned short count = 0xFFFF; // wait for quite some time
while ((spiTransferByte(0xFF) == 0) && count )
count--;
// If count didn't run out, return success
return (count != 0);
}
s16 ads7870ConvertRaw(u08 channel)
{
s16 result;
// assert chip select
cbi(ADS7870_CS_PORT, ADS7870_CS_PIN);
// start conversion
spiTransferByte(ADS7870_CONVERT | channel);
// wait for completion
while( ads7870ReadReg(ADS7870_GAINMUX) & ADS7870_GAINMUX_CNVBSY);
// assert chip select
cbi(ADS7870_CS_PORT, ADS7870_CS_PIN);
// read result
spiTransferByte(ADS7870_REG_READ | ADS7870_REG_16BIT | ADS7870_RESULTHI);
result = spiTransferByte(0x00)<<8;
result |= spiTransferByte(0x00);
// release chip select
sbi(ADS7870_CS_PORT, ADS7870_CS_PIN);
// return result
return result;
}
u08 mmcCommand(u08 cmd, u32 arg)
{
u08 r1;
u08 retry=0;
// send command
spiTransferByte(cmd | 0x40);
spiTransferByte(arg>>24);
spiTransferByte(arg>>16);
spiTransferByte(arg>>8);
spiTransferByte(arg);
spiTransferByte(0x95); // crc valid only for MMC_GO_IDLE_STATE
// end command
// wait for response
// if more than 8 retries, card has timed-out
// return the received 0xFF
while((r1 = spiTransferByte(0xFF)) == 0xFF)
if(retry++ > 8) break;
// return response
return r1;
}
