Por fin me salió el porcentaje de las narices. El map de Arduino no lo tiene C# ni por asomo.
Código C#:
// Variables.
bool alto = false;
int N = 0;
int P = 0;
int resul = 0;
private void TestDoEvents()
{
// Carga el archivo en el array.
byte[] archivo = File.ReadAllBytes(textBox_ubicacion_archivo.Text);
// 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 i = 0; i <= archivo.GetUpperBound(0); i++)
{
// Enviando archivo al puerto serie.
serialPort1.Write(archivo, i, 1);
// Números de Bytes.
P = i;
// Resultado de la regla de tres. Cálculo del porcentaje de la barra de progreso.
resul = 100 * i / N;
// Muestra barra del progreso.
progressBar_barrra_progreso.Value = i;
// Muestra la cantidad de Bytes enviados.
label_Bytes_transmitidos.Text = i.ToString() + " Bytes.";
// Muestra la cantidad en porciento archivo enviado.
label_Por_ciento.Text = resul + " %";
// Evento de cancelación.
Application.DoEvents();
if (alto == true)
{
alto = false;
break; // TODO: might not be correct. Was : Exit For
}
}
button_Cancelar.Text = "Arranque";
}
private void button_Cancelar_Click(object sender, EventArgs e)
{
if (button_Cancelar.Text == "Arranque")
{
button_Cancelar.Text = "Cancelar";
TestDoEvents();
progressBar_barrra_progreso.Value = 0; // Resetear progressBar a 0.
label_Bytes_transmitidos.Text = "0";
}
else
{
if (alto == true)
{
alto = false;
}
else
{
alto = true;
button_Cancelar.Text = "Arranque";
}
}
}
En cuanto a lsa EEPOM, no sabía que por cada una hay diferente tamaño de la página.
Ver lista EEPROM I2C.
Pues mira que lo tengo progamado enviar todo de golpe. Jajajajaajjajjjja, hasta el final no para de enviar archivos bytes por bytes.
Enviar archivo hex al puerto serie en C#:
private void button_Grabar_Click(object sender, EventArgs e)
{
byte[] archivo = File.ReadAllBytes(textBox_ubicacion_archivo.Text); // Carga el archivo en el array.
}
El libro morado de Enrique Palacios sobre PIC16F84A explica muy bien la EEPROM 24LC256, de 64 páginas. Voy a leer bien las hojas de datos de cada modelo, concretamente los que yo tengo, 24LC16B y el 24LC64. Por supuesto que también los demás y pongo aquí en resumen tamaño y paginación de cada uno de ellos.
EEPROM protocolo I2C:
EEPROM - CAPACIDAD - PAGINACIÓN
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.
Casi no acabo de escribir todo esto.
Cuando pula un poco más el programa, tendré que remplantearme la forma de escribir código para cada dispositivo.
Hay que tener cosas claras. Desde C#, selección de dispositivo y bien programado para cada uno de ellos. Incluido paginación, y el array de datos a enviar, por ejemplo, 64 Kbit, así que tendrá un máximo y graba hasta ahí.
Si no hay que grabar Byte por Byte que es lo que estaba haciendo.
¿Cómo haces la manera que dices para grabar EEPROM?
Por ejemplo, el 24LC256. ¿Tengo que enviar 64 bytes por 64 bytes?
¿Así?
Envío 64 Bytes.
Delay o timer (5 ms (Mili segudnos)).
Envío 64 Bytes.
Timer (5 ms).
Envío 64 Bytes.
Timer (5 ms).
Envío 64 Bytes.
Timer (5 ms).
Envío 64 Bytes.
Cuando digo 5 ms, me imagino que es su descando, es decir, no enviar nada hasta que pase ese tiempo, luego vuelve a enviar 64 Bytes eguidos, luego descansa otros 5 ms sin enviar nada y así hasta veces cuanta.
24LC256 32K Bytes x 8 bits = 256 Kbits.
32 KBytes divididos en 64 páginas de 256 Bytes cada una.
Me confirma como ejemplo, la realidad de como hacerlo. Luego lo haré en programación y lo pongo aquí.
Saludos.
