void SI4432_WriteReg(char addr,char val)
{
RF4432_SEL_0;
SPI_ReadWriteByte(addr|WR);
SPI_ReadWriteByte(val);
RF4432_SEL_1;
}
static rt_uint32_t xfer(struct rt_spi_device* device, struct rt_spi_message* message)
{
struct rt_spi_configuration * config = &device->config;
rt_uint32_t size = message->length;
const rt_uint8_t * send_ptr = message->send_buf;
rt_uint8_t * recv_ptr = message->recv_buf;
struct kinetis_spi_cs * kinetis_spi_cs = device->parent.user_data;
//rt_kprintf("spi size:%d\r\n", size);
while(size--)
{
rt_uint16_t data = 0xFF;
if(send_ptr != RT_NULL)
{
data = *send_ptr++;
}
/* 最后一个 并且是需要释放CS */
if((size == 0) && (message->cs_release))
{
data = SPI_ReadWriteByte(HW_SPI2, HW_CTAR0, data, kinetis_spi_cs->ch, kSPI_PCS_ReturnInactive);
}
else
{
data = SPI_ReadWriteByte(HW_SPI2, HW_CTAR0, data, kinetis_spi_cs->ch, kSPI_PCS_KeepAsserted);
}
if(recv_ptr != RT_NULL)
{
*recv_ptr++ = data;
}
}
return message->length;
}
uint8_t Si_t::ReadRegister (const uint8_t Addr) {
uint8_t Rpl;
NSEL_Lo();
SPI_ReadWriteByte (FSPI, Addr);
Rpl = SPI_ReadWriteByte (FSPI, 0);
NSEL_Hi();
return Rpl;
}
u8 NRF24L01_Write_Byte(u8 reg, u8 pBuf)
{
u8 status;
NRF24L01_CSN_L(); //使能SPI传输
status = SPI_ReadWriteByte(reg);//发送寄存器值(位置),并读取状态值
SPI_ReadWriteByte(pBuf); //写入数据
NRF24L01_CSN_H(); //关闭SPI传输
return status; //返回读到的状态值
}
u8 NRF24L01_Read_Reg(u8 reg)
{
u8 reg_val;
NRF24L01_CSN_L(); //使能SPI传输
SPI_ReadWriteByte(reg); //发送寄存器号
reg_val=SPI_ReadWriteByte(0XFF);//读取寄存器内容
NRF24L01_CSN_H(); //禁止SPI传输
return(reg_val); //返回状态值
}
//在指定位置读出指定长度的数据
//*pBuf:数据指针
//返回值,此次读到的状态寄存器值
u8 NRF24L01_Read_Buf(u8 regaddr,u8 *pBuf,u8 datalen)
{
u8 status,u8_ctr;
Clr_NRF24L01_CSN; //使能SPI传输
status=SPI_ReadWriteByte(regaddr); //发送寄存器值(位置),并读取状态值
for(u8_ctr=0;u8_ctr<datalen;u8_ctr++)pBuf[u8_ctr]=SPI_ReadWriteByte(0XFF);//读出数据
Set_NRF24L01_CSN; //关闭SPI传输
return status; //返回读到的状态值
}
u8 NRF_Write_Reg(u8 reg,u8 value)
{
u8 status;
NRF_CSN=0; //使能 SPI 传输
status =SPI_ReadWriteByte(NRF_SPI,reg); //发送寄存器号
SPI_ReadWriteByte(NRF_SPI,value); //写入寄存器的值
NRF_CSN=1; //禁止 SPI 传输
return(status); //返回状态值
}
//读取SPI寄存器值 ，regaddr:要读的寄存器
u8 NRF24L01_Read_Reg(u8 regaddr)
{
u8 reg_val;
Clr_NRF24L01_CSN; //使能SPI传输
SPI_ReadWriteByte(regaddr); //发送寄存器号
reg_val=SPI_ReadWriteByte(0XFF);//读取寄存器内容
Set_NRF24L01_CSN; //禁止SPI传输
return(reg_val); //返回状态值
}
//读取 SPI 寄存器值
//reg:要读的寄存器
u8 NRF_Read_Reg(u8 reg)
{
u8 reg_val;
NRF_CSN = 0; //使能 SPI 传输
SPI_ReadWriteByte(NRF_SPI,reg); //发送寄存器号
reg_val=SPI_ReadWriteByte(NRF_SPI,0XFF); //读取寄存器内容
NRF_CSN = 1; //禁止 SPI 传输
return(reg_val); //返回状态值
}
//通过SPI写寄存器
u8 NRF24L01_Write_Reg(u8 regaddr,u8 data)
{
u8 status;
Clr_NRF24L01_CSN; //使能SPI传输
status =SPI_ReadWriteByte(regaddr); //发送寄存器号
SPI_ReadWriteByte(data); //写入寄存器的值
Set_NRF24L01_CSN; //禁止SPI传输
return(status); //返回状态值
}
char SI4432_ReadReg(char addr)
{
char retval;
RF4432_SEL_0;
SPI_ReadWriteByte(addr|RR);
retval = SPI_ReadWriteByte(0xff);
RF4432_SEL_1;
return retval;
}
u8 NRF24L01_Write_Reg(u8 reg,u8 value)
{
u8 status;
CSN_L(); //使能SPI传输
status=SPI_ReadWriteByte(reg); //发送寄存器号
SPI_ReadWriteByte(value); //写入寄存器的值
CSN_H(); //禁止SPI传输
return(status); //返回状态值
}
u8 NRF24L01_Read_Buf(u8 reg,u8 *pBuf,u8 len)
{
u8 status,u8_ctr;
CSN_L(); //使能SPI传输
status=SPI_ReadWriteByte(reg); //发送寄存器值(位置),并读取状态值
for(u8_ctr=0;u8_ctr<len;u8_ctr++)
pBuf[u8_ctr]=SPI_ReadWriteByte(0XFF);//读出数据
CSN_H(); //禁止SPI传输
return status; //返回读到的状态值
}
u8 NRF24L01_Write_Buf(u8 reg, u8 *pBuf, u8 len)
{
u8 status,u8_ctr;
NRF24L01_CSN_L(); //使能SPI传输
status = SPI_ReadWriteByte(reg);//发送寄存器值(位置),并读取状态值
for(u8_ctr=0; u8_ctr<len; u8_ctr++)
SPI_ReadWriteByte(*pBuf++); //写入数据
NRF24L01_CSN_H(); //关闭SPI传输
return status; //返回读到的状态值
}
u8 NRF_Write_Buf(u8 reg, u8 *pBuf, u8 len)
{
u8 status,u8_ctr;
NRF_CSN = 0; //使能 SPI 传输
status = SPI_ReadWriteByte(NRF_SPI,reg); //发送寄存器值(位置),并读取状态值
for(u8_ctr=0; u8_ctr<len; u8_ctr++)
SPI_ReadWriteByte(NRF_SPI,*pBuf++); //写入数据
NRF_CSN = 1; //关闭 SPI 传输
return status; //返回读到的状态值
}
void SPI_ISR(void)
{
static uint8_t i = 1;
static uint16_t temp = 0;
if(i == 7)
{
SPI_ITDMAConfig(BOARD_SPI_INSTANCE, kSPI_IT_TCF, false);
shell_printf("ID:0x%X\r\n", temp);
return ;
}
if(i == 6)
{
temp <<= 8;
}
temp |= SPI_ReadWriteByte(BOARD_SPI_INSTANCE,HW_CTAR0, W25QXX_READ_ID_TABLE[i], 1, kSPI_PCS_KeepAsserted);
i++;
}
static uint32_t xfer(uint8_t *buf_in, uint8_t *buf_out, uint32_t len, uint8_t cs_state)
{
uint8_t dummy_in;
if(!buf_in)
buf_in = &dummy_in;
GPIO_WriteBit(HW_GPIOA, 5, 0); //cs
while(len--)
{
*buf_in = SPI_ReadWriteByte(HW_SPI0, *buf_out);
if(buf_out)
buf_out++;
if(buf_in != &dummy_in)
buf_in++;
}
GPIO_WriteBit(HW_GPIOA, 5, cs_state); //cs
return len;
}
void SPI2_Init()
{
SPI_InitTypeDef SPI_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
//开启SPI所用引脚的时钟，开启复用时钟，开启CE 、CSN 引脚对应的时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_AFIO,ENABLE);
//配置 CE 和 CSN 引脚
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_10;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//PA9时钟速度50MHz
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //
GPIO_Init(GPIOB, &GPIO_InitStructure);
//配置SCK MISO MOSI引脚 ，复用输出
/*!< Configure SPI_FLASH_SPI pins: SCK MISO MOSI*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
// GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
//配置IRQ引脚， 配置为上拉输入
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOB, &GPIO_InitStructure);
SPI_I2S_DeInit(SPI2);
SPI_Cmd(SPI2, DISABLE); //必须先禁用,才能改变MODE
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; //两线全双工
SPI_InitStructure.SPI_Mode = SPI_Mode_Master; //主
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; //8位
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low; //CPOL=0 时钟悬空低
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; //CPHA=0 数据捕获第1个
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; //软件NSS
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8 ; //8分频 9MHz
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; //高位在前
SPI_InitStructure.SPI_CRCPolynomial = 7; //CRC7
SPI_Init(SPI2, &SPI_InitStructure);
SPI_Cmd(SPI2, ENABLE);
SPI_ReadWriteByte(0xff); //启动传输
}
int CMD_SPI(int argc, char *const argv[])
{
uint8_t data[6];
uint32_t instance;
printf("SPI TEST CMD\r\n");
GPIO_QuickInit(HW_GPIOE, 6, kGPIO_Mode_OPP);
instance = SPI_QuickInit(SPI2_SCK_PD12_SOUT_PD13_SIN_PD14, kSPI_CPOL0_CPHA0, 20*1000*1000);
PORT_PinMuxConfig(HW_GPIOD, 12, kPinAlt2); //
PORT_PinMuxConfig(HW_GPIOD, 13, kPinAlt2); //
PORT_PinMuxConfig(HW_GPIOD, 14, kPinAlt2); //
PORT_PinMuxConfig(HW_GPIOD, 11, kPinAlt2); //SPI2_PCS0
PORT_PinMuxConfig(HW_GPIOD, 15, kPinAlt2); //SPI2_PCS1
SPI_EnableTxFIFO(HW_SPI2, true);
SPI_EnableRxFIFO(HW_SPI2, true);
// SPI_ReadWriteByte(instance, HW_CTAR0, 0x90, HW_SPI_CS1, kSPI_PCS_KeepAsserted);
// DelayMs(20);
if((argc == 2) && (!strcmp(argv[1], "FLASH")))
{
return DO_SPI_FLASH(argc, argv);
}
if((argc == 2) && (!strcmp(argv[1], "DMA")))
{
return DO_SPI_DMA(argc, argv);
}
printf("param error\r\n");
PEout(6) = !PEout(6);
SPI_ReadWriteByte(instance, HW_CTAR0, 0x90, HW_SPI_CS1, kSPI_PCS_KeepAsserted);
SPI_ReadWriteByte(instance, HW_CTAR0, 0x00, HW_SPI_CS1, kSPI_PCS_KeepAsserted);
SPI_ReadWriteByte(instance, HW_CTAR0, 0x00, HW_SPI_CS1, kSPI_PCS_KeepAsserted);
SPI_ReadWriteByte(instance, HW_CTAR0, 0x00, HW_SPI_CS1, kSPI_PCS_KeepAsserted);
// SPI_WaitSync(instance);
data[0] = SPI_ReadWriteByte(instance, HW_CTAR0, 0xFF, HW_SPI_CS1, kSPI_PCS_KeepAsserted);
data[1] = SPI_ReadWriteByte(instance, HW_CTAR0, 0xFF, HW_SPI_CS1, kSPI_PCS_ReturnInactive);
PEout(6) = !PEout(6);
printf("data:0x%02X 0x%02X\r\n", data[0], data[1]);
//初始化SPI
// SPI_QuickInit(BOARD_SPI_MAP, kSPI_CPOL0_CPHA1, 1*1000);
//安装回调函数
// SPI_CallbackInstall(BOARD_SPI_INSTANCE, SPI_ISR);
//开启SPI中断
// SPI_ITDMAConfig(BOARD_SPI_INSTANCE, kSPI_IT_TCF);
return CMD_RET_USAGE;
}
// ============================== Inner use ====================================
void Si_t::WriteRegister (const uint8_t Addr, const uint8_t AData) {
NSEL_Lo();
SPI_ReadWriteByte (FSPI, Addr | 0x80); // Send Addr with Write flag
SPI_ReadWriteByte (FSPI, AData); // Send data
NSEL_Hi();
}
void Si_t::FIFORead (void) {
NSEL_Lo();
SPI_ReadWriteByte(FSPI, 0x7F); // Write FIFO address
for (uint8_t i=0; i<PktLength; i++) RX_PktArray [i] = SPI_ReadWriteByte(FSPI, 0);
NSEL_Hi();
}
void AD7687_SendWord (uint16_t data)
{
SPI_ReadWriteByte(SPI0_PCS0_PA14,data,SPI_PCS_Inactive);
}
uint16_t AD7687_ReceiveWord(void)
{
uint16_t data;
data = SPI_ReadWriteByte(SPI0_PCS0_PA14,0,SPI_PCS_Inactive);
return data;
}
