Tutorial Codespaces paso a paso - Hola Mundo Python + C

## Tutorial Codespaces paso a paso - Hola Mundo Python + C

### PASO 1: Crea tu repo de prácticas

1. Ve a github.com/new
2. Nombre: `mis-primeros-codespaces`
3. Marca `Add a README file`
4. Create repository

### PASO 2: Crea tu Codespace

1. Dentro de tu repo, dale clic al botón verde `<> Code`
2. Pestaña `Codespaces`
3. Clic en `Create codespace on main`

Espera 45 segundos. Se te abrirá VS Code en el navegador. Ya estás dentro de una máquina Linux.

Verifica que estás dentro: abre la terminal con `Ctrl + ñ` o `Ctrl + `` ` y escribe:
```bash
pwd
ls -la
```

### PASO 3: Hola Mundo en Python

Python ya viene instalado.

1. En el explorador de la izquierda, clic en `New File` -> `main.py`
2. Pega esto:

```python
# main.py
print("Hola mundo desde Codespaces!")
print("Python funciona!")

nombre = input("¿Cómo te llamas? ")
print(f"Hola, {nombre}!")
```

3. En la terminal, ejecútalo:
```bash
python main.py
```
O también:
```bash
python3 main.py
```

Listo. Acabas de ejecutar Python en la nube sin instalar nada en tu PC.

### PASO 4: Hola Mundo en C

Aquí es donde Codespaces brilla, porque C necesita compilador.

1. En la terminal, verifica si tienes compilador:
```bash
gcc --version
```
Si te dice `command not found`, instálalo:
```bash
sudo apt update && sudo apt install build-essential -y
```

2. Crea un archivo nuevo: `hola.c`

```c
// hola.c
#include <stdio.h>

int main() {
    printf("Hola mundo desde C en Codespaces!\n");
    
    int edad;
    printf("¿Cuántos años tienes? ");
    scanf("%d", &edad);
    printf("Tienes %d años. ¡C en la nube funciona!\n", edad);
    
    return 0;
}
```

3. Compila y ejecuta. En C no es directo como Python, son 2 pasos:

```bash
# Compilar
gcc hola.c -o hola

# Ejecutar
./hola
```

Si quieres ver los archivos:
```bash
ls
# Verás: hola  hola.c  main.py
```

**Explicación:** `gcc` es el compilador. Convierte tu `hola.c` (texto) en un ejecutable `hola` (programa que la máquina entiende).

### PASO 5: Hazlo pro - El archivo que te ahorra todo

Para no tener que instalar `gcc` cada vez, vamos a crear la configuración automática.

Crea esta carpeta y archivo: `.devcontainer/devcontainer.json`

1. Clic derecho -> `New Folder` -> `.devcontainer`
2. Dentro, `New File` -> `devcontainer.json`
3. Pega esto:

```json
{
  "name": "Python + C",
  "image": "mcr.microsoft.com/devcontainers/base:ubuntu",
  "features": {
    "ghcr.io/devcontainers/features/python:1": {
      "version": "3.11"
    }
  },
  "customizations": {
    "vscode": {
      "extensions": [
        "ms-python.python",
        "ms-vscode.cpptools"
      ]
    }
  },
  "postCreateCommand": "sudo apt update && sudo apt install -y build-essential gdb",
  "remoteUser": "vscode"
}
```

Que hace esto:
- Instala Python 3.11 automáticamente
- Instala `build-essential` (gcc, g++)
- Instala extensiones de Python y C++ en VS Code

Ahora haz commit para guardarlo:
```bash
git add .
git commit -m "Agrego mi entorno Python + C"
git push
```

La próxima vez que crees un Codespace en este repo, todo vendrá instalado solo.

### PASO 6: Prueba con más lenguajes (misma lógica)

Una vez que entiendes el patrón, es igual para todo:

**Para JavaScript:**
```bash
echo 'console.log("Hola JS")' > hola.js
node hola.js
```

**Para Java:**
```bash
echo 'public class Hola { public static void main(String[] args){ System.out.println("Hola Java"); } }' > Hola.java
javac Hola.java
java Hola
```

### PASO 7: Cerrar y no gastar horas

1. Ve a github.com/codespaces
2. Verás tu Codespace activo. Dale a los 3 puntitos `...` -> `Stop codespace`

Tu código ya quedó guardado en GitHub porque hiciste `git push`. Puedes borrar el Codespace sin miedo, lo vuelves a crear cuando quieras.

---

**Reto para ti:**

Crea un archivo `calculadora.py` y un `calculadora.c` que sumen dos números que pida el usuario. Si lo haces, ya dominas la base de Codespaces.

¿Quieres que te pase el siguiente paso? Te puedo armar el template para C++ , Go y Rust en el mismo repo para que tengas un Codespace multi-lenguaje listo. 

Tutorial: Obtener Credenciales y Configurar Adafruit IO

---

Tutorial: Obtener Credenciales y Configurar Adafruit IO

Aquí tienes un tutorial paso a paso para navegar en la plataforma de Adafruit IO y extraer exactamente los 4 datos necesarios (Username, AIO Key, Feed y Dashboard) para configurar tu ESP32. 

Paso 1: Crear una Cuenta e Iniciar Sesión

1. Entra al sitio oficial: adafruit.com.
2. Haz clic en Sign Up (si no tienes cuenta) o en Sign In (si ya estás registrado).
3. Llena los datos básicos. La cuenta gratuita (Free Plan) es perfectamente funcional para este proyecto.

---

Paso 2: Obtener tu Username y AIO Key

Estos datos equivalen a tu "usuario y contraseña" para que la ESP32 pueda iniciar sesión en el servidor MQTT de Adafruit.

1. Una vez dentro de tu panel principal, dirige tu mirada a la barra superior derecha.
2. Haz clic en el botón amarillo con un icono de llave que dice "My Key".
3. Se abrirá una ventana emergente (pop-up) con dos campos de texto:
   • Username: Este es tu nombre de usuario único.
   • Active Key: Es una cadena larga de letras y números generada aleatoriamente.
4. Haz clic en el botón Copy al lado de cada uno para guardarlos en tu bloc de notas. ¡Mantén tu Active Key en secreto!

---

Paso 3: Crear y obtener el Feed (Canal del Sensor)

El Feed es la base de datos o el "buzón" donde tu ESP32 va a depositar las lecturas del sensor.

1. En el menú superior izquierdo de la pantalla, haz clic en la opción Feeds.
2. Haz clic en el botón azul "+ New Feed".
3. En la casilla Name, escribe el nombre para tu sensor (por ejemplo: Temperatura).
4. Haz clic en Create.
5. Ahora verás tu feed en la lista. Presta atención a la columna que dice Key:
   • Adafruit convierte automáticamente el nombre a minúsculas y reemplaza los espacios por guiones (ejemplo: si lo llamaste Sensor Uno, su clave será sensor-uno).
   • Este valor en minúsculas es tu Feed Key, el cual usarás en el código de Thonny para completar el tópico de publicación: tu_username/feeds/tu-feed-key.

---

Paso 4: Crear el Dashboard y la Gráfica

El Dashboard es la interfaz visual (la pantalla) donde acomodarás los gráficos y botones para interactuar desde la computadora o el celular.

1. En el menú superior, haz clic en Dashboards.
2. Haz clic en el botón azul "+ New Dashboard".
3. Ponle un nombre descriptivo (por ejemplo: Control ESP32) y haz clic en Create.
4. Haz clic sobre el nombre del Dashboard que acabas de crear para entrar en él. Verás un lienzo completamente negro o vacío.
5. Haz clic en el botón "+" azul (Create New Block) en la barra de herramientas superior derecha.
6. Se abrirá un catálogo de componentes visuales. Selecciona Line Chart (Gráfico de líneas).
7. Aparecerá una lista con tus feeds. Marca la casilla de verificación al lado del feed que creaste en el Paso 3 (por ejemplo: Temperatura) y haz clic en Next Step.
8. En esta última ventana puedes personalizar el gráfico: ponerle un título, definir los valores mínimos/máximos del eje Y, o cambiar el color de la línea.
9. Haz clic en Create Block y ¡listo! Tu gráfica aparecerá en pantalla lista para recibir los datos de tu placa.

---

Resumen de lo que debes pegar en Thonny:

Al terminar este tutorial, deberías tener tus cuatro parámetros listos en tu script de MicroPython de la siguiente manera:

python

ADAFRUIT_USERNAME = "El_Username_del_Paso_2"
ADAFRUIT_AIO_KEY  = "La_Active_Key_del_Paso_2"
FEED_KEY          = "el-nombre-en-minusculas-del-Paso_3"

# Tu dirección final de publicación MQTT será:
MQTT_TOPIC = f"{ADAFRUIT_USERNAME}/feeds/{FEED_KEY}"

Usa el código con precaución.

¿Lograste visualizar la ventana emergente de "My Key" correctamente en la página web, o necesitas que preparemos el código definitivo para enlazar la rampa y el triángulo que mencionaste antes a dos feeds distintos?

tutorial paso a paso para configurar tu graficador en Adafruit IO

 

Para visualizar los datos que estás enviando desde tu simulación en Bash o desde tu ESP32, necesitas crear un Dashboard (tablero de control) y añadirle un bloque de gráfica de líneas (Line Chart).

A continuación, tienes el tutorial paso a paso para configurar tu graficador en Adafruit IO:

---

Paso 1: Crear o verificar tu Feed

Antes de hacer la gráfica, necesitas un Feed (el canal donde se guardan tus datos). Si ya creaste uno con tu script (por ejemplo, mi-sensor), puedes saltar al Paso 2. Si no:

1. Inicia sesión en Adafruit IO.
2. En el menú superior, haz clic en Feeds.
3. Haz clic en el botón New Feed (Nuevo Feed).
4. Asigna un nombre (por ejemplo, mi-sensor) y haz clic en Create.

---

Paso 2: Crear un nuevo Dashboard

1. En el menú superior de la página, haz clic en Dashboards (Tableros).
2. Haz clic en el botón New Dashboard (Nuevo Tablero).
3. En la ventana emergente, escribe un nombre para identificarlo (ej. Control de Sensores) y una descripción opcional.
4. Haz clic en Create. Verás tu nuevo dashboard en la lista; haz clic sobre su nombre para abrirlo.

---

Paso 3: Añadir el bloque de gráfica (Line Chart)

1. Con tu dashboard vacío abierto, haz clic en el botón "+" (Create a new block) ubicado en la esquina superior derecha.
2. Se abrirá una lista con diferentes tipos de bloques visuales (botones, barras, mapas). Busca y selecciona el bloque llamado Line Chart (Gráfica de líneas).

---

Paso 4: Vincular la gráfica con tu Feed

1. Al seleccionar Line Chart, aparecerá una lista con todos tus feeds disponibles.
2. Busca tu feed (ej. mi-sensor) y marca la casilla que está a su lado.
   • Nota: Si estás enviando datos de varios sensores, puedes marcar más de una casilla para graficar múltiples líneas en el mismo recuadro.
3. Haz clic en el botón Next step (Siguiente paso) en la parte inferior.

---

Paso 5: Personalizar la gráfica

En esta última pantalla puedes ajustar los detalles visuales de tu graficador:

• Block Title: Dale un título a la gráfica (ej. Historial del Sensor).
• X-Axis Label / Y-Axis Label: Ponle etiquetas a los ejes si lo deseas (ej. Tiempo en el eje X, y Porcentaje % en el eje Y).
• Show History: Elige cuánto tiempo hacia atrás quieres que muestre la gráfica (puedes elegir que muestre los datos de la última hora, las últimas 24 horas, etc.).
• Cuando termines de configurarlo a tu gusto, haz clic en Create block (Crear bloque).

---

Paso 6: Organizar tu tablero

1. Tu gráfica aparecerá inmediatamente en el dashboard.
2. Si quieres cambiarla de tamaño o moverla de lugar, haz clic en el icono de engranaje verde de la esquina superior derecha y selecciona Edit Layout (Editar diseño).
3. Arrastra los bordes del bloque para hacerlo tan grande como quieras y haz clic en Save Layout (Guardar diseño).

¡Listo! En cuanto ejecutes tu script de Bash o tu código de ESP32, verás cómo la línea de la gráfica empieza a actualizarse automáticamente en tiempo real cada vez que recibe un nuevo valor.

Para complementar tu tablero, dime:

• ¿Te gustaría aprender a agregar un bloque indicador (como un indicador de aguja o "Gauge") para ver el valor actual del sensor?
• ¿Quieres configurar una alerta por correo electrónico en Adafruit IO para cuando el sensor llegue a 100?