求救:有没有高手做过ARM的SPI接口和外部flash通信(MCU是LPC2134, 外部flash的芯片为SST25VF010A)

冬冬瓜

求救:有没有高手做过ARM的SPI接口和外部flash通信(MCU是LPC2134, 外部flash的芯片为SST25VF010A) [复制链接]

如题.
请问大虾:这两者之间的驱动应该怎样去写,周立功书上写的SPI主机发送和接受数据采用的是如下代码:
S0SPDR = data;
while(0==S0SPSR & 0x80));
return (S0SPDR);
但我在使用的时候,只能发送,但不能从SST25VF010A接收数据,请问是什么原因?怎样处理呢?

sherryrain

可以用软件SPI测试一下,因为软件SPI可以很随意调整时序,查问题比较方便.
其实速度要求不严格的情况下,用软件SPI很方便也可靠.

woinwow

TO:lailaiququ
您能不能说具体点,用什么软件呢,您能不能说具体点? 我用的是ADS1.2编译器和EasyJTAG-H仿真器,我还用Proteus软件进行模拟过,用上面的软件代码始终不能得到从机(SST25VF010A)发过来的数据,换句话说MCU上MISO引脚没有信号.

ray23

把I/O口设置成GPIO模式，对照FALSH的数据手册，用置1，清零，读，I/O脚。
SPI好像有几种模式的，时序有点差别，反正按手册加上余量严格模拟。

有示波器最好了。

还有就是flash电源是否对，我以前用的AT45系列的好像不是3.3V，这种没用过。

20030201

我看了AT系列的datasheet这个的编程方式跟我用的那个flash编程方式相同,我的测试代码如下:麻烦您看看
#include  "config.h"
#include  "LPC2294.h"
#define   CHIP_SEL    0x00000100            /* P0.8  Chip Enable or Disable */
#define   CMD_NUM        4

#define CE_Low()  (IOCLR=CHIP_SEL)
#define CE_High() (IOSET=CHIP_SEL)

#define SST25VF010A_SCK                                (1<<4)
#define SST25VF010A_MISO                                (1<<5)
#define SST25VF010A_MOSI                                (1<<6)

#define SET_SST25VF010A_SCK()                (IO0SET  = SST25VF010A_SCK)
#define CLR_SST25VF010A_SCK()                (IO0CLR = SST25VF010A_SCK)

#define SET_SST25VF010A_SO()                 (IO0SET = SST25VF010A_MISO)
#define CLR_SST25VF010A_SO()                (IO0CLR = SST25VF010A_MISO)

#define SET_SST25VF010A_SI()                        (IO0SET = SST25VF010A_MOSI)
#define CLR_SST25VF010A_SI()                        (IO0CLR = SST25VF010A_MOSI)

/************************************************************************/
/* PROCEDURE: Send_Byte                                                        */
/*                                                                        */
/* This procedure outputs a byte shifting out 1-bit per clock rising        */
/* edge on the the SI pin(LSB 1st).                                        */
/*                                                                        */
/* Input:                                                                */
/*                out                                                        */
/*                                                                        */
/* Output:                                                                */
/*                SI                                                        */
/************************************************************************/
void Send_Byte(uint8 out)
{       
        unsigned char i = 0;
        for (i = 0; i < 8; i++)
        {               
                if ((out & 0x80) == 0x80)        /* check if MSB is high */
                        //SI = 1;
                        SET_SST25VF010A_SI();
                else
                        //SI = 0;                                        /* if not, set to low */
                        CLR_SST25VF010A_SI();
                SET_SST25VF010A_SCK();                   //SCK = 1;                         toggle clock high
                out = (out << 1);                                /* shift 1 place for next bit */
                CLR_SST25VF010A_SCK();                         //SCK = 0;                        /* toggle clock low */
        }
}

/************************************************************************/
/* PROCEDURE: Get_Byte                                                        */
/*                                                                        */
/* This procedure inputs a byte shifting in 1-bit per clock falling        */
/* edge on the SO pin(LSB 1st).                                                */
/*                                                                        */
/* Input:                                                                */
/*                SO                                                        */
/*                                                                        */
/* Output:                                                                */
/*                None                                                        */
/************************************************************************/
uint8 Get_Byte()
{
        unsigned char i = 0, in = 0, temp = 0;
        for (i = 0; i < 8; i++)
        {
                in = (in << 1);                /* shift 1 place to the left or shift in 0 */
                temp =(( IO0PIN & SST25VF010A_MISO ) >> 5);                /* save input */
                SET_SST25VF010A_SCK(); //SCK = 1;                        /* toggle clock high */
        if (temp == 1)                        /* check to see if bit is high */
                in = in | 0x01;        /* if high, make bit high */

                CLR_SST25VF010A_SCK(); //SCK = 0;                        /* toggle clock low */
        }
        return in;
}

unsigned char Read_Status_Register()
{
        unsigned char byte = 0;
        CE_Low();                        /* enable device */
        Send_Byte(0x05);                /* send RDSR command */
        byte = Get_Byte();                /* receive byte */
        CE_High();                        /* disable device */
        return byte;
}

unsigned char Read_ID(ID_addr)
{
        unsigned char byte;
        CE_Low();                            /* enable device */
        Send_Byte(0x90);                /* send read ID command (90h or ABh) */
    Send_Byte(0x00);                /* send address */
        Send_Byte(0x00);                /* send address */
        Send_Byte(ID_addr);                /* send address - either 00H or 01H */
        byte = Get_Byte();                /* receive byte */
        CE_High();                        /* disable device */
        return byte;
}

/************************************************************************/
/* PROCEDURE: WREN                                                        */
/*                                                                        */
/* This procedure enables the Write Enable Latch.                        */
/*                                                                        */
/* Input:                                                                */
/*                None                                                        */
/*                                                                        */
/* Returns:                                                                */
/*                Nothing                                                        */
/************************************************************************/
void WREN()
{
        CE_Low();                        /* enable device */
        Send_Byte(0x06);                /* send WREN command */
        CE_High();                        /* disable device */
}

/************************************************************************/
/* PROCEDURE: WRDI                                                        */
/*                                                                        */
/* This procedure disables the Write Enable Latch.                        */
/*                                                                        */
/* Input:                                                                */
/*                None                                                        */
/*                                                                        */
/* Returns:                                                                */
/*                Nothing                                                        */
/************************************************************************/
void WRDI()
{
        CE_Low();                        /* enable device */
        Send_Byte(0x04);                /* send WRDI command */
        CE_High();                        /* disable device */
}

/************************************************************************/
/* PROCEDURE:        Byte_Program                                                */
/*                                                                        */
/* This procedure programs one address of the device.                        */
/* Assumption:  Address being programmed is already erased and is NOT        */
/*                block protected.                                        */
/*                                                                        */
/*                                                                        */
/*                                                                        */
/* Input:                                                                */
/*                Dst:                Destination Address 000000H - 07FFFFH        */
/*                byte:                byte to be programmed                        */
/*                                                                      */
/*                                                                        */
/* Returns:                                                                */
/*                Nothing                                                        */
/*                                                                        */
/************************************************************************/
void Byte_Program(unsigned long Dst, unsigned char byte)
{
        CE_Low();                                /* enable device */
        Send_Byte(0x02);                         /* send Byte Program command */
        Send_Byte(((Dst & 0xFFFFFF) >> 16));        /* send 3 address bytes */
        Send_Byte(((Dst & 0xFFFF) >> 8));
        Send_Byte(Dst & 0xFF);
        Send_Byte(byte);                        /* send byte to be programmed */
        CE_High();                                /* disable device */
}

/************************************************************************/
/* PROCEDURE:        Read                                                        */
/*                                                                        */               
/* This procedure reads one address of the device.  It will return the         */
/* byte read in variable byte.                                                */
/*                                                                        */
/*                                                                        */
/*                                                                        */
/* Input:                                                                */
/*                Dst:        Destination Address 000000H - 07FFFFH                */
/*                                                                      */
/*                                                                        */
/* Returns:                                                                */
/*                byte                                                        */
/*                                                                        */
/************************************************************************/
unsigned char Read(unsigned long Dst)
{
        unsigned char byte = 0;       

        CE_Low();                /* enable device */
        Send_Byte(0x03);                 /* read command */
        Send_Byte(((Dst & 0xFFFFFF) >> 16));        /* send 3 address bytes */
        Send_Byte(((Dst & 0xFFFF) >> 8));
        Send_Byte(Dst & 0xFF);
        byte = Get_Byte();
        CE_High();                        /* disable device */
        return byte;                        /* return one byte read */
}




void Delay(unsigned short iTime)
{       
        unsigned int i,j;
        for(i=0;i         {
                for (j=0;j<1;j++);
        }
}

void Alarm(void)
{
        SET_SST25VF010A_SCK();
        Delay(2);
        CLR_SST25VF010A_SCK();
        __asm{ NOP }
}



void DelayNS(uint32 dly)
{  uint32  i;
   for (;dly>0;dly--)
      for(i=0;i<5000;i++);
}

void MSpiIni(void)
{ SPI_SPCCR=0x4C;           //设置SPI时钟分频
  SPI_SPCR=0x30;            //设置SPI接口模式,MSTR=1,CPOL=1,CPHA=0,LSBF=0
}  

uint8 MSendData(uint8 data)
{
  CE_Low();                             //片选
  SPI_SPDR=data;
  while(0==(SPI_SPSR&0x80));                  //等待SPIF置位,即等待数据发送完毕
  CE_High();
  return(SPI_SPDR);
}

//Read                                         0x03
//Byte-Write                         0x02
//WREN                                        0x06
//WRDI                                        0x04
//Read_Staus_Register        0x05
//Write_Staus_Register        0x01

uint8 const Cmd[CMD_NUM]={0x03, 0x00, 0x00, 0x04/*, 0x05, 0x01*/};

int main(void)
{ uint8 rcv_data;
  uint8 i;

PINSEL0 = (PINSEL0 & 0xFFFF00FF);
  
  IODIR = CHIP_SEL | SST25VF010A_SCK | SST25VF010A_MOSI ;
  //MSpiIni();                         //初始化SPI接口

  while(1)
  {
        //rcv_data =Read_Status_Register();
        WREN();
        Byte_Program(0x000005, 0xA5);
        WRDI();       
        DelayNS(1);
        rcv_data = Read(0x000005);
        DelayNS(1);
  }
  return(0);
}

我用了以上测试,代码含义:先往地址0x000005写一个数据,然后将这个数读出来,可是发现SO因脚始终没有信号.

zljzlj

也就是MCU始终不能正确地从SST25VF010A的SO引脚接收数据,请问这是什么原因呢?

sujd_01

到的BLOG里可以找到你想要的代码

我用的是LPC2146 +M25P40 ,用的是SPI接口

祝你好运

luckyboy

TO:wanyeye
能不能给个具体的链接?谢谢!

pcwe

M25P40
是什么啊

hlyft

TO:wanyeye
能够讲一下您的MUC和M25P40的连接方式吗?
我的连接方式为:
LPC2134(MCU)             SST25VF010A
   SCK         <----->     SCK
   MOSI        <----->     SI
   MISO        <----->     SO
MCU的SSEL因脚通过一个1K的电阻上拉到3.3V, SST25VF010A的CS(片选引脚)直接接地,HOLD和WP引脚直接接到3.3V

你的LPC2146 + M25P40也是这样进行连接的吗?

jasonliu

我的问题是MISO引脚上没有数据,换句话说就是不能读取SST25VF010A当中的信息

simbill

这种情况会是什么原因造成的呢?

caobenda

这个简单啊,网上搜一下就得到答案了.

shuimiao11

不会,帮顶