اطلاعیه

Collapse
No announcement yet.

AT45DB321 با lpc1768

Collapse
X
 
  • فیلتر
  • زمان
  • Show
Clear All
new posts

    AT45DB321 با lpc1768

    با سلام
    دنبال کتابخانه ای برای ارتباط با at45db321 با lpc1768 می گردم .
    اگر کسی با این آی سی کار کرده و کتابخانه ای یا سمپلی داره ممنون می شم بهم کمک کنه !

    #2
    پاسخ : AT45DB321 با lpc1768

    این ادرس رو نگاه کن خیلی سایت خوبی هست یک درایور برای این دیتا فلش گذاشته ولی نمیدونم چقدر به دردت میخوره
    http://read.pudn.com/downloads94/sourcecode/embed/371761/at45db321_m55800/at45db321.c__.htm

    دیدگاه


      #3
      پاسخ : AT45DB321 با lpc1768

      سلام
      در ادرس زیر هم یک مثال از آقای صادق محمدی موجود هست که با اتمگا راه اندازی شده
      ولی یک هدر فایل داره که با تغییر یکی دو تا دستورمیشه رو روی میکروهای دیگه اجرا کرد
      http://sadmonew.blogfa.com/post-7.aspx

      دیدگاه


        #4
        پاسخ : AT45DB321 با lpc1768

        نوشته اصلی توسط Sadeghbakhshi
        سلام
        در ادرس زیر هم یک مثال از آقای صادق محمدی موجود هست که با اتمگا راه اندازی شده
        ولی یک هدر فایل داره که با تغییر یکی دو تا دستورمیشه رو روی میکروهای دیگه اجرا کرد
        http://sadmonew.blogfa.com/post-7.aspx
        آره پیدا کرده بودم و دارم تغییر می دم
        فکر کنم دارم به نتیجه می رسم .

        دیدگاه


          #5
          پاسخ : AT45DB321 با lpc1768

          این هم فایلی که من تغییر دادم و باهاش جواب گرفتم با lpc1768 و کمپایلر iar
          اینجا می ذارم اگه کسی خواست ، استفاده کنه :

          کد:
          #include <NXP/iolpc1768.h>
          #include "lpc17xx_nvic.h"
          #include "core_cm3.h"
          #include "lpc17xx_gpio.h"
          #include "defines.h"
          #include "func.h"
          #include "externs.h"
          #include "intrinsics.h"
          #include "lpc17xx.h"
          
          
          #define BUF1 0x00
          #define BUF2 0x01
          
          #define BYTE_DUMMY 0x00 //ÑÆÔª×Ö½Ú
          
          #define BUF_HEAD 0x0000 //»º³åÊ×µØÖ·
          #define PAGE_HEAD 0x0000 //FLASHÒ³Ê×µØÖ·
          #define AT45DB321_BYTE_PER_PAGE 528 //AT45DB321 ÿҳ528×Ö½Ú
          #define RECORD_SIZE   80 //528/6=80 ÿ¼Ç¼×î¶à80×Ö½Ú
          
          volatile unsigned char data[528];
          
          /* SPSR */
          #define SPIF  7
          #define WCOL  6
          /* bits 5-1 reserved */
          #define SPI2X  0
          
          /* SPCR */
          #define SPIE  7
          #define SPE   6
          #define DORD  5
          #define MSTR  4
          #define CPOL  3
          #define CPHA  2
          #define SPR1  1
          #define SPR0  0
          
          /* SFIOR */
          #define ADTS2  7
          #define ADTS1  6
          #define ADTS0  5
          /* bit 4 reserved */
          #define ACME  3
          #define PUD   2
          #define PSR2  1
          #define PSR10  0
          
          
          #define RESET_0 FIO0PIN&=~(1<<5)
          #define RESET_1 FIO0PIN|=(1<<5)
          
          #define WP_0 FIO0PIN&=~(1<<4)
          #define WP_1 FIO0PIN|=(1<<4)
          
          #define AT_SO FIO0PIN&(1<<8)
          
          //#define SI_0 PORTB&=~(1<<SI)
          //#define SI_1 PORTB|=(1<<SI)
          #define CS_0   FIO0PIN&=~(1<<6)
          #define CS_1   FIO0PIN|=(1<<6)
          
          #define SI_0   FIO0PIN&=~(1<<9)
          #define SI_1   FIO0PIN|=(1<<9)
          
          
          #define SCK_SPI_0   FIO0PIN&=~(1<<7)
          #define SCK_SPI_1   FIO0PIN|=(1<<7)
          
          //***************************************************
          void SPI_WriteByte(BYTE spi_write_data)
          {
            BYTE i;
            CS_0;
            delay(2);
            for(i=0;i<8;i++) //send 8 bits
            {
             SCK_SPI_0;
             if((spi_write_data<<i)&0x80)
               SI_1;
             else
              SI_0;
            delay(2);
             SCK_SPI_1;
             delay(2);
            }
          }
          //******************************************************
          BYTE SPI_ReadByte(void)
          {
            BYTE i,temp;
            CS_0;
            delay(2);  // bit bit_in;
            temp=0x00;//initialize the data output
          
            for(i=0;i<8;i++)
            {
              SCK_SPI_0;
              delay(2);
              SCK_SPI_1;
              delay(2);
              temp <<= 1;
              if(AT_SO)
                temp |=1;
              else
               temp |=0;
            }
            return (temp);
          }
          //*********************************************************************************
          void AT45_Write_Buffer(unsigned char buffer_choice,unsigned int address, unsigned char *string, unsigned int buf_len)
          {
            unsigned int i;
            unsigned char t;
            CS_0; //active the device
            delay(2);
            if(buffer_choice)
               SPI_WriteByte(0x87);  //buffer 2
            else
              SPI_WriteByte(0x84); //buffer 1
          
            SPI_WriteByte(BYTE_DUMMY);   //xxxx xxxx don¡¯t care bits
            t=(BYTE)((address>>8)&0x03);
            SPI_WriteByte(t);  //BFA9,BFA8
            SPI_WriteByte((BYTE)address); //BFA7~BFA0
            for(i=0;i<buf_len;i++)       /*buffer. More detail in the datasheet.*/
            {
              SPI_WriteByte(string[i]);
               delay(30);
            }
            CS_1; //inactive the device
            delay(2);
          }
          //***************************************************************
          void AT45_Read_Buffer(unsigned char buffer_choice,unsigned int address,unsigned int buf_len,unsigned char * string)
          {
            unsigned int i;
            unsigned char tp;
            CS_0; //active the device
            delay(2);
          
            if(buffer_choice)
               SPI_WriteByte(0x0D6);  //buffer 2
            else
               SPI_WriteByte(0x0D4); //buffer 1
          
            SPI_WriteByte(BYTE_DUMMY);   //xxxx xxxx
          
            tp=(BYTE)((address>>8)&0x03);
            SPI_WriteByte(tp);  //BFA9,BFA8
            SPI_WriteByte((BYTE)address); //BFA7~BFA0
            SPI_WriteByte(BYTE_DUMMY);   //xxxx xxxx
          //now read the user_data
            for(i=0;i<buf_len;i++)
               string[i]=SPI_ReadByte();
            CS_1;
            delay(2);
          }
          
          //*************************************************************
          void DataFlashReset(void) //¸´Î»´æ´¢Æ÷
          {
            CS_0;
            delay(2);
            RESET_0;
            delay(5);
            CS_1;
            delay(2);
            RESET_1;
           delay(2);
          }
          //*************************************************************
          void ReadID(void)
          {
            BYTE i;
            CS_0;
            delay(2);
            SPI_WriteByte(0X9F);
            for(i=0;i<4;i++)
            	d[i]=SPI_ReadByte();
            CS_1;
            delay(2);
          }
           //*************************************************************
          void IsBusy(void)
          {
            while(!(ReadFlashState()&0x80))
            {
            ;
            }
          }
          //*************************************************************
          unsigned char AT45_MemoryByteRead(unsigned int page,unsigned int address)
          {
           // unsigned char temp=0;
            IsBusy();
            CS_0;
            SPI_WriteByte(0xd2);// MEM_PAGE_READ  //0x68 ÎÒ¸ÄΪÁË0xD2Ò³¶Á  0XE8
          
            SPI_WriteByte((unsigned char)(page>>6)); //µØÖ·×î¸ß×Ö½Ú
            SPI_WriteByte((unsigned char)((page<<2)|(address>>8)));
            SPI_WriteByte((unsigned char)address);//µØÖ·µÍ×Ö½Ú
          
            SPI_WriteByte(BYTE_DUMMY);//32 don't care bits
            SPI_WriteByte(BYTE_DUMMY);
            SPI_WriteByte(BYTE_DUMMY);
            SPI_WriteByte(BYTE_DUMMY);
          
            SPI_WriteByte(0xff);
            CS_1;
            return 1;
           // return SPDR;
          }
          //*************************************
          void AT45_MemoryRead(unsigned int page,unsigned int address,unsigned int num,unsigned char * string)
          {
            unsigned int i=0;
            unsigned char temp=0;
            IsBusy();
            CS_0;
            delay(2);
            //send command stream of data
            SPI_WriteByte(0xD2);// MEM_PAGE_READ  //0x68 ÎÒ¸ÄΪÁË0xD2Ò³¶Á  0XE8
            SPI_WriteByte((BYTE)(page>>6)); //µØÖ·×î¸ß×Ö½Ú
          
            temp = (((BYTE)page)<<2);
            temp = temp|((address>>8)&0x03);//µØÖ·¸ß×Ö½Ú
            SPI_WriteByte(temp);
          
            SPI_WriteByte((BYTE)address);//µØÖ·µÍ×Ö½Ú
          
            SPI_WriteByte(BYTE_DUMMY);//32 don't care bits
            SPI_WriteByte(BYTE_DUMMY);
            SPI_WriteByte(BYTE_DUMMY);
            SPI_WriteByte(BYTE_DUMMY);
            //now read the user_data
            //2048*264=538624,but don't read so many
            //bytes at one time.
            for(i=0;i<num;i++)
            {
              string[i]=SPI_ReadByte();
            }
            CS_1;
            delay(10);
            IsBusy();
          }
          ///***********************************************
          void AT45_EraseBlock(WORD block)//Block(0~1023)
          {
            BYTE temp;
            CS_0;
            delay(2);
            //send command stream of data
            SPI_WriteByte(0x50);// MEM_BLOCK_ERASE
            SPI_WriteByte((BYTE)(block>>3));//µØÖ·×î¸ß×Ö½Ú
            temp = (((BYTE)block)<<5);
            SPI_WriteByte(temp);    //µØÖ·¸ß×Ö½Ú
            SPI_WriteByte(BYTE_DUMMY);    //µØÖ·µÍ×Ö½Ú
            CS_1;
            delay(100);
            IsBusy();
          }
          //******************************************************************************
          void AT45_Memory_PageWrite(unsigned char buffer_choice,unsigned int page,unsigned int address,unsigned int num,unsigned char *string)
          {
            //memory to buffer.
            unsigned int i;
            unsigned char tt;
            CS_0;
            delay(2);
            if(buffer_choice)
             SPI_WriteByte(0x55);  //buffer 2
            else
            SPI_WriteByte(0x53); //buffer 1
            tt=(BYTE)(page >>6);
            SPI_WriteByte(tt);    // 6 to 7
            tt=(BYTE)(page <<2);
            SPI_WriteByte(tt);
            SPI_WriteByte(BYTE_DUMMY);
            CS_1;
            delay(50);
            IsBusy();
          
            //write buffer
            CS_0; //active the device
            delay(2);
            if(buffer_choice)
             SPI_WriteByte(0x87);  //buffer 2
            else
             SPI_WriteByte(0x84); //buffer 1
            SPI_WriteByte(BYTE_DUMMY);   //xxxx xxxx don¡¯t care bits
            tt=(BYTE)((address>>8)&0x03);
            SPI_WriteByte(tt);  //BFA9,BFA8
            SPI_WriteByte((BYTE)address); //BFA7~BFA0
            for(i=0;i<num;i++)       /*buffer. More detail in the datasheet.*/
            {
            SPI_WriteByte(string[i]);
            delay(30);
            }
            CS_1; //inactive the device
            delay(2);
          
            //buffer to memory
            CS_0;
            delay(2);
            if(buffer_choice)
             SPI_WriteByte(0x86);  //buffer 2
            else
             SPI_WriteByte(0x83); //buffer 1
            tt=(BYTE)(page >>6);
            SPI_WriteByte(tt);  //6 ÎÒ¸ÄΪ7
            tt=(BYTE)(page <<2);
            SPI_WriteByte(tt);
            SPI_WriteByte(BYTE_DUMMY);
            CS_1;
            delay(2);
            IsBusy();
          }
          //******************************************************
          unsigned char ReadFlashState(void)
          {
            unsigned char result=0;
            CS_0;
            delay(2);
            SPI_WriteByte(0XD7);
            result=SPI_ReadByte();
            CS_1;
            delay(2);
            return result;
          }

          دیدگاه

          لطفا صبر کنید...
          X