Metaconta:
Tengo que averiguar como implmentarlo porque e4stoy liado, ajjajaa ajajjajaja.
¿Implementar qué? 2048 es divisible entre 16 así que tranquilamente puedes irte así:
int veces = 2048 / 16;
for (int i = 0; i < veces; i++) {
serialPort1.Write(archivo, i * 16, 16);
// Retraso de 5 ms y mecanismo de cancelación
}
serialPort1.Write(archivo, i * 16, 16);
¿Por qué i * 16?
i = posición de los bytes del archivo hex metido en un array tipo Byte[].
0 * 16 = 0 Bytes.
1 * 16 = 16 Bytes.
2 * 16 = 32 Bytes.
[...]
16 * 16 = 256 Bytes.
[...]
128 * 16 = 2048 Bytes.
El mecanismo de cancelación puede ser así:
private void timer1_Tick(object sender, EventArgs e)
{
serialPort1.Write(archivo, posicion, 16)
posicion += 16;
if (posicion >= 2048)
{
Timer1.Stop();
}
}
Otra cosa antes que se me olvide.
Cuando instalas Arduino IDE se instala los drivers. Si tengo Arduino UNO acabado con su caja incluido y usando LCD más un buen zócalo ZIF.
Quiero evitar usar estos zócalos.
Sobre todo este.
¿Hay en la Web oficial de Arduino, descargar solo driver de los Arduinos?
Eso que tengas que descargar el IDE completo, como que no mola. 
Saludos.
¿Hay en la Web oficial de Arduino, descargar solo driver de los Arduinos?
Eso que tengas que descargar el IDE completo, como que no mola.
Estas respondiendo todos los dias usando el blog de Arduino y nunca te diste cuenta que tienes una opción que dice Software?
Has click ahi y te responderás solo la consulta.
Al descargar el IDE aparece esto
Por lo que queda claro que no puedes evitar bajar el software del IDE asi que tu mejor opción es subirlo a un repositorio y usar el link correspondiente para tu mejor utilidad.
Metaconta:
serialPort1.Write(archivo, i * 16, 16);¿Por qué i * 16?
Pensé que los parámetros de Write eran:
int Write(Byte[] a, int offset, int len)
a: el vector de bytes.
offset: posición inicial donde se va a iterar el vector (relativo al cero).
len: la cantidad de bytes que se van a tomar desde la posición offset.
Se supone que de esta manera enviamos bytes en bloques de 16, pero a vez sin olvidarnos de ninguno (a menos de que archivo.Length % 16 != 0).
Metaconta:
El mecanismo de cancelación puede ser así:private void timer1_Tick(object sender, EventArgs e)
{
serialPort1.Write(archivo, posicion, 16)
posicion += 16;
if (posicion >= 2048)
{
Timer1.Stop();
}
}
Recuerda que también hay que tomar en cuenta si puede ser a voluntad del usuario.
Metaconta:
Si tengo Arduino UNO acabado con su caja incluido y usando LCD más un buen zócalo ZIF.Quiero evitar usar estos zócalos.
Sobre todo este.
Tiene sentido; es para crear una herramienta de desarrollo, no un proyecto definitivo. Que se pueda colocar y remover un integrado con facilidad, es algo que conviene para un desarrollador.
Metaconta:
¿Hay en la Web oficial de Arduino, descargar solo driver de los Arduinos?Eso que tengas que descargar el IDE completo, como que no mola.
Entonces sería buscarlos por separado. Arduino Uno he visto que puede tener tres convertidores USB/serial distintos: uno que es un microcontrolador similar al de un Leonardo/Micro, otros usan un FTDI, y por último los clones chinos y su CH340. Sería cuestión de buscarlos por separado y luego subirlos a la nube para facilitarle la vida al que los busque. De hecho estoy registrado en un servicio gratuito de alojamiento web, si subiera dichos archivos a la carpeta pública, podría crear un link de descarga 100% directo.
Hola:
Hice lo de enviar en otro programa a parte para saber si puedo grabar algo al LC2416B y nada.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO; // No olvidar.
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace EEPROM_pagina_16_Bytes_cs
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
// Abrir puerto mientra se ejecute la aplicación.
if (!serialPort1.IsOpen)
{
try
{
serialPort1.Open(); // Abrir puerto.
}
catch (System.Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
}
int posicion = 0;
// Variables.
bool alto = false;
int N = 0;
int P = 0;
int resultado = 0;
// Carga el archivo en el array.
byte[] archivo = File.ReadAllBytes(@"Archivo.hex");
private void timer1_Tick(object sender, EventArgs e)
{
serialPort1.Write(archivo, posicion, 16);
posicion += 16;
if (posicion >= 2048)
{
timer1.Enabled = false;
}
}
private void TestDoEvents()
{
timer1.Enabled = true;
// Hasta donde llegue el tamaño del archivo.
progressBar_barrra_progreso.Maximum = archivo.Length;
// Guarda la cantidad de Bytes del archivo en la variable.
N = archivo.Length - 1;
// Transmite byte en byte los datos del archivo al puerto serie.
for (int posicion = 0; posicion <= archivo.GetUpperBound(0); posicion++)
{
// Enviando archivo al puerto serie.
// serialPort1.Write(archivo, posicion, 16);
// Números de Bytes posicion de guarda en la variable P.
P = posicion;
// Resultado de la regla de tres. Cálculo del porcentaje de la barra de progreso.
resultado = ((100 * posicion) / N);
// Muestra barra del progreso.
progressBar_barrra_progreso.Value = posicion;
// Muestra la cantidad en porciento archivo enviado.
label_Por_ciento.Text = resultado + " %";
// Evento de cancelación.
Application.DoEvents();
if (alto == true)
{
alto = false;
break; // TODO: might not be correct. Was : Exit For
}
}
}
private void button_Enviar_Click(object sender, EventArgs e)
{
TestDoEvents();
progressBar_barrra_progreso.Minimum = 0; // Barra de progreso en 0.
progressBar_barrra_progreso.Maximum = archivo.Length; // Hasta donde llegue el tamaño del archivo.
}
}
}
Les dejo el programa en descarga. Lo he intentado usar con el puerto com1 físico y el programador TE20x, el mismo que el JDM Programmer.
Está a 115200 baudios.
Saludos.
Prgrama.zip (5.22 KB)
Empezando otra vez desce cero, estoy que ardo. Les dejo mi idea y sacan sus propias conclusiones antes de empezar.
Nombre de los componentes:
button_Archivo
button_Leer
button_Grabar
button_Verificar
textBox_Ubicacion_archivo
textBox_Tamaño_EEPROM
textBox_Pagina_EEPROM
textBox_Escritura_ms
richTextBox_Hex
richTextBox_ASCII
comboBox_Elige_EEPROM
statusStrip_Informacion
progressBar_Progreso
label_Ubicacion
label_Hex
label_ASCII
label_Progreso
label_Tamaño_EEPROM
label_Pagina_EEPROM
label_Escritura_ms
label_Elige_EEPROM
serialPort1
timer1
Lo que quiero hacer para este tema:
Encontrar un archivo hexadecimal, llamado Archivo.hex. (Da igual el nombre). Si pulsas el botón button_Archivo, se habre una ventana para encontrar el Archivo.hex. Cuando selecciones el archivo y lo aceptas, en el textBox_Ubicacion_archivo aparece el nombre de la ubicación.
Se mostrará el contenido en el richTextBox_Hex en hexadecimal. Al mismo tiempo se mostrará en ASCII en el otro richTextBox_ASCII.
El puerto serie serialPort1 está configurado por ahora en el COM1, 115200 baudios. Esto puede cambiar.
El timer1 a 5ms su intervalo.
Nos centraremos solo un botón, el de Grabar.
En comboBox_Elige_EEPROM añado en Items estas EEPROM.
24LC00 - 128 bit - 0 Bytes.
24LC01B - 1 Kbit - 8 Bytes.
24LC02B - 2 Kbit - 8 Bytes.
24LC04B - 4 Kbit - 16 Bytes.
24LC08B - 8 Kbit - 16 Bytes.
24LC16B - 16 Kbit - 16 Bytes.
24LC32A - 32 Kbit - 32 Bytes.
24LC64 - 64 Kbit - 32 Kbytes.
24LC128 - 128 Kbit - 64 Bytes.
24LC256 - 256 Kbit - 64 Bytes.
24LC512 - 512 Kbit - 128 Bytes.
24LC1025 - 1025 Kbit - 128 Bytes.
24LC1026 - 1026 Kbit - 128 Bytes.
AT24CM02 - 2 Mbit - 256 Bytes.
Si no está en la lista porque salió una EEPROM nueva, elijo en comboBox_Elige_EEPROM como Items 24xx?? Manual.
En textBox_Tamaño_EEPROM pongo el tamaño yo mismo a 2048 a mano, en textBox_Pagina_EEPROM pongo 16 que es lo que debo hacer, enviar 16 Bytes de página y en textBox_Escritura_ms defino su intervalo a 5.
Si selecciono el comboBox_Elige_EEPROM alguna EEPROM, tiene que salir por defecto sus valores indicado en textBox_Tamaño_EEPROM
textBox_Pagina_EEPROM
textBox_Escritura_ms
Si es manual, lo introduce el usuario.
En este caso nos centramos en el 24LC16B, que son 2048 Bytes, página 16 Bytes a enviar por cada 5 ms. 5ms son 0.005 segundos del timer.
Vuelvo repetir, nos centramos en grabar, que sea capaz de enviar 2048 bytes en 16 Bytes cada 5 ms hasta llegar el tope, 2048 Bytes y luego se detiene el proceso.
Si se me escapa algún dato antes de empezar, avisa.
Saludos.
PD: Me voy a la playa, hace mucho calor, luego vuelvo. Para eso estamos de vacaciones, ejjejejejej.
Metaconta:
Se puede usar diccionario en Arduino?
Si existe en C++ posiblemente en la IDE de Arduino también se haya heredado.
La idea de usar #define (o similar), es para reemplazar números enteros por algo más significativo y fácil de comprender. También al final (en el compilado) debe convertise en valores "hard-coded", y no en una estructura que ocupe espacio en memoria.
Metaconta:
Lo he intentado usar con el puerto com1 físico y el programador TE20x, el mismo que el JDM Programmer.
Si no es con el Arduino entonces no tengo idea.
Metaconta:
Está a 115200 baudios.
Para volcado (lectura) de la EEPROM la velocidad no importa; pero para el grabado sería mandatorio el retraso de 5 ms (y hacer el búfer RX tan grande como 256 bytes; y sí se puede, también el de I2C).
De no poder agrandarse el búfer de entrada de I2C (Wire), la lectura solo se podría realizar en bloques de 32 bytes a menos que Serial los consuma lo suficientemente rápido para que nunca se llegue a llenar.
Metaconta:
24LC00 - 128 bit - 0 Bytes.
Para efectos de código debes aclarar bien qué significa una página de 0 bytes, ¿será más bien que solo se puede escribir un byte a la vez?
Ahora sí se ve más elaborado. Creo que con esos datos debe bastar para iniciar el grabado. También debes encargarte del "módulo" o "capa" que maneja la comunicación con el Arduino a manera de "petición/respuesta" (es binaria o a nivel de bytes)
Buena:
El protocolo de comunicación de TE20x o JDM Programmer es el mismo que el de Arduino, RS232.
Aún no se ha hecho nada de Arduino, como que pines usaremos para I2C, para SPI enel futuro y para el LCD de la Pad KeyShield.
Los datos se envían con el protocolo RS232 del puerto serie en tramas de Bytes. Así que para el 24LC12B, son en 16 Bytes en 16 Bytes por cada 5 ms.
En cuanto al 24LC00 - 128 bit - 0 Bytes. Solo es Byte por Byte, jejejejejjeejjeje.
Sigo investigando.
Metaconta:
El protocolo de comunicación de TE20x o JDM Programmer es el mismo que el de Arduino, RS232.
UART supongo. Sí, hablamos de un protocolo de comunicación serial; sin embargó creí que era de un protocolo de aplicación (como mi implementación de "petición-respuesta").
Metaconta:
Aún no se ha hecho nada de Arduino, como que pines usaremos para I2C, para SPI enel futuro y para el LCD de la Pad KeyShield.
I2C: A4 y A5.
SPI: 10, 11, 12 y 13.
LCD: me preocupa que entre en conflicto con SPI.
Buenas:
Para el LCD:
LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);
// LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
El pin 10 es la luz de fondo del LCD, así que ni tocarlo. Está ocupado físicamente.
Los pines 0 y 1 son del puerto, ni tocarlo ya que se usará para la comunicación del grabado y lectura de las EEPROM.
El Pin A0 está ocupado por la LCD Padkey Shield, botones en la entrada analógica.
Queda libre de Arduino UNO r3 los pines 2, 3, 4, 5 y 6. También los analógicos que se adapta al digital A1, A2, A3, A4, A5.
Parece que si hay pines de sobra, tanto para el I2C como el SPI.
Siguiendo el tema del escritorio.
Dentro del ComboBox, en Items he rellenado estos datos para elegirlo.
24xx?? Manual
24LC00 - 128 bit - 0 Bytes.
24LC01B - 1 Kbit - 8 Bytes.
24LC02B - 2 Kbit - 8 Bytes.
24LC04B - 4 Kbit - 16 Bytes.
24LC08B - 8 Kbit - 16 Bytes.
24LC16B - 16 Kbit - 16 Bytes.
24LC32A - 32 Kbit - 32 Bytes.
24LC64 - 64 Kbit - 32 Bytes.
24LC128 - 128 Kbit - 64 Bytes.
24LC256 - 256 Kbit - 64 Bytes.
24LC512 - 512 Kbit - 128 Bytes.
24LC1025 - 1025 Kbit - 128 Bytes.
24LC1026 - 1026 Kbit - 128 Bytes.
AT24CM02 - 2 Mbit - 256 Bytes.
Como puedes ver arriba, he elegido la EEPROM llamada 24LC16B, en el cual dice que son de 16 Kbit, o lo que es lo mismo 2048 Bytes y de 16 Bytes de página.
Los tres TextBox está en modo lectura y de ha mostrado información como, Tamaño Bytes a 2018, Página a 16 y Escritura (ms) a 5.
Cada EEPROM del ComboBox tiene sus datos como indiqué arriba y en modo lectura los tres TextBox.
Si en el ComoBox elijo esta opción:
24xx?? Manual
Los tres TextBox se limpian de contenido y se desactiva el modo solo lectura, es decir, que se puede introducir datos por el usuario.
Los datos que están en los textBox son siempre números. Esos números siempre se guardan en sus correspondientes variables llamadas:
// Variables.
int tamañoBytes = 0;
int pagina = 0;
int escrituraMs = 0;
¿Cuál es la idea de que el usuario pueda insertar los tamaños de la EEPROM, página y tiempo?
Con el tiempo, hay progrmas muy populares que han dejado de actualizarse, por ejemplo el PonyProg, IC-Prog, WinPic800 (este le estoy convenciando que actualice, ajajjajajjaa) y no hay posibilidad de usar las nuevas EEPROM más grandes que van apareciendo.
Por ejemplo, en PonyProg no es capaz de grabar un 24LC1025 porque no está programado, ya que en esa época no existía. Según la demanda de los TV entre otros aparatos, van sacando mayor capacidad.
Si no puedes usar el 24LC1025, como máximo hasta el 24LC512.
¿Cuál es la solución habitual?
Buscar otro programador.
¿Cuál es la solución para este programador que estamos haciendo?
Está pensado para el futuro. Si sacan una nueva EEPROM y no está en la lista, por ejemplo, uno de 4 Mbit, se mira la hoja de datos y se configura por capacidad de EEPROM, tamaños de la página en Bytes y los cilcos de escritura.
Haré hasta los iconos con Photoshop. De grabado, lectura, verificar.
Otra pregunta, dice que 1Kbit. ¿Son 1000 bit o son 1024 bit?
1000 bit / 8 = 125 Byte.
1024 bit / 8 = 128 Byes.
¿256 Kbit = 256000 Bit o 256 Kbit son exactamente 262144 bit para el 24LC256?
262144 / 8 = 32768 Bytes = 32 KBytes.
Para no volverme loco, tengo que hacer una buena tabla, ya que debo respetar en Bytes en C# si o si.
Sigo investigando...
Metaconta:
El pin 10 es la luz de fondo del LCD, así que ni tocarlo. Está ocupado físicamente.
[...]
Queda libre de Arduino UNO r3 los pines 2, 3, 4, 5 y 6.
Si no es el 10, también suelo usar el 4 para el CS del SPI.
Metaconta:
También los analógicos que se adapta al digital A1, A2, A3, A4, A5.
Corrección:
Metaconta:
También los analógicos que se adapta al digital A1, A2, A3~~, A4, A5~~.
A4 y A5 siguen siendo del I2C.
Metaconta:
¿Cuál es la solución para este programador que estamos haciendo?Está pensado para el futuro. Si sacan una nueva EEPROM y no está en la lista, por ejemplo, uno de 4 Mbit, se mira la hoja de datos y se configura por capacidad de EEPROM, tamaños de la página en Bytes y los cilcos de escritura.
¡Bien dicho! Buena forma de retrasar su obsolescencia.
Metaconta:
Haré hasta los iconos con Photoshop. De grabado, lectura, verificar.
Vaya, da la impresión de querer hacerlo de forma "profesional".
Metaconta:
Otra pregunta, dice que 1Kbit. ¿Son 1000 bit o son 1024 bit?1000 bit / 8 = 125 Byte.
1024 bit / 8 = 128 Byes.¿256 Kbit = 256000 Bit o 256 Kbit son exactamente 262144 bit para el 24LC256?
262144 / 8 = 32768 Bytes = 32 KBytes.
No eres el único que se confundió con eso. Cuando intenté estudiar las hojas de datos quedé con la misma duda.
Es extraño, no lo expresan correctamente pero en realidad sí referencian múltiplos binarios. 16000 bits jamás se van a alinear con páginas de 16 bytes (16000 / 128 = 125)...
Ehhh... 
tal parece que se ha caído mi teoría; pero... 1000 / 64 = 15.625, así que estoy completamente seguro que es en múltiplos binarios. Otro ejemplo: 64 Kbit = 65536 bits.
Hola:
Tendré que hacer una buena lista de todas las EEPROM proque debe ser exacto, tanto bit como Bytes, es decir, tiene que ser 65536 bit, no 64 Kbit a secas a la hora de programar. A parte de esto, ponerlo en Bytes, así:
65536 bit / 8 = 8192 Bytes.
Me quedo todo en Bytes, nada de 8 KBytes o en bit. Para poder trabajar internamente a la hora de lectura y escritura de las EEPROM.
Estoy liado con el tema de cargas de las EEPROM en los comoBox, ajjajajaja.
En este sentido me funciona. No subo ejecutable proque no lo probarán por lo que he comprobado, ejjejeje.
Ahora estoy haciendo la otra parte que no me sale, elegir I2C que carga todas las EEPROM tipo 24LCxx, y SPI, carga todas las EEPROM tipo 25LCxx.
Lista 24LCxx:
24LC00 - 128 bit - 0 Bytes.
24LC01B - 1 Kbit - 8 Bytes.
24LC02B - 2 Kbit - 8 Bytes.
24LC04B - 4 Kbit - 16 Bytes.
24LC08B - 8 Kbit - 16 Bytes.
24LC16B - 16 Kbit - 16 Bytes.
24LC32A - 32 Kbit - 32 Bytes.
24LC64 - 64 Kbit - 32 Bytes.
24LC128 - 128 Kbit - 64 Bytes.
24LC256 - 256 Kbit - 64 Bytes.
24LC512 - 512 Kbit - 128 Bytes.
24LC1025 - 1025 Kbit - 128 Bytes.
24LC1026 - 1026 Kbit - 128 Bytes.
AT24CM02 - 2 Mbit - 256 Bytes.
24xx??
Lista 25LCxx:
25LC010A - 1 Kbit - 16 Bytes.
25LC020A - 2 Kbit - 16 Bytes.
25LC040A - 4 Kbit - 16 Bytes.
25LC080C - 8 Kbit - 16 Bytes.
25LC080D - 8 Kbit - 32 Bytes.
25LC160D - 16 Kbit - 32 Bytes.
25LC320A - 32 Kbit - 32 Bytes.
25LC640A - 64 Kbit - 32 Bytes.
25LC128 - 128 Kbit - 64 Bytes.
25LC256 - 256 Kbit - 64 Bytes.
25LC512 - 512 Kbit - 128 Bytes.
25LC1024 - 1 Mbit - 256 Bytes.
AT25M02 - 2 Mbit - 256 Bytes.
25LCxx
La lista en realidad so nmucho más, hay muchas variantes, muchas, como estoy de pruebas, pongo las más usadas, más adelante pondré todas las que venden actualmente. Aún así, podrás programar sus datos para programar cualquier EEPROM.
Pare dejarlo más claro en boceto.
Saludos.
Metaconta:
Estoy liado con el tema de cargas de las EEPROM en los comoBox, ajjajajaja.
¿EEPROM por qué? Solo hazte de cuentas que las capacidades a partir de 1 Kbit comienzan con una cifra de 2^10 bits; entonces eso quiere decir que 16 Kbit = 2^14 bits y 64 Kbit = 2^16 bits. ¿Encuentras un patrón en esto?
Si en C# los combobox se manejan idéntico a Java, entonces lo que deberías hacer es cambiar lo que sería el "modelo" del de las EEPROM según la elección en el combobox del protocolo. En Java, un modelo de combobox es básicamente una forma de adjuntarle un vector (array) de objetos.
Lista EEPROM en Bytes:
128 bit = 16 Bytes.
1 Kbit = 1024 bit = 128 Bytes.
2 Kbit = 2048 bit = 256 Bytes.
4 Kbit = 4096 bit = 512 Bytes.
8 Kbit = 8192 bit = 1024 Bytes.
16 Kbit = 16384 bit = 2048 Bytes.
32 Kbit = 32768 bit = 4096 Bytes.
64 Kbit = 65536 bit = 8192 Bytes.
128 Kbit = 131072 bit = 16384 Bytes.
256 Kbit = 262144 bit = 32768 Bytes.
512 Kbit = 524288 bit = 65536 Bytes.
1024 Kbit = 1 Mbit = 1048576 bit = 131072 Bytes.
2048 Kbit = 2 Mbit = 2097157 bit = 262144 Bytes.
Había que hacerla y con paciencia.
Sigo avanzando poco a poco. Ahora por fin me funciona la elección de las EEPROM, no puse muchas, pero pondré toda sus variantes, que no falte ninguno, pero esto es al final, hasta ver que Arduino UNO sea capaz de graber una EEPROM, incluido leerla.
Me toca controlar el puerto serie como debe ser. Esto de las páginas y tiempo no es fácil.
Como podrás ver.
En este caso la variable archivo contiene 2048 Bytes que lo indica en Tamaño Bytes del formulario.
El 0 es la posición del archivo, empieza desde el principio.
La variable pagina en este caso es de 16 Bytes.
El timer1 tiene un intervalo de 5ms.
Con esto, graba un archivo de 2048 Bytes de tamaño, dividido en páginas de 16 Bytes por cada 5 ms.
Sigo investigando...
Saludos.
Metaconta:
Lista EEPROM en Bytes:
128 bit = 16 Bytes.
1 Kbit = 1024 bit = 128 Bytes.
2 Kbit = 2048 bit = 256 Bytes.
4 Kbit = 4096 bit = 512 Bytes.
8 Kbit = 8192 bit = 1024 Bytes.
16 Kbit = 16384 bit = 2048 Bytes.
32 Kbit = 32768 bit = 4096 Bytes.
64 Kbit = 65536 bit = 8192 Bytes.
128 Kbit = 131072 bit = 16384 Bytes.
256 Kbit = 262144 bit = 32768 Bytes.
512 Kbit = 524288 bit = 65536 Bytes.
1024 Kbit = 1 Mbit = 1048576 bit = 131072 Bytes.
2048 Kbit = 2 Mbit = 2097157 bit = 262144 Bytes.
Todo correcto.
Metaconta:
pero esto es al final, hasta ver que Arduino UNO sea capaz de graber una EEPROM, incluido leerla.
Y yo sé cómo hacerlo; de hecho sabes que podría colaborar en dicha tarea...
Buenas:
Mira el post atrás, lo he editdo y no se si haz visto la última imagen. En PIC en asm se hacerlo, ejjejejejjje, en Arduino nunca lo he hecho.
Si sabes hacerlo, prepara esquemas, mientras hago un mini programa rápido que solo incluye un archivo interno para poder enviar tramas de Bytes con su página correspondiente. Dije mini programa rápido, con un botón para enviar y me dices si ha grabado algo.
La version grande del programa hay que tomárselo con más calma.
Adelante.
Metaconta:
Si sabes hacerlo, prepara esquemas
¿De qué exactamente?
Metaconta:
y me dices si ha grabado algo.
¿Cómo?
Y otra pregunta: ¿vas a encargarte también de hacer la parte de Arduino o qué?
Voy a encargarme hacer de todo. Si es posible, hasta meter los archivos en una ;iro-SD, pero esto ya se verá, ajajjja.
Metaconta:
hasta meter los archivos en una ;iro-SD
Uuuu, ¿que una EEPROM SPI comparta el bus con una tarjeta SD?
He leído tantas calamidades sobre dispositivos que comparten el bus SPI (cosa que no debería ser) que ya lo veo como un desafío.
Ok. Es mucho pedir.
