It is currently 23 Apr 2019 21:50

All times are UTC + 1 hour




Post new topic Reply to topic  [ 2 posts ] 
Author Message
PostPosted: 11 Jan 2019 07:46 
Offline

Joined: 28 Oct 2007 03:16
Posts: 144
Location: West Australia
This is working code:
1. PIC32 compiler
2. EasyPICFusionv& board
3. 23LC1024 SRAM SPI IMbit memory
First the .c test file
////////////////////////////////////////////////////////////////////////////////
// Project:         SRAM_23LCV1024                                            //
// File:            Test_23LCV1024_SRAM.c                                     //
// Function:        Read and write to 23LCV1024 SPI SRAM in Mikro bus 1       //
//                  23LCV1024 Vdd = 2.5 to 5.5V with 20MHz SPI                //
// MCU:             32MX795F512L                                              //
// Board:           EasyPIC_Fusionv7                                          //
// Power:           3.3V for MCU and TFT                                      //
// Xtal:            Running at 80MHz                                          //
// Compiler:        mikroC PRO for PIC32 version 4.0.0                        //
// Programmer:      ICD3 or on-boaard                                         //
// Author:          WVL                                                       //
// Date:            11 Jan 2019                                               //
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
// Quick set up                                                               //
// SRAM uses left socket on EasyPICFusion with CS defined in .h file          //
// SPI3 is hard wired to MikroBus sockets on EasyPICFusionv7 board            //
// Do not include .c or .h files in the Mikro IDE                             //
// 23LCV1024 is similar to 23A1024 and 23LC1023 but different pins, voltages  //
// Volatile memory with infinite number of read/writes                        //
// Test results on RF4/RF5 UART 2 USBA                                         //
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
#include "SRAM_23LCV1024.h"     // CS pin allocated and prototype functions   //
#include "SRAM_23LCV1024.c"     // functions for SRAM read and write          //
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
// Function - direct PrintOut stream to the PC via UART2/USB a                //
void U2(char c);                                                              //
////////////////////////////////////////////////////////////////////////////////

void main(){
    char                      x = 0;
    char                      y = 0;
    char                   read = 0;
    char                 write = 30;
    unsigned int              a = 0;
    unsigned int              b = 0;
    unsigned int              c = 0;
    unsigned short    my_string[25];       // conversion unsigned long to string
    unsigned long       address = 0;
    char              test_page[32];       // to test 32 byte page write
    char              read_page[32];       // for page read
    // Init MCU
    AD1PCFG = 0xFFFF;           // 1=digital 0=analog
    JTAGEN_bit = 0;             // disable JTAG
    // Ports and pins
    TRISA = 0;
    TRISB = 0;
    TRISC2_bit = 0;
    TRISD = 0;
    TRISE = 0;
    TRISF = 0;
    TRISG = 0;

    // Init peripherals
    UART2_Init(115200);          // U2Tx/RF5 U2Rx/RF4
    delay_ms(100);
    Printout(U2,"Test_SRAM_23LCV1024 now running\r\n");
    // Init SRAM on SPI3
    SRAM_Init();
    // Clear SRAM - or turn power off
    SRAM_Clear();
    Printout(U2,"SRAM Clear completed\r\n");
   
    while(1){
   
        // Test byte write and read
        // Write a byte
        SRAM_WriteByte(write,address);
        // Read a byte
        read = SRAM_ReadByte(address);
        // Display results
        Printout(U2,"Test byte read and write\r\n");
        a = write;
        b = read;
        LongWordToStrWithZeros(address, my_string);
        Printout(U2,"Write:%u Read:%u Address:%s\r\n",a,b,my_string);
       
        // Load test_page with 32 bytes
        for(x=0;x<32;x++)test_page[x] = x+y;
       
        // Test page write and read of 32 bytes to page 10
        SRAM_WritePage(test_page,10);
        SRAM_ReadPage(read_page,10);
        // Display result
        Printout(U2,"Test page read and write 32 bytes to page 10\r\n");
        for(x=0;x<32;x++){
            a = test_page[x];
            b = read_page[x];
            c = x;
            Printout(U2,"test_page:[%u]%u   \tread_page:[%u]%u\r\n",c,a,c,b);
        }

        // Housekeeping
        address++;
        Write++;
        y++;
        LATG0_bit = ~LATG0_bit;
        delay_ms(2000);
    }
   
}
////////////////////////////////////////////////////////////////////////////////
// Function - direct PrintOut stream to the PC via UART1                      //
void U1(char c){UART1_Write(c);}                                              //
////////////////////////////////////////////////////////////////////////////////
// Function - direct PrintOut stream to the PC via UART2                      //
void U2(char c){UART2_Write(c);}                                              //                                                                             
////////////////////////////////////////////////////////////////////////////////

And the .c file for the SRAM
////////////////////////////////////////////////////////////////////////////////
// Project:         SRAM_23LCV1024                                            //
// File:            SRAM_23LCV1024.c                                          //
// Function:        Read/write to MODE REGISTER to set type of read/write     //
//                  Read/Write to DATA MEMORY in BYTE, PAGE, SEQURNTIAL mode  //
//                  23LCV1024 Vdd = 2.5 to 5.5V with 20MHz SPI                //
// MCU:             32MX795F512L                                              //
// Board:           EasyPIC_Fusionv7                                          //
// Power:           3.3V for MCU and TFT                                      //
// Xtal:            Running at 80MHz                                          //
// Compiler:        mikroC PRO for PIC32 version 4.0.0                        //
// Programmer:      ICD3                                                      //
// Author:          WVL                                                       //
// Date:            30 December 2018                                          //
////////////////////////////////////////////////////////////////////////////////

#include "SRAM_23LCV1024.h"     // constants, pin allocations, prototypes
#include <built_in.h>           // decomposition of 20bit address into 8 bits

////////////////////////////////////////////////////////////////////////////////
// Function - Initialise SRAM                                                 //
//            Max speed is 80/4 = 20MHz but 10MHz measured maximum            //
//            MODE 0: CPOL=0 and CPHA=0 - use this mode                       //
//            MODE 3: CPOL=1 and CPHA=1                                       //
//            _SPI_CLK_IDLE_HIGH,_SPI_ACTIVE_2_IDLE)                          //
//            _SPI_CLK_IDLE_LOW, _SPI_IDLE_2_ACTIVE)                          //
//            Uses SPI3 on SDO3/RF8 SDI3/RF2 SCK3/RD15 CS/RC2                 //
void SRAM_Init(){                                                             //
    SPI3_Init_Advanced(_SPI_MASTER,_SPI_8_BIT,8,_SPI_SS_DISABLE,\
    _SPI_DATA_SAMPLE_MIDDLE,_SPI_CLK_IDLE_LOW,_SPI_IDLE_2_ACTIVE);            //
    CS = 0;                                                                   //
    delay_ms(10);                                                             //
    CS = 1;                                                                   //
}                                                                             //
////////////////////////////////////////////////////////////////////////////////
// Function - Read one byte from memory with 24 bit address                   //
//            Using BYTE MODE                                                 //
char SRAM_ReadByte(unsigned long address){                                    //
    char my_byte = 0;                                                         //
    SRAM_WriteMode(BYTE_MODE);         // set BYTE MODE                       //
    CS = 0;                                                                   //
    SPI3_Write(READ);               // read instruction                       //
    SPI3_Write(Higher(address));                                              //
    SPI3_Write(Hi(address));                                                  //
    SPI3_Write(Lo(address));                                                  //
    my_byte = SPI3_Read(0);                                                   //
    CS = 1;                                                                   //
    return my_byte;                                                           //
}                                                                             //
////////////////////////////////////////////////////////////////////////////////
// Function - Write one byte to memory with 24 bit address                    //
//            Using BYTE MODE                                                 //
SRAM_WriteByte(char in_byte, unsigned long address){                          //
    SRAM_WriteMode(BYTE_MODE);      // set BYTE MODE                          //
    CS = 0;                                                                   //
    SPI3_Write(WRITE);              // write instruction                      //
    SPI3_Write(Higher(address));                                              //
    SPI3_Write(Hi(address));                                                  //
    SPI3_Write(Lo(address));                                                  //
    SPI3_Write(in_byte);                                                      //
    CS = 1;                                                                   //
}                                                                             //
////////////////////////////////////////////////////////////////////////////////
// Function - Write a byte to the Mode Register                               //
SRAM_WriteMode(char in_byte){                                                 //
    CS = 0;                                                                   //
    SPI3_Write(WRMR);                                                         //
    SPI3_Write(in_byte);                                                      //
    CS = 1;                                                                   //
}                                                                             //
////////////////////////////////////////////////////////////////////////////////
// Function - Read a byte from the Mode Register                              //
char SRAM_ReadMode(){                                                         //
    char my_byte = 0;                                                         //
    CS = 0;                                                                   //
    SPI3_Write(RDMR);                                                         //
    my_byte = SPI3_Read(0);                                                   //
    CS = 1;                                                                   //
    return my_byte;                                                           //
}                                                                             //
////////////////////////////////////////////////////////////////////////////////
// Function - Write a page of 32 bytes to memory with 24 bit address          //
//            23LCV1024 has 4,096 pages of 32 bytes each                      //
//            Function is passed a pointer to the array to be written         //
SRAM_WritePage(char *in_array, unsigned int page){                            //
    unsigned long address = 0;                                                //
    char x = 0;                                                               //
    address = (unsigned long)page*32UL;     // calculate starting address     //
    SRAM_WriteMode(PAGE_MODE);              // select page mode               //
    CS = 0;                                                                   //
    SPI3_Write(WRITE);                      // select write to memory         //
    SPI3_Write(Higher(address));            // set addres of 1st page byte    //
    SPI3_Write(Hi(address));                                                  //
    SPI3_Write(Lo(address));                                                  //
    for(x=0;x<32;x++){                                                        //
        SPI3_Write(*in_array);                                                //
        in_array++;                                                           //
    }                                                                         //
    CS = 1;                                                                   //
}                                                                             //
////////////////////////////////////////////////////////////////////////////////
// Function - Clear all memory. Set SEQUENTIAL mode. Issue WRITE instruction. //
//            Set address to zero. Data out for 131,071 bytes                 //
//            Use SEQUENTIAL MODE and start at address 0                      //
//            Return 1 when done                                              //
SRAM_Clear(){                                                                 //
    unsigned long count = 0;                                                  //
    SRAM_WriteMode(SEQUENTIAL_MODE);                                          //
    CS = 0;                                                                   //
    SPI3_Write(WRITE);                                                        //
    SPI3_Write(0);              // address 0                                  //
    SPI3_Write(0);              // address 0                                  //
    SPI3_Write(0);              // address 0                                  //
    while(count<131072UL){                                                    //
        SPI3_Write(0x00);       // data 0                                     //
        count++;                // increment address counter                  //
    }                                                                         //
    CS = 1;                                                                   //
    return 1;                                                                 //
}                                                                             //
////////////////////////////////////////////////////////////////////////////////
// Function - Read a page of 32 bytes from memory with 24 bit address         //
//            Function is passed a pointer to the array to be recorded        //
SRAM_ReadPage(char *out_array, unsigned int page){                            //
    unsigned long address = 0;                                                //
    char x = 0;                                                               //
    address = (unsigned long)page*32UL;     // calculate starting address     //
    SRAM_WriteMode(PAGE_MODE);                                                //
    CS = 0;                                                                   //
    SPI3_Write(READ);                                                         //
    SPI3_Write(Higher(address));                                              //
    SPI3_Write(Hi(address));                                                  //
    SPI3_Write(Lo(address));                                                  //
    for(x=0;x<32;x++){                                                        //
        *out_array = SPI3_Read(address);                                      //
        out_array++;                                                          //
    }                                                                         //
    CS = 1;                                                                   //
}                                                                             //
////////////////////////////////////////////////////////////////////////////////

And the .h file for the SRAM
////////////////////////////////////////////////////////////////////////////////
// Project:         SRAM_23LCV1024                                            //
// File:            SRAM_23LCV1024.h                                          //
// Function:        Read/write to MODE REGISTER to set type of read/write     //
//                  Read/Write to DATA MEMORY in BYTE, PAGE, SEQURNTIAL mode  //
//                  23LCV1024 Vdd = 2.5 to 5.5V with 20MHz SPI                //
// MCU:             32MX795F512L                                              //
// Board:           EasyPIC_Fusionv7                                          //
// Power:           3.3V for MCU and TFT                                      //
// Xtal:            Running at 80MHz                                          //
// Compiler:        mikroC PRO for PIC32 version 4.0.0                        //
// Programmer:      ICD3                                                      //
// Author:          WVL                                                       //
// Date:            30 December 2018                                          //
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
// 23LCV1024 is 1Mbit SRAM with SPI comms                                     //
// 1Mbit = 1024kbits = 1,048,576 bits = 1204 X 1204 bits = 131,072 bytes      //
// Unlimited read/write cycles                                                //
// 20MHz clock maximum                                                        //
// 20 bit address 0 to 0xFFFFF or 0 to 1,048,575                              //
// Page is 32 bytes. Page0 = 0-31. Page1=32-63. PageN starts at = 32*n        //
// Total pages = 131,072/32 = 4,096                                           //
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
// Byte Operation – is selected when bits 7 and 6 in the                      //
// MODE register are set to 00. In this mode, the read/                       //
// write operations are limited to only one byte. The                         //
// command followed by the 24-bit address is clocked into                     //
// the device and the data to/from the device is transferred                  //
// on the next eight clocks                                                   //
                                                                              //
// Page Operation – is selected when bits 7 and 6 in the                      //
// MODE register are set to 10. The 23LCV1024 has 4096                        //
// pages of 32 bytes. In this mode, the read and write operations             //
// are limited to within the addressed page (the                              //
// address is automatically incremented internally). If the                   //
// data being read or written reaches the page boundary,                      //
// then the internal address counter will increment to the                    //
// start of the page                                                          //
                                                                              //
// Sequential Operation – is selected when bits 7 and 6                       //
// in the MODE register are set to 01. Sequential operation                   //
// allows the entire array to be written to and read                          //
// from. The internal address counter is automatically                        //
// incremented and page boundaries are ignored. When                          //
// the internal address counter reaches the end of the                        //
// array, the address counter will roll over to 0x00000                       //
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
// Modes                                                                      //
#define BYTE_MODE       0b00000000                                            //
#define PAGE_MODE       0b10000000                                            //
#define SEQUENTIAL_MODE 0b01000000                                            //
// Instructions                                                               //
#define READ            0x03    // Read data from memory                      //
#define WRITE           0x02    // Write data to memory                       //
#define RDMR            0x05    // Read mode register                         //
#define WRMR            0x01    // Write mode register                        //
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
#define CS LATC2_bit            // left hand Mikrobus socket                  //
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
// Function prototypes                                                        //                                                                           //
////////////////////////////////////////////////////////////////////////////////
// Function - Initialise SRAM                                                 //
//            Max speed is 80/4 = 20MHz but 10MHz measured maximum            //
//            MODE 0: CPOL=0 and CPHA=0 - use this mode                       //
//            MODE 3: CPOL=1 and CPHA=1                                       //
//            _SPI_CLK_IDLE_HIGH,_SPI_ACTIVE_2_IDLE)                          //
//            _SPI_CLK_IDLE_LOW, _SPI_IDLE_2_ACTIVE)                          //
//            Uses SPI3 on SDO3/RF8 SDI3/RF2 SCK3/RD15 CS/RC2                 //
void SRAM_Init();                                                             //
////////////////////////////////////////////////////////////////////////////////
// Function - Read a byte from memory with 24 bit address                     //
char SRAM_ReadByte(unsigned long address);                                    //
////////////////////////////////////////////////////////////////////////////////
// Function - Write a byte to memory with 24 bit address                      //
SRAM_WriteByte(char in_byte, unsigned long address);                          //
////////////////////////////////////////////////////////////////////////////////
// Function - Write a byte to the Mode Register                               //
SRAM_WriteMode(char in_byte);                                                 //
////////////////////////////////////////////////////////////////////////////////
// Function - Read a byte from the Mode Register                              //
char SRAM_ReadMode();                                                         //
////////////////////////////////////////////////////////////////////////////////
// Function - Write a page of 32 bytes to memory with 24 bit address          //
//            23LCV1024 has 4,096 pages of 32 bytes each                      //
//            Function is passed a pointer to the array to be recorded        //
SRAM_WritePage(char *in_array, unsigned int page);                            //
////////////////////////////////////////////////////////////////////////////////
// Function - Read a page of memory with 24 bit address                       //
//            Function is passed a pointer to the array to be recorded        //
SRAM_ReadPage(char *out_array, unsigned int page);                            //
////////////////////////////////////////////////////////////////////////////////

If you find this useful - please let me know and I will post other similar code here.
I find SDK and Libstock too difficult!

Regards Bill Legge


Top
 Profile  
 
PostPosted: 16 Jan 2019 15:28 
Offline
mikroElektronika team
User avatar

Joined: 25 Jan 2008 09:56
Posts: 10205
Hi,

Thank you for your contribution. :)

Regards,
Filip.


Top
 Profile  
 
Display posts from previous:  Sort by  
Post new topic Reply to topic  [ 2 posts ] 

All times are UTC + 1 hour


Who is online

Users browsing this forum: No registered users and 1 guest


You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot post attachments in this forum

Search for:
Jump to: