INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE
INGENIERÍA MECÁNICA Y
ELÉCTRICA.
PROYECTO : LECTOR DE EBOOKS
CON BOTONERA
ALUMNOS:
Romero Cuevas Alessandro Alberto. GRUPO: 6CV4
Zuriel Miguel Rodríguez GRUPO: 6CV7
PROFESORA:
Segura Corona María Aurora
INTRODUCCION
En la era digital actual, la lectura de libros electrónicos (eBooks) se ha vuelto
cada vez más popular debido a su conveniencia y accesibilidad. Los
dispositivos dedicados a la lectura de eBooks, como los lectores
electrónicos, permiten a los usuarios almacenar y acceder a una vasta
colección de libros en un solo dispositivo. Sin embargo, estos dispositivos a
menudo vienen con un costo elevado y pueden tener una interfaz compleja
para algunos usuarios.
El objetivo de este proyecto es desarrollar un lector de eBooks sencillo y
económico utilizando una placa de desarrollo STM32 y una botonera para la
navegación. Este proyecto combina conocimientos de electrónica,
programación y sistemas embebidos para crear una solución práctica y
accesible para la lectura de eBooks. Utilizaremos una pantalla LCD para
mostrar el contenido del libro y una botonera para navegar entre las páginas.
El proyecto se basa en la plataforma Mbed OS, que proporciona un entorno
de desarrollo eficiente y facilita la integración de diferentes componentes de
hardware. Utilizaremos una interfaz SPI para la comunicación con el LCD y
un registro de desplazamiento 74HC165 para leer el estado de los botones
de la botonera. Además, implementaremos funciones de software para
gestionar la visualización del texto y la navegación entre las páginas del
eBook.
OBJETIVOS ESPECIFICOS
• Desarrollar un lector de eBooks económico: Utilizar componentes de
bajo costo y ampliamente disponibles para crear un dispositivo
funcional.
• Implementar una interfaz de usuario sencilla: Utilizar una botonera
para navegar entre las páginas del eBook, facilitando la interacción del
usuario.
• Utilizar la plataforma Mbed OS: Aprovechar las capacidades de Mbed
OS para simplificar el desarrollo y la integración de hardware.
• Aprender y aplicar conceptos de sistemas embebidos: Adquirir y
aplicar conocimientos en programación de microcontroladores,
manejo de periféricos y diseño de interfaces de usuario.
ALCANCE DEL PROYECTO
Este proyecto abarcará desde el diseño y ensamblaje del hardware
necesario, hasta la implementación del software que permitirá la lectura y
navegación del contenido de un eBook. Los componentes principales
incluyen una placa de desarrollo STM32, una pantalla LCD de 20x4
caracteres, una botonera para la navegación y los circuitos necesarios para
la interconexión de estos elementos.
Se desarrollará un programa en C++ utilizando el entorno de desarrollo de
Mbed OS. Este programa gestionará la lectura del estado de los botones, la
visualización del texto en la pantalla LCD y la navegación entre las diferentes
páginas del eBook. El texto del eBook se almacenará directamente en la
memoria del microcontrolador, eliminando la necesidad de almacenamiento
externo como tarjetas SD.
MARCO TEORICO
Protocolos de Comunicación en Sistemas Embebidos
1. Introducción a los protocolos de comunicación: Los protocolos de
comunicación son conjuntos de reglas que permiten el intercambio de
datos entre dispositivos. Son esenciales para asegurar que la
información se transmita de manera efectiva y sin errores.
2. Descripción y uso del protocolo SPI: El Protocolo de Interfaz
Periférica Serial (SPI) es una interfaz síncrona que se utiliza para la
comunicación rápida entre un dispositivo maestro y uno o varios
dispositivos esclavos. Es común en microcontroladores y sensores, y
se caracteriza por su simplicidad y alta velocidad de transferencia de
datos, que puede alcanzar hasta 50 megahercios (MHz).
3. Comparación con otros protocolos de comunicación (I2C, UART):
o I2C: Es un protocolo de comunicación que utiliza dos líneas (SDA
y SCL) para la transferencia de datos. Es útil cuando se conectan
múltiples dispositivos esclavos a un maestro y se prefiere una
configuración simple.
o UART: Es un protocolo de comunicación asíncrono que no
requiere una señal de reloj compartida. Utiliza líneas de
transmisión (TX) y recepción (RX) para el intercambio de datos
y es conocido por su facilidad de uso y configuración
Manejo de Almacenamiento en Sistemas Embebidos
:
1. Opciones de almacenamiento en sistemas embebidos: Los sistemas
embebidos pueden utilizar diferentes tipos de almacenamiento,
incluyendo memorias volátiles como RAM para datos temporales y
memorias no volátiles como EEPROM o flash para almacenamiento
persistente de firmware y configuraciones 12. Además, las bases de
datos relacionales son una parte integral de muchos sistemas
embebidos para almacenar y organizar grandes volúmenes de datos.
2. Manejo de memoria interna del microcontrolador: La memoria interna
de un microcontrolador se divide generalmente en dos tipos: memoria
de programa (no volátil) y memoria de datos (volátil). La memoria de
programa, como ROM, contiene el conjunto de instrucciones que
gobierna la aplicación, mientras que la memoria de datos, como RAM,
se utiliza para almacenar variables y datos temporales.
3. Uso de tarjetas SD y otros dispositivos de almacenamiento externo:
Las tarjetas SD son una forma popular de almacenamiento no volátil y
portátil, utilizadas en una variedad de dispositivos electrónicos.
Vienen en diferentes tamaños y capacidades, desde unos pocos
megabytes hasta varios gigabytes. Además de las tarjetas SD, existen
otros dispositivos de almacenamiento externo como pendrives USB y
discos duros externos, que se utilizan para expandir la capacidad de
almacenamiento de los sistemas embebidos y facilitar la transferencia
de datos entre dispositivos
RECURSOS
- Tarjeta de Desarrollo: Bluepill con CPU ARM M3 (STM32F103C8T6)
- Tarjeta Transceptor Serial a USB: CP2102, PL2303, CH340G o FT232RL
- Tarjeta ST-Link V2
- Pantalla LCD: 20 caracteres x 4 líneas con interfaz Hitachi HD44780
- Módulo I2C: Interfaz para LCD
- C.I. SN74HC595: Registro de corrimiento octal con entrada serial y salida paralelo
- C.I. SN74HC165: Registro de corrimiento octal con entrada paralela y salida serial
- Lector de memorias SD para conectar con la tarjeta
- Botonera: 8 botones tipo Push Button
- Resistencia SIP: 10K de 9 pines con pin común
- Protoboard
- Multímetro
- Cables Ribbon (Hembra-Macho)
- Conector Dupont: 8 sockets (2), 4 sockets (2), 3 sockets, 2 sockets
- Tira de Pines Macho y Hembra
- Buzzer Piezoeléctrico
- Cautín y soldadura
- Thermofit 1/8" (1m)
- Trimpot: 10K
- Resistencias: 1K y 100 ohm @ 1/8 watt
- Capacitores: 0.1uF (Monolíticos)
- Pinzas de Punta y Corte
- Cutter
DESARROLLO DEL PROYECTO
• Decisión de Utilizar la Botonera y el Código Base
Para el desarrollo del proyecto de un lector de eBooks, se decidió emplear
una botonera para la navegación del contenido del libro. Esta elección se
fundamentó en la simplicidad y familiaridad de la interfaz para el usuario.
Además, se optó por utilizar el código proporcionado por el profesor Antulio,
que ofrecía una estructura inicial robusta y un punto de partida sólido.
• Investigación y Análisis del Código
Se llevó a cabo un estudio detallado del código base para comprender su
funcionamiento y estructura. Asimismo, se realizó una búsqueda exhaustiva
en internet sobre la lectura de eBooks utilizando microcontroladores y
pantallas LCD. A través de esta investigación, se descubrió que la opción
más adecuada para almacenar eBooks era utilizar una memoria SD en lugar
de la memoria interna de la Bluepill STM, debido a la mayor capacidad de
almacenamiento y la facilidad de manejo de archivos.
• Implementación de la Memoria SD
Se investigó cómo conectar una tarjeta SD a la tarjeta Bluepill STM y cómo
leer datos desde ella. Se determinó que el formato de archivo más adecuado
para los eBooks era el .txt, debido a su simplicidad y compatibilidad con el
sistema. Se procedió a escribir el código necesario para implementar esta
funcionalidad, adaptando bibliotecas y ejemplos encontrados en la
comunidad de desarrolladores.
• Formato de Archivo y Sistema de Archivos
Para manejar los archivos en la tarjeta SD, se optó por utilizar el sistema de
archivos FAT (File Allocation Table). FAT es un sistema de archivos
ampliamente soportado y bien documentado, ideal para aplicaciones en
sistemas embebidos debido a su eficiencia y simplicidad. La elección de FAT
permitió aprovechar las bibliotecas existentes que facilitan la
implementación de funciones de lectura y escritura en la tarjeta SD.
• Problemas Encontrados y Cambios en el Alcance del Proyecto
Durante la implementación, se identificó un problema significativo: la
infraestructura y las bibliotecas disponibles estaban principalmente
diseñadas para Arduino y no eran fácilmente adaptables a la Bluepill STM.
Este obstáculo llevó a reconsiderar el alcance del proyecto. Se decidió,
temporalmente, almacenar el eBook en la memoria interna de la Bluepill,
dado que el tamaño del texto no era muy grande (aproximadamente 20 KB).
• Almacenamiento del eBook en la Memoria Interna
Inicialmente, se intentó guardar el eBook como un archivo .h dentro del
proyecto. Sin embargo, surgieron problemas de compatibilidad de
caracteres que impedían el correcto funcionamiento del código. Por lo tanto,
se decidió simplificar los parámetros del proyecto y almacenar el eBook
como una cadena de texto dentro del archivo [Link].
• Desafíos y Soluciones
Incluso después de simplificar el almacenamiento del eBook, se enfrentaron
varios desafíos técnicos. El manejo de la memoria interna y la correcta
visualización del texto en la pantalla LCD resultaron ser tareas complejas.
No obstante, se persistió en la búsqueda de soluciones, realizando múltiples
pruebas y ajustes al código.
• Avance y Resultados
A pesar de los desafíos, se logró un avance significativo. Se pudo visualizar
el contenido del eBook en la pantalla LCD y navegar entre las páginas
utilizando la botonera. Este logro proporcionó una base sólida para futuras
mejoras y expansiones del proyecto.
CONCLUSIONES DEL PROYECTO
El desarrollo del lector de eBook nos brindó una experiencia enriquecedora
en múltiples aspectos, más allá de los aspectos técnicos del proyecto. Este
trabajo nos permitió no solo aplicar nuestros conocimientos en sistemas
embebidos, sino también enfrentarnos a retos que nos llevaron a desarrollar
habilidades de resolución de problemas, adaptabilidad y colaboración.
Desde el inicio, la elección de utilizar la botonera como interfaz de usuario
fue una decisión basada en su simplicidad y familiaridad para los usuarios.
Esta elección se mantuvo constante a lo largo del proyecto y demostró ser
efectiva para la navegación del contenido del eBook. Sin embargo, el
verdadero aprendizaje surgió cuando nos enfrentamos a la implementación
del almacenamiento de los eBooks.
Inicialmente, nuestra intención era utilizar una tarjeta SD para almacenar los
eBooks debido a su capacidad de almacenamiento y facilidad de manejo.
Sin embargo, nos encontramos con dificultades significativas en la
integración de la SD con la Bluepill STM, principalmente porque la
infraestructura y las bibliotecas disponibles estaban más orientadas a la
plataforma Arduino. Este obstáculo nos enseñó la importancia de la
flexibilidad y la capacidad de adaptación en proyectos de ingeniería.
La decisión de cambiar el enfoque y almacenar el eBook en la memoria
interna de la Bluepill fue un punto crítico del proyecto. A pesar de la
reducción en la capacidad de almacenamiento y flexibilidad, este cambio
nos permitió avanzar y completar una versión funcional del proyecto. Este
proceso nos enseñó a manejar las limitaciones de hardware y a encontrar
soluciones prácticas dentro de las restricciones existentes.
Además, trabajar con la memoria interna y lidiar con problemas de
compatibilidad de caracteres al intentar almacenar el eBook como un
archivo .h nos proporcionó una experiencia valiosa en la gestión de datos en
sistemas embebidos. Optar finalmente por almacenar el texto como un
string en el archivo [Link] fue una solución simple pero efectiva, que
destacó la importancia de la simplicidad en el diseño de sistemas.
El proyecto también resaltó la importancia del trabajo en equipo y la
comunicación. Colaborar para solucionar problemas, compartir
descubrimientos y ajustar el enfoque del proyecto fue crucial para nuestro
éxito. A través de este proceso, aprendimos a valorar las contribuciones de
cada miembro del equipo y a desarrollar una mentalidad de cooperación y
apoyo mutuo.
El desarrollo de este lector de eBook nos proporcionó una experiencia
integral que fue más allá de la implementación técnica. Nos enseñó a ser
resilientes frente a los desafíos, a valorar la simplicidad y la adaptabilidad
en el diseño de sistemas, y a trabajar de manera efectiva en equipo. Estas
lecciones serán invaluables en nuestra futura carrera profesional,
preparándonos para enfrentar y superar los desafíos que surjan en el
desarrollo de tecnología y sistemas.
---
BIBLIOGRAFÍA
1. [Link]
0/760/4/[Link]
2. [Link]
3. [Link]
4. [Link]
5. [Link]
6. [Link]
7. [Link]
ANEXOS
CÓDIGO
/*!
######################################################
#####################
** @file
** Archivo : [Link]
** Proyecto : Bluepill_LCD_eBook
** Procesador : STM32F103C8T6
** Plataforma : Blue Pill
** Herramienta : Mbed Keil Studio Cloud
** Compilador : Mbed Online C Compiler
** Versión : Keil Studio Cloud 1.6.16
** Fecha/Hora : 19-06-2024, 14:32, # CodeGen: 0
** Descripción :
** Este proyecto proporciona las rutinas básicas para la implementación
** de un lector de eBooks en una pantalla LCD alfanumérica de 16x2
usando
** el microcontrolador STM32F103C8T6 en la plataforma Blue Pill. El
proyecto
** permite la navegación por las páginas del libro utilizando una botonera
** conectada mediante un registro de desplazamiento 74HC165.
** - Utilizando los GPIO's para controlar el LCD y la botonera.
** - Lectura y despliegue del contenido del eBook almacenado en el
código fuente.
** Componentes : GPIO, Timer, TextLCD.
** Configuraciones : TextLCD.
** Autores :
** Romero Cuevas Alessandro Alberto. GRUPO: 6CV4
** Zuriel Miguel Rodríguez GRUPO: 6CV7
**
** ATEAM Development Group:
** - Antulio Morgado Valle
**
** Versión : Beta
** Revisión :A
** Release :0
** Bugs & Fixes :
** Date : 19/06/2024
**
**
** El permiso se otorga por este medio, sin cargo, a cualquier persona que
** obtenga una copia de este software y los archivos de documentación
asociados
** (el "Software"), para operar en el Software sin restricciones, incluidos,
** entre otros, los derechos de uso, copia, modificación, fusión, publicación,
** distribución, sublicencia y/o venta de copias de el Software, y para
permitir
** que las personas a quienes se suministra el Software lo hagan, sujeto a
las
** siguientes condiciones:
**
** El aviso de copyright anterior y este aviso de permiso se incluirán en todas
** las copias o partes sustanciales del Software.
**
** EL SOFTWARE SE PROPORCIONA "TAL CUAL", SIN GARANTÍA DE
NINGÚN TIPO, EXPRESO
** O IMPLÍCITO, INCLUYENDO PERO NO LIMITADO A LAS GARANTÍAS DE
COMERCIABILIDAD,
** APTITUD PARA UN PROPÓSITO PARTICULAR Y NO INCUMPLIMIENTO. EN
NINGÚN CASO,
** LOS AUTORES O TITULARES DE DERECHOS DE AUTOR SERÁN
RESPONSABLES POR CUALQUIER
** RECLAMACIÓN, DAÑOS U OTRAS RESPONSABILIDADES, YA QUE SEA
RESPONSABLE DE UN
** CONTRATO, CORTE U OTRA MANERA, DERIVADOS DE, FUERA O EN
CONEXIÓN CON
** EL SOFTWARE O EL USO O OTRAS REPARACIONES EN EL SOFTWARE.
**
######################################################
#####################*/
#include "stm32f103c8t6.h"
#include "mbed.h"
#include "I2C.h"
#include "SPI.h"
#include "Serial.h"
#include "TextLCD.h"
//#include "Escalas.h"
#include <stdio.h>
#define ON 0 // Estado para ENCENDIDO
#define OFF 1 // Estado para APAGADO
#define FALSE 0 // Estado FALSO
#define TRUE 1 // Estado VERDADERO
#define HIGH 1 // Estado ALTO
#define LOW 0 // Estado BAJO
#define BUZZ_ON 1 // Estado para Buzzer Encendido
#define BUZZ_OFF 0 // Estado para Buzzer Apagado
#define BUZZ_TYPE 0 // Tipo de Buzzer: 0=Pasivo, 1=Activo
#define KEY_ON 0 // Estado para boton presionado
#define KEY_OFF 1 // Estado para boton sin presionar
#define KEY_HOLD 2 // Estado para boton mantenido
#define KEY_RELEASE 3 // Estado para boton liberado
#define LCD_INTERFACE 2 // Tipo Interfaz del LCD: 0=Normal, 1=I2C,
2=SPI
#define LCD_SIZE LCD20x4 // Tipo de HD44780, LCD20x4, LCD16x4,
LCD16x2,
#define LCD_Filas 4 // Número de Renglones del LCD
#define LCD_Columnas 20 // Número de Caracteres x Renglón del
LCD
#define I2C_ADDRESS 0x4E // Dirección I2C para Interfaz al LCD: 0x7E,
0x4E,
#define OLED_ENABLE 1 // OLED Instalado: 0=None, 1=I2C
#define ESCALA_MUSICAL 1 // 0=diatónica, 1=Dodecafónica,
2=Temperada, 3=Filosófica, 4=Pitagórica
#define TICKER_RATE 1000 // Periodo de interrupción (us)
#define BAUD_RATE 115200 // Velocidad de Transmisión (Bauds)
// Velocidades Permitidas:
// 300, 600, 1200, 2400, 4800, 9600,
// 14400, 19600, 28800, 38400, 57600
// 115200, 230400
// Nota Periodo (seg) Frecuencia (Hz)
#define DO2 0.01528898864105 // 65.40655 Hz (Escala Diatónica)
#define RE2 0.01362097193807 // 73.4162 Hz
#define MI2 0.01213569404944 // 82.40155 Hz
#define FA2 0.01145383531676 // 87.307 Hz
#define SOL2 0.01020424302629 // 97.99845 Hz
#define LA2 0.009 // 110 Hz
#define SI2 0.00800909403534 // 123.4706 Hz
#define DO3 0.00764449432052 // 130.8131 Hz
#define RE3 0.00681048596904 // 146.8324 Hz
#define MI3 0.00606784702472 // 164.8031 Hz
#define FA3 0.00572691765838 // 174.614 Hz
#define SOL3 0.00510212151315 // 195.9969 Hz
#define LA3 0.0045 // 220 Hz
#define SI3 0.00404954701767 // 246.9412 Hz
#define DO4 0.00382224716026 // 261.6262 Hz
#define RE4 0.00340524298452 // 293.6648 Hz
#define MI4 0.00303392351236 // 329.6062 Hz
#define FA4 0.00286345882919 // 349.228 Hz
#define SOL4 0.00255106075657 // 391.9938 Hz
#define LA4 0.00227 // 440 Hz
#define SI4 0.00202477350884 // 493.8824 Hz
#define DO5 0.00191112358013 // 523.2524 Hz
#define DOs5 0.00180386633495 // 554.3648 Hz
#define RE5 0.00170262149226 // 587.3296 Hz
#define MI5 0.00151696175618 // 659.2124 Hz
#define FA5 0.00143172941459 // 698.456 Hz
#define SOL5 0.00127553037829 // 783.9876 Hz
#define LA5 0.001136 // 880 Hz
#define SI5 0.00101238675442 // 987.7648 Hz
#define DO6 0.00095556179007 // 1046.5048 Hz
#define RE6 0.00085131074613 // 1174.6592 Hz
#define MI6 0.00075848087809 // 1318.4248 Hz
#define FA6 0.0007158647073 // 1396.912 Hz
#define SOL6 0.00063776518914 // 1567.9752 Hz
#define LA6 0.0005681 // 1760 Hz
#define SI6 0.00050619337721 // 1975.5296 Hz
#define DO7 0.00047778089503 // 2093.0096 Hz
#define RE7 0.00042565537306 // 2349.3184 Hz
#define MI7 0.00037924043905 // 2636.8496 Hz
#define FA7 0.00035793235365 // 2793.824 H
#define SOL7 0.00031888259457 // 3135.9504 Hz
#define LA7 0.00028409 // 3520 Hz
#define SI7 0.0002530966886 // 3951.0592 Hz
#define DO8 0.00023889044752 // 4186.0192 Hz
// Definiciones y configuraciones
#define NEXT_BUTTON 0
#define PREV_BUTTON 1
// Pines para 74HC165 (ajusta según tu configuración)
#define DATA_PIN D2
#define CLOCK_PIN D3
#define LOAD_PIN D4
/*
+-------------------------------------------------------------------------------
| Configuración de Puertos
+-------------------------------------------------------------------------------
*/
Ticker TimerInt; // Inicializa la Interrupción por Timer
DigitalOut Led_monitor(LED1); // Inicializa el LED Monitor (Interno)
PwmOut buzzer(PB_0); // Inicializa el PWM para el Buzzer
/*
** -------------------------------------------------------------------
** Inicialización de los Pines de Funciones Especiales.
** -------------------------------------------------------------------
*/
/*************************************************
* Host PC Communication channels
**************************************************/
//Serial terminal(USBTX, USBRX); // Inicializa la Comunicación Serial a la
PC
Serial terminal(PA_2, PA_3); // Inicializa la Comunicación Serial a la PC
#if LCD_INTERFACE == 2
SPI spi_lcd(PA_7,PA_6,PA_5,PA_4); // SPI_MOSI, SPI_MISO, SPI_SCK,
SPI_CS
DigitalOut SSel(PA_4); // Inicializa el Pin de Seleccion de Esclavo SPI
#endif
#if LCD_INTERFACE == 2
TextLCD_SPI lcd(&spi_lcd, PA_4, TextLCD::LCD_SIZE, TextLCD::HD44780);//
SPI bus, SN74595 expander, CS pin, LCD Type
#endif
/* END Port Declarations */
/*
+-------------------------------------------------------------------------------
| Variables Globales de Usuario
+-------------------------------------------------------------------------------
*/
uint8_t secuencias[]= // Secuencia de Inicialización del LCD
{
0x38, 0x3C, 0x38, 0x3C, 0x38, 0x3C, 0x28, 0x2C, // 8 33 32
0x08, 0x0C, 0x88, 0x88, 0x28, 0x2C, 0x08, 0x0C, // 16 08 20
0x08, 0x0C, 0x48, 0x4C, 0x08, 0x0C, 0x18, 0x1C, // 24 04 01
0x08, 0x0C, 0x28, 0x2C, 0x08, 0x0C, 0xF8, 0xFC, // 32 02 0F
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // 40 00 00
// A partir de aquí se puede codificar un mensaje !!!
};
uint16_t No_Secuencias=sizeof(secuencias); // Número de secuencias a
desplegar
uint8_t buffer_temp=0; // Variable temporal (para guardar datos
uint16_t Rate=TICKER_RATE/2; // Velocidad de TimerInt (500us = 0.5ms)
uint16_t counter=250; // Cuenta inicial de 250us
uint16_t heartbeat; // Contador de Overrunig
uint8_t botones; // Codificación del valor de los botones
int16_t i=0; // Índice
bool flag; // Bandera
/* END global variables */
// Función para leer el estado de los botones del 74HC165
int readButtons() {
DigitalOut clockPin(CLOCK_PIN);
DigitalOut loadPin(LOAD_PIN);
DigitalIn dataPin(DATA_PIN);
loadPin = LOW;
wait_us(1); // espera mínima para cargar los valores
loadPin = HIGH;
int buttons = 0;
for (int i = 0; i < 8; i++) {
clockPin = LOW;
wait_us(1); // espera mínima para cambiar el reloj
buttons |= ([Link]() << i);
clockPin = HIGH;
}
if (buttons & (1 << NEXT_BUTTON)) {
return NEXT_BUTTON;
} else if (buttons & (1 << PREV_BUTTON)) {
return PREV_BUTTON;
}
return -1; // Ningún botón presionado
}
// Contenido del eBook (ejemplo)
const char ebook_text[] = "This is the first line.\nThis is the second
line.\nThis is the third line.\n";
// Inicialización del LCD
void setup() {
[Link]();
[Link](0, 0);
[Link]("eBook Reader");
}
int main() {
setup();
char buffer[80]; // Buffer para una línea de texto del eBook
const char *ebook_ptr = ebook_text;
int currentPage = 0;
while (true) {
// Posiciona el puntero en la página actual
const char *page_ptr = ebook_ptr + currentPage * sizeof(buffer) * 4;
// Lee y muestra la página actual
[Link]();
for (int i = 0; i < LCD_Filas; i++) { // Ajustado para 4 líneas
if (scanf(page_ptr, "%79[^\n]\n", buffer) != 1) {
break; // No hay más líneas para leer
}
[Link](0, i);
[Link]("%s", buffer);
page_ptr += strlen(buffer) + 1; // Avanza a la siguiente línea
}
// Lee los botones para navegación
int buttonState = readButtons();
if (buttonState == NEXT_BUTTON) {
currentPage++;
} else if (buttonState == PREV_BUTTON) {
currentPage = max(0, currentPage - 1);
}
wait_ms(500); // Espera un momento para evitar rebotes en los botones
}
}
/* END functions */
/* END routines */
/* END program */