Hola, estoy intentando utilizar una RAM externa conectada a un arduino.
A la hora de hacer el cableado tengo dudas en donde conectar el HOLD, he visto esquemas que los conecta a +5V y otros a GND.
¿Para qué sirve exactamente el HOLD? ¿Dónde debería conectarlo?
Gracias anticipadas,
mariocotorillas que suerte que trabajamos juntos no?
Te entiendo a las mil maravillas.
Ahora perdona la ironía pero lee tu post de nuevo y dime si alguien puede responderte basado en lo que dices?
Mi amigo.. te invito a que leas las normas del foro, punto 3.
Detalla tu problema con la mayor cantidad de elementos posibles.
Si estas haciendo una conexión de RAM externa y me hablas de una conexión dada, no te parece que debes incluir un esquema electrónico?
Si no lo tienes y usas ALGO comprado, pon un enlace, foto, o lo que sea que ayude. Si tienes código lo mismo.
Cualqueir información que dispongas será ultl para responderte.
No cuesta nada ser más amable. Si no quieres responder no lo hagas, pero creo que en ningún momento posteé en un tono inapropiado, puedes decir lo mismo de mejores maneras, creo que no soy el primer usuario que te lo dice.
El problema lo detallé hasta el punto que me pareció oportuno, si quieres más información para poder ayudar a la comunidad, pídela de manera educada, tan sencillo como eso.
No me parece que deba incluir ningún esquema electrónico, pues si alguien ha trabajado con RAM externa sabrá a que me refiero y el que no haya trabajado no me podrá ayudar. En caso de que alguien que haya trabajado crea necesario que deba aportar más información puede preguntarlo de una manera coherente.
De todas formas y a riesgo de otra macro respuesta sin aporte tecnológico ni interés como la que has dado antes, he dejado un link de la web que proporciona arduino respecto a las memorias RAM.
Saludos
Hola:
En la Web que puso indica que usa el protocolo SPI, que es mucho más aconsejable y rápida que el I2C.
http://playground.arduino.cc/Main/SpiRAM
Aquí hay mucha más RAM de la firma Microchip.
http://www.microchip.com/pagehandler/en-us/products/memory/serialSRAM/home.html
#include <SPI.h>
#define SRAM_DEVICE 10 // SRAM on pin 10
// 23A256 commands
#define SRAM_READ 0b011 // Read data from memory array beginning at selected address
#define SRAM_WRITE 0b010 // Write data to memory array beginning at selected address
#define SRAM_RDSR 0b101 // Read STATUS register
#define SRAM_WRSR 0b001 // Write STATUS register
// operation modes (status register)
#define SRAM_BYTE_MODE 0b00000000 // Byte mode (default operation)
#define SRAM_PAGE_MODE 0b10000000 // Page mode
#define SRAM_SEQN_MODE 0b01000000 // Sequential mode
#define SRAM_RSVD_MODE 0b11000000 // Reserved
#define SRAM_HOLD_MODE 0b00000001 // Set this bit to DISABLE hold mode
// setup SRAM device by turning into sequential mode
void sram_setup (const byte device)
{
digitalWrite (device, LOW); // select device
SPI.transfer (SRAM_WRSR);
SPI.transfer (SRAM_SEQN_MODE);
digitalWrite (device, HIGH); // deselect device
} // end of sram_setup
// write 'length' bytes from 'data' to device at address 'address'
void sram_write (const byte device, unsigned int address, byte * data, unsigned int length)
{
if (length == 0) // don't bother if nothing to do
return;
digitalWrite (device, LOW);
SPI.transfer (SRAM_WRITE); // write mode
SPI.transfer (address >> 8); // high-order address byte
SPI.transfer (address & 0xFF); // low-order address byte
for ( ; length ; --length)
SPI.transfer (*data++); // data byte
digitalWrite (device, HIGH); // deselect device
} // end of sram_write
// read 'length' bytes into 'data' to device from address 'address'
void sram_read (const byte device, unsigned int address, byte * data, unsigned int length)
{
if (length == 0) // don't bother if nothing to do
return;
digitalWrite (device, LOW); // select device
SPI.transfer (SRAM_READ); // read mode
SPI.transfer (address >> 8); // high-order address byte
SPI.transfer (address & 0xFF); // low-order address byte
for ( ; length ; --length)
*data++ = SPI.transfer (0); // data byte
digitalWrite (device, HIGH); // deselect device
} // end of sram_write
void setup (void)
{
Serial.begin (9600);
SPI.begin ();
sram_setup (SRAM_DEVICE);
}
char test [] = "hello, world";
void loop (void)
{
sram_write (SRAM_DEVICE, 100, (byte *) test, sizeof test);
char buf [100];
sram_read (SRAM_DEVICE, 100, (byte *) buf, sizeof buf);
Serial.println (buf);
delay (1000);
}
Un cordial saludos.
Gracias! Queda todo muy bien explicado en la última web que pusiste!
¿Sabéis a qué Vcc debo conectar la RAM? En la web de arduino pone 5V, pero el chip 23K256 está diseñado para ser utilizado entre 2.7-3.6V, supongo que deberé seguir este criterio último, no?
Si alguien lo ha utilizado que me diga, gracias
Bueno yo aclaré mi tono irónico pero no entendiste mi aclaración, lo que no importa.
Luego editaste tu post porque esa dirección al final no estaba y era parte de lo que te pedía como información.
Ya te respondieron en gran medida.
Respecto de los niveles, si la memoria es 3.3V tendrás que usar adaptadores de nivel para darle ordenes pero podrías prescindir de ellos para las operaciones de lectura.
Puntualmente. Si es SPI a 3.3V todo lo que es salida de arduino a la memoria puedes usar 1k (conectado a la salida del Arduino) y 2k (a gnd) como divisor resistivo, desde el punto central a la memoria.
La entrada MISO sin adaptador.
Otra alternativa es esta
Gracias por la respuesta,
Tengo reguladores en mi placa, por lo que alimentaré la RAM a 3.3V, además la placa atmel que utilizo también se alimenta a 3.3V, por lo que entiendo que no debería haber problemas de comunicación, no?
Si me estoy equivocando en algo decídmelo, gracias.
Si todo trabaja a 3.3V no tienes de que preocuparte, es mas es hora de que TODOS nos vayamos poniendo a trabajar a 3.3V porque 5V se esta abandonando de a poco.
Hola:
Estos están mejor o eso parece. Porque es en un integrado.
Saludos.
Mejor para que? Ya dijo que Arduino y memoria estan a 3.3V