Memory Experiments

https://github.com/merlinmarrs/Video-Memory

This project started with an ambitious board combining ADC, DAC and SRAM. 

There were too many issues so I broke the board down into two parts: a memory board and a ADC/DAC board. This allowed me to isolate things and proceed in a step by step way.

I discovered that the memory needed a WR signal inbetween clock address refreshing, and for the second board that my op amp choice was inappropriate and needed to work around it (by using the DAC only as an R2R ladder and skipping the op-amp for the ADC input). 

During assembly I found that several 0 ohm jumpers were causing shorts. I also tore out the 8 pin header but applying too much force accidentally. Otherwise the switch system was very effective to test my understanding of the memory chip operation. It can essentially record a series of button manipulations for about 1.5 minutes.  

Here is my first successful “recording” of a sine wave through the ADC and into SRAM and play back from SRAM through the DAC :

BOARD ERRATA:

-need last bit of address counter (cuts memory in half !)

-more jumpers should be broken out for testing (like alternative op amp for input, clk for various chips, etc.)

-leds burn out when activated and output plugged into 5V at the same time…

-GND and 5V switched on the two boards 🙁

-Wrong op amp spec’d. The ADC1175 suggests the LMH6702MF and a choke between power supplies. 

-caps on all ICs

-the LEDs I set up on the microchip are plugged into ADC…

-Add enable header on microchip board

-power LED on the ADC board

-add a MSB and LSB next to LEDs on memory board **

I calculated how much I could store in the 4K of the SRAM I am currently using, and it would be a single line of a 600×800 screen at 40Mhz pixel frequency…

So what can I do with this ? I could record 4,000 pixels of a static image (i.e. lower the resolution of the image to 100×400 for instance) and then play it back. This would require me to control the sampling of the ADC with the CLK pin of the ADC1175 for every X pixels, somehow synchronized with the VGA in signal (use timing signals of an incoming VGA signal set), or to generate a custom VGA output signal with different timing using the VGAX library. 

Some important references : 

nootropicdesign.com/video-experimenter/build

gieskes.nl/visual-equipment/?file=gvs1

I am looking into what I could draw on screen with only 4K memory at a 20MHz clock.

EEPROM and SD cards are also interesting before reaching the holy grail of magnetic recording media of course…

I have the AT28C256F-15TU EEPROM chip which has 256K x 8 bits (enough to at least store an entire 600×800 static screen) and the ADV7125STZ50 8 bit triple HS video DAC. 

https://www.mouser.fr/datasheet/2/268/doc0006-1108095.pdf

https://www.mouser.fr/datasheet/2/609/ADV7125-1503638.pdf

I’d like to have a standalone arduino VGAX based board (https://github.com/smaffer/vgax) which can output 120×60 pixels and reads from internal SRAM and can record and playback. With 256K I could record a static image on screen at a higher resolution or a low resolution short video.

I have already made an SD card image saving board: 

Just realized what I’m trying to do is called a frame grabber and it’s a massive PCB :

https://en.wikipedia.org/wiki/Frame_grabber#:~:text=A%20frame%20grabber%20is%20an,or%20a%20digital%20video%20stream.&text=Historically%2C%20frame%20grabber%20expansion%20cards,to%20interface%20cameras%20to%20PCs.

*********************************************************************************

I have designed a similar memory board but using a 256K EEPROM chip in place of the  SRAM and with VGA connectors to begin testing images. (There do appear to be larger SRAMs, going up to 16MB. There are obviously large flash memories in SD format going into the GBs which may also be interesting to play with).

-Added out VGA to work with VGAX library (not sure if need a second microchip to handle just the memory stuff?)

-Added a 16MHz resonator

-With two 8 bit counters to have the full 13 bits to control this time.

-EEPROM will keep a recording after power down.

-can control buffers with microchip

Just learned that EEPROM is probably the slowest…

Just a thought but I could save control signals for the 0c74 instead of saving actual pixel information…

*************

First test (WORKING):

int switchState = 0;

pinMode(6, OUTPUT); // CLK LED (*)
pinMode(7, OUTPUT); // CLK

pinMode(10, OUTPUT); // WR/RD SIGNAL TO SRAM
pinMode(A3, INPUT); // WR/RD SWITCH (WR HIGH, READ LOW)

pinMode(8, OUTPUT); // WR LED
}

// the loop function runs over and over again forever
void loop() {

switchState = digitalRead(A3);

// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (switchState == LOW) {
// WR selected on switch so turn WR LED on and send a LOW to SRAM

digitalWrite(8, HIGH);
//
digitalWrite(10, HIGH);
digitalWrite(6, HIGH); // 
digitalWrite(7, HIGH); // 
delay(10);
digitalWrite(10, LOW);
digitalWrite(6, HIGH); // 
digitalWrite(7, HIGH); // 
delay(10); // 
digitalWrite(10, LOW);
digitalWrite(6, LOW); 
digitalWrite(7, LOW); 
delay(10); // 
digitalWrite(10, HIGH);
digitalWrite(6, LOW); // 
digitalWrite(7, LOW); // 
delay(10); // 

}
else {
// READ selected on switch so turn WR LED OFF on and send a HIGH to SRAM
digitalWrite(10, HIGH); // STAYS HIGH THE WHOLE TIME
digitalWrite(8, LOW);
//
digitalWrite(6, HIGH); // 
digitalWrite(7, HIGH); //
delay(20); // 
digitalWrite(6, LOW); // 
digitalWrite(7, LOW); // 
delay(20); //

}

}

This is what it produces:

Second test (WORKING): 

int switchState = 0;

// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin 13 as an output.
pinMode(6, OUTPUT); // CLK LED (*)
pinMode(7, OUTPUT); // CLK

pinMode(10, OUTPUT); // WR/RD SIGNAL TO SRAM
pinMode(A3, INPUT); // WR/RD SWITCH (WR HIGH, READ LOW)

pinMode(8, OUTPUT); // WR LED
}

// the loop function runs over and over again forever
void loop() {

switchState = digitalRead(A3);

// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (switchState == LOW) {
// WR selected on switch so turn WR LED on and send a LOW to SRAM

digitalWrite(8, HIGH);
//
digitalWrite(10, HIGH);
digitalWrite(6, HIGH); // turn the LED on (HIGH is the voltage level)
digitalWrite(7, HIGH); // turn the LED on (HIGH is the voltage level)
delayMicroseconds(1);
digitalWrite(10, LOW);
digitalWrite(6, HIGH); // turn the LED on (HIGH is the voltage level)
digitalWrite(7, HIGH); // turn the LED on (HIGH is the voltage level)
delayMicroseconds(1); // wait for a second
digitalWrite(10, LOW);
digitalWrite(6, LOW); // turn the LED on (HIGH is the voltage level)
digitalWrite(7, LOW); // turn the LED on (HIGH is the voltage level)
delayMicroseconds(1); // wait for a second
digitalWrite(10, HIGH);
digitalWrite(6, LOW); // turn the LED on (HIGH is the voltage level)
digitalWrite(7, LOW); // turn the LED on (HIGH is the voltage level)
delayMicroseconds(1); // wait for a second
// wait for a second
}
else {
// READ selected on switch so turn WR LED OFF on and send a HIGH to SRAM
digitalWrite(10, HIGH); // STAYS HIGH THE WHOLE TIME
digitalWrite(8, LOW);
//
digitalWrite(6, HIGH); // turn the LED on (HIGH is the voltage level)
digitalWrite(7, HIGH); // turn the LED on (HIGH is the voltage level)
delayMicroseconds(1); // wait for a second
digitalWrite(6, LOW); // turn the LED on (HIGH is the voltage level)
digitalWrite(7, LOW); // turn the LED on (HIGH is the voltage level)
delayMicroseconds(1); // wait for a second

}

}

And here are some shots of what three different speeds (10ms, 10microseconds, 1 microseconds) as delay in the Arduino code :

***********************************************************************

Third test (NOT WORKING):

I recorded a sine wave at 100KHz (with WR activated on the microchip board) with the ADC being clocked at 10KHz. I made sure I had the ADC selected with the right buffers and then sent this 8 bit sequence to the memory where I recorded it with a new Arduino code:

void setup()
{
DDRD = B11111111; // set PORTD (digital 7~0) to outputs
DDRB = B11111111; // set PORTB (digital 7~0) to outputs
}

void loop()
{
if((PINC & 0b00001000)==0)
{
PORTD = B11111111; // set PORTD pins (digital 7~0) high
PORTB = B00000000; // set PORTD pins (digital 7~0) low
PORTD = B00000000; // set PORTD pins (digital 7~0) low
PORTB = B11111111; // set PORTD pins (digital 7~0) high

}
else
{
PORTB = B00000100; // WR PULLED HIGH SO TURNED OFF
PORTD = B11111111; // set PORTD pins (digital 7~0) high
PORTD = B00000000; // set PORTD pins (digital 7~0) low
}
}

/*
CLOCK:
_____ _____
| ` | | |
___| |___| |____

WR:
_________ ____________
` | |
|___|

*/

I then switched to the DAC with the buffers and switched into READ mode on the microchip board.  Now the 8 bit sequence was being translated back into a sine wave. I took this sine wave and amplified it with an audio amp and sent it to the three color channels combined with an arduino running the VGAX pattern code without the colors plugged in and only H and V SYNC.

I got this on the screen :

Here is the tentacular and unoptimized setup :

To make this actually easy to use, I need to:

-have the microchip control the buffers and the ADC clocking based on the switch state.

-have the memory and adc on a single board.

-have a VGAX out setup integrated into the memory board.

-have an op amp on the ADC board to amplify the output signal !!

-have a dial change the speed of the playback / sampling of recording.

*******************************************

I added an external crystal and set the AVR dude Fuses to : Ext. Crystal Osc.8.0 – ___MHz 16K CK/14 CK + 65 ms. 

I added F_CPU 16000000UL ABOVE the #include. 

Forgot that if you don’t add 0b before a binary number nothing happens with the pins !

Here is the code that still isn’t working :

/*
* eeprom board v.2.c
*
* Created: 06/02/2022 09:19:50
* Author : Jonah
*/

#include <avr/io.h>

int main(void)
{

DDRC = 0b00000000; // PC3 is the switch for WR (0) or RD(1)

DDRD = 0b11111111; //PD5 is CLK and PD4 is !OE

DDRB = 0b11111111; //PB0 is the LED and PB2 is !WE

while (1)
{

/*
BYTE WRITE: A low pulse on the WE or CE input with CE or WE low (respectively) and OE high initiates a write
cycle. The address is latched on the falling edge of CE or WE, whichever occurs last. The data is latched by the first
rising edge of CE or WE. Once a byte write is started, it will automatically time itself to completion. Once a
programming operation is initiated and for the duration of tWC, a read operation will effectively be a polling operation.
*/

if((PINC & 0b00001000)==0) // WRITE MODE: (CE -> TIED LO); !WE -> TOGGLE ; !OE -> HI ; CLK -> TOGGLE
{
PORTD = 0b00010000; // !OE -> HI ; CLK -> LO
PORTB = 0b00000000; // !WE -> LO
PORTB = 0b00000001; // !WE -> LO (to make the pulse width at least 100ns)
PORTB = 0b00000101; // !WE -> HI
PORTD = 0b00110000; // !OE -> HI ; CLK -> HI (next address must come a max of 50 ns following !WE going HI?)

}

/*
READ: The AT28C256 is accessed like a Static RAM. When CE and OE are low and WE is high, the data stored at
the memory location determined by the address pins is asserted on the outputs.
The outputs are put in the highimpedance state when either CE or OE is high. This dual-line control offers designers flexibility in preventing bus
contention in their system.

*/

else // READ MODE : (CE -> TIED LO); !WE -> HI ; !OE -> (TOGGLE ? OR JUST LO?) ; CLK -> TOGGLE
{
PORTB = 0b00000101; // !WE -> HI
PORTD = 0b00100000; // !OE -> LO ; CLK -> HI
PORTD = 0b00000000; // !OE -> LO ; CLK -> LO
}
}
}

**********************************************************************************

One question I have is: does the EEPROM require OE to go on and off when reading unlike the SRAM I worked with in the previous board ?

Another question is, how long does the EEPROM need to write a byte ? It talks about “access times of 150ns”…?

Is it OK I have CE tied low the whole time ?

As a next step I will try doing all of this but very slowly to see if that works. 

*EDIT : tried slowing everything down and I’m still not able to load anything into the memory :(. I just get 5V and little pops of ground after writing ground into every cell of the memory. This is after changing !OE toggle and always ON also. 

I did get the VGAX code running though so at least that works. 

ERRATA:

-the labeling of WR and RD are confusing, when the switch is to the RD side it is in WR mode etc. 

-the VGA parts are COMPLETELY wrong. 

-I need to order 16MHz of this format (I took one from a dead Arduino board). 

-the text is too small and came off during cleaning.

TROUBLESHOOTING AT28C256 EEPROM:

-Need to wait a second before doing and writing or reading,

-Need to either wait the maximum time for the EEPROM to write (Write Cycle Time Max AT28C256 = 10ms) or poll 1/0 7 to wait until it matches what you sent it before starting another write cycle.

-The device may be locked (even though the devices should ship unlocked) :(. The unlock sequence is :

LOAD DATA AA
TO
ADDRESS 5555

LOAD DATA 55
TO
ADDRESS 2AAA

LOAD DATA 80
TO
ADDRESS 5555

LOAD DATA AA
TO
ADDRESS 5555

LOAD DATA 55
TO
ADDRESS 2AAA

LOAD DATA 20
TO
ADDRESS 5555

LOAD DATA XX
TO
ANY ADDRESS(4)

LOAD LAST BYTE
TO
LAST ADDRESS

************************

Here are some thoughts I have on the SRAM device :

Do I want addressed to loop or not ? (Add inverter if want to loop)

  >> Make it optional with a jumper, this expands the possibilities of experimenting.