# SiPi Electron

**SiPi Electron** es la rama de [SiPi](../) para crear cosas electronicas:
robots, electrodomesticos inteligentes, sensores, LEDs, motores. Esta
escrita en **C puro** (sin dependencias externas) para poder correr tanto
en la computadora (modo simulado, para aprender y probar sin placa) como,
mas adelante, directamente en microcontroladores chicos (Arduino/AVR,
ESP32, etc.), donde Python no entra pero C sí.

La idea: que crear algo electronico con SiPi sea tan facil como escribir
un programa de escritorio, y que este sea el lenguaje elegido por
principiantes y makers para ese mundo.

## Por que C y no el interprete Python de SiPi

- El SiPi "grande" (Python) es ideal para escritorio, apps y IA, pero no
  entra en un microcontrolador de unos pocos KB de RAM.
- SiPi Electron es un interprete **chico, portable y sin dependencias**:
  compila con cualquier `cc` de C11 y, a futuro, con `avr-gcc` / `xtensa-gcc`
  para correr en la placa misma.
- La sintaxis es el mismo SiPi en español (`si`, `mientras`, `repetir N
  veces`, `funcion`, `decir`, interpolacion `{variable}`), asi que aprender
  uno ayuda con el otro.

## IDE grafica (recomendado)

SiPi Electron incluye una interfaz de escritorio propia, pensada como
una IDE de verdad y no una ventanita basica: editor de codigo con
resaltado de sintaxis, una **placa virtual** que anima el estado de
cada pin en vivo mientras el programa corre, y una consola con la
salida real del interprete.

```bash
./sipi-electron-ide
```

(requiere Python 3 con `tkinter`; usa `customtkinter` si esta
instalado, para un look mas moderno, pero funciona igual sin el). La
IDE compila el motor en C automaticamente la primera vez que apretas
**Ejecutar** — no hace falta correr `make` a mano.

Colores de marca propios de esta IDE (para que nunca se confundan con
los del editor principal de SiPi): acento cobre/ambar `#fab387` en vez
del violeta `#8839ef` del logo de SiPi grande.

## Compilar y probar por linea de comandos (modo simulado)

```bash
make
./sipi-electron examples/parpadeo_led.spe
```

En modo simulado no hace falta ninguna placa: la capa de hardware (HAL)
imprime en pantalla lo que haria en un pin real (`hal_host.c`). Así se
puede aprender y probar la logica del programa desde el primer minuto,
y despues llevarlo a una placa real sin cambiar una linea del programa.

## Ejemplo minimo

```sipi
programa "Parpadeo de LED"

variable pin_led = 13
pin_modo(pin_led, 1)

repetir 5 veces
    pin_escribir(pin_led, 1)
    esperar_ms(300)
    pin_escribir(pin_led, 0)
    esperar_ms(300)
fin

decir "Listo!"
```

## Comandos de electronica disponibles

| Comando | Que hace |
|---|---|
| `pin_modo(pin, modo)` | Configura un pin (`0` entrada, `1` salida) |
| `pin_escribir(pin, valor)` | Escribe digital (`0` o `1`) en un pin |
| `pin_leer(pin) -> var` | Lee un pin digital |
| `analogico_leer(pin) -> var` | Lee un pin analogico (0-1023) |
| `pwm_escribir(pin, valor)` | Escribe PWM (0-255), para motores/brillo |
| `esperar_ms(ms)` | Pausa en milisegundos |
| `esperar_segundos(s)` | Pausa en segundos |

Mas utilidades: `raiz_cuadrada(x)`, `redondear(x)`, `absoluto(x)`,
`azar_entre(a, b)`.

## Sintaxis del lenguaje soportada en esta primera version

`programa`, `decir` (con interpolacion `{variable}`), `variable`, `const`,
`si` / `sino` / `fin`, `mientras`, `repetir N veces`, `funcion` /
`devolver`, `llamar` / `llamar_valor ... -> variable`, `romper`,
`continuar`, operadores (`+ - * / %`, comparaciones, `y` / `o` / `no`).

A diferencia del SiPi grande, en Electron **todo bloque se cierra con
`fin`** (todavia no soporta indentacion como unico cierre) — esto
simplifica muchisimo el parser en C y lo hace mas facil de portar a un
microcontrolador con pocos recursos.

## Arquitectura interna

```
src/
  sipi_electron.h   tipos compartidos (tokens, AST, valores, HAL)
  lexer.c           texto -> tokens
  parser.c          tokens -> AST (descenso recursivo)
  interpreter.c      recorre el AST y lo ejecuta
  hal_host.c        capa de hardware simulada (para la computadora)
  main.c            punto de entrada / CLI (salida sin buffer, para que
                     una interfaz grafica la pueda leer en vivo)
ide/
  editor_sipi_electron.py   IDE de escritorio (Python + tkinter/customtkinter)
sipi-electron-ide           lanzador rapido de la IDE
```

La IDE nunca reimplementa el lenguaje: guarda el codigo del editor a un
`.spe` y corre el binario real de `src/` como subproceso, leyendo su
salida linea por linea para animar la placa virtual — el motor en C
sigue siendo la unica fuente de verdad de como se ejecuta un programa.

Para correr sobre una placa real, se agrega un `hal_avr.c` o
`hal_esp32.c` que implemente las mismas seis funciones de `hal.h`
(`hal_pin_modo`, `hal_pin_escribir`, `hal_pin_leer`,
`hal_analogico_leer`, `hal_pwm_escribir`, `hal_esperar_ms`) contra los
registros / SDK reales — el lexer, el parser y el interprete no cambian
nada.

## Roadmap corto

- [ ] `hal_avr.c` para correr en Arduino Uno/Nano (ATmega328P) sin Arduino IDE
- [ ] `hal_esp32.c` usando ESP-IDF, con WiFi/Bluetooth opcional
- [ ] Listas y diccionarios basicos (sensores multiples, arreglos de LEDs)
- [ ] Interrupciones (`al_detectar_pin`) para botones y sensores rapidos
- [ ] Integracion con el CLI y el IDE visual de SiPi (mismo icono, misma marca)
- [ ] Ejemplos: semaforo, robot seguidor de linea, riego automatico
