精华内容
下载资源
问答
  • 模拟SPI

    2017-04-21 15:29:29
    模拟SPI

    IIC相对而言硬件设计较为简单,两线总线可以直接挂载很多芯片,但通信受干扰,容易进入“死锁”状态,需要软件处理。SPI相对而言需要的硬线更多,但不存在出现“死锁”的问题,另外通信速率也更高。

    死锁: 是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。

    那么为什么会产生死锁呢?
    1.因为系统资源不足。
    2.进程运行推进的顺序不合适。    
    3.资源分配不当。

    产生死锁的四个必要条件:

    互斥条件(Mutual exclusion):资源不能被共享,只能由一个进程使用。
    请求与保持条件(Hold and wait):已经得到资源的进程可以再次申请新的资源。
    非剥夺条件(No pre-emption):已经分配的资源不能从相应的进程中被强制地剥夺。
    循环等待条件(Circular wait):系统中若干进程组成环路,该环路中每个进程都在等待相邻进程正占用的资源。



    #ifndef _USER_SPI_FLASH_H_

    #define _USER_SPI_FLASH_H_

    #include "nrf_gpio.h"
    #include <stdint.h>

    //SPI hardware gpio config
    #define SPI_FLASH_CS    14
    #define SPI_FLASH_CLK   11
    #define SPI_FLASH_MOSI  12
    #define SPI_FLASH_MISO  13
    //#define SPI_FLASH_WP25

    //SPI hardware fuction
    #define    SPIFlash_Enable_CS     nrf_gpio_pin_clear(SPI_FLASH_CS) 
    #define    SPIFlash_Disable_CS   nrf_gpio_pin_set(SPI_FLASH_CS)
    #define    SPIFlash_Set_SCLK     nrf_gpio_pin_set(SPI_FLASH_CLK)
    #define    SPIFlash_Clr_SCLK     nrf_gpio_pin_clear(SPI_FLASH_CLK)
    #define    SPIFlash_Set_DO       nrf_gpio_pin_set(SPI_FLASH_MOSI)
    #define    SPIFlash_Clr_DO       nrf_gpio_pin_clear(SPI_FLASH_MOSI)
    #define    SPIFlash_Get_DI       nrf_gpio_pin_read(SPI_FLASH_MISO)

    #define W25Q80 0XEF13
    #define W25Q16 0XEF14
    #define W25Q32 0XEF15
    #define W25Q64 0XEF16

    #define FLASH_ID 0XEF14

    //指令表
    #define W25X_WriteEnable 0x06 
    #define W25X_WriteDisable 0x04 
    #define W25X_ReadStatusReg 0x05 
    #define W25X_WriteStatusReg 0x01 
    #define W25X_ReadData 0x03 
    #define W25X_FastReadData 0x0B 
    #define W25X_FastReadDual 0x3B 
    #define W25X_PageProgram 0x02 
    #define W25X_BlockErase 0xD8 
    #define W25X_SectorErase 0x20 
    #define W25X_ChipErase 0xC7 
    #define W25X_PowerDown 0xB9 
    #define W25X_ReleasePowerDown    0xAB 
    #define W25X_DeviceID 0xAB 
    #define W25X_ManufactDeviceID    0x90 
    #define W25X_JedecDeviceID 0x9F 

    //page  --256bytes
    //1 Sector =  4Kbytes
    //16 Sector = 1 Block  = 64Kbytes
    //W25X16
    //size = 2M BYTE= 32 Block = 512 Sector 

    void USER_SPI_Init(void);

    //uint8_t SPI_Flash_ReadWriteByte(uint8_t dat);//
    uint8_t SpiFlash_ReadOneByte(void);//read byte
    void SpiFlash_WriteOneByte(uint8_t DataBuffer);//wirte byte
    uint16_t SPI_Flash_ReadID(void); //read ID ,W25X16 is 0xEF14

    void SPI_Flash_ReadUID(uint8_t* TAB);
    uint8_t SpiFlash_ReadSR(void);//
    void SPI_FLASH_Write_SR(uint8_t sr); 
    void SPI_FLASH_Write_Enable(void); 
    void SPI_FLASH_Write_Disable(void);
    void SPI_Flash_Wait_Busy(void); 
    void SPI_Flash_Erase_Sector(uint32_t Dst_Addr);
    void SPI_Flash_Erase_Chip(void); 

    void SPI_Flash_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead); 
    void SPI_Flash_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);

    uint8_t SPI_Flash_Test(void);

    #endif /*_USER_SPI_FLASH_H_*/

    -------------------------------------------------------------------------------------------------------------------------------

    #include "user_spi_flash.h"

    //SPI hardware gpio config
    void USER_SPI_Init(void)
    {
    nrf_gpio_cfg_output(SPI_FLASH_CS);
    nrf_gpio_cfg_output(SPI_FLASH_CLK);
    nrf_gpio_cfg_output(SPI_FLASH_MOSI);
    nrf_gpio_cfg_input(SPI_FLASH_MISO,NRF_GPIO_PIN_NOPULL);
    }

    uint8_t SpiFlash_ReadOneByte(void)
    {
        uint8_t BitCount = 0;
        uint8_t retValue = 0;
        SPIFlash_Set_SCLK;  //clK=Hight
        for(BitCount = 0;BitCount < 8; BitCount++)
        {
            retValue <<= 1;
            SPIFlash_Set_SCLK;  //clK=Hight
            if(SPIFlash_Get_DI)
            {
                retValue |= 0x01;
            }
            else
            {
                retValue &= 0xFE;
            }
            SPIFlash_Clr_SCLK; //clK=Hight failling edge read one bit
        }
        SPIFlash_Set_SCLK;
        return (retValue);
    }

    void SpiFlash_WriteOneByte(uint8_t DataBuffer)
    {
        uint8_t BitCount = 0;
        SPIFlash_Clr_SCLK; //clK=Low 
        for(BitCount = 0;BitCount < 8; BitCount++)
        {
            SPIFlash_Clr_SCLK; //clK=Low 
            if(DataBuffer & 0x80)
            {
                SPIFlash_Set_DO;
            }
            else
            {
                SPIFlash_Clr_DO;
            }
            DataBuffer <<= 1;
            SPIFlash_Set_SCLK; //clK=Hight rising edge werite one bit
        }
        SPIFlash_Clr_SCLK;
        SPIFlash_Set_DO; // ont byte have send, MOSI line = Hight means is free
    }

    uint16_t SPI_Flash_ReadID(void)
    {   
      uint16_t Temp = 0;
      SPIFlash_Enable_CS;  
      SpiFlash_WriteOneByte(0x90);
      SpiFlash_WriteOneByte(0x00);
      SpiFlash_WriteOneByte(0x00);
      SpiFlash_WriteOneByte(0x00); 
      Temp |= SpiFlash_ReadOneByte()<<8;
      Temp |= SpiFlash_ReadOneByte();
      SPIFlash_Disable_CS;
      return Temp;
    }

    void SPI_Flash_ReadUID(uint8_t* TAB)
    {   
      SPIFlash_Enable_CS;  
      SpiFlash_WriteOneByte(0x4B);
      SpiFlash_WriteOneByte(0x00);
      SpiFlash_WriteOneByte(0x00);
      SpiFlash_WriteOneByte(0x00); 
      SpiFlash_WriteOneByte(0x00);
      TAB[0] = SpiFlash_ReadOneByte();
      TAB[1] = SpiFlash_ReadOneByte();
    TAB[2] = SpiFlash_ReadOneByte();
    TAB[3] = SpiFlash_ReadOneByte();
    TAB[4] = SpiFlash_ReadOneByte();
    TAB[5] = SpiFlash_ReadOneByte();
    TAB[6] = SpiFlash_ReadOneByte();
    TAB[7] = SpiFlash_ReadOneByte();
      SPIFlash_Disable_CS;
    }

    uint8_t SpiFlash_ReadSR(void)
    {
        uint8_t retValue = 0;
        SPIFlash_Enable_CS;
        SpiFlash_WriteOneByte(W25X_ReadStatusReg);
        retValue = SpiFlash_ReadOneByte();
        SPIFlash_Disable_CS;
        return retValue;
    }

    void SPI_FLASH_Write_SR(uint8_t sr)
    {
        SPIFlash_Enable_CS;
        SpiFlash_WriteOneByte(W25X_WriteStatusReg);
        SpiFlash_WriteOneByte(sr);
        SPIFlash_Disable_CS;
    }


    void SPI_FLASH_Write_Enable(void)
    {
        SPIFlash_Enable_CS;
        SpiFlash_WriteOneByte(W25X_WriteEnable);
        SPIFlash_Disable_CS;
    }

    void SPI_FLASH_Write_Disable(void)
    {
        SPIFlash_Enable_CS;
        SpiFlash_WriteOneByte(W25X_WriteDisable);
        SPIFlash_Disable_CS;
    }

    void SPI_Flash_Wait_Busy(void)
    {
    while ((SpiFlash_ReadSR()&0x01)==0x01);
    }

    void SPI_Flash_Erase_Sector(uint32_t Dst_Addr)
    {
    Dst_Addr*=4096;
    SPI_FLASH_Write_Enable(); 
    SPI_Flash_Wait_Busy();   
    SPIFlash_Enable_CS;
    SpiFlash_WriteOneByte(W25X_SectorErase); 
    SpiFlash_WriteOneByte((uint8_t)((Dst_Addr)>>16)); 
    SpiFlash_WriteOneByte((uint8_t)((Dst_Addr)>>8));   
    SpiFlash_WriteOneByte((uint8_t)Dst_Addr);  
    SPIFlash_Disable_CS;     
    SPI_Flash_Wait_Busy(); 
    }

    void SPI_Flash_Erase_Chip(void)   
    {                                             
    SPI_FLASH_Write_Enable();//SET WEL 
    SPI_Flash_Wait_Busy();   
    SPIFlash_Enable_CS;
    SpiFlash_WriteOneByte(W25X_ChipErase);
    SPIFlash_Disable_CS;     
    SPI_Flash_Wait_Busy();
    }

    void SPI_Flash_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead)

      uint16_t i;        
      SPIFlash_Enable_CS;
      SpiFlash_WriteOneByte(W25X_ReadData);  
      SpiFlash_WriteOneByte((uint8_t)((ReadAddr)>>16)); 
      SpiFlash_WriteOneByte((uint8_t)((ReadAddr)>>8));   
      SpiFlash_WriteOneByte((uint8_t)ReadAddr);   
      for(i=0;i<NumByteToRead;i++)
      { 
        pBuffer[i]=SpiFlash_ReadOneByte(); 
      }
      SPIFlash_Disable_CS;     
    }

    void SPI_Flash_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
    {
      uint16_t i;  
      SPI_FLASH_Write_Enable(); 
      SPIFlash_Enable_CS;
      SpiFlash_WriteOneByte(W25X_PageProgram);
      SpiFlash_WriteOneByte((uint8_t)((WriteAddr)>>16));
      SpiFlash_WriteOneByte((uint8_t)((WriteAddr)>>8));
      SpiFlash_WriteOneByte((uint8_t)WriteAddr);
      for(i=0;i<NumByteToWrite;i++) SpiFlash_WriteOneByte(pBuffer[i]);
      SPIFlash_Disable_CS; 
      SPI_Flash_Wait_Busy();


    uint8_t SPI_Flash_Test(void)
    {
    uint16_t id;
    uint8_t w_tab[5]={0x01,0x02,0x03,0x04,0x05};
    uint8_t r_tab[5]={0};
    uint8_t UID_tab[8];

    SPI_Flash_ReadUID(UID_tab);
    SPI_Flash_Erase_Sector(1);
    //SPI_Flash_Erase_Chip();
    SPI_Flash_Write_Page(w_tab,4096,5);
    SPI_Flash_Read(r_tab,4096,5);
    id=SPI_Flash_ReadID();
    if(id==0xEF15)
    {
    return 0;
    }
    else
    {
    return 1;
    }
    }






    展开全文
  • 模拟SPI
  • stm32模拟spi控制w5500

    2018-10-06 16:09:50
    stm32模拟spi控制w5500实现客户端模式,芯片spi借口有别的用途,通过软件模拟spi与w5500通信 stm32模拟spi控制w5500实现客户端模式,芯片spi借口有别的用途,通过软件模拟spi与w5500通信 stm32模拟spi控制w5500...
  • 软件模拟SPI程序代码4种模式:SPI协议简介,SPI接口介绍,SPI接口连接图,SPI数据传输方向,SPI传输模式,通过模拟SPI程序来加深理解
  • STM32F103模拟SPI

    2018-08-25 01:34:20
    STM32F103模拟SPI
  • freeRTOS,hal库,stm32f4,硬件SPI和模拟spi方式,与通信rn8209,实际运用过。
  • 基于STM32F103的模拟SPI

    2020-10-18 11:09:29
    基于STM32F103的模拟SPI
  • Io模拟SPI.txt

    2020-03-16 10:53:45
    这是STM32使用IO模拟spi程序通讯,包括引脚初始化、发送一个字节接受一个字节,发送多个字节,接受多个字节的函数,亲测好用。
  • 基于STM32F429开发板,用模拟SPI和硬件SPI两种方式驱动OLED。基于STM32F429开发板,用模拟SPI和硬件SPI两种方式驱动OLED
  • 1.前言 接上一篇“spi抽象/硬件spi”博客。...模拟spi与之前一篇“i2c抽象/模拟i2c”中描述的模拟i2c抽象思路一致,对模拟spi通过函数指针的方式进行封装,将时序实现源码和应用程序分离,方便移植和更

    1.前言

    接上一篇“spi抽象/硬件spi”博客。上一篇文章主要描述spi总线抽象过程和使用方式,同时实现stm32f1硬件spi,及spi抽象接口函数的使用。对于一些特殊mcu没有硬件spi,或者硬件spi不够用的情况下,可以用io翻转方式模拟spi总线。模拟spi实现,只需将硬件spi部分替代即可,上层代码或者器件外设驱动程序无须更改,方便移植。模拟spi与之前一篇“i2c抽象/模拟i2c”中描述的模拟i2c抽象思路一致,对模拟spi通过函数指针的方式进行封装,将时序实现源码和应用程序分离,方便移植和更换模拟spi的io口。

    展开全文
  • GPIO模拟SPI

    2019-04-17 21:28:00
    相同的,我用gpio模拟spi来理解spi协议。 我用的是4线spi,四线各自是片选、时钟、命令/数据、数据。 数据在时钟上升沿传递,数据表示的是数据还是命令由命令/数据线决定。 開始条件: void spi_start(void) { ...

    上次用gpio模拟i2c理解i2c协议。相同的,我用gpio模拟spi来理解spi协议。

    我用的是4线spi,四线各自是片选、时钟、命令/数据、数据。

    数据在时钟上升沿传递,数据表示的是数据还是命令由命令/数据线决定。


    開始条件:

    void spi_start(void)
    {
    	gpio_config(GPIO_CS, GPIO_OUTPUT);
    	udelay(SPI_SPEED_DURATION);
    	gpio_set(GPIO_CS, 0);/* start condition */
    	udelay(SPI_SPEED_DURATION);
    }

    结束条件:


    void spi_stop(void)
    {
    	gpio_set(GPIO_CS, 1); /* stop condition */
    	udelay(SPI_SPEED_DURATION);
    }

    传输数据:


    void spi_txdata_byte(uint8_t data)
    {
    	int i = 0;
    
    	for(i = 7; (i >= 0)&&(i <= 7); i--) {
    		gpio_set(GPIO_CLK, 0);//时钟上升沿传递数据
    		udelay(SPI_SPEED_DURATION);
    		if(i == 7) {
    			gpio_config(GPIO_MOSI, GPIO_OUTPUT);
    			udelay(SPI_SPEED_DURATION);
    		}
    
    		gpio_set(GPIO_MOSI, (data >> i) & 0x01);
    		udelay(SPI_SPEED_DURATION);
    		gpio_set(GPIO_CLK, 1);
    		udelay(SPI_SPEED_DURATION * 2);
    	}
    	
    	return;
    }



    转载于:https://www.cnblogs.com/ldxsuanfa/p/10726324.html

    展开全文
  • 模拟spi从机

    2015-09-16 17:30:00
    模拟spi的从机,同时通过cs线可以唤醒主机获取从机数据
  • 软件模拟SPI协议

    2021-01-12 15:47:24
    软件模拟SPI协议什么是SPISPI的通讯模式通讯协议详细程序简写程序结语 最近在学习51单片机的内容,为了防止自己学过就忘,在这里写一些平时的学习笔记,如果有错误希望大家可以给我指正一下。这里是最近学习的SPI...


    最近在学习51单片机的内容,为了防止自己学过就忘,在这里写一些平时的学习笔记,如果有错误希望大家可以给我指正一下。这里是最近学习的SPI串行总线通讯协议的内容,由于所用单片机没有硬件SPI,所以需要用IO口来模拟SPI。

    什么是SPI

    SPI的定义可以去网上查,能查到很多,这里主要记一下比较有用的部分。
    SPI的通信原理很简单,它以主从方式工作,这种模式通常有一个主设备和一个或多个从设备,需要至少4根线,事实上3根也可以(单向传输时)。这四根线分别是MISO、MOSI、SCLK、CS,具体的描述见下表:
    MISO– Master Input Slave Output,主设备数据输入,从设备数据输出;
    MOSI– Master Output Slave Input,主设备数据输出,从设备数据输入;
    SCLK – Serial Clock,时钟信号,由主设备产生;
    CS – Chip Select,从设备使能信号,由主设备控制。

    可能各个地方的名字不同,比如MISO线有的也叫做MDI(master data input),MOSI也叫作MDO(master data output),SCLK也叫SCK(时钟)等等。

    需要注意SPI是串行通讯协议,所以他的数据是一位一位进行传输的。

    SPI的通讯模式

    在介绍SPI通讯模式之前,有两个值需要了解,CPOL(时钟极性)和CPHA(时钟相位)。CPOL是用来配置SCK时钟信号什么时候是空闲状态,什么时候是有效状态;CPHA用来配置数据采样发生在第几个边沿。
    CPOL=0表示当SCK=0时为空闲状态,SCK=1时为有效状态。
    CPOL=1表示当SCK=1时为空闲状态,SCK=0时为有效状态。
    CPHA=0表示数据采样是在第1个边沿,数据发送在第2个边沿。
    CPHA=1表示数据采样是在第2个边沿,数据发送在第1个边沿。这里需要结合SPI的时序图来看
    图中的CPOL就是SCK时钟信号

    SPI共有四种通讯模式,不同的从设备可能在出厂是就是配置为某种模式,这是不能改变的;但我们的通信双方必须是工作在同一模式下,所以我们可以对我们的主设备的SPI模式进行配置,通过CPOL(时钟极性)和CPHA(时钟相位)来控制我们主设备的通信模式,具体如下:

    Mode00:CPOL=0,CPHA=0
    Mode01:CPOL=0,CPHA=1
    Mode10:CPOL=1,CPHA=0
    Mode11:CPOL=1,CPHA=1

    通讯协议

    从SPI的通讯模式可以知道,四种不同的模式对应的通讯协议不同,所以我把四种模式下的通讯协议都写出来了,需要用到那种模式就用哪个协议就好了,可能会有些问题,希望大家可以指正出来。

    详细程序

    SPI通讯默认是高位字节(MSB)优先传送,除非某些特定的设备明确说明是低位字节(LSB)优先传送。

    一般常用的是Mode00和Mode01两种模式。

    首先第一种,MODE00

    /* CPHA=0   CPOL=0  写入数据  MSB优先*/
    void soft_SPI_Write_MODE00(u8 write_data)
    {
        
        u8 i=0;
    	CS=0;
    	SCK=0;                //SCK空闲时为低电平
        
        for (i = 0; i < 8; i++) //写入数据,从高位开始
        {
            if (write_data & 0x80)
            {
                MOSI=1;
            }
            else
            {
                MOSI=0;
            }
            SCK=1; //时钟拉高 上升沿传输一位数据
            write_data<<=1;
            SCK=0; //时钟拉低等待下一位数据的传输
        }
        CS=1;		//片选拉高结束通讯
    }
    /*读取数据*/
    u8 soft_SPI_Read_Mode00(u8 write_data)
    {
        u8 read_data = 0;
        u8 i=0;
        CS=0;
        SCK=0;
        for (i = 0; i < 8; i++) //读取数据,从高位开始
        {
            read_data<<=1;
            if (MISO)
                read_data |= 0x01;
            SCK=1; //时钟拉高 上升沿传输一位数据
    
            SCK=0; //时钟拉低等待下一位数据的传输
        }
    
    	CS=1;
        return read_data;
    }
    

    第二种Mode01

    /* CPHA=0   CPOL=1  写入数据 MSB优先*/
    void soft_SPI_RW_MODE01(u8 write_data)
    {
    
        CS=0;  //片选拉低有效
        SCK=1; //SCK空闲时为高电平
    
        for (i = 0; i < 8; i++) //写入数据,从高位开始
        {
            if (write_data & (0x80 >> i))
                MOSI=1;
            else
                MOSI=0;
            SCK=0; //时钟拉低 下降沿传输一位数据
            SCK=1; //时钟拉高 等待下一位数据的传输
        }
    }
    /*读取数据*/
    u8 soft_SPI_Read_Mode01(u8 write_data)
    {
    	u8 read_data = 0;
        u8 i;
        for (i = 0; i < 8; i++) //读取数据,从高位开始
        {
    		read_data <<= 1;
            if (MISO)
                read_data |= 0x01;
    
            SCK=0; //时钟拉低 下降沿传输一位数据
            SCK=1; //时钟拉高 等待下一位数据的传输
        }
        CS=1; //一个字节传输结束 片选拉高 最后一位数据传输结束后时钟线已被拉高为空闲状态 不需要再次拉高
        return read_data;
    }
    

    另外两个模式一般不太用到,这里就不贴代码了。

    简写程序

    上面几段程序是根据SPI时序图来写的比较详细的通讯协议,程序会显得比较长,冗杂。但其实SPI通讯是全双工的,主机和从机的发送数据是同时完成的,两者的接收数据也是同时完成的。也就是说,当上升沿主机发送数据的时候,从机也发送了数据,再根据资料中写到的SPI是串行通信的方式,每次只发送一位数据,我们就可以在主机发送一位数据的同时也接收一位数据。以Mode00为例贴一段简写后的程序

    u8 soft_SPI_RW_MODE00(u8 write_data)
    {
        uint8_t i;
        uint8_t read_data=0;
        CS=0;
        SCK=0;        //空闲状态为低电平
        for(i=0;i<8;i++)
        {
            if(write_data&0X80)               //读一位    
                MOSI=1;
            else
                MOSI=0;
            read_data<<=1;
            if(MISO)
                read_data|=0x01;             //写一位
            SCK=1;
            write_data<<=1;
            
            SCK=0;
        }
    	CS=1;
        return read_data;
    }
    

    结语

    以上就是本次软件SPI通讯协议的全部内容了,有什么错误希望大家可以多多指正,共同进步。

    展开全文
  • 单片机使用软件模拟SPI与TI芯片ADS8689进行通信,在头文件中定义了寄存器地址和命令,在.c文件中对初始化函数、读写函数进行了实现
  • STM32模拟SPi.rar

    2019-05-22 19:47:58
    使用GPIO端口模拟SPi协议,可以根据端口设置,自行修改宏定义,修改引脚时钟
  • stm32模拟spi.c

    2020-06-04 17:31:39
    stm32模拟spi源代码,使用HAL库实现,可以拿来很方便的移植。下载前请注意,本代码已经在博客中完全开源出来,如有必要,请到博客中复制文本
  • 模拟spi如何写

    2016-04-20 14:44:06
    模拟spi需要4个普通io口,用作CS,SCK,SDI,CLR四个作用。 模拟spi不用配置io口去切换什么模式,只是不停的置高低电平 模拟SPI不是配置,就是通过最普通的IO口,也就是只有拉低拉高这种能力,然后认为的去...
  • STC12C5608AD通过硬件SPI读写LE25FU406(三洋),软件模拟SPI读写FM25F04(上海复旦微电子),软件模拟I2C单总线挂2个AT24C02进行读写,并用串口发送数据。压缩包内包含源程序、芯片datasheet资料、原理图。
  • 硬件SPI与软件模拟SPI速度区别实测

    千次阅读 2020-06-17 23:11:13
    硬件SPI与软件模拟SPI速度区别实测 目前为了程序移植方便,许多以SPI接口的芯片所提供的参考代码大多都使用的是软件SPI,比如笔者用过的存储芯片W25Q16,SPI接口驱动的OLED显示屏,LORA芯片SX1278等。 最近为了驱动...
  • ESP32模拟SPI控制0.9存OLED,通过模拟SPI的方式控制OLED显示屏幕,包含完整的控制代码。是一个完成的demo。
  • STC15F2K60S2 模拟SPI驱动AT45DB161-SU,暂时只支持页的擦除,写入和读取,其他还没完善。模拟 SPI,是模拟SPI
  • 本文介绍了通过SPI总线接口实现数据传输的实现方法,给出了用MCS-51单片机汇编语言模拟SPI串行总线的输入、输出,输入/输出以传送8位数据的子程序。
  • msp430代码模拟spi

    2015-10-12 21:38:02
    msp430使用io口模拟spi总线,与74ch595通讯
  • 一,模拟SPI, 先占个坑,以后慢慢填》》》》 二,模拟IIC, 先占个坑,以后慢慢填》》》》 三,模拟UART 51单片机版: 直接看 main 主函数。首先是对通信的波特率的设定,在这里我们配置的波特率是 9600,那么串口...
  • GPIO口模拟SPI

    2021-01-03 22:50:32
    SPI是一种高速、全双工、同步通信总线,标准的SPI有4个引脚,常用于单片机和EEPROM、FLASH、实时时钟、数字信号处理等器件的通信。...以下使用一款集成芯片举例 GPIO 口模拟SPI 16.1 SPI Block Descri
  • IO模拟SPI通信

    2012-04-21 23:40:46
    IO模拟SPI通信读写EEPROM 稍微调试可用
  • IO口模拟SPI

    2020-01-07 14:46:55
    IO口模拟SPI 根据SPI通信规范,与IO口模拟I2C类似,通过普通IO端口模拟也可以实现单片机(主设备)与从设备的SPI通信,其中使能信号CS在开始SPI通信前置低,在通信结束后置高,时钟线SCK通过IO口延时高低电平变化...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,740
精华内容 696
关键字:

模拟spi