//Fetch the next act payload
//Return the payload length
char NRF24L01_RxPacket(char *payload)
{
int len;
int i;
//Get the packet length
RADIO_EN_CS();
SPI_SendByte(CMD_RX_PL_WID);
len = SPI_ReceiveByte();
RADIO_DIS_CS();
if (len>0 && len<33)
{
//Read the packet from the RX buffer
RADIO_EN_CS();
SPI_SendByte(CMD_R_RX_PAYLOAD);
for(i=0;i<len;i++)
payload[i] = SPI_ReceiveByte();
RADIO_DIS_CS();
} else {
len=0;
}
//Pulse CE
//CE_PULSE();
return len;
}
UINT8 SD_WriteData(UINT8 pu8DataPointer[], UINT32 u32DataLength) {
UINT8 u8R1;
UINT8 u8Counter;
UINT32 u32Counter;
//SPI_SS = ENABLE;
SPI_SendByte(0xFE);
for(u32Counter = 0; u32Counter < u32DataLength; u32Counter++)
SPI_SendByte(pu8DataPointer[u32Counter]);
SPI_SendByte(0xFF); // checksum Bytes not needed
SPI_SendByte(0xFF);
/* Response RHandler (R1) */
u8Counter = SD_WAIT_CYCLES;
do {
u8R1 = SPI_ReceiveByte();
u8Counter--;
} while(((u8R1 & 0x80) != 0) && (u8Counter > 0)); // #001 wait for SD response <> 0xFF
//SPI_SS = DISABLE;
if(u8Counter == 0) return (SD_FAIL_TIMEOUT);
if((u8R1 & 0x1F) != 0x05) return (SD_FAIL_WRITE); // #001 checks if response = 0101 = data accepted
while(SPI_ReceiveByte()==0x00) ; // Dummy SPI cycle
return(SD_OK);
}
UINT8 SD_SendCommand(UINT8 u8SDCommand, UINT32 u32Param, UINT8 pu32Response[], UINT8 u8ResponseLength) {
UINT8 u8R1;
UINT8 u8Counter;
UINT8 buffer[4];
buffer[0] = (UINT8)((u32Param & 0xFF000000) >> 24);
buffer[1] = (UINT8)((u32Param & 0x00FF0000) >> 16);
buffer[2] = (UINT8)((u32Param & 0x0000FF00) >> 8);
buffer[3] = (UINT8)((u32Param & 0x000000FF) >> 0);
/* Enable CS */
//SPI_SS = ENABLE;
/* Send Start byte */
SPI_SendByte((UINT8)(u8SDCommand | 0x40));
/* Send Argument */
for(u8Counter = 0; u8Counter < 4; u8Counter++) {
SPI_SendByte(buffer[u8Counter]);
}
/* Send CRC */
if((u8SDCommand & 0x02F) == SD_CMD8_SEND_IF_COND) {
SPI_SendByte(0x87);
} else {
SPI_SendByte(0x95);
}
/*
} else if ((u8SDCommand & 0x02F) == SD_CMD1) {
SPI_SendByte(0x95);
} else {
SPI_SendByte(0x01);
}
*/
/* Response RHandler (R1) */
u8Counter = SD_WAIT_CYCLES;
do {
u8R1 = SPI_ReceiveByte(); //Recibe Respuesta de SD (R1=1byte)
u8Counter--;
} while(((u8R1 & 0x80) != 0) && (u8Counter > 0));
if(u8Counter == 0) {
//SPI_SS = DISABLE;
return (SD_FAIL_TIMEOUT);
}
for (u8Counter = 0; u8Counter < u8ResponseLength; u8Counter++) {
pu32Response[u8Counter] = SPI_ReceiveByte();
}
/* Disable CS */
//SPI_SS = DISABLE;
return (u8R1);
}
uint8_t hwspi_read_block() {
uint16_t i;
uint8_t sreg;
if (SPI_USE_3B_CMDS && SPI_ADDRESS_LENGTH == 4) {
HWSPI_CS_LOW;
SPI_SendByte(SPI_COMMAND_EN4B);
HWSPI_CS_HIGH;
}
/* Save global interrupt flag and disable interrupts */
sreg = SREG;
cli();
HWSPI_CS_LOW;
if (SPI_USE_3B_CMDS || SPI_ADDRESS_LENGTH == 3)
SPI_SendByte(SPI_COMMAND_3B_READ);
else
SPI_SendByte(SPI_COMMAND_4B_READ);
/* address */
if (SPI_ADDRESS_LENGTH == 4) SPI_SendByte(buf_addr[0]);
SPI_SendByte(buf_addr[1]);
SPI_SendByte(buf_addr[2]);
SPI_SendByte(buf_addr[3]);
for (uint8_t k = 0; k < SPI_BLOCK_SIZE / BUF_SIZE_RW; ++k) {
for (i = 0; i < BUF_SIZE_RW; ++i) {
buf_rw[i] = SPI_ReceiveByte();
}
usb_serial_write(buf_rw, BUF_SIZE_RW);
}
uint16_t rest = SPI_BLOCK_SIZE - ((SPI_BLOCK_SIZE / BUF_SIZE_RW) * BUF_SIZE_RW);
for (i = 0; i < rest; ++i) {
buf_rw[i] = SPI_ReceiveByte();
}
HWSPI_CS_HIGH;
usb_serial_write(buf_rw, rest);
/* Restore global interrupt flag */
SREG = sreg;
return 1;
}
UINT8 SD_ReadSector(UINT32 u32SD_Block,UINT8 pu8DataPointer[]) {
volatile UINT8 u8Temp = 0;
__RESET_WATCHDOG(); /* feeds the dog */
if (!gSDCard.SDHC) u32SD_Block <<= SD_BLOCK_SHIFT;
SPI_SS = ENABLE;
//Utilizo u8Temp para capturar respuesta de la tarjeta SD (fines depurativos)
u8Temp = SD_SendCommand(SD_CMD17_READ_BLOCK, u32SD_Block, NULL, 0);
if((u8Temp & SD_R1_ERROR_MASK) != SD_OK) {
SPI_SS = DISABLE;
return (SD_FAIL_READ);
}
while(u8Temp != 0xFE) u8Temp = SPI_ReceiveByte();
//La SD responde 0xFF...0xFF mientras accede al sector y 0xFE cuando esta lista.
//Los datos que envía a continuación corresponden al sector solicitado.
if (SD_ReadData(pu8DataPointer,SD_BLOCK_SIZE) != SD_OK) return (SD_FAIL_READ);
SPI_SS = DISABLE;
return (SD_OK);
}
byte MMC_Release(byte result)
{
MMC_SS_HIGH();
SPI_ReceiveByte(0xFF); // CS does not release SPI until next clock....flush CS release
SPI_Disable();
return result;
}
byte MMC_ReadOCR(byte cmd, uint32_t param, byte* ocr)
{
byte r = MMC_Command(cmd,param);
byte i = 4;
while (i--)
*ocr++ = SPI_ReceiveByte(0xFF);
return r;
}
//uint8_t device_code1;
uint8_t hwspi_read_id()
{
HWSPI_CS_LOW;
SPI_SendByte(SPI_COMMAND_REMS);
SPI_SendByte(0);
SPI_SendByte(0);
SPI_SendByte(0);
//maker_code = 0xC2;
//device_code0 = 0x18;
maker_code = SPI_ReceiveByte();
device_code0 = SPI_ReceiveByte();
HWSPI_CS_HIGH;
return 1;
}
static char sdWaitWriteFinish(void)
{
unsigned short count = 0xFFFF; // wait for quite some time
while ((SPI_ReceiveByte(0xFF) == 0) && count )
count--;
// If count didn't run out, return success
return (count != 0);
}
uint8_t hwspi_status() {
uint8_t status;
HWSPI_CS_LOW;
SPI_SendByte(SPI_COMMAND_RDSR);
status = SPI_ReceiveByte();
HWSPI_CS_HIGH;
return status;
}
uint8_t hwspi_security() {
uint8_t sec;
HWSPI_CS_LOW;
SPI_SendByte(SPI_COMMAND_RDSCUR);
sec = SPI_ReceiveByte();
HWSPI_CS_HIGH;
return sec;
}
char NRF24L01_ReadReg(char addr)
{
char value;
RADIO_EN_CS();
SPI_SendByte(CMD_R_REG | (addr&0x1F));
value = SPI_ReceiveByte();
RADIO_DIS_CS();
return value;
}
byte MMC_Token()
{
int count = 0xFFF; // was FFF
byte r;
while (count--)
{
r = SPI_ReceiveByte(0xFF);
if (r != 0xFF)
break;
}
return r;
}
//LSB of returned register is in DataToRead[0]
bool AD7794ReadReg( uint8_t reg, uint8_t *DataToRead )
{
if( (reg >= 0) && (reg <= 7) )
{
AD7794Select(1);
SPI_SendByte( AD7794_CR_READ | (reg << 3) );
if( (reg == 0) || (reg == 4) || (reg == 5) )
{
//8-bit register
*DataToRead = SPI_ReceiveByte();
}
else if( (reg == 1) || (reg == 2) )
{
//16-bit register
DataToRead[1] = SPI_ReceiveByte();
DataToRead[0] = SPI_ReceiveByte();
}
else
{
//16-bit register
DataToRead[2] = SPI_ReceiveByte();
DataToRead[1] = SPI_ReceiveByte();
DataToRead[0] = SPI_ReceiveByte();
}
AD7794Select(0);
return true;
}
//Invalid register
return false;
}
UINT8 SD_ReadData(UINT8 pu8DataPointer[], UINT32 u32DataLength) {
UINT8 CRC[2];
UINT32 u32Counter;
/* Enable CS */
//SPI_SS = ENABLE;
for(u32Counter = 0; u32Counter < u32DataLength; u32Counter++) {
pu8DataPointer[u32Counter] = SPI_ReceiveByte();
}
for(u32Counter = 0; u32Counter < 2; u32Counter++) {
CRC[u32Counter] = SPI_ReceiveByte();
}
/* Disable CS */
//SPI_SS = DISABLE;
(void) SPI_ReceiveByte(); // Unknown issue. SPI dummy cicle required by some cards
return (SD_OK);
}
UINT8 SD_WriteSector(UINT32 u32SD_Block, UINT8 * pu8DataPointer) {
UINT16 u16Counter;
UINT8 SD_response;
__RESET_WATCHDOG(); /* feeds the dog */
SPI_SS = ENABLE;
if(!gSDCard.SDHC) u32SD_Block <<= SD_BLOCK_SHIFT;
if(SD_SendCommand(SD_CMD24_WRITE_BLOCK, u32SD_Block, NULL, 0) != SD_OK) {
SPI_SS = DISABLE;
return (SD_FAIL_WRITE);
}
SPI_SendByte(0xFE);
for(u16Counter = 0; u16Counter < SD_BLOCK_SIZE; u16Counter++)
SPI_SendByte(*pu8DataPointer++);
SPI_SendByte(0xFF); // checksum Bytes not needed
SPI_SendByte(0xFF);
SD_response=0xFF;
while (SD_response == 0xFF) SD_response = SPI_ReceiveByte();
if((SD_response & 0x0F) != 0x05) {
SPI_SS=DISABLE;
return (SD_FAIL_WRITE);
}
while(SPI_ReceiveByte()==0x00) ; // Dummy SPI cycle
(void) SPI_ReceiveByte();
SPI_SS = DISABLE;
return (SD_OK);
}
// Read 512 bytes, hopefully quickly but not too quickly
// Data transfer - strips the 2 CRC bytes off the end
void SPI_Receive(byte* buffer, int len)
{
// Unroll a bit
SPDR = 0xFF; // Byte 0
byte i = 0xFF;
do
{
byte a;
loop_until_bit_is_set(SPSR, 7);
a = SPDR;
SPDR = 0xFF;
*buffer++ = a;
loop_until_bit_is_set(SPSR, 7);
a = SPDR;
SPDR = 0xFF;
*buffer++ = a;
} while (i--);
loop_until_bit_is_set(SPSR, 7);
i = SPDR; // CRC byte 0
SPI_ReceiveByte(0xFF); // CRC byte 1
}
byte MMC_WriteSector(byte *buffer, uint32_t sector)
{
if (!(_mmcState & MMC_INITED))
return MMC_NOT_INITED;
if (!(_mmcState & MMC_HIGH_DENSITY))
sector <<= 9;
u8 r = WRITE_FAILED;
SPI_Enable();
MMC_SS_LOW();
if (MMC_Command2(24,sector) != 0)
{
u8 d = 16;
while (d--)
SPI_ReceiveByte(0xFF); // pad
SPI_ReceiveByte(0xFE); // Send token
SPI_Send(buffer,512);
SPI_ReceiveByte(0xFF); // CRC
SPI_ReceiveByte(0xFF); // CRC
u8 status;
while ((status = SPI_ReceiveByte(0xFF)) == 0xFF)
;
if (status == 0xE5)
r = 0;
else
r = status;
while (SPI_ReceiveByte(0xFF) == 0)
;
r = MMC_Release(r);
} else {
r = MMC_Release(WRITE_FAILED);
}
return r;
}
void SPI_Send(byte* data, int len)
{
while (len--)
SPI_ReceiveByte(*data++);
}
byte MMC_Init2()
{
byte ocr[4];
MMC_SS_HIGH(); //
SPI_Init(); // Init slow at first TODO
_mmcState = 0;
// initialize the MMC card into SPI mode by sending 80 clks
int i;
for (i = 0; i < 10; i++)
SPI_ReceiveByte(0xFF);
// Send GO_IDLE_STATE
MMC_SS_LOW();
if (MMC_Command(0,0) != 1)
return GO_IDLE_TIMEOUT;
_mmcState = MMC_PRESENT;
MMC_SS_HIGH();
// Full speed
SPI_Enable();
MMC_SS_LOW();
if (MMC_ReadOCR(58,0,ocr) != 1) // Read OCR check voltages
return READ_OCR_TIMEOUT; // Can't read OCR
if ((ocr[1] & 0x10) == 0)
return BAD_VOLTAGE; // Card does not like out voltage
// Try CMD8
if (MMC_ReadOCR(8,0x1AA,ocr) == 1)
{
// SDHC
_mmcState |= MMC_SDHC;
if ((ocr[2] & 0x0F) != 1)
return BAD_VOLTAGE; // Card does not like out voltage
if (ocr[3] != 0xAA)
return BAD_PATTERN;
// Send ACMD41 and wait for it to come out of idle
i = 0x7FFF; // Wait a long time. A long, long time - some cards take 700 miliseconds or more.
while (i--)
{
MMC_Command(55,0); // SEND_APP_CMD
if (MMC_Command(41,1L << 30) == 0) // ACMD41 with HCS bit 30 set
break;
}
if (i < 0)
return OP_COND_TIMEOUT;
// Check density again
if (MMC_ReadOCR(58,0,ocr) != 0) // Bits[30:29]=1,0
return READ_OCR_TIMEOUT; // Can't read OCR
if ((ocr[0] & 0x60) == 0x40)
_mmcState |= MMC_HIGH_DENSITY;
} else {
// SDCARD 1vXX
// Send SEND_OP_COND and wait for it to come out of idle
i = 0x7FFF;
while (i--)
{
if ((MMC_Command(1,0) & 1) == 0)
break;
}
if (i < 0)
return OP_COND_TIMEOUT;
}
// Send SET_BLOCKLEN for 512 byte block
if (MMC_Command(16,512) != 0)
return SET_BLOCKLEN_TIMEOUT;
_mmcState |= MMC_INITED;
return 0;
}
u8 ReadAcc(u8 r)
{
SPI_ReceiveByte(r << 1);
return SPI_ReceiveByte(0);
}
void WriteAcc(u8 r, u8 v)
{
SPI_ReceiveByte(0x80 | (r << 1));
SPI_ReceiveByte(v);
}
