SDRAM Examples

[rdockterjr]

I've noticed the Portenta_SDRAM library: https://github.com/arduino/ArduinoCore-mbed/tree/master/libraries/Portenta_SDRAM
But it does not have an examples folder. It would be very helpful if someone could post a basic read/write example for interacting with the external SDRAM.

[facchinm]

@rdockterjr you are right, a tutorial on external ram usage is coming.
In the meantime, you can take a look at https://github.com/arduino/ArduinoCore-mbed/blob/master/libraries/doom/doomgeneric_arduino.cpp#L198 for a sample use.
After initializing the RAM via SDRAM.begin(start_address) you can call SDRAM.malloc() and SDRAM.free() from C++ code or ea_malloc and ea_free from C code and it will transparently use the external ram as storage.

[facchinm]

@sbhklr

[rdockterjr]

@facchinm Thanks for the feedback. Just to clarify the preferred usage method would be as follows:
int *array;
array = (int *)SDRAM.malloc(100);
Which would give me an array of size 100 on the SDRAM chip. As opposed to the access method in test():
uint8_t *const sdramptr = (uint8_t*)SDRAM_START_ADDRESS;
Which would just give me a pointer to the first location in SDRAM. Which I could then use directly? Would this way be more efficient?

[facchinm]

Using the wrapped malloc allows you to forget about allocations as they are entirely handled by the library, so that's the best way unless you need some specific location (for example to allocate a large contiguous area like a framebuffer).

[aentinger]

I'm closing this as no further reply by @rdockterjr came in. Please reopen and continue the discussion if necessary.

[hpssjellis]

@aentinger

Can we open this up again?

What would be incredibly useful would be an example assigning the Camera 320x320 Grayscale frame buffer to SDRAM for the Portenta Vision Shield.

Here is a link to the present Portenta raw data example

https://github.com/arduino/ArduinoCore-mbed/blob/master/libraries/Portenta_Camera/examples/CameraCaptureRawBytes/CameraCaptureRawBytes.ino

By the way a grayscale OLED is the only way to mess around with the Portenta Vision Shield (I use the WaveShare 1.5 inch Grayscale 128x128 using the library Adafruit_SSD1327.h)

I would submit a PR for you if the SDRAM 320x320 camera example worked.

I have a base example here for using the grayscale OLED with the Portenta camera, it just needs the SDRAM coding.

[hpssjellis]

Surprisingly this works here with camera at 320x320 and the OLED is very fast showing the screen, using SDRAM for the camera frame buffer.

@facchinm

but I feel it will eventually have memory leaks. Can someone make a suggestion as to how to make it a bit more robust. Specifically how to align it 16 or 32 bit whatever makes more sense. When I use the below method with a machine learning program it randomly crashes. I think align 32 is the best bet but don't know how to do that. The follwoing is probably the main line of code

  sdram_frame_buffer = (uint8_t *)mySDRAM.malloc(320 * 320 * sizeof(uint8_t));

/*
 * 
 *
 * Purchase here https://www.waveshare.com/1.5inch-OLED-Module.htm about $29 USD
 *
 * Note u8g2 is an arduino search caplble library, easy to install
 *
 *  using 128 x 64 seeeduino OLED
 *  black GND 
 *  red 3v3      so do not need the protective resistors below
 *  //white SDA    D11 // on portenta
 *  //yellow SCL   D12 // on portenta
 *  
 *  FOR the GRAYSCALE Waveshare OLED
 *   blue  DIN (mosi) D8
 *   yellow (sck) D9 
 *   orange (cs) D7
 *   green (dc)  D6
 *   white (reset) not needed but D14 if you did
 *
 * another reference here 
 * https://learn.adafruit.com/adafruit-gfx-graphics-library/graphics-primitives
 *
 */


#include <Arduino.h>  // only needed for https://platformio.org/
#include <SDRAM.h>
#include <Adafruit_SSD1327.h>

// Used for software SPI
#define OLED_CLK D9  //yellow wire
#define OLED_MOSI D8 // blue wire 

// Used for software or hardware SPI
#define OLED_CS D7  // orange wire
#define OLED_DC D6   // green wire 

// Used for I2C or SPI
#define OLED_RESET -1

// hardware SPI
Adafruit_SSD1327 display(128, 128, &SPI, OLED_DC, OLED_RESET, OLED_CS);


#include "camera.h"

CameraClass cam;

SDRAMClass mySDRAM;

uint8_t *sdram_frame_buffer;
//uint8_t frame_buffer[320*320];

void setup() {
  //Serial.begin(921600);  
  Serial.begin(115200);  
 
  //mySDRAM.begin();
  
  mySDRAM.begin(SDRAM_START_ADDRESS);

  
  sdram_frame_buffer = (uint8_t *)mySDRAM.malloc(320 * 320 * sizeof(uint8_t));
 
  // Init the cam QVGA, 30FPS
  cam.begin(CAMERA_R320x320, 30);

    if ( ! display.begin(0x3D) ) {
     Serial.println("Unable to initialize OLED");
     while (1) yield();
  }    
    display.setTextSize(1);
    display.setTextColor(SSD1327_WHITE);

    display.setRotation(0);
    display.setCursor(0,0);

    
}

void loop() {
    display.clearDisplay();                 // clear the internal memory

  
   //  display.drawPixel(random(128), random(128), random(512)); 
  // Wait until the receiver acknowledges
  // that they are ready to receive new data
  //while(Serial.read() != 1){};
  
  // Grab frame and write to serial
  if (cam.grab(sdram_frame_buffer) == 0) {
     //Serial.write(frame_buffer, 320*320);     


    for (int x=0; x < 320; x++){     // FRAME_BUFFER_COLS = 320
       for (int y=0; y < 320; y++){       //FRAME_BUFFER_ROWS = 320

          uint16_t myGRAY = sdram_frame_buffer[(y * 320) + x] ;  
        //  int myGRAY = frame_buffer[(y * 320) + x] ;  

        
          int myGrayMap = map(myGRAY, 0, 255, 0, 15);  
          int xMap = map(x, 0, 320, 0, 127);
          int yMap = map(y, 0, 320, 0, 127);
     //     display.drawPixel(xMap, yMap, myGRAY); 
           display.drawPixel(xMap, yMap, (int)myGrayMap);   // grayscale 0-16, 128x128  //128 x 64
         // delayMicroseconds(10);
      } 
    }     
  }

      display.drawRect(5,5,120,120, SSD1327_WHITE );

    display.setCursor(10,10);
    display.println("Rocksetta");

    
  display.display();
        
 // delay(100); 
}

[hpssjellis]

Extra question for working with Tensorflowlite.
Here is an unsigned char array that stores a potentially very large machine learning model. How can I assign the char array to SDRAM and 32 or 16 bit align it?

unsigned int model_tflite_len = 2640;
const unsigned char model_tflite[] = { ...}

[hpssjellis]

Ok, with some help from the people at EdgeImpulse.com I got the alignment working for the camera here

The key parts are

#define ALIGN_PTR(p,a)   ((p & (a-1)) ?(((uintptr_t)p + a) & ~(uintptr_t)(a-1)) : p)


SDRAMClass mySDRAM;

uint8_t *sdram_frame_buffer; // 32-byte aligned
static uint8_t *ei_camera_frame_mem;

then in setup

    ei_camera_frame_mem = (uint8_t *) SDRAM.malloc(320 * 320 + 32 /*alignment*/);
    sdram_frame_buffer = (uint8_t *)ALIGN_PTR((uintptr_t)ei_camera_frame_mem, 32);

and this method works without errors with a machine learning model.

Still curious about the above tensorflwolite question.