unsigned char mmc_GoIdle()
{
unsigned char response=0x01;
CS_LOW();
//Send Command 0 to put MMC in SPI mode
mmcSendCmd(MMC_GO_IDLE_STATE,0,0x95);
//Now wait for READY RESPONSE
if((mmc_error = mmcGetResponse())!=0x01)
{
CS_HIGH();
return MMC_INIT_ERROR;
}
while(response==0x01)
{
CS_HIGH();
spiSendByte(0xff);
CS_LOW();
mmcSendCmd(MMC_SEND_OP_COND,0x00,0xff);
response=mmcGetResponse();
}
CS_HIGH();
spiSendByte(0xff);
return MMC_SUCCESS;
}
char nrf_snd_pkt_crc_encr(int size, uint8_t * pkt, uint32_t const key[4]){
if(size > MAX_PKT)
size=MAX_PKT;
nrf_write_reg(R_CONFIG,
R_CONFIG_PWR_UP| // Power on
R_CONFIG_EN_CRC // CRC on, single byte
);
// nrf_write_long(C_W_TX_PAYLOAD,size,pkt);
uint16_t crc=crc16(pkt,size-2);
pkt[size-2]=(crc >>8) & 0xff;
pkt[size-1]=crc & 0xff;
if(key !=NULL)
xxtea_encode_words((uint32_t*)pkt,size/4,key);
CS_LOW();
xmit_spi(C_W_TX_PAYLOAD);
sspSend(0,pkt,size);
CS_HIGH();
CE_HIGH();
delayms(1); // Send it. (only needs >10ys, i think)
CE_LOW();
return nrf_cmd_status(C_NOP);
};
void nrf_init() {
// Enable SPI correctly
sspInit(0, sspClockPolarity_Low, sspClockPhase_RisingEdge);
// Enable CS & CE pins
gpioSetDir(RB_SPI_NRF_CS, gpioDirection_Output);
gpioSetPullup(&RB_SPI_NRF_CS_IO, gpioPullupMode_Inactive);
gpioSetDir(RB_NRF_CE, gpioDirection_Output);
gpioSetPullup(&RB_NRF_CE_IO, gpioPullupMode_PullUp);
CE_LOW();
// Setup for nrf24l01+
// power up takes 1.5ms - 3.5ms (depending on crystal)
CS_LOW();
nrf_write_reg(R_CONFIG,
R_CONFIG_PRIM_RX| // Receive mode
R_CONFIG_PWR_UP| // Power on
R_CONFIG_EN_CRC // CRC on, single byte
);
nrf_write_reg(R_EN_AA, 0); // Disable Enhanced ShockBurst;
// Set speed / strength
nrf_write_reg(R_RF_SETUP,DEFAULT_SPEED|R_RF_SETUP_RF_PWR_3);
// Clear MAX_RT, just in case.
nrf_write_reg(R_STATUS,R_STATUS_MAX_RT);
};
void sd_write(char __flash *str, unsigned long int bpos) {
CS_LOW();
spi_sendbyte(0xFF);
//converting bpos to 4 bytes and set write-start position
spi_sendbyte(0x58);
spi_sendbyte(((bpos & 0xFF000000)>>24));
spi_sendbyte(((bpos & 0x00FF0000)>>16));
spi_sendbyte(((bpos & 0x0000FF00)>>8));
spi_sendbyte(((bpos & 0x000000FF)));
spi_sendbyte(0x00); //CRC
while (spi_sendbyte(0xFF)!=0x0);
spi_sendbyte(0xFF);
spi_sendbyte(0xFE);
_spi_sendtext(str); //str len up to 512 bytes
spi_sendbyte(0x00); //1-st byte CRC
spi_sendbyte(0x00); //2-nd byte CRC
while (spi_sendbyte(0xFF)&0x5 != 0x5); //waiting for the command reception signal
while (spi_sendbyte(0xFF)!=0x00); //waiting for the command reception signal
test(2);
CS_HIGH();
}
BYTE SD_WriteOneSector(DWORD sector,BYTE* buf){//写一个扇区(buf为512字节)，成功返回0
BYTE rtn;
WORD i,cnt=0;
SPI_SetSpeedHigh();//设定SPI到高速模式
rtn=SD_SendCommand(24,sector<<9);//读命令
if(rtn!=0x00)
return rtn;
CS_LOW();
SPI_ByteRW(0xFF);
SPI_ByteRW(0xFF);
SPI_ByteRW(0xFF);
SPI_ByteRW(0xFE);//发开始符
for(i=0;i<512;i++){//送512字节数据
SPI_ByteRW(*(buf++));
}
SPI_ByteRW(0xFF);//dummy crc
SPI_ByteRW(0xFF);
rtn=SPI_ByteRW(0xFF);
if((rtn & 0x1F)!=0x05){//等待是否成功
CS_HIGH();
return rtn;
}
//等待操作完
while(!SPI_ByteRW(0xFF)){
if((cnt++)==0xFFFF){
CS_HIGH();
return 1;//超时退出
}
}
CS_HIGH();
SPI_ByteRW(0xFF);//额外8个时钟周期
return 0;
}
rt_size_t fm25_read(rt_device_t dev, rt_off_t offset, void * buf, rt_size_t size)
{
uint32_t index;
uint8_t *buffer = (uint8_t*) buf;
fram_lock();
//spi_config();
//rt_kprintf("READ: %d, size=%d\n", offset, size);
CS_LOW();
spi_readwrite( FM25_READ);
spi_readwrite( (offset >> 8)&0xFF );
spi_readwrite( offset & 0xFF );
for(index=0; index<size; index++)
{
*buffer++ = spi_readwrite(0xFF);
if( spi_timeout_cnt > 0 )
{
fram_unlock();
spi_timeout_cnt = 0;
rt_kprintf("Read time out\n");
return -1;
}
offset++;
}
CS_HIGH();
fram_unlock();
return size;
}
void nrf_read_pkt_crc(int len, uint8_t* data, uint8_t* crc){
CS_LOW();
xmit_spi(C_R_RX_PAYLOAD);
sspReceive(0,data,len);
sspReceive(0,crc,2);
CS_HIGH();
};
STATIC mp_obj_t irq_callback(mp_obj_t line)
{
DEBUG_printf("<< IRQ; state=%lu >>\n", sSpiInformation.ulSpiState);
switch (sSpiInformation.ulSpiState) {
case eSPI_STATE_POWERUP:
/* This means IRQ line was low call a callback of HCI Layer to inform on event */
DEBUG_printf(" - POWERUP\n");
sSpiInformation.ulSpiState = eSPI_STATE_INITIALIZED;
break;
case eSPI_STATE_IDLE:
DEBUG_printf(" - IDLE\n");
sSpiInformation.ulSpiState = eSPI_STATE_READ_IRQ;
/* IRQ line goes down - we are start reception */
CS_LOW();
// Wait for TX/RX Compete which will come as DMA interrupt
SpiReadHeader();
sSpiInformation.ulSpiState = eSPI_STATE_READ_EOT;
SSIContReadOperation();
break;
case eSPI_STATE_WRITE_IRQ:
DEBUG_printf(" - WRITE IRQ\n");
SpiWriteDataSynchronous(sSpiInformation.pTxPacket, sSpiInformation.usTxPacketLength);
sSpiInformation.ulSpiState = eSPI_STATE_IDLE;
CS_HIGH();
break;
}
return mp_const_none;
}
DRESULT dataflash_random_read(BYTE *buff, DWORD offset, DWORD length) {
if (!length) return RES_PARERR;
if (status & STA_NOINIT) return RES_NOTRDY;
if (offset+length > MAX_PAGE*256) return RES_PARERR;
do {
wait_for_ready();
DWORD pageaddr = ((offset/256) << 9) | (offset%256);
DWORD remaining = 256 - offset%256;
if (remaining > length) {
remaining = length;
}
length -= remaining;
offset += remaining;
CS_LOW();
xmit_spi(OP_PAGEREAD);
xmit_spi((BYTE)(pageaddr >> 16));
xmit_spi((BYTE)(pageaddr >> 8));
xmit_spi((BYTE)pageaddr);
xmit_spi(0x00); // follow up with 4 don't care bytes
xmit_spi(0x00);
xmit_spi(0x00);
xmit_spi(0x00);
do {
rcvr_spi_m(buff++);
} while (--remaining);
CS_HIGH();
} while (length);
return length ? RES_ERROR : RES_OK;
}
uint8_t nrf_cmd_status(uint8_t cmd)
{
CS_LOW();
sspSendReceive(&cmd, 1);
CS_HIGH();
return cmd;
};
void nrf_read_pkt(int len, uint8_t* data)
{
CS_LOW();
sspSendByte(C_R_RX_PAYLOAD);
sspReceive(data,len);
CS_HIGH();
};
void fm25_hw_init()
{
int i = 0xFFFFF;
fm25_spi_cfg();
while(i--);
//spi_config();
CS_LOW();
spi_readwrite( FM25_WRDI );
CS_HIGH();
spi_flash_device.type = RT_Device_Class_Block;
spi_flash_device.init = fm25_init;
spi_flash_device.open = fm25_open;
spi_flash_device.close = fm25_close;
spi_flash_device.read = fm25_read;
spi_flash_device.write = fm25_write;
spi_flash_device.control = fm25_control;
/* no private */
spi_flash_device.user_data = RT_NULL;
rt_device_register(&spi_flash_device, "fram0",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
}
void nrf_write_reg(const uint8_t reg, const uint8_t val)
{
CS_LOW();
sspSendByte(C_W_REGISTER | reg);
sspSendByte(val);
CS_HIGH();
};
// Reading the contents of the CSD and CID registers in SPI mode is a simple
// read-block transaction.
unsigned char mmcReadRegister (const char cmd_register, const unsigned char length, unsigned char *pBuffer)
{
unsigned char uc = 0;
unsigned char rvalue = MMC_TIMEOUT_ERROR;
if (mmcSetBlockLength (length) == MMC_SUCCESS)
{
CS_LOW ();
// CRC not used: 0xff as last byte
mmcSendCmd(cmd_register, 0x000000, 0xff);
// wait for response
// in the R1 format (0x00 is no errors)
if (mmcGetResponse() == 0x00)
{
if (mmcGetXXResponse(0xfe)== 0xfe)
for (uc = 0; uc < length; uc++)
pBuffer[uc] = spiSendByte(0xff); //mmc_buffer[uc] = spiSendByte(0xff);
// get CRC bytes (not really needed by us, but required by MMC)
spiSendByte(0xff);
spiSendByte(0xff);
rvalue = MMC_SUCCESS;
}
else
rvalue = MMC_RESPONSE_ERROR;
// CS = HIGH (off)
CS_HIGH ();
// Send 8 Clock pulses of delay.
spiSendByte(0xff);
}
CS_HIGH ();
return rvalue;
} // mmc_read_register
uint16_t max1168_read_adc(uint8_t reg, enum max1168_clk clk, enum max1168_mode mode)
{
#define CH2 0x20
uint16_t raw_data;
max1168_init();
if (mode == MODE_8BIT)
PORTB &= ~(1<<DSEL);
else
PORTB |= (1<<DSEL);
CS_LOW();
/* TODO: remove hardcoded channel */
max1168_xfer_byte(CH2 | clk);
if (mode == MODE_16BIT)
max1168_xfer_byte(SPI_DUMMY_BYTE);
if (clk == CLK_INTERNAL)
while ((PINB & (1<<EOC)));
raw_data = max1168_xfer_byte(SPI_DUMMY_BYTE) << 8;
raw_data |= max1168_xfer_byte(SPI_DUMMY_BYTE);
CS_HIGH();
return raw_data;
}
void nrf_write_long(const uint8_t cmd, int len, const uint8_t* data)
{
CS_LOW();
sspSendByte(cmd);
sspSend(data,len);
CS_HIGH();
};
void nrf_init()
{
//ce
LPC_GPIO2->FIODIR |= (1<<2);
//cs_rad
LPC_GPIO2->FIODIR |= (1<<6);
CE_LOW();
delay_ms(11);
// Setup for nrf24l01+
// power up takes 1.5ms - 3.5ms (depending on crystal)
CS_LOW();
nrf_write_reg(R_CONFIG,
R_CONFIG_PRIM_RX| // Receive mode
R_CONFIG_PWR_UP| // Power on
R_CONFIG_EN_CRC // CRC on, single byte
);
nrf_write_reg(R_EN_AA, 0); // Disable Enhanced ShockBurst;
// Set speed / strength
nrf_write_reg(R_RF_SETUP,DEFAULT_SPEED|R_RF_SETUP_RF_PWR_3);
// Clear MAX_RT, just in case.
nrf_write_reg(R_STATUS,R_STATUS_MAX_RT);
// CS_HIGH();
};
// TODO: This function will not exit gracefully if SD card does not do what it should
void SD_read(unsigned long sector, unsigned short offset, unsigned char * buffer,
unsigned short len) {
unsigned short i, pos = 0;
CS_LOW();
SPI_send(0x51); // sector * 512 = sector << 9
SPI_send(sector>>15); // sector*512 >> 24
SPI_send(sector>>7); // sector*512 >> 16
SPI_send(sector<<1); // sector*512 >> 8
SPI_send(0); // sector*512
SPI_send(0xFF);
for(i=0; i<10 && SPI_send(0xFF) != 0x00; i++) {} // wait for 0
for(i=0; i<10 && SPI_send(0xFF) != 0xFE; i++) {} // wait for data start
for(i=0; i<offset; i++) // "skip" bytes
SPI_send(0xFF);
for(i=0; i<len; i++) // read len bytes
buffer[i] = SPI_send(0xFF);
for(i+=offset; i<512; i++) // "skip" again
SPI_send(0xFF);
// skip checksum
SPI_send(0xFF);
SPI_send(0xFF);
CS_HIGH();
}
void nrf_read_long(const uint8_t cmd, int len, uint8_t* data){
CS_LOW();
xmit_spi(cmd);
for(int i=0;i<len;i++)
data[i] = 0x00;
sspSendReceive(0,data,len);
CS_HIGH();
};
uint8_t nrf_read_reg(const uint8_t reg){
uint8_t val;
CS_LOW();
xmit_spi(C_R_REGISTER | reg);
rcv_spi(&val);
CS_HIGH();
return val;
};
void SerialFlash_BlockErase2(long address)
{
CS_LOW();
SPI_BYTE(CMD_BE2);
SPI_BYTE((unsigned char)(address>>16));
SPI_BYTE((unsigned char)(address>>8));
SPI_BYTE((unsigned char)(address & 0xFF));
CS_HIGH();
}
void SpiOpen(gcSpiHandleRx pfRxHandler)
{
DEBUG_printf("SpiOpen\n");
/* initialize SPI state */
sSpiInformation.ulSpiState = eSPI_STATE_POWERUP;
sSpiInformation.SPIRxHandler = pfRxHandler;
sSpiInformation.usTxPacketLength = 0;
sSpiInformation.pTxPacket = NULL;
sSpiInformation.pRxPacket = (unsigned char *)spi_buffer;
sSpiInformation.usRxPacketLength = 0;
spi_buffer[CC3000_RX_BUFFER_SIZE - 1] = CC3000_BUFFER_MAGIC_NUMBER;
wlan_tx_buffer[CC3000_TX_BUFFER_SIZE - 1] = CC3000_BUFFER_MAGIC_NUMBER;
/* SPI configuration */
SPI_HANDLE->Init.Mode = SPI_MODE_MASTER;
SPI_HANDLE->Init.Direction = SPI_DIRECTION_2LINES;
SPI_HANDLE->Init.DataSize = SPI_DATASIZE_8BIT;
SPI_HANDLE->Init.CLKPolarity = SPI_POLARITY_LOW;
SPI_HANDLE->Init.CLKPhase = SPI_PHASE_2EDGE;
SPI_HANDLE->Init.NSS = SPI_NSS_SOFT;
SPI_HANDLE->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
SPI_HANDLE->Init.FirstBit = SPI_FIRSTBIT_MSB;
SPI_HANDLE->Init.TIMode = SPI_TIMODE_DISABLED;
SPI_HANDLE->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
SPI_HANDLE->Init.CRCPolynomial = 7;
spi_init(SPI_HANDLE);
// configure wlan CS and EN pins
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.Speed = GPIO_SPEED_FAST;
GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStructure.Pull = GPIO_NOPULL;
GPIO_InitStructure.Alternate = 0;
GPIO_InitStructure.Pin = PIN_CS->pin_mask;
HAL_GPIO_Init(PIN_CS->gpio, &GPIO_InitStructure);
GPIO_InitStructure.Pin = PIN_EN->pin_mask;
HAL_GPIO_Init(PIN_EN->gpio, &GPIO_InitStructure);
HAL_GPIO_WritePin(PIN_CS->gpio, PIN_CS->pin_mask, GPIO_PIN_SET);
HAL_GPIO_WritePin(PIN_EN->gpio, PIN_EN->pin_mask, GPIO_PIN_RESET);
/* do a dummy read, this ensures SCLK is low before
actual communications start, it might be required */
CS_LOW();
uint8_t buf[1];
HAL_SPI_Receive(SPI_HANDLE, buf, sizeof(buf), SPI_TIMEOUT);
CS_HIGH();
// register EXTI
extint_register((mp_obj_t)PIN_IRQ, GPIO_MODE_IT_FALLING, GPIO_PULLUP, (mp_obj_t)&irq_callback_obj, true, NULL);
extint_enable(PIN_IRQ->pin);
DEBUG_printf("SpiOpen finished; IRQ.pin=%d IRQ_LINE=%d\n", PIN_IRQ->pin, PIN_IRQ->pin);
}
void SerialFlash_SectorErase(long address)
{
CS_LOW();
SPI_BYTE(CMD_SE);
SPI_BYTE((unsigned char)(address>>16));
SPI_BYTE((unsigned char)(address>>8));
SPI_BYTE((unsigned char)(address & 0xFF));
CS_HIGH();
}
static rt_err_t fm25_close(rt_device_t dev)
{
CS_LOW();
spi_readwrite( FM25_WRDI );
CS_HIGH();
SPI_Cmd(FM25_SPI, DISABLE);
return RT_EOK;
}
static uint8_t fm25_read_status(void)
{
uint8_t tmp;
CS_LOW();
spi_readwrite( FM25_RDSR );
tmp=spi_readwrite(0xFF);
CS_HIGH();
return tmp;
}
static
int select (void) /* 1:Successful, 0:Timeout */
{
CS_LOW(); /* Set CS# low */
xchg_spi(0xFF); /* Dummy clock (force DO enabled) */
if (wait_ready(500)) return 1; /* Wait for card ready */
deselect();
return 0; /* Timeout */
}
static void wait_for_ready() {
BYTE reg_status = 0xFF;
CS_LOW();
xmit_spi(OP_STATUSREAD);
do {
rcvr_spi_m((uint8_t *) ®_status);
} while (!(reg_status & SB_READY));
CS_HIGH();
}
void SerialFlash_PageProgram(long address, unsigned char *buf, unsigned short size)
{
CS_LOW();
SPI_BYTE(CMD_PP);
SPI_BYTE((unsigned char)(address>>16));
SPI_BYTE((unsigned char)(address>>8));
SPI_BYTE((unsigned char)(address & 0xFF));
SPI_BUF_SEND(buf, size);
CS_HIGH();
}
/**************************************************************************//**
* @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;
}
unsigned char SerialFlash_ReadStatus(void)
{
unsigned char status;
CS_LOW();
SPI_BYTE(CMD_RDSR);
status = SPI_BYTE(0);
CS_HIGH();
return status;
}
