模拟SPI程序

合集下载

SPI编程说明

2：设定板子参数（打开程序之后回到设备操作，再选择文件选项，把板子厚度那一项修改一下即可，以实际板子厚度为准）。
３：划分ＦＯＶ（点击创建ＦＯＶ，然后选择是或者否即可）。
４：调整原点（点击手动添加，通过控制和调整板子原点，使钢网文件盒板子实际重叠即可。控制移动时调节视野的，调整板子原点才是移动坐标的。）
8:添加拼板（点击开始和结束，选择对应的两个焊盘）
8：添加拼板（选择对应的焊盘点之后，如果需要选择角度的选择角度，之后点击添加即可完成）。
9：编辑基准点（找到基准点，右键点击注册基准点，弹出对话框，点击OK即可完成第一个基准点的注册，再找到另外一个基准点以相同的办法完成即可。如果第二个基准点是粉红色，那就回到选择设定焊盘区域那，再注册一次）。
５：基准点设定（打开编辑基准点，选择基准点列表，双击数字1，即可切换到板子对应的基准点。基准点完成之后，保存基准点也是在这下面）。
5：基准点调节（先把曝光时间设置在３－７之间，点击二值化，再点击拍照，将基准点彻底的与周边颜色区分开来；并保证那个绿色的十字架在ＭＡＲＫ点的正中间，以相同的手法，完成另一个基准点的制作，并保存）。
2：当你连续测试几块板子都觉得你这个程序没有问题的话，那么你就到文件选项将这个程序保存；第一次做的时候保存不了，你可以选择点击导出程序。
3：这就是我们的程序制作大概步骤，剩下的一些都是需要自己的摸索的。
10：创建FOV（点击创建，弹出对话框选择是或者否都可以完成FOV的创建）。
11：OK NG（点出OK NG来，然后直接点击生成即可，注意两个都要点击生成的）。
12：程序到此已经做完，剩下的是在SPI软件的调试，所以将做好的程序导出即可。
二：SPI软件调试
1：加载检测程序（打到手动模式，选择文件选项，点击打开程序，选择加载程序，选择所需要打开的程序，双击或者选择再打开。）

SPI单主单从的验证及程序

SPI单主单从的验证及程序在主机测量：DORD=1主机CPHA=0，SCLK(CPOL=1)，MOSI(输出)主机输出A5、5A;前沿改变，后沿采样；主机CPHA=0，SCLK(CPOL=1),MISO（输入）从机输出F0主机输入;前沿改变，后沿采样（正好对着时钟的跳变处）在从机测量：主机CPHA=0，SCLK(CPOL=1)，MOSI(输出)主机输出A5、5A 从机输入;前沿改变，后沿采样主机CPHA=0，SCLK(CPOL=1),MISO（输入）从机输出F0主机输入前沿改变，后沿采样在主机测量：主机CPHA=1，SCLK(CPOL=1)，MOSI(输出)主机输出A5、5A;后沿改变，前沿采样主机CPHA=1，SCLK(CPOL=1),MISO（输入）从机输出F0主机输入;后沿改变，前沿采样在从机测量：主机CPHA=1，SCLK(CPOL=1)，MOSI(输出)主机输出A5、5A 从机输入；后沿改变，前沿采样主机CPHA=1，SCLK(CPOL=1),MISO（输入）从机输出F0主机输入；后沿改变，前沿采样MISO从机发AA时，SPI的总结：（1）由单主单从的实践中得到的体会。

STC12C5A60S2单片机实验。

实验验证DORD和CPHA的方式与资料所给信息不同。

DORD=1时，数据先发送最高位。

CPHA=0时，前沿改变，后沿采样。

CPHA=1时，前沿采样，后沿改变。

（2）实验程序：主机程序：SPSTAT EQU 0CDH//初始地址SPCTL EQU 0CEHSPDAT EQU 0CFHORG 0000HLJMP MAINORG 0100HMAIN:CLR P1.0 //判断单片机是否在工作状态MOV SPCTL, #0FDH ;如果为主机，SPI初始化控制寄存器，主机数据先发送最高位，前沿采样，后沿改变，频率设置低点，这样好采样。

MOV SPSTAT, #0C0H //状态寄存器复位，写1复位CLR P1.4 //从机选择拉低LOOP:MOV SPDAT,#0CCH ;将要发送的数据给发送寄存器MOV A,SPDATMOV P0,ASPI_WAIT: //判断是否发送完MOV A, SPSTATANL A,#80HJZ SPI_WAITMOV SPSTAT, #0C0H //发完复位NOPNOPNOPNOPNOPNOPMOV SPDAT,#0CCHMOV A,SPDATMOV P2,ASPI_WAIT1:MOV A, SPSTATANL A,#80HJZ SPI_WAIT1MOV SPSTAT, #0C0HNOPNOPNOPNOPNOPNOPLJMP LOOP ;发送完成后，循环开始END从机程序：SPSTAT EQU 0CDHSPCTL EQU 0CEHSPDAT EQU 0CFHORG 0000HLJMP MAINORG 0100HMAIN:CLR P1.0MOV SPCTL,#6DH //从机SSIG设置为0，MSTR为0，其它的和主机一样 MOV SPSTAT, #0C0HSPI_WAIT:MOV A, SPSTATANL A,#80HJZ SPI_WAITMOV SPSTAT, #0C0HMOV A,#0AAHMOV SPDAT,AMOV P0,ALJMP SPI_WAITEND。

51单片机模拟spi串行接口程序

unsigned char SPI_TransferByte(unsigned char val)
{
unsigned char BitCounter;
for(BitCounter=8; BiCounter!=0; BitCounter--)
{ CLK=0;
DataI=0; // write
if(val&0x80) DataI=1;
val<<=1;
CLK=1;
if(DataO)val|=1; // read
}
CLK=0;
return val;
}
sbit CLK= P1^5;
sbit DataI=P1^7;
sbiபைடு நூலகம் DataO=P1^6;
#define SD_Disable() CS=1 //片选关
#define SD_Enable() CS=0 //片选开
val<<=1;
CLK=1;
if(DataO)val|=1; // read
}
CLK=0;
return val;
}
sbit CLK= P1^5;
sbit DataI=P1^7;
sbit DataO=P1^6;
#define SD_Disable() CS=1 //片选关
#define SD_Enable() CS=0 //片选开
unsigned char SPI_TransferByte(unsigned char val)
{
unsigned char BitCounter;
for(BitCounter=8; BiCounter!=0; BitCounter--)
{ CLK=0;

运用4个普通IO口模拟SPI程序等

SIG--------- PORTB.0 双项输入 Din--------- PORTB.2 单项输出 Dout-------- PORTB.3 双项输入 SCLK-------- PORTB.4 单项输出 CS---------- PORTB.5 单项输出 SEL--------- PORTB.6 单项输出 RESET------- PORTB.1 单项输出 #define SET1302_RST PORTB|=(1<<7) #define CLR1302_RST PORTB&=~(1<<7) ************************************************************* ************************/ #define ATT_SIG PINB.0 #define ATT_Din PORTB.2 #define ATT_Dout PINB.3 #define ATT_SCLK PORTB.4
运用 4 个普通 I/O 口模拟 SPI 程序源代码
/******************************************************************** 函数名：uchar SpiReadWrite(uchar dat) 功能:SPI 发送接收一个数据说明：调用：入口参数：出口参数： ***********************************************************************/ uchar SpiReadWrite(uchar dat) { uchar i,temp; temp=0; SCK=0; _nop_(); for(i=0;i<8;i++) { if(dat & 0x80) { MOSI=1; }

stc12单片机SPI的nrf24l01程序

stc12单片机SPI的nrf24l01程序/////////////////////发送/////////////////////////////// #include <reg52.h>#include <intrins.h>typedef unsigned char uchar;#define uint unsigned int//****************************************IO端口定义***************************************sfr SPCTL = 0xCE;//SPI Control Register SSIG SPEN DORD MSTR CPOL CPHASPR1 SPR0 0000,0100sfr SPSTAT = 0xCD;//SPI Status Register SPIF WCOL - - - -- - 00xx,xxxxsfr SPDAT = 0xCF;sbit CE =P1^0;sbit CSN =P1^1;sbit IRQ =P1^2;sbit led=P1^3;//********************************************************* ********************************* uchar bdata sta;//状态标志sbit RX_DR =sta^6;sbit TX_DS =sta^5;sbit MAX_RT =sta^4;//*********************************************NRF24L01*************************************#define TX_ADR_WIDTH 5// 5 uints TX address width#define RX_ADR_WIDTH 5// 5 uints RX address width#define TX_PLOAD_WIDTH 32// 32 uints TX payload#define RX_PLOAD_WIDTH 32// 32 uints TX payloaduchar const TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};//本地地址uchar const RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};//接收地址 uchar codeTx_Buf[TX_PLOAD_WIDTH]={0xff,0xee,0x11,0x22,0x33,0xaa,0xbb,0x11,0x22,0x33,0xaa,0xbb,0x11,0x2 2,0x33,0xaa,0xbb,0x11,0x22,0x33,0xaa,0xbb,0x11,0x22,0x33,0xaa ,0xbb,0x11,0x22,0x33,0xee,0xff};//发送数据 ucharRx_Buf[RX_PLOAD_WIDTH];//接收数据//***************************************NRF24L01寄存器指令*******************************************************#define READ_REG 0x00 // 读寄存器指令 #defineWRITE_REG 0x20 // 写寄存器指令 #define RD_RX_PLOAD 0x61 // 读取接收数据指令 #define WR_TX_PLOAD 0xA0 // 写待发数据指令 #define FLUSH_TX0xE1 // 冲洗发送FIFO指令 #define FLUSH_RX 0xE2 // 冲洗接收 FIFO指令 #define REUSE_TX_PL 0xE3 // 定义重复装载数据指令#define NOP 0xFF // 保留//*************************************SPI(nRF24L01)寄存器地址****************************************************#define CONFIG 0x00 // 配置收发状态，CRC校验模式以及收发状态响应方式 #define EN_AA 0x01 // 自动应答功能设置 #define EN_RXADDR 0x02 // 可用信道设置#define SETUP_AW 0x03 // 收发地址宽度设置 #defineSETUP_RETR 0x04 // 自动重发功能设置 #define RF_CH 0x05 // 工作频率设置 #define RF_SETUP 0x06 // 发射速率、功耗功能设置 #define STATUS 0x07 // 状态寄存器 #define OBSERVE_TX 0x08 // 发送监测功能 #defineCD 0x09 // 地址检测 #define RX_ADDR_P0 0x0A // 频道0接收数据地址#defineRX_ADDR_P1 0x0B // 频道1接收数据地址 #defineRX_ADDR_P2 0x0C // 频道2接收数据地址 #defineRX_ADDR_P3 0x0D // 频道3接收数据地址 #defineRX_ADDR_P4 0x0E // 频道4接收数据地址 #defineRX_ADDR_P5 0x0F // 频道5接收数据地址 #define TX_ADDR 0x10 // 发送地址寄存器 #define RX_PW_P0 0x11 // 接收频道0接收数据长度 #define RX_PW_P1 0x12 // 接收频道1接收数据长度 #define RX_PW_P2 0x13 // 接收频道2接收数据长度 #define RX_PW_P3 0x14 // 接收频道3接收数据长度 #define RX_PW_P4 0x15 // 接收频道4接收数据长度 #define RX_PW_P5 0x16 // 接收频道5接收数据长度#define FIFO_STATUS 0x17 // FIFO栈入栈出状态寄存器设置/******************************************延时函数********************************************************///长延时 void Delay(unsigned int s) { unsigned int i,j;for(i=0;i<1000;i++)for(j=0;j<s;j++); } //短延时 voiddelay_ms(unsigned int x) { unsigned int i,j; i=0;for(i=0;i<x;i++) { j=108; while(j--); } } /************初始化5A spi***************/ void Init_SPI() { SPDAT=0; //初始化数据寄存器 SPSTAT=0XC0; //清除状态寄存器SPCTL=0XD2;//设置为主机模式主频不能超过2M //忽略SS 使能spi MSB SCLK空闲为0 第一个时钟边沿开始采集 spi通信的频率为CUP_CLK/16 } //SPDAT 读写一个字节 //TxData:要写入的字节//返回值:读取到的字节 uchar SPI_ReadWriteByte(uchar TxData){ SPDAT=TxData; //发送一个bytewhile((SPSTAT&0x80)==0); SPSTAT=0XC0; //清除状态寄存器 return SPDAT; //返回收到的数据 } //读取SPI寄存器值 //reg:要读的寄存器 uchar SPI_Read_Reg(uchar reg) { uchar reg_val; CSN = 0; //使能SPI传输SPI_ReadWriteByte(reg); //发送寄存器号reg_val=SPI_ReadWriteByte(0xFF);//读取寄存器内容 CSN = 1;//禁止SPI传输 return(reg_val); //返回状态值 } // 向寄存器REG写一个字节，同时返回状态字节reg寄存器地址 value写入的数据 uchar SPI_RW_Reg (ucharreg,uchar value) { uchar status; CSN=0;status=SPI_ReadWriteByte(reg);//发送寄存器号SPI_ReadWriteByte(value); //写入寄存器的值 CSN=1;return(status); } //写一个数据包 ucharSPI_Write_Buf(uchar reg, uchar *pBuf, uchar bytes) { ucharstatus,byte_ctr; CSN = 0;status=SPI_ReadWriteByte(reg); for(byte_ctr=0; byte_ctr<bytes;byte_ctr++) SPI_ReadWriteByte(*pBuf++); CSN = 1; return(status); } //读一个数据包 uchar SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars) { uchar status,uchar_ctr; CSN = 0;status = SPI_ReadWriteByte(reg);for(uchar_ctr=0;uchar_ctr<uchars;uchar_ctr++)pBuf[uchar_ctr]=SPI_ReadWriteByte(0xFF); CSN = 1; return(status); } /*******************************接 ***** 收 ***** 模 *****式 ***** 代 ***** 码 *************************************//*********************************************************************** *******************************/ /*函数:unsigned char nRF24L01_RxPacket(unsigned char* rx_buf) /*功能:数据读取后放如rx_buf接收缓冲区中/******************************************************************* ***********************************/ unsigned charnRF24L01_RxPacket(unsigned char* rx_buf) { // unsigned char revale=0; sta=SPI_Read_Reg(STATUS); // 读取状态寄存其来判断数据接收状况 SPI_RW_Reg(WRITE_REG+STATUS,sta); //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志 if(RX_DR) // 判断是否接收到数据{ SPI_Read_Buf(RD_RX_PLOAD,rx_buf,RX_PLOAD_WIDTH);// read receive payload from RX_FIFO bufferSPI_RW_Reg(FLUSH_RX,0xFF);//清除接受FIFO return 1;//读取数据完成标志 } return 0; }/******************************************************************* *********************************/ /*函数:voidRX_Mode(void) /*功能:数据接收配置/******************************************************************* *********************************/ void RX_Mode(void) { CE=0; //SPI_RW_Reg(FLUSH_RX,0x00);//清除接受FIFO //SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH); // Writes TX_Address to nRF24L01 SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // RX_Addr0 same as TX_Adr for Auto.Ack SPI_RW_Reg(WRITE_REG + EN_AA,0x01);//使能自动应答 Enable Auto.Ack:Pipe0 SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); //连接通道0和地址 Enable Pipe0//SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x1a); // 500us + 86us, 10 retrans...1a SPI_RW_Reg(WRITE_REG + RF_CH, 40);//通信频率0~125 设置通信的频率 Select RF channel 40SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为2字节 SPI_RW_Reg(WRITE_REG +RF_SETUP,0X07); //0x07 TX_PWR:0dBm, Datarate:1Mbps, LNA:HCURR // 设置TX发射参数,0db增益,2Mbps,低噪声增益开启 SPI_RW_Reg(WRITE_REG + CONFIG, 0x0F);//配置基本工作模式的参数 CE=1; delay_ms(130); }//************************************串口初始化********************************************************* void StartUART( void ) { //波特率9600 TMOD=0x20;//设置定模式2 TH1=0xFD; TL1=0xFD; SM1=1; //设置串口SCON,为方式1 SM0=0; REN=1; //串行允许 TR1=1; //启动定时器EA=1; //中断 ES=1; //打开串口 }//************************************通过串口将接收到数据发送给PC端 ************************************** voidR_S_Byte(uint R_Byte) { ES=0; SBUF=R_Byte; while(TI==0); TI=0; ES=1; } /************************************主函数************************************************************/ uchar NRF24L01_Check(void) { ucharbuf[5]={0XA5,0XA5,0XA5,0XA5,0XA5}; uchar i;SPI_Write_Buf(WRITE_REG+TX_ADDR,buf,5);//写入5个字节的地址.SPI_Read_Buf(TX_ADDR,buf,5); //读出写入的地址for(i=0;i<5;i++) if(buf[i]!=0XA5) break; if(i!=5) return 1;//检测24L01错误 return 0; //检测到24L01 } void main() { uint i=0; CE=0; CSN=1; led=0; Init_SPI(); StartUART(); //串口初始while(NRF24L01_Check())//检测不到24L01 { delay_ms(500);delay_ms(500); R_S_Byte(0x11); } //接收模式代码 RX_Mode(); //接受模式 Delay(10);//防止编译警告 while(1){ if(nRF24L01_RxPacket(Rx_Buf)) { for(i=0;i<TX_PLOAD_WIDTH;i++) { R_S_Byte(Rx_Buf[i]); //发送接收到的数据到电脑 } } Delay(10); } }。

SPI初始化程序

//SPI初始化子程序，用于数码管显示void spi_intial(){SpiaRegs.SPICCR.all =0x0047; // 使SPI处于复位方式, 下降沿, 八位数据SpiaRegs.SPICTL.all =0x0006; //主控模式,般时钟模式,使能talk,闭SPI中断SpiaRegs.SPIBRR =0x007F; //配置波特率SpiaRegs.SPICCR.all =SpiaRegs.SPICCR.all|0x0080; // 退出复位状态EALLOW;GpioMuxRegs.GPFMUX.all=0x000F;// 设置通用引脚为SPI引脚EDIS;}//IO初始化子程序void gpio_init(){EALLOW;GpioMuxRegs.GPAMUX.bit.TDIRA_GPIOA11=0; //GPIOA11设置为一般I/O口GpioMuxRegs.GPADIR.bit.GPIOA11=1; //把GPIOA11设置为输出//将GPIOE0~GPIOE2配置为一般I/O口输出,作138译码GpioMuxRegs.GPEMUX.all = GpioMuxRegs.GPEMUX.all&0xfff8; GpioMuxRegs.GPEDIR.all = GpioMuxRegs.GPEDIR.all|0x0007;//将GPIOB8~GPIOB15配置为一般I/O口,D0~D7GpioMuxRegs.GPBMUX.all = GpioMuxRegs.GPBMUX.all&0x00ff;EDIS;GpioDataRegs.GPADAT.bit.GPIOA11=0; //GPIOA11=0;该端口为74HC595锁存信号}//键扫描子程序K1~K8int Keyscan1(void){EALLOW;//将GPIOB8~GPIOB15配置为输入,D0~D7GpioMuxRegs.GPBDIR.all = GpioMuxRegs.GPBDIR.all&0x00ff;EDIS;GpioDataRegs.GPEDAT.all = 0xfff8; //选通KEY低8位for (i=0; i<100; i++){} //延时//判K1~K8是否按下if ((GpioDataRegs.GPBDAT.all|0x00ff)!=0xffff){for (i=0; i<30000; i++){} //延时消抖if ((GpioDataRegs.GPBDAT.all|0x00ff)!=0xffff){KeyReg1=GpioDataRegs.GPBDAT.all ; //读键值while ((GpioDataRegs.GPBDAT.all|0x00ff)!=0xffff) //判K1~K8是否松开{GpioDataRegs.GPDDAT.bit.GPIOD1 = !GpioDataRegs.GPDDAT.bit.GPIOD1;for (i=0; i<1000; i++){}}return (1);}}return (0);}//键扫描子程序K9~K16int Keyscan2(void){EALLOW;//将GPIOB8~GPIOB15配置为输入,D0~D7GpioMuxRegs.GPBDIR.all = GpioMuxRegs.GPBDIR.all&0x00ff;EDIS;GpioDataRegs.GPEDAT.all = 0xfff9; //选通KEY高8位for (i=0; i<100; i++){} //延时//判K8~K16是否按下if ((GpioDataRegs.GPBDAT.all|0x00ff)!=0xffff){for (i=0; i<30000; i++){} //延时消抖if ((GpioDataRegs.GPBDAT.all|0x00ff)!=0xffff){KeyReg2=GpioDataRegs.GPBDAT.all ; //读键值while ((GpioDataRegs.GPBDAT.all|0x00ff)!=0xffff) //判K8~K16是否松开{GpioDataRegs.GPDDAT.bit.GPIOD1 = !GpioDataRegs.GPDDAT.bit.GPIOD1; for (i=0; i<1000; i++){}}return (1);}}return (0);}//按键记录次数，显示在16个LED上void LedOut(Uint16 led){EALLOW;//将GPIOB8~GPIOB15配置为输出,D0~D7GpioMuxRegs.GPBDIR.all = GpioMuxRegs.GPBDIR.all|0xff00;EDIS;GpioDataRegs.GPEDAT.all = 0xfffb; //LEDB选通GpioDataRegs.GPBDAT.all = ~led; //显示高8位for (i=0; i<100; i++){} //延时GpioDataRegs.GPEDAT.all = 0xffff; //锁存高8位GpioDataRegs.GPEDAT.all = 0xfffa; //LEDA选通GpioDataRegs.GPBDAT.all = ~(led<<8); //显示低8位for (i=0; i<100; i++){}GpioDataRegs.GPEDAT.all = 0xffff; //锁存低8位}//键散转子程序K1~K8void KeyFunction1(unsigned int KeyReg1){switch(KeyReg1){case K1: {LEDReg= 0x00; //键号0}break;case K2: {LEDReg= 0x01; //键号1}break;case K3: {LEDReg= 0x02; //键号2}break;case K4: {LEDReg= 0x03; //键号3}break;case K5: {LEDReg= 0x04; //键号4}break;case K6: {LEDReg= 0x05; //键号5}break;case K7: {LEDReg= 0x06; //键号6}break;case K8: {LEDReg= 0x07; //键号7}break;default:break;}}//键散转子程序K9~K16void KeyFunction2(unsigned int KeyReg2) {switch(KeyReg2){case K9: {LEDReg= 0x08; //键号8}break;case K10: {LEDReg= 0x09; //键号9}break;case K11: {LEDReg= 0x0A; //键号A}break;case K12: {LEDReg= 0x0B; //键号B}break;case K13: {LEDReg= 0x0C; //键号C}break;case K14: {LEDReg= 0x0D; //键号D}break;case K15: {LEDReg= 0x0E; //键号E}break;case K16: {LEDReg= 0x0F; //键号F}break;default:break;}}void display (LEDReg) //显示子程序{GpioDataRegs.GPADAT.bit.GPIOA11=0; //给LACK信号一个低电平SpiaRegs.SPITXBUF =LEDCode[LEDReg]; //给数码管送数while(SpiaRegs.SPISTS.bit.INT_FLAG != 1){}SpiaRegs.SPIRXBUF = SpiaRegs.SPIRXBUF;GpioDataRegs.GPADAT.bit.GPIOA11=1; //给LACK信号一个高电平为锁存74HC595 for(i=0;i<10;i++){} //延时}void main(void){Uint16 keyNum = 0x0000; //按键次数初始化InitSysCtrl(); // 系统初始化程序，该子程序存放在DSP281x_sysctrl.c中DINT; //关闭总中断spi_intial(); //SPI初始化子程序gpio_init(); // I/O初始化子程序IER = 0x0000; // 关闭外围中断IFR = 0x0000; // 清中断标志LedOut(keyNum); // LED指示灯初始化for(i=0;i<8;i++)// 8个数码管清0{SpiaRegs.SPITXBUF =LEDCode[0]; //给数码管送数while(SpiaRegs.SPISTS.bit.INT_FLAG != 1){}SpiaRegs.SPIRXBUF = SpiaRegs.SPIRXBUF;}GpioDataRegs.GPADAT.bit.GPIOA11=1; //给LACK信号一个高电平为锁存74HC595 for(i=0;i<10;i++){}while (1){if (Keyscan1() == 1) // 调用键扫描K1~K8子程序{keyNum=keyNum+1; // 按键记数KeyFunction1(KeyReg1);display (LEDReg); //显示键值LedOut(keyNum); //显示按键次数}if (Keyscan2() == 1) // 调用键扫描K8~K16子程序{keyNum=keyNum+1;KeyFunction2(KeyReg2);display (LEDReg); //显示键值LedOut(keyNum); //显示按键次数}}}。

SPI完整程序

SPI接口源程序module simple_spi_top(// 8bit WISHBONE bus slave interfaceinput wire clk_i, // clockinput wire rst_i, // reset (asynchronous active low)input wire cyc_i, // cycleinput wire stb_i, // strobeinput wire [1:0] adr_i, // addressinput wire we_i, // write enableinput wire [7:0] dat_i, // data inputoutput reg [7:0] dat_o, // data outputoutput reg ack_o, // normal bus terminationoutput reg inta_o, // interrupt output// SPI portoutput reg sck_o, // serial clock outputoutput wire mosi_o, // MasterOut SlaveINinput wire miso_i // MasterIn SlaveOut);//// Module body//reg [7:0] spcr; // Serial Peripheral Control Register ('HC11 naming) wire [7:0] spsr; // Serial Peripheral Status register ('HC11 naming)reg [7:0] sper; // Serial Peripheral Extension registerreg [7:0] treg, rreg; // Transmit/Receive register// fifo signalswire [7:0] rfdout;reg wfre, rfwe;wire rfre, rffull, rfempty;wire [7:0] wfdout;wire wfwe, wffull, wfempty;// misc signalswire tirq; // transfer interrupt (selected number of transfers done) wire wfov; // write fifo overrun (writing while fifo full)reg [1:0] state; // statemachine statereg [2:0] bcnt;//// Wishbone interfacewire wb_acc = cyc_i & stb_i; // WISHBONE accesswire wb_wr = wb_acc & we_i; // WISHBONE write access// dat_ialways @(posedge clk_i or negedge rst_i)if (~rst_i)beginspcr <= #1 8'h10; // set master bitsper <= #1 8'h00;endelse if (wb_wr)beginif (adr_i == 2'b00)spcr <= #1 dat_i | 8'h10; // always set master bitif (adr_i == 2'b11)sper <= #1 dat_i;end// write fifoassign wfwe = wb_acc & (adr_i == 2'b10) & ack_o & we_i; assign wfov = wfwe & wffull;// dat_oalways @(posedge clk_i)case(adr_i) // synopsys full_case parallel_case2'b00: dat_o <= #1 spcr;2'b01: dat_o <= #1 spsr;2'b10: dat_o <= #1 rfdout;2'b11: dat_o <= #1 sper;endcase// read fifoassign rfre = wb_acc & (adr_i == 2'b10) & ack_o & ~we_i;// ack_oalways @(posedge clk_i or negedge rst_i)if (~rst_i)ack_o <= #1 1'b0;elseack_o <= #1 wb_acc & !ack_o;// decode Serial Peripheral Control Registerwire spie = spcr[7]; // Interrupt enable bitwire spe = spcr[6]; // System Enable bitwire dwom = spcr[5]; // Port D Wired-OR Mode Bit wire mstr = spcr[4]; // Master Mode Select Bit wire cpol = spcr[3]; // Clock Polarity Bitwire cpha = spcr[2]; // Clock Phase Bitwire [1:0] spr = spcr[1:0]; // Clock Rate Select Bits// decode Serial Peripheral Extension Registerwire [1:0] icnt = sper[7:6]; // interrupt on transfer countwire [1:0] spre = sper[1:0]; // extended clock rate selectwire [3:0] espr = {spre, spr};// generate status registerwire wr_spsr = wb_wr & (adr_i == 2'b01);reg spif;always @(posedge clk_i)if (~spe)spif <= #1 1'b0;elsespif <= #1 (tirq | spif) & ~(wr_spsr & dat_i[7]);reg wcol;always @(posedge clk_i)if (~spe)wcol <= #1 1'b0;elsewcol <= #1 (wfov | wcol) & ~(wr_spsr & dat_i[6]);assign spsr[7] = spif;assign spsr[6] = wcol;assign spsr[5:4] = 2'b00;assign spsr[3] = wffull;assign spsr[2] = wfempty;assign spsr[1] = rffull;assign spsr[0] = rfempty;// generate IRQ output (inta_o)always @(posedge clk_i)inta_o <= #1 spif & spie;//// hookup read/write buffer fifofifo4 #(8)rfifo(.clk ( clk_i ),.rst ( rst_i ),.clr ( ~spe ),.din ( treg ),.we ( rfwe ),.dout ( rfdout ),.re ( rfre ),.full ( rffull ),.empty ( rfempty )),wfifo(.clk ( clk_i ),.rst ( rst_i ),.clr ( ~spe ),.din ( dat_i ),.we ( wfwe ),.dout ( wfdout ),.re ( wfre ),.full ( wffull ),.empty ( wfempty ));//// generate clk dividerreg [11:0] clkcnt;always @(posedge clk_i)if(spe & (|clkcnt & |state))clkcnt <= #1 clkcnt - 11'h1;elsecase (espr) // synopsys full_case parallel_case4'b0000: clkcnt <= #1 12'h0; // 2 -- original M68HC11 coding 4'b0001: clkcnt <= #1 12'h1; // 4 -- original M68HC11 coding 4'b0010: clkcnt <= #1 12'h3; // 16 -- original M68HC11 coding 4'b0011: clkcnt <= #1 12'hf; // 32 -- original M68HC11 coding4'b0100: clkcnt <= #1 12'h1f; // 84'b0101: clkcnt <= #1 12'h7; // 644'b0110: clkcnt <= #1 12'h3f; // 1284'b0111: clkcnt <= #1 12'h7f; // 2564'b1000: clkcnt <= #1 12'hff; // 5124'b1001: clkcnt <= #1 12'h1ff; // 10244'b1010: clkcnt <= #1 12'h3ff; // 20484'b1011: clkcnt <= #1 12'h7ff; // 4096endcase// generate clock enable signalwire ena = ~|clkcnt;// transfer statemachinealways @(posedge clk_i)if (~spe)beginstate <= #1 2'b00; // idlebcnt <= #1 3'h0;treg <= #1 8'h00;wfre <= #1 1'b0;rfwe <= #1 1'b0;sck_o <= #1 1'b0;endelsebeginwfre <= #1 1'b0;rfwe <= #1 1'b0;case (state) //synopsys full_case parallel_case2'b00: // idle statebeginbcnt <= #1 3'h7; // set transfer countertreg <= #1 wfdout; // load transfer registersck_o <= #1 cpol; // set sckif (~wfempty) beginwfre <= #1 1'b1;state <= #1 2'b01;if (cpha) sck_o <= #1 ~sck_o;endend2'b01: // clock-phase2, next dataif (ena) beginsck_o <= #1 ~sck_o;state <= #1 2'b11;end2'b11: // clock phase1if (ena) begintreg <= #1 {treg[6:0], miso_i};bcnt <= #1 bcnt -3'h1;if (~|bcnt) beginstate <= #1 2'b00;sck_o <= #1 cpol;rfwe <= #1 1'b1;end else beginstate <= #1 2'b01;sck_o <= #1 ~sck_o;endend2'b10: state <= #1 2'b00;endcaseendassign mosi_o = treg[7];// count number of transfers (for interrupt generation)reg [1:0] tcnt; // transfer countalways @(posedge clk_i)if (~spe)tcnt <= #1 icnt;else if (rfwe) // rfwe gets asserted when all bits have been transferedif (|tcnt)tcnt <= #1 tcnt - 2'h1;elsetcnt <= #1 icnt;assign tirq = ~|tcnt & rfwe;endmodule******************************************************************************* // 4 entry deep fast fifomodule fifo4(clk, rst, clr, din, we, dout, re, full, empty);parameter dw = 8;input clk, rst;input clr;input [dw:1] din;input we;output [dw:1] dout;input re;output full, empty;reg [dw:1] mem[0:3];reg [1:0] wp;reg [1:0] rp;wire [1:0] wp_p1;wire [1:0] wp_p2;wire [1:0] rp_p1;wire full, empty;reg gb;always @(posedge clk or negedge rst)if(!rst) wp <= #1 2'h0;elseif(clr) wp <= #1 2'h0;elseif(we) wp <= #1 wp_p1;assign wp_p1 = wp + 2'h1;assign wp_p2 = wp + 2'h2;always @(posedge clk or negedge rst)if(!rst) rp <= #1 2'h0;elseif(clr) rp <= #1 2'h0;elseif(re) rp <= #1 rp_p1; assign rp_p1 = rp + 2'h1;// Fifo Outputassign dout = mem[ rp ];// Fifo Inputalways @(posedge clk)if(we) mem[ wp ] <= #1 din;// Statusassign empty = (wp == rp) & !gb;assign full = (wp == rp) & gb;// Guard Bit ...always @(posedge clk)if(!rst) gb <= #1 1'b0;elseif(clr) gb <= #1 1'b0;elseif((wp_p1 == rp) & we) gb <= #1 1'b1;elseif(re) gb <= #1 1'b0; endmodule。

模拟SPI程序

写程序：voidSPIx_WriteByte(u8 TxData){u8 j=0;SPI_FLASH_CLK_LOW(); //clk=0if(TxData&0x80){SPI_FLASH_DI_HIGH();} //mosi=1else{SPI_FLASH_DI_LOW();} //mosi=0for(j=0;j<3;j++); //延时SPI_FLASH_CLK_HIGH(); //clk=1，一个上升沿写入一位for(j=0;j<5;j++); //延时SPI_FLASH_CLK_LOW(); //clk=0if(TxData & 0x40){SPI_FLASH_DI_HIGH();} //mosi=1else{SPI_FLASH_DI_LOW();} //mosi=0for(j=0;j<3;j++); //延时SPI_FLASH_CLK_HIGH();for(j=0;j<5;j++);SPI_FLASH_CLK_LOW();if(TxData&0x20){SPI_FLASH_DI_HIGH();} //mosi=1else{SPI_FLASH_DI_LOW();} //mosi=0for(j=0;j<3;j++); //延时SPI_FLASH_CLK_HIGH();for(j=0;j<5;j++);SPI_FLASH_CLK_LOW();if(TxData&0x10){SPI_FLASH_DI_HIGH();} //mosi=1else{SPI_FLASH_DI_LOW();} //mosi=0for(j=0;j<3;j++); //延时SPI_FLASH_CLK_HIGH();for(j=0;j<5;j++);SPI_FLASH_CLK_LOW();if(TxData&0x08){SPI_FLASH_DI_HIGH();} //mosi=1else{SPI_FLASH_DI_LOW();} //mosi=0for(j=0;j<3;j++); //延时SPI_FLASH_CLK_HIGH();for(j=0;j<5;j++);SPI_FLASH_CLK_LOW();if(TxData&0x04){SPI_FLASH_DI_HIGH();} //mosi=1 else{SPI_FLASH_DI_LOW();} //mosi=0for(j=0;j<3;j++); //延时SPI_FLASH_CLK_HIGH();for(j=0;j<5;j++);SPI_FLASH_CLK_LOW();if(TxData&0x02){SPI_FLASH_DI_HIGH();} //mosi=1 else{SPI_FLASH_DI_LOW();} //mosi=0for(j=0;j<3;j++); //延时SPI_FLASH_CLK_HIGH();for(j=0;j<5;j++);SPI_FLASH_CLK_LOW(); //clk=0if(TxData&0x01){SPI_FLASH_DI_HIGH();}else{SPI_FLASH_DI_LOW();}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_HIGH(); //clk=1for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW(); //clk=0}读程序0x80==0x80u8 SPIx_ReadByte(void){u8i=0,j=0;for(j=0;j<3;j++); //延时SPI_FLASH_CLK_HIGH(); //clk=1if(GPIOC->IDR&0x80==0x80){i=i+0x80;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW(); //clk=0,下降沿读数for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x80==0x80){i=i+0x40;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x80==0x80){i=i+0x20;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x80==0x80){i=i+0x10;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x80==0x80){i=i+0x08;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x80==0x80){i=i+0x04;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x80==0x80){i=i+0x02;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x80==0x80){i=i+0x01;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();returni;}读程序0x40==0x40u8 SPIx_ReadByte(void){u8i=0,j=0;for(j=0;j<3;j++); //延时SPI_FLASH_CLK_HIGH(); //clk=1if(GPIOC->IDR&0x40==0x40){i=i+0x80;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW(); //clk=0,下降沿读数for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x40==0x40){i=i+0x40;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x40==0x40){i=i+0x20;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x40==0x40){i=i+0x10;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x40==0x40){i=i+0x08;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x40==0x40){i=i+0x04;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x40==0x40){i=i+0x02;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x40==0x40){i=i+0x01;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();returni;}读程序0x20==0x20u8 SPIx_ReadByte(void){u8i=0,j=0;for(j=0;j<3;j++); //延时SPI_FLASH_CLK_HIGH(); //clk=1if(GPIOC->IDR&0x20==0x20){i=i+0x80;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW(); //clk=0,下降沿读数for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x20==0x20){i=i+0x40;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x20==0x20){i=i+0x20;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x20==0x20){i=i+0x10;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x20==0x20){i=i+0x08;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x20==0x20){i=i+0x04;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x20==0x20){i=i+0x02;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x20==0x20){i=i+0x01;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();returni;}读程序0x10==0x10读程序0x08==0x08读程序0x04==0x04读程序0x02==0x02u8 SPIx_ReadByte(void){u8i=0,j=0;for(j=0;j<3;j++); //延时SPI_FLASH_CLK_HIGH(); //clk=1if(GPIOC->IDR&0x02==0x02){i=i+0x80;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW(); //clk=0,下降沿读数for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x02==0x02){i=i+0x40;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x02==0x02){i=i+0x20;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x02==0x02){i=i+0x10;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x02==0x02){i=i+0x08;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x02==0x02){i=i+0x04;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x02==0x02){i=i+0x02;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x02==0x02){i=i+0x01;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();returni;}读程序0x01==0x01u8 SPIx_ReadByte(void){u8i=0,j=0;for(j=0;j<3;j++); //延时SPI_FLASH_CLK_HIGH(); //clk=1if(GPIOC->IDR&0x01==0x01){i=i+0x80;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW(); //clk=0,下降沿读数for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x01==0x01){i=i+0x40;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x01==0x01){i=i+0x20;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x01==0x01){i=i+0x10;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x01==0x01){i=i+0x08;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x01==0x01){i=i+0x04;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x01==0x01){i=i+0x02;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW();for(j=0;j<5;j++);SPI_FLASH_CLK_HIGH();if(GPIOC->IDR&0x01==0x01){i=i+0x01;}for(j=0;j<3;j++); //延时SPI_FLASH_CLK_LOW(); returni;}。

STC单片机SPI功能程序

#include "reg51 .h"
#define FOSC 18432000L
#define BAUD (256 - FOSC / 32 / 115200)
typedef unsigned char BYTE;
typedef unsigned int WORD;
typedef unsigned long DWORD;
sfr AUXR = 0x8e; //Auxiliary register
sfr SPSTAT = 0x84; //SPI status register
#define SPIF 0x80 //SPSTAT.7
SPDAT = SPDAT; //mov data from receive buffer to send buffer
}
}
}
///////////////////////////////////////////////////////////
void InitSPI()
{
SPDAT = 0; //initial SPI data
SPSTAT = SPIF | WCOL; //clear SPI status
SPCTL = SPEN; //slave mode
SPSTAT = SPIF | WCOL; //clear SPI status
SPISS =1 ; //push high slave SS
return SPDAT; //return received SPI data
sfr SPDAT = 0x86; //SPI data register
sbit SPISS = P1^3; //SPI slave select, connect to slave' SS(P .4) pin

SPIM模拟器

16
改进版本：读入与输出
例： a = x + y; b=x-y # lixianfeng – 2010/09/20 … … main: ## Get first number from user, put into $t0. …… ## Get second number from user, put into $t1. …… # Print out $t2 & $t3 move $a0, $t2 # move the number to print into $a0 li $v0, 1 # load syscall print_int into $v0 syscall # make the syscall move $a0, $t2 li $v0, 1 syscall jr $ra
27
斐波那契数列
# fib.s – computing Fibonacci numbers # fib(n) = fib(n-2) + fib(n-1) for n > 1; otherwise fib(n) = 1 # Registers used: # $a0: parameter, initially n # $s0: placeholder for parameter n # $s1: fib(n-1) # $s2: fib(n-2) .text fib: ## Part 1. Preamble as a callee subu $sp, $sp, 32 # create its stack frame sw $ra, 28($sp) # save the return address sw $fp, 24($sp) # save $fp of caller sw $s0, 20($sp) # callee saved registers sw $s1, 16($sp) # callee saved registers sw $s2, 12($sp) # … addu $fp, $sp, 32 # move $fp to the frame base ## Other parts…

AVR的AT45DB041读写程序

void AT45DB041B_BufferWrite(uchar buffer,uint buffer_adderss,uchar *writ_pHeader,uint length)
{
uint i=0;
uchar statu_bit=0;
for(i=0;i<255;++i) //AT45DB041 busy
case 2:SPI_HostWriteByte(0x87);break; //buffer 2 writ
}
SPI_HostWriteByte(0x00);
SPI_HostWriteByte((unsigned char)(buffer_adderss>>8));
SPI_HostWriteByte((unsigned char)buffer_adderss);
{
uint i;
uchar statu_bit=0;
for(i=0;i<255;++i) //AT45DB041 busy
{
statu_bit=AT45DB041B_StatusRegisterRead();
if(testbit(statu_bit,7)) break;
}
SPI_CS_E;
SPI_HostWriteByte(0xe8);
SPI_HostWriteByte((uchar)(page_adderss>>7));
SPI_HostWriteByte((uchar)((page_adderss<<1)|(buffer_adderss>>8)));
*******************************************************/

运用4个普通IO口模拟SPI程序等.

#define ATT_CS
PORTB.5
#define ATT_SEL PORTB.6 #define ATT_REST PORTB.1 #define SET7022_Din PORTB|=(1<<2) #define CLR7022_Din PORTB&=~(1<<2) #define SET7022_SCLK PORTB|=(1<<4) #define CLR7022_SCLK PORTB&=~(1<<4) #define SET7022_CS #define CLR7022_CS PORTB|=(1<<5) PORTB&=~(1<<5)
else MOSI=0; dat<<=1; SCK=1; _nop_(); _nop_(); _nop_(); _nop_(); temp<<=1; if(MISO)temp++; SCK=0; _nop_(); _nop_(); _nop_(); _nop_(); } return temp; }
/************************************************************ *************************/ ulong Read_SPI(uchar comm) { uchar j; ulong rbyte=0; if(ATT_SIG==0) { SET7022_CS; CLR7022_SCLK; CLR7022_CS; #asm("cli") for( j=0;j<8;j++) { //关中断 //使能 SPI
2、SPI 简介：同步外设接口(SPI)是由摩托罗拉公司开发的全双工同步串行总线，该总线大量用在与 EEPROM、ADC、FLASH 和显示驱动器之类的慢速外设器件通信。 SPI（Serial Peripheral Interface）是一种串行同步通讯协议，由一个主设备和一个或多个从设备组成，主设备启动一个与从设备的同步通讯，从而完成数据的交换。通讯时，数据由 MOSI 输出，MISO 输入，数据在时钟的上升或下降沿由 MOSI 输出，在紧接着的下降或上升沿由 MISO 读入，这样经过 8/16 次时钟的改变，完成 8/16 位数据的传输。

模拟spiC程序

// return send_data; //返回接收到的数据
return rcv;
}
u8 Soft_SPI_ReadWrite_Byte(u8 send_data)
{
u8 i;
u8 rcv;
// Soft_SPI_CLK = 0;
Soft_SPI_MISO_IN(); //设置MISO为输入模式
for(i = 0;i < 8;i++)
/**********************************************************
* @ File name -> soft_spi.c
* @ Version -> V1.0
* @ Date -> 11-15-2013
* @ Brief -> GPIO模拟SPI接口函数
{
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //使能PA端口时钟
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3; //CLK and MOSI
* 函数功能 ---> 模拟SPI发送数据函数
* 入口参数 ---> send_data: 要发送的数据
* 返回参数 ---> 接收到的数据
* 功能说明 ---> 优先发送MSB，需要先发送LSB的请修改此函数
**********************************************************/

使用MCU的GPIO模拟SPI

用GPIO模拟SPI协议的实现一SPI协议概括SPI，是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。

是Motorola首先在其MC68HCXX系列处理器上定义的。

SPI接口主要应用在EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。

SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，正是出于这种简单易用的特性，现在越来越多的芯片集成了这种通信协议，比如AT91RM9200.SPI的通信原理很简单，它以主从方式工作，这种模式通常有一个主设备和一个或多个从设备，需要至少4根线，事实上3根也可以（单向传输时）。

也是所有基于SPI的设备共有的，它们是SDI（数据输入），SDO（数据输出），SCK（时钟），CS（片选）。

（1）SDO –主设备数据输出，从设备数据输入（2）SDI –主设备数据输入，从设备数据输出（3）SCLK –时钟信号，由主设备产生（4）CS –从设备使能信号，由主设备控制其中CS是控制芯片是否被选中的，也就是说只有片选信号为预先规定的使能信号时（高电位或低电位），对此芯片的操作才有效。

这就允许在同一总线上连接多个SPI设备成为可能。

接下来就负责通讯的3根线了。

通讯是通过数据交换完成的，这里先要知道SPI是串行通讯协议，也就是说数据是一位一位的传输的。

这就是SCK时钟线存在的原因，由SCK提供时钟脉冲，SDI，SDO 则基于此脉冲完成数据传输。

数据输出通过SDO线，数据在时钟上升沿或下降沿时改变，在紧接着的下降沿或上升沿被读取。

完成一位数据传输，输入也使用同样原理。

这样，在至少8次时钟信号的改变（上沿和下沿为一次），就可以完成8位数据的传输。

要注意的是，SCK信号线只由主设备控制，从设备不能控制信号线。

同样，在一个基于SPI的设备中，至少有一个主控设备。

AD420中文资料

摘要：AD420是具有灵活串行数字接口的16住数模转换器，它带有SPI和Microwire总线接口，使用方便、性价比高。

介绍了AD420的引脚功能、电气特性,阐述了AD420与MSP430的接口技术，并给出了在MSP430控制下的实际应用电路及程序。

关键词：AD420；D/A转换；MSP430；电流环1 概述AD420是ADI公司生产的高精度、低功耗全数字电流环输出转换器。

AD420的输出信号可以是电流信号，也可以是电压信号。

其中电流信号的输出范围为4mA~20mA，0mA~20mA或0mA~24mA，具体可通过引脚RANGE SELECTl，RANGE SELECT2进行配置。

当需要输出电压信号时，它也能从一个隔离引脚提供电压输出，这时需外接一个缓冲放大器，可输出0V～5V，0V~10V，±5V 或±10V电压。

AD420具有灵活的串行数字接口(最大速率可达3.3 Mb/s)，使用方便、性价比高、抑制干扰能力强，非常适合用于高精度远程控制系统。

AD420与单片机的接口方式有2种：3线制和异步制。

单片机系统通过AD420可实现连续的模拟量输出。

其主要特点如下：宽泛的电源电压范围为12 V~32 V，输出电压范围为0V~-2.5 V；带有3线模式的SPI或Microwire接口，可采集连续的模拟输入信号，采用异步模式时仅需少量的信号线；数据输出引脚可将多个AD420器件连接成菊链型；上电初始化时，其输出最小值为0 mA，4 mA或O V；具有异步清零引脚，可将输出复位至最小值(0mA、4 mA或0V)；BOOST引脚可连接一个外部晶体管来吸收回路电流，降低功耗；只需外接少量的外部器件，就能达到较高的精度。

AD420采用24引脚SOIC和PDIP封装，表1是其引脚功能说明。

2 工作原理在AD420中，二阶调节器用于保持最小死区。

从调节器发出的单字节流控制开关电流源，两个连续的电阻电容装置进行过滤。

【调试记录】ADS1247参考程序

【调试记录】ADS1247参考程序以前在做⼀个项⽬中，算是我⼈⽣的第⼀个项⽬，在⼤四保研后跟着师兄做的，师兄选定⽅案、芯⽚和制作板⼦，我主要负责软件调试和测试。

项⽬使⽤了⼀款TI的24位ADC，是ADS1247，与单⽚机通信采⽤的SPI，其实是模拟SPI时序，当时在⽹上查找了相关资料，发现资料太少了，⽽且例程也没有，但是调试其与单⽚机通信时总是出错，费了⼀个多星期，数据⼿册也看了多遍，发现这⽚⼦确实有点不好调，没办后来像许多⼈请教最后终于调通了。

后来发现仍然有很多的⽹友找我要例程，虽然很想直接沟通和交流，但是有时真的没时间，很抱歉，现在把例程贴出来，希望对⼤家会有帮助。

有问题可以评论，我也会时常来看看。

模拟SPI时序，采⽤内部参考电压，其实问题出在读数据和写数据两个⼦函数上。

头⽂件：#ifndef _ADS_SPI_H#define _ADS_SPI_H//**************端⼝映射**************//#define ADC_Start _RC7#define ADC_CS _RC6#define ADC_DRDY _RB6#define ADC_Dout _RB7#define ADC_Din _RB9#define ADC_SCLK _RB8#define ADC_RESET _RB5//**************指令集**************//#define WakeUp 0x00 //唤醒#define Sleep_C 0x02 //休眠#define SYNC 0x04 //同步ad转换#define Reset 0x06 //复位#define NOP 0xff //空指令#define RData 0x12 //读⼀次数据#define RDataC 0x14 //连续读数据#define SDataC 0x16 //停⽌连续读数据#define RReg 0x20 //读寄存器#define WReg 0x40 //写寄存器//**************寄存器地址***************//#define Reg_MUX0 0x00 //Multiplexer Control Register 0#define Reg_VBias 0x01 //Bias Voltage Register#define Reg_MUX1 0x02 //Multiplexer Control Register 1#define Reg_SYS0 0x03 //System Control Register 0#define Reg_CFC0 0x04#define Reg_CFC1 0x05#define Reg_CFC2 0x06#define Reg_FSC0 0x07#define Reg_FSC1 0x08#define Reg_FSC2 0x09#define Reg_IDAC0 0x0a //IDAC Control Register 0#define Reg_IDAC1 0x0b#define Reg_GPIOCFG 0x0c#define Reg_GPIODIR 0x0d#define Reg_GPIODAT 0x0e#define AD_REF 2.047998#define AD_LSB AD_REF/262143.0//#define AD_LSB AD_REF/8388608.0#define nop() asm("nop")void delay_AD(int num);void ADS1247_Init(void);unsigned char ADS1247SPI(unsigned char WriteData);void ADS1247WREG(unsigned char Address,unsigned char databyte);unsigned char ADS1247RREG(unsigned char Address);unsigned long ADS1247ReadData( );unsigned char ADS1247ReadByte( );#endif源程序：#include "ADS_SPI.h"//********AD延时函数********//void delay_AD(int num)//延时1.25*num（us）{int i=0;for (i= 0; i < num ;i++ );}//********连续读数据******//void AD_RDATAC(){ADS1247SPI(RDataC);delay_AD(100);}//***************************************************//函数名 : ADS1247SPI();//功能说明：ADS1247全双⼯通信//输⼊说明：写操作时，写⼊WriteData;// 读操作时，写⼊0xFF，读出SDOUT输出值//作者/时间/版本号://修改记录: ⽆//***************************************************unsigned char ADS1247SPI(unsigned char WriteData){unsigned char i,ReadData=0;for(i=0;i<8;i++){ADC_SCLK=1;nop();nop();nop();ReadData<<=1;if (WriteData & 0x80)ADC_Din=1;elseADC_Din=0;nop();nop();nop();if (ADC_Dout==1)ReadData++;ADC_SCLK=0;nop();nop();nop();WriteData<<=1;}return ReadData;}//***************************************************//函数名 : ADS1247WREG();//功能说明：ADS1247写寄存器//输⼊说明:将databyte 的值写⼊地址为Address 的寄存器中//作者/时间/版本号://修改记录: ⽆//***************************************************void ADS1247WREG(unsigned char Address,unsigned char databyte) {ADS1247SPI(0x40+(Address&0x0F));ADS1247SPI(0X00);ADS1247SPI(databyte);}//***************************************************//函数名 : ADS1247RREG();//功能说明：ADS1247读寄存器//输⼊说明:读地址为Address 的寄存器中的数据，返回该值//作者/时间/版本号://修改记录: ⽆//***************************************************unsigned char ADS1247RREG(unsigned char Address) {unsigned char RegData=0X00;ADS1247SPI(0x20+(Address&0x0F));ADS1247SPI(0X00);RegData=ADS1247SPI(0XFF);return RegData;}//***************************************************//函数名 : ADS1247ReadData();//功能说明：ADS1247读19位数据//输⼊说明://作者/时间/版本号://修改记录: ⽆//***************************************************unsigned long ADS1247ReadData(){unsigned char i=0;unsigned long WriteDataOut =0xFFFFFF;unsigned long ADCData=0;for(i=0;i<19;i++)//AD取19bit{ADC_SCLK=1;nop();nop();nop();ADCData<<=1;if (WriteDataOut & 0x800000)ADC_Din=1;elseADC_Din=0;nop();nop();nop();if (ADC_Dout==1)ADCData++;ADC_SCLK=0;nop();nop();nop();WriteDataOut<<=1;}return ADCData;}//***************************************************//函数名 : ADS1247ReadByte();//功能说明：ADS1247读8位数据//输⼊说明://作者/时间/版本号://修改记录: ⽆//***************************************************unsigned char ADS1247ReadByte(){unsigned char i=0;unsigned char WriteDataOut =0xFF;unsigned char ADCData=0;for(i=0;i<8;i++){ADC_SCLK=1;nop();nop();nop();ADCData<<=1;if (WriteDataOut & 0x80)ADC_Din=1;elseADC_Din=0;nop();nop();nop();if (ADC_Dout==1)ADCData++;ADC_SCLK=0;nop();nop();nop();WriteDataOut<<=1;}return ADCData;}//***************************************************//函数名 : ADS1247_Init();//功能说明：ads1247初始化//输⼊说明://作者/时间/版本号://修改记录: ⽆//***************************************************void ADS1247_Init(void){//端⼝设置_TRISC7 =0; //start是输出端_TRISC6 =0; //cs是输出端_TRISB6 =1; //DRDY是输⼊端_TRISB7 =1; //DOUT是输⼊端_TRISB9 =0; //din是输出端_TRISB8 =0; //sclk是输出端_TRISB5 =0; //Rsest是输出端_RB5=0; //resetdelay_AD(1);_RB5=1;delay_AD(500);//delay 0.6ms_RC7=1; //startdelay_AD(10);_RC6=0; //CS=0delay_AD(10);ADS1247WREG(Reg_MUX0 , 0x08); //AIN1 as positive input channel;AIN0 as negative input channel; ADS1247WREG(Reg_VBias , 0x00); //Bias voltage not enabledADS1247WREG(Reg_MUX1 , 0x30); //Onboard reference;ADS1247WREG(Reg_SYS0 , 0x02); //PGA=1;rate=20SPS 修改了ADS1247WREG(Reg_IDAC0 , 0x00); //DOUT/DRDY pin functions only as Data OutADS1247SPI(0x62);// 0110 0010 Self offset Calibrationdelay_AD(100);AD_RDATAC( );}。

运用4个普通IO口模拟SPI程序等

运用4个普通I/O口模拟SPI程序源代码收藏/********************************************************************函数名：uchar SpiReadWrite(uchar dat)功能:SPI发送接收一个数据说明：调用：入口参数：出口参数：***********************************************************************/ uchar SpiReadWrite(uchar dat){uchar i,temp;temp=0;SCK=0;_nop_();for(i=0;i<8;i++){if(dat & 0x80){MOSI=1;}else MOSI=0;dat<<=1;SCK=1;_nop_();_nop_();_nop_();_nop_();temp<<=1;if(MISO)temp++;SCK=0;_nop_();_nop_();_nop_();_nop_();}return temp;}1、SPI总线速度：波特率可以高达5Mbps，具体速度大小取决于SPI硬件。

例如，Xicor公司的SPI串行器件传输速度能达到5MHz；ATMEL的AT45DB021B，20 MHz Max Clock Frequency；LPC2214的SPI，最大数据位速率为输入时钟速率的1/8。

2、SPI简介：同步外设接口(SPI)是由摩托罗拉公司开发的全双工同步串行总线，该总线大量用在与EEPROM、ADC、FLASH和显示驱动器之类的慢速外设器件通信。

SPI（Serial Peripheral Interface）是一种串行同步通讯协议，由一个主设备和一个或多个从设备组成，主设备启动一个与从设备的同步通讯，从而完成数据的交换。

通讯时，数据由MOSI 输出，MISO 输入，数据在时钟的上升或下降沿由MOSI 输出，在紧接着的下降或上升沿由MISO 读入，这样经过8/16 次时钟的改变，完成8/16 位数据的传输。

SPI总线信号特性和完整性的测试程序与规定

SPI总线信号特性和完整性的测试程序与规定1. 简介SPI（Serial Peripheral Interface）总线是一种常用于串行通信的接口标准，用于在微控制器和外部设备之间传输数据。

为了确保SPI总线的正常工作和数据的可靠传输，需要进行信号特性和完整性的测试。

2. 测试程序为了测试SPI总线的信号特性和完整性，可以采用以下步骤和程序：1. 设置SPI主设备和从设备：确定SPI主设备和从设备的连接方式和参数设置，包括时钟频率、数据位数、传输模式等。

2. 发送测试数据：主设备向从设备发送特定的测试数据，可以是不同类型和长度的数据。

3. 接收数据并验证：从设备接收主设备发送的数据，并进行验证。

验证可以包括数据位的正确性、时序的准确性等。

4. 记录测试结果：记录测试过程中的数据发送和接收情况，以及验证结果。

3. 测试规定为了确保测试的准确性和可比性，应根据以下规定进行SPI总线信号特性和完整性的测试：1. 测试环境：测试应在稳定的实验环境中进行，尽量减少外界干扰。

2. 测试设备：选择合适的SPI主设备和从设备，确保设备的质量和性能符合要求。

3. 测试参数：根据实际需求选择合适的测试参数，包括时钟频率、数据位数、传输模式等。

4. 测试数据：选择不同类型和长度的测试数据，覆盖各种可能的情况。

5. 测试记录：记录测试过程中的数据发送和接收情况，以及验证结果，确保测试结果可追溯和可重复。

4. 注意事项在进行SPI总线信号特性和完整性的测试时，需要注意以下事项：1. 保持一致性：在进行不同测试之间，保持测试环境、设备和参数的一致性，确保测试结果的可比性。

2. 测试时间：根据实际需求，合理安排测试的时间和频率，以充分覆盖可能的情况。

3. 故障排除：在测试过程中，如果发现异常情况或测试结果与预期不符，应及时进行故障排除，确保测试的准确性和可靠性。

5. 总结SPI总线信号特性和完整性的测试是确保SPI总线正常工作和数据可靠传输的重要步骤。

中科蓝讯AB32VG1开发实践指南说明书

中科蓝讯AB32VG1开发实践指南文档更新日志2021-8-19 1.0.1版本更新1.更新UART文档2.更新RTC文档3.新增WIFI模块配置文档近日，国内领先的自主物联网操作系统（RT-Thread）厂商睿赛德科技联合其高级会员国内领先RISC-V物联网芯片公司中科蓝讯正式发布基于AB32VG1 RISC-V评估板，AB32VG1评估板原生搭载RT-Thread物联网操作系统，基于RT-Thread Studio提供SDK，并配备了数百页开发实践指南，践行为开发者提供易获取、易用的RISC-V开发平台的初心。

蓝讯骄龙AB32VG1是中科蓝讯在2020 RT-Thread 开发者大会上首度面向通用市场发布的其自主RISC-V内核32位MCU芯片，AB32VG1主频120M ，片上集成RAM 192K, Flash 4Mbit，ADC，PWM，USB，UART，IIC 等资源。

在软件开发上，AB32VG1的软件SDK内置RT-Thread Studio IDE中，可以让开发者毫无障碍的进行应用开发，搭配RT-Thread丰富的软件包可进一步降低开发门槛，助力开发者快速搭建自己的应用。

AB32VG1评估板具有丰富的软硬件资源、详尽的例程文档和低成本等优势。

在正式发布前已有数位开发者进行了内测尝鲜，并提供了宝贵的意见和建议，其中数位开发者提交了代码贡献如mysterywolf、JiangYangJie 、iysheng 、yaoyufan 、leton-tian，多位小伙伴参与撰写和校对了实践指南，再次向他们表示感谢。

A B32VG1硬件相关的资料：h t t p s://g i t e e.c o m/b l u e t r u m/A B32VG1_D O C以上信息如有错误，请联系官方人员微信改正：rtthread2020零、实践指南说明硬件介绍AB32VG1 开发板是以中科蓝讯(Bluetrum) 公司推出的基于RISC-V 架构的高配置芯片AB32VG1 为核心所组成的。