Hoy colocas el mapa: el curso te deja con una Raspberry Pi encendida de forma limpia, un sistema que reconoces, una terminal que obedeces, y más adelante un pin de tres con tres voltios que enciende una luz, lee un botón y avisa sin salir a internet. No confundas este camino con el catálogo de placas, con el manual de comandos ni con la balda de proyectos. La referencia es una Pi con header de cuarenta pines y Linux; el Pico no entra.

Cuando el índice esté completo vas a poder hacer, en este orden y no antes, ocho cosas que se notan. Preparar una tarjeta y arrancar. Saber qué sistema es el de este curso y cuál no. Apagar sin romper el disco, eso es la lección 9 y aún no está escrita. Entrar con tu usuario y entender sudo. Escribir un programa corto en el Python que ya trae el sistema. Encender un LED en el GPIO 17, que es el pin físico 11, con resistencia y a 3,3 V. Leer un pulsador. Dejar que un sensor decida un aviso en la propia placa, sin depender de una web. Esta lección no te pide la placa. Te pide que no adelantes el último paso al primero.

El curso no es un talento ni un título. Es una cola de gestos. Cada gesto tiene un porqué y un sitio donde se rompe si lo copias de un tutorial viejo. El tutorial viejo suele decir «usuario pi», «pin 17» sin decir si cuenta el agujero o el número BCM, y «5 V en el GPIO para que se vea mejor». Las tres frases están mal en esta casa. El usuario lo pones tú al grabar. El 17 del ejemplo es BCM y vive en el físico 11. El GPIO no acepta 5 V.

Cuatro baldas que no se pisan

Hardware es el catálogo. Ahí vive qué placa es, cuánta corriente pide la fuente y el mapa largo de modelos. Si una ficha de placa todavía no está, no la inventes desde el curso. Software es la referencia densa: el comando, la librería, el error raro, la ancla a la que este curso señala cuando el gesto ya se entiende y quieres el detalle de la herramienta. Proyectos es la balda de montajes ya armados, muchos, en niveles. Enseñanza, esta página, es el camino. Si un proyecto da el cable por sabido, vuelves a la lección del cable. No al revés.

Por eso esta página no repite el manual. La lección 3 explica qué le pasa a la tarjeta y al primer arranque, y solo ella enlaza la referencia de imagen y arranque. La lección 36, cuando se escriba, será la de SSH. No está en esta pasada y no se resume aquí con un procedimiento falso. La lección 9 será apagar. La 21 será guardar un CSV. Nombrarlas sirve para que el mapa no mienta. Rellenarlas con cuatro frases serviría para aprobar un índice y para suspender a quien llegue creyendo que ya lo sabe.

La máquina de referencia

La referencia es una Raspberry Pi con header de cuarenta pines y un sistema Linux en la tarjeta. Valen, para el gesto de estas primeras lecciones, una Pi 4, una Pi 5, una Pi 400 o una Zero 2 W, porque el header que vas a mirar se numera igual: físico 1 arriba, 3,3 V; físico 2 a su lado, 5 V; físico 11, GPIO 17. No valen como «la misma placa» un Pico ni un Pico W. Esos son microcontroladores. No arrancan este Linux, no tienen esta tarjeta de sistema y sí tienen patillas de conversión analógica. En el header de la Pi con Linux no hay ninguna entrada analógica. Si un esquema te pide «el pin A0», es de otra familia. No lo traduzcas a un GPIO a ojo.

Linux cambia el modo de pensar si vienes de una placa de un solo programa. Aquí hay usuarios, archivos, procesos y un disco que se estropea si cortas la corriente a mitad de una escritura. El GPIO es una puerta de al lado, no el centro. Puedes usar la Pi semanas sin tocar un pin. No puedes usar el pin con sentido si no sabes que es de 3,3 V y que el número que escribes en el programa no es el que cuentas con el dedo en el borde.

Cómo está hecha una lección

Arriba va el Maestro. Es un guion para oír, no un resumen decorativo. El botón Escuchar usa la voz de la casa si el cascarón definió LesVencimosMaestro.decir. Si no existe, el navegador habla en español de España con su propia síntesis. Da igual el motor: el texto es el del recuadro, el mismo que puedes leer en silencio.

Debajo está el mecanismo, escrito para que puedas explicar el fallo sin mirar. Cuando hay circuito, hay un dibujo en SVG hecho para esta página. No es una foto de un póster ajeno ni un archivo incrustado de las fuentes. En la lección 4 y en el pinout de esta misma página el dibujo es el header, y se puede tocar.

Cada lección trae una práctica que se hace aquí, sin la Pi. Puede ser ordenar pasos, elegir un pin en el dibujo o leer un error y decir qué significa. Si la fallas, el texto de arriba todavía no está asentado. No pases de largo: la Pi no va a ser más clara que este recuadro. Después hay un ejercicio que sí es en la máquina, o en papel si aún no la tienes. Y hay preguntas con la respuesta tapada. No son un examen. Son la prueba de que no te llevas solo el título.

Qué cierran de verdad las lecciones 1 a 8

Al acabar la 8 tienes que poder decir, sin notas, esto. Una Pi no es un Pico. La imagen de este curso, a 3 de octubre de 2026, es Raspberry Pi OS basado en Debian 13 Trixie. El primer arranque exige usuario y contraseña puestos por ti. El header trabaja a 3,3 V en los GPIO. Los pines de 5 V no son señal. Los físicos 27 y 28 no se usan para un LED. Sabes abrir una terminal y leer un «command not found» como un nombre mal escrito, no como una placa muerta. No sabes todavía apagar con el comando justo: eso es la 9. No sabes SSH: eso será la 36. No enciendes el LED: eso llega cuando el pin y el circuito tengan lección propia.

Si tu prisa es «ver una luz hoy», este curso te va a parecer lento. La luz de un tutorial de diez minutos suele ser un GPIO a pelo, un número de pin equivocado y la corriente cortada al terminar. Aquí la luz espera a que el arranque, la tensión y el nombre del pin estén dichos. Es más largo el primer día. Es más corto el día en que algo no enciende, porque ya sabes qué mirar.

Lo que esta lección no va a hacer por ti

No elige el modelo de placa por ti más allá de la familia. Si dudas entre una Pi 4 y una Pi 5, el catálogo Hardware es el sitio de las diferencias de fuente, de conector y de nombre de modelo. El header de señales, para estas lecciones, se enseña igual: 3,3 V, físico 11 igual a GPIO 17, 27 y 28 reservados. No instala el sistema en esta página: la página se abre en el navegador, incluso desde el disco, y la tarjeta se graba en otro ordenador. No abre un puerto ni una cuenta. No hay red obligatoria para leer esto.

Aviso eléctrico, de toda la casa. Los GPIO de este header son de 3,3 V. Meter 5 V en un GPIO lo rompe. Los físicos 2 y 4 son 5 V de alimentación, no de lógica. Los físicos 27 y 28 están reservados. El físico 11 es el GPIO 17. No hay ADC en este header: el Pico sí tiene, y por eso un esquema de Pico no se copia aquí. Nada del curso se conecta a la red de 230 V. Si un montaje «solo es un relé de la lámpara», no es un montaje de esta página.

Cómo usar el índice de abajo y el de arriba

El índice nombra las cuarenta y tres lecciones para que las anclas existan y el orden no se reescriba luego con otros números. Las lecciones 9 a 43 no tienen cuerpo en esta pasada. Si pulsas una y solo ves el nombre en el índice, no está escrita: no hay un texto corto haciéndose pasar por lección. Las ocho primeras sí se leen enteras. El pinout interactivo, con id pinout-ensenanza, está en esta misma página, antes de las lecciones, porque vas a necesitarlo en la 4 y porque un mapa que solo vive en un póster no se puede preguntar.

Cuando más adelante una ficha de proyectos nombre leccion-25 o leccion-40, ese número es el de este índice, no un alias. No inventes otro. Si la lección aún no tiene texto, el montaje espera. Adelantar el proyecto sin la lección es exactamente el fallo que este mapa quiere impedir.

Una tarde concreta, para que el mapa no se quede en abstracto

Imagina que la placa llega hoy y alguien de casa quiere «probarla en diez minutos». El recorrido que esta lección defiende es otro. Primero se mira el header sin cablear: se localizan el físico 1, el físico 2 y el físico 11, y se dice en voz alta qué es cada uno. Eso es la lección 4, no un adorno. Después se graba la tarjeta en el otro ordenador, con usuario y contraseña, y se arranca con pantalla. Eso es la 3, y el detalle de la herramienta vive en la referencia de arranque, enlazada solo desde esa lección. Si el escritorio aparece, se reconoce el sistema de la lección 5 y se abre la terminal de la lección 8. Ahí se acaba el primer tramo. El LED se queda en la caja.

El atajo que no se acepta es saltar a un esquema encontrado fuera, con el pin «17» contado desde el borde y el ánodo del LED al 5 V. Ese atajo enciende a veces, quema otras, y no enseña nada que puedas repetir. Si ya lo hiciste en otra placa, no lo traigas como costumbre. Aquí el número se dice dos veces, físico y BCM, y la tensión se dice antes que el programa.

Ejercicio en la Pi

En un papel, escribe las ocho cosas que cierran las lecciones 1 a 8 y, al lado, tres cosas que este curso todavía no te deja hacer (apagar con el comando de la lección 9, entrar por SSH, encender el LED). Si una de las tres te tienta más que el mapa, anota por qué y no la adelantes.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Una Raspberry Pi de este curso es un ordenador pequeño que arranca Linux desde una tarjeta. Tiene procesos, usuarios y un disco que hay que apagar bien. El Pico es otra cosa, un microcontrolador con entradas analógicas que el header de cuarenta pines de la Pi no tiene, y hoy se separan las dos máquinas.

Un ordenador, no un chip con un solo programa

En un ordenador de mesa hay un procesador, memoria, un disco y un sistema operativo que reparte el tiempo entre programas. Una Raspberry Pi de las que usa este curso está hecha de esa misma idea, metida en una placa del tamaño de una tarjeta. El procesador y la memoria van soldados. El disco, en la práctica de estas lecciones, es la tarjeta microSD: ahí está el sistema, tus archivos y lo que un programa deje escrito. Si cortas la corriente mientras esa tarjeta se está escribiendo, no «se apaga el programa». Se puede romper el sistema de archivos. Por eso apagar tiene lección propia, la 9, y no se despacha con un tirón de cable en la lección 2.

El sistema reparte. Puede haber un escritorio, una terminal y, más adelante, un script de GPIO, los tres vivos. Si uno se queda esperando, los otros no se mueren por definición. Eso es lo contrario de un microcontrolador pequeño, donde a menudo el único programa es el que grabaste y una espera larga deja sordo al chip. Aquí la espera de un programa no apaga el escritorio. Tampoco convierte un pin en analógico. Son planos distintos: el de los procesos y el de los voltios.

La placa añade lo que el chip suelto no te deja tocar con los dedos: conectores USB, HDMI o el equivalente del modelo, Ethernet en muchos, Wi-Fi en muchos, y el header de cuarenta pines. Ese header es la parte que parece «de electrónica». Es real, y es una parte. Puedes aprender las lecciones 1 a 8 sin clavar un solo cable en él. No puedes aprenderlas creyendo que la Pi es solo ese peine de pines.

Qué hay dentro, dicho para poder señalarlo

El sistema en un chip, el SoC, hace de procesador y de centro de vídeo y de periféricos. La memoria RAM está al lado, no en la tarjeta. La tarjeta guarda lo que tiene que seguir ahí después de quitar la corriente. Por eso cambiar de tarjeta es cambiar de sistema, y por eso una tarjeta a medio grabar no «arregla» un pin. Son averías de familias distintas. Si la pantalla no muestra el escritorio, el sospechoso primero es la tarjeta, la fuente o el cable de vídeo, no el GPIO 17, que todavía no has cableado.

La alimentación entra por el conector de corriente del modelo, a 5 V, con una fuente capaz. Esa 5 V alimenta la placa. Dentro, una parte se convierte a 3,3 V para la lógica y para los GPIO. Las dos tensiones asoman al header: físicos 2 y 4 son 5 V; físicos 1 y 17 son 3,3 V. Los GPIO hablan a 3,3 V. Ver las dos tensiones en el mismo peine es la trampa clásica. La lección 4 la abre con números. Aquí basta el mapa mental: lo gordo que entra por el enchufe no es lo que sale por un GPIO.

El Pico no es una Pi pequeña

Raspberry Pi Pico, y la familia que lo sigue, lleva un microcontrolador de la serie RP, no un sistema Linux de escritorio. Se programa como se programa un microcontrolador: grabas un firmware y ese es el que corre. No hay usuarios, no hay apt, no hay el escritorio de Raspberry Pi OS. Hay patillas, y entre ellas hay entradas analógicas de verdad: un conversor que mide una tensión y la convierte en un número. Eso el Pico lo tiene. El header de cuarenta pines de la Pi con Linux, no.

La consecuencia es concreta. Un esquema que dice «conecta el potenciómetro a A0 y lee el analógico» está hablando de otra placa. En esta Pi no existe ese A0. Más adelante el curso medirá luz o temperatura con sensores digitales o con trucos que no son un ADC del header. No se adelanta el circuito. Se adelanta la negativa: no busques el pin analógico en el peine, porque no está. Quien insiste, acaba usando un GPIO digital como si midiera voltios a medias, y el número que obtiene no significa lo que el tutorial prometía.

Tampoco al revés. No instales la imagen Trixie en un Pico esperando un escritorio. No cabe, y el Imager, cuando eliges bien el aparato, no te ofrece esa imagen para ese aparato. Si el desplegable del aparato dice Pico, has salido de este curso. Vuelve a elegir una Raspberry Pi de las que arrancan Linux.

Qué sí comparten, para no crear una magia falsa

Las dos son placas de la misma casa y las dos hablan de pines a tensión baja, nunca de 230 V. Las dos se rompen si metes en una patilla lógica una tensión de más. El parecido acaba ahí para este tramo. Compartir marca no comparte esquema. Cuando una página diga «Raspberry Pi» y el dibujo tenga tres chips en fila y un conector USB-micro de programación, mira si es un Pico. El header de cuarenta pines en dos filas de veinte, con 5 V en los físicos 2 y 4, es la Pi. Si no ves ese peine, no es la máquina de la lección 4.

Procesos, archivos y por qué importa ya

Aunque hoy no abras la terminal, el modelo mental tiene que estar puesto. Un archivo en /home es tuyo. La partición de arranque no es un cajón de apuntes: escribir ahí «porque vi la carpeta» es una forma conocida de dejar la placa sin arrancar. El CSV de medidas, cuando exista la lección 21, irá a una carpeta de tu usuario, no a la de arranque. Se dice ahora para que la costumbre nazca bien. No se practica el archivo todavía.

Un proceso es un programa en marcha. Cerrar la tapa del portátil no es el símil correcto: la Pi no tiene esa tapa. Quitar el USB de alimentación es un corte duro. El sistema necesita un apagado que vacíe las escrituras. Hasta la lección 9 no se enseña el comando. Hasta entonces, si has arrancado para mirar, espera a saber apagar. No hagas «pruebas de diez segundos» a base de tirones. El primer arranque, además, escribe más que un arranque ya hecho. Cortarlo a la mitad es de los peores momentos.

Qué queda fuera de esta lección

No se listan aquí todos los modelos ni los vatios de cada fuente. Eso es catálogo. No se explica el primer arranque paso a paso: es la lección 3, la única que enlaza la referencia de imagen y arranque. No se enseña a entrar desde otro equipo. No se nombra un procedimiento de SSH para rellenar. El pinout grande está en esta página, sección pinout-ensenanza, por si quieres señalar el físico 11 mientras lees. Señalar no es cablear.

Aviso. Header de la Pi: GPIO a 3,3 V, sin ADC. Pico: sí tiene ADC y no es esta máquina. Físicos 27 y 28 reservados. Físico 11 igual a GPIO 17. 230 V fuera.

Señalado el parecido de marca, el gesto de esta lección es negarlo en voz alta delante de la placa que tengas. Si es la de cuarenta pines, di «Linux, sin ADC, 3,3 V». Si es el Pico, di «no es el curso» y no le busques ranura de sistema. Mezclarlos en la misma mesa el primer día es la forma más rápida de clavar el esquema bueno en la placa mala.

Ejercicio en la Pi

Sin enchufar nada, escribe dos columnas: «lo haría en la Pi» y «lo haría en un Pico». Mete al menos cuatro tareas: arrancar un escritorio Linux, leer un analógico del propio conector, guardar un archivo en la tarjeta, grabar un único firmware. Si una tarea cae en las dos, tácha la duda y vuelve al párrafo del ADC.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

La imagen se graba en otro ordenador, con Raspberry Pi Imager, y en el apartado del usuario pones un nombre y una contraseña que sean tuyos. No dejes el usuario de los tutoriales viejos. Cuando la tarjeta esté dentro y des corriente, no la quites a mitad del primer arranque.

Quién graba y quién arranca

La Raspberry Pi no se instala a sí misma la primera vez. No tiene, de fábrica, un sistema usable en una tarjeta vacía. El sistema lo escribes tú, desde otro ordenador, en la microSD, y luego esa tarjeta se mete en la Pi. El otro ordenador puede ser el de casa. Hace falta un lector de tarjetas si ese ordenador no trae ranura. Hace falta la imagen correcta, que la lección 5 nombra: a 3 de octubre de 2026, Raspberry Pi OS basado en Debian 13 Trixie. Hoy el gesto es grabar y arrancar. Elegir entre escritorio, Full y Lite con criterio es la lección 6. Si es tu primera vez, graba la de escritorio de 64 bits. No empieces por una imagen de otra familia «porque ocupa menos».

Raspberry Pi Imager es el programa que escribe esa imagen y, a la vez, deja puestos el usuario y la contraseña. Hay otras formas de volcar una imagen. Esta casa usa Imager porque el apartado de personalización evita el fallo más caro del primer día: una Pi sin usuario y sin pantalla, parada en el asistente, que parece una tarjeta rota y no lo es.

El usuario no es opcional

En la personalización, el apartado User pide un usuario y una contraseña. Ponlos. Elige un nombre que no sea el de un tutorial de hace años. Aquel usuario por defecto se quitó a propósito: dejarlo vacío, o copiarlo de memoria, te deja o fuera del sistema o dentro de un ejemplo que ya no existe. La contraseña es la tuya. No hay una de fábrica que «siempre valga» cuando el asistente ya pasó.

Si rellenas el usuario, el primer arranque no se queda esperando a que inventes uno con un teclado que aún no has conectado. Si no lo rellenas y no hay pantalla, la Pi se sienta en el asistente y no sigue. Eso no se arregla regrabando diez veces la misma tarjeta vacía de usuario. Se arregla grabando otra vez con el usuario puesto, o completando el asistente con pantalla y teclado.

El Wi-Fi puede quedar en blanco. El SSH también. Si no rellenas nada de eso, el escritorio vuelve a preguntar en el primer arranque, y la red se puede saltar. A partir de ahí la placa trabaja sin internet: mirar el escritorio, abrir la terminal y, más adelante, un GPIO, no piden red. Lo que pide red es bajar paquetes nuevos, y eso no es esta lección. Sin pantalla, en cambio, SSH tiene que quedar activado en el Imager, porque si no, no hay puerta de entrada. Cómo se entra es la lección 36, que todavía no está escrita. No se improvisa aquí un comando de conexión para salir del paso.

El detalle de pantallas del Imager, si ya estás consultando la referencia y no aprendiendo el orden, está en Software, imagen y primer arranque. Esta ancla no se repite en otras lecciones. Si más adelante buscas «el enlace de arranque» y no estás en la lección 3, no está: es a propósito.

La tarjeta, el corte de corriente y el primer minuto

Se graba con la tarjeta en el lector del otro ordenador, no dentro de la Pi. Cuando Imager termine y diga que puedes quitarla, la quitas del lector. Metes la tarjeta en la ranura de la Pi con la alimentación desconectada. Una tarjeta insertada a medias se lee como «no arranca». Empújala hasta el clic del modelo que tengas. No fuerces una tarjeta de otro tamaño con un adaptador dudoso el primer día.

Conecta después el vídeo y el teclado, y al final la alimentación. El orden importa poco entre pantalla y teclado. Sí importa que la corriente sea el último gesto y que no sea un cable de carga flojo «un momento, para ver». Una fuente incapaz reinicia la placa justo cuando el primer arranque más escribe. Parece un fallo de la imagen. A menudo es la fuente.

El primer arranque tarda más que el segundo. La placa reparte el sistema, crea lo que le pediste y, si hace falta, enseña el asistente. Una pantalla negra durante unos segundos no es una muerte. Una pantalla negra durante varios minutos, sin ninguna luz de actividad, sí pide que quites corriente y revises tarjeta y fuente, no que cambies de imagen a ciegas. El LED verde de actividad, en muchos modelos, parpadea cuando la tarjeta se lee. Si no parpadea nunca, la tarjeta no se está leyendo: mal insertada, mal grabada, o no es la ranura.

Aviso. No cortes la alimentación durante este primer arranque. No es la lección de apagar: el comando llega en la 9. Hoy la regla es más bruta y más importante: si ya desenchufaste, espera a entender el apagado antes de hacer experimentos de «apagar y encender». Y no metas 5 V por un GPIO «mientras tanto». El header no participa en arrancar.

Qué ves si salió bien y qué ves si te quedaste en el asistente

Si pusiste usuario y hay pantalla, acabas viendo el escritorio, o un asistente corto de idioma, teclado y país. El país y el teclado importan: una contraseña con símbolos, tecleada con el mapa equivocado, parece una contraseña rechazada. Si el arroba y las comillas no salen donde crees, no regrabes. Cambia el mapa de teclado. El Wi-Fi, si aparece, se puede saltar. Saltarlo no rompe el arranque.

Si no hay escritorio y la placa «no hace nada», separa tres casos. Uno: no hay alimentación, fuente o cable. Dos: la tarjeta no está bien o no se grabó hasta el final. Tres: no hay pantalla y no activaste SSH ni pusiste usuario, y la Pi está en el asistente, callada. El tercer caso es el que más se confunde con una placa muerta. La frase de diagnóstico es: sin pantalla y sin usuario en el Imager, el silencio es el asistente, no un fallo de la tarjeta. Con pantalla, el asistente se ve. Complétalo. No lo confundas con un error de la imagen Trixie.

Lo que no se hace en esta lección

No se edita config.txt. No se abre raspi-config «por si acaso». No se actualiza nada con red. No se prueba el GPIO. No se copia una guía que arranca creando el usuario pi. Si esa guía es tu única fuente, está vieja respecto a este curso. El sistema de nombres de paquete de otra distribución tampoco se mezcla aquí: Ubuntu y DietPi existen, y la lección 6 dice por qué no son la base. Grabarlas hoy te deja fuera de los ejemplos.

Cuando el escritorio ya esté, no apagues tirando del cable si puedes evitarlo. Si no tienes más remedio porque todavía no existe en tu cabeza el comando de la lección 9, espera a que la actividad de la tarjeta pare, quita corriente una sola vez, y no hagas de eso un hábito. La próxima lección de sistema, la 5, pone nombre a lo que acabas de arrancar. La 7 te enseña a reconocer que de verdad arrancó. La 8 abre la terminal.

Cuando Imager pida confirmar que la tarjeta se va a borrar, léelo. Una tarjeta que ya tenía fotos no es «una tarjeta vacía de aspecto». El programa no recupera lo anterior. Si la única tarjeta que tienes es la de la cámara de casa, para. Consigue otra. Este curso no merece ese susto, y el susto no enseña el arranque.

Ejercicio en la Pi

Si tienes el otro ordenador y una tarjeta, graba la imagen de escritorio con usuario y contraseña puestos por ti. Anota el nombre de usuario en un papel, no en la partición de la tarjeta. Arranca con pantalla. Si no tienes tarjeta, escribe los cinco pasos de la práctica ya ordenados y marca cuál está prohibido.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Los GPIO hablan a tres con tres voltios. Los físicos 2 y 4 son cinco voltios de alimentación, no una señal más fuerte: el físico 11 es el GPIO 17 y el físico 17 es otra vez tres con tres, de alimentación. Los físicos 27 y 28 están reservados, no hay entrada analógica en este peine, y hoy no se cablea.

Tres palabras, aplicadas a este peine

Tensión es el empujón entre dos puntos, en voltios. Corriente es cuánta carga pasa, y en un GPIO se habla de miliamperios. Resistencia es el freno, en ohmios. Sin freno, la corriente la limita solo lo poco que aguanten el pin y el LED, y uno de los dos pierde. Entre un GPIO en alto y tierra hay 3,3 V, no 5. Esa diferencia de 1,7 V respecto a los tutoriales de placas de 5 V cambia la cuenta de la resistencia y, sobre todo, prohíbe «tomar el 5 V del header» como si fuera el mismo tipo de pin.

Un GPIO en alto sale a 3,3 V. En bajo, sale hacia tierra. Como entrada, tolera 3,3 V. No tolera 5 V. No es una tolerancia estrecha que «aguanta un momento». Es la forma rápida de dejar el pin muerto y, a veces, de llevarse por delante más lógica de la que se ve. Los físicos 2 y 4 entregan 5 V porque son la alimentación que entró por la fuente, no porque sean GPIO puestos fuertes. No se reconfiguran. No los nombres en un programa. Si un cable de señal acaba ahí, el programa no manda: manda el cortocircuito.

El mapa mínimo que hay que poder decir dormido

Con el header mirándote y el físico 1 arriba a la izquierda, la fila izquierda son los impares y la derecha los pares. Físico 1: 3,3 V. Físico 2: 5 V. Físico 6: tierra. Físico 11: GPIO 17. Físico 17: otra vez 3,3 V, alimentación. Físicos 27 y 28: reservados, ID_SD e ID_SC, la EEPROM que un HAT usa para identificarse. No son GPIO libres aunque algún mapa viejo los numere como GPIO 0 y GPIO 1. Usarlos para un LED es una manera de romper la detección de placas de expansión y de no entender luego por qué un HAT no aparece.

El número que escribirás en gpiozero, cuando esa lección exista, es el BCM. El 17 significa GPIO 17, o sea el agujero físico 11. Si cuentas diecisiete agujeros, caes en el 3,3 V de alimentación. El LED no luce, o peor: lo alimentas desde un pin que no es salida. El pinout de esta página, pinout-ensenanza, se puede tocar. Esta lección usa un recorte de cuatro pines para la práctica. El mapa completo no se memoriza hoy. Se memorizan los que queman y el del ejemplo.

La cuenta del LED, hecha a 3,3 V antes de tener el LED

Un LED rojo se queda cerca de 2 V. Si lo alimentas desde un GPIO a 3,3 V, sobra alrededor de 1,3 V, y esos tienen que caer en la resistencia. Con 330 ohmios, la corriente sale sobre 1,3 dividido entre 330, unos 4 miliamperios. Se ve, y el pin ni se entera. Con 220 ohmios estás en torno a 6 miliamperios, también razonable para un solo LED. Con cero ohmios, el LED y el pin se reparten un empujón sin freno.

330 ohmios es el valor del ejemplo de esta casa, no una constante de la naturaleza. Si la ficha de tu LED pide otra corriente, se recalcula. No se quita la resistencia «porque con 3,3 V no pasa nada». Pasa menos que con 5 V, y aun así un LED moderno de alta eficiencia, o un pin en corto, no son un juguete. La resistencia va en serie: da igual el lado del LED, porque la corriente es la misma en todo el camino. No va en paralelo con el LED. En paralelo no frena nada.

La tierra es el otro hilo del idioma. El GPIO decide alto o bajo respecto a su masa. El cátodo del LED tiene que volver a un GND del header, no a otro GPIO y no al 5 V. Si la masa no está, el circuito está abierto y el LED apagado con razón. Si el retorno cae en el físico 2, has unido una salida de 3,3 V, o un LED, con 5 V. Eso no se «prueba un segundo».

Cuánta corriente es mucha

Un LED con 330 ohmios pide unos pocos miliamperios. Eso es lo que este curso va a pedir a un pin. No un motor, no una tira, no un relé de bobina directa. La alimentación de 3,3 V del físico 1 tampoco es una fuente de laboratorio: está pensada para lógica pequeña. Cargar todos los GPIO a la vez como si cada uno diera decenas de miliamperios hunde esa línea y puede molestar a la propia tarjeta. No hace falta el número exacto de tu modelo para obedecer la regla: una salida, una resistencia, un LED. La corriente gorda, el día que exista, no saldrá del GPIO.

Los 5 V del físico 2 pueden alimentar un módulo que lo pida, siempre que la lógica de ese módulo hable a 3,3 V con la Pi. Muchos módulos «de 5 V» sacan 5 V por el pin de datos. Ese es el que no se conecta. Si la etiqueta no separa alimentación y señal, no se conecta hasta saberlo. El curso no tiene prisa por los módulos.

Lo que el header no es

No es un ADC. Medir una tensión variable con un GPIO digital da alto o bajo, un umbral, no un número fino. El Pico sí tiene conversor. Copiar su patilla analógica aquí es inventar un pin. No es una regleta de 230 V. Un relé de lámpara de pared no se cuelga de este curso. No es simétrico: darle la vuelta a la placa en la cabeza cambia impares y pares, y el 5 V acaba donde creías que había un GPIO. Por eso el dibujo fija el pin 1 arriba a la izquierda, con la serigrafía de la placa como juez, no la memoria.

Aviso. 3,3 V en todo GPIO. 5 V solo en los físicos 2 y 4, y nunca hacia un GPIO. Físico 11 = GPIO 17. Físicos 27 y 28 reservados. Sin ADC en este header. Sin 230 V.

El corto, la polaridad y el HAT

Un cortocircuito, en este header, es un camino sin freno entre una alimentación y tierra, o entre un GPIO en alto y tierra. El físico 2 unido al físico 6 con un cable pelado es eso: 5 V contra masa. La fuente puede caer, la placa puede apagarse para protegerse, o puede oler. No se «ve qué pasa» dejándolo un segundo. Se quita corriente. Un GPIO unido a tierra sin resistencia, puesto en alto por un programa, es el mismo tipo de fallo a 3,3 V: menos espectacular y suficiente para dañar el pad.

El LED tiene sentido. La pata larga, el ánodo, mira hacia el GPIO cuando el GPIO es quien empuja. La corta, el cátodo, mira hacia tierra después de la resistencia, o la resistencia va en el otro tramo: en serie da igual el orden, no da igual el sentido del diodo. Al revés, con resistencia, normalmente no luce y no muere. Sin resistencia, al derecho, sí puede morir. Por eso el dibujo de esta lección lleva las tres piezas en fila y el 5 V tachado al margen, no como cuarto paso opcional.

Los físicos 27 y 28 no están «vacíos». Al arrancar, la Pi puede mirar ahí una EEPROM pequeña que traen los HAT oficiales, para saber qué placa has puesto encima y qué pines reclama. Si esos dos pines los ocupas con un LED o con un pulsador, esa lectura se vuelve ruido. El HAT no se presenta, o se presenta mal, y el fallo aparece meses después, cuando por fin pongas una placa de expansión y culpes al conector. Se reservan desde el primer día, aunque hoy no tengas HAT. GPIO 0 y GPIO 1, si un mapa los dibuja ahí, no son un regalo: son esos mismos pines con el nombre viejo de BCM.

Ejercicio en la Pi

En la placa apagada, o en el pinout de esta página, señala con el dedo el físico 11, un 5 V y una tierra. Escribe la cuenta del LED: voltios que sobran desde 3,3, resistencia 330 ohmios, corriente aproximada. No conectes el LED todavía.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

A 3 de octubre de 2026 la imagen de este curso es Raspberry Pi OS basado en Debian 13, de nombre Trixie. Bookworm es la generación anterior y no es la base de lo que vas a leer. Hoy se reconoce el sistema: no se cambia de imagen por aburrimiento, y no se actualiza todo solo porque haya red.

Por qué el nombre de la versión es parte del mecanismo

Un sistema no es una etiqueta en la caja. Es el conjunto de programas, rutas y comportamientos que vas a encontrar al encender. Raspberry Pi OS está construido sobre Debian. Debian nombra sus versiones estables con un nombre, y ese nombre viaja a la imagen de la Pi. A 3 de octubre de 2026, la versión que este curso toma como referencia es Raspberry Pi OS basado en Debian 13 Trixie. Si tu tarjeta dice otra cosa, no estás «un poco detrás»: estás en otro mapa. Un comando copiado puede no existir, un archivo puede vivir en otra ruta, y el fallo parece tuyo cuando es de generación.

Trixie no es un programa que instales encima de lo que sea. Es la imagen. Se elige al grabar, en la lección 3, no con un botón mágico dentro de un sistema viejo el primer día. Cambiar de generación regrabando es lícito cuando sabes que la tarjeta no tiene nada que salvar. Cambiar a ciegas porque un foro lo pide es la forma de perder el usuario que acabas de crear y de no saber ya en qué lección estás.

Qué hay en la página de descarga, sin perderse

En la imagen oficial hay, para esta generación, una edición con escritorio de 64 bits, una Full y una Lite. Las tres pueden ser Trixie. No son tres sistemas enemigos: son tres cortes del mismo. El escritorio es el que este curso usa para empezar, porque vas a mirar con los ojos. Full añade más software del que hoy no necesitas. Lite quita el escritorio y se queda en terminal. La lección 6 decide cuándo Lite es la correcta. Si ya grabaste escritorio siguiendo la lección 3, no regrabes al acabar esta página.

Bookworm es la generación anterior. Sigue descargable y muchos tutoriales la dan por eterna. Este curso no la usa como base. Si tu tarjeta es Bookworm porque la grabaste hace meses, puedes leer el mecanismo de los pines igual: el header no cambió de idioma por el nombre de Debian. No puedes exigir que cada ruta y cada paquete del texto coincidan. Cuando una lección posterior nombre un paquete, será el de Trixie. Si el paquete no aparece, la primera pregunta es «¿qué generación es esta tarjeta?», no «¿está rota la Pi?».

64 bits, y qué no significa

La imagen de 64 bits es la que se recomienda para arrancar en el hardware de este curso que puede con ella. «64 bits» no significa el doble de GPIO, ni pines de 5 V, ni un ADC que antes no estaba. El header sigue a 3,3 V. El físico 11 sigue siendo el GPIO 17. Los físicos 27 y 28 siguen reservados. Quien mezcla la novedad del sistema con una novedad eléctrica inventada acaba cableando mal y culpando a Trixie.

Tampoco significa que debas borrar una tarjeta que ya funciona en mitad de una lección para «pasar a 64 bits» si ya estás en la imagen de escritorio de 64 bits. Comprueba antes de grabar otra vez. Grabar destruye lo que hubiera en la tarjeta. No es un archivo que se copia al lado. Es la tarjeta entera.

Cómo saber qué arrancaste, sin fe

La lección 8 abrirá la terminal con calma. Aquí solo se adelanta el gesto de lectura, porque el nombre del sistema se comprueba, no se supone. Cuando sepas escribir un comando, cat /etc/os-release enseña el nombre y la versión. Buscas Debian y el 13, o el nombre Trixie, según cómo lo imprima tu imagen. Si pone 12 o Bookworm, no has mentido: has arrancado otra generación. Anótalo. No hace falta repararlo en esta página si el escritorio te sirve para seguir las lecciones 7 y 8, pero no finjas que el texto posterior va a encajar al milímetro.

El escritorio también se presenta. No hace falta un número de compilación. Hace falta no confundir el asistente del primer arranque con «un sistema distinto». El asistente es Trixie preguntando lo que el Imager no traía. Cuando termina, sigues en la misma imagen. Regrabar porque el asistente preguntó el país es tirar el trabajo de la lección 3.

Lo que no se toca por estar en Trixie

No se abre la partición de arranque para «actualizar el sistema a mano» copiando archivos. No se mezcla un repositorio de otra versión porque un paquete no salía. No se instala aún nada: apt, y el hecho de que bajar paquetes pide red, es la lección 15, no esta. Si no hay red, Trixie sigue siendo Trixie. El escritorio no se evapora. El GPIO, cuando llegue, tampoco pide Trixie conectada a internet.

Si alguien te dice que Trixie «ya permite 5 V en el GPIO», es falso. El sistema operativo no renegocia el silicio del header. La lección 4 sigue mandando. Si alguien te dice que en Trixie el pin 11 cambió de número, también es falso: el físico 11 sigue siendo el GPIO 17 en el header de cuarenta pines de este curso.

Aviso. La referencia fechada es Trixie, Debian 13, a 3 de octubre de 2026. Bookworm no es un sinónimo. Ninguna versión autoriza 5 V en un GPIO ni usa los pines 27 y 28 como salida de un LED.

Qué significa «basado en Debian» y qué no

Debian es la familia de la que Raspberry Pi OS toma paquetes, versiones y el apellido Trixie. No significa que una guía genérica de Debian de escritorio, escrita para un PC, se pueda seguir al pie de la letra. Esas guías a veces cambian el gestor de arranque, el kernel o la red de una forma que en la Pi pasa por la tarjeta y por un firmware que el PC no tiene. El kernel que arranca la placa, y la forma en que el vídeo sale al HDMI, los mantiene la imagen de Raspberry Pi OS. «Basado en Debian 13» te dice la generación de los paquetes. No te invita a sustituir el arranque por el de un manual de torre.

Cuando leas /etc/os-release, fíjate en dos campos y no en la frase entera. VERSION_ID en 13 encaja con Debian 13. El nombre VERSION_CODENAME o el campo que mencione Trixie confirma la generación. Un PRETTY_NAME largo puede incluir «Raspberry Pi OS» y «Debian» a la vez: no es una contradicción, es las dos capas. Si el número es 12, es Bookworm aunque el escritorio se parezca. La lección siguiente no cambia este criterio: Lite también puede ser Trixie, y también puede ser Bookworm si grabaste la generación vieja sin escritorio.

Hay una fecha en esta lección a propósito: 3 de octubre de 2026. Las imágenes se mueven. Si lees esto meses después, el mecanismo sigue siendo el mismo —una generación, un nombre, no mezclar mapas— y el nombre concreto se comprueba en la tarjeta, no se recita de memoria. No actualices el sistema «para llegar a la siguiente» en medio de las lecciones 7 y 8. Primero se sabe apagar. Una actualización cortada por un tirón de cable es una tarjeta a medio escribir, que es el fallo de la lección 3 con otro disfraz.

Un síntoma concreto de estar en la generación equivocada, sin tocar aún un paquete: un tutorial de Bookworm te manda un archivo de configuración que Trixie ya no lee en ese sitio, o al revés. El archivo existe, lo editas, y la placa no cambia de comportamiento. No es que «el sistema ignore las órdenes». Es que estás hablando con la habitación de al lado. Por eso la comprobación de /etc/os-release va antes que cualquier receta copiada, y por eso esta lección no incluye una receta.

El escritorio puede decir «Raspberry Pi OS» en un acerca de, sin el apellido Trixie a la vista. Eso no basta para dar la generación por sabida. El apellido se lee en el archivo, cuando la terminal exista, o se recuerda de la fila que elegiste en el Imager. Las dos comprobaciones tienen que coincidir. Si no coinciden, manda el archivo: es lo que de verdad arrancó, no lo que creíste marcar.

Ejercicio en la Pi

Si la Pi ya arrancó, anota qué generación crees que es y por qué. Cuando la lección 8 te deje escribir comandos, compruébalo con cat /etc/os-release y corrige la nota. Si aún no hay terminal, deja la nota como hipótesis, no como hecho.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Trixie se corta de tres maneras: escritorio para mirar la pantalla, Full con más programas de los que hoy usas, y Lite sin escritorio. Ubuntu y DietPi arrancan en hardware parecido y no son la base de los ejemplos. El header no se vuelve de cinco voltios por cambiar de marca.

Tres cortes, un solo sistema

La lección 5 fijó la generación: Trixie, Debian 13, a 3 de octubre de 2026. Dentro de esa generación el Imager no te da una sola fila. Te da un escritorio, una imagen Full y una Lite. Elegir mal no rompe el header. Te deja en una habitación distinta de la que el curso describe, y luego cada frase de «abre el menú» o «no hay menú» choca con lo que ves.

La imagen con escritorio es la de aprender. Hay menú, hay ventanas y hay una forma visible de abrir la terminal, que es la lección 8. El primer arranque puede preguntarte idioma y teclado. Eso es a favor: ves el error. Si el país quedó mal, lo ves. Full mete más aplicaciones en esa misma idea. Pesa más al grabar y al arrancar, y no te enseña el GPIO antes. No la elijas por completismo el primer día. Si ya la grabaste, tampoco la tires: es Trixie con escritorio de más, y las lecciones 7 y 8 se pueden seguir.

Lite es el mismo Raspberry Pi OS sin ese escritorio. Arranca en texto. Se entra por el teclado que conectes o, más adelante, por SSH. Ocupa menos y no gasta sesión gráfica. Es la imagen correcta cuando la placa se va a quedar haciendo un trabajo fijo: un sensor, una cámara, un script, y nadie va a sentarse a mirar un menú. No es la imagen correcta para las lecciones 7 y 8 tal como están escritas, porque la 7 te pide reconocer el escritorio. Si grabaste Lite, no has estropeado la tarjeta. Has adelantado un modo que el curso deja para cuando el trabajo fijo exista. Para seguir este tramo, graba el escritorio en una tarjeta, o acepta que «ver el escritorio» no va a ocurrir y no finjas que la pantalla negra de texto es un fallo.

Cómo se decide sin postureo

Hazte una sola pregunta: ¿en las próximas lecciones hay una persona delante de un monitor? Si sí, escritorio. Si la placa va a vivir en una caja y la única puerta será la terminal, Lite, y entonces la lección 36, cuando exista, importará más que la 7. Las dos cosas a la vez, «quiero escritorio por si acaso y Lite para que vaya rápida», no es una imagen. Es una indecisión. Se graba una. Cambiar luego es regrabar, y regrabar borra la tarjeta.

Las otras imágenes que el Imager enseña

Ubuntu publica escritorio y servidor para Raspberry Pi. Es un sistema serio, de otra familia de paquetes. DietPi es una imagen mínima de terceros: el Imager la ofrece dentro de otras opciones de propósito general. Ninguna de las dos es la base de los ejemplos de este curso ni de la referencia de Software que enlaza aquí. Si las usas, un nombre de paquete puede no existir, la ruta de arranque puede no ser la misma, y el asistente del primer día no se parece al de la lección 3. No es que la placa las rechace. Es que este texto no las va a ir traduciendo.

La tentación es grabarlas porque alguien midió que arrancan unos segundos antes. En las lecciones 1 a 8 esos segundos no enseñan nada. El coste es no poder comprobar el mecanismo con el mismo nombre que el libro. Cuando sepas por qué quieres otro sistema, ya no necesitas esta lección. Hasta entonces, Trixie escritorio.

Lo que no cambia aunque cambies de corte

Lite no inventa un ADC. El escritorio no convierte el físico 2 en un GPIO. Full no libera los pines 27 y 28. Ubuntu no autoriza 5 V en la lógica. El silicio del header es el de la lección 4 en todas estas imágenes. Si un tutorial de otra distribución te dice que el pin 17 del borde es el 17 del programa, sigue siendo el mismo error de numeración, con otro fondo de pantalla.

Tampoco cambia la regla del usuario. Sea escritorio o Lite, el usuario lo pones tú en el Imager. En Lite se nota más el olvido: no hay un escritorio que te recoja. Hay un arranque en texto pidiendo un nombre que no creaste, o un silencio si además no hay teclado. La lección 3 ya lo dijo. Aquí se repite porque la gente cambia a Lite «para ahorrar» y se deja el usuario vacío justo en la variante que menos perdona.

Regrabar no es una preferencia estética

Cada grabación borra la tarjeta. Si ya completaste el primer arranque, ya tienes usuario, idioma y quizá algún archivo. Pasar de escritorio a Lite porque esta lección mencionó Lite es destruir eso para obtener una habitación que aún no necesitas. La decisión de Lite se toma cuando hay un trabajo fijo, no cuando se lee la palabra en un índice.

Si grabaste Ubuntu sin querer, la forma limpia de volver es grabar Trixie de nuevo, con usuario, y repetir el arranque. No hay una capa de compatibilidad que este curso te vaya a dictar. No edites archivos de arranque de una distribución para «hacer que parezca» la otra.

Aviso. Otra imagen no cambia el header: GPIO a 3,3 V, físico 11 igual a GPIO 17, pines 27 y 28 reservados, sin ADC, sin 230 V.

Qué se ve, para no confundir habitaciones

En el escritorio hay una barra, un menú y un fondo. Puedes abrir el menú con el ratón sin saber un comando. Eso es lo que la lección 7 llama arrancar. En Lite no hay esa barra. Hay un prompt de texto pidiendo usuario y contraseña, o directamente el prompt si la sesión ya entró. Una pantalla negra con una sola línea parpadeante no es «el escritorio que tarda». Es Lite, o es un fallo de vídeo. Se distinguen así: si el verde parpadeó y al pulsar Enter aparece un prompt o una petición de login, el sistema está en texto. Si no aparece nada, ni una línea, sigue siendo el cable o la fuente.

Un caso cerrado. Quieres aprender, tienes monitor, y además te han dicho que Lite «es lo serio». Grabas Lite. Llegas a la lección 7 y no hay menú que reconocer. No has aprendido más: te has saltado el andamio. La vuelta es regrabar el escritorio, con usuario otra vez, y aceptar que la tarde anterior era un ensayo. El otro caso, el bueno para Lite, todavía no está en estas ocho lecciones: una Pi que ya sabes manejar, metida en una caja, con un script que debe vivir solo. Entonces el escritorio estorba. Hoy no estorba. Hoy es la habitación.

Full se reconoce igual que el escritorio, con más entradas en el menú. No te va a pedir que las uses. Si una de esas entradas ofrece activar interfaces, déjala. Activar I2C porque el menú lo pone a mano no es la lección 31. Es un interruptor sin circuito. DietPi y Ubuntu pueden mostrar también un escritorio o un login de texto. El aspecto no certifica la marca. La certifica el nombre en la imagen que elegiste al grabar, y luego /etc/os-release o el archivo equivalente. Si ese nombre no es Raspberry Pi OS, estás fuera de la base, aunque la ventana se parezca.

Si dudas, la regla de desempate es aburrida y correcta: quédate con la imagen que ya arranca a escritorio, siempre que sea Trixie. Dudar no obliga a regrabar. Regrabar es una decisión, y solo se toma cuando sabes qué habitación necesitas y aceptas borrar la tarjeta. Lite no se «prueba un momento» encima del escritorio. Lo sustituye.

Hay una frase que se oye en casa: «graba las dos y comparamos». Hacen falta dos tarjetas, no dos particiones mágicas. Comparar enseñará que el escritorio tiene menú y Lite no. No enseñará el GPIO. Si solo tienes una tarjeta, la comparación se hace en papel, con esta lección, y se graba una vez.

Ejercicio en la Pi

Escribe en una línea qué imagen tienes grabada de verdad, no cuál te gustaría. Si no lo sabes, no regrabes: míralo en el primer arranque o espera a la terminal. Al lado, escribe si hay alguien delante de una pantalla en las próximas lecciones, y comprueba que las dos frases no se contradicen.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Arrancar no es que el LED rojo exista: es llegar a un escritorio que responde, o saber por qué no has llegado. El primer arranque tarda, el asistente de idioma no es otro sistema, y un teclado en el mapa equivocado hace que la contraseña parezca falsa. Hoy se mira, se reconoce y se espera.

Qué cuenta como «ya está»

Una Pi ha arrancado, para este curso, cuando ves el escritorio de Raspberry Pi OS y el puntero obedece al ratón o el teclado abre el menú. Antes de eso hay una cola de cosas que también son normales: pantalla negra unos segundos, un logo, el asistente de país y de teclado, una pregunta de red. Ninguna de esas pantallas es un fallo por existir. El fallo es quedarse en una de ellas sin leerla, o apagarlas a tirones porque tardan más que el móvil.

El primer arranque es el lento. Está creando lo que la imagen dejó preparado y aplicando el usuario que pusiste en el Imager. El segundo arranque, otro día, será más corto. Juzgar la placa por el primer minuto es como juzgar un horno antes de que caliente. Si a los varios minutos sigue todo negro y no hay parpadeo de actividad en la tarjeta, entonces sí: quita corriente, revisa la tarjeta bien metida, el cable de vídeo y la fuente. No regrabes todavía. La mayoría de «no arranca» de esta lección son un HDMI en el puerto que no toca, una fuente floja o una tarjeta a medio insertar.

Luces, sin convertirlas en un código secreto

En muchos modelos hay un LED rojo de alimentación y un LED verde de actividad de la tarjeta. El rojo fijo suele querer decir que entra corriente. El verde parpadea cuando la tarjeta se lee. Si el rojo no se enciende, no busques el sistema: no hay alimentación, o no llega. Si el rojo parpadea o se apaga en cuanto la placa intenta arrancar, la fuente no puede. Eso no se cura eligiendo otra imagen.

No memorices una tabla de parpadeos de un modelo que no es el tuyo. La Pi 5, por ejemplo, tiene botón de encendido, y pulsarlo no es el apagado limpio de la lección 9 ni un comando que esta lección te deje usar como costumbre. El catálogo Hardware, cuando mires la ficha de tu modelo, dirá el LED concreto. Aquí la regla basta: sin luz ninguna, no hay corriente; verde callado todo el rato y pantalla negra, la tarjeta no se está leyendo; verde vivo y pantalla negra, mira el cable de vídeo antes de culpar a Trixie.

El asistente no es un sistema distinto

Si pusiste usuario en el Imager, puede que no te lo vuelva a pedir. Sí puede pedirte país, idioma y teclado. Responde. El teclado es el mecanismo escondido de esta lección: las letras salen según un mapa. Si el mapa es el de otro país, la tecla donde tú esperas un guion escribe otra cosa. Más adelante una contraseña fallará y creerás que la placa la rechaza. La rechaza porque no le estás mandando los símbolos que crees. Cuando el asistente pregunte, elige el teclado que de verdad tienes encima, no el que «viene en la foto del tutorial».

La pregunta de la red se puede saltar. Saltarla deja la Pi sin Wi-Fi y con el sistema intacto. Las lecciones 7 y 8 no descargan nada. Si saltas la red y luego echas de menos un paquete, ese problema es de la lección 15, no una prueba de que el arranque fue mal. No conectes el móvil como fuente «mientras buscas el Wi-Fi». La fuente floja sí tumba el arranque. El Wi-Fi vacío no.

Qué no es todavía un éxito

Ver el escritorio no significa que ya puedas cortar la corriente. El sistema sigue teniendo escrituras perezosas. Apagar es un comando y una espera, y es la lección 9, que en esta pasada no está escrita. Si terminas la sesión de hoy, no hagas diez ciclos de enchufar y desenchufar «para ver si siempre arranca». Una vez basta. Cuando el verde deje de parpadear un rato, si no te queda otra que cortar, corta una sola vez y da por cerrada la tarde. Mañana, la lección 9 sustituye ese gesto.

Tampoco es un éxito abrir el menú de preferencias y activar interfaces que aún no usas. I2C, SPI, la cámara y SSH tienen lección o referencia cuando toca. Activarlos hoy no adelanta el aprendizaje. SSH, en concreto, será la lección 36. Dejarlo encendido «por si acaso» en una red que no controlas no es un ejercicio de esta página.

Y no es el momento del header. El escritorio puede convivir con un cable metido en el físico 2 por error, y el escritorio seguirá ahí mientras el pin se quema. Que la pantalla vaya bien no certifica el cableado. Como en esta lección no hay cableado, deja el peine en paz. Si ya habías pinchado algo antes de leer la lección 4, quita corriente y quita esos cables antes de volver a darla.

Una pantalla que no es la tuya

El vídeo sale por el conector que el modelo trae. Un adaptador barato puede no negociar el modo y dejarte en negro con el verde parpadeando: la Pi arrancó y tú no la ves. Prueba otro cable o el otro puerto HDMI si hay dos, antes de regrabar la tarjeta. Regrabar no cambia un adaptador. Si usas un televisor, asegúrate de que la entrada es la del cable que pusiste, no otra toma. Parece indigno de decirse y es una causa real.

Cuando por fin ves el escritorio, no cambies aún el tema, ni instales un navegador distinto, ni aceptes actualizaciones largas si no sabes cuánto van a tardar y cómo se apaga al final. Una actualización a medias, cortada por hambre de desenchufar, es peor que un sistema sin actualizar. Trixie ya es el sistema. Puede esperar.

Aviso. Llegar al escritorio no autoriza a tirar del cable ni a probar el header. GPIO a 3,3 V. Físico 11 es GPIO 17. Pines 27 y 28 quietos. Sin 230 V.

El teclado, contado con una contraseña

Supón que la contraseña que pusiste en el Imager era casa-42. En el asistente, el mapa de teclado quedó en inglés de Estados Unidos y el tuyo es español. El guion puede seguir saliendo. El problema llega con la arroba, la comilla o la eñe, el día que la contraseña las tenga, o con símbolos que en un mapa viven en otra tecla. El sistema compara bytes, no intenciones. «La he puesto bien» es falso si la tecla no emite ese signo. Por eso el asistente pregunta el teclado antes de que dependas de la contraseña cada mañana. Si ya pasaste el asistente y las teclas no coinciden, se cambia el mapa en la configuración de localización del escritorio. No se regraba la tarjeta para mover una tecla.

Dos puertos de vídeo, cuando el modelo los tiene, no son «el mismo con dos enchufes por si acaso» el primer día. El sistema puede sacar imagen por uno y dejar el otro negro hasta que se le dice lo contrario. Si el verde late y tu monitor calla, cambia de puerto antes de concluir que Trixie no trae escritorio. Un televisor con tres HDMI hace la misma jugada en el otro extremo: la Pi habla por el cable, el televisor escucha otra toma. La lección 6 ya separó Lite de este caso. Aquí, si grabaste escritorio, el negro con actividad es casi siempre el camino de la imagen, no la ausencia de escritorio.

Cuando el puntero por fin se mueve, recorre solo esto: menú, apagado a la vista pero sin usarlo todavía si no sabes qué hace cada entrada, y el icono de la terminal para la lección siguiente. Hay entradas de apagado en el menú que sí son un apagado limpio. Usarlas no es un tirón. Aun así, esta lección no las convierte en el temario: la 9 dirá el comando y la espera del LED. Si usas el menú para terminar hoy, espera a que la placa se quede quieta antes de retirar la fuente. No pulses el botón de una Pi 5 cinco veces «a ver». Un botón de encendido no es un reset de juguete.

Anota la hora a la que diste corriente y la hora a la que viste el puntero. En el primer arranque ese intervalo puede ser de minutos. Si fue de pocos segundos, bien. Si pasaron más de cinco minutos con el verde en silencio, no esperes un sexto «por fe»: corta, revisa tarjeta y fuente, y solo entonces plantea regrabar. La fe no repara un contacto.

Ejercicio en la Pi

Con la Pi delante, espera al escritorio. Anota tres cosas que hayas visto antes de llegar (logo, asistente, pregunta de red u otra) y di si eran fallo o tránsito. No cambies ajustes eléctricos. No abras el header. Si no tienes placa, escribe las tres escenas de la práctica y qué mirarías en cada una.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

La terminal es una conversación con el sistema, una línea cada vez. whoami, pwd y ls no cambian nada: preguntan, y un nombre mal escrito no rompe la placa. Las mayúsculas importan, y todavía no hace falta sudo, ni borrar, ni tocar el header.

Abrirla, y qué es esa línea que parpadea

En el escritorio de Raspberry Pi OS hay un acceso a la terminal: un icono de pantalla negra en la barra, o el menú, sección de accesorios, programa Terminal. Ábrelo. No es una página web y no pide red. Es una ventana donde el sistema espera una orden y, cuando pulsas Enter, la ejecuta o te dice que no puede.

Lo que ves antes del cursor se llama prompt. Suele llevar tu usuario, una arroba, el nombre de la máquina, dos puntos, una tilde o una ruta, y un símbolo de peso o de dólar. La tilde significa tu carpeta personal, /home seguido de tu usuario. El símbolo final, en una cuenta normal, no es una almohadilla. La almohadilla sería una sesión de root, y no la queremos. Si alguien te dice que el primer gesto es sudo su para «ir más rápido», ese alguien te está sacando del sitio donde los errores son baratos. sudo tiene lección, la 11, y no está escrita en esta pasada. Hoy se trabaja sin él.

Tres preguntas que no rompen nada

whoami responde el usuario. Tiene que ser el que pusiste en el Imager, no el de un tutorial viejo y no root. Si sale otro, no estás en la cuenta que crees. No lo arregles creando usuarios a ciegas. Anótalo y recuerda la lección 3.

pwd significa print working directory: en qué carpeta estás. Al abrir la terminal, casi siempre /home/tuusuario. Esa es tu mesa. Los archivos de prácticas, cuando existan, viven aquí o en una carpeta que cuelgue de aquí. No viven en la partición de arranque. Aunque hoy no veas esa partición, la regla se dice ya: no guardes apuntes en /boot ni en /boot/firmware. Es el sitio por el que la placa arranca. Un archivo de más, o uno editado «para probar», puede dejarla sin escritorio. El CSV de la lección 21, cuando se escriba, también irá a tu carpeta, no ahí.

ls lista lo que hay. ls -l lo lista con detalle: permisos, dueño, tamaño, fecha. Si la carpeta está vacía, no es un error. Es una cuenta nueva. ls de una carpeta vacía no imprime una frase amable. No imprime nada, y devuelve el prompt. El silencio, aquí, significa «no hay nombres», no «la terminal se rompió».

whoami
pwd
ls
ls -l

Moverse, y por qué las mayúsculas no perdonan

cd cambia de carpeta. cd solo, sin argumento, o cd ~, te devuelve a tu home. cd .. sube un nivel. cd / te lleva a la raíz del sistema, que no es tu mesa: es el pasillo de todo. No hace falta quedarse ahí. Si te pierdes, pwd y luego cd sin más. No hay un botón de deshacer universal, pero estos tres no borran.

Los nombres distinguen mayúsculas. ls existe. LS no. Documentos y documentos son dos carpetas posibles, y solo una existe. El sistema no te corrige la intención. Te dice que no está. La flecha arriba recupera el comando anterior para corregir una letra, en vez de reescribirlo. El tabulador, si lo pulsas a mitad de un nombre, intenta completarlo. Si no completa, el nombre no es único o no existe. No insistas con diez tabuladores: mira con ls.

clear limpia la ventana. No borra archivos. Solo quita de la vista lo que ya leíste. Úsalo cuando el error ya lo hayas entendido, no antes: el texto del error es la pista, y limpiarlo para que «quede bonito» es tirar la pista.

Leer un error de verdad

Escribe sl y pulsa Enter. Querías ls y se te fue el dedo. La respuesta se parece a esto:

bash: sl: orden no encontrada

O, si el idioma del sistema está en inglés, bash: sl: command not found. Las dos frases dicen lo mismo. bash es el programa que está leyendo tus líneas. sl es lo que le pediste. «No encontrada» significa que en los sitios donde se buscan los comandos no hay ninguno con ese nombre. No significa que la tarjeta se haya corrompido, ni que el GPIO se haya quemado, ni que Trixie esté mal grabada. Significa que el nombre está mal.

El mismo mecanismo, con otras palabras, aparece si escribes una ruta que no existe: el sistema dice que no hay tal archivo o carpeta. Antes de reinstalar nada, lee el nombre. Compara mayúsculas. Compara si estás en la carpeta que crees, con pwd. La práctica de esta página te pone un error y tres lecturas. Una sola es la de este mecanismo.

Lo que hoy no se escribe

No se usa sudo. No se usa rm. No se edita un archivo del sistema. No se instala un paquete. No se lanza un programa de Python todavía: el bloque de Python son las lecciones 17 a 22, y el CSV es la 21. Puedes, si quieres, comprobar la generación con cat /etc/os-release, que solo lee. Si el texto menciona Debian 13 o Trixie, coincide con la lección 5. Si menciona Bookworm, ya lo sabías como posibilidad: anótalo, no regrabes en medio de este ejercicio.

Cerrar la ventana de la terminal no apaga la Pi. Cierra la conversación. El escritorio sigue. Apagar sigue siendo la lección 9. Salir de la terminal con exit es lo mismo que cerrar la ventana: termina esa sesión de shell, no la máquina.

Y el header sigue fuera. Nada de lo que escribas hoy en la terminal enciende el físico 11. Quien pegue un programa de GPIO encontrado fuera, en esta lección, se salta el pin, la resistencia y el hecho de que en una Pi 5 la librería vieja no es la del curso. Eso se dirá cuando toque gpiozero. Hoy, whoami, pwd, ls y un error leído con calma.

Aviso. La terminal no vuelve seguro un cable mal puesto. Si no hay cables, no los pongas. 3,3 V, físico 11 igual a GPIO 17, pines 27 y 28 reservados, sin ADC en el header, sin 230 V.

Una sesión, línea a línea

Esto es una sesión posible, con el usuario ana. No la copies si tu usuario es otro: el mecanismo es el mismo y el nombre no.

ana@pi-casa:~ $ whoami
ana
ana@pi-casa:~ $ pwd
/home/ana
ana@pi-casa:~ $ ls
ana@pi-casa:~ $ ls -l
total 0
ana@pi-casa:~ $ LS
bash: LS: orden no encontrada
ana@pi-casa:~ $ ls
ana@pi-casa:~ $ cd /
ana@pi-casa:/ $ pwd
/
ana@pi-casa:/ $ cd
ana@pi-casa:~ $ pwd
/home/ana

La primera línea pregunta y la segunda contesta. pwd confirma que la tilde y /home/ana son el mismo sitio. El primer ls callado es una home vacía, y ls -l lo dice con un total de cero. LS produce el error de la práctica. El ls siguiente, en minúsculas, vuelve al silencio sano. cd / baja a la raíz: el prompt cambia la tilde por una barra. No has roto nada, y tampoco has ganado nada quedándote. cd sin argumento regresa. Si en la raíz hubieras intentado crear un archivo «porque hay sitio», estarías escribiendo fuera de tu mesa, a menudo sin permiso, y la tentación siguiente sería sudo. Esa tentación se aplaza.

Ruta absoluta y ruta relativa. /home/ana empieza por la barra: se cuenta desde la raíz, estés donde estés. Documentos, sin barra, se cuenta desde la carpeta actual. Si no estás en home, cd Documentos falla aunque la carpeta exista en home. El error habla de la carpeta, no del comando cd. Por eso pwd va antes de discutir. cd /home/ana/Documentos funciona desde cualquier sitio, si esa carpeta existe. En una cuenta nueva puede no existir. Crearla no es esta lección: aún no hace falta un sitio distinto de home.

El historial de la flecha arriba dura mientras la ventana sigue abierta y, según cómo cierre, un poco más. No es un cuaderno fiable. Lo fiable es el papel donde anotaste el usuario y la ruta, como pide el ejercicio. Si cierras con exit y vuelves a abrir, pwd debe enseñar otra vez tu home. Si enseña la raíz, el arranque de esa ventana no es el de una cuenta normal y hay que mirar, no acostumbrarse.

bash: LS: orden no encontrada

Ejercicio en la Pi

En la Pi, abre la terminal. Ejecuta whoami, pwd y ls. Luego escribe LS en mayúsculas y lee la frase. Corrígelo con la flecha arriba o escribiendo ls. Anota en papel el usuario y la ruta. No uses sudo. No borres nada. Si no hay placa, copia el prompt de un ejemplo inventado con tu nombre y señala qué trozo es el usuario y cuál la carpeta.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Apagar bien es una orden y una espera, no un tirón del cable. La orden es sudo shutdown -h now: el sistema vuelca a la tarjeta lo que aún estaba solo en memoria y desmonta los sistemas de archivos. Cortar antes deja escrituras a medias y la tarjeta se corrompe por eso.

La orden, y dónde está escrita en la referencia

La orden es esta, tal cual, en la terminal de la cuenta que creaste con el Imager:

sudo shutdown -h now

shutdown pide un cierre ordenado. -h significa halt: parar la máquina, no volver a arrancar. now significa que el cierre empieza ya, no dentro de unos minutos. Las tres piezas van juntas. Si quitas -h, no es la orden de esta lección. Si cambias now por un número para «dejarla apagándose mientras recojo», tampoco: hoy se espera delante. El detalle de la referencia, el de consultar y no el de aprender el orden, está en Software, apagado. Esta página no copia esa ficha. Aquí se explica el mecanismo para que el tirón deje de parecer un atajo.

sudo va delante porque parar la máquina es una decisión de todo el sistema, no de tu carpeta. Quién presta ese poder, y por qué un script de GPIO no lo necesita, es la lección 11. Hoy solo hace falta saber que esta línea sí lo lleva, que la contraseña que pide es la tuya, y que mientras la escribes no se dibujan puntos. La pantalla en blanco durante la contraseña no está congelada.

Qué ocurre entre el Enter y el silencio

Al pulsar Enter no se corta la electricidad. Se arranca una secuencia. El sistema avisa a los programas para que cierren sus archivos. El que puede, termina y suelta lo que tenía a medias. El que no obedece a tiempo se detiene. Hasta que esos programas no sueltan los archivos, no tiene sentido hablar de «ya está guardado»: un editor puede tener en memoria una versión que tú crees escrita porque pulsaste guardar, y el guardado puede haber llegado solo a la memoria del sistema.

Después el núcleo vuelca los datos pendientes. En Linux, cuando un programa escribe, la llamada vuelve en cuanto los bytes están en la memoria RAM, en lo que se llama la caché de páginas. La tarjeta microSD no los tiene todavía. Hay un volcado de fondo, cada poco, pero «cada poco» no es «antes de que tú tires del cable». El cierre ordenado hace un volcado explícito y, a continuación, desmonta los sistemas de archivos. Desmontar es decir: no queda nadie escribiendo, los buffers están vacíos, y el sistema de archivos queda marcado como cerrado en limpio.

Al final la placa se detiene. En unos modelos la propia alimentación de la placa se corta al llegar ahí y parece que se apagó sola. En otros el LED rojo sigue encendido porque la fuente de cinco voltios sigue conectada: el procesador está parado y la corriente no. Las dos cosas son un halt correcto. Lo que no varía es el orden. Primero el cierre. Luego la espera. Luego, si vas a guardar la placa o a dejarla sin corriente, quitas la fuente. Quitar la fuente es el último gesto, no el primero.

Por qué cortar la corriente corrompe la tarjeta

La microSD no es un disco que escriba el byte en el instante en que el programa dice «guarda». Hay tres sitios donde una escritura puede estar a medias, y el tirón los corta los tres.

El primero es la memoria del sistema. Los bytes están en RAM y el programa ya recibió el «hecho». Si quitas la corriente ahí, esos bytes no existen en la tarjeta. El archivo queda como estaba, o queda truncado si una parte sí llegó y la otra no. Tú recordarás que guardaste. La tarjeta recuerda otra cosa.

El segundo es el sistema de archivos de la raíz. En Raspberry Pi OS, a 3 de octubre de 2026, esa raíz es ext4 sobre Debian 13 Trixie. ext4 lleva un diario: una libreta donde apunta los cambios de estructura antes de darlos por buenos. Si el corte llega en mal momento, al siguiente arranque el diario se relee y la estructura suele quedar coherente. «Suele» no es «tu archivo está entero». El diario protege sobre todo la estructura, no el último párrafo que estabas guardando. La opción habitual de este sistema escribe los datos del archivo antes de apuntar la estructura, así que un corte tiende a perder lo último más que a mezclar bloques viejos dentro del archivo. Perder lo último ya es corrupción de tu trabajo. Y si el corte parte el propio apunte del diario, el arranque siguiente puede frenarse, montar la raíz solo para lectura, o no montarla.

El tercero no lo controla Linux. Dentro de la microSD hay un controlador y una tabla propia que decide en qué celda física cae cada bloque. Esa tabla también se reescribe, y las celdas se borran por bloques grandes, no de uno en uno. Si la corriente muere mientras la tarjeta reescribe su tabla, el daño ya no es «un archivo». Pueden desaparecer bloques de cualquier partición, también de la de arranque. Por eso un sync hecho a mano no equivale a apagar: sync vacía los buffers de Linux y se vuelve, y la tarjeta puede seguir moviendo celdas, y los programas pueden seguir escribiendo un segundo después. El cierre de shutdown para a quien escribe, vuelca, desmonta y solo entonces deja la máquina quieta el tiempo suficiente para que ese gesto final de la tarjeta termine.

La partición de arranque suma un motivo más. En esta generación del sistema está montada en /boot/firmware y es una FAT, sin diario. Un corte a medias ahí no tiene libreta que rehacer. Si se parte un archivo que la placa necesita para arrancar, el síntoma siguiente no es «falta una línea de mi texto»: es una placa que no vuelve. La lección 8 ya dijo que tus apuntes no viven ahí. Esta lección dice por qué, además, no se apaga tirando del cable «total, solo estaba en el escritorio»: el escritorio también apoya los pies en esa partición.

sync, el menú y el reinicio no sustituyen el orden

sync existe y hace una sola cosa: pedir que los buffers salgan hacia el dispositivo. No avisa a los programas. No desmonta. No detiene el procesador. Escribir sync y desenchufar es el ejemplo de apagar a medias con una palabra técnica en medio. No lo uses como ritual de cierre.

El menú del escritorio, la entrada de apagar, sí es un cierre ordenado si lo dejas terminar. Llama al mismo mecanismo, con otro tirador. No ahorra la espera. Cerrar la ventana de la terminal no es esa entrada: eso ya lo viste, termina la conversación y deja la máquina encendida. Cerrar la tapa de una caja tampoco. Y el botón físico, en un modelo que lo traiga, no es un permiso para retirar la fuente mientras el LED de actividad sigue latiendo. Si lo usas, el orden no cambia: se espera a que la actividad pare.

Reiniciar tampoco es el gesto de guardarla. sudo reboot también cierra en orden, y por eso reiniciar bien no corrompe. Pero al final vuelve a dar corriente lógica y a montar los discos. Si el plan es meter la placa en un cajón, un reinicio es el camino contrario: la dejas arrancando sola encima de la mesa. Para desenchufar, la orden es la de halt.

Hay una forma lenta del mismo comando, con minutos de aviso. No es más segura: es el mismo cierre, retrasado. En esta lección no se usa, porque la espera hay que verla, no irse a otra habitación y tirar del cable «cuando ya habrá acabado».

Qué miras mientras esperas

La imagen desaparece o se queda en negro. El LED verde de actividad, el que parpadea cuando la tarjeta trabaja, deja de parpadear. Eso es la señal de esta lección, no una tabla de códigos de un modelo concreto. El rojo puede seguir. Si el rojo sigue, no has fallado: la fuente sigue enchufada, que es exactamente el estado de después del halt y de antes de quitar la corriente.

No des la orden y cuentes «tres» para tirar. Tres segundos pueden coincidir con el volcado. La espera es hasta el silencio de la actividad, y un poco más, lo que tardas en convencerte de que el verde no va a dar otro latido. Entonces retiras el conector de alimentación, una vez, del todo. Un conector que se queda a medio sacar, haciendo y deshaciendo contacto, son muchos cortes seguidos. Eso corrompe más que un solo tirón. A medias, aquí, significa eso: quitar la corriente antes de que el cierre haya terminado, o quitarla a golpes de contacto flojo.

Si la placa no se calla y la imagen no se va, no insistas desenchufando «para ayudarla». Lee qué programa se quedó. Vuelve a pedir el cierre. Solo si de verdad no hay manera de obtener un halt, un único corte es menos daño que diez. Anota que ese día no apagaste bien, y al siguiente arranque mira si el sistema se queja de comprobar el disco. No regrabes la tarjeta por un solo susto si la placa vuelve y tus archivos abren.

Qué no es este aviso

Aviso. No es la red de 230 V. Es no desenchufar a medias. El daño de esta lección es una tarjeta con escrituras partidas, no una descarga de la red doméstica. La fuente que retiras entrega 5 V a la placa. Nada del curso se conecta a 230 V, ni el apagado se «arregla» con un enchufe de pared gobernado a ciegas. GPIO a 3,3 V. Físico 11 es GPIO 17. Los físicos 27 y 28 siguen reservados. Apagar no autoriza a cablear.

Tampoco es una lección de recuperar una tarjeta ya rota. Si un corte anterior dejó la placa sin arrancar, el arreglo no es repetir el corte. Esa copia de la tarjeta, cuando exista, será otra lección del índice. Hoy el mecanismo es no fabricar el fallo.

Una tarde que se acaba

Estás en la terminal. Has mirado whoami y pwd. No hay cables en el header. Quieres dejar la placa hasta mañana.

sudo shutdown -h now

Escribes tu contraseña. No aparece. Pulsas Enter. La sesión se cierra, el escritorio se despide, el verde da sus últimos parpadeos y deja de latir. Apagado, no fijo en un código que haya que memorizar. Cuentas un respiro largo. Retiras la alimentación. La placa ya estaba parada; la corriente era lo único que quedaba.

Lo que no hiciste: sync y tirar; sacar el conector en cuanto la pantalla se puso rara; pulsar el botón varias veces; desenchufar y enchufar para «ver si siempre arranca». Un ciclo de más, hoy, no enseña nada que esta página no haya dicho ya, y cada ciclo mal cerrado es una tirada de dados sobre la FAT de arranque.

Mañana das corriente otra vez, una sola vez, y esperas al escritorio como en la lección 7. Si vuelve, el apagado de ayer estaba bien. Si tarda lo de un primer arranque, también puede ser normal. Si no vuelve y el verde no late, entonces miras tarjeta y fuente, no inventas otro método de apagado.

Un corte que no parece un corte

No hace falta un dedo en el conector para dejar la escritura a medias. Una fuente corta, un cable que entra flojo o un latigazo en el enchufe de cinco voltios tiran la tensión un instante. Para la tarjeta es el mismo hecho: la alimentación desaparece mientras una celda se estaba programando. Por eso la fuente de esta placa tiene que ser la que aguanta el modelo, y el conector tiene que entrar del todo. Un apagado perfecto no compensa diez bajadas de tensión al día, y diez apagados perfectos no convierten en buena una fuente que se viene abajo cuando el sistema hace algo.

Si aun así un día se fue la luz, el arranque siguiente es la comprobación, no un castigo inmediato. Puede aparecer un aviso de que el sistema de archivos no se cerró en limpio y que se está releyendo el diario. Si el escritorio vuelve y tus archivos abren, tuviste suerte con ext4, no una prueba de que el método del tirón sea válido. Si vuelve en solo lectura, el sistema está protegiendo lo que queda: no sigas trabajando ahí como si nada, y no regrabes antes de copiar, desde otra máquina, lo que todavía se pueda leer. Esa copia de la tarjeta es otra lección del índice, todavía sin cuerpo. Esta solo deja dicho el síntoma para que no lo confundas con «Trixie se ha estropeado solo».

Lo que no es un síntoma de corrupción: una contraseña rechazada por el mapa del teclado, un ls que calla porque la carpeta está vacía, un primer arranque lento. Esos ya tienen su lección. El de aquí es un archivo que ayer tenía un tamaño y hoy tiene cero, o una placa que ya no encuentra su partición de arranque. Las dos cosas se evitan con el orden del esquema, no con un comando nuevo.

Ejercicio en la Pi

Si vas a terminar de verdad la sesión, ejecuta sudo shutdown -h now, espera al silencio de la actividad y solo entonces retira la fuente. Anota en papel las tres fases que viste: la orden, la espera, la corriente. No hagas un segundo ciclo para comprobar. No pongas cables. Si todavía necesitas la placa encendida para la lección siguiente, no lances el cierre: escribe en papel la orden exacta y qué observarías en el LED de actividad, y deja el desenchufado para cuando sí hayas terminado. Si no hay placa, ordena en una frase el mismo mecanismo y di qué se pierde si el tirón llega durante el volcado de la caché.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

El usuario lo creó el Imager: el nombre que escribiste es la cuenta que existe, whoami lo repite y tu sitio es /home seguido de ese nombre. No existe la cuenta pi con la contraseña raspberry: Trixie no la fabrica. Tampoco vives en root.

Quién creó la cuenta

En la lección 3 grabaste Raspberry Pi OS con el Imager. En esa grabación escribiste un nombre y una contraseña. No eran un adorno del asistente: el Imager los dejó en la tarjeta para que el primer arranque creara esa cuenta y su carpeta. El sistema de referencia, a 3 de octubre de 2026, es Raspberry Pi OS sobre Debian 13 Trixie. En esa imagen la cuenta ya nace con el nombre que tú diste. No nace con un nombre de fábrica.

Si dejaste el usuario en blanco y el primer arranque te lo preguntó en pantalla, la cuenta es la que respondiste ahí. El mecanismo es el mismo: alguien tuvo que elegir el nombre, y ese alguien fuiste tú, no un valor escondido en la imagen. whoami imprime ese nombre, letra por letra. Si no coincide con lo que recuerdas, no estás donde crees. No crees otra cuenta para forzar el recuerdo. Anota lo que whoami dice y usa ese nombre en el resto del curso.

La referencia de cuentas, grupos y de este sitio del sistema está en Software, el sistema. Aquí no se copia la ficha. Aquí se evita el error que esa ficha ya no perdona: presentarse en una Pi actual como si el nombre viniera puesto.

pi y raspberry no son una lección

Durante años las imágenes traían un usuario llamado pi y una contraseña pública, raspberry. Todo el mundo la sabía. Quien encendía el acceso remoto sin cambiarla dejaba la puerta con la llave en la cerradura, la misma llave en todas las placas. Esa cuenta por defecto se quitó. En Trixie no está. No hay un paso oculto de esta lección que la vuelva a crear.

Enseñarla es un fallo. Un tutorial que empieza por «usuario pi, contraseña raspberry» está hablando de otra época o de otra imagen. No se corrige obedeciéndolo. No se crea el usuario pi para que el tutorial encaje. No se pone esa contraseña «un momento, mientras pruebo». La contraseña pública sigue siendo pública: si más adelante abres una puerta de red, quien pruebe pares viejos los probará también en tu casa. Esta lección no abre esa puerta. SSH es otra lección, todavía sin escribir, y no se adelanta fabricando la cuenta que esos intentos esperan.

Si en el Imager elegiste precisamente ese nombre y esa contraseña, la imagen no te lo impidió: te dejó construir el agujero a mano. La cuenta entonces sí existe, porque tú la pediste, no porque Trixie la traiga. Cámbiala antes de cualquier acceso remoto. El nombre ya creado no se arregla con un tutorial. La contraseña de tu propia cuenta se cambia con passwd: pide la actual, luego la nueva dos veces, y no dibuja lo que tecleas. No hace falta ser root para cambiar la tuya. No uses passwd sobre otra cuenta.

whoami, la carpeta y el número

whoami responde una línea: el nombre efectivo, el de ahora. No responde la contraseña, ni el nombre de la máquina, ni si tienes permiso para sudo. Sirve para no discutir con el prompt. El prompt puede abreviar; whoami no.

whoami
pwd
echo $HOME
ls /home

pwd imprime la carpeta donde estás. Al abrir la terminal tiene que ser tu home: /home/ y, pegado, el mismo nombre que dio whoami. echo $HOME imprime esa ruta aunque te hayas movido. Si pwd y $HOME no coinciden, te has movido, no te has convertido en otra persona. Se vuelve con cd sin argumentos. ls /home enseña las carpetas de las cuentas humanas. En la placa de este curso se espera una: la tuya. Si aparece pi y tú no la creaste, alguien siguió el tutorial viejo. No entres ahí a trabajar.

Por debajo, el sistema no guarda personas: guarda números. id -u imprime el número de la cuenta con la que hablas. Root es el cero. Si sale cero, estás en root aunque una pista visual te confunda. Si sale cualquier otro número, no estás en root. El número concreto se lee en tu placa. No se copia de un ejemplo. El nombre es un rótulo de ese número. Dos rótulos no pueden ser la misma cuenta; un rótulo mal recordado no cambia el número.

Puedes leer el rótulo en el fichero de cuentas, sin editarlo:

getent passwd "$USER"

Verás tu nombre, un hueco donde iría la contraseña y no va, el número, el número del grupo primario, un texto libre que puede estar vacío, la ruta de tu home y el programa que se abre al entrar, el shell. En esta imagen ese programa es bash, el mismo que ya leía tus órdenes en la lección 8. Leer esa línea no cambia nada. Abrir el fichero con un editor y «corregirlo» sí puede dejarte fuera de la cuenta. No es el ejercicio.

Por qué no vives en root

Root es la cuenta del número cero. Existe porque el sistema tiene que hacer, en el arranque y en el cierre, cosas que una persona no debe hacer con la mano cada vez: montar discos, crear la red, parar servicios. Su carpeta es /root, no /home/root. Si pwd dice /root, te has sentado en la mesa equivocada.

El núcleo, cuando mira un permiso, hace una excepción con el cero: no le aplica la pared que sí te aplica a ti. Un rm mal escrito, un redirección a un fichero de /etc, un programa pegado que escribe donde no debe, en tu cuenta se topan con un «permiso denegado». En root ocurren. Esa pared es el motivo de tener dos identidades en una placa donde solo vive una persona. No es desconfianza hacia un segundo habitante. Es desconfianza hacia el siguiente comando, que puedes equivocar.

Hay un segundo coste, más lento. Lo que root crea queda de root. Un archivo nacido en tu home durante una sesión de root pasa a ser de root. Mañana tú, en tu cuenta, no puedes guardarlo. El atajo que se le ocurre a quien no ha hecho la lección 11 es volver a root para editar lo suyo. Cada vez la mesa está más llena de objetos que no puedes tocar sin préstamo. Trabajar siempre en tu usuario evita esa trampa. Los programas de las lecciones de Python, cuando lleguen, se lanzan así. Un script de GPIO tampoco pide ser root: lo dice la lección siguiente, y el voltaje del pin no cambia por ser el usuario cero. Sigue siendo 3,3 V.

El prompt lo cuenta si lo miras. Un peso o un dólar es una cuenta normal. Una almohadilla es root. No conviertas la almohadilla en la costumbre de «ir más rápido». sudo -i y sudo su abren esa sesión larga. No son el trabajo de hoy. No hay una contraseña de root que debas buscar en un foro para entrar «de verdad». Entrar como root con una clave copiada es el mismo fallo que la cuenta pública, con la pared ya quitada.

Qué es tuyo y qué no se toca

Dentro de /home y de tu nombre puedes crear carpetas y archivos sin préstamo. Fuera, casi todo es del sistema. Puedes leer mucho: el fichero de cuentas, /etc/os-release, la lista de /home. Leer no es vivir ahí. No guardes apuntes en /etc, ni en /root, ni en /boot/firmware. Esos sitios siguen siendo el pasillo y el arranque. Tu mesa es la única que esta lección te autoriza a usar.

Las mayúsculas del nombre importan igual que en ls. El nombre que diste en el Imager es el que hay. Inventar una variante con la inicial en mayúscula crea la idea de una segunda cuenta que no existe, y el sistema responderá que no está. No es que te haya expulsado.

Tampoco hace falta un segundo usuario «para los experimentos». Un experimento que cabe en una carpeta de tu home cabe en tu cuenta. Crear usuarios es una operación de root y no está en el ejercicio. Si algún día hay dos personas en la misma placa, cada una tendrá su /home y sus permisos; eso se apoya en la lección 12, y no se improvisa clonando pi.

Cómo se reconoce una sesión equivocada

Tres lecturas bastan, y ninguna escribe.

whoami
id -u
pwd

Nombre distinto del Imager: no sigas, mira si abriste otra sesión. Número cero: sal con exit hasta volver a un prompt con peso, y comprueba otra vez. Ruta /root o ruta /home/pi: no crees archivos ahí. Vuelve a tu home con cd y confirma con pwd.

Una sesión buena, con el nombre de ejemplo ana, se ve así. Si tu nombre es otro, cambia la palabra, no el mecanismo.

ana@pi-casa:~ $ whoami
ana
ana@pi-casa:~ $ id -u
1000
ana@pi-casa:~ $ pwd
/home/ana
ana@pi-casa:~ $ ls /home
ana

El 1000 de este ejemplo es un número posible del primer usuario en Debian, no una cita que tu placa deba obedecer. Si id -u te da otro número que no sea cero, la lectura es la misma: no eres root. Lo que no puede salir, en una imagen limpia de este curso, es pi en whoami.

Aviso. Estar en tu usuario no vuelve seguro un cable. GPIO a 3,3 V. El físico 11 es el GPIO 17. Los pines 27 y 28 no se usan. No hay cuenta mágica que autorice 5 V en un GPIO, y no hay nada de 230 V en esta lección.

La contraseña no vive donde se lee el nombre

El fichero que getent passwd consulta tiene un campo para la contraseña y en ese campo no está la contraseña. Suele haber una marca que significa «no se guarda aquí». El secreto está en otro fichero, el de las sombras, y tu usuario no puede leerlo. Si lo intentas, el sistema responde que el permiso no alcanza. Esa negativa es la pared de la que habla esta lección, funcionando. No se salta con sudo para «ver cómo es un hash». No necesitas el hash para trabajar, y sacarlo a una foto o a un papel es regalar el material con el que se prueba una contraseña débil.

Cuando inicias sesión, el escritorio o la terminal comprueban el nombre contra la lista de cuentas y la contraseña contra ese secreto. Si encajan, arrancan una sesión con tu número, colocan HOME en tu carpeta y abren bash. Si no encajan, no crean una cuenta nueva para consolarte: dicen que no. Una contraseña rechazada, con el teclado bien elegido desde la lección 7, es una contraseña distinta, no una placa rota. Nada de eso regraba la tarjeta.

La contraseña no se vuelve a preguntar en cada whoami. Se preguntó al entrar, o al arrancar el escritorio. Las órdenes de esta lección no la piden. Si una orden la pide, no es de las de hoy, salvo passwd si de verdad tienes que retirar la contraseña pública. En ese caso la falta de eco sigue siendo normal.

Sesión, cuenta y nombre de la máquina

La cuenta es el número y el nombre, y dura aunque apagues. La sesión es esta conversación, y se acaba con exit o al cerrar la ventana. Puedes abrir dos terminales. En las dos, whoami dice lo mismo, porque las dos sesiones son tuyas. Cerrar una no borra el usuario. Apagar bien, como en la lección 9, tampoco borra el usuario: al volver, la cuenta sigue y la sesión es nueva.

En el prompt, lo que va antes de la arroba es el usuario y lo que va después es la máquina. Confundirlos produce un whoami «raro» que en realidad es el nombre de la Pi. El nombre de la máquina lo elegiste quizá en el Imager, o lo trae un valor generado. No es una segunda cuenta. No se usa para entrar. Cambiar de carpeta no lo cambia, y cambiarlo no es esta lección: vive en el sistema, no en tu home, y tocarlo pide el préstamo que todavía no hemos separado.

ls sin más esconde los nombres que empiezan por punto. ls -a los enseña. En una cuenta nueva pueden estar los ficheros con los que bash arranca y las carpetas . y .., que significan «aquí» y «el nivel de arriba». No son basura y no se borran para «dejar la home limpia». Son la configuración de tu sesión. Tu trabajo de las prácticas, cuando lo crees, será un nombre sin punto, visible con ls a secas, dentro de esta misma carpeta.

Qué pasa si el nombre ya no te gusta

Regrabar la tarjeta para cambiar el nombre borra el sistema entero. No es un renombrado: es la lección 3 otra vez, con la tarjeta vaciada. No se hace a mitad de este bloque. Renombrar una cuenta ya creada mueve el número, la carpeta y el dueño de los archivos, y un paso a medias te deja sin poder entrar. Por eso esta lección no da esa orden. Si el nombre funciona y no es pi, se queda. Si es pi porque lo pediste tú, el arreglo urgente es la contraseña, con passwd, no un experimento de renombrado el mismo día que aprendes a no ser root.

Tampoco se clona la cuenta «por si rompo algo». Lo que puedes romper de tu trabajo cabe en una carpeta. Copia el archivo, no la identidad. La identidad tiene un número, una home y, en la lección 12, unos grupos que groups imprimirá en tu placa. Esta página no adelanta esa lista. Si un texto la adelanta con cinco nombres fijos, está inventando la tuya.

Comprueba por último que tu home es una carpeta y que tú eres quien la posee, sin cambiarle nada:

ls -ld "$HOME"

Verás una d al principio, porque es un directorio, y tu nombre en el puesto del dueño. Los permisos concretos se leen en la lección 12. Si el dueño que sale no es el de whoami, no empieces a crear archivos: estás mirando la casa de otra cuenta, o la tuya ha quedado en manos de root por una sesión mal usada. Se anota y se pregunta el motivo antes de prestar sudo para «arreglarlo». Un chown a ciegas es cómo una casa queda peor.

Ejercicio en la Pi

Abre la terminal. Ejecuta whoami, id -u, pwd, echo $HOME y ls /home. Comprueba que el nombre es el del Imager, que el número no es cero, que la ruta cuelga de /home y que no aparece una cuenta pi que tú no hayas pedido. Anota el nombre y la ruta en el mismo papel de la lección 8. No crees usuarios. No cambies la contraseña si ya no es la pública de los tutoriales viejos. No abras sudo -i. Si no hay placa, escribe la sesión de ejemplo con tu propio nombre en vez de ana y tacha el sitio donde un tutorial pondría pi.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

sudo presta el poder de root para una orden, y al terminar devuelve el prompt a tu usuario. La contraseña que pide es la tuya. La orden privilegiada es la excepción: si no sabes decir en voz alta por qué esta línea la necesita, no lleva sudo.

Un préstamo de una línea

En la lección 10 te quedaste en tu número, el que no es cero. Algunas órdenes tienen que cruzar la pared: parar la máquina, instalar un programa para todo el sistema, cambiar un fichero de /etc. Para eso existe sudo. Se escribe delante de una orden. El sistema pide tu contraseña, ejecuta esa orden con el número cero, y la siguiente línea vuelve a ser tuya. No te muda a /root. No cambia lo que dirá whoami después.

whoami
sudo true
whoami

true es un programa que acierta y no hace nada. Con sudo delante, lo único que ocurre es el préstamo: se comprueba tu contraseña y se devuelve el prompt. El segundo whoami tiene que repetir tu nombre, no root. Si dice root, no usaste un préstamo de una línea: abriste una sesión de root y hay que salir con exit.

La contraseña es la del Imager, la de tu cuenta. No es una contraseña distinta llamada «la de sudo», y no es una contraseña de root que haya que buscar. Mientras la escribes no hay puntos ni asteriscos. Parece que el teclado se ha muerto. No se ha muerto: el secreto no se dibuja, ni siquiera en longitud. Pulsas Enter. Si fallas, sudo te da más intentos y, si siguen fallando, no ejecuta la orden. La placa no se corrompe por una contraseña mal puesta. Se queda como estaba.

Durante un rato, en esa misma terminal, puede no volver a preguntar. Es una comodidad de la sesión, no un ascenso permanente. No cuentes con ella para encadenar órdenes a ciegas, y no la interpretes como «ya soy root». Otra ventana puede pedir la contraseña otra vez. Si quieres ver el pregunta de nuevo a propósito, sudo -k olvida ese rato. No apaga nada. Solo retira el recuerdo de que ya demostraste ser tú.

El sitio de la referencia para la cuenta y este préstamo es Software, el sistema. La ficha no sustituye al criterio. El criterio es el de esta página.

Cuándo sí

Sí, cuando la orden cambia el sistema entero o lo detiene, y tu usuario de número distinto de cero recibe un permiso denegado por una razón de pared, no por un nombre mal escrito.

Apagar es el caso que ya ejecutaste o que tienes anotado: sudo shutdown -h now. Parar todos los programas y desmontar no es un derecho de una carpeta personal. El préstamo aquí es la lección 9, no un adorno.

Instalar o quitar un paquete para toda la placa también lo es. Esa orden llegará en la lección del apt, no hoy. El motivo, adelantado solo para reconocerlo, es que un paquete escribe fuera de tu home, en sitios compartidos por cada cuenta y por el propio arranque. Tu usuario no puede, y no debe, hacerlo con la mano.

Editar un fichero que no es tuyo, bajo /etc, es el mismo caso. Hoy no se edita ninguno. El día que haga falta, el préstamo cubre la orden que escribe, no un paseo largo con el prompt en almohadilla «por si acaso hay que tocar algo».

Antes de escribir sudo, di la frase: «esta orden tiene que modificar el sistema compartido, o pararlo, y mi cuenta sola no puede». Si la frase sale forzada, la orden no va con préstamo.

Cuándo no

No, en todo lo que ya sabes hacer en tu mesa. whoami, pwd, ls, cd, echo hacia un archivo de tu home, mkdir en tu home, cat de un archivo tuyo. Si delante de esas pones sudo, o no cambia el resultado, o lo empeora: el archivo que nazca nacerá de root y mañana no podrás guardarlo.

No, en un programa de Python que vive en tu carpeta. Se lanza con python3 y el nombre del archivo. El bloque de Python todavía no está escrito; el criterio sí: el intérprete no pide el número cero por ser un intérprete.

No, en un script de GPIO. La placa está preparada para que la cuenta que usa el header pueda abrir el dispositivo de los pines sin ser root. Un programa que enciende el GPIO 17, el físico 11, se ejecuta como tú. Ponerle sudo porque «es hardware» es el reflejo que esta lección corta. El hardware tiene su propio límite, y no es el de las cuentas: la señal es de 3,3 V. Root puede escribir un uno lógico igual que tú, y root no convierte el pin en una salida de 5 V ni lo vuelve indestructible. Si metes 5 V en ese GPIO, el pin se quema siendo root o no siéndolo. El permiso del programa y el voltaje son dos paredes distintas. Saltarse la primera no refuerza la segunda.

Si un script de pines falla, lees la frase. Si dice que no encuentra el archivo, es la ruta o las mayúsculas, como en la lección 8, y sudo no inventa archivos. Si dice que el permiso no alcanza, el arreglo no es acostumbrarte a root: es la lección 12, los grupos, y se mira lo que hay en tu cuenta en vez de borrar la pared. Un fallo de cableado tampoco se cura con sudo. El LED que no enciende puede ser la resistencia, el pin físico equivocado o la masa. Ninguno de esos tres cambia porque la orden lleve préstamo.

Tampoco lleva sudo el chmod de un archivo que ya es tuyo. Puedes cambiar sus permisos porque eres el dueño. Lo verás en la lección siguiente, y verás también el modo que no se usa. Adelantar sudo chmod sobre tu home es cómo se deja uno sin poder entrar en su propia carpeta.

La orden privilegiada es la excepción

No voy a decirte qué frase queda registrada, ni en qué fichero, ni cuánto tiempo se conserva. Inventarlo aquí sería darte un registro falso. Lo que sí es regla, y te basta para trabajar: la orden privilegiada es la excepción. El día normal, en esta placa, no lleva sudo. El día que lo lleva, es una línea que sabes justificar, rodeada de líneas que no lo llevan.

Esa excepción se defiende sola si es rara. Si todo lleva sudo, ya no hay excepción: hay una sesión de root disfrazada de líneas sueltas, y el daño de un pegado se parece al daño de trabajar en el cero. Por eso el reflejo de «si falla, lo repito con sudo» es el fallo de la lección, más grave que el fallo original. El original decía la verdad. El reflejo la tapa.

Tampoco hace falta una libreta paralela de «qué anota el sistema» para decidir. Decides antes de pulsar Enter, no después mirando un rastro que esta página no describe. Si no puedes explicar el préstamo, no lo pides. Si puedes explicarlo, lo pides una vez, compruebas el resultado y vuelves a tu prompt.

Lo que sudo no cubre de la línea

El préstamo es el programa que sudo ejecuta, no toda la frase que escribió el teclado. El shell, que eres tú, prepara la línea antes. Las redirecciones las hace él. Este caso se ve mucho y se lee mal:

sudo echo hola > /etc/hostname

El shell, con tu número, intenta abrir /etc/hostname para escribir el resultado. No puede. La queja sale antes de que sudo preste nada útil, o sale del sitio equivocado: el echo privilegiado escribe en un flujo que tu shell ya intentó conectar. El síntoma es un permiso denegado que no se cura repitiendo la misma línea. Y no se cura tampoco abriendo una sesión de root para redirigir a mano «hasta que calle».

Hoy ese fichero no se toca. El ejemplo está para leer el límite, no para cambiar el nombre de la máquina. Cuando de verdad haya que escribir fuera de casa, se usará una orden cuya escritura ocurra dentro del programa prestado, en la lección que corresponda, no un atajo aprendido a medias. Si lo ves en un tutorial como primer paso, el tutorial te está entrenando el reflejo que aquí se prohíbe.

La sesión larga no es un sudo

sudo -i, sudo su y sudo bash no prestan una orden. Abren un shell cuyo número es cero, con la casa en /root y la almohadilla en el prompt. Todo lo que escribas después va prestado, incluidos los errores, hasta que salgas. No es «sudo más cómodo». Es irte a vivir donde la lección 10 dijo que no se vive.

Se reconoce en cuanto miras. whoami dice root. id -u dice 0. pwd puede decir /root. La salida es exit, una vez por cada puerta que abriste, y otra vez whoami hasta que vuelva tu nombre. No apagues desde esa confusión si no sabes en qué sesión estás: primero vuelve a ti, luego, si toca terminar, la orden de la lección 9, que sí es un préstamo de una línea.

Un programa que dejas corriendo con el préstamo sigue en cero aunque cierres la tapa de la terminal mal. Por eso un blink «de prueba» con sudo es peor que el mismo blink sin él: el proceso es privilegiado, los ficheros que cree serán de root, y tú habrás aprendido el gesto al revés. El curso, cuando encienda un LED, lo encenderá sin ese gesto.

Permiso denegado no es una sola enfermedad

La frase de permiso denegado sale por motivos distintos y el préstamo solo responde a uno.

Estás fuera de tu home, escribiendo donde el sistema se protege. Puede ser un caso de «cuándo sí», si de verdad esa era la tarea. Casi nunca lo es en estas lecciones. Vuelve a tu carpeta.

El archivo es tuyo en la ruta pero el dueño es root, porque ayer lo creaste prestado. ls -l enseña el dueño. El arreglo de fondo es no repetir la causa. No se recorre el home con un préstamo masivo «para dejarlo todo mío»: un error de ruta en esa orden recorre el sistema. Se anota el archivo concreto y se pide criterio, no prisa.

El dispositivo del pin no se abre. Antes de prestar nada, confirma que el programa es el del curso y que lo lanzas como tú. Los grupos que te permiten o no ese dispositivo se miran en la lección 12, con el comando que los imprime en tu máquina. Esta lección no trae la lista.

El nombre del comando está mal. sudo de un nombre que no existe sigue sin existir. La respuesta cambia de sitio: ahora el que no encuentra la orden es el entorno privilegiado, y la causa es la misma que LS en la lección 8. Corriges las mayúsculas. No instalas nada todavía.

Aviso. sudo no es un guante eléctrico. Un GPIO sigue a 3,3 V. El físico 2 y el físico 4 son 5 V de alimentación, no señal, y ningún préstamo los convierte en GPIO. Los físicos 27 y 28 siguen reservados. Nada de 230 V. Y la orden privilegiada, se repite porque es toda la regla de registro que vas a sacar de aquí, es la excepción: no inventes un parte de lo que quedó apuntado.

Quién puede pedir el préstamo

No todas las cuentas pueden. Hay una política del sistema que dice a quién se le presta el cero y para qué órdenes. La cuenta que creó el Imager en Raspberry Pi OS queda autorizada a pedir ese préstamo: si no, no habrías podido ni plantearte el apagado de la lección 9. Una cuenta nueva, el día que exista, no hereda ese derecho solo por existir. Esta página no copia la política ni inventa sus líneas. Si quieres leer la tuya, la orden es sudo -l. Imprime lo que esta placa permite, te pedirá la contraseña si el recuerdo se ha ido, y no cambia ningún fichero. Lo que salga se lee. No se compara contra un texto de aquí, porque aquí no está.

Esa autorización sigue sin ser una sesión. Poder pedir el préstamo y vivir en root son estados distintos. El primero es una llave que sacas para una cerradura. El segundo es dejarte la llave puesta y la puerta abierta mientras escribes ls. El curso usa la llave. No deja la puerta abierta.

El programa prestado, además, no recibe tu entorno entero. La lista de carpetas donde se buscan los comandos puede ser más corta que la de tu prompt. Por eso a veces alguien dice «solo me funciona con sudo»: el programa se encontraba por un camino de tu sesión y, prestado, no se encuentra, o se encuentra otro. El reflejo de dejar el sudo puesto esconde el camino roto. Se mira el error sin préstamo, en tu home, con pwd y el nombre exacto. Si hace falta un paquete del sistema, eso será apt con préstamo, en su lección, no un prefijo eterno.

Leer el resultado y volver

Después de una orden prestada que sí tocaba —hoy, como mucho, sudo true o el apagado cuando termines— miras el resultado antes de hacer otra cosa. true no imprime nada y devuelve el prompt: eso es el éxito de un programa que no tiene nada que decir. Un permiso denegado, un «orden no encontrada» o una espera que no termina son tres resultados distintos. El primero se diagnostica con la sección anterior. El segundo se corrige en el nombre. El tercero no se mata quitando la corriente: si fuera el apagado, se espera como en la lección 9; si fuera cualquier otra orden colgada, se interrumpe con la tecla de corte de la terminal, Control y C, que pide al programa que pare. No es un apagado. No es un sudo. Es dejar de ejecutar esa línea.

Cuando el prompt ha vuelto, whoami cierra la comprobación. Tu nombre, tu número distinto de cero, tu carpeta si haces pwd. Si los tres encajan, el préstamo se devolvió. Si no encajan, no sigas creando archivos: exit y comprueba de nuevo. La excepción ya pasó. El resto de la tarde es tu cuenta.

Ejercicio en la Pi

Sin apagar todavía. Ejecuta whoami. Luego sudo -k y sudo true. Escribe tu contraseña cuando la pida y fíjate en que no se dibuja. Cuando vuelva el prompt, whoami otra vez: tiene que ser el mismo nombre. No lances sudo -i. No pongas sudo delante de ls ni de un programa de pines. En el papel, haz dos columnas. En la del sí, escribe la orden de apagado de la lección 9 y anota que instalar un paquete, cuando toque, también cae ahí. En la del no, escribe whoami, un python3 de un archivo de tu home y el blink del GPIO. Si no hay placa, dibuja la misma línea de tiempo del esquema: tú, una excepción, tú otra vez, y el blink fuera del recuadro prestado.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Cada archivo tiene un dueño, un grupo y el resto del sistema, y se ven con ls -l. En un archivo tuyo, chmod go-r le quita la lectura al grupo y a los otros, y chmod go+r la devuelve. No se usa chmod 777; el comando groups imprime tus grupos en la placa.

Tres cajones, no una nube de derechos

La lección 10 separó tu número del cero. La 11 dijo cuándo se presta el cero. Esta dice qué puedes hacer sin prestarlo, y por qué. Un archivo en Linux no está «abierto» o «cerrado». Tiene un dueño, que es un usuario, y un grupo, que es un conjunto de usuarios, y nueve marcas: tres para el dueño, tres para quien esté en ese grupo sin ser el dueño, y tres para cualquier otra cuenta. Las tres marcas, en ese orden, son leer, escribir y ejecutar.

En el listado se ven juntas. Crea un archivo de práctica en tu home, no fuera:

cd
echo hola > notas.txt
ls -l notas.txt

Una línea posible, si tu usuario de ejemplo se llamara ana, sería esta. La tuya cambia el nombre, el tamaño y la fecha. No cambies el ejemplo para que encaje: lee la tuya.

-rw-r--r-- 1 ana ana 5 oct  3 01:10 notas.txt

La primera letra no es un permiso. Es el tipo. Un guion es un archivo. Una d es un directorio. Después vienen nueve marcas, de tres en tres. rw- del dueño: puede leer y escribir, no ejecutar. r-- del grupo: solo leer. r-- de los otros: solo leer. El primer ana es el dueño. El segundo ana es el grupo del archivo. En Debian, y por tanto en Raspberry Pi OS Trixie a 3 de octubre de 2026, lo habitual al crear un archivo es que ese grupo se llame como tú. Es un grupo privado de tu cuenta, no una prueba de que estés solo en el sistema. Si en tu listado el grupo es otra palabra, no está roto: es el grupo primario de esa sesión, y manda lo que imprime la placa, no este ejemplo.

El número que sigue a los permisos es cuántos nombres apuntan a ese archivo. En un archivo recién creado es 1. No es un permiso y no se cambia con chmod. Luego el tamaño en bytes, la fecha y el nombre.

La misma lectura en cifras, por si el listado te la pide. Leer vale cuatro, escribir dos, ejecutar uno. Se suman dentro de cada cajón. Dueño: cuatro más dos, seis. Grupo: cuatro. Otros: cuatro. Por eso a este archivo se le dice 644. No hace falta que uses la cifra para el ejercicio. Hace falta que sepas leerla cuando un texto te la tire encima, y que reconozcas la que no vas a usar.

El chmod que se deshace

El cambio concreto de esta lección, sobre notas.txt y sobre ningún otro sitio, es quitar la lectura al grupo y a los otros, mirar, y devolverla.

chmod go-r notas.txt
ls -l notas.txt
chmod go+r notas.txt
ls -l notas.txt

g es el grupo, o son los otros, u sería el dueño y no lo tocas. El signo menos quita una marca. El signo más la pone. r es la lectura. go-r quita la lectura en los dos cajones que no eres tú. Si partías de rw-r--r--, te quedas en rw-------, que en cifras es 600: el dueño lee y escribe, y nadie más lee. go+r pone otra vez esas dos lecturas. El tercer ls -l tiene que coincidir con el primero en las nueve marcas. Si no coincide, cambiaste algo más; no sigas sumando chmod hasta que se parezca. Vuelve a leer la línea y deshaz solo lo que sepas nombrar.

Este par es reversible porque cada orden es la inversa de la otra, hecha sobre el mismo archivo, sin tocar el dueño y sin tocar el bit de escritura. No es reversible porque exista un deshacer universal. No existe. La inversa la escribes tú, y solo funciona si recuerdas de dónde saliste. Por eso el primer ls -l no se salta: es el original, y el papel donde lo copias vale más que la memoria.

Sirve para un archivo tuyo. Si el dueño es otro, chmod te dirá que no puedes, y esa negativa se respeta. No se llama a sudo chmod para ganar la discusión. Un archivo de root en tu home es la herencia de la lección 11, no un ejercicio de modos.

Por qué no es 777

chmod 777 pone lectura, escritura y ejecución en los tres cajones. En cifras: siete es cuatro más dos más uno, tres veces. En marcas: rwxrwxrwx. Cualquier cuenta escribe, cualquier cuenta ejecuta. No es «abrirlo para que funcione». Es publicar el archivo a todos los usuarios de la máquina, humanos o no, y además marcarlo como programa.

En una Pi donde crees estar solo, «otros» no está vacío. El sistema tiene cuentas que no son personas, las que usan los servicios. Esas cuentas caen en «otros» cuando no son el dueño ni están en el grupo del archivo. Un 777 les deja escribir tu nota, sustituirla o, si es un programa, colocar otra cosa en su lugar. Que nadie se siente en el escritorio no apaga esas cuentas.

El bit de ejecución en un texto es un mentira añadida. notas.txt no es un programa. Marcarlo ejecutable no lo vuelve uno, y en un directorio el efecto de las marcas es otro, así que copiar 777 «a todo» cambia también el sentido de entrar en las carpetas. El reflejo de 777 se aprende en un apuro y se pega después en una clave, en un script o en la propia home. Aquí no se escribe esa orden, ni en cifra ni en letras a+rwx, que es el mismo modo con otro disfraz.

Si un programa no arranca, las causas de este tramo del curso son el nombre, la ruta, la cuenta y, cuando toque, un grupo. No el siete siete siete. Si un archivo tuyo no se lee, primero mira si estás en la carpeta y si el dueño eres tú. El par go-r y go+r enseña a mover una marca. No enseña a abrir todas.

Carpetas, y el ejecutar que no ejecuta

En un directorio, la r deja listar los nombres, la w deja crear y borrar nombres dentro, y la x deja atravesarlo: entrar, y alcanzar lo que hay dentro si conoces el nombre. Sin x, la carpeta no se cruza aunque te sepas el archivo de memoria. No es el ejecutar de un programa. Es el permiso de paso.

Por eso el ejercicio es un archivo, no tu home. Tu home necesita que tú puedas cruzarla. Quitarle marcas «para probar» te deja fuera de tu propia mesa, y recuperarla ya pide un préstamo y un camino que esta lección no va a dictar a medias. No hagas chmod de $HOME. No hagas chmod con -R, que recorre hacia abajo y multiplica el error. No lo hagas sobre /, ni sobre /etc, ni sobre /boot/firmware. Un modo mal puesto en el arranque impide volver a encender el sistema, y no hay 777 que lo salve: lo empeora.

Un archivo nuevo y un directorio nuevo no nacen con las mismas marcas, y no nacen con 777. La máscara de creación habitual retira la escritura del grupo y de los otros. Un archivo parte de un molde sin ejecución y queda en rw-r--r--. Un directorio parte de un molde con paso y queda en rwxr-xr-x, el 755, porque sin la x no podrías entrar. Si tu ls -l de notas.txt no es 644, no fuerces el ejemplo: anota lo que salió. La máscara se puede haber cambiado. El mecanismo se comprueba con el listado, no con la fe en el 644. El par de esta lección sigue siendo válido como inversa solo si devuelves exactamente las marcas que quitaste.

groups imprime los tuyos, y esta página no

Un grupo es un nombre que agrupa cuentas para el cajón del medio. En vez de dar permiso usuario por usuario, se da al grupo, y quien está en él lo recibe. Tu cuenta está en unos cuantos. Cuáles son no lo sé desde aquí, y no voy a rellenar la lista con los de una imagen de ejemplo. Sería mentira el día que la tuya no coincida, y es justo el vicio que el curso está cortando.

groups

Sin argumentos, groups imprime los grupos de la cuenta actual, nombres separados por espacios. Esa línea es tuya. Se copia al papel al lado del whoami. No se corrige para que se parezca a un foro. No se memoriza de otra placa. Si la repites mañana y ha cambiado, algo añadió o quitó una pertenencia; se investiga el motivo, no se restaura a ojo.

groups con un nombre de otra cuenta pide ver los grupos de esa cuenta. Hoy no hay otra cuenta que mirar. No lo uses con pi: o no existe, y el error es ese, o alguien la creó, y curiosearla no es el ejercicio.

El cajón del grupo, en el archivo, no significa «todos tus grupos». Significa el grupo que ls -l escribe en esa línea, uno solo. Tú encajas en ese cajón si ese nombre está entre lo que imprimió groups. Si no está, caes en «otros» aunque tengas muchos grupos. Por eso copiar la línea de groups y copiar el grupo de ls -l son dos apuntes distintos. Confundirlos produce un chmod al cajón equivocado.

Hay dispositivos, el de los GPIO entre ellos, cuyo permiso de paso suele ir por grupo y no por ser root. Es el motivo de fondo de la lección 11: un script de pines puede abrir el dispositivo porque tu cuenta está en el grupo que la placa preparó, no porque hayas prestado el cero. Si estás o no estás es, otra vez, lo que groups diga en tu máquina. Si un texto te asegura cinco nombres fijos, incluido el del pin, sin haberlos leído ahí, está inventando la lista. No los añadas a mano en esta lección. Añadir un grupo es una operación privilegiada y, mal hecha, es cómo se mete una cuenta en un sitio que no le corresponde. Si el script no abre el pin, se anota la frase de error y el resultado de groups. No se pasa a 777 ni a sudo.

La referencia de este mecanismo, sin la lista de tu placa, está en Software, el sistema.

Dueño, grupo y otros en una frase que se pueda comprobar

Dueño: el usuario que ls -l pone primero. En tu archivo de práctica tiene que ser el de whoami. Puede leer y escribir. No hace falta que el archivo sea ejecutable.

Grupo: el nombre que va justo después del dueño. Quien pertenezca a ese grupo, y no sea el dueño, recibe solo las tres marcas del medio. En el archivo recién creado, leer. Después de go-r, ninguna. Después de go+r, leer otra vez.

Otros: toda cuenta que no sea el dueño y no esté en ese grupo. Incluye las cuentas de servicio. En el archivo recién creado pueden leer notas.txt, no escribirlo. Es un apunte de cinco bytes con la palabra hola. Que otros lo lean no es un drama. El drama sería que pudieran escribirlo, y es lo que un 777 les regala junto con la ejecución. El ejercicio no necesita esconder el apunte, pero te deja el gesto por si el archivo del futuro sí es privado: go-r, comprobar, y go+r si lo que querías era volver.

Puedes ver marcas raras en archivos del sistema: una s donde iría una x, o una t al final de un directorio compartido. Son mecanismos de paso privilegiado y de directorio restringido en el borrado. No se copian a notas.txt. No se buscan en esta lección las cifras que los encienden. Verlos en ls -l de un fichero que no es tuyo significa «no es de esta práctica».

Cambiar el dueño o el grupo del archivo es otra orden, chown, y en la práctica pide préstamo en cuanto el destino no es tuyo. Hoy no se usa. El dueño correcto se consigue creando el archivo como tú, no corrigiéndolo después.

Aviso. Un modo mal abierto no autoriza un cable. GPIO a 3,3 V. Físico 11, GPIO 17. Físicos 27 y 28 quietos. chmod no se aplica a un pin, y 777 no se aplica a nada de esta lección. Sin 230 V.

Del listado al papel, sin saltarte el original

Haz la secuencia de una vez y no borres el archivo hasta haber comparado las tres líneas. Primera: ls -l notas.txt recién creado. Segunda: después de chmod go-r notas.txt. Tercera: después de chmod go+r notas.txt. La primera y la tercera coinciden en las nueve marcas. La segunda solo conserva las tres del dueño, rw-, y el resto son guiones, si partías del molde habitual. Si la segunda muestra una w en el grupo, es que el original ya tenía escritura de grupo: go-r no toca la w. La inversa correcta sigue siendo go+r, que devuelve la lectura y no quita esa escritura que tú no quitaste. No «limpies» esa w con un 600 escrito de memoria si no estaba en el plan: estarías cambiando otro bit, y la vuelta ya no sería la inversa.

Al lado, la línea entera de groups. Si en ella no reconoces una palabra, no la borres del papel y no la busques para eliminarla del sistema. Un grupo que no conoces puede ser el que abre un dispositivo que usarás dentro de unas lecciones. Quitarlo ahora, con una orden privilegiada sacada de un buscador, es cómo el blink futuro falla y el reflejo pide sudo. Se anota. Se pregunta cuando el error exista. No se adelanta.

El archivo notas.txt puede quedarse. Son cinco bytes en tu home, que es donde la lección 8 dijo que viven los apuntes. No lo muevas a la partición de arranque para «tenerlo a mano si el sistema no entra». Ahí estorba, y además un chmod de práctica no tiene nada que hacer en una FAT de arranque, que ni siquiera guarda los permisos de la misma manera. Si quieres tirarlo al acabar, rm notas.txt borra ese archivo y solo ese, escrito el nombre entero, sin asteriscos y sin sudo. Si dudas del nombre, no lo borres: un apunte de más no corrompe la tarjeta. Un rm con un espacio de más, sí puede llevarse otra cosa. En la duda, se queda.

Ejercicio en la Pi

En tu home, crea notas.txt con la línea echo hola > notas.txt. Anota el ls -l original. Ejecuta chmod go-r notas.txt, anota el segundo listado, ejecuta chmod go+r notas.txt y anota el tercero. Comprueba que las nueve marcas del tercero son las del primero. Ejecuta groups sin argumentos y copia la línea al papel sin corregirla contra ningún ejemplo, porque esta página no trae la lista. No hagas chmod de la carpeta. No uses 777. No uses sudo. No borres con asteriscos. Si no hay placa, escribe las tres líneas de permisos que saldrían partiendo de rw-r--r-- y deja en blanco, a propósito, la línea de grupos.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Un servicio es un programa que el sistema vigila por ti. Para saber si está vivo no lo paras: la orden es systemctl status y el nombre de esa unidad, y lees la línea Active. Status pregunta. No mates servicios del sistema a ciegas.

Qué estás mirando cuando dices «servicio»

En Raspberry Pi OS, a 3 de octubre de 2026, el arranque lo organiza systemd, el mismo que trae Debian 13 Trixie. Un servicio es una unidad: un fichero de instrucciones con un nombre, casi siempre acabado en .service, que dice qué programa lanzar, con qué usuario y cuándo. El programa es el proceso. La unidad es la ficha. systemctl es la herramienta que lee esa ficha y el estado que systemd guarda en memoria.

No confundas la ficha con el proceso. La ficha puede existir y el proceso no estar corriendo. El proceso puede haber terminado hace horas y la ficha seguir en el disco para el próximo arranque. Preguntar «¿está vivo?» es preguntar por el proceso de ahora, no por si el fichero existe ni por si arrancará mañana. Lo de mañana es la lección 14. Hoy se mira el ahora.

La orden de esta lección es:

systemctl status NOMBRE

NOMBRE lo pones tú. Si la unidad se llama con el sufijo, puedes escribirlo. Si omites .service, systemd prueba ese sufijo. No omite el nombre entero. Sin nombre, systemctl status habla del gestor del sistema, no de un catálogo para memorizar. No recorras nombres «a ver cuáles suenan». Esta página no enumera los servicios de la placa, porque la lista sería la de otra tarjeta, otro día, otros paquetes. La que vale es la que sale cuando preguntas por un nombre que ya conoces: el de una unidad que tú has creado, o el que un fallo te ha escrito en la pantalla. Si no tienes el nombre, no tienes todavía una pregunta.

El detalle de referencia, el de consultar y no el de aprender a leer la línea, está en Software, el sistema. Aquí está el criterio: status no se usa para apagar cosas.

La línea que de verdad responde

La salida es un bloque corto. Arriba, un punto o una marca de color y el nombre. Luego Loaded, que dice si systemd ha leído la ficha y desde qué ruta, y si esa ficha está enganchada al arranque o no. Luego Active, que es la respuesta de hoy. Más abajo puede salir el identificador del proceso principal y unas líneas recientes del registro. Esas líneas se leen en la lección 16. No las borres desde aquí. No las confundas con la respuesta: la respuesta es Active.

Traduce solo estas palabras, que son las que vas a ver, no un inventario de unidades:

Activo. La línea dice active (running). El proceso principal sigue ahí. El servicio está vivo en el sentido llano: hay alguien ejecutando lo que la ficha pidió. También es activo active (exited). Eso aparece en trabajos de una sola vez: el programa arrancó, hizo su tarea y salió con bien. systemd lo cuenta como éxito, no como muerte. Leer «exited» y concluir que está roto es el error de no mirar el paréntesis junto a active. Si dice active, no está muerto.

Esperando. La línea dice active (waiting). La unidad está viva y su trabajo, ahora mismo, es esperar: un dato, una conexión, un dispositivo, un aviso. No está haciendo ruido y no por eso ha fallado. Esperando no es muerto. No lances una segunda copia «para despertarlo». No lo pares porque te parece ocioso. Un servicio que espera está cumpliendo la ficha. Si de verdad tuviera que estar haciendo otra cosa, lo dice el registro, no el silencio.

Muerto. La línea dice inactive (dead). No hay proceso de esa unidad. Muerto, aquí, no significa corrompido ni «hay que reinstalar». Significa apagado. Una unidad que existe y que nadie ha arrancado está muerta, y es lo normal. Una unidad que arrancó, terminó y no debía quedar residente también puede verse así, según cómo esté escrita. Antes de asustarte, lee si tú la habías encendido. Si no la habías encendido, muerto es la respuesta correcta, no una avería.

Hay una cuarta palabra que no es ninguna de las tres y conviene no mezclarla. failed significa que lo intentó y systemd anotó un fallo: el programa salió mal, o se cayó tantas veces que la ficha dejó de reintentar. No es un muerto tranquilo. Es un muerto con causa. La causa no se arregla parando otra vez lo que ya está parado, ni regrabando la tarjeta. Se lee, y el sitio largo de esa lectura es la lección 16. Hoy basta con no llamar «muerto normal» a un failed, ni «roto el sistema» a un inactive (dead).

Una salida de ejemplo, no un inventario

Esto es la forma de la respuesta para una unidad inventada en esta página, casa-aviso.service, que no viene en la imagen. Si en tu placa no existe, status lo dirá. No la busques en una lista de fábrica. No crees hoy cinco unidades para llenar el ejemplo.

systemctl status casa-aviso.service

Si nunca la has creado, la frase será que la unidad no se encuentra. Eso no es dead. Dead exige que la ficha exista y el proceso no. «No se encuentra» exige que el nombre esté mal o que la unidad no esté instalada. Son dos negativas distintas. La primera se corrige leyendo el nombre, letra por letra, mayúsculas incluidas. La segunda se corrige no inventando el servicio.

Si existiera y nadie la hubiera arrancado, la línea diría Active: inactive (dead). Leída bien: la ficha está, el proceso no, y no hay un fallo anotado. No hay nada que matar. Matar lo que ya está muerto es cómo se acaba tocando el vecino: el nombre se parece, el dedo confirma el que no era, y paras una pieza del arranque.

Si estuviera en marcha, verías active (running) y un número de proceso. Ese número identifica a ese proceso ahora. No es una licencia para enviarle una señal de muerte desde la terminal. Si estuviera active (waiting), el número puede existir igual y el trabajo ser esperar. El paréntesis manda más que el número.

Loaded no es Active

En la línea Loaded puedes ver la ruta de la ficha y una palabra como enabled o disabled. Enabled habla del próximo arranque: si el sistema la enganchará solo al encender. Disabled habla de lo contrario. Ninguna de las dos dice si ahora mismo el proceso está vivo. Puedes tener enabled y dead: arrancará en el próximo encendido y ahora está parada. Puedes tener disabled y running: alguien la arrancó a mano en esta sesión y, al reiniciar, no volverá. Las dos combinaciones son coherentes. Confundirlas es el motivo de la lección 14, y el motivo de no «arreglar» hoy un disabled parando procesos.

La ruta también se lee, no se edita. Una ficha bajo el directorio del sistema pertenece a un paquete. Una ficha bajo /etc/systemd/system es local, de la máquina. Ver la ruta te dice a quién obedecer si más adelante hay que cambiar algo. No abras el fichero del paquete para «probar». Status ya te ha dejado leer el estado sin abrirlo.

Por qué no se mata a ciegas

systemctl stop existe. systemctl disable existe. systemctl restart existe. Ninguno es la orden de esta lección. Stop pide a esa unidad que suelte el proceso. Si el nombre era el de una pieza que mantiene la sesión, la red, el escritorio o el reloj del sistema, te quedas sin ella hasta que vuelva a subir, y a veces no vuelve sola. Restart hace stop y start seguidos: un corte breve que, en la unidad equivocada, es un corte igual. Disable no mata el proceso de hoy; le quita el enganche del próximo arranque. Hecho sobre un nombre que no entendías, el fallo aparece mañana, cuando ya no recuerdas qué tocaste.

A ciegas significa exactamente esto: paras, reinicias o desenganchas porque el nombre no te suena, porque dead te asusta, porque waiting te parece vago, o porque un texto de fuera dice «para todos los servicios que no uses». Tú no tienes, en esta página, la lista de los que la placa usa. Un nombre opaco puede ser el que monta discos, el que entrega la dirección de la red o el que dibuja el escritorio. No hace falta que yo los enumere para que la regla valga: si no sabes decir qué trabajo hace, no lo paras.

Tampoco mates el proceso por el número. El identificador que muestra status es para reconocer, no para kill. Un kill fuerte salta el cierre ordenado que la ficha tenía previsto. El servicio puede reaparecer al instante, porque systemd lo vigila, y tú habrás aprendido el gesto peor. O puede no reaparecer y dejarte el sistema a medias. La pregunta se responde con status. La acción, cuando exista, tendrá un nombre tuyo y la lección 14.

Status, por su parte, no cambia el estado. Puedes ejecutarlo dos veces. La segunda tiene que contar la misma historia si nadie ha arrancado nada entre medias. Si el terminal se llena y no vuelve el prompt, no se ha colgado la placa: estás en el visor de páginas. La tecla q lo cierra. Tirar del cable porque el visor espera es el fallo de la lección 9, no un paso de esta.

Qué no demuestra un status

No demuestra que el GPIO esté bien cableado. Un servicio muerto o vivo no cambia los 3,3 V del pin, ni convierte el físico 11 en otra cosa que el GPIO 17, ni libera los físicos 27 y 28. No demuestra que la red exista. No demuestra que un paquete esté actualizado. No demuestra que la tarjeta se apagara bien ayer. Demuestra una sola cosa: qué hace ahora esa unidad, con las palabras de la línea Active, y si systemd recuerda un fallo.

Si la unidad no se encuentra, no instales un paquete al azar para forzar que aparezca. El nombre se comprueba. Si está failed, no regrabes. Anota el nombre y deja el registro para la lección 16. Si está dead y es tuya y la quieres en marcha, todavía no la pares: la 14 dirá cómo encenderla sin tocar las demás.

Aviso. systemctl status no autoriza un stop del sistema, ni un cable. GPIO a 3,3 V. Físico 11 es GPIO 17. Pines 27 y 28 reservados. Sin 230 V. Y no hay en esta lección una lista de servicios que «sobran».

El punto de color no manda

Delante del nombre, status suele pintar una marca. En un terminal que acepta color, verde acompaña a lo que va bien, rojo a un failed, y un tono neutro a lo que simplemente no corre. Es una ayuda visual, no otro estado. El color depende de que la salida sea un terminal y de que no hayas pedido una salida pelada. Copiar un tutorial según «si está en verde» falla el día que lees la misma orden redirigida a un archivo, o el día que tu tema no pinta. La palabra de la línea Active es la que se anota. La marca, si está, solo te lleva el ojo hasta esa línea.

Debajo, el bloque del grupo de control lista los procesos que systemd atribuye a esa unidad. Ahí se ve el programa concreto y su número. Sirve para comprobar que la ficha lanzó el binario que crees, no un homónimo de otra carpeta. No sirve para ir cazando números. Si el programa no es el que esperabas, el arreglo es la ficha, en la lección siguiente si la ficha es tuya, no una matanza de procesos con el mismo nombre corto. Un nombre corto puede pertenecer a otra unidad que sí necesitas. Por eso el stop a ciegas y el kill por nombre son el mismo error con dos teclados.

Hay una forma aún más corta de la misma pregunta: systemctl is-active NOMBRE imprime una palabra y vuelve. active, inactive o failed. No muestra la ruta ni el registro. Vale para confirmar lo que ya leíste en status, no para sustituir la lectura la primera vez. Si is-active dice active, recuerda que ahí dentro caben running, waiting y exited. La palabra suelta no distingue el esperando del que ya terminó su trabajo de una pasada. Por eso la orden de la lección sigue siendo status, con el paréntesis a la vista.

El estado que ves es el de esta sesión de systemd, la de este arranque. Un servicio que murió antes de apagar bien puede haber dejado el failed grabado, y al volver a encender sigues viéndolo. Eso no se limpia reinstalando ni parando vecinos. Se lee. Borrar el síntoma sin leerlo es la lección 16, y tampoco se hace. Hoy te llevas el nombre y la línea Active, en papel, y dejas la placa como estaba.

Ejercicio en la Pi

Elige un nombre que no vayas a adivinar entre los del sistema. Usa casa-aviso.service. Ejecuta systemctl status casa-aviso.service. Si dice que no se encuentra, anota esa frase y que no es lo mismo que dead: todavía no has creado la unidad. Si por algún motivo ya existiera, copia solo la línea Active y decide cuál de las tres lecturas es: activo, esperando o muerto. No ejecutes stop, restart ni disable. Si el visor se queda abierto, sal con q. Si no hay placa, escribe en papel las tres líneas Active de esta lección y al lado qué significan, y tacha «parar a ciegas».

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Dejar un servicio encendido son dos ideas. Enable engancha la unidad al próximo arranque; arrancar ahora la pone en marcha en esta sesión. sudo systemctl enable --now NOMBRE hace las dos, y el ejemplo es un servicio tuyo, no el acceso remoto.

Dos decisiones que se parecen y no lo son

La lección 13 miraba el ahora. Esta decide el ahora y el después, por separado, porque systemd los guarda por separado. enable no lanza el proceso. Escribe el enganche para que, en el próximo arranque, la unidad suba sola. Hasta que no reinicies, el proceso sigue como estaba: si estaba muerto, sigue muerto. start lanza el proceso en esta sesión. No escribe el enganche. Reinicias, y no vuelve. Las dos órdenes existen precisamente para que puedas probar hoy sin comprometer el arranque, o preparar el arranque sin tocar lo que está corriendo. Juntarlas sin querer es cómo un experimento de una tarde se queda para siempre, o cómo un arreglo de esta tarde desaparece al apagar bien.

La orden que hace las dos, y solo cuando de verdad quieres las dos, es:

sudo systemctl enable --now NOMBRE

--now es la parte de «arranca también ahora». Sin esas letras, enable se queda en el enganche. Con ellas, enable y start ocurren en la misma línea. Sigue siendo un préstamo de una orden, la de la lección 11: hace falta sudo porque el enganche vive fuera de tu home, en el sistema, y porque poner en marcha una unidad del sistema no es un derecho de tu carpeta. La contraseña es la tuya. Al volver el prompt, whoami sigue siendo tu nombre.

NOMBRE es el de tu unidad, no el de una pieza que venía en la imagen y que no sabes qué hace. El ejemplo de esta lección se llama casa-aviso.service. Lo vas a crear tú. No viene de fábrica. No lo sustituyas por el servicio de acceso remoto «para ir probando con uno de verdad». Ese acceso es la lección 36, todavía sin escribir, y encenderlo ahora para que la prueba sea más interesante es dejar una puerta abierta antes de saber leer un registro. Si un texto te empuja a enable de ese servicio como primer gesto, el texto no es este curso.

La referencia del mecanismo está en Software, el sistema. La ficha no elige el nombre por ti.

Un servicio que es tuyo de verdad

Tuyo significa tres cosas a la vez. El programa vive en tu home. La ficha dice que el proceso corre con tu usuario, no con el cero. Y el nombre no choca con una unidad que el sistema ya usa. casa-aviso cumple el tercero porque no es un nombre de paquete. El programa puede ser este, guardado como aviso.sh en tu carpeta. Sustituye ana por lo que imprime whoami.

#!/bin/sh
while true
do
  date >> "$HOME/aviso.log"
  sleep 30
done

El bucle escribe la fecha en un archivo de tu home y espera treinta segundos. No pide red. No toca el header. No instala nada. Treinta segundos no es una cifra sagrada: es un ritmo para que el archivo crezca despacio y puedas ver, con ls -l, que el proceso sigue vivo. chmod u+x aviso.sh le da ejecución solo a ti, el dueño. No es 777. Si omites el chmod, la unidad fallará al arrancar y status dirá failed, que es una lectura, no una invitación a ampliar permisos al mundo.

La ficha va aparte del programa. La escribes en tu home, con el mismo nombre de usuario dentro, y luego la copias al sitio donde systemd lee las unidades locales. No editas las fichas que vinieron con los paquetes.

[Unit]
Description=Aviso local de casa

[Service]
Type=simple
User=ana
WorkingDirectory=/home/ana
ExecStart=/home/ana/aviso.sh

[Install]
WantedBy=multi-user.target

Type=simple significa que el programa que lanzas es el proceso principal y que systemd lo considera en marcha en cuanto ha arrancado. Encaja con un bucle que no termina. User= es la línea que impide que el servicio sea root. Sin ella, el proceso sería del cero, el archivo aviso.log nacería de root y mañana no podrías ampliarlo sin préstamo. Es el fallo de la lección 11 metido dentro de una ficha. WorkingDirectory y ExecStart usan tu home real, no la de un ejemplo que no existe. WantedBy=multi-user.target es el enganche: en el arranque normal, también en el de escritorio, esa meta tira de las unidades que la piden. Sin la sección Install, enable no tiene dónde enganchar y te lo dirá. No inventes otra meta «porque el escritorio es gráfico». Esta basta.

Copiar la ficha al sitio del sistema es el préstamo, no un editor abierto como root:

sudo cp casa-aviso.service /etc/systemd/system/casa-aviso.service
sudo systemctl daemon-reload

daemon-reload obliga a systemd a volver a leer las fichas. Sin él, enable y status pueden estar mirando una versión vieja, o ninguna, y creerás que el archivo que acabas de guardar no existe. Reload no arranca tu servicio y no para los demás. Es una relectura. Se hace después de copiar y cada vez que cambies la ficha. No es el sustituto de enable.

Qué hace enable por dentro, sin convertirlo en magia

Enable crea un enlace con el nombre de tu unidad dentro de la lista de los que el arranque desea. No copia el programa. No modifica aviso.sh. Si borras el enlace, el programa sigue en tu home y la ficha sigue en /etc/systemd/system. Por eso disable, que no es la orden de hoy, quita el enganche y no borra tu script. Y por eso enable de un nombre equivocado engancha ese nombre, no «el sistema en general». El argumento no es opcional y no es un asterisco.

Start hace otra cosa: pide a systemd que ejecute ahora ExecStart con el usuario de la ficha. Si el script no es ejecutable, si la ruta está mal, o si User= no existe, la unidad pasa a failed. Lo verás con status, no con otro enable repetido a ver si suena distinto. Repetir enable sobre una unidad que ya está enabled no corrige un script roto. Dice que el enganche ya estaba, y el proceso sigue fallando.

--now no es un tercer estado. Es start pegado a enable. Si el enganche se crea y el arranque del proceso falla, puedes quedar enabled y failed a la vez: mañana lo reintentará, y hoy está mal. Por eso la comprobación no es «el comando no imprimió queja». La comprobación es:

systemctl status casa-aviso.service

Quieres active (running) y, en Loaded, enabled. Las dos palabras. Si solo ves enabled y dead, olvidaste --now y la de hoy no ha arrancado. Si ves running y disabled, alguien hizo start suelto y el próximo arranque no la traerá. Si ves failed, lees la línea y no enable otra vez.

El archivo aviso.log tiene que crecer en tu home y ser tuyo en ls -l. Si el dueño es root, la ficha no tiene el User= que crees, o copiaste una ficha distinta. No lo arregles con sudo sobre el log. Corriges la ficha, daemon-reload, y dejas que el proceso nuevo, ya con tu usuario, escriba. Parar y volver a arrancar esa unidad tuya, cuando ya sabes que es tuya y que la ficha cambió, sí es una acción con nombre. No es un stop a ciegas de la lección 13. El nombre está escrito en tu papel, lo creaste tú, y no paras ninguna otra.

Probar el próximo arranque sin tirar del cable

Enable se demuestra al volver a encender. Un reinicio limpio es sudo reboot. Cierra en orden, como el apagado de la lección 9, y vuelve a subir. No es un tirón. No es diez ciclos. Es una vez, si quieres ver el enganche con tus ojos. Cuando regrese el escritorio, systemctl status casa-aviso.service tiene que seguir en active (running) sin que tú lo arranques a mano. Si está dead y enabled, el enganche no está donde crees o la ficha no se leyó: mira la ruta en Loaded y si hiciste daemon-reload antes de enable. Si la placa no vuelve, no es esta unidad de un sleep la causa probable. No deshagas media imagen. Entras como puedas y miras status. Quitar el enganche de tu unidad, si hiciera falta, es sudo systemctl disable casa-aviso.service, con ese nombre completo, nunca con un nombre que no hayas creado.

Dejarla encendida no te obliga a dejarla para siempre. Cuando la prueba termine, disable y stop de casa-aviso.service son la marcha atrás de las dos ideas: disable quita el mañana, stop quita el ahora. sudo systemctl disable --now casa-aviso.service junta la marcha atrás igual que enable --now juntaba la ida. No practiques esa marcha atrás con otro nombre «ya que estás». Y no borres el registro para ocultar que falló una vez. El log de tu home, aviso.log, puedes dejarlo. Es tuyo y no es el diario del sistema.

Lo que esta orden no enciende

No enciende el pin. Un servicio puede, en una lección muy posterior, lanzar un programa de GPIO, y ese programa seguirá siendo de 3,3 V, con el físico 11 como GPIO 17, sin tocar el 27 ni el 28. Esta unidad de ejemplo no lo hace, a propósito. Si metes un programa de pines en ExecStart hoy, lo harás sin la lección del pin, y además lo harás residente: un error de cable se queda encendido en cada arranque. Eso es peor que un script que lanzas a mano y que termina.

No abre la puerta de red. No instala paquetes. No cambia permisos del sistema. No sustituye a un cron que no hemos explicado: el bucle con sleep es deliberadamente burdo para que veas el proceso en status. No es el modelo de un reloj de tareas. Cuando el trabajo de verdad sea «una vez al día», se escribirá de otra manera, en su lección, no dejando un bucle eterno porque esta funcionó.

Y no se copia a todas las unidades que status enseña en dead. Dead era normal. Enable --now sobre un dead que no es tuyo convierte un estado sano en un proceso de más, y a veces en un conflicto con el que ya espera en waiting. La regla de la 13 no caduca al aprender la 14. Solo cambia para el nombre que tú has puesto en la ficha.

Aviso. enable --now es para casa-aviso, o para otra unidad que hayas escrito tú con el mismo criterio. No para el acceso remoto y no para un nombre sacado de un listado que no entendiste. GPIO a 3,3 V. Sin 230 V. Si reinicias, que sea con sudo reboot, no a tirones.

Cómo se ve el enganche, y qué no es

systemctl is-enabled casa-aviso.service imprime una palabra: enabled o disabled, y vuelve. Es la mitad del status, la del futuro, sin el proceso. Úsala después de enable para no discutir con un bloque largo. No imprime running. Si alguien te dice que is-enabled «ya demuestra que está vivo», está mezclando las dos ideas otra vez. Vivo se mira con status, en Active.

El enganche es un enlace con el nombre de la unidad dentro de la carpeta de deseos de esa meta de arranque. Puedes mirarlo, sin borrar nada, listando esa carpeta. Ver el enlace confirma que enable escribió donde debía. No verlo, después de un enable que no se quejó, suele querer decir que no hubo daemon-reload y systemd contestó sobre la ficha anterior, o que la sección Install no estaba. No fabriques el enlace a mano. Enable sabe el sitio. Un enlace hecho a dedo sobrevive mal al siguiente disable y deja una unidad que «no se va».

La palabra preset que a veces acompaña en Loaded es la sugerencia con la que el paquete habría dejado una unidad suya. En la tuya no hay paquete. El preset no te obliga. Quien manda en tu ficha es el enable o el disable que ejecutaste. No cambies el preset global del sistema para que tu aviso «salga enabled solo»: ese cambio afectaría a unidades que no has leído.

Si cambias aviso.sh después de haber arrancado, el proceso que ya corre sigue con el programa que tenía en memoria, no con el archivo nuevo, hasta que esa unidad se arranque de nuevo. Un servicio simple no relee el script en cada vuelta del bucle si el bucle es el propio proceso ya cargado: el shell leyó el archivo al empezar. Para probar un cambio, sudo systemctl restart casa-aviso.service, con ese nombre. Restart aquí es start y stop de lo tuyo, después de un cambio que tú hiciste. Sigue sin ser un restart de todo lo que status podría listar. Y si el cambio fue la ficha y no el script, primero daemon-reload y luego restart. Al revés, restart obedece la ficha vieja y creerás que la línea nueva no funciona.

Un ExecStart con una ruta que no está, o un User= que no es el de whoami, no se arregla con un segundo enable --now. Status pasará a failed y el proceso no quedará running. Corriges el texto, copias otra vez la ficha, recargas y reinicias esa unidad. El log de tu home, si el usuario era el bueno y solo falló el script, puede tener una línea o no tener ninguna. La ausencia de aviso.log con un failed en status significa que ni siquiera llegó a ejecutar el bucle, no que el disco esté lleno. No borres otros registros para «hacer sitio» a esta prueba.

Ejercicio en la Pi

Crea aviso.sh en tu home con el bucle de esta lección, ponle chmod u+x y escribe la ficha con tu usuario real en User=, WorkingDirectory y ExecStart. Cópiala con sudo a /etc/systemd/system/casa-aviso.service, haz sudo systemctl daemon-reload y sudo systemctl enable --now casa-aviso.service. Comprueba con systemctl status casa-aviso.service que está active (running) y enabled, y con ls -l que aviso.log es tuyo. No hagas enable de ningún otro nombre. No enciendas el acceso remoto. Si quieres ver el próximo arranque, un solo sudo reboot y otra vez status. Si no hay placa, escribe en dos columnas qué queda hecho con enable, qué queda hecho con start, y qué añade --now.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

sudo apt update no instala nada: pregunta a los repositorios qué paquetes hay, y para esa pregunta hace falta red en ese momento. Si la red no está, lo ya instalado sigue donde estaba. Un GPIO, un CSV en tu disco o una foto con la cámara ya configurada no llaman a internet para funcionar.

Update es una pregunta, no una obra

Los programas que vinieron en la imagen, y los que instales más adelante con el sistema de paquetes, están descritos en listas. Esas listas dicen el nombre, la versión y de qué otros paquetes dependen. apt update vuelve a traer las listas. No trae los programas. No sustituye los que ya tienes. No abre el header. Al terminar, apt sabe qué habría de nuevo si algún día decidieras actualizar, y tú puedes leer ese resumen. La decisión de instalar o de subir versiones es otra orden, y no es la de esta lección.

sudo apt update

Hace falta sudo porque las listas se guardan fuera de tu home, donde el gestor de paquetes las consulta luego. Es el préstamo de una orden, la de la lección 11, no una sesión de root. La contraseña es la tuya. Si el recuerdo del préstamo sigue vivo en esa terminal, puede no preguntarla. Sigue siendo una excepción, no un hábito para el resto de la tarde.

Hace falta red en ese momento porque las listas viven en los repositorios, no en tu cabeza. La Pi tiene que resolver el nombre de esos servidores y traer los índices. Sin cable y sin wifi, la orden acaba en un error de red y devuelve el prompt. Ese error no desinstala lo que ya estaba. No deja la tarjeta a medias por sí solo: no llegó a cambiar paquetes. Deja las listas como estaban, quizá viejas. Lo único que no tienes es la respuesta nueva a «qué hay».

La referencia de trabajar sin red, cuando ya no estás aprendiendo esta diferencia, está en Software, sin red. Esta lección no copia la ficha. Fija el corte: la red se usa para saber qué hay. El trabajo local no la espera.

Qué estás leyendo al final de update

Las líneas del medio nombran orígenes y dicen si el índice se pudo leer. No hace falta memorizar cada palabra inglesa. Hace falta ver si terminó en un resumen o en una queja de conexión. El resumen habla de cuántos paquetes podrían subir de versión. «Podrían» no es «debes hacerlo ahora». Es el resultado de la pregunta. Anótalo si quieres, y no conviertas el número en una urgencia de la misma tarde. Una subida de versiones descarga paquetes de verdad, escribe en el sistema y puede tardar. Si la cortas a medias, eso sí puede dejar un paquete a medio configurar, y el corte de corriente de la lección 9 es justo el que no quieres en medio. Por eso update, que no instala, es la orden de hoy, y la otra se deja para cuando tengas tiempo de esperar y de apagar bien al acabar.

Instalar un paquete concreto, el día que la lección lo pida, es otra frase, con el nombre del paquete, no un update repetido. Update no adivina qué querías instalar. Si lo lanzas tres veces seguidas con red, la tercera suele decir que las listas ya están al día. No has ganado tres instalaciones. Has preguntado tres veces.

No edites a mano los ficheros de orígenes para «arreglar» un update que falló por falta de red. El fallo era la red, no la lista. Cambiar orígenes a un sitio que alguien pegó en un foro es cómo se mete un paquete que no es el de Debian ni el de Raspberry Pi OS. Esta imagen, a 3 de octubre de 2026, bebe de Trixie y de los paquetes de la placa. Mezclar otra generación es el mismo error que grabar otra distribución en la lección 6. Y no desactives la comprobación de firmas para que una queja calle. La firma es lo que distingue un índice de verdad de un índice cambiado por el camino. Si un día la fecha de la placa está tan desencaminada que la firma parece caducada o del futuro, el arreglo es la fecha, no un interruptor que acepte cualquier cosa. Esta lección no trae ese interruptor.

Lo que no pide internet después de estar en la tarjeta

Un paquete, una vez desempaquetado, es archivos en el disco. El programa arranca desde ahí. No vuelve al repositorio cada vez que lo ejecutas, salvo que ese programa, por su propio trabajo, hable con un servidor. Los tres trabajos de este curso que a veces se confunden con «hay que estar en línea» no son de esos.

El GPIO. El pin lo gobierna el núcleo de la propia placa y la librería que ya esté instalada. Encender el físico 11, que es el GPIO 17, es una escritura en un dispositivo local. No hay un servidor al otro lado del LED. Si el programa falla, las causas siguen siendo el pin, el permiso, el nombre del archivo o el cable, no un update pendiente. Y el voltaje sigue siendo 3,3 V estés o no estés en red. La red no protege el pin y la falta de red no lo apaga.

Un CSV. Es un archivo de texto en tu home, el de la lección 21 cuando se escriba. Crearlo, ampliarlo y leerlo son operaciones del sistema de archivos. apt update no lo rellena y su fallo no lo borra. Puedes anotar lecturas todo un día con el cable de red desenchufado, siempre que el programa que escribe ya estuviera en la tarjeta. Llevarte el archivo después, en la propia microSD o copiándolo en casa, tampoco exige que la Pi consulte un repositorio.

Una foto ya configurada. Si la cámara ya está reconocida y el programa que dispara ya está instalado, el disparo habla con el sensor por el conector de la placa, no con internet. La imagen cae en un archivo local. «Ya configurada» es la condición: esta lección no te manda a activar la cámara ni a bajar un controlador nuevo. Si todavía no está configurada, el arreglo no es un update lanzado a ciegas ni un paquete con un nombre adivinado. Será la lección de la cámara, cuando exista. Hasta entonces, no tener red no te quita las fotos que ya sabes hacer, y tener red no sustituye esa lección.

Lo mismo vale para lo que ya practicaste. whoami, ls, systemctl status de tu unidad, el bucle de casa-aviso escribiendo en aviso.log: ninguno consulta el índice de apt. Puedes apagar la wifi para comprobarlo. No hace falta. El mecanismo no depende de que hagas el teatro de desconectar, y desconectar a medias un enchufe flojo es otro problema, el de la alimentación, no el de las listas.

Dos atajos que no son apt

El primero es encadenar un descargador con una tubería hacia el shell, casi siempre con sudo delante. El texto que llega por la red se ejecuta tal cual, en el momento, con poder de root si lo prestaste. No lo lees antes. No queda un paquete que apt conozca. Si la red se corta a la mitad, el shell puede haber aplicado una parte y no la otra. Si el origen cambia el texto mañana, repites una orden distinta creyendo que es la misma. Esta página no escribe esa orden, ni en un recuadro para copiar, porque copiarla es el fallo. Si la ves en un tutorial como «la forma rápida de instalar el controlador», es la forma rápida de no saber qué has instalado. En este curso se instala con apt, cuando hay un paquete con nombre, o no se instala.

El segundo es pip suelto contra el Python del sistema, y peor si va con sudo. pip copia librerías de otro índice, no del de Debian, y las deja donde el intérprete del sistema las encuentra. Esas copias no tienen ficha de apt. Un update posterior no las entiende. Una subida de versión del sistema puede pisarlas o romperse al tropezar con ellas. En Debian 13, y por tanto en esta Raspberry Pi OS Trixie, el Python del sistema está marcado como entorno gestionado por fuera: pip, si lo intentas como administrador, debe negarse o exigirte un interruptor que significa «sé que estoy rompiendo el acuerdo». Ese interruptor no es un paso de la lección. No lo busques. No instales gpiozero, ni nada del curso, con pip y con root «porque apt tardaba».

Si un programa de Python que ya venía, o que instalaste con apt, importa y funciona, ya lo tienes. No hace falta una segunda copia más nueva sacada de internet el mismo día. Si falta una librería, el nombre se busca como paquete del sistema el día que la lección lo diga, con red, con apt, y se anota el nombre. No se adivina. Un entorno aparte dentro de tu home es otro mecanismo, de otra lección si algún día hace falta, y tampoco se crea con sudo. Tu usuario, tu carpeta, como el resto del curso.

Qué sí seguirá pidiendo red, para no mezclar

Pide red, en el momento de hacerlo: traer listas, instalar un paquete que no esté ya en la tarjeta, y cualquier programa cuyo trabajo sea hablar con un sitio remoto. No pide red: ejecutar lo que ya está, leer y escribir tu home, gobernar un pin, guardar un CSV, disparar una cámara ya configurada, mirar status, leer el registro local de la lección 16. Si un programa local de pronto se niega a arrancar y la queja habla de un servidor, estás ante un programa que sí quería red, no ante una prueba de que el GPIO se ha vuelto remoto. Lees la frase. No lanzas update como reflejo universal.

Tampoco uses la red de esta lección para dejar el acceso remoto encendido «ya que hay wifi». Sigue siendo la lección 36, no un efecto secundario de apt. Update no abre puertas. Solo refresca listas.

Si update tarda, es la red o el servidor, no un pin caliente. No desenchufes para «desatascarlo». Espera o interrumpe esa orden con Control y C. Interrumpir update a mitad de las listas no es interrumpir una instalación de paquetes: lo peor habitual es un índice a medias que la siguiente update, con red, rehace. No es motivo para regrabar. Y no es motivo para el atajo del descargador.

Aviso. La red no cambia el header. GPIO a 3,3 V. Físico 11 es GPIO 17. Pines 27 y 28 reservados. Sin 230 V. apt update sin red falla la pregunta y deja los programas. No hay en esta lección ni una tubería de un texto remoto hacia el shell, ni un pip de root.

Listas, paquetes y el disco, cada cosa en su sitio

Cuando update termina bien, lo nuevo en el disco son índices: textos comprimidos con nombres y versiones. No son los programas. El programa, el día que se instale, llegará como un paquete, se desempaquetará en su sitio y apt anotará que está instalado. A partir de ese instante el paquete ya no necesita el índice para arrancar. El índice solo vuelve a hacer falta cuando preguntas qué hay de nuevo o cuando pides instalar algo que aún no tienes. Borrar los índices «para ahorrar tarjeta» no gana un sistema más limpio: gana un update obligatorio la próxima vez que quieras saber algo, y no borra los programas. No es un paso de mantenimiento de esta lección.

La palabra inglesa upgrade, que verás en el resumen, es la subida de versiones. Update es la pregunta. En castellano se parecen si las traduces las dos por «actualizar». No las juntes. Si escribes la de subir versiones creyendo que es la de preguntar, empezarás a descargar paquetes y a configurarlos. Si eso ocurre, déjala terminar, no quites la corriente, y al final apaga como en la lección 9 si ya habías acabado la sesión. No la mates a la mitad porque «solo querías mirar». La próxima vez la orden de mirar es la que lleva update.

Un paquete puede depender de otros. Por eso instalar, cuando toque, no siempre es un solo archivo. Apt calcula el conjunto. Tú no recopilas esos archivos a mano ni los traes de un sitio distinto del que las listas acaban de firmar. El cálculo también necesita las listas frescas si el paquete no estaba ya descargado. Sin red y sin el paquete en la tarjeta, no hay instalación mágica. Con el programa ya instalado, la dependencia ya está resuelta en el disco y el CSV, el pin o la foto no vuelven a pedirla.

Puedes saber si un programa concreto está instalado sin red, porque esa respuesta sale del disco, de la base local de paquetes instalados, no del repositorio. Hace falta el nombre. No hace falta adivinar diez. Si no recuerdas el nombre, no recorras el índice entero «por si aparece algo útil que instalar». Esa lectura larga es cómo se acaba instalando de más. El ejercicio de hoy no instala.

Ejercicio en la Pi

Si tienes red, ejecuta sudo apt update y lee el final: si las listas se renovaron y cuántos paquetes podrían subir, sin subirlos. No instales un paquete por probar. No lances la orden que sube versiones. Si no tienes red, ejecuta la misma orden, copia la frase de fallo y comprueba que el prompt vuelve. En los dos casos, sin tocar el header, ejecuta whoami y ls y escribe una frase: estos no han usado la red. En el papel, apunta los tres trabajos que seguirían sin internet si ya estuvieran en la máquina: el GPIO, el CSV, la foto ya configurada. No desactives firmas. No pegues un instalador remoto. No invoques pip con sudo. Si no hay placa, dibuja el esquema: update dentro de la red, y los tres trabajos fuera.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Cuando algo falla, la orden es journalctl -n 50 --no-pager: cincuenta líneas, las últimas, y lees el final. No borras registros para que el problema desaparezca de tu vista. El nombre de la unidad, si lo conoces, acota la lectura.

El diario no es un archivo que se abre con el editor

systemd guarda lo que las unidades y el propio núcleo le cuentan en un diario binario. No es un texto que puedas corregir a mano, ni un cuaderno donde las líneas se borren con una goma. journalctl es el lector. Traduce el diario a líneas que la terminal puede enseñar. Cada línea lleva un tiempo, el nombre de la máquina, quién habló y el mensaje. El tiempo va de antes a después según bajas. El final de la salida es lo último que ocurrió. Por eso la orden pide el final y no el principio: el fallo que te importa suele ser reciente, y el principio del diario es otra sesión, a veces otro día.

journalctl -n 50 --no-pager

-n 50 corta a cincuenta líneas. Cincuenta no es un número mágico del hardware. Es bastante para ver el último tropiezo y el contexto inmediato, y poco para ahogarte. Si esas cincuenta no llegan al inicio del fallo, repites con un número mayor, no con un borrado. --no-pager impide el visor de páginas. Las líneas se imprimen y vuelve el prompt. Sin esa opción, una salida larga abre el visor, el prompt desaparece y parece que la placa se ha parado. No se ha parado. La lección 13 ya dijo que q cierra ese visor. Aquí ni siquiera entras: cincuenta líneas caben, y las quieres en la misma pantalla donde puedes copiar.

La orden no cambia el diario. Puedes lanzarla dos veces. La segunda puede tener una línea más si algo habló entre medias, no porque tú hayas «refrescado el problema». Leer no gasta el registro y no lo archiva. Es una pregunta, como status y como apt update, con la diferencia de que esta no necesita red. El diario está en el disco de la propia placa. La referencia, para consultar el lector y no para saltarte la lectura, está en Software, el sistema.

Qué estás mirando en esas cincuenta

No estás mirando un inventario de servicios. Estás mirando los últimos avisos, mezclados, en el orden en que ocurrieron. Habrá líneas que no entiendas. Se dejan. No se cazan una por una para parar la unidad que nombran. El criterio de la lección 13 sigue en pie: un nombre que no sabes qué hace no se stop. Aquí solo se lee.

Buscas, desde el final hacia arriba, la línea que coincide con lo que acabas de intentar. Si probaste casa-aviso.service, buscas ese nombre. Si el script no era ejecutable, el mensaje dirá que la ejecución falló, o que el permiso no alcanzó, o que la ruta de ExecStart no está. Esa frase es más precisa que «el servicio no va». Cópiala al papel tal cual, con la hora. Mañana, sin la pantalla, el papel es el registro que sí puedes enseñar. No la resumes en «falló algo».

Status ya te enseñaba unas pocas líneas al final de su bloque. Eran un recorte del mismo diario. Si el recorte no basta, no pidas otro status esperando un párrafo nuevo: status resume el estado, journalctl enseña el tramo. El estado failed de la lección 13 y las líneas de aquí cuentan la misma historia en dos formatos. Failed sin una línea leída es un título. La línea es el motivo.

Una línea de error no siempre es el primer error. A menudo la última es la consecuencia: «no pude arrancar» después de «no existe el archivo». Lees unas cuantas hacia arriba desde el final, no solo la última palabra. Cincuenta te dan ese margen. Si la causa es más vieja que esas cincuenta, el corte se te quedó corto. Subes el número. No concluyes que el diario está vacío.

Acotar cuando ya sabes el nombre

El diario entero de la placa habla de muchas cosas a la vez. Cincuenta líneas pueden estar llenas de ruido de otra unidad y no enseñar la tuya, si la tuya falló hace más de cincuenta avisos. Entonces, y solo entonces, acotas por el nombre que ya conoces:

journalctl -u casa-aviso.service -n 50 --no-pager

-u es la unidad. Sigue siendo un nombre que tú pones, el de la ficha que creaste o el que status te mostró en failed. No es una invitación a probar nombres hasta que alguno «tenga gracia». Si -u con un nombre inventado no imprime nada útil, ese nombre no ha hablado. No significa que debas crearlo. La orden principal de la lección, la que haces cuando todavía no sabes quién habló, es la que no lleva -u: las cincuenta últimas de todo, y de ahí sacas el nombre. Luego, si hace falta, acotas.

Otra acotación útil, sin sustituir a la orden principal, es el arranque en curso. Lo que pasó antes de apagar bien pertenece a otra sesión. Mezclarlo confunde un fallo de ayer con el de hoy. Cuando sospeches eso, se puede pedir solo este arranque. No es la orden que hay que memorizar primero. La primera sigue siendo journalctl -n 50 --no-pager, porque no da nada por supuesto: enseña el final, sea de este arranque o arrastrado del anterior. Si ves una hora que no es la de ahora, ya sabes que estás leyendo historia, y no reinicias servicios para cambiar el pasado.

Permiso para leer, no permiso para destruir

Con tu usuario, el diario a veces se deja leer y a veces no, según los grupos de tu cuenta. Esos grupos no los escribo aquí. La lección 12 ya dijo que groups los imprime en tu placa y que no se copian de un texto. Si journalctl responde que no tienes permiso, no has roto el diario. Te falta la lectura del diario del sistema, no un registro nuevo. El préstamo de una orden, otra vez el de la lección 11, es:

sudo journalctl -n 50 --no-pager

Misma lectura, con el cero solo para abrir el diario. No añade un borrado. No te quedas en una sesión de root después. Si tu usuario ya puede leer, no pongas sudo por costumbre. La excepción sigue siendo la excepción.

Lo que no harás, ni con sudo ni sin él, es vaciar el diario porque «ocupa» o porque la línea de error te molesta verla. Borrar logs no reinicia el servicio bien, no cablea el pin, no trae las listas de apt y no convierte un failed en running. Quita la hora, el nombre y el mensaje. La próxima vez que falle, status dirá failed igual y tú no tendrás las cincuenta líneas de la primera vez para comparar. Tampoco se borra la carpeta de registros de texto que convive en el disco con el diario. Parte de lo que buscas puede estar solo en el diario, y parte de lo que un paquete escribió puede estar en un texto de esa carpeta. Arrasar los dos «para empezar de cero» es empezar ciego. El tamaño se mira otro día, con una orden que esta lección no da, y solo cuando el disco de verdad no admite más escritura. Hoy hay sitio de sobra para cincuenta líneas.

Tampoco edites una línea para que parezca que no hubo error, ni pegues el diario en un sitio público con contraseñas dentro. Algunas líneas repiten rutas de tu home. No suelen llevar la contraseña, y aun así no hace falta publicarlas. El papel es para ti. El arreglo es del programa o de la ficha, no del renglón.

Del mensaje a la causa, sin salirte del curso

Una ruta que no existe en ExecStart se corrige en la ficha, con daemon-reload y restart de esa unidad tuya. Un permiso denegado al ejecutar aviso.sh se corrige con chmod u+x sobre ese archivo, no con 777 y no con el diario. Un User= que no coincide con whoami se corrige en la ficha. Un pin que no enciende no va a dejar en el diario una frase mágica si el programa ni siquiera se lanzó: primero el proceso tiene que estar active, y el cable sigue siendo de 3,3 V en el físico 11. El diario no mide voltios y no inventa un fallo eléctrico. Si el programa corre y el LED no, el registro puede estar en silencio y el problema ser el circuito, de una lección posterior. Silencio reciente más proceso running significa «el programa no se está quejando», no «borra el diario por si acaso».

Si la línea habla de la red durante apt update, ya sabes de la lección 15 que la pregunta necesitaba red. No reinstales el gestor de paquetes porque el diario lo nombre. Si la línea habla de una unidad que no creaste, la anotas y no la paras. Si no entiendes la frase, la copias igual. Traducirla mal y actuar es peor que dejarla en papel hasta que sepas. No busques la frase en un sitio remoto para pegar la primera receta: esa receta suele ser el stop a ciegas, el pip de root o el texto volcado al shell, los tres rechazados ya.

Después de leer, el sistema se queda como estaba. No hay una orden de «cerrar el registro». El prompt vuelve gracias a --no-pager. Apagar, si toca, sigue siendo sudo shutdown -h now y la espera. El diario se escribe en disco con el mismo cuidado que el resto: un tirón a medias puede partir la última anotación, justo la del fallo que querías conservar. Leer el registro y luego cortar la corriente es perder el final del registro.

Aviso. Leer no es borrar y no es cablear. GPIO a 3,3 V. Físico 11 es GPIO 17. Pines 27 y 28 reservados. Sin 230 V. Cincuenta líneas bastan para empezar. El vacío del diario no es un arreglo.

Una lectura posible, con tu unidad y no con un catálogo

Supón que enable --now de casa-aviso dejó la unidad en failed. Status ya te lo dijo. Ahora:

journalctl -n 50 --no-pager

Bajas a la última línea. Subes hasta ver casa-aviso. Encuentras, por ejemplo, que el archivo de ExecStart no es ejecutable, y debajo que la unidad ha quedado en failed. No hace falta que el texto coincida letra por letra con el de tu placa: los mensajes exactos los pone tu versión de systemd, y se copian de la pantalla, no de esta página. Lo que no cambia es el orden. Primero la causa, un poco más arriba. Después la consecuencia, más abajo. Actúas sobre la causa, en el script o en la ficha, y vuelves a mirar status. Si sigue en failed, repites la lectura. No vacías el diario entre las dos lecturas: la comparación es precisamente ver si la línea nueva es otra.

Si las cincuenta líneas no nombran tu unidad, no concludes que no falló. Acotas con -u y el mismo -n 50 --no-pager. Si tampoco ahí hay nada, la unidad no ha escrito todavía, y el failed que viste puede ser de otro nombre que leíste deprisa. Vuelves a status y lees el nombre otra vez. El remedio no es un registro más largo del sistema entero borrado y rehecho.

La misma línea, repetida, no es otro fallo

A veces el diario no copia cincuenta veces el mismo texto. Resume: el mensaje se repitió tantas veces desde tal hora. Eso sigue siendo una sola causa, no cincuenta averías. La hora del resumen y el nombre de quien habla te dicen si el bucle de tu aviso, o cualquier otra unidad, está insistiendo. No «arregles» la insistencia borrando el resumen. Si es tu bucle escribiendo al diario además de a aviso.log, el ruido lo produces tú y se quita cambiando el script, no el lector. El ejemplo de esta lección escribe en un archivo de tu home precisamente para no llenar el diario del sistema. Si más adelante un programa escribe en los dos sitios, el archivo de home es el cuaderno de tus datos y el diario es el de los fallos. No los intercambies: un CSV de lecturas no se busca con journalctl, y un failed no se busca abriendo el CSV.

La hora de la línea es la hora que la placa cree. Si esa hora va desencaminada, el orden dentro del diario sigue siendo el orden en que se escribió, y el final sigue siendo lo último. No reordenes las líneas a ojo porque el reloj te parezca raro, y no borres el tramo «de la hora imposible». Este curso no arregla el reloj en esta lección. Usa el orden de la salida. Lo más abajo es lo más nuevo aunque el número de la hora te sorprenda.

Cuando hayas copiado la línea y hayas corregido tu unidad, lanza otra vez journalctl -n 50 --no-pager y compara con el papel. Una línea nueva, posterior, que ya no dice failed, es la prueba de que el cambio se notó. La línea vieja puede seguir ahí, más arriba, porque no se reescribe la historia. Verla otra vez no significa que el arreglo no haya valido. Significa que el diario hace su trabajo: conservar. Quien borra para no volver a ver la línea vieja se queda sin esa comparación.

Ejercicio en la Pi

Ejecuta journalctl -n 50 --no-pager. Si tu usuario no tiene permiso, la misma orden con sudo delante, una sola vez, y no te quedes en root. Localiza la última línea y copia al papel la hora y el mensaje. Si creaste casa-aviso y falló, busca ese nombre; si no aparece en las cincuenta, repite con -u casa-aviso.service y el mismo corte. No borres el diario. No borres la carpeta de registros. No pares unidades que solo has visto en una línea. Si el visor apareciera porque olvidaste --no-pager, sal con q y repite la orden bien escrita. Si no hay placa, escribe qué extremo de las cincuenta líneas es el más nuevo y por qué vaciarlo no arregla un failed.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Python está en esta placa porque ya viene con Raspberry Pi OS, y el comando es python3. python a secas no es el camino. Hoy no se enciende ningún pin: el circuito es la lección 24 y la librería la 25.

Un lenguaje que se vuelve a leer

Hasta aquí las órdenes vivían en la terminal y se acababan al pulsar Enter. Sirven para preguntar quién eres, listar una carpeta o mirar un servicio. No sirven para dejar escrito «si el número pasa de 28, avisa» y ejecutarlo igual el martes. Eso es un programa: un texto que el sistema puede repetir sin que tú recuerdes cada paso.

Python es ese texto en legible. Las palabras se parecen a la frase que dirías. Una condición se ve como una condición. Un nombre guarda un número y, al releer el archivo, el nombre sigue ahí. No es un acertijo de símbolos. Dentro de un mes, el archivo te dice qué hacía. Una línea suelta en el historial de la terminal no. Por eso el curso, a partir de aquí, guarda el trabajo en archivos y no en la memoria de una sesión.

Legible no significa blando. El intérprete no adivina. Si la sangría está mal, se para y lo dice. Si usas un nombre que no has creado, se para y lo dice. Esa queja, leída en la línea que señala, es la lección 20. Hoy basta saber que el fallo se ve en texto, no en un parpadeo del LED. Todavía no hay LED.

Ya está en el sistema

Raspberry Pi OS, sobre Debian 13 Trixie, a 3 de octubre de 2026, trae Python 3. No se descarga para empezar. No se compila. No se pide prestado root para «meterlo». El programa que lo ejecuta se llama con esta orden:

python3 --version

Tiene que imprimir una versión que empieza por 3. Las cifras de después son las de tu imagen. Se leen. No se copian de un tutorial que diga otro parche, y no se persigue ese parche instalando nada. Si la orden responde que no encuentra el comando, no estás en la imagen de este curso o no estás en la cuenta que crees. No lo soluciones con un atajo de fuera.

Ese atajo, dicho para reconocerlo y no hacerlo, es traer un instalador remoto y volcarlo al shell, o usar pip como root contra el Python del sistema. La lección 15 ya los rechazó. Aquí se repiten porque un texto de Python los pone en la primera pantalla. El intérprete ya está. Pip como root mezclaría librerías que apt no conoce dentro del Python de Trixie, que es un entorno gestionado por el sistema. No es el paso para «tener gpiozero más nuevo». gpiozero, cuando llegue su lección, se usa el que corresponde a esta imagen, no una copia paralela.

La referencia de Python en la ficha de comandos, la de consultar y no la de saltarte el porqué, está en Software, Python. Thonny se explica en la lección siguiente, en este curso, y no se enlaza a esa ficha.

python3, no python a secas

El nombre corto python, en esta imagen, no es el intérprete de la 3. Debian dejó de prometer que python exista y apunte a Python 3. Puede no haber comando. Puede haber un resto de otro paquete. Un tutorial de hace años lo escribía porque en su máquina apuntaba a Python 2, que ya no es el lenguaje de este curso. Si lo ejecutas y falla, el fallo esperado es «orden no encontrada», el mismo mecanismo de la lección 8. No instales un paquete solo para que el nombre corto exista. Escribes python3, que es el que está.

python3 --version
python --version

La primera tiene que funcionar. La segunda, si dice que no está, confirma el párrafo anterior y no es una avería. Si la segunda imprime una versión, no la adoptes: este curso nombra el intérprete con el 3 para no depender de un alias. Dos nombres para el mismo programa confunden el día que dejen de ser el mismo. Un solo nombre, python3, en la terminal y, cuando guardes un archivo, delante del archivo.

No le pongas sudo. sudo python3 abre el intérprete como root. Un archivo que crees desde ahí nace de root, y un descuido tiene la pared de la lección 11 ya quitada. Python no necesita el cero para existir. Un script de pines, cuando toque, tampoco. Hoy no hay pines.

La librería de los pines no se adelanta

gpiozero es la librería con la que este curso, más adelante, hablará con el header desde Python. Está pensada para este intérprete y para esta placa, no para un microcontrolador de otro lenguaje ni para el Pico. Eso explica la elección del lenguaje. No explica saltarse el circuito.

El circuito es la lección 24: qué cable, qué resistencia, qué pin físico. La librería es la 25: el programa que enciende esa salida. Si hoy importas la librería y escribes un pin «para ver si Python funciona», estás encendiendo hardware sin la lección del hardware. Python funciona si python3 --version responde. No necesita un LED para demostrarlo. Y un LED mal puesto se quema igual en Python que en cualquier otro sitio: el GPIO sigue a 3,3 V, el físico 11 sigue siendo el GPIO 17, y los físicos 27 y 28 siguen reservados. El intérprete no cambia el voltaje.

Tampoco adelantes el sensor. Un número de temperatura, cuando llegue la lección 19, será una variable que tú escribes. El sensor de verdad es la lección 30. Hoy no hay lectura física que Python deba ir a buscar.

El Pico no entra en esta elección. Lleva otro mundo, con conversor analógico, y este header no. MicroPython en otra placa no es el python3 de Trixie. No copies un ejemplo del Pico en este archivo esperando el mismo pinout. Aquí el sistema es Linux y el intérprete es el del sistema.

Qué queda fuera de esta lección

No se escribe todavía el archivo que se guarda: es la 18. No se escribe el if del umbral: es la 19. No se lee todavía un traceback con calma: es la 20. No se abre Thonny como requisito para comprobar la versión. La terminal basta, y es la misma terminal de la lección 8. Thonny, cuando lo abras, tiene que estar usando este mismo python3. Si un día Thonny ejecutara otro intérprete, el archivo no significaría lo mismo. Eso se mira en la 18, no instalando un segundo Python.

Comprobar la versión no pide red. El intérprete está en la tarjeta. Si ayer apt update falló por no haber red, Python no se ha ido. Si alguien te dice que hay que actualizar pip antes del primer programa, te está sacando del sistema que ya tienes. El primer programa será un archivo de tu home, ejecutado con tu usuario, en la lección siguiente.

Aviso. Elegir Python no autoriza el header. GPIO a 3,3 V. Físico 11 es GPIO 17. Pines 27 y 28 quietos. Sin 230 V. Sin pip como root y sin volcar un instalador remoto al shell. La librería de los pines espera a la lección 25.

Qué hace el intérprete cuando le hablas

python3 sin más, y Enter, abre una conversación. El prompt cambia: deja de ser el dólar de bash y pasa a ser tres ángulos. Ahí cada línea se ejecuta al momento y no se guarda en un archivo. Sales con exit() o con Control y D. Al salir, lo que escribiste en esa conversación no está en el disco. Sirve para probar una suma. No sirve para el curso, que quiere un texto repetible. La lección 18 guardará el archivo. Hoy, si abres esa conversación para ver el prompt, ciérrala antes de seguir. No la confundas con la terminal: el dólar vuelve cuando Python se ha ido.

Una línea suelta, sin entrar en esa conversación, también existe:

python3 -c 'print("listo")'

-c ejecuta el texto de las comillas y termina. Tiene que imprimir listo y devolverte el dólar. Es la prueba de que el intérprete corre un programa mínimo, en tu usuario, sin archivo y sin red. No es el programa de la lección siguiente: al terminar, esa frase no queda guardada. Si las comillas se pelean con las de bash, no insistas con combinaciones raras. La prueba de la versión ya bastaba. El archivo, con sus propias comillas, llega enseguida.

command -v python3 imprime la ruta del programa, dentro del sistema, no en tu home. No la copies a tu carpeta «por si acaso». No la borres. No persigas un segundo Python más nuevo al lado de este. Dos intérpretes en la misma placa hacen que un archivo corra en uno y Thonny en el otro, y el fallo parece del archivo. Este curso tiene un intérprete: el python3 del sistema.

Por qué no otro lenguaje en este tramo

Hay otros lenguajes en el mundo y alguno puede estar en la imagen. No son el camino de las lecciones que vienen. La librería con la que encenderemos el físico 11 está escrita para Python. Cambiar de lenguaje ahora obliga a traducir cada ejemplo y a buscar otra librería que este curso no va a explicar. Un entorno de bloques puede servir para un primer contacto visual. No guarda el archivo de texto que python3 va a repetir, y no es donde vive el umbral de la lección 19.

Tampoco hace falta un editor todavía para entender el motivo. El motivo es el archivo futuro: legible, ya ejecutable con lo que la imagen trae, y alineado con la librería que aún no abres. Quien empieza instalando un entorno pesado, o una versión paralela, llega a la lección 18 con dos Pythons y ninguna certeza de cuál ejecuta el archivo. La certeza es la ruta que imprime command -v y la versión que imprime --version. Las dos se anotan en el papel, al lado del usuario de la lección 10.

El intérprete, al ejecutar, puede dejar una carpeta de caché junto a un programa grande. No la busques hoy y no la borres como ritual de limpieza. No es tu programa. Tu programa será el .py que guardes. Si un día aparece esa carpeta, se ignora. Borrarla no arregla un error de sintaxis y a veces solo obliga a rehacer un trabajo interno que no ves.

Por último, el idioma. Puedes imprimir frases en castellano, con tildes, porque el sistema y Python 3 hablan en Unicode. Si una tilde se ve rara, el fallo suele ser el archivo guardado en otra codificación, no el intérprete ausente. No reinstalas Python por una tilde. Guardas el archivo como el resto del sistema, y lo verás en la lección del archivo. Hoy la versión en inglés de --version es normal: el número no se traduce, y no por eso el sistema dejó de estar en español.

Lo que la versión no está diciendo

La línea de --version no dice que la red funcione, ni que el diario esté sano, ni que un paquete de más esté al día. Dice que este ejecutable arranca y que es la rama 3. Si más adelante un programa falla, no empieces por cambiar de versión. Empieza por la línea que el propio Python señalará, en la lección 20. Reinstalar el intérprete por un nombre mal escrito es el mismo reflejo que regrabar la tarjeta porque LS no existía.

Tampoco dice qué librerías hay. Que gpiozero esté pensada para este Python no significa que hoy debas comprobar si importa. Importarla ejecuta código de esa librería y, en algunas máquinas, toca el dispositivo de los pines solo con cargarla mal. No es la prueba. La prueba de la librería será un programa de la lección 25, con el circuito de la 24 ya hecho. Hasta entonces, una importación «inocente» es adelantar las dos.

Y no dice quién eres. python3 --version con tu usuario y la misma orden con sudo pueden encontrar el mismo ejecutable y aun así no ser la misma idea: la segunda presta el cero para una pregunta que no lo necesita. Si en el papel anotas la versión, anota también que la pediste sin sudo. Ese dato evita, dentro de unas lecciones, un archivo creado desde el intérprete equivocado.

Ejercicio en la Pi

En la terminal, ejecuta python3 --version. Anota la línea entera. Ejecuta también python --version. Si no existe el comando, anota esa frase y que no vas a instalar un alias. No uses sudo. No importes ninguna librería de pines. No conectes cables. Si no hay placa, escribe por qué el curso elige Python y cuál de los dos nombres es el de esta imagen.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Un programa de este curso es un archivo en tu carpeta: se llama hola.py y se ejecuta con python3 hola.py. Thonny hace lo mismo si guardas. La consola de abajo no es un archivo: lo que escribas ahí vive en la sesión.

El archivo es el programa

La lección 17 dejó el intérprete comprobado y la conversación de los tres ángulos cerrada. Esta lección crea el texto que sí se queda. En tu home, no en el arranque y no en una carpeta del sistema, un archivo de nombre hola.py. La extensión .py le dice a quien lo abre que es Python. El intérprete no exige la extensión para funcionar, y aun así la usamos: Thonny la reconoce y tú, dentro de un mes, también.

El contenido mínimo es una línea:

print("hola")

print escribe en la salida. Las comillas hacen que hola sea texto y no un nombre de variable. Sin comillas, Python buscaría una variable llamada hola, no la encontraría y eso sería un error de nombre, de la lección 20. Hoy lleva comillas. Nada más. Ni pines, ni umbrales, ni archivos que abrir.

Puedes crear ese archivo con el editor que ya tengas o, si prefieres no abrir aún Thonny, con una redirección en tu home:

cd
printf '%s\n' 'print("hola")' > hola.py
python3 hola.py

cd sin argumento te deja en tu carpeta, la de whoami. La redirección crea el archivo como tuyo, sin sudo. python3 hola.py lee ese archivo y lo ejecuta. Tiene que imprimir hola y devolver el prompt. La segunda vez que lo ejecutas, imprime otra vez hola. No se ha gastado. El programa es el archivo, y el archivo no se consume al correr.

Cambia el texto. Abre hola.py, pon print("hola otra vez"), guarda y ejecuta de nuevo. Sale la frase nueva. Si sale la vieja, no has guardado, o python3 está leyendo otro hola.py de otra carpeta. pwd y ls -l hola.py lo dicen. La fecha del listado tiene que ser la de ahora. Si es vieja, el guardado fue a otro sitio.

La ficha de referencia del intérprete sigue en Software, Python. Thonny no está en ese enlace. Se explica aquí.

Thonny, el editor y la consola

Thonny es el entorno que trae el escritorio de esta imagen para escribir Python sin pelearte con un editor pensado para otra cosa. Lo abres desde el menú de programación. Arriba, o en el centro, está el editor: el sitio del archivo. Abajo está la consola, con los tres ángulos. Son dos sitios distintos aunque compartan ventana.

El editor es el archivo, cuando lo guardas. Guardar pide un nombre y una carpeta. El nombre es hola.py. La carpeta es tu home, la misma de pwd. Si guardas en el escritorio o en una carpeta de descargas, el programa existe, pero python3 hola.py desde tu home no lo encontrará. Un programa que «va en Thonny y no en la terminal» es, casi siempre, un archivo guardado en otro sitio, no dos Pythons. Mira la barra del título: tiene que decir la ruta, no «sin título».

Sin título significa que todavía no hay archivo. Puedes escribir print("hola"), pulsar el botón de ejecutar y Thonny te pedirá guardar. Guarda. Si cancelas y ejecuta igual desde un temporal, al cerrar puedes quedarte sin nada con tu nombre. El hábito de este curso es guardar primero, ejecutar después, y comprobar con ls que hola.py está en tu home.

El botón de ejecutar corre el archivo del editor, el que está guardado, con el python3 del sistema. Tiene que salir hola en la consola. Es el mismo resultado que python3 hola.py en la terminal, si es el mismo archivo. Si no coincide, no reinstales Thonny. Compara rutas. Compara que no haya dos archivos con el mismo nombre. Y comprueba, en las opciones del intérprete solo si hace falta, que no apunta a otro Python distinto del que command -v python3 te dio en la lección 17. No instales un intérprete desde Thonny. El de la imagen basta.

La consola no es un archivo

Abajo, en los tres ángulos, puedes escribir print("hola") y Enter. Sale hola. Eso no ha creado hola.py. Ha ejecutado una línea en la sesión, igual que python3 sin archivo en la lección 17. La sesión muere al cerrar Thonny, al cerrar la consola o al reiniciar la placa. Lo que no estaba guardado en el editor no existe después. No está en una papelera de Python. No lo recupera el historial de bash. No lo guarda el diario de la lección 16, porque no fue un servicio: fue una línea de una ventana.

Por eso el gesto que parece trabajar y no trabaja es este: pruebas en la consola, ves que sale, cierras contento y al día siguiente no hay programa. El programa era la prueba. La prueba no se guardó. El archivo, si lo guardaste vacío o no lo guardaste, no contiene la prueba. Antes de cerrar, el editor tiene que mostrar print("hola") y el título tiene que ser la ruta de hola.py. Entonces cierras. Abres de nuevo. El editor sigue teniendo la línea. La consola está limpia, y es lo correcto: la consola no era el archivo.

Ejecutar con el botón después de reabrir lee el archivo y vuelve a imprimir. En la terminal, python3 hola.py hace el mismo viaje: del disco al intérprete, y a la pantalla. Los dos caminos son válidos. El curso los quiere iguales. Si solo funciona uno, la diferencia está en la carpeta de trabajo o en el archivo que cada uno abre, no en que Thonny tenga un Python privado que debas alimentar con pip.

El nombre del archivo no lleva espacios en este curso, ni tildes, ni un punto de más. hola.py es suficiente. Un nombre con espacio obliga a comillas en la terminal y es la primera fuente de un «archivo no encontrado» que en realidad es un nombre partido en dos. Guárdalo de una pieza. Si Thonny propone otra carpeta la primera vez, cámbiala a tu home antes de aceptar. La próxima vez suele recordar. Si no recuerda, la barra del título manda, no la costumbre.

Qué se rompe si mezclas los dos sitios

Escribes el programa bueno en la consola y dejas el editor con una línea vieja. Pulsas ejecutar. Sale lo viejo. La consola, debajo, enseña lo viejo y tú crees que «se ha olvidado» de lo que acabas de teclear ahí. No se ha olvidado: no lo ha leído. El botón no mira la consola. Mira el archivo. Corriges el archivo, guardas, ejecutas.

O al revés: corriges el archivo y, sin guardar, ejecutas. Thonny suele avisarte. Si el aviso se acepta mal, o si guardas con otro nombre, python3 hola.py sigue en la versión anterior. ls -l y la hora. El nombre exacto, mayúsculas incluidas. Hola.py y hola.py son dos archivos. Python no los junta.

No ejecutes con sudo ni guardes el archivo fuera de tu home para «que tenga permiso». Tu usuario puede crear hola.py y puede lanzar python3. Si un guardado te niega el permiso, estás intentando escribir fuera de tu carpeta. Vuelve a home. No prestes el cero para ganar esa escritura: el archivo nacería de root y la próxima edición te pediría sudo otra vez, que es la trampa de la lección 11.

La carpeta desde la que lanzas importa cuando el programa, más adelante, abra otro archivo por un nombre relativo. hola.py de hoy no abre nada. Aun así, lánzalo desde tu home, que es donde está. python3 /home/tuusuario/hola.py también vale, con tu nombre real, porque la ruta no depende de dónde estés. Las dos formas tienen que imprimir lo mismo. Si una dice que no hay archivo, la ruta está mal, y ese será el FileNotFound de la lección 20 aplicado al propio programa. No es que Python se haya desinstalado.

Un cambio pequeño que demuestra que guardaste

Deja el archivo así, en dos líneas:

print("hola")
print("desde el archivo")

Ejecuta con python3 hola.py. Tienen que salir las dos frases, en ese orden, una por línea. En Thonny, guarda y ejecuta. Las mismas dos frases. Cierra Thonny por completo, abre la terminal, ejecuta otra vez. Siguen las dos. Eso es «se vuelve a ejecutar»: no dependes de que la ventana siguiera abierta.

Quita la segunda línea, guarda, ejecuta. Sale solo hola. Has demostrado que manda el archivo de ahora, no un recuerdo de la consola. Vuelve a poner la segunda línea si quieres dejar el archivo completo. No hace falta borrarlo al acabar. Son dos líneas en tu home. No lo muevas a la partición de arranque. No lo conviertas en un servicio de la lección 14: un hola en cada arranque no enseña nada más y ensucia el diario.

Aviso. Guardar un .py no enciende pines. GPIO a 3,3 V. Físico 11 es GPIO 17. Pines 27 y 28 reservados. Sin 230 V. La consola de Thonny no sustituye al archivo, y el archivo no se ejecuta con sudo.

Texto plano, carpeta de trabajo y una segunda ejecución limpia

El archivo tiene que ser texto plano. Un procesador de documentos guarda otra cosa, con formato, aunque tú veas las letras print. Python abre eso, no reconoce el programa y se queja en la primera línea. El editor de Thonny guarda texto. Si creas el archivo desde la terminal con la redirección de esta lección, también es texto. No lo abras luego en un programa que «arregla las comillas» cambiándolas por comillas curvas. Las comillas del programa son las rectas. Una comilla curva es otro carácter, y el intérprete no la toma como cierre del texto. El fallo parecerá de sintaxis. La causa es el carácter, en esa línea, y se verá en la lección 20. Hoy se evita guardando desde Thonny o desde la terminal.

La carpeta de trabajo es desde donde lanzas python3, no siempre la carpeta donde vive el archivo. Si estás en tu home y el archivo está en tu home, el nombre hola.py basta. Si haces cd / y escribes python3 hola.py, el intérprete busca hola.py en la raíz, no lo encuentra y la queja es de archivo ausente, aunque el programa siga sano en tu home. No es un Python roto. Es una ruta. Vuelves con cd y repites, o escribes la ruta desde la raíz, con tu usuario real en medio. Thonny, al ejecutar, usa como carpeta de trabajo la del archivo guardado, que es lo cómodo. La terminal usa la de pwd. Por eso las dos pueden diferir sin que el archivo haya cambiado. Antes de discutir, pwd.

Una segunda ejecución limpia es cerrar la consola de Thonny, no solo borrar lo que se ve. Hay una acción de reiniciar la consola. Úsala si quieres el mismo efecto que cerrar: los nombres que hubieras creado en los tres ángulos desaparecen, y el archivo no. Si después de reiniciar la consola el botón sigue imprimiendo las dos frases, esas frases están en el archivo. Si no imprime nada, el editor está vacío o no guardaste. Reiniciar la consola no es reiniciar la placa. No hace falta sudo reboot para probar un print. Y apagar a tirones, otra vez, no forma parte de guardar un archivo: guardas, compruebas con python3 hola.py, y si terminas el día apagas con la orden de la lección 9.

Puedes dejar un comentario en el archivo, una línea que empiece por almohadilla. Python no la ejecuta. Sirve para una nota tuya, por ejemplo qué carpeta es la buena. No sustituye al print. Si comentas la única línea de print, el programa sigue siendo válido y no imprime nada. Silencio, aquí, no es un fallo: no había nada que imprimir. Es el mismo silencio útil de un ls en una carpeta vacía, aplicado a un programa vacío de salidas. Quita la almohadilla si querías la frase. No añadas líneas de pines comentadas «para más adelante»: adelantan la lección 25 dentro de un archivo que todavía es un hola.

Ejercicio en la Pi

Crea hola.py en tu home con print("hola"). Ejecuta python3 hola.py dos veces y comprueba que sale las dos. Ábrelo en Thonny, añade una segunda frase, guarda en la misma ruta y ejecuta con el botón. Cierra Thonny. En la terminal, python3 hola.py tiene que enseñar las dos frases. No dejes la única copia en la consola. No uses sudo. No abras la librería de pines. Si no hay placa, escribe qué queda en el disco y qué se pierde al cerrar la consola, con estos dos sitios separados.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

El dato de hoy es una temperatura que tú escribes en una variable. El umbral es concreto: si pasa de 28, avisa, y veintiocho justo no pasa de veintiocho. La decisión es un if, la sangría es el bloque de esa decisión, y el sensor de verdad llega en la lección 30.

Un nombre que guarda el número

En aviso.py, un archivo nuevo en tu home, la primera línea crea un dato:

temperatura = 27

A la izquierda, el nombre. A la derecha, el valor. Un solo igual es guardar, no comparar. A partir de esa línea, temperatura vale 27 hasta que otra línea lo cambie. No hay sensor detrás. No hay pin leyendo. El 27 lo has elegido tú para ensayar el caso tranquilo. Cuando quieras ensayar el caso de aviso, guardarás 29 en la misma línea y ejecutarás otra vez. El archivo es el de la lección 18: se guarda, se lanza con python3 aviso.py, y lo que no está en el archivo no cuenta.

El número va sin comillas. Con comillas sería un texto, la palabra 27, y compararlo con 28 no significa «más caliente»: significa otra operación, la de ordenar palabras, que no es este umbral. 27 es un entero. 28 también. Puedes usar 27.5 si algún día el dato trae décimas. Hoy el entero basta y se ve claro.

El nombre importa. temperatura se lee. t se olvida. Las mayúsculas distinguen: Temperatura sería otro nombre, vacío, y usarlo sería un error de nombre en la lección 20. Elige uno y repítelo igual. No hace falta declararlo en otro sitio. La línea del igual lo crea.

La referencia del lenguaje, sin el sensor y sin el circuito, está en Software, Python. El 28 de esta lección no sale de esa ficha: es el umbral del curso para poder decidir con un número que cabe en la cabeza.

Si pasa de 28, avisa

Pasar de 28 es ser mayor que 28. Veintiocho no pasa de veintiocho. Veintinueve sí. La decisión se escribe así:

temperatura = 27
if temperatura > 28:
    print("aviso")
else:
    print("sigue")

La primera línea guarda. La segunda compara: dos símbolos de mayor, no un igual. Al final de la línea del if van dos puntos. Abren el bloque. La línea de print("aviso") va sangrada: cuatro espacios. Esa sangría dice que el aviso solo ocurre cuando la comparación es cierta. else vuelve al mismo margen que el if, lleva sus dos puntos, y su print va sangrado otros cuatro espacios. Es la otra rama: cuando no pasa de 28.

Con 27, al ejecutar, sale sigue. No sale aviso. Si saliera aviso, la comparación está mal escrita, o el número guardado no es 27, o el print del aviso está fuera del if, al margen izquierdo, y entonces se ejecuta siempre. Con 29 guardado en la primera línea, y el archivo guardado de verdad, sale aviso. Con 28 exacto sale sigue, porque el curso dijo «pasa de 28», no «llega a 28». Si algún día el umbral debiera incluir el 28, la comparación sería otra, >=, y se diría en voz alta. No se cambia en silencio.

No conectes un sensor para «hacerlo real». La lección 30 trae la medida. Meter hoy un aparato en el header no da una variable: da un cable sin programa de lectura, y el riesgo de siempre. 3,3 V, físico 11 igual a GPIO 17, pines 27 y 28 sin tocar. El número, hasta esa lección, lo escribes tú. Por eso puedes probar las dos ramas en un minuto, cosa que un sensor clavado en 22 grados no te dejaría ver.

La sangría no es un adorno

En otros lenguajes el bloque se encierra entre signos y la sangría es solo para el ojo. En Python la sangría es el bloque. El intérprete cuenta los espacios. Cuatro espacios dentro, cero espacios en el if y en el else. Si sangras de menos, la línea queda fuera y se ejecuta siempre, o Python dice que esperaba un bloque sangrado. Si sangras de más, dice que esa sangría no la esperaba. Si mezclas tabuladores y espacios, el archivo puede parecer alineado y no estar alineado: el tabulador cuenta como otro carácter. En este curso se usan cuatro espacios, los que Thonny pone al pulsar el tabulador si está en su ajuste de origen, que es el de la imagen. No rellenes a ojo con espacios desiguales.

Los dos puntos son la otra mitad. Sin ellos, la línea del if no abre bloque y el fallo salta en la línea siguiente, a menudo con un signo bajo el principio del print. La causa es la línea de arriba, la que perdió los dos puntos. Lo verás con calma en la lección 20. Aquí la regla es escribirlos siempre al final del if, del else, del while y del for.

Un print al margen izquierdo, debajo del if, no «forma parte del si» por estar cerca. Forma parte del programa entero y corre en los dos casos. Eso no es un aviso condicional. Es un aviso mentiroso. La prueba es ejecutar con 27: si sale aviso, el print no está dentro. No cambies el 28 para forzarlo. Corrige la sangría y guarda.

Repetir sin copiar el archivo cuatro veces

Probar 26, 27, 28 y 29 editando la primera línea cuatro veces funciona, y es lento. Un bucle repite el mismo bloque con datos distintos. Este recorre cuatro números. El 28 está a propósito, para ver que no avisa:

for temperatura in (26, 27, 28, 29):
    if temperatura > 28:
        print(temperatura, "aviso")
    else:
        print(temperatura, "sigue")

for toma cada valor del paréntesis, lo guarda en temperatura y ejecuta el bloque sangrado. Luego el siguiente valor. Cuatro vueltas y se acaba. No es un bucle eterno. La sangría de dentro es de cuatro espacios respecto al for, y la del print es de ocho: cuatro por el for y cuatro por el if. El bloque de dentro pertenece al if, y el if pertenece al for. Si dejas el print del aviso a cuatro espacios, pertenece al for y no al if, y avisa en las cuatro vueltas. Otra vez la sangría es el significado, no el margen estético.

Tiene que salir, en este orden: 26 sigue, 27 sigue, 28 sigue, 29 aviso. Si el 28 avisa, has escrito mayor-o-igual o has comparado con otro número. Si no sale el 29, el bucle no llega, o el archivo que ejecutas no es este. ls -l aviso.py y la ruta, como en la lección 18.

Hay otro bucle, while, que repite mientras una comparación siga siendo cierta. Sirve, y es fácil dejarlo cierto para siempre. Un mientras eterno no devuelve el prompt. Lo cortas con Control y C en la terminal, o con el botón de parar en Thonny. Cortar no apaga la placa. No es un fallo de la tarjeta. Es un programa que no tenía salida. Por eso el ejemplo del curso es el for con cuatro números: se acaba solo. Si escribes un while, tiene que haber una línea dentro que cambie el dato hacia la salida, por ejemplo restar uno a un contador que empezó en un número pequeño. Sin esa línea, no lo dejes corriendo y no tires del cable.

El paréntesis con cuatro números no es el sensor ni es un archivo de medidas. Es la lista de ensayo. La lección 21, cuando exista, leerá un CSV del disco. La 30 pondrá en la variable lo que mida el aparato. El if de esta página no cambia ese día: seguirá preguntando si el número pasa de 28. Cambia el origen del número, no la decisión. Por eso se practica la decisión con un origen que controlas.

El else no es obligatorio. Si solo te importa avisar, puedes dejar el if y el print sangrado, y no escribir la rama del silencio. Con 27 el programa termina sin imprimir. Ese silencio es correcto: no pasaba de 28 y no habías pedido otra frase. No lo confundas con un programa que no arrancó. Arrancó y no tuvo nada que decir. El ejercicio, aun así, lleva las dos ramas, porque ver sigue demuestra que el if se evaluó y cayó del otro lado. Sin el else, un archivo que no imprime puede ser un éxito o un print mal sangrado que ni siquiera está. Con el else, las cuatro vueltas hablan y puedes contarlas.

Qué no decide este programa

No enciende un LED. Un aviso en pantalla no es un pin. No envía un mensaje a otra máquina: eso pediría red y no está escrito. No guarda la serie en un archivo: puedes verla en la terminal, y si cierras sin haber redirigido, la serie no queda en disco. El programa sí queda. La salida de una ejecución no es el programa, igual que la consola de Thonny no era el archivo.

No uses sudo para lanzarlo. No importes la librería de pines para «avisar de verdad». No leas un pin analógico: este header no tiene conversor, y el Pico no es la placa. El 27 y el 29 son datos de ensayo, no medidas. Si un compañero te pasa un archivo que ya habla con un sensor, no es el de esta lección. El de esta lección cabe en las líneas de arriba y se entiende sin hardware.

Aviso. El umbral no autoriza a cablear el sensor. Ese llega en la lección 30. GPIO a 3,3 V. Físico 11 es GPIO 17. Pines 27 y 28 reservados. Sin 230 V. La sangría se cuenta en espacios, no se adivina.

Guardar, comparar y no pisar el dato

Un error de dedo cambia el programa sin que la sangría se entere. Si en el if escribes un solo igual, no estás preguntando. Estás intentando guardar, y además dentro de una pregunta, que Python rechaza. La línea que se queja es esa. No es que 28 «no quepa». La comparación de igualdad, el día que la necesites, lleva dos iguales. Este umbral no la necesita: usa el mayor, porque pasar de 28 no es ser exactamente 28.

Tampoco pises el dato dentro del bloque sin darte cuenta. Una línea temperatura = 29 sangrada dentro del else cambiaría el nombre después de haber decidido, no antes. La decisión ya se tomó con el valor de la vuelta. Si la pones antes del if, entonces sí cambia lo que el if ve. El orden de las líneas es el orden de los hechos. El bucle lo enseña bien: en cada vuelta el for guarda el siguiente número y el if ve ese, no el de la vuelta anterior. No hace falta borrar la variable entre vueltas. El for la reescribe.

Puedes imprimir el propio número junto al texto, como en el ejemplo, para no adivinar qué vuelta fue. print acepta las dos cosas separadas por una coma y pone un espacio en medio. No sumes el número y el texto con un más: un entero y un texto no se suman, y el fallo es de tipo, otra queja distinta, en la línea del print. La coma evita esa mezcla. Si quieres una sola frase, construye el texto en otra lección. Hoy la coma basta para ver el 29 al lado de aviso.

El paréntesis de números es una serie fija. El orden es el que escribes. Si pones el 29 el primero, el aviso sale el primero, y el programa sigue siendo correcto: la decisión no depende de la posición, depende del valor. No ordenes la serie «para que quede bonita» y luego creas que el if se ha roto porque el aviso ya no está al final. Mira el número que acompaña a la palabra.

Cuando el archivo crezca, una decisión dentro de otra seguirá siendo sangría: doce espacios si hay tres bloques, siempre de cuatro en cuatro. No es el caso de hoy. Hoy hay dos niveles en el for y uno en el if suelto de la primera versión. Si te pierdes, vuelve a la versión corta, la de una sola temperatura, comprueba 27 y 29, y solo entonces restaura el for. Las dos versiones no se pegan una debajo de la otra: o guardas un número, o el for lo guarda por ti. Las dos a la vez hacen que el primer igual se pise enseguida y no llegues a verlo. Deja una. El ejercicio pide el for.

Ejercicio en la Pi

Crea aviso.py en tu home con el for de los cuatro números y el if de mayor que 28. Guárdalo. Ejecuta python3 aviso.py. Tienen que salir tres «sigue» y un «aviso», y el aviso solo en el 29. Cambia el 28 del if por otro número solo si quieres ver que el corte se mueve, y déjalo otra vez en 28. No conectes sensor. No dejes un while que no termine. Si la sangría se queja, no borres el archivo: la lección siguiente te dice qué línea mirar, y puedes corregir los cuatro espacios y guardar. Si no hay placa, escribe en papel qué imprime cada uno de 26, 27, 28 y 29 con este umbral.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Cuando Python se para, escribe un traceback: el archivo, la línea y, al final, el tipo de queja. SyntaxError, IndentationError, NameError y FileNotFoundError delatan una línea. Se corrige esa línea, se guarda y se ejecuta otra vez. No se reinstala Python.

Anatomía de la queja

Lanzas python3 aviso.py y, en vez de las frases, sale un bloque. Las primeras líneas dicen Traceback, el archivo entre comillas y la palabra line con un número. Debajo, copia la línea del archivo. A veces un acento circunflejo marca un carácter. Al final, el tipo y una explicación corta. Se lee de abajo arriba para saber el tipo, y se vuelve al número de línea para saber dónde. El tipo sin el número no te lleva al archivo. El número sin abrir el archivo no se corrige.

Esa queja sale en la terminal que lanzó el programa, o en la consola de Thonny si ejecutaste desde el editor. No sale en el diario del sistema, salvo que un servicio esté lanzando el programa, y el tuyo de hoy no es un servicio. No abras journalctl para un print mal sangrado. El traceback ya está delante. Copiarlo al papel incluye el número de línea. Sin el número, copiaste el nombre y perdiste el sitio.

La referencia del intérprete sigue en Software, Python. Esta lección no enlaza Thonny a esa ficha. Thonny enseña el mismo traceback en su consola. La línea es la misma.

SyntaxError, la frase que no cierra

Un archivo así, a propósito:

temperatura = 27
if temperatura > 28
    print("aviso")

Faltan los dos puntos. Python no puede abrir el bloque. El traceback suele señalar la línea siguiente, la del print, con el circunflejo al principio, y decir SyntaxError. La línea que delata no es siempre la línea culpable ella sola: es la línea donde el lector se perdió. Si el circunflejo está al inicio y la línea de arriba es un if, un for o un else, miras esa de arriba y buscas los dos puntos. Señalas las dos, en ese orden: la que el mensaje numera, y la inmediatamente anterior si el fallo es de cierre. No recorres el archivo entero.

Otra forma del mismo tipo: una comilla que no se cierra, print("aviso). El mensaje habla de cadena no terminada y señala esa línea. Ahí la línea numerada sí es la que abres. Añades la comilla, guardas, ejecutas. No cambias el 28. No tocas la sangría si la queja no habla de sangría.

SyntaxError aparece antes de ejecutar ninguna rama. No ha avisado ni ha seguido. El programa ni siquiera ha empezado a decidir. Por eso regrabar la tarjeta, o reinstalar Python, no puede ser la respuesta: el intérprete ha sido capaz de leer el archivo y de decirte dónde dejó de entenderlo. Eso es un intérprete sano.

IndentationError, el bloque que no cuadra

Este archivo tiene los dos puntos y una sangría de más en la segunda orden, o un print que no está dentro de ningún bloque:

temperatura = 27
print("listo")
    print("aviso")

La tercera línea no pertenece a un if. El mensaje dice IndentationError y numera esa línea. El circunflejo, si aparece, está bajo el inicio de la sangría. La línea que delata es la 3. Quitas los espacios para dejarla al mismo margen que las otras, o, si querías que perteneciera a un if, escribes el if encima y dejas cuatro espacios, no un puñado desigual. Guardas. Ejecutas.

La variante expected an indented block es la contraria: hay dos puntos y la línea siguiente no está sangrada. El número señala el sitio donde el bloque vacío se notó. Sangras cuatro espacios esa línea. No sangras todo el archivo «por si acaso». Un archivo entero sangrado es otro error, porque la primera línea no puede vivir dentro de un bloque que no existe.

Mezclar tabulador y espacios da este mismo tipo aunque a simple vista las columnas cuadren. Thonny puede enseñar los espacios si se lo pides en el menú de ver. Cuatro espacios, los del curso. Si la línea 3 es la numerada, no memorices la palabra inglesa y pases a otra lección: abres la línea 3.

NameError, el nombre que no existe

Este archivo compara un nombre que nadie guardó:

if temperatura > 28:
    print("aviso")

No hay línea temperatura =. Python llega a ejecutar, abre el if y no encuentra el nombre. El mensaje dice NameError, nombra entre comillas el que falta, y numera la línea del if. Esa es la línea que delata: ahí se usa el nombre. El arreglo puede ser esa misma línea, si el nombre está mal escrito, o una línea nueva encima que guarde el número. Temperatura con mayúscula no es temperatura. El error dirá el que escribiste, no el que querías. Lees las comillas del mensaje y las comparas con la línea numerada, carácter a carácter.

Un nombre usado solo en la consola de Thonny y luego en el archivo no cuenta. La consola no rellena el archivo. Si en la consola creaste temperatura y el botón falla con NameError, el archivo no la tiene. Se guarda en el archivo. No se «hereda» de la sesión. Es el mismo corte de la lección 18, visto desde el error.

FileNotFoundError, la ruta que no está

Este archivo pide un archivo que no has creado:

open("medidas.csv")

La línea es la 1. El mensaje dice FileNotFoundError y repite el nombre medidas.csv. No dice que el disco se haya roto. Dice que, desde la carpeta de trabajo, ese nombre no está. pwd y ls lo confirman. O creas ese archivo en esa carpeta, y será la lección del CSV cuando toque, o la ruta es otra y la escribes entera desde tu home. No crees el archivo en una carpeta y lo busques desde otra. Thonny y la terminal pueden tener carpetas de trabajo distintas, y el mismo open falla en una y no en la otra. La línea del open es la que miras. El arreglo es la ruta o la carpeta, no un permiso 777 y no un sudo.

El CSV de verdad, con filas y lecturas, es la lección 21. Aquí el nombre solo sirve para ver el error. No hace falta que el sensor exista. No hace falta que el archivo tenga datos. Si no ibas a abrirlo, borra esa línea. Dejar un open de un archivo ausente para «el día del sensor» solo añade un fallo fijo en la línea 1, delante del if que sí funcionaba.

Si el que no encuentra es el propio programa, python3 aviso.py dice que no hay ese archivo antes de entrar en Python del mismo modo, o con un mensaje del intérprete si la ruta iba dentro. Miras pwd. No miras el umbral. Un programa que no se encuentra no tiene traceback de la línea 3 porque no llegó a abrir ninguna línea. Distingue las dos quejas: la del sistema, que no halla el .py, y la de Python, que abre el .py y no halla otro nombre escrito dentro.

Corregir una línea y no el sistema

El ciclo es corto. Lees el número. Abres esa línea. La comparas con el tipo solo para saber qué mirar: cierre y dos puntos, sangría, nombre, ruta. Cambias eso. Guardas. Ejecutas otra vez. Si aparece otro error, es otra línea o la misma aún mal. Se repite el ciclo. No se acumulan cambios al azar. No se comenta el archivo entero para que «deje de fallar»: un archivo vacío no avisa cuando pasa de 28, y el silencio sería mentira.

No reinstales Python. No cambies a python a secas. No pongas sudo por si el error era de permiso: estos cuatro, en tu home, no lo son. Un permiso denegado sería otra frase, y en estos ejemplos no sale. No borres aviso.py para huir del traceback. El traceback es el mapa. Sin archivo no hay mapa y tampoco hay programa.

Thonny suele subrayar la línea antes de ejecutar, en los errores de sintaxis y de sangría. Ese subrayado es el mismo número. Puedes creerlo y aun así leer el texto de la consola, porque el número escrito es el que coincide con la terminal. Si el subrayado y el traceback discrepan, manda el número del traceback y guardas de nuevo: a veces el editor muestra una versión sin guardar y el intérprete leyó la vieja. Otra vez la lección 18.

Aviso. Un traceback no se arregla con cables ni con root. GPIO a 3,3 V. Físico 11 es GPIO 17. Pines 27 y 28 reservados. Sin 230 V. Señala la línea. No memorices el nombre como si fuera la reparación.

Contar la línea como la cuenta el archivo

El número es el del archivo guardado, desde la primera línea, contando las vacías. Una línea en blanco entre el igual y el if ocupa número. Si el traceback dice 4 y tú cuentas solo las líneas con letras, caes en la 3 y corriges la que no es. En Thonny el número está al margen del editor. Tiene que coincidir con el del mensaje. Si el editor muestra asterisco de «sin guardar», el número puede estar mirando un texto que el intérprete aún no ha leído. Guardas y vuelves a ejecutar antes de mover nada más.

El circunflejo no es un adorno del mensaje. Señala el carácter donde el lector se detuvo. En una comilla sin cerrar, cae cerca de esa comilla, en la línea numerada. En unos dos puntos ausentes, cae al principio de la línea siguiente. En una sangría inesperada, cae donde empiezan los espacios de más. Miras ese carácter, no la línea de más arriba «por sistema» ni la de más abajo. La regla de mirar la anterior solo vale cuando el circunflejo está al inicio y la línea numerada es inocente: un print bien escrito debajo de un if incompleto. Si el print ya tiene la comilla rota, la línea numerada es la buena y no subas a cambiar el umbral.

Los cuatro nombres se distinguen por lo que te mandan mirar en esa línea, y por nada más. SyntaxError: la frase no se puede leer; busca un cierre, unos dos puntos, una comilla. IndentationError: la frase se entiende pero el margen no es un bloque; cuenta espacios. NameError: la frase se ejecutó y un nombre no existe; compáralo con el igual de más arriba. FileNotFoundError: la frase se ejecutó y un archivo nombrado en esa línea no está en la carpeta de trabajo; compara con ls. Si memorizas los cuatro y no abres la línea, no has hecho la lección. Si abres la línea y no recuerdas el nombre inglés, sí la has hecho, siempre que el arreglo sea el de esa línea.

Una segunda ejecución después del arreglo tiene que pasar de largo del traceback. Si repite el mismo número y la misma línea copiada, no guardaste, o guardaste otro archivo, o estás lanzando otra copia de aviso.py. pwd, ls -l y la hora. Es el mismo diagnóstico de la lección 18, ahora con un número de línea en la mano. Si el número cambia, has avanzado: el primer fallo ya no está, y el nuevo se lee igual, sin prisa y sin instalar nada. Dos fallos seguidos no significan que el archivo esté maldito. Significan que había dos líneas mal y solo habías visto la primera, porque Python se para en la primera que no puede pasar.

File "aviso.py", line 3
    print("aviso")
IndentationError: unexpected indent

Ejercicio en la Pi

Parte de tu aviso.py que ya funciona. Añade, a propósito, una línea sangrada de más que no pertenezca a ningún bloque. Ejecuta python3 aviso.py. Copia el número de línea que salga, no solo el nombre del error. Abre esa línea, quita la sangría indebida o métela donde corresponda con cuatro espacios, guarda y ejecuta. Tienen que volver los sigue y el aviso del 29. Provoca después, si quieres, un NameError cambiando una letra del nombre, lee la línea que lo usa y restaura la letra. No borres el archivo. No reinstales nada. No pidas el CSV todavía. Si no hay placa, copia el traceback de la práctica y subraya en papel la única línea que mirarías primero.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

CSV es texto: una línea por medida, campos separados por comas, en un archivo de tu carpeta. Se abre en modo añadir, no en modo vaciar, y se escribe dentro de un with, que cierra el archivo al salir del bloque. El número sigue siendo una variable, como en la lección 19.

Una línea, una medida

En la lección 19 el programa decidía si un número pasaba de 28 e imprimía aviso o sigue. La impresión vive en la sesión. Cierras la terminal, o se va la luz después de un apagado mal hecho, y esa lista ya no está. El archivo sí puede estar, si lo escribiste en disco antes. Esta lección es ese paso, todavía con el número que tú guardas en una variable, no con un aparato.

CSV significa valores separados por comas. No es un formato privado. Es texto que tú puedes abrir con el mismo editor de hola.py. Cada medida ocupa una línea. Si la medida tiene dos campos, van en la misma línea separados por una coma. Un salto de línea, el carácter que print pone solo al final, separa una medida de la siguiente. Sin ese salto, la segunda medida se pega a la primera y deja de ser una línea.

El archivo se llama medidas.csv y vive en tu home, junto a aviso.py. No vive en la partición de arranque. No hace falta una librería para empezar: escribes texto. Hay un módulo llamado csv en Python, y esta lección no te pide memorizar su import. Con write y una coma basta. El día que un campo traiga comillas o saltos raros, ese módulo cita los campos. Hoy el campo es un número y una palabra, y se ven.

La ficha de referencia, la de consultar el formato y no la de saltarte el cierre, está en Software, CSV.

Añadir no es vaciar

Abrir un archivo tiene modo. El modo que esta lección usa es añadir, la letra a. El archivo, si no existe, se crea. Si existe, el puntero de escritura se coloca al final. Lo que ya había se queda. Cada ejecución suma líneas. Eso es un cuaderno de medidas: la de ayer sigue y la de hoy entra debajo.

El otro modo que vas a ver escrito en tutoriales es w. Abre y vacía. Si el archivo tenía cuarenta líneas y abres con w, esas cuarenta desaparecen en el momento de abrir, antes de que escribas nada. No es un fallo del disco. Es el modo. Para una medida que se acumula, w es el modo equivocado. No lo uses «porque el ejemplo de fuera lo usa». El ejemplo de fuera a menudo reescribe un informe entero. Tú estás anotando una línea más.

Hay un modo de lectura, r, que no escribe. Si lo usas por costumbre y luego llamas a write, Python se niega. La queja será de modo, en la línea del write, y se lee como en la lección 20: esa línea, no un Python nuevo. El modo de esta lección es a.

Por qué with cierra

Abrir pide al sistema un archivo y te devuelve un objeto. Ese objeto tiene memoria intermedia: lo que escribes puede quedarse un rato en RAM antes de llegar a la tarjeta, el mismo mecanismo de la lección 9 aplicado a un solo archivo. close vuelca y suelta el archivo. Si el programa termina bien y tú llamaste a close, la línea está. Si una excepción salta entre el write y el close, y el close era una línea más abajo que ya no se ejecuta, el archivo puede quedarse sin la última línea y, peor, abierto hasta que el intérprete muera del todo.

with ata el abrir y el cerrar al bloque. Entras, el archivo se abre. Escribes sangrado dentro. Sales del bloque, por el final normal o porque una línea de dentro ha fallado, y Python cierra. No es un adorno ni un import. Es la forma de que el cierre ocurra aunque tú no llegues a la línea donde lo habrías escrito a mano.

temperatura = 27
with open("medidas.csv", "a", encoding="utf-8") as medidas:
    if temperatura > 28:
        texto = "aviso"
    else:
        texto = "sigue"
    medidas.write(str(temperatura) + "," + texto + "\n")

Se lee en este orden, que es el orden de la práctica. Primero el with abre medidas.csv en modo añadir, con texto Unicode, y le pone el nombre medidas solo dentro del bloque. Después, sangrada, una escritura: el número, una coma, la palabra y el salto de línea. Una medida, una línea. Al terminar el bloque, el with cierra. No hay una llamada a close que puedas olvidar, y no debe haber un write después, ya fuera: el nombre medidas no se usa fuera. Si lo usas, el error es de archivo cerrado, en esa línea de después.

encoding="utf-8" fija cómo se guardan las letras. La palabra sigue no lleva tilde, y aun así se declara: el día que el texto lleve una, el archivo no depende de un ajuste raro de la sesión. El número se convierte con str porque write quiere texto, no un entero. Juntarlo con un más sin convertirlo es un fallo de tipo, en la línea del write. La coma de Python que separa argumentos de print no es la coma del CSV. Aquí la coma va dentro de las comillas del texto, porque es un carácter más de la línea.

Qué queda en el disco, y qué no

Ejecutas python3 aviso.py con ese bloque. Luego, en la terminal, cat medidas.csv enseña una línea, por ejemplo 27,sigue. Ejecutas otra vez sin cambiar el 27: aparece una segunda línea igual. Eso es añadir. Si la segunda ejecución hubiera vaciado, verías una sola línea y habrías usado w sin querer. ls -l medidas.csv crece de tamaño. El archivo es tuyo, como hola.py. No hace falta sudo para crearlo en tu home. Si el permiso se niega, estás escribiendo fuera de tu carpeta.

Puedes meter el with dentro del for de la lección 19. Cada vuelta abre, escribe una línea y, al acabar la vuelta, sale del bloque y cierra. Cuatro números, cuatro líneas, cuatro cierres. También puedes abrir una vez, escribir las cuatro líneas dentro del mismo bloque y cerrar al salir del for. Las dos formas son un with. La diferencia es cuándo ocurre el cierre: al salir del bloque, no en cada write. Si el bloque abarca las cuatro escrituras, un corte de programa a la mitad puede perder lo que aún no se había volcado. Si cada medida tiene su propio with, cada línea se cierra antes de la siguiente. Para un cuaderno que quieres conservar aunque el programa se caiga en la tercera medida, el with corto, una medida, es el que esta lección enseña.

No escribas la cabecera en cada ejecución. Una primera línea temperatura,estado ayuda a leer el archivo, y solo la primera vez. Si la metes dentro del mismo write de cada medida, el cuaderno queda con una cabecera por línea y ya no es una tabla. Si el archivo ya tiene bytes, no la repitas. Puedes mirar el tamaño antes de abrir, o aceptar que el ejercicio de hoy son solo líneas de datos y la cabecera se añade a mano una vez, con el editor, si la echas de menos. No es un import.

El 27 no ha salido de un sensor. Cambias la variable, guardas, ejecutas, y la línea nueva refleja el número nuevo. Cuando la lección 30 mida de verdad, la línea que escribe será la misma: un número, una coma, un texto, un salto. Cambia el origen del número, no el with. Hasta entonces, inventar una lectura de hardware dentro de este archivo es adelantar el circuito y la librería.

No abras el mismo archivo dos veces a la vez, una en el editor y otra en el programa, y esperes que las dos vean lo mismo al segundo. Guardar desde el editor mientras el programa lo tiene abierto en añadir puede pisar el final o quedarte con una mezcla. El ciclo es: el programa escribe y cierra, luego tú lees. Si quieres corregir una línea a mano, cierra el programa antes. Un CSV no se edita con el programa en marcha dentro del with. Y no lo conviertas en un servicio que escribe en cada arranque: cuatro líneas de ensayo bastan para ver el modo añadir. Dejarlo residente llenaría el disco de repeticiones del mismo 27, que no es una medida nueva.

Aviso. Guardar un CSV no enciende pines ni pide red. GPIO a 3,3 V. Físico 11 es GPIO 17. Pines 27 y 28 reservados. Sin 230 V. El modo añadir y el with son el mecanismo. No hace falta un import para esta línea.

La carpeta, el buffer y una lectura para comprobar

open con un nombre sin barras busca en la carpeta de trabajo, la de pwd, no siempre la carpeta donde está el .py. Si lanzas el programa desde otro sitio, el CSV aparece allí, o Python dice que no puede crear la ruta. Es el FileNotFound de la lección 20 si un directorio intermedio no existe, o un archivo sorpresa en una carpeta que no miraste. Lanza desde tu home, o escribe la ruta que cuelga de tu home. Thonny, al ejecutar, usa la carpeta del archivo guardado. La terminal usa pwd. Si cat no ve el archivo y el programa no se quejó, find no hace falta: mira la carpeta desde la que lanzaste.

El buffer es la razón de fondo del cierre, incluso cuando no hay excepción. write puede volver antes de que la tarjeta tenga los bytes. with al salir llama al cierre, y el cierre vuelca. Un programa que abre, escribe y se queda en un bucle eterno sin salir del bloque no ha cerrado: la línea puede no estar aún en el disco. Por eso el with de una medida es corto. Entras, escribes, sales, y solo entonces das la siguiente medida. No dejes el archivo abierto mientras esperas un sensor que esta lección no tiene.

Comprobar no es volver a abrir en modo añadir y escribir otra vez. Es leer. Puedes abrir en modo r dentro de otro with, o usar cat en la terminal, que no es Python y no cambia el archivo. Las dos lecturas tienen que coincidir. Si Python imprime una línea de más, esa línea la escribió tu programa, no el lector. Cuenta las ejecuciones. Dos lanzamientos, dos líneas de datos, más la cabecera solo si la pusiste una vez a mano.

Una coma dentro de la palabra partiría el campo en dos para quien lea el CSV en columnas. sigue y aviso no llevan coma. No construyas el texto con una frase larga y una coma en medio si luego quieres dos columnas. El número, la coma separadora, la palabra, el salto. Si más adelante un campo puede llevar coma, ese es el momento del módulo csv, y seguirá sin ser un import que esta práctica pida ordenar. La práctica ordena el with. El import no es una de las piezas.

El archivo sobrevive al cierre de Thonny, al cierre de la terminal y a un apagado bien hecho. No sobrevive a un modo w ni a un rm con el nombre mal puesto. No lo borres para «ver si se crea de nuevo» más de una vez: la primera creación ya te lo ha enseñado. Si lo borras, las medidas se van. El programa, al abrirlo en añadir, lo creará vacío y escribirá una línea. Parecerá que el cuaderno empieza hoy. Es lo que pediste al borrar, no un reset del with.

Ejercicio en la Pi

En tu home, guarda el programa de esta lección en aviso.py o en un archivo nuevo, con el with en modo a y una sola línea por ejecución. Lánzalo dos veces con python3. cat medidas.csv tiene que mostrar dos líneas, no una. Cambia la temperatura a 29, guarda, ejecuta, y la tercera línea tiene que decir aviso. No abras con w. No uses sudo. No importes una librería para esta prueba. No conectes un sensor. Si no hay placa, escribe las tres piezas del with en el orden correcto y qué le pasaría al archivo si el modo fuera el de vaciar.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Lo que pertenece al sistema se instala con apt: python3-gpiozero no se instala con pip. Lo demás, si de verdad hace falta, va en un entorno aparte, python3 -m venv entorno y source entorno/bin/activate. Un pip de root deshace el acuerdo de apt con el Python del sistema.

Dos inventarios que no deben pisarse

Un programa tuyo, hola.py o aviso.py, importa nombres. Algunos vienen con el propio Python: open no se instala. Otros vienen con la imagen, empaquetados por Debian, y apt sabe qué versión hay y qué archivos puso. Otros no vienen, y alguien te dirá que los bajes con pip. Pip lleva su propio inventario. Si los dos inventarios escriben en la misma carpeta del Python del sistema, el siguiente apt no entiende los archivos de pip, y el siguiente pip no entiende los de apt. Una actualización deja el intérprete a medias. En Raspberry Pi OS sobre Debian 13 Trixie, a 3 de octubre de 2026, ese choque se corta de raíz: el Python del sistema está marcado como gestionado por fuera. Pip, si lo lanzas contra él, se niega.

La negativa no es un fallo de red ni una versión vieja de pip. Es la marca. Pip ve que esa instalación no es suya y sale sin copiar nada. El texto habla de un entorno gestionado externamente. La salida correcta no es un interruptor para saltarse la marca. Ese interruptor existe, lo pegan los tutoriales, y reinstala el choque que la marca acaba de evitar. Este curso no lo usa. No lo busques. La negativa se lee como se leen los errores de la lección 20: dice el motivo, y el motivo es el sitio, no la falta de sudo.

Poner sudo delante empeora el sitio, no lo aclara. sudo pip escribe como root en el Python de todos, que es justo el inventario de apt. Además los archivos quedan de root. Es el fallo de la lección 11 y el de la 15 juntos. Si pip ya se negaba sin sudo, con sudo puede que la marca siga negándolo, o que un interruptor de root lo fuerce. En los dos casos la orden está mal. No es el camino de gpiozero ni de ninguna otra librería de estas lecciones.

La ficha del intérprete está en Software, Python. Thonny sigue sin enlazarse allí. Un entorno virtual no se elige desde un instalador de fuera.

Lo del sistema, con apt

gpiozero es la librería con la que la lección 25 hablará con el pin. En esta imagen el paquete se llama python3-gpiozero. El tres del nombre importa: es la build para el Python 3 del sistema, no un paquete genérico ni un módulo que pip deba ir a buscar a otro índice. Cuando haga falta tenerlo, la orden es la de apt, con red en ese momento, como en la lección 15:

sudo apt install python3-gpiozero

No hoy, si ya está y no vas a encender el pin. Comprobar si está no es importarlo en un programa de pruebas: importarlo puede tocar el dispositivo. Puedes preguntar al inventario de apt, que lee el disco y no el header. Si el paquete no está, se instala con esa orden el día de la lección 25, no con pip el día de hoy «para ir adelantando». Pip instalaría otra copia, en otro sitio o en el sitio prohibido, y la lección 25 no sabría cuál de las dos está importando.

Lo mismo vale para el módulo que crea entornos, si al lanzarlo Python dice que no está. El paquete es python3-venv, también de apt. No se arregla con pip. Es una pieza del sistema para poder tener luego un entorno limpio. Instalarla no instala gpiozero y no enciende nada.

Después de un apt, el programa se lanza con el python3 del sistema, el de command -v, sin prefijo de entorno. Ese intérprete ve los paquetes de apt. Un entorno recién creado, por defecto, no los ve. Por eso el programa del pin, cuando llegue, no se mete en un entorno vacío esperando que gpiozero aparezca solo. O usas el Python del sistema, donde está el paquete, o creas el entorno pidiéndole que vea los paquetes del sistema. Este curso, para el pin, usa el Python del sistema. El entorno es para lo demás.

Lo demás, en un venv

Un entorno virtual es una carpeta con su propio intérprete y su propio inventario de pip. Se crea en tu home, con tu usuario, sin sudo:

cd
python3 -m venv entorno
source entorno/bin/activate

-m venv llama al módulo venv del Python 3 del sistema. entorno es el nombre de la carpeta. Puede ser otro, y en este curso se llama así para no discutirlo. Dentro aparecen un intérprete, un pip y una estructura que no debes rellenar a mano. source entorno/bin/activate cambia esta terminal: pone esa carpeta delante en la búsqueda de comandos. El prompt suele mostrar el nombre entre paréntesis. El paréntesis es una pista. La prueba es command -v python3: tiene que apuntar dentro de entorno, no a la ruta del sistema que anotaste en la lección 17.

Activar no atraviesa ventanas. Otra terminal sigue en el sistema hasta que tú actives allí. Cerrar la terminal desactiva. deactivate desactiva y deja la carpeta en el disco: el entorno no se borra al salir, solo dejas de usarlo. Borrar la carpeta entorno borra las librerías que hubieras instalado dentro, no las de apt. Por eso gpiozero no se instala dentro. Si lo borras, no se lleva por delante el Python del sistema.

Dentro del entorno, pip escribe en la carpeta, como tu usuario. No lleva sudo. Un sudo pip con el entorno activo puede salir de la carpeta y escribir en el sistema, o crear archivos de root dentro de entorno que luego tu usuario no puede actualizar. Las dos cosas rompen el motivo de haberlo creado. Si una librería que no es del sistema hace falta de verdad, se instala con el pip del entorno, sin sudo, después de activar, y se anota el nombre. Hoy no hay ninguna que instalar para seguir el curso. Crear el entorno y ver que command -v cambia es la práctica. No rellenes el entorno «por si acaso».

Por qué la imagen se niega

En un Python que tú hubieras compilado en tu casa, pip sería el dueño de esa carpeta y apt no la miraría. En Trixie el intérprete es un paquete. Sus librerías de sistema también. La marca de gestionado por fuera le dice a pip: esta instalación tiene otro dueño. Instalar aquí rompería las actualizaciones. La herramienta se detiene antes de copiar. No es una moda de un tutorial. Es el acuerdo de Debian 13, y Raspberry Pi OS lo trae porque es esa base.

La gente que pega el interruptor de saltarse la marca obtiene el pip de root funcionando un rato. El siguiente apt que toque el mismo módulo se queja de archivos que no son suyos, o los sustituye y el programa que pip instaló deja de importar. El arreglo de entonces es más largo que haber creado entorno el primer día. Por eso la negativa se acepta. No se vence.

Tampoco se rodea bajando un script de instalación y volcándolo al shell, con sudo o sin él. Eso ejecuta lo que haya al otro lado en el momento de la tubería, no deja un paquete de apt y no deja un entorno reproducible. La lección 15 ya lo rechazó para el sistema. Aquí se rechaza otra vez porque los textos de Python lo ponen como «forma de instalar pip». Pip del sistema, si hace falta tocarlo, es un paquete de apt. Pip del entorno viene creado con el venv. No hay un tercer pip que descargar.

Qué no haces en esta lección

No enciendes el GPIO. No importas gpiozero. No escribes el circuito: es la 24, y el programa es la 25. No creas el entorno con sudo ni dentro de /usr. No activas el entorno y lanzas ahí el aviso.py creyendo que es obligatorio: ese programa solo usa el Python de serie y sigue yendo con el intérprete del sistema. El entorno es una herramienta para librerías que apt no empaqueta, no un paso previo de cada archivo.

Si activaste y el python3 aviso.py se comporta igual, bien: no has añadido librerías. Si un día, dentro del entorno, un import del sistema falla, es porque el entorno no mira los paquetes de apt. Sales con deactivate y usas el Python del sistema para ese programa. No reinstales la librería con pip para callar el import. En el caso de gpiozero, reinstalarla con pip es exactamente lo que esta lección prohíbe.

Aviso. Ni pip de root ni un instalador remoto. GPIO a 3,3 V cuando llegue el circuito. Físico 11 es GPIO 17. Pines 27 y 28 reservados. Sin 230 V. Hoy no hay montaje y no hay import de pines.

Cómo se reconoce que sigues en el sitio correcto

Después de activar, python3 -c 'import sys; print(sys.prefix)' imprime la carpeta del entorno, la tuya. Después de desactivar, el mismo comando imprime una ruta del sistema, bajo el árbol de la imagen, no bajo tu home. Esa ruta es la prueba, más firme que el paréntesis del prompt, porque el paréntesis se puede copiar en un texto y la ruta no se inventa. Anótala al lado de la de la lección 17. Son dos intérpretes a propósito. El error sería no saber cuál está hablando.

Thonny, si lo dejas en el intérprete del sistema, no ve lo que instales dentro de entorno. Si un día le dices que use el intérprete del entorno, dejará de ver gpiozero salvo que ese entorno se haya creado viendo los paquetes del sistema. No cambies el intérprete de Thonny en esta lección. El botón de ejecutar sigue con el Python de la imagen, que es con el que hola.py y aviso.py ya funcionan. Un entorno no se «activa» dentro de Thonny con source: source es de la terminal. Meter esa línea en un archivo .py no activa nada. Es texto de shell, no de Python, y la lección 20 te lo marcaría como sintaxis rota en la primera línea.

La carpeta entorno es grande comparada con hola.py y no se copia al CSV ni se sube a un servicio. No la muevas a la partición de arranque. No la crees dos veces con el mismo nombre si la primera está a medias: o la terminas, o la borras entera y vuelves a lanzar python3 -m venv entorno. Un entorno a medias, cortado porque se fue la red a mitad de un pip que no debías lanzar, se reconoce porque activate existe y el pip de dentro falla. Se borra la carpeta y se repite la creación, que no necesita red. El pip que no debías lanzar sigue sin lanzarse en el segundo intento.

Si apt te dice que python3-gpiozero ya está en la versión más nueva, no hay nada que instalar y no hay nada que pip deba «poner al día». Más nuevo por pip, encima del paquete, es la mezcla. Te quedas con el de apt. La lección 25 importará ese. Si el import falla ese día, se lee el error, se mira command -v python3 por si seguías dentro del entorno, y se sale. No se responde al fallo con sudo pip.

Ejercicio en la Pi

En tu home, python3 -m venv entorno. Si falta el módulo, instálalo con apt como python3-venv, no con pip. Activa con source entorno/bin/activate y anota lo que imprime command -v python3. Tiene que vivir dentro de entorno. deactivate y vuelve a mirar el comando: tiene que volver el Python del sistema. No instales gpiozero con pip. No uses sudo pip. No importes la librería de pines. Si no hay placa, escribe las dos columnas: qué entra por apt y qué entra por el venv, y por qué el pip suelto sobre el sistema se niega.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

El físico es el agujero y BCM es el nombre que el chip le da a un GPIO: el físico 11 es el BCM 17. Los físicos 2 y 4 son 5 V y no son GPIO; el físico 6 es masa; los físicos 27 y 28 están reservados. Un GPIO aguanta 3,3 V y no admite 5 V.

Dos numeraciones en el mismo peine

El header de cuarenta pines es una pieza física. Los agujeros se cuentan en orden, de uno a cuarenta. Ese es el número físico. Lo ves en la serigrafía si la hay, y lo ves en el dibujo de esta página. No depende del programa. El agujero 11 es el undécimo aunque tú no escribas una línea.

BCM es otra cuenta. Es el número que el procesador usa para ese GPIO dentro del chip. Los fabricantes de la placa eligieron qué número BCM sale a qué agujero, y el mapa no es «el físico y el BCM son el mismo». Casi nunca lo son. Quien dice «pin 17» sin decir cuál de las dos cuentas está a punto de tocar el agujero equivocado. En este curso, cuando se diga GPIO 17 o BCM 17, es el nombre del chip. El agujero donde vive es el físico 11. Cuando se diga físico 17, es otro agujero: el segundo de 3,3 V, alimentación, no una señal.

Puedes tocar los agujeros en el dibujo de esta misma página, el pinout de la enseñanza. El dibujo grande, con el límite fino de cada alimentación, está en Hardware, el pinout de 40. Esta lección no copia ese límite en miliamperios. Inventarlo aquí sería darte una cifra falsa con pinta de precisa. Si necesitas el número fino, lo lees allí, en la ficha del hardware, no en un comentario de un programa.

Los agujeros que hay que saber antes de un cable

Físico 1: 3,3 V. Es alimentación. Sirve, con cuidado y en lecciones que lo digan, para alimentar un circuito que acepte esa tensión. No es un GPIO. No lo enciendes y apagas con un programa. Está a 3,3 V mientras la placa está encendida. Confundirlo con «el pin de señal de 3,3 V» y ponerle un LED a pelo es adelantar la lección 24 mal: ni siquiera pasarías por el GPIO.

Físicos 2 y 4: 5 V. También alimentación, la gorda, la que entra desde la fuente hacia la placa y se ofrece en esos dos agujeros. No son GPIO. No hay programa que los ponga a cero. Un cable desde el 2 o el 4 hacia un GPIO mete 5 V en una patilla que no los admite. Eso quema la patilla, a veces el chip. No es un aviso teórico de la lección del LED: es la razón por la que el 5 V y la señal no se tocan. El LED del curso no se prueba «a ver si brilla más» desde el pin 2.

Físico 6: masa, GND. Es el retorno. Todo circuito de este curso cierra contra masa, no contra otro GPIO y no contra el 5 V. Hay más masas en el header. La del curso, para no elegir al tuntún, es el físico 6, al lado de los primeros pines, fácil de señalar en el dibujo. Masa no es «el negativo de un enchufe de pared». Es el cero del circuito de la placa. Nada de esto se conecta a 230 V.

Físico 11: GPIO 17, número BCM 17. Es la señal del curso. Cuando la lección 25 la ponga en alto, habrá unos 3,3 V entre ese agujero y masa. Cuando la ponga en bajo, habrá cerca de cero. No hay un tercer estado de 5 V. El programa no puede pedirlo. La patilla no lo da y no lo recibe.

Físicos 27 y 28: reservados a la EEPROM del HAT, el identificador que una placa de extensión lee por esos dos agujeros. En el dibujo salen como ID_SD e ID_SC. No son pines libres «que nadie usa». Usarlos como LED o como sensor estorba esa memoria y puede dejar un HAT sin identificar, o pelear con el arranque de la extensión. En las prácticas de este curso no se cablean. Aunque un mapa diga que por debajo hay un GPIO, la regla de la práctica es no usarlos. El 27 físico no es el BCM 27. Buscar el número 27 en el borde y clavarlo es el error de mezclar las dos cuentas, precisamente en el agujero reservado.

Por qué la señal es de 3,3 V y no de 5

El chip que hay detrás del GPIO trabaja a 3,3 V. Un uno lógico es esa tensión, medida contra masa. Un cero es masa. No hay una opción en el programa para «sacar 5 V por el GPIO 17». Quien necesita 5 V para un relé o para una tira usa el pin de alimentación 2 o 4 para la potencia, y aísla la señal, en una lección que lo explique con el circuito delante. Esta no lo explica porque todavía no hay montaje. Lo que sí queda cerrado: meter 5 V en un GPIO, venga del pin 2, de otro aparato o de un sensor alimentado a 5 V, empuja la patilla por encima de lo que admite. La patilla se daña. A veces sigue el resto del chip. El daño no se deshace cerrando el archivo de Python.

Por eso un nivel que «en otro curso era 5 V» no se copia. Arduino de 5 V y esta Pi no hablan el mismo uno lógico. Un cable directo entre un uno de 5 V y el físico 11 no es una conexión de datos. Es el fallo de esta lección. Si más adelante un sensor solo existe en 5 V, se dirá cómo traducirlo. No se puentea «un momento para probar».

El 3,3 V del físico 1 y el 3,3 V de un GPIO en alto no son el mismo papel aunque la tensión se parezca. El físico 1 está siempre ahí, con la corriente que la fuente de 3,3 V pueda dar, y esa corriente también tiene límite en la ficha de Hardware. El GPIO en alto solo da la corriente de una patilla, bastante menor, y solo cuando el programa lo pone en salida. Usar el GPIO como si fuera la fuente del pin 1 calienta la patilla. Usar el pin 1 como si fuera un GPIO que el programa apaga no se apaga: sigue a 3,3 V. Las dos confusiones se evitan nombrando el agujero.

No anoto amperios. El límite fino, el de la patilla y el de los pines de alimentación, cambia de lectura si lo redacto de memoria. Está en Hardware, el pinout de 40. Aquí la regla que no depende de esa cifra: señal a 3,3 V, nunca 5 V hacia un GPIO, masa al físico 6, señal del curso en el físico 11.

Lo que este header no es

Esta Pi, con Linux, no tiene un conversor analógico en el header. No hay un agujero que te devuelva «cuántos voltios hay, en un número». Las entradas del GPIO son umbral: por encima, uno; por debajo, cero. Cómo se elige ese umbral y qué pasa con una señal que se queda en medio es la lección 29. No se explica aquí. El Pico sí tiene conversor, y el Pico no es este curso. Un ejemplo escrito para el Pico que lee un analógico en un pin no se traslada al físico 11. En el físico 11, cuando sea salida, habrá alto o bajo, no una tensión a medias medida por la propia placa.

Tampoco es el momento de activar interfaces. I2C, SPI y la memoria del HAT tienen agujeros propios. Los 27 y 28 ya están reservados aunque tú no actives nada. No los «liberes» en un menú para ganar dos pines. No ganas dos pines de práctica. Ganas un conflicto con la EEPROM.

Hoy no se monta el LED y no se llama a gpiozero. Saber el agujero es anterior al cable, y el cable es la lección 24. Si ya tienes algo pinchado de un experimento anterior, quita corriente con el apagado de la lección 9 y quita esos cables antes de seguir. Un header lleno de puentes mientras lees números es cómo el físico 2 acaba en el físico 11 sin que el texto lo pida.

Aviso. GPIO a 3,3 V. Físico 11 es BCM 17. Físicos 2 y 4 son 5 V y no entran en un GPIO. Físico 6 es masa. Físicos 27 y 28 no se usan. Sin 230 V. Sin amperios inventados: el límite fino está en Hardware. Sin ADC en este header: eso es la lección 29, y el Pico no es esta placa.

Cómo se nombra en voz alta para no clavarlo mal

Antes de un cable, la frase completa tiene las dos cuentas y el papel. «Físico 11, BCM 17, señal de 3,3 V.» «Físico 6, masa.» «Físico 2, 5 V, alimentación, no se acerca a un GPIO.» Si la frase no te sale, no tienes aún el agujero. El dibujo de esta página está para señalarlo con el dedo en la pantalla, no para sustituir la frase. El de Hardware está para el límite que aquí no copio. Los dos enlaces dicen lo mismo sobre el 11 y el 17. Si un tercero, un foro, dice que el GPIO 17 es el agujero 17, el foro está usando una sola cuenta y está mal para esta placa.

La orientación del header también se mira. El físico 1 está en una esquina, marcada en la placa, no en la esquina que te quede más cómoda al girar la caja. Si giras la placa y cuentas desde el otro extremo, el 2 y el 1 se cambian de sitio en tu cabeza y el 5 V acaba donde creías la señal. El dibujo tiene el 1 arriba a la izquierda de su propio esquema. Tú lo haces coincidir con la esquina marcada, no al revés. Un minuto de coincidencia evita el cable del fallo.

Los GPIO que no son el 17 existen y no son la práctica. Nombrarlos todos no cabe y no hace falta. El mapa completo se consulta en el pinout, no se memoriza. Lo que se memoriza es el puñado de esta lección, porque es el que el siguiente montaje va a tocar: 11 como señal, 6 como masa, y la prohibición del 2, del 4, del 1 usado como si fuera señal, y del 27 y el 28. El resto se queda sin cable hasta que una lección lo nombre con las dos cuentas.

Un HAT real usa los 27 y 28 para leer su memoria y saber qué es, y puede usar otros GPIO para su función. Si algún día pones un HAT, sus pines ya no están libres para tu LED. Hoy no hay HAT en el ejercicio. La reserva de los 27 y 28 vale igual, con o sin placa puesta: no son de las prácticas. No los puentees «mientras no hay HAT» para una prueba que el físico 11 ya puede hacer.

La masa del físico 6 es la misma red de masa que las otras masas del header. Elegirla es para tener un agujero fijo en el texto y en el dibujo, no porque las otras sean de otro voltaje. No hace falta cablear tres masas. Una, la 6, cierra el circuito de la lección 24. Duplicar masas no da más 3,3 V y sí da más sitios donde un cable suelto puede tocar el 5 V.

Cuando dudes entre dos agujeros, no desenchufes a medias para «probar cuál chispea». No hay chispa que buscar y sí hay un pin que quemar. Paras, miras el dibujo, dices la frase con las dos cuentas y solo entonces, en la lección siguiente, hay cable. Esta lección termina en el papel y en el enlace del pinout, con el header como estaba.

El color del dibujo ayuda y no manda. En esta página la alimentación y la masa no se pintan igual que un GPIO, y los reservados tampoco. Si tu pantalla cambia el contraste, lees el texto del agujero, no el recuerdo del color. Un GPIO pintado de otro tono sigue siendo 3,3 V. Un 5 V pintado con el color que te guste sigue sin ser señal. La frase escrita gana al color.

Ejercicio en la Pi

Con la placa apagada o, si está encendida, sin tocar el header, abre el pinout de esta página y señala, sin cablear: físico 1, físicos 2 y 4, físico 6, físico 11, físico 17, físicos 27 y 28. Al lado de cada uno escribe en papel qué es, con las dos cuentas cuando haya dos. No inventes la corriente que aguanta. Si miras el límite, que sea en Hardware. No conectes el Pico ni un sensor de 5 V. Si no hay placa, copia el esquema de los agujeros y tacha «físico 17 es el GPIO 17».

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

El camino de la corriente es uno solo, en serie: del GPIO 17, el físico 11, a una resistencia de unos 330 ohmios, de ahí al LED, y del LED a masa en el físico 6. Sin resistencia no hay nada que limite la corriente cuando el diodo conduce. Se hace en placa de pruebas, no se suelda, y el programa es la lección 25.

Un solo camino, cuatro piezas

La lección 23 dejó los agujeros nombrados y sin cable. Esta los une con un LED, que es un diodo: deja pasar la corriente en un sentido y casi no la deja en el otro. Cuando conduce, la tensión entre sus patas se queda en la suya, más baja que los 3,3 V del GPIO en alto. La diferencia no puede caer en un cable directo. Tiene que caer en una resistencia, puesta en serie, de manera que la corriente cruce el mismo camino: pin, resistencia, LED, masa. No hay un atajo al lado. Un atajo sería un cable que une el físico 11 con el LED saltándose la resistencia, o un LED con las dos patas en el mismo nodo. Eso es el LED a pelo, y no se monta.

La resistencia de este curso es de unos 330 ohmios. Unos, porque en la caja puede haber 300 o 330 y el papel es el mismo: limitar. No es un puente. No es un trozo de cable del mismo color. No se sustituye por «ya veré la corriente en el programa». El programa, en la lección 25, solo podrá poner el pin a 3,3 V o a masa. No podrá elegir un amperio. El límite fino de lo que la patilla aguanta está en Hardware, el pinout de 40, y no lo copio aquí. La resistencia es la pieza que hace que ese límite no se negocie con un cable pelado.

El orden eléctrico de la resistencia y el LED, mientras estén en serie en el mismo camino, da igual: primero la resistencia y luego el LED, o al revés, la corriente es la misma. El sentido del LED no da igual. El sentido que este curso monta es: desde el físico 11, la resistencia, el ánodo del LED, el cátodo del LED, el físico 6. El ánodo es la pata larga. El cátodo es la pata corta, y el cuerpo del LED tiene un chaflán de ese lado. La pata larga mira hacia la resistencia que viene del GPIO. La corta mira hacia masa. Al revés, con 3,3 V, lo habitual es que no luzca. No es una razón para quitar la resistencia y probar «más fuerte» desde el pin de 5 V.

Masa es el físico 6. Señal es el físico 11, BCM 17. Ni el físico 1, ni el 2, ni el 4, ni el 17 físico, ni el 27, ni el 28. Si el esquema y el header no coinciden, manda la lección 23 y el pinout de esta página. Se mira antes de pinchar.

Por qué la resistencia va sí o sí

Un LED apagado, o polarizado al revés dentro de lo que estos 3,3 V suelen permitir, apenas conduce. En el sentido bueno, en cuanto la tensión basta para que conduzca, el diodo no se porta como una resistencia estable. Se porta como un camino fácil. La corriente sube todo lo que la fuente de esa patilla pueda entregar. La patilla de un GPIO no está hecha para ser la fuente de un diodo desnudo. Se calienta, deja de ser un pin fiable, o muere. El LED también puede morir. La resistencia en serie es el tramo que obliga a la corriente a pagar una caída. Sin ese tramo no hay montaje del curso, aunque el LED sea pequeño y «de los de tablero».

No calculo aquí el número fino. Hace falta la tensión propia del LED, que depende del color y del modelo, y hace falta el límite de la patilla, que está en Hardware. Con esos dos datos se elige resistencia. El curso ya ha elegido: unos 330 ohmios, en serie, para este GPIO a 3,3 V y un LED normal de señal. No la bajes a un valor de unos pocos ohmios para que «se vea de día» y no la quites. Si con 330 no se ve, primero se revisa el sentido del LED y el agujero, en la lección 25, cuando haya programa. No se revisa alimentando desde 5 V.

Tampoco pongas la resistencia en paralelo con el LED, creyendo que «está en el circuito». En paralelo, el LED sigue teniendo un camino directo desde el pin hasta masa, y la resistencia es un segundo camino al lado. El diodo sigue a pelo. Serie significa un único hilo: sales del 11, entras en la resistencia, sales de la resistencia, entras en el LED, sales del LED, entras en el 6. Si puedes ir del 11 al 6 sin cruzar la resistencia, el montaje está mal.

Placa de pruebas, no soldadura

La placa de pruebas es un bloque de agujeros donde unas tiras de metal unen filas por dentro. En la zona central, lo habitual es que cinco agujeros de una fila sean el mismo nodo, y la fila de al lado sea otro nodo. El canal del medio parte las filas en dos mitades que no se tocan. Las tiras largas de los bordes, si la placa las tiene, corren a lo largo y sirven de alimentación. Hoy no las uses para 5 V. No hace falta alimentación de borde: el circuito sale del header y vuelve al header.

Cada pata del LED va a una fila distinta. Si las dos patas caen en la misma fila de cinco, están en cortocircuito y el LED no está en el camino: lo está el metal de la placa. La resistencia une la fila del ánodo con la fila donde llega el cable del físico 11, o ella misma es el puente entre el cable del 11 y el ánodo, con cada extremo en una fila. El cable de masa sale de la fila del cátodo y entra en el físico 6. Cuatro nombres, cuatro sitios. Antes de soltar el dedo, recorres el camino con la punta de un lápiz sobre la placa, no con corriente.

Se monta sin alimentación. Si la Pi está encendida, primero el apagado de la lección 9, esperas, quitas corriente, y entonces pinchas. Mover un cable con el header vivo es cómo el físico 11 y el físico 2 se rozan un instante. Un instante basta. La placa de pruebas sujeta por presión. Las patas se doblan un poco y entran rectas, no tumbadas contra el agujero de al lado. Un contacto flojo se ve luego como un LED que no luce, y se aprieta con la placa apagada, no se «arregla» con más tensión.

No se suelda. El estaño fija un empalme para quedarse: un cable que ya no vas a quitar, una placa que ya no es de ensayo. Eso es la lección 28. Aquí el circuito es de quita y pon, precisamente para poder corregir el sentido del LED y la fila equivocada sin destrozar patas. Soldar ahora pegaría un error. Aprender a soldar sobre el único LED que tienes, en el mismo rato en que aún confundes el físico 11 con el 17, junta dos dificultades que el curso ha separado. La 28 llegará cuando el empalme se quede. Hoy la placa de pruebas es el montaje completo, no un ensayo de lo que luego soldarás sí o sí.

Qué no va a ocurrir al encender, y está bien

Cuando vuelvas a dar corriente, el LED no tiene por qué lucir. Nadie ha puesto el GPIO 17 en salida. Al arrancar, esa patilla no es una fuente encendida. El circuito puede estar perfecto y oscuro. La oscuridad no se cura puenteando el físico 1 o el físico 2 al LED. El físico 1 es 3,3 V fijos, siempre, y saltarte el GPIO enseña un circuito distinto del que la lección 25 va a gobernar. El físico 2 es 5 V, y ya está prohibido. Se enciende la Pi, se mira que sigue entera, y se deja el LED apagado hasta el programa.

gpiozero no se importa hoy. No hay una línea que «pruebe el montaje». Probarlo a mano, con un cable desde el 11 hasta 3,3 V, tampoco: o dejas el pin en un estado raro o acabas usando el pin 1. El montaje se da por entendido cuando el camino, el sentido y la resistencia se pueden decir en voz alta mirando la placa. La luz es la lección siguiente.

Si al montar te sobra un cable y lo dejas pinchado en el 4 «por si el programa lo pide», quítalo. El programa no va a pedir 5 V. Un cable de más en alimentación es una antena de errores. El header, al acabar, tiene dos conexiones de este circuito: la del físico 11 y la del físico 6, y nada en el 2, el 4, el 27 y el 28. La resistencia y el LED están en la placa de pruebas, no colgando del peine con las patas retorcidas en el propio agujero del header. Las patas de un LED no entran bien en el header y sí entran en la placa de pruebas. Del header salen dos cables, o un cable y la pata si algún montaje raro lo pide. El de este curso son cables al breadboard.

Aviso. Nunca el LED a pelo. Unos 330 ohmios en serie. Físico 11, GPIO 17, a 3,3 V. Masa en el físico 6. Nada de 5 V en el LED ni en el GPIO. Físicos 27 y 28 sin cable. Sin 230 V. Sin soldadura: la soldadura es la lección 28. Sin programa: gpiozero es la 25. Sin amperios inventados.

Reconocer la resistencia y no el puente

Una resistencia de unos 330 ohmios, en el marcado de cuatro bandas que suele traer, se lee tres, tres, y un cero: naranja, naranja, marrón. La cuarta banda es la tolerancia y no cambia el papel en el circuito. No confundas ese marrón con el negro, que sería un multiplicador de uno y dejaría la pieza en unos 33 ohmios, demasiado baja para este LED, ni con el rojo, que la subiría a unos miles y la dejaría tan tenue que creerías el circuito roto. Si la tuya no trae bandas y trae números, lee el valor impreso y quédate en ese entorno de unos 330. Si no sabes leerla, no la sustituyas por un cable «hasta la lección que lo calcule». El cable es el montaje prohibido. Una resistencia del entorno justo es el montaje.

El cuerpo de la resistencia no tiene sentido. Da igual qué extremo mire al pin. El LED sí tiene sentido, y ya está dicho. En la placa de pruebas, deja aire entre filas: la pata de la resistencia y la pata larga del LED comparten fila, y nada más de este circuito entra en esa fila. La otra pata de la resistencia comparte fila solo con el cable que viene del físico 11. La pata corta comparte fila solo con el cable que va al físico 6. Si cuentas cinco agujeros y metes un tercero, has creado un nodo de más y el esquema ya no es el dibujo.

Un puente suelto encima de la resistencia, «para asegurar el contacto», la anula. La corriente toma el puente y el LED vuelve a estar a pelo. Quita cualquier cable que una el mismo par de filas que ya une la resistencia. El contacto flojo se nota porque la pata no entra hasta el fondo, no porque falte un paralelo de cobre. Empuja con la placa sin alimentación.

Cuando el montaje esté dicho en voz alta, compara con el esquema de esta página, no con una foto de otro curso donde el LED sale del pin de 5 V o donde no hay resistencia porque el programa «usa PWM». Aquí no hay PWM y no hay 5 V. El dibujo tiene cuatro estaciones y dos tachados: sin resistencia, y sin estaño. Si tu placa de pruebas tiene estaño en alguna pata, eso ya no es esta lección. Se desmonta el ensayo y se deja la soldadura para la 28, con el circuito que de verdad se vaya a quedar, no con el primer intento.

Ejercicio en la Pi

Con la alimentación quitada, monta en la placa de pruebas el camino: cable del físico 11, resistencia de unos 330 ohmios, LED con la pata larga hacia esa resistencia, cable del cátodo al físico 6. Recorre el camino con el dedo y comprueba que no hay atajo sin resistencia, que el 2 y el 4 están libres, y que el 27 y el 28 también. No sueldes. No escribas programa. Da corriente solo cuando el montaje esté quieto, y acepta que el LED siga apagado: no hay quien ponga el pin en alto. Si no hay piezas, dibuja el esquema en el mismo orden y escribe por qué la placa de pruebas y no el estaño.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

El circuito no cambia: BCM 17 en el físico 11, resistencia de unos 330 ohmios y masa en el físico 6. gpiozero lo enciende con LED(17), on, off y close, y en la Pi 5 usa lgpio si está. Si falta el paquete, entra por apt como python3-gpiozero, no por pip.

El mismo circuito, ahora con una orden

La lección 24 dejó el camino montado y el LED apagado a propósito. No había programa. Esta lección es ese programa, y no es un circuito nuevo. Señal en el físico 11, que es el BCM 17. Resistencia de unos 330 ohmios en serie. LED con la pata larga hacia esa resistencia. Masa en el físico 6. Si falta la resistencia, no escribas código para compensar: no se puede. Si el LED está al revés, el programa pondrá el pin en alto y seguirás sin luz. Se corrige el sentido con la alimentación quitada, no subiendo a 5 V.

gpiozero numera en BCM. LED(17) es el GPIO 17, el físico 11. LED(11) sería otro agujero, el BCM 11, que en el header es el reloj SPI, el físico 23. No es el LED que montaste. El físico 17, además, es el otro 3,3 V de alimentación y no es un GPIO: no existe un LED de ese agujero. Si alguien te dicta el número del borde, traduces antes. El dibujo está en el pinout de esta página.

La referencia de la librería, la de consultar y no la de cambiar de fábrica de pines, está en Software, gpiozero.

on, off y close

El archivo vive en tu home, se llama luz.py y se lanza con el Python del sistema, no dentro de un venv vacío. La lección 22 ya separó los sitios: gpiozero es paquete del sistema.

from gpiozero import LED
luz = LED(17)
luz.on()
input("Enter para apagar ")
luz.off()
luz.close()

from gpiozero import LED trae la clase. LED(17) reserva el BCM 17 como salida y, con el ajuste de esta librería, lo deja apagado al nacer. on lo pone en alto: unos 3,3 V entre el físico 11 y masa, y la corriente cruza la resistencia y el LED. Tiene que lucir. off lo pone en bajo, cerca de masa, y el LED se apaga. close suelta la reserva. Sin el close, al salir a veces la patilla queda cogida y el siguiente lanzamiento se queja de que el GPIO está ocupado. El close es parte del programa, no un adorno. input solo espera a que pulses Enter para que te dé tiempo a mirar. No lee el pin.

No hace falta sudo. El dispositivo de los pines, en esta imagen, se abre con tu usuario. Si lo lanzas con sudo, el programa puede funcionar y además enseñarte el reflejo malo: archivos de root y un pin que parece exigir el cero. No lo exige. Si el permiso se niega, se lee el error, se mira groups como en la lección 12, y no se convierte en costumbre el sudo.

Cuando el programa termina bien, el LED está apagado y el pin libre. Vuelve a lanzarlo. Tiene que repetirse. Si la segunda vez dice que el pin está en uso, la primera no cerró: mira que close está y que no cortaste el proceso con un tirón de corriente. Control y C mata el programa a medias. Después de un Control y C, un close que estaba más abajo no llegó a ejecutarse. Por eso el ensayo es Enter, no un corte.

Pi 5, lgpio, y las vías que no son el camino

En la Pi 5 la vía que funciona es lgpio. gpiozero la usa si está instalada. No configuras a mano una fábrica de pines, no exportas variables raras y no reescribes el programa para nombrar el chip. El archivo de arriba es el mismo en una Pi anterior y en una Pi 5, siempre que gpiozero encuentre lgpio en esta última. Si no lo encuentra, el fallo sale al crear LED(17), en esa línea, y se lee como en la lección 20. No se cambia el número. No se prueba otro agujero.

RPi.GPIO no es el camino, y en la Pi 5 no sirve. wiringPi tampoco es el camino. No los importes, no los instales con pip para «desatascar» el LED y no copies un ejemplo que abre el BCM con esas librerías. El ejemplo de este curso es el de gpiozero. Hay otras vías, descritas aparte y sin tutorial en esta página, en Software, libgpiod y en Software, pigpio.

Si el import dice que no existe gpiozero, el paquete es python3-gpiozero y entra con apt, con red en ese momento:

sudo apt install python3-gpiozero

No con pip y no con sudo pip. La lección 22 explicó por qué el Python del sistema se niega. Si estabas dentro del venv, deactivate antes de lanzar luz.py: el entorno vacío no ve el paquete de apt. Después de instalar, el mismo archivo, sin cambiar el 17.

Lo que el programa no arregla

Si no luce y el programa no se quejó, el pin sí subió. El fallo está en el camino: sentido del LED, fila de la placa de pruebas en corto, resistencia que no es la del camino, cable en el físico 17 en vez del 11, masa que no es masa. Se apaga la Pi como en la lección 9 antes de mover un cable. No se deja el on puesto mientras recolocas patas: un roce con el físico 2 mete 5 V en el GPIO. El programa, por muy correcto que sea, no impide ese roce.

Tampoco enciendas el físico 2 desde el código. No hay LED de un pin de 5 V. Quien escribe un número hasta que «alguno brilla» está probando agujeros a ciegas, incluidos los 27 y 28, que siguen reservados a la EEPROM del HAT. El único número de esta lección es el 17 de BCM.

El brillo a medias no es esta lección. on es alto del todo, dentro de lo que la resistencia permite. off es bajo del todo. La mitad del tiempo en alto es PWM, la lección 27. No pongas un bucle de ons y offs «para atenuar» todavía: sin una pausa medida es un parpadeo sucio, y con pausas largas es un semáforo, no un brillo.

Aviso. GPIO a 3,3 V. Físico 11, BCM 17. Resistencia de unos 330 ohmios. Masa en el físico 6. Nada de 5 V. Físicos 27 y 28 sin cable. Sin 230 V. Sin RPi.GPIO, sin wiringPi y sin pip. close suelta el pin.

Qué está haciendo la patilla mientras esperas el Enter

on no manda un pulso y se olvida. Deja la salida en alto y se queda así hasta off o hasta close. Durante el input el programa está parado en esa línea, esperando el teclado, y el pin sigue en alto porque nadie le ha dicho lo contrario. Por eso puedes mirar el LED con calma. Si el Enter no llega porque la ventana no tiene el foco, el LED sigue encendido. No es un bloqueo de la placa. Es la línea de espera. Pulsas Enter en esa terminal.

Al hacer off, la patilla pasa a bajo y el LED se apaga aunque la resistencia y el diodo sigan en su sitio. El circuito no se ha roto: no hay tensión suficiente para que el diodo conduzca. Esa es la prueba de que mandaba el pin y no un cable olvidado al físico 1, que estaría siempre a 3,3 V y no obedecería el off. Si apagas en el programa y el LED sigue igual de brillante, no estás gobernando ese LED. Hay un puente a alimentación. Se corta la corriente y se mira el camino antes de volver a ejecutar.

close no es un tercer brillo. Suelta la reserva y, en esta librería, deja de forzar la salida. Después del close no llames a on: el objeto ya no tiene el pin. Si quieres otro encendido, creas otro LED(17) o no cierras hasta el final. Un solo objeto, on, off, close, en ese orden. Crear dos LED(17) a la vez es pedir el mismo BCM dos veces y la segunda creación falla. No es que el LED se haya fundido.

El archivo no lleva PWM, no lleva botón y no importa Button ni Servo. Esas clases existen y son las lecciones 26 y 27. Meterlas hoy mezcla tres circuitos en un arranque. Tampoco escribas un while True con on y off sin un tiempo de espera: el pin conmuta más rápido de lo que el ojo separa y el LED parece medio encendido o raro, y además no llegas a un close limpio si cortas con Control y C. El ensayo de hoy es un solo alto, una mirada, un bajo y un close.

Thonny ejecuta el mismo archivo si el intérprete es el del sistema y guardaste luz.py en disco. La consola de abajo no es el programa, como en la lección 18. Si escribes luz.on() solo en la consola, al cerrar Thonny el pin puede quedarse como la sesión lo dejó, porque esa línea no estaba en el archivo y no hubo close guardado. El hábito es el archivo completo, de la importación al close, guardado, y el botón de ejecutar sobre ese archivo. Si la luz se queda colgada, vuelves a lanzar un archivo que solo hace LED(17), off y close, y lo dejas escrito para la próxima vez que un ensayo se corte a medias.

Leer el fallo sin cambiar de librería

Si la primera línea del traceback es el import, gpiozero no está en el intérprete que estás usando. Miras command -v python3. Si la ruta cae dentro de entorno, sigues en el venv y ese entorno no ve el paquete de apt. deactivate y repites. Si ya estás en el Python del sistema y el módulo no existe, apt con python3-gpiozero. No hay un tercer paso con pip.

Si el traceback está en LED(17) y habla de que no puede cargar una fábrica de pines, en la Pi 5 la frase suele querer decir que lgpio no está a su alcance. No abras un ejemplo de RPi.GPIO para comparar. Anotas la frase, con el número de línea, y dejas el archivo como está. La vía sigue siendo lgpio por debajo de gpiozero, no una librería distinta escrita a mano. En una Pi anterior el mismo archivo puede haber funcionado porque gpiozero encontró otra vía válida. No por eso el curso cambia de import: el import es gpiozero en las dos.

Si el traceback dice que el pin está ocupado, algún proceso no hizo close. No reinicies la placa a tirones. Cierras el otro programa si sigue en una terminal, o lanzas el archivo corto de off y close. Si no queda ninguno, un apagado bien hecho de la lección 9 suelta lo que un proceso muerto haya dejado, y al volver el pin está libre. Es un último recurso, no el primer gesto, y no es un motivo para borrar el sistema.

Una luz tenue con on, y brillante de verdad solo si puenteas cosas, no se arregla en el programa. on ya es el alto entero. Tenue con el alto entero suele ser el sentido del LED justo en el límite, una resistencia de miles de ohmios en vez de unos 330, o un contacto a medias. Se apaga, se mira la banda de la resistencia y la pata larga, y se vuelve a lanzar el mismo archivo. No se edita el 17 para buscar otro brillo.

Anota en el cuaderno de esta página, el de más abajo, qué viste: si lució, si el segundo lanzamiento pudo repetir el on, y la frase exacta si algo falló. Ese cuaderno no viaja a ningún servidor. Sirve para no fiar la prueba a la memoria del LED, que al apagarse ya no enseña el error.

Ejercicio en la Pi

Con el montaje de la 24 quieto, escribe luz.py como arriba y ejecútalo con python3 luz.py, sin sudo. El LED luce, pulsas Enter, se apaga. Lánzalo otra vez para ver que close dejó el pin libre. Si el import falla, sudo apt install python3-gpiozero y no pip. Si usas una Pi 5 y gpiozero no encuentra forma de hablar con el pin, no cambies a RPi.GPIO: anota la frase y deja lgpio como la vía, la que gpiozero usa si está. No muevas cables con el programa en on.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Un lado del pulsador va al GPIO y el otro a masa. Button, en gpiozero, activa el pull-up interno: sin pulsar, la patilla lee alto; al pulsar, cierras a masa y cuenta como pulsado. bounce_time va en segundos y 0,2 s basta para un pulsador de tablero. Nunca alimentes el botón desde 5 V. La otra forma, 3,3 V y pull_up=False, es una alternativa, y 5 V en esa patilla la rompe.

Dos cables y ni uno de alimentación

Un pulsador de tablero es un contacto. En reposo, las dos patas no se tocan. Al apretar, se tocan. No tiene polaridad como el LED y no pide una fuente propia. El circuito del curso es este: una pata al GPIO, la otra a una masa del header. Nada en el físico 2 y nada en el físico 4.

El GPIO del botón no es el 17. El 17 sigue siendo el LED, físico 11. El botón de esta lección es el BCM 23, que sale por el físico 16. La masa puede ser el físico 14, al lado, o la misma masa de la placa de pruebas si ya viene del físico 6, siempre que sea masa de verdad y no el raíl donde alguien dejó 5 V. Dos cosas en el mismo nodo de masa están bien. Una pata del botón en el nodo de 5 V no está bien.

Sin pulsar, el contacto está abierto. Si la patilla no tuviera más, quedaría al aire y leería ruido. gpiozero, al crear un Button, activa el pull-up interno: una resistencia de dentro del chip tira de la patilla hacia 3,3 V. Abierta, la lectura es alto. Pulsada, el contacto gana a esa resistencia y pone la patilla a masa. La librería llama a eso pulsado. No hace falta una resistencia externa para este montaje. No pongas el botón entre 3,3 V y masa sin más, puenteando la alimentación: eso no es un pulsador leído, es un cortocircuito del raíl cuando aprietas.

La ficha del rebote, para consultar el nombre y no para cambiar el cable, está en Software, antirrebotes.

bounce_time en segundos

Al cerrar, la lámina del pulsador rebota. En unos milisegundos el contacto se abre y se cierra varias veces. Un programa que cuente flancos sin filtro cuenta cinco pulsaciones donde tú hiciste una. bounce_time es el tiempo, en segundos, durante el cual un cambio nuevo se ignora después de uno aceptado. La unidad es el segundo, no el milisegundo. Escribir 200 pensando en milisegundos deja doscientos segundos de sordera. Escribir 0.2 son dos décimas. Para un pulsador de tablero, 0,2 s basta: el rebote mecánico es mucho más corto, y un segundo apretón hecho a propósito, un poco después, sigue contando como otro.

from gpiozero import Button
boton = Button(23, bounce_time=0.2)
print("espera")
boton.wait_for_press()
print("pulsado")
boton.close()

Button(23) es el BCM 23, físico 16, con el pull-up que la clase pone por defecto. wait_for_press se queda esperando un cierre a masa. Cuando llega, y pasado el filtro de 0,2 s, el programa sigue e imprime. close suelta el pin, igual que con el LED. No uses sudo. Lánzalo con el Python del sistema.

Si aprietas y no imprime, el cable no está llegando a masa o no está en el físico 16. No subas el botón a 5 V para «asegurarlo». Si imprime solo, sin que toques, hay un puente a masa o estás leyendo otro agujero que ya está en bajo. Se suelta el pin con close, se apaga si vas a mover cables, y se revisa el físico 16, no el 27 ni el 28.

Dos apretones más rápidos que 0,2 s se funden en uno. Eso no es un pulsador roto. Es el filtro haciendo su trabajo. Si más adelante cuentas pulsaciones y se te comen las rápidas, se baja el tiempo con juicio, siempre en segundos: 0,05 sigue siendo más largo que un rebote típico y más corto que 0,2. No se pone a cero «para no perder ninguna». A cero, el rebote vuelve a contar por su cuenta.

La otra forma, y la que rompe el pin

Se puede invertir el sentido. Button(23, pull_up=False, bounce_time=0.2) no tira de la patilla hacia 3,3 V. Espera que tú la lleves a 3,3 V al pulsar, y que en reposo algo la deje en bajo. Esa alimentación del contacto, si la montas, es el físico 1, los 3,3 V, no el GPIO del LED y no el 5 V. El otro lado del botón sigue siendo el GPIO. Hace falta además un pull-down, interno si la librería lo deja activo en ese modo, para que en reposo no flote. Es una alternativa válida solo a 3,3 V. El curso no la usa como montaje principal porque es más fácil equivocar el raíl. El montaje principal es pull-up y masa, el de arriba, sin discutir de dónde sale la alimentación: no sale de ningún raíl externo.

5 V en el GPIO, venga del físico 2, del 4 o de un pulsador «más claro» alimentado a 5 V, rompe el pin. No es una tercera forma. Es el daño de la lección 23, ahora con un dedo que lo repite cada vez que aprieta. Aunque el programa lleve pull_up=False y te parezca coherente, la patilla sigue siendo de 3,3 V. El argumento de Python no cambia el límite del silicio. Si ya lo conectaste, suelta el cable con la corriente quitada y no compruebes «si aún lee». Puede leer un rato y estar herido.

El LED puede convivir. Un archivo que crea el LED(17) y el Button(23) usa dos BCM distintos. Al pulsar, luz.on(), y el LED obedece la lección 25. Al soltar, luz.off(). Los dos close al final. No pongas el botón en el 17 «para ahorrar un cable»: estarías leyendo la misma patilla que fuerzas como salida, y el LED y el contacto se pelean. Dos números, dos papeles.

Qué cuenta como una pulsación

wait_for_press espera el paso a pulsado. No mide cuánto lo dejas apretado. Si quieres el release, existe, y no hace falta hoy. Lo que importa es no contar el rebote. Puedes verlo mal a propósito: quita bounce_time un momento, cuenta en un bucle corto cuántas veces cambia is_pressed mientras aprietas una sola vez, y verás más de un cambio. Vuelve a poner 0,2. No dejes la versión sin filtro como el programa bueno. El experimento sirve para creer el filtro, no para quedarte sin él.

El bucle, si lo escribes, tiene que poder salir y llegar al close. Un while True sin salida te obliga a Control y C, y el close no corre. Una condición que termine, o un wait_for_press de una sola vez como el ejemplo, devuelve el prompt con el pin suelto. La placa no se apaga para probar el botón. Se apaga, como siempre, solo cuando terminas la sesión y con la orden de la lección 9, no a tirones con el dedo aún en el contacto.

Anota en el cuaderno si el primer apretón bastó y si dos apretones muy seguidos se fundieron en uno. Esa nota se queda en el navegador. No confirma el cable: el cable lo confirma el programa, y la nota te evita repetir el ensayo a ciegas mañana.

Aviso. El botón va a masa, o, en la alternativa, a 3,3 V del físico 1. Nunca a 5 V. BCM 23 es el físico 16. El LED sigue en el BCM 17, físico 11, con su resistencia. Físicos 27 y 28 libres. GPIO a 3,3 V. Sin 230 V. bounce_time en segundos: 0,2.

El pull-up no es un cable que tengas que ver

La resistencia de pull-up no aparece en la placa de pruebas. Está dentro del chip y el programa la pide al crear el Button. Por eso el montaje parece pobre: dos hilos y un contacto. Si añades una resistencia externa a 3,3 V «porque en el dibujo de otro sitio sale», no rompes nada si de verdad es 3,3 V y no estorba el cierre a masa, pero tampoco es necesaria para que este ejemplo funcione. Si la pones al físico 2, has construido la avería con una pieza de más. El esquema de esta lección no lleva esa resistencia fuera. Lleva el nombre del pull-up para que sepas por qué en reposo la patilla no flota.

Flotar es quedarse sin nadie que fije el nivel. Una patilla al aire lee unos y ceros según lo que le inducen los cables de al lado. Verías pulsaciones fantasma. El pull-up es quien fija el uno. El dedo en el botón es quien fija el cero, y solo mientras el contacto aguanta. Al soltar, gana otra vez el pull-up, sin que el programa tenga que «recargar» la patilla. No hace falta un off del botón. No es una salida.

gpiozero considera pulsado el nivel que corresponde al cierre, no el alto. Con pull-up, pulsado es bajo. No imprimas el nivel crudo y lo interpretes al revés: si algún día lees la patilla por otro medio y ves cero al apretar, coincide con este montaje. No inviertas el if para que «alto signifique pulsado» sin cambiar el cable. El alto, aquí, es la mano fuera.

El LED, si lo enciendes desde el mismo archivo al detectar el botón, sigue con su resistencia de unos 330 ohmios. El botón no la sustituye y no se pone en serie con el LED para «pulsar la corriente». Ese otro circuito, un interruptor en serie con el diodo, enciende el LED a mano y deja al GPIO fuera. No es la lección. Aquí el GPIO escucha, y otro GPIO, el 17, habla. Son dos patillas. close de las dos, en cualquier orden, al terminar, las dos sueltas.

Si el programa se queda en «espera» y el botón está bien, mira que no haya un bounce_time enorme por haber escrito 200 o 2 en vez de 0.2. Dos segundos de filtro parecen un botón muerto si aprietas y sueltas enseguida y el flanco que valía ya pasó, o si el primer rebote consumió la ventana. 0,2 es el número de la lección. Se escribe con punto en el archivo, porque Python no acepta la coma decimal en el código, y se lee en voz alta como cero coma dos segundos.

El físico 14, si lo usas de masa del botón, es masa igual que el 6. No es un segundo tipo de cero. Elige uno y no dejes el otro cable «de repuesto» en el físico 4. Un repuesto en 5 V es el accidente de la próxima vez que muevas la placa.

Si el botón es de cuatro patas, las dos que se cierran al pulsar son las que van al GPIO y a masa. Las otras dos, en muchos pulsadores de tablero, ya están unidas por dentro a esas. No las uses para «llegar» al físico 2. Un tester o el propio programa, con la Pi apagada al cablear, bastan para no cruzar esquinas. Si no tienes tester, dejas solo dos hilos y no inventas un tercero hacia 5 V.

Ejercicio en la Pi

Con la corriente quitada, cablea el pulsador: físico 16 y una masa. No toques el 2 ni el 4. Deja el LED como estaba si sigue montado. Escribe el programa del Button(23, bounce_time=0.2), espera el apretón, imprime y cierra. Una pulsación, una línea. Prueba dos apretones separados: hacen falta dos ejecuciones, o un bucle que sepas terminar y que acabe en close. No alimentes el botón a 5 V. Si quieres mirar la alternativa, que sea el físico 1 y pull_up=False, y dilo en el cuaderno como alternativa, no como el montaje del curso.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

PWMLED usa un value de 0 a 1: 0,5 es la mitad del tiempo en alto, no la mitad de los voltios. El pin sigue saltando entre masa y 3,3 V. El servo recibe la señal por un GPIO, y la alimentación del servo no sale del pin de 3,3 V. El límite del raíl de 5 V está en Hardware. Un servo que se traba no se deja alimentado del header.

Mitad del tiempo, no mitad de los voltios

El LED sigue en el BCM 17, físico 11, con la resistencia de unos 330 ohmios y la masa en el físico 6. No se quita la resistencia porque ahora el programa «manda menos». En el instante en que el PWM está en alto, la patilla está a 3,3 V enteros y la corriente es la del on. El truco es que ese instante no dura todo el tiempo.

from gpiozero import PWMLED
luz = PWMLED(17)
luz.value = 0
input("apagado, Enter ")
luz.value = 0.5
input("mitad del tiempo, Enter ")
luz.value = 1
input("siempre alto, Enter ")
luz.close()

value es una fracción del periodo. 0 no enciende. 1 no suelta el alto. 0,5 reparte el periodo en dos mitades. El ojo suma las mitades y llama a eso menos brillo. No ha aparecido un 1,65 V estable en el pin. Si pudieras mirar despacio, verías alto y bajo, alto y bajo. Un medidor que promedia te enseña un número intermedio y es fácil leerlo como «media tensión». No lo es. La patilla solo sabe los dos niveles de siempre. Por eso un aparato que necesite de verdad 1,65 V continuos no se alimenta con value = 0.5. Recibiría una onda, no una fuente.

En el archivo, el decimal se escribe con punto: 0.5. En voz alta es cero coma cinco. No pongas 50 para decir la mitad: 50 no cabe en la escala de 0 a 1, y la librería no lo va a interpretar como un porcentaje escrito a tu manera. Tampoco pongas 5 queriendo decir cinco voltios. No hay un value que fabrique 5 V. El techo sigue siendo 3,3 V, y solo durante la parte alta del periodo.

La ficha del nombre, sin convertir esta página en un manual de temporizadores, está en Software, PWM.

El servo: señal por un lado, comida por otro

Un servo pequeño tiene tres hilos. Uno es la señal. Otro es la alimentación del motor. Otro es la masa, común. La señal de este curso sale de un GPIO libre, el BCM 18, físico 12, no del 17 si el LED sigue ahí. La librería manda una tanda de pulsos. El circuito interno del servo mide esos pulsos y mueve el motor. mid lo deja al centro. No hace falta memorizar un value entre menos uno y uno para el primer ensayo: mid dice el centro sin que confundas la escala con la de PWMLED, que era de 0 a 1. Son dos clases. No copies el 0,5 del LED en el servo creyendo que es el mismo idioma.

from gpiozero import Servo
servo = Servo(18)
servo.mid()
input("centro, Enter ")
servo.close()

Ese archivo no alimenta el motor. El hilo de alimentación del servo no sale del físico 1 ni de ningún GPIO. El físico 1 es 3,3 V y poca capacidad para un motor: el servo no gira bien, o tira del raíl de 3,3 V que también usa el chip. La alimentación, si el servo es de los que aceptan 5 V y de verdad cabe, sale del físico 2 o del 4, los de 5 V, y la masa del servo va a una masa del header, la misma referencia que la señal. La señal, solo el físico 12. Tres hilos, tres papeles. Juntar señal y alimentación en el mismo cable es el fallo.

Cuánta corriente aguanta el raíl de 5 V no lo escribo. El límite está en Hardware, el pinout de 40. Un número inventado aquí te haría dejar conectado un servo que no cabe. La regla que no depende de esa cifra: si el servo se traba, zumba y no se mueve, no se deja alimentado del header. Se le quita la alimentación, se corrige el atasco en vacío, y solo entonces se vuelve a dar corriente. Un motor trabado pide corriente de continuo y calienta el raíl y el propio servo. El close de la señal no basta si el hilo de 5 V sigue puesto: el motor puede seguir empujando. Primero se corta esa comida. El apagado de la placa, si hace falta, es el de la lección 9, no un tirón con el eje bloqueado.

Qué no se mezcla

El LED con PWM no se mueve al servo. El servo no se prueba poniendo PWMLED en el hilo de señal y esperando un ángulo: la forma del pulso que el servo entiende la construye la clase Servo, no un value de brillo. Al revés, un LED colgado de Servo solo verá pulsos estrechos y apenas lucirá, o lucirá raro. Cada clase con su aparato.

No alimentes el servo desde el GPIO «un segundo para ver si vibra». El GPIO no es un raíl de motor. No lo alimentes desde el físico 1. Y no dejes el de 5 V puesto mientras corriges el mecánico con el eje agarrado. La señal puede seguir en mid y el motor seguir empujando contra tu mano. Cortas la comida, luego hablas del programa.

Si no tienes servo, no lo improvises con un motor de continuo atado al pin. Eso es la lección 28: un motor directo no se conecta. El ejercicio sin servo es el PWM del LED, los tres values, y el dibujo de los tres hilos en el cuaderno, separados. El dibujo también enseña. El motor atado no enseña: calienta el pin.

Aviso. value 0,5 no es media tensión. El pin sigue a 3,3 V o a masa. Resistencia del LED en su sitio. Señal del servo por un GPIO. Comida del servo fuera del pin de 3,3 V. Límite del 5 V en Hardware, sin cifra inventada aquí. Servo trabado, alimentación fuera. Físicos 27 y 28 libres. Sin 230 V.

El periodo no se ve, y por eso engaña

El cambio de alto a bajo ocurre muchas veces por segundo, más de las que el ojo separa. Por eso el LED no parpadea: parece fijo y más flojo. Si bajas mucho la frecuencia, el parpadeo aparece y deja de llamarse brillo. gpiozero elige una frecuencia de PWM suficiente para un LED de señal. No la reescribas hoy. El value es la parte que tú cambias. La frecuencia no es el ejercicio, y subirla no crea voltios nuevos.

Un alto que dura la mitad deja pasar, en promedio, menos energía por el LED. Por eso se ve menos. En cada instante de alto, la resistencia sigue limitando igual que con on. No hay un instante en el que el pin «se porte bien» sin resistencia. Quien quite la resistencia porque el brillo medio parece seguro está mirando el promedio y olvidando el pico. El pico es 3,3 V contra el diodo. La lección 24 no se deroga.

Puedes anotar los tres brillos en el cuaderno: apagado, medio, lleno. Si el medio y el lleno se ven iguales, la sala está demasiado clara o el LED ya estaba al límite de lo que tu ojo distingue. No subas a 5 V para separarlos. Aleja la vista de una luz directa o tapa un poco el LED con la mano, con el circuito quieto, sin tocar patas. Si siguen iguales y el programa no se quejó, mira que de verdad guardaste el 0.5 y no lanzaste el archivo viejo del on. pwd y la hora del archivo, como en la lección 18.

El servo, cuando lo hay, se prueba sin carga: el eje en el aire, no empujando una pieza atascada ni una puerta. mid una vez, miras, close de la señal, y si no vas a seguir, quitas también el hilo de 5 V. Dejar la señal en close y la comida puesta es un servo que puede dar un tirón al volver a conectar la señal, o quedarse empujando si el close no cortó el pulso que el aparato ya había aceptado. La costumbre segura es comida fuera cuando no estás mirando. El header no es una fuente que se abandona.

La masa común importa. Si la señal sale de la Pi y la masa del servo se queda en otra fuente que no comparte masa con la Pi, el servo no entiende los pulsos: no tienen referencia. Compartir masa no es compartir el 5 V con un GPIO. Es unir los ceros. El hilo de masa va a un agujero de masa, el físico 6 o el 14 o el 20, no al físico 11 ni al 12. El 12 es solo señal. Si te sobra un hilo y no sabes cuál es, no lo pruebas en los GPIO. Lo pruebas con el servo desconectado de la Pi, mirando el color que el fabricante marcó, y si no está marcado no lo adivinas contra el chip.

Señal y comida no son el mismo hilo

El dibujo del servo, si lo miras despacio, tiene tres caminos y no dos. La señal sale de un GPIO, el BCM 18, físico 12, y es un tren de pulsos a 3,3 V. La comida es otro hilo, el que el servo pide para el motor de dentro, y no sale de ese GPIO ni del pin de 3,3 V del header. La masa es el tercero y es común: sin ella la señal no tiene cero y el servo no sabe qué es un pulso. Juntar señal y comida «porque los dos alimentan algo» es el error. La señal no alimenta el motor. La comida no es un GPIO. Si el hilo de comida lo llevas al físico 1, que es 3,3 V, o al físico 12, que es la señal, o no se mueve o se lleva por delante la patilla. El límite de la línea de 5 V, cuánta corriente admite el header, no lo invento aquí: está en Hardware, en el pinout de cuarenta pines. Si el servo que tienes pide más de lo que esa línea da, la comida no sale del header. Sale de una fuente aparte que comparte solo la masa con la Pi, y esta lección no te manda a construirla hoy.

Un servo trabado, el eje contra un tope, sigue pidiendo corriente. close de gpiozero cierra el objeto de Python y deja de mandar pulsos por el GPIO. No corta el hilo de 5 V. Si la comida sigue puesta, el motor puede seguir empujando o quedarse caliente. Por eso, cuando dejas de mirar, la comida se quita a mano. No es un detalle de estilo. Es la diferencia entre un ensayo de un minuto y un servo que se queda solo contra el tope.

PWMLED y Servo no se intercambian. Un value de 0,5 en el LED es la mitad del tiempo en alto, no un ángulo. Servo.mid coloca el eje en el centro según lo que gpiozero entiende por centro, y no es un value que puedas copiar del LED. Si escribes LED donde tocaba Servo, o al revés, el error es de tipo, no de brillo. No lo «arregles» cambiando de pin hasta que algo se mueva. Vuelves al import que corresponde y al objeto que corresponde. Y el LED, con PWM o sin él, sigue llevando la resistencia de la lección 24. El PWM no la sustituye.

Cuando acabes el ensayo del LED, close y comprueba que un on de la lección 25 sigue siendo el mismo brillo que value 1. Si value 1 se queda más flojo, no estás en el archivo que crees o el PWM no llegó a 1. No lo «completes» con el pin de 5 V. Y si el servo no lo tienes, el cuaderno con los tres hilos separados cumple la mitad del ejercicio: señal, comida, masa, cada uno con su agujero, y la comida tachada si no vas a usarla.

Ejercicio en la Pi

Sobre el LED ya montado, prueba value 0, 0,5 y 1, con esperas y un close al final. Mira que 1 coincida con el brillo del on de la lección 25 y que 0,5 se vea menos sin que hayas cambiado la resistencia. Si tienes un servo de verdad y cabe en el raíl, señal al físico 12, comida al 5 V, masa común, Servo(18) y mid, y lo sueltas si se traba. Si no tienes servo, dibuja los tres hilos separados y no cuelgues un motor del GPIO. No inventes el amperaje del raíl: si dudas, no lo alimentes del header.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

No se conecta 5 V a un GPIO, ni un motor directo al pin, ni la red de 230 V. La lección 24 sigue en placa de pruebas y no se suelda. Se suelda cuando el empalme se queda: un cable que va a vivir, una hilera de pines en una placa hija. El soldador descansa en su soporte, no se respira el humo encima, no se suelda la propia Pi y se desenchufa al terminar. El plomo funde antes, el estaño sin plomo pide más calor, y la ficha del estaño manda.

Tres cosas que no entran

La primera ya está dicha y se repite porque es la que más se «prueba un momento». Un GPIO de esta Pi con Linux es de 3,3 V. El físico 2 y el físico 4 son 5 V de alimentación y no son GPIO. Un cable entre ellos y el físico 11, o el 12, o el 16, mete 5 V en una patilla que no los admite. El programa no lo suaviza. gpiozero no tiene un modo de sobrevivir a eso. Se quita el cable con la corriente fuera. No se comprueba encendiendo.

La segunda es un motor directo. Un motor de continuo no es un LED. La bobina pide más de lo que una patilla puede entregar, y al parar o al cambiar de sentido la bobina devuelve un golpe de tensión. El pin no está protegido contra ese golpe por el hecho de que el programa haga off. Un motor trabado es peor: se queda pidiendo corriente como un casi cortocircuito. No se cuelga del BCM 17, ni del 18, ni de ningún GPIO, ni siquiera «con la resistencia del LED delante», que no está pensada para eso y no frena un motor. Si algún día un motor se mueve desde esta placa, será con una etapa en medio, en una lección que la nombre, y la comida del motor no saldrá de la patilla de señal. Hasta entonces, no se conecta.

La tercera es la red de 230 V. Nada del header, nada del LED, nada del servo y nada de una placa hija se ata a la red de casa. No hay un relé «pequeño» en esta lección que lo autorice. El soldador, si se enchufa a la pared, es la herramienta, y su tensión se queda en su cable. No se acerca esa tensión al peine de la Pi, no se usa el enchufe como masa del circuito y no se suelda con la Pi alimentada «para ir probando». Doscientos treinta voltios no son una versión grande de los 5 V. Son otro mundo, y este curso no entra.

Esta lección no tiene ficha en Software. El criterio está aquí. El mapa de agujeros, si dudas cuál es el de 5 V, sigue en el pinout de esta página.

La lección 24 no se suelda

El LED, la resistencia de unos 330 ohmios y los dos cables del físico 11 y del físico 6 viven en la placa de pruebas. Se pueden sacar. Esa es la virtud. Soldarlos ahora fija un ensayo que todavía puede estar al revés, en la fila equivocada o en el agujero equivocado. El estaño no perdona un error de agujero con la misma facilidad que una pata que se desenchufa. La lección 24 dijo que no se soldaba. Esta lo confirma: aquel montaje sigue siendo de quita y pon aunque ya sepas encenderlo con gpiozero.

Tampoco se suelda el pulsador de la 26 ni el ensayo del PWM. Mientras cambies de value, de bounce_time o de sentido del LED, el empalme no se ha quedado. Se queda cuando decides que ese cable ya no se va a mover: el que sale de una caja hacia un conector, o la hilera de pines que una placa hija llevará siempre. Antes de esa decisión, la placa de pruebas es el sitio correcto, no un paso vergonzante.

Cuándo sí

Sí se suelda un cable que va a vivir. Un hilo que has medido, que tiene funda, que entra en un conector o en una regleta, y que mañana tiene que seguir siendo el mismo hilo. El empalme entre el hilo y la pieza, si esa pieza no es la Pi, puede ser de estaño. Sí se suelda una hilera de pines en una placa hija: la tira de patillas que luego enchufarás, o de la que saldrán cables, hecha para quedarse en esa placa pequeña. La hija se trabaja en la mesa, sola, sin el header de la Pi debajo.

No se suelda la propia Pi. Ni los agujeros del header para «fijar» un cable, ni un punto de prueba del circuito impreso, ni el conector de alimentación. La placa es la que arranca Linux. Un estaño en el sitio equivocado, un puente entre el físico 1 y el 2, o una gota que une dos patas del chip, no se deshace con close. Si necesitas salir del header, usas cables hembra, o una hija ya terminada que se enchufa, no el soldador sobre la Pi encendida o apagada. Apagada tampoco: el daño es mecánico y eléctrico en el cobre, no solo de software.

El soldador, cuando no está tocando el empalme, está en su soporte. No se deja en la mesa, no se engancha el cable en el codo, no se apunta a la funda de otro hilo. El humo del fundente no se respira encima: no te inclinas con la nariz sobre el punto. Trabajas de lado, con aire, y si el rollo huele fuerte te apartas. No es un olor que haya que comprobar. Al terminar, el soldador se desenchufa. No se confía en que «se enfría solo» mientras recoges, porque la punta sigue quemando la mesa y la funda mucho después de dejar de brillar. Se espera a que esté frío antes de guardarlo. El frío se nota sin tocar la punta: no se prueba con el dedo.

Empalme que moja, empalme que se posa

Un empalme bien hecho moja las dos piezas: la pastilla de cobre y el hilo o la pata. El estaño sube por la pata y se extiende por la pastilla. El contorno es un filete, cóncavo, no una bola. Se ve que el metal líquido ha corrido y se ha quedado unido, no apoyado. Eso es lo que el dibujo de la izquierda quiere decir. No hace falta una foto de fábrica. Hace falta reconocer que las dos superficies quedaron cubiertas.

Un empalme frío es el de la derecha. La punta no calentó la pieza, o se llevó una gota ya hecha y se dejó caer encima. El estaño se posa como un borrón, a veces mate, a veces brillante pero con un cuello que no toca el cobre. Mañana falla: el cable se mueve y el contacto se abre, o hace un contacto intermitente que parecería un rebote de software. No se arregla con bounce_time. Se rehace el empalme. Se calienta la unión, se retira el estaño viejo si estorba, y se vuelve a mojar. No se acumulan capas sobre el borrón.

La manera corta de llegar al filete, sin convertir esto en un taller: se calienta la pastilla y la pata, juntas, y entonces se acerca el estaño a la unión, no a la punta para hacer una gota y transportarla. Si el estaño no corre, la pieza aún está fría o la punta está sucia. No se aprieta más fuerte con la punta hasta rayar el cobre. Se espera un instante o se limpia la punta en la esponja o el latón del soporte, y se repite. Si aun así no corre, miras la ficha del rollo: puede que estés usando sin plomo con una punta que no llega, y la solución no es un número que yo te dicte.

El estaño con plomo funde antes. El estaño sin plomo pide más calor. Los dos existen, no se mezclan a ciegas en el mismo empalme, y la temperatura concreta, en grados, la dice el fabricante de ese hilo, en su ficha. Esta página no la copia. Copiarla mal, con un grado de más o de menos inventado, quema la pastilla o deja el empalme frío. Lees el rollo que tienes. Si el rollo no dice nada, no adivinas: preguntas el tipo antes de tocar una placa hija que te importe. En la placa de pruebas, mientras tanto, no hace falta resolverlo, porque no estás soldando.

Orden de la mesa

La Pi, si está en la mesa, está apagada y apartada del soporte del soldador. No se suelda un cable con el otro extremo aún pinchado en el header: un tirón del cable arrastra la placa contra la punta. Se suelda el extremo libre, se deja enfriar, y solo entonces se enchufa. La placa hija, igual: pines soldados, se enfría, se inspecciona que no haya un puente entre dos patas vecinas, y después se enchufa a la Pi, con la Pi sin corriente.

Un puente de estaño entre dos pines de la hilera es un cortocircuito que el programa no ve hasta que algo huele. Se mira a contraluz antes de enchufar. Si hay puente, se quita con la punta y, si hace falta, con malla, sin rascar el cobre hasta levantarlo. No se da corriente «a ver si el puente era de los importantes».

Al acabar, soldador fuera del enchufe, punta en el soporte hasta que enfríe, estaño tapado, placa de pruebas de la lección 24 todavía sin estaño. Si hoy no había nada que se quedara, no has soldado, y la lección está igual de hecha: has sabido no soldar. El cuaderno puede decir «hoy no se suelda» y listar las tres cosas que no se conectan. Eso es el contenido, no una falta de práctica.

Aviso. No se conecta 5 V a un GPIO, ni un motor al pin, ni 230 V a nada de este curso. La 24 no se suelda. No se suelda la Pi. Soldador en su soporte, sin respirar el humo encima, desenchufado al terminar. Sin grados inventados. GPIO a 3,3 V. Físicos 27 y 28 libres.

Qué se revisa antes de dar corriente

Antes de volver a alimentar la Pi, el header se mira como se miró en la lección 24, con una pregunta más: ¿hay algún hilo que no sea el del LED, el de su resistencia y su masa? Un hilo de más hacia el físico 2 o el físico 4 es 5 V. Un hilo que sale hacia un motor, aunque el motor esté «apagado» porque no has escrito el programa, ya está conectado. Se quita con la fuente desenchufada, no se deja para la siguiente prueba. El pulsador de la 26, si sigue puesto, va a masa y a su GPIO, nunca a 5 V. El servo, si lo ensayaste, tiene la comida fuera. La señal del PWM, si no la estás usando, no se queda pinchada en un servo abandonado.

La placa hija, el día que exista, se enchufa alineando el pin 1 con el pin 1. Una hilera dada la vuelta pone 5 V donde el fabricante de la hija esperaba masa, o un GPIO donde esperaba 5 V. El estaño bonito no corrige una hilera al revés. Se mira el serigrafiado, se cuenta el físico 1, que es 3,3 V, y el físico 2, que es 5 V, y solo entonces se empuja. Si no cuadra, no se fuerza. Los físicos 27 y 28 siguen libres: no son un sitio donde «aparcar» el hilo que sobra.

Si el empalme de un cable que sí se queda queda feo, no se da por bueno porque conduce un momento al tocarlo. El contacto que depende de la presión del dedo es el empalme frío del dibujo. Se rehace en frío de corriente, con la Pi fuera, y se vuelve a mirar el filete. Un puente entre patas vecinas se quita antes de enchufar, no después de oler. Y si hoy no hay nada que se quede, el soldador ni se enchufa: la práctica es la lista de lo que no se conecta, escrita en el cuaderno, y el LED de la 24 todavía en la placa de pruebas.

Ejercicio en la Pi

Sin soldar, recorre el header y aparta cualquier cable que una 5 V con un GPIO o que ate un motor a un pin. Deja el LED de la 24 en la placa de pruebas. En el cuaderno, escribe las tres cosas que no se conectan y en qué caso sí soldarías: un cable que se queda o una hilera en una placa hija. Si de verdad tienes que soldar esa hilera hoy, la Pi no está debajo, el soldador vuelve al soporte, no respiras el humo encima y lo desenchufas al terminar. Si no tienes que soldar, no enciendas el soldador para la práctica: decir que no toca es el resultado bueno.

Tu cuaderno

Lo que escribas aquí se guarda solo en este navegador. No se envía a ningún sitio.

Tu cuaderno

Un GPIO de esta Pi con Linux solo distingue alto y bajo: cerca de 3,3 V o cerca de masa. Una señal que sube y baja de continuo no tiene una entrada en el header de 40 pines, porque esa Pi no lleva ADC ahí. El Pico sí tiene entradas analógicas, y el Pico no es este curso. Si el sensor habla con un voltaje variable, hace falta un conversor, por ejemplo un ADS1115, o se cambia el sensor por uno digital.

Alto y bajo no son una medida

Hasta aquí el header ha hecho de interruptores. El LED se encendía porque el BCM 17, en el físico 11, se ponía alto. El pulsador se leía porque el BCM 23, en el físico 16, estaba alto por el pull-up o bajo porque lo cerrabas a masa. En los dos casos el programa recibía una de dos respuestas. No recibía «un poco». on no es un 40 por ciento. is_pressed no es un 40 por ciento. O cuenta o no cuenta.

Eso basta para una lámpara, para un aviso de puerta y para el umbral que tú escribiste a mano en la lección 19. No basta para un sensor que traduce el mundo a un voltaje intermedio. Una fotorresistencia en un divisor, una sonda que sube unos milivoltios por grado, un potenciómetro a medio recorrido: la patilla del medio no está ni en masa ni en 3,3 V. Está en algún punto de en medio, y ese punto es el dato. Un GPIO no te devuelve ese punto. Te devuelve la decisión que el chip ya tomó por dentro, con un umbral que tú no has elegido y que no es el de 28 grados.

Puedes comprobarlo con la cabeza, sin cablear nada analógico. Si el pin dice alto, tú solo sabes que la tensión superó el corte interno. No sabes si iba justo por encima o pegada a 3,3 V. Si dice bajo, no sabes si era masa limpia o un resto. Dos lecturas distintas del mundo caben en el mismo bit. Por eso un programa que haga if sobre ese bit no está midiendo: está clasificando, y la clase la puso el silicio, no tú.

La curva no tiene agujero

El header de esta Pi con Linux tiene alimentación, masa y GPIO. Los GPIO son digitales. Los físicos 2 y 4 son 5 V de alimentación, no una entrada de medida y no un sitio donde «leer mejor» porque el número sería más grande. Los físicos 1 y 17 son 3,3 V de alimentación. Tampoco miden. Los de masa son el cero de referencia. Ninguno de esos agujeros acepta una rampa y te la devuelve como número. No hay un físico 0 analógico escondido entre el 1 y el 2. No traduzcas A0, A1 o ADC0 de un esquema de otra placa a un BCM de esta. Ese esquema es de otra familia.

La frase corta que no sirve es «Raspberry no tiene ADC». Es demasiado ancha y es falsa si con ella tapas el Pico. La frase de este curso es concreta: la Pi con Linux no tiene ADC en el header de 40 pines. El Pico sí tiene ADC, y el Pico no es este curso: no arranca Raspberry Pi OS y no es la máquina de estas lecciones. Una ficha basta, en Hardware, Pico. No se monta el sensor de hoy en un Pico «porque allí sí entra» y se sigue llamando a esto la misma práctica.

El PWM de la lección 27 no rellena este hueco. Allí la Pi fabricaba un brillo aparente encendiendo y apagando muy deprisa. Salía ella. No leía una tensión ajena. value 0,5 no significa que el pin se haya vuelto analógico ni que ahora sepa medir la mitad. Sigue saltando entre masa y 3,3 V. Confundir «yo genero pulsos» con «yo leo un voltaje variable» es el error que lleva a pinchar un divisor en el físico 11 y a creer que LED o Button van a pronunciar voltios. No lo van a pronunciar.

Conversor, o sensor que ya habla en digital

Si el aparato que tienes entrega un voltaje variable, entre el aparato y el header tiene que haber alguien que convierta esa rampa en un número. Ese alguien es un conversor analógico-digital. Un ejemplo, y solo un ejemplo, es el ADS1115: un chip que mide tensiones en sus propias entradas y luego habla con la Pi por un bus digital. La Pi no se vuelve analógica. Sigue recibiendo bits. El conversor es quien vio el voltaje. Hoy no se cablea ese chip. No le asignes un BCM «analógico» porque no existe, y no lo alimentes a 5 V en un pin de 3,3 V para probar. Cuando toque el bus, será la lección 31, con los hilos que esa lección nombre, no con un agujero inventado.

La otra salida, y es la que el curso toma en la lección 30, es cambiar de sensor. Un sensor digital ya hizo la conversión dentro de su cápsula, o ni siquiera trabaja con una tensión intermedia tuya. Te entrega un número por un protocolo. El BME280, por I2C, es de esa clase: temperatura con unidad, no un bit suelto. Un DHT no se elige a ciegas en esta Pi; el porqué está en la 30, y no es que el DHT «sea analógico». También es digital, pero su manera de contar el tiempo encaja mal con Linux. No adelantes el montaje. Quédate con el criterio: o hay conversor, o hay sensor digital que esta máquina pueda leer sin fingir un pin que no está.

No inventes el pin. Si un dibujo de internet marca A0 en una Pi de cuarenta pines, el dibujo está mezclando placas. El pinout de esta página no tiene esa etiqueta. Si la buscas y no aparece, no la crees en el físico 7 «porque está libre». Libre quiere decir GPIO digital libre, no entrada de medida. Los físicos 27 y 28 siguen reservados a la EEPROM del HAT: tampoco son el hueco analógico que faltaba.

Qué harías si ignoras esto

El fallo típico es pinchar la salida de una sonda analógica en un GPIO y leerla con Button o con un bucle que imprime ceros y unos. Verás cambios cuando la tensión cruce el umbral interno, y los llamarás medida. No lo son. Un cuarto de vuelta más del potenciómetro puede no cambiar el bit, y un soplo de ruido puede cambiarlo. El programa parece vivo y el número no significa voltios ni grados. Arreglarlo con más print no crea un ADC.

El otro fallo es alimentar esa sonda desde el físico 2, los 5 V, «para que la escala llegue más arriba», y leer el divisor con un GPIO de 3,3 V. Aunque el nudo del divisor se quede bajo, un error de resistencias te mete más de 3,3 V en la patilla. La lección 23 no se deroga porque el sensor sea pequeño. 5 V en un GPIO lo rompe. Y aunque no lo rompa, sigue sin haber ADC: solo has hecho más peligroso un bit.

Hoy no se compra nada a toda prisa. Se escribe el criterio. En el cuaderno caben tres líneas: qué es alto y bajo, que este header no mide una rampa, y cuál de los dos caminos usarías si mañana tuvieras una sonda de voltaje variable. Conversor, por ejemplo un ADS1115, o sensor digital. Sin un tercer camino llamado «pin analógico de la Pi».

El umbral interno no es tu umbral

Dentro del chip, la entrada digital compara la patilla con un corte. Por debajo, bajo. Por encima, alto. Ese corte no está escrito en tu programa y no es el 28 de la lección 19. La lección 19 comparaba un número que tú habías guardado, con unidad de temperatura cuando el número signifique grados, y con una regla tuya: pasar de 28. Aquí, si engañas al GPIO con una tensión intermedia, quien decide es el corte del fabricante del SoC, con histéresis, con ruido y sin una línea de código que lo nombre. No puedes moverlo a 1,2 V porque tu sensor viva en esa zona. No aparece en gpiozero como un argumento de Button. Si lo buscas, no lo vas a encontrar, y inventarlo en un comentario no cambia el silicio.

Por eso dos programas distintos, leídos sobre el mismo cable analógico mal puesto, pueden contar la misma mentira. Uno imprime «luz» y el otro imprime «presencia». Los dos vieron el mismo bit. El mundo, entre tanto, pudo haber pasado de sombra a sol sin cruzar otra vez el corte, o pudo haber cruzado el corte por un pico de ruido de un milisegundo. El cuaderno que anote ese bit como si fuera lux o grados mezcla unidades. La lección 30 existe precisamente para que el número traiga unidad. Hoy el trabajo es negar el atajo: un bit no se gradúa.

Tampoco se gradúa leyendo muy deprisa. Un bucle que muestree el GPIO mil veces por segundo sigue recibiendo ceros y unos. La nube de ceros y unos no es una aproximación del voltaje, salvo en un caso muy concreto que este curso no usa: si tú mismo generas la rampa y conoces el corte, a veces se habla de medir por tiempo. No es el header midiendo. Es un truco con un condensador, fácil de hacer mal, y no sustituye a un conversor. No lo montes «para saltarte el ADS1115». Si no tienes conversor y no tienes sensor digital, no mides. Esperas a tener uno de los dos. Apuntarlo en el cuaderno es un resultado válido de la práctica, no una falta.

El físico 11 sigue siendo salida del LED si lo dejaste así. No lo reutilices como «la entrada analógica de la casa» ni siquiera un minuto, con la sonda en la mano y la frase «solo para ver». Un minuto basta para meter 5 V si el otro extremo del cable estaba en el raíl equivocado. Apaga como en la lección 9 antes de acercar un cable nuevo, y si el cable nuevo no es digital, no lo acerques. La resistencia del LED no se convierte en conversor porque esté en serie. Limita corriente de un diodo. No traduce una rampa a un número.

Qué anotar para no deshacerlo en la 30

La lección siguiente elige un sensor digital y un número con grados. Para que esa elección no se caiga, deja escrito que el dato bueno no es el estado del pin. Es un número que significa algo, con unidad, comparable con el 28. Si mañana el programa imprime 0 o 1 y lo llamas temperatura, has vuelto a esta lección por la puerta de atrás. Si imprime 21, aún tienes que saber si son grados o un registro crudo: eso se apura en la 30 y se depura en la 32. El orden es ese. No se empieza por una librería nueva ni por un pin inventado.

Si en la mesa hay un módulo con tornillo de tres patas marcado VCC, OUT y GND, OUT es casi seguro la rampa. VCC no se ata al físico 2 solo porque el texto del módulo diga 5 V en letra pequeña que no has leído. Y OUT no se ata a un GPIO «a ver si gpiozero lo entiende». Se deja en la bolsa. En el cuaderno: «módulo analógico, no entra en este header». Esa frase te ahorra el experimento. El conversor, si un día lo compras, se elige porque sus entradas aguantan el voltaje de esa sonda y porque habla en digital con la Pi. Las corrientes y los máximos los dice su hoja, no esta página. No invento amperios del raíl de 3,3 V ni del de 5 V para animarte a colgarle cosas.

Aviso. GPIO a 3,3 V. La Pi con Linux no tiene ADC en el header de 40 pines. No hay pin analógico que inventar. El Pico sí tiene ADC y no es este curso. Físicos 2 y 4 son 5 V, no medida. Físicos 27 y 28 sin cable. Sin 230 V.

Ejercicio en la Pi

No conectes una sonda analógica. Con la Pi como está, abre el pinout y señala, en voz alta o en el cuaderno, que no hay etiqueta de entrada analógica. Anota la frase completa: la Pi con Linux no tiene ADC en el header de 40 pines. Al lado, una frase del Pico: sí tiene, y no es esta máquina. Si tienes a mano un sensor que solo saca voltaje variable, no lo pinches: escribe si el camino sería un conversor o cambiar de sensor. El LED y el pulsador, si siguen montados, se quedan como estaban, en digital. No los muevas al físico 2 para «probar niveles».

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

El sensor de esta lección es un BME280, digital por I2C, y no un DHT elegido a ciegas: el DHT depende de tiempos muy justos y en la Pi falla más. Se alimenta a 3,3 V, con su masa, y dos hilos de datos. El número que importa lleva unidad, grados Celsius, y el umbral es el de la lección 19: si pasa de 28, avisa. El bus, las direcciones y cómo se enciende quedan para la 31.

Por qué este sensor y no el otro

Un DHT, el 11 o el 22, también presume de dar temperatura en digital. Cabe en un solo hilo de datos, y por eso parece más simple que un bus. La simplicidad está en el cable y no en el tiempo. El sensor y el programa tienen que ponerse de acuerdo en microsegundos: un pulso un poco largo es un bit, un pulso un poco corto es el otro. En un microcontrolador que no hace otra cosa, ese acuerdo se sostiene. En la Pi con Linux el núcleo atiende a más de un programa. Un retraso de nada, invisible en un print, le cambia el bit al DHT. El resultado es una lectura que falla, un checksum que no cuadra, o un número que no se mueve cuando la habitación sí. Por eso no se elige a ciegas. No es que esté prohibido en el universo. Es que este curso, en esta máquina, no lo usa de sensor de confianza.

El BME280 mide dentro del chip y entrega el dato por I2C. Los tiempos del bus los lleva el periférico, no un bucle tuyo contando pausas. Linux puede seguir siendo Linux. Tú pides un número y, cuando el montaje es el bueno, el número vuelve con decimales que sí caben en una habitación. También mide presión y humedad en el mismo chip. Hoy solo importa la temperatura. No montes tres sensores para tres magnitudes que este ya reúne, y no cambies a un DHT porque un dibujo lo pinche con menos cables.

Sigue siendo digital. No rellena el hueco de la lección 29 con una rampa. Si tu cajón solo tiene una sonda de voltaje variable, esta lección no te autoriza a pincharla en el físico 3. El físico 3 va a ser datos, no una entrada analógica. O hay conversor, como se dijo, o hay un sensor de esta clase.

El montaje, sin adelantar el bus

Con la Pi apagada del modo de la lección 9, cuatro hilos. La alimentación del módulo, la patilla marcada 3V3 o 3,3 V, va al físico 1. El físico 1 es 3,3 V de alimentación, no un GPIO. El físico 17 también es 3,3 V si el 1 ya está ocupado por otra cosa de verdad, no por un experimento. La masa del módulo va a un agujero de masa, el físico 6 o el 9. Es el mismo cero de siempre. No es el físico 2 y no es el físico 4: esos son 5 V. Un sensor de 3,3 V alimentado a 5 V es la avería de la lección 32, no un atajo para que «se vea mejor».

Los otros dos hilos son datos. En la serigrafía del BME280 ponen SDA y SCL. SDA va al físico 3, que es el BCM 2. SCL va al físico 5, que es el BCM 3. No los cruces «para probar». No los lleves al físico 11 ni al 16, que siguen siendo el LED y el pulsador si los dejaste puestos. Esos dos números, 17 y 23, no son el bus. El detalle de por qué hay un bus, de cómo varios sensores comparten esos mismos dos hilos y de cómo se enciende, es la lección 31. Hoy los hilos se reconocen y se dejan en su agujero. No hace falta todavía i2cdetect para saber si el cable de masa es masa.

Muchas placas del BME280 traen más almohadillas: CS, SDO, SDI, o nombres parecidos, porque el chip también sabe hablar otro protocolo. No las sueldes todas a GPIO «para que ninguna quede huérfana». El curso usa I2C: alimentación, masa, SDA y SCL. Si la plaquita ya trae puentes de fábrica, se quedan. Tirar CS a masa puede sacar al chip del modo que estamos usando, y entonces el bus de la 31 saldrá vacío con los cables bien puestos. Si una almohadilla no la entiendes, no la inventes. La hoja de esa placa manda, y esta página no inventa el puente que la tuya no trae.

Algunas placas ponen VIN y aceptan más tensión porque llevan su propio regulador. Eso lo dice su hoja, no un foro. Esta lección no te manda a los 5 V. La patilla marcada 3V3 se alimenta a 3,3 V. La patilla marcada 3V3 no se prueba con el físico 2 «un segundo». Si solo ves VIN y no sabes si hay regulador, no adivinas: preguntas a la hoja antes de dar corriente. Mientras tanto el módulo se queda sin alimentar, que es más barato que un chip cocido.

Un número con unidad

Cero o uno era el pulsador. Grados son otra cosa. El dato de esta lección se llama en voz alta con su unidad: grados Celsius. En el programa, la variable puede llamarse grados. Sin unidad, 28 no significa nada: podrían ser un registro, un recuento o la dirección de un chip. Con unidad, 28 son 28 °C, el mismo umbral de la lección 19. Pasar de 28 es ser mayor que 28. Veintiocho justo no pasa. Veintinueve sí. La comparación no se cambia en silencio a «mayor o igual».

El número, mientras el bus no esté encendido y leído, lo escribes tú. El cable ya puede estar puesto. El if ya se puede probar, que es lo que la lección 19 hacía a propósito para ver las dos ramas. No hace falta que el sensor conteste hoy para saber que 27 sigue y 29 avisa. Cuando más adelante la lectura llegue sola, sustituye el número escrito a mano por esa lectura, sin tocar la comparación. Si la lectura viene sin convertir, un entero enorme que no cabe en la cocina, no la compares todavía: no son grados. La lección 32 trata esa mentira. Hoy no la tapes dividiendo por un factor que hayas adivinado.

grados = 27.5
if grados > 28:
    print("aviso")
else:
    print("sigue")

En el archivo el decimal lleva punto, como en la lección 19. En voz alta es veintisiete coma cinco. Con 27,5 tiene que salir sigue. Cambias la primera línea a 29, guardas, y sale aviso. Con 28 exacto sale sigue. Si sale aviso con 28, la comparación no es la del curso. No bajes el umbral para que el LED de la alerta quede más bonito. El umbral es 28 porque el curso lo fijó así, no porque el BME280 lo pida.

No instales una librería a ciegas, y no uses pip como root: la lección 22 sigue en pie. El paquete, cuando haga falta de verdad, entra por apt si existe en esta imagen, con red en ese momento, como el resto de paquetes del curso. Hoy el ejercicio cierra sin esa pieza. Un import que no tienes no se finge. Se anota «lectura aún no» y se prueba el umbral con el número escrito. Inventar el import no crea el dato.

Qué no significa el primer número que veas

Si alguien te presta un programa que ya imprime 21, pregunta la unidad antes de celebrarlo. 21 °C en una habitación cerrada es creíble. 21 a secas, salido de un registro, puede ser un trozo del dato. 21 °F sería otra escala y no es la de este umbral: 28 °F no es el 28 del curso. El curso habla en Celsius. No conviertas a escondidas y dejes el if igual, porque entonces avisas con otro calor.

Tampoco llames temperatura al estado del GPIO. Si lees el físico 3 con Button mientras es SDA, verás altos y bajos del propio bus, o un pin ocupado, no los grados. El bus no se espía con la clase del pulsador. Se deja quieto hasta la lección 31, que lo enciende y lo mira con la herramienta del bus, no con un botón.

El LED del BCM 17 puede seguir. No lo enganches al aviso todavía si eso te obliga a mezclar el archivo a medias. Primero las dos ramas del print. El aviso en la pantalla basta. Un LED que enciende al pasar de 28 es el mismo if, con on dentro, y la resistencia de la lección 24 no se quita. Si no te da la tarde, el print es el ejercicio completo. No añadas un relé ni 230 V para «avisar de verdad».

Cómo se reconoce un dato que ya sirve

Un dato que sirve se puede decir en una frase de cocina. «Hace 27,5 grados y no pasa de 28, así que no aviso.» Si la frase necesita disculpas, el dato no está listo. «Sale 27,5 pero no sé de qué» no se compara. «Sale 1 porque el pin está alto» no es temperatura. «Sale 275 y lo parto por diez a ver si cuadra» es una conversión inventada: a veces acierta y mañana, con otro registro, miente. El curso prefiere un número que ya venga en grados, o ninguno, antes que un factor sacado de un ejemplo de otra placa.

Puedes anotar al lado del if, en un comentario de una línea, la unidad. El comentario no ejecuta nada. Te impide, dentro de una semana, tratar grados como un contador de pulsaciones. No comentes en inglés de tutorial ni copies un bloque que lee el DHT «ya que estamos». Ese bloque trae los tiempos justos que acabas de dejar fuera. Si el archivo se mezcla, bórralo hasta dejar el if limpio y vuelve a probar 27,5 y 29. Dos pruebas, dos ramas. Más vueltas no enseñan el umbral.

El sensor, una vez cableado, no se mueve de sitio mientras pruebas el archivo. Cada vez que desenchufas SDA con la Pi en marcha estás interrumpiendo un bus que la 31 todavía no ha presentado, y puedes dejar el chip a medias. Los cambios de cable se hacen con la corriente quitada, como en el LED. Si solo cambias el número de la primera línea, no hace falta apagar: no estás tocando patillas. Guardas el archivo y lanzas python3 con el nombre que le hayas puesto, desde tu home, con el Python del sistema. No con sudo. Un umbral no necesita root, y un archivo creado como root luego no lo puedes guardar.

Si el módulo trae agujeros para una regleta y aún no está soldada, no sueldes la Pi, y no sueldes tampoco el módulo en caliente contra el header. La lección 28 sigue valiendo: la placa de pruebas o los cables hembra bastan para este ensayo. Soldar la hilera del módulo, si se va a quedar, se hace con el módulo solo, fuera de la Pi, y se deja enfriar antes de enchufarlo. Si hoy es un ensayo, no hay soldadura. Cuatro cables entran y salen.

Aviso. El BME280 va a 3,3 V. Nada de 5 V en una patilla de 3,3 V. SDA al físico 3, SCL al físico 5, masa de verdad. GPIO a 3,3 V. Físicos 27 y 28 sin cable. Sin pin analógico inventado. Sin 230 V. El umbral es pasar de 28 °C, no llegar a 28.

Ejercicio en la Pi

Apaga bien. Cablea el BME280: 3,3 V al físico 1, masa al físico 6, SDA al físico 3, SCL al físico 5. No uses el físico 2. No rellenes el resto de patillas del módulo con GPIO sueltos. Enciende. En un archivo de tu home, el de la lección 19 o uno nuevo al lado, prueba grados a 27,5 y a 29. Tiene que salir sigue y luego aviso. Anota en el cuaderno la unidad, °C, y que el bus todavía no se ha explicado: la 31 dirá cómo comprobar que el chip contesta. Si no tienes el módulo, no lo sustituyas por un DHT ni por una sonda analógica. Escribe el if igual y dibuja los cuatro hilos en el cuaderno con sus físicos. Eso es el montaje, en papel, hasta que el sensor exista.

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

I2C son dos hilos compartidos: SDA es el BCM 2, en el físico 3, y SCL es el BCM 3, en el físico 5. Varios sensores pueden ir en esos mismos dos hilos si cada uno tiene su dirección. El bus se enciende en raspi-config, en Interface Options, y el menú fino está en Software. i2cdetect -y 1 enseña las direcciones en hexadecimal. Si la tabla sale vacía, no cambies el programa: mira el cable, la alimentación y que el bus esté encendido.

Dos hilos, no un pin por sensor

En el pulsador hacían falta un GPIO libre por cada contacto. En I2C no. Los sensores se enganchan en paralelo a los mismos dos hilos: todos los SDA juntos en el físico 3, todos los SCL juntos en el físico 5. La Pi pregunta por una dirección. Solo contesta el chip que la tiene. Los demás se callan. Por eso caben el BME280 y otro chip en el mismo header sin gastar el físico 11 ni el 16. Esos siguen libres para el LED y el botón.

Cada chip necesita, además, comida y cero. El paralelo de los datos no alimenta. Cada módulo lleva su 3,3 V, desde el físico 1 o desde el mismo raíl de 3,3 V de la placa de pruebas si ese raíl sale del físico 1, y su masa, al físico 6 o a la masa común. Compartir masa es obligatorio: sin el mismo cero, la dirección no se entiende. Compartir los 5 V no forma parte del trato. Un módulo de 3,3 V no se cuelga del físico 2 aunque el de al lado sí lo aguante. Si uno de los dos es de 5 V según su hoja y el otro no, no los unas al mismo raíl de alimentación. Esta lección no mezcla eso. Los dos, si son los del curso, van a 3,3 V.

La dirección no es el número de pin. Es un nombre corto del chip, casi siempre de siete bits, y se escribe en hexadecimal: 0x76, 0x77. En muchas placas del BME280 la dirección es una de esas dos, según cómo esté el puente SDO. No la copies de esta página como si fuera ley. La ley, en tu mesa, es la que imprima i2cdetect. Dos chips con la misma dirección en el mismo bus no se distinguen: contestan a la vez y la tabla miente o el programa lee basura. Si los dos módulos nacieron con 0x76, no es un fallo del cable. Hay que cambiar el puente de uno, como diga su hoja, hasta que sean direcciones distintas. No se arregla creando un segundo bus imaginario en el físico 11.

El reloj lo pone la Pi. SCL no es una alimentación disfrazada y no se mide con el dedo. SDA es el hilo por el que van las preguntas y las respuestas, en los dos sentidos, por eso es un solo cable y no dos. No hace falta un hilo de «ida» y otro de «vuelta». Quien añada un tercer hilo de datos «por si acaso» está inventando otro protocolo. Se dejan los dos.

Encender el bus, y mirarlo

De fábrica, en esta imagen, el bus del header puede estar apagado. Un cable perfecto y un programa perfecto no ven nada si el periférico no está habilitado. Se enciende con raspi-config, en Interface Options, la entrada de I2C, activar. El menú fino, incluida la línea que esa herramienta escribe, está en Software, I2C. No edites config.txt a mano en esta lección: es fácil dejar otra línea tocada. Cuando raspi-config termine, hace falta un reinicio para que el bus nazca. El reinicio limpio es sudo reboot, el de la lección 14, una vez, no diez tirones del cable.

Al volver, la herramienta se llama i2cdetect. Si la consola dice que no existe, el paquete es i2c-tools y entra con apt, no con pip:

sudo apt install i2c-tools

Hace falta red en ese momento, como en la lección 15. Sin red, solo entra si ya estaba en la caché. No lo instales dentro de un venv. Es una herramienta del sistema. La orden para mirar el bus del header, en los modelos donde ese bus es el 1, es:

i2cdetect -y 1

El -y evita una pregunta de más. El 1 es el número del bus, no el físico 1 y no «un sensor». Si la orden dice que no tienes permiso, no cambies el sensor de sitio y no inventes el nombre de un grupo. Mira groups en la placa, como en la lección 12, y anota lo que salga. El permiso no se arregla leyendo otra dirección.

La tabla usa hexadecimal. Una celda con 76 es la dirección 0x76. Una celda con -- es silencio. UU, si aparece, no es vacío: el sistema ya se quedó con esa dirección. Sigue habiendo algo ahí. Vacío de verdad es una tabla sin ningún número de chip, solo rayas. Entonces no abras el programa de los grados para «retocarlo». El programa aún no es el sospechoso. Mira, en este orden: que SDA siga en el físico 3 y SCL en el físico 5, que no estén cruzados, que el módulo tenga 3,3 V y masa, que no hayas tirado de un puente CS que lo saque de I2C, y que de verdad activaras el bus y reiniciaras después. Un detect lanzado antes del reboot mira el bus viejo, el apagado.

Qué haces con el número que salga

Anota la celda. Si sale 76, tu programa, cuando llegue el momento de leer, usará 0x76 y no 0x77 porque un ejemplo de internet lo trajera. Si salen dos celdas, anota las dos y cuál módulo es cuál: se tapa uno, se vuelve a detectar, y la que desaparece es la del módulo que tapaste quitándole los 3,3 V con la Pi apagada, no arrancando el chip en caliente si no hace falta. Con la corriente puesta, soltar solo el SDA ya basta para que esa dirección calle, y es más brusco de la cuenta. Mejor apagar, soltar un módulo, encender, detectar, y comparar.

No hace falta otra librería para este paso. i2cdetect no es un import de Python. Es la prueba de que el pasillo existe y de que alguien contesta. El if de los grados, el de la lección 30, sigue comparando un número con unidad. No compares la dirección 0x76 con 28. Setenta y seis hexadecimal no son grados. Son el nombre del chip en el pasillo. Mezclarlos es la mentira que la lección 32 va a separar: no hay dispositivo, o el número es absurdo. Hoy, si la tabla tiene una dirección, hay dispositivo. Si no la tiene, no lo hay, y el umbral no se toca para compensar.

Los pull-up de estos dos pines ya vienen en la Pi. No añadas resistencias a 5 V «porque I2C se tira hacia arriba». Tirar SDA o SCL a 5 V mete 5 V en un GPIO. El bus de este header trabaja a 3,3 V. Si un módulo trae sus propias resistencias a su alimentación y esa alimentación es 3,3 V, se puede convivir. Si sus resistencias van a un VIN de 5 V, ese módulo no es el invitado de esta lección hasta que su hoja diga lo contrario. No lo descubras midiendo con el chip ya frito.

El físico 3 y el físico 5 dejan de estar libres para un LED o un pulsador mientras el bus esté en uso. No son «GPIO normales que además hacen I2C si quiero». Con el bus encendido, un LED(2) pelea con SDA. No lo lances para ver la luz. El LED sigue en el 17, físico 11. El botón sigue en el 23, físico 16. Los físicos 27 y 28 siguen sin cable: no son un segundo I2C de repuesto.

Cómo se lee la tabla sin convertirla en un mito

La tabla tiene columnas de 0 a f. Son dieciséis columnas porque el hexadecimal va de ese modo, no porque haya dieciséis sensores. La fila dice el grupo alto de la dirección y la columna el bajo. No hace falta memorizar la suma. Hace falta copiar los dos caracteres que no sean rayas. Si en la fila 70: y en la columna 6 ves 76, la dirección es 0x76. Si no estás seguro de la fila, copia la celda entera tal como se ve y no la traduzcas a decimal para el programa. El código del chip se escribe con 0x. En decimal, 118 y 0x76 son el mismo valor, y usar 118 donde la llamada espera hexadecimal, o al revés, es una dirección equivocada con pinta de número serio. La lección 32 empieza por ahí cuando el chip sí está y el programa pregunta a otro sitio.

El cero de la esquina, las primeras direcciones, sale a menudo tachado o vacío a propósito: son direcciones que el bus reserva. No las rellenes. No busques tu BME280 en la fila 00:. Si la única marca rara es UU, ya se dijo: el núcleo tiene un controlador encima. No es la tabla vacía de «no hay cable». Vacío es ausencia de números y de UU. Anótalo con esas palabras en el cuaderno para no contar mañana un UU como un fallo de masa.

Un segundo sensor se añade con la Pi apagada. Se repiten SDA, SCL, 3,3 V y masa. No se cruza SDA del segundo al SCL del primero «para equilibrar». Los dos SDA van al mismo hilo. Los dos SCL van al otro. Si al detectar solo aparece una dirección, el segundo no está hablando: su alimentación, su masa, su dirección repetida o un puente que lo dejó en otro modo. No des por bueno el primero y olvides el segundo en silencio. La lección dice que varios caben. Caben cuando cada uno contesta. Si no tienes segundo sensor, no improvises con un DHT en el mismo par de hilos. El DHT no es I2C. Pincharlo en el físico 3 no lo convierte y estorba al BME280.

Cuando la dirección ya es estable, el número de grados de la lección 30 sigue siendo un número con unidad, no la celda. Puedes dejar escrito en el cuaderno «0x76 es el nombre, no los grados». Esa frase evita el programa que compara 0x76 con 28 y avisa siempre, porque setenta y seis, leído como entero, pasa de veintiocho. Es un error de principiante muy limpio: el if está bien escrito y el dato es el equivocado. Si te pasa, no has descubierto que la cocina está ardiendo. Has descubierto que metiste la dirección en la variable grados.

Aviso. SDA, BCM 2, físico 3. SCL, BCM 3, físico 5. Alimentación del sensor a 3,3 V, no a 5 V. i2cdetect -y 1. Si sale vacío, no cambies el programa: cable, alimentación, bus encendido y reinicio hecho. GPIO a 3,3 V. Físicos 27 y 28 libres. Sin 230 V.

Ejercicio en la Pi

Con el BME280 cableado como en la lección 30, abre raspi-config y activa I2C en Interface Options. Reinicia una vez con sudo reboot. Si falta la orden, instala i2c-tools con apt, no con pip. Lanza i2cdetect -y 1. Copia al cuaderno la celda que tenga número, en hexadecimal, o escribe «vacío» si solo hay rayas. Si está vacío, no edites el if: revisa físico 3, físico 5, 3,3 V, masa, y que el reinicio fue después de activar. Si tienes un segundo sensor I2C de 3,3 V y otra dirección, puedes unirlo a los mismos dos hilos y volver a detectar. Si su dirección coincide con la del primero, no los dejes juntos: sepáralos y anótalo. No añadas una librería nueva para este ejercicio. El dato en grados sigue siendo el de la 30.

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

El dato miente cuando el cable está suelto, cuando la dirección no es la que contestó en el bus, cuando un sensor de 3,3 V se alimentó a 5 V, o cuando se lee el número crudo y se le llama grados. No es lo mismo «no hay dispositivo» que «el número es absurdo». Si i2cdetect sale vacío, se mira primero el cable, la alimentación y el bus. Si la dirección está y el programa se queda en 85 °C, el chip contestó y la mentira es la medida, no una librería nueva.

No hay dispositivo

La prueba está en la lección 31 y no se sustituye por un print. i2cdetect -y 1 con solo rayas quiere decir que ninguna dirección contestó. En ese estado, el archivo de Python no tiene a quién leer. Si aun así imprime un número, ese número no salió del BME280 en este arranque: salió de un valor que dejaste escrito, de un ejemplo, o de un fallo que el programa convirtió en una cifra para no quedarse callado. Tratarlo como grados de la cocina es la mentira.

Lo que se mira primero, y en este orden, es aburrido y es físico. SDA sigue en el físico 3. SCL sigue en el físico 5. No están cruzados. La masa sigue en un agujero de masa. La alimentación sigue en 3,3 V, físico 1 o el raíl que nace de ahí, no en el físico 2. El bus se activó en Interface Options y hubo un sudo reboot después. Un cable suelto entra en esta lista: la regleta que hace contacto si empujas con el dedo y lo pierde si sueltas no es un sensor inestable, es un contacto. Se apaga, se sienta el cable hasta el fondo, se enciende, se vuelve a detectar. No se reescribe el if entre medias.

Tampoco se cambia de librería. No hay un import que haga visible un chip al que no le llega la masa. Añadir otra librería deja dos maneras de leer, ninguna con dispositivo, y el siguiente error será cuál de las dos creer. El curso no añade esa segunda pieza. i2c-tools, si ya lo instalaste para detectar, no cuenta como librería de más: es la herramienta con la que miras. No instales al lado un paquete «más moderno» porque la tabla haya salido vacía.

Hay dispositivo, y el número no es de este mundo

La otra cara: la tabla muestra una dirección, por ejemplo 76, y el programa imprime 85, y sigue imprimiendo 85 aunque soples el sensor, aunque abras la ventana, aunque esperes un minuto. La habitación no está a 85 °C. Un número clavado, insensible al mundo, no es una medida que se haya quedado quieta por casualidad. Es un valor que no llegó a ser temperatura, o una temperatura de error que algún ejemplo usa cuando la lectura no cuadra. El umbral de 28 no se entera de la diferencia: 85 pasa de 28, así que el if avisaría con toda la razón aritmética y con toda la mentira física. No bajes el umbral a 90 para acallar la alarma. Quita el falso grado.

Primero separa los casos. Si al repetir i2cdetect -y 1 la dirección desaparece, ya no estás en «85 grados»: estás en «no hay dispositivo», y vuelves al cable, a la alimentación y al bus. Si la dirección sigue ahí y el 85 sigue clavado, el chip contesta a su nombre y lo que falla es lo que haces con la respuesta. Estás leyendo el byte crudo y lo llamas grados. O estás leyendo un registro que no es el de temperatura. O la dirección del programa no es la de la tabla: detect dice 76 y el código pregunta 0x77, no obtiene el dato bueno y se queda con un relleno. Se corrige la dirección para que sea la de la celda, no se instala un lector nuevo.

El crudo se reconoce porque no cabe en la frase de la cocina. 21 o 27,5 sí caben en una habitación. 8500 no. 280, si no has decidido aún la escala, tampoco se compara con 28: podrías estar viendo décimas o milésimas empaquetadas en un entero, y partir por el número que «queda bonito» es inventar la hoja del chip. La hoja dice la escala. Si no la tienes delante, no divides. Anotas «número crudo, sin unidad» y no dejas que el if dispare. Mejor no avisar que avisar de un horno que no existe.

85 °C clavados es el caso de práctica de esta lección precisamente porque engaña al umbral. Pasa de 28, luego el programa «funciona». Funciona la comparación. No funciona la medida. Antes de tocar el 28, preguntas: ¿el bus ve al chip ahora mismo? Vacío: cable, 3,3 V, masa, bus. Con dirección y 85 quieto: unidad y registro y dirección del programa, no otra librería. Soplar el sensor es una prueba legítima solo cuando ya hay dirección. Si al soplar, con cuidado y sin tocar patillas, el número se mueve un poco y sigue en grados creíbles, era una habitación caliente de verdad y el 85 no era tu caso. Si no se mueve ni un decimal, no es el aire de la boca: es un valor fijo.

La dirección equivocada y los 5 V

Dirección equivocada es un caso estrecho del anterior. Detect muestra una celda. El programa pregunta otra. A veces la librería que ya tenías, una sola, trae 0x77 por defecto y tu puente está en 0x76. Se cambia ese número al que viste, se vuelve a leer, y se mira si ahora el valor se mueve y cabe en grados. No se dejan las dos direcciones en un bucle «a ver cuál da un número bonito»: un registro leído en la dirección del vecino, si el vecino existe, es el dato del vecino, no una segunda opinión sobre el mismo aire.

Cinco voltios en un sensor de 3,3 V es anterior a cualquier lectura. Si el hilo de alimentación está en el físico 2 o en el 4, se quita con la Pi apagada. No se aprovecha «ya que enciende» para tomar una medida de despedida. Un chip que aguantó un rato puede mentir y luego morir, o morir del todo y dejar la tabla vacía al día siguiente. Vacío después de haberlo puesto a 5 V no se depura instalando nada: se da por posible el daño, se deja el módulo fuera, y se revisa el que lo sustituya antes de darle corriente, patilla a patilla. La hoja manda si el módulo trae VIN con regulador. Sin esa frase en la hoja, no hubo permiso. El físico 1 es el que este curso usa.

Un cable de datos suelto a ratos parece las dos enfermedades. Un minuto hay dirección, al siguiente no, y el programa conserva el último 85 o el último cero. Cuando el fallo es intermitente, se empuja el cable y se mira detect, no se promedia el 85 con la habitación. Promediar una mentira con un número creíble no da la temperatura. Da un tercer número, también mentira, más difícil de ver. El cuaderno anota la hora y si en ese momento había celda o no. Eso separa los casos mejor que otro paquete.

Qué no tocar

No toques el umbral para que la mentira deje de avisar. 28 °C sigue siendo el corte de la lección 19. Con una medida buena, 27,5 sigue y 29 avisa. Con 85 clavados, el aviso es un síntoma, no una orden de cambiar el if. No toques los pines del bus para «liberarlos»: pasar SDA al físico 11 no crea un I2C nuevo. No añadas una librería. La que ya usabas, si ya leías, se queda; si todavía no lees y solo tienes detect, sigues sin añadirla hasta tener una dirección estable y la unidad clara. Pip como root sigue prohibido.

No tapes el síntoma imprimiendo la palabra «grados» al lado de un crudo. La etiqueta no convierte. Si escribes print(valor, "°C") y valor es 85 fijo o 512, has mentido con más tipografía. Quita la etiqueta hasta que el número, solo, sea creíble, y entonces devuélvela. El Maestro de esta lección no te pide fe en la pantalla. Te pide el orden: ¿hay alguien en el bus? Si no, cable y alimentación y bus. Si sí, ¿el número tiene unidad y se mueve como el aire? Si no, dirección, registro y escala. En los dos caminos, el programa del umbral espera.

Un orden que no se salta

Conviene decirlo como una lista hablada, no como un esquema colgado fuera del texto. Primero la tabla. Si está vacía, paras. Cable, 3,3 V, masa, bus, reinicio. El 85 que hubiera en pantalla se ignora hasta que la tabla cambie. Segundo, si hay una celda, comparas esa celda con la dirección escrita en el programa. Si no coinciden, las igualas a la celda y vuelves a leer. Tercero, miras si el número se mueve cuando cambia el aire, sin tocar patillas con el dedo húmedo. Si no se mueve y es 85, o es un entero descomunal, no tiene unidad todavía: no entra en el if. Cuarto, solo con un número en °C que suba y baje como la habitación, dejas el umbral donde estaba. Pasar de 28 avisa. 28 no avisa.

Saltarse el orden es lo que produce la librería de más. En el segundo fallo se instala un paquete, en el tercero otro, y al final hay tres lecturas distintas de las cuales una imprime 85, otra imprime 0 y otra revienta en el import. Ninguna de las tres ha empujado el cable. Desinstalar a ciegas tampoco es la lección. Simplemente no se añade. Si ya habías instalado una para el BME280 por apt, en un momento anterior y con red, se queda esa y se corrige el uso: dirección y unidad. No se pone al lado la de pip «por si la del sistema está vieja». La lección 22 explicó el precio de mezclar el Python del sistema con pip de root. Aquí el precio es no saber qué número creer.

El cuaderno de esta lección cabe en cuatro líneas, una por mentira. Cable suelto: qué hilo era, si lo encontraste. Dirección: la de la tabla y la que tenía el código. Alimentación: 3,3 V o el susto de los 5 V, y si el módulo sigue contestando después de corregirlo. Unidad: grados de verdad, o crudo, o 85 clavado. Con esas cuatro líneas, la próxima vez que la pantalla avise no empiezas por el umbral. Empiezas por la línea que esté en blanco. Una línea en blanco es un caso que no has mirado, no una invitación a cambiar el 28.

Aviso. Vacío en i2cdetect -y 1: cable, 3,3 V, masa, bus. No otra librería. 85 °C clavados con el chip presente: el número no es la habitación. No bajes el umbral. Nada de 5 V en un sensor de 3,3 V. GPIO a 3,3 V. Físicos 27 y 28 sin cable. Sin 230 V.

Ejercicio en la Pi

Lanza i2cdetect -y 1 y escribe en el cuaderno una de las dos frases, la que sea verdad: «no hay dispositivo» o «está la dirección» y el hexadecimal que viste. Si no hay dispositivo, no cambies el programa y no instales nada: revisa físico 3, físico 5, masa y 3,3 V, y que I2C se activó antes del último sudo reboot. Si hay dirección y además tienes un número en pantalla, decide si es creíble en °C. Si está clavado en 85, o es un entero que no cabe en la habitación, no lo compares con 28 y no añadas una librería: anota «absurdo» y qué mirarías después, la unidad y la dirección del código frente a la celda. Si el número se mueve y cabe en grados, entonces sí puedes dejar el if de la lección 30 delante, sin cambiar el 28. Si no tienes sensor, resuelve en el cuaderno los dos casos del dibujo, vacío y 85 clavado, diciendo qué se mira primero en cada uno.

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

La cámara de la placa entra por el conector de cinta. Una cámara USB es otro ojo, enchufado al puerto USB, y no ocupa ese conector. Los comandos de ahora son rpicam-still y rpicam-vid. raspistill es el nombre viejo: un tutorial que lo usa está atrasado. Si el comando no existe, lo primero es mirar si la cámara está activa, no instalar un paquete al azar.

Dos enchufes, dos ojos

La cámara que se vende como «de la Pi» no va al header de cuarenta pines. Va a un conector pequeño de cinta, en la placa, el de la cámara. La cinta tiene un lado con contactos. El pestillo del conector se abre, la cinta entra recta, los contactos hacia el lado que indique el serigrafiado de tu modelo, y el pestillo cierra. Si forcejeas con la Pi encendida y la cinta a medio salir, puedes dejar el conector torcido y además no vas a ver nada útil. Se hace con la alimentación desconectada, como cuando mueves un cable del header. No es un GPIO. No se «traduce» al físico 11.

Una cámara USB es otro aparato. Tiene su propio cable, entra en un puerto USB de la Pi y el sistema la ve como un ojo más, no como la cinta. Puedes tener las dos a la vez. No son intercambiables en el gesto: sacar la cinta y meterla en un USB no cabe, y meter el conector USB en la cinta no cabe. Si un dibujo mezcla las dos en un solo enchufe, el dibujo está mal. El de esta lección las pone enfrentadas a propósito.

El header sigue siendo el de siempre. No alimentes la cámara desde el físico 2 «porque el USB no llega». El USB ya trae su alimentación por el puerto. La cinta, si es la oficial de la placa, se alimenta por su conector, no por un par de cables que improvises al 5 V. Inventar esa alimentación es la manera de freír un módulo pequeño. GPIO a 3,3 V si algún día un accesorio de la cámara te pide un pin de aviso: ese pin no se ata a 5 V. Los físicos 27 y 28 siguen libres. Esta lección no los usa.

Los nombres que valen hoy

En esta imagen los comandos se llaman rpicam-still y rpicam-vid. El primero hace una foto. El segundo hace vídeo. La ficha corta, con el aviso de que las opciones cambian y manda el --help de tu Pi, está en Software, cámara. No hace falta memorizar una chuleta de flags. Hace falta no usar el nombre viejo.

raspistill es el nombre viejo de la foto. raspivid es el viejo del vídeo. Pertenecen a una pila anterior. Un tutorial que los pone en la primera línea está atrasado respecto a Trixie, aunque el resto del texto suene reciente: a veces solo han cambiado el año del título. Si lo copias, la consola dirá que no existe, y la tentación es instalar «lo que falte» hasta que el nombre viejo reviva. No revive. El arreglo es escribir el nombre nuevo, no cazar un paquete que devuelva el viejo.

Las opciones concretas sí pueden cambiar de una versión a otra. Por eso, cuando el comando exista, la autoridad es rpicam-still --help y rpicam-vid --help, en la propia Pi. Si el help de tu versión llama de otra manera a una opción, manda el help. Esta página no va a congelar una lista larga. La lección 34 usa dos opciones que la ficha de Software da por buenas mientras el help las liste: -o para el archivo y -t para el tiempo. Hoy basta saber que esos comandos son los vivos.

Si el comando no está

Escribes rpicam-still y la respuesta es que no se encuentra la orden. El reflejo malo es apt install con un nombre inventado, el de un blog, el de otra distribución. No. Lo primero es la cámara, no el paquete. ¿La cinta está en su conector, con el pestillo cerrado, y lo hiciste en frío? ¿O la USB está de verdad en un puerto USB y no colgando a medias? Una cámara que no está enchufada no aparece por mucho paquete que bajes.

Lo segundo es si el sistema la tiene activa. En esta imagen la detección automática de la cámara de cinta suele venir encendida. Software lo dice con la línea que ya trae el sistema. Se mira que siga en su sitio. No se abre config.txt a inventar otra línea «por si acaso»: la lección 3 ya apartó ese gesto, y una línea de más no crea un comando. Si después de ver el conector y la detección el comando sigue sin existir, preguntas al sistema qué paquetes mencionan el nombre, con apt-cache search rpicam, y lees la lista. No instalas el primero que suene. Si no hay red, la búsqueda solo ve lo que ya esté en la caché, igual que el resto de apt en este curso.

Tampoco cambies de herramienta a un módulo de Python porque la orden falte. El módulo se llama picamera2, y el nombre del paquete apt no se afirma a ciegas: Software manda buscarlo con apt-cache search picamera2. Esta lección no lo instala. Una foto de prueba, cuando el comando exista, es la 34, y se queda en la Pi. No es un motivo para añadir una librería hoy.

Si tienes los dos ojos conectados y no sabes cuál va a hablar, no lo resuelvas tapando uno con el dedo a ciegas mientras lanzas órdenes. Mira el help por si tu versión tiene forma de elegir cámara. Si no la entiendes, deja solo un ojo conectado, el que quieres probar, con la Pi apagada si el que quitas es la cinta. Un solo ojo enseña más que dos a la vez el primer día.

Qué no es este ojo

No es el sensor de la lección 30. El BME280 devolvía un número en grados. La cámara devuelve una imagen, un rectángulo de luz guardado en un archivo, o un vídeo que es muchos rectángulos seguidos. No se lee con i2cdetect y no se compara con 28. Si alguien te propone «la cámara por I2C en el físico 3», está mezclando el bus de un chip pequeño con el conector de cinta. El físico 3 sigue siendo SDA si lo dejaste para el sensor. No lo sueltes para «hacer sitio a la imagen».

Tampoco es un pin analógico que esta Pi no tiene. La lección 29 apartó las rampas. La cámara no se pincha en un GPIO para «leer el brillo». El brillo, si algún día lo quieres como número, no sale de mirar el archivo con Button. Sale de un programa que abra la imagen, y ese programa no es el de hoy. Hoy solo separas los enchufes y los nombres.

El índice de esta zona dice «cámara y sonido». El sonido no tiene lección en este curso. No aproveches la cámara para colar aplay ni un micro. La ficha de audio, si la necesitas, vive en Software y se queda ahí. Esta lección no la resume. Si el tutorial de la cámara trae al final un altavoz y una cuenta en una web, ciérralo. El altavoz no toca. La cuenta, menos: la imagen de tu casa se queda en casa, y eso es la lección 35, no un extra opcional.

Cuando el help salga, léelo en diagonal una vez. Busca si menciona la salida a un archivo. No copies diez opciones a un script «para que quede profesional». Una opción de más, de una versión que no es la tuya, hace fallar la orden entera y parece que la cámara murió. El fallo es la opción. --help es más corto que reinstalar. Si el help está en inglés, no pasa nada: los nombres de las opciones se leen igual, y las frases las puedes anotar en el cuaderno en castellano con tus palabras. No hace falta traducir el comando.

El primer día, un solo gesto

El gesto de hoy cabe en una frase: sé qué ojo tienes y sé qué comando lo nombra. No hace falta una foto bonita. Una foto borrosa, o ninguna, con el comando correcto anotado, vale más que una imagen nítida sacada con un nombre viejo que mañana no estará. Si la cinta no entra del todo, no la empujes con una uña hasta doblarla. Sácala, mira el pestillo y vuelve a probar en frío. Una cinta doblada no se endereza con software.

Si la USB pide más corriente de la que el puerto quiere darle, el síntoma suele ser que el ojo desaparece al arrancar, no que raspistill fuera mejor. No lo resuelvas con un hub sin marca ni con el pin de 5 V del header puenteado al cable. Si hace falta alimentación de verdad, la hoja de esa cámara lo dirá, y no esta página. Mientras tanto usa un solo ojo, el que el puerto aguante, y anótalo. No invento amperios del puerto ni del raíl.

Cuando cierres, la cámara puede quedarse montada. No dejes la cinta a medio pestillo «para mañana». O está cerrada o está fuera, guardada derecha. El comando no se queda residente por haber pedido el help: --help imprime y termina. Si un proceso de cámara se quedara abierto porque lanzaste otra cosa, lo cierras desde esa terminal. No desenchufes la Pi para matarlo. Apagar, si toca, es la orden de la lección 9.

Anota también qué modelo de placa tienes delante, sin convertirlo en una marca de cámara. El conector de cinta no está en el mismo sitio en todas las Pi, y esta página no dibuja un logo para señalarlo. Lo señalan el serigrafiado y el hecho de que es plano, pequeño y no es un USB. Si dudas entre dos conectores planos, no pruebes la cinta en el que no sea el de la cámara: hay placas con otro conector de cinta para la pantalla. Meter la cámara en el de la pantalla, o al revés, no enseña nada y puede no hacer contacto. Si no estás seguro, para y mira el dibujo de tu modelo en Hardware antes de forzar. No uses el header como tercer intento.

Aviso. Cinta en su conector, con la Pi apagada. USB en un puerto USB. Comandos: rpicam-still y rpicam-vid. raspistill está viejo. Si la orden no existe, primero la cámara activa y el conector, no un paquete al azar. GPIO a 3,3 V. Físicos 27 y 28 sin cable. Sin 230 V.

El cuaderno de hoy puede ser muy corto: «cinta» o «USB», el comando que sí existe, y la frase de que raspistill no se usa. Si escribiste un apt y no lo lanzaste, bórralo de la nota. Una nota que guarda el nombre del paquete inventado es la trampa de la semana que viene.

Ejercicio en la Pi

Apaga bien. Si tienes cámara de cinta, siéntala en su conector y cierra el pestillo. Si tienes USB, enchúfala en un puerto USB, no en el header. Enciende. En la terminal escribe rpicam-still --help. Si el help aparece, anota en el cuaderno que el comando existe y no lances aún la foto: eso es la 34. Si la consola dice que no existe, no instales nada con un nombre inventado. Revisa el conector y anota «comando ausente, cámara por comprobar». apt-cache search rpicam solo si ya diste ese paso, y no instales a partir de una lista que no hayas leído. No uses raspistill para comparar.

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

Una foto se hace con rpicam-still -o foto.jpg. Un vídeo corto, con rpicam-vid -t 5000 -o video.mp4. -o es el archivo de salida. -t es el tiempo en milisegundos: 5000 son cinco segundos, no cinco mil. El archivo se queda en la Pi. No se sube a ningún sitio.

La foto, a un archivo

Sitúate en tu home. pwd tiene que enseñar /home/ y tu usuario, el de la lección 10, no /root y no una carpeta de sistema. Desde ahí:

rpicam-still -o foto.jpg

rpicam-still es el comando vivo de la lección 33. -o viene de output, la salida. Lo que va detrás es el nombre del archivo que se va a crear. foto.jpg es un nombre del curso, corto, en esta carpeta. Puedes elegir otro nombre, pero entonces eres tú quien tiene que encontrarlo. No pongas el archivo en /etc ni en una ruta que no sea tuya. No hace falta sudo. Una foto no es una operación de root, y un archivo creado como root luego no lo borras con tu usuario sin lío.

Cuando la orden termina, el archivo está en la Pi. ls -l foto.jpg enseña el tamaño. Si el tamaño es cero, la orden no llegó a escribir: no lo subas «a ver si en otro sitio se ve». Si el tamaño es de un archivo de verdad, ya está. Ábrelo en el propio escritorio, si lo tienes delante, o déjalo. Esta lección no enseña a copiarlo al portátil. Copiarlo dentro de casa, a otro equipo tuyo, puede esperar. Sacarlo a internet no entra.

Si la consola se queja de que -o no existe, paras. Abres rpicam-still --help y buscas cómo se llama la salida en tu versión. La ficha está en Software, cámara, y dice lo mismo: si el help no la lista, no la fuerces. No vuelvas a raspistill porque aquel sí aceptara -o en un tutorial viejo. El nombre viejo sigue viejo.

Cinco segundos, no cinco mil

El vídeo corto es este:

rpicam-vid -t 5000 -o video.mp4

Se lee por partes. rpicam-vid es el comando del vídeo. -t es el tiempo que dura la toma. El número va en milisegundos. Un segundo son mil milisegundos. 5000 milisegundos son cinco segundos. -o otra vez es el archivo, y se llama video.mp4. El orden de las opciones puede variar. Lo que no varía es el significado: tiempo por un lado, nombre por el otro. No confundas el 5000 con el nombre del archivo ni el nombre con la duración.

El error de leer 5000 como segundos deja la cámara grabando más de una hora. No es un vídeo corto y no es lo que pediste. Si te pasa, Control y C corta el proceso. Luego miras si quedó un archivo a medias y no lo tratas como el ejercicio bien hecho. Vuelves a lanzar la orden leyendo -t en milisegundos. Cinco segundos caben en una respiración. Si la orden vuelve enseguida, demasiado pronto para haber grabado nada, mira si el número se coló en otro sitio o si el help de tu versión usa otra unidad. El help manda. Esta página afirma milisegundos porque es lo que el comando viene usando, y porque 5000 con esa unidad es el corto que queremos.

Durante esos cinco segundos la cámara mira lo que tenga delante. Ponle una pared, una planta, el techo. No hace falta una escena. Hace falta un archivo. ls -l video.mp4 al terminar. El tamaño no será cero si grabó. El archivo sigue en la misma carpeta que la foto. Dos nombres distintos: si repites la orden, pisas el archivo anterior del mismo nombre. Si quieres conservar los dos intentos, cambia el nombre en -o. No hace falta una carpeta nueva en /var.

Qué no hace esta orden

No abre una cuenta. No pide una contraseña de una web. No imprime una dirección para que alguien de fuera entre a ver. Si un ejemplo añade al final una subida, un token o un «compartir enlace», eso no es esta lección: es lo contrario de la siguiente. Tú te quedas en el archivo local. pwd y ls son la prueba. Una miniatura en el escritorio de la propia Pi también es prueba. Un icono de «subido» no lo es, porque no tenías que subir nada.

Tampoco enciende un servidor para ver la cámara en el móvil. Aunque el móvil esté en la misma mesa, esta lección no monta esa puerta. Ver el archivo en la Pi basta. La lección 35 explica por qué la imagen no sale de casa, y ni siquiera allí se monta un servidor. Hoy, si te sobra tiempo, repites la foto con otro nombre y compruebas que -o cambió el archivo y no el comando. Esa es la práctica real del flag.

El sonido del vídeo, si el archivo lo trajera, no se configura aquí. No hay lección de audio en este curso. No añadas un micro «ya que grabo» ni busques el flag del sonido en un blog. Cinco segundos de imagen muda, si tu comando no mete audio por su cuenta, cumplen. Si el help enseña una opción de audio, la dejas en paz. Meterla sin entenderla es la opción de más que tumba la orden.

GPIO no interviene. No dispares la foto puenteando un pin. El pulsador de la lección 26 puede seguir montado y no forma parte de rpicam-still. Juntar el botón y la cámara es un proyecto, y el proyecto es más adelante. Hoy el disparo es la orden en la terminal, con tu usuario, en tu carpeta.

Dónde mirar el archivo sin sacarlo

El archivo vive donde estabas cuando lanzaste la orden. Si no hiciste cd, es tu home. pwd lo confirma. ls -l foto.jpg video.mp4 enseña las dos líneas, con un tamaño y una hora. La hora es la de la Pi. Si la hora está mal, el archivo sigue siendo tuyo: no es un motivo para mandarlo a un reloj de internet. Se mira en la propia máquina. En el escritorio, el gestor de archivos abre la misma carpeta. Si ves la foto ahí, la lección está hecha. Si el gestor está en otra carpeta, no des por perdido el archivo: vuelve a pwd.

Un archivo que no aparece suele ser un nombre distinto del que buscas. La orden escribió lo que pusiste detrás de -o, no lo que recuerdas. Si escribiste Foto.JPG con mayúsculas, ls foto.jpg no lo encuentra: en este sistema las mayúsculas importan, como en la lección 10 con el nombre de usuario. Mira ls sin filtro. No relances la cámara diez veces. La primera foto, si pesa, ya vale.

Pisar el archivo es fácil y no es grave en este ejercicio. La segunda rpicam-still -o foto.jpg sustituye la primera. Si querías las dos, el segundo -o tiene que ser otro nombre, foto-2.jpg por ejemplo. No hace falta un programa que numere. Dos nombres claros bastan. El vídeo igual: video.mp4 se sustituye si repites la misma orden. Cinco segundos perdidos se vuelven a grabar. No son un documento único.

La previsualización, si la ventana sale en el monitor de la Pi, es local. Se ve donde está enchufada la pantalla. No es una emisión. Cuando la orden acaba, la ventana se cierra y queda el archivo. No busques la ventana en el móvil. Si no hay monitor y entras más adelante por la terminal de otro equipo de casa, el archivo sigue estando: ls -l no necesita escritorio. Abrir la imagen sin escritorio puede esperar. Crearla no. Y esa otra entrada, si la usas, es SSH, la lección 36, no una web de la cámara.

Errores que parecen de la cámara y no lo son

Permiso denegado al escribir suele ser la carpeta, no el objetivo. Estás en un sitio que no es tuyo, o el archivo que ya existe es de root porque la vez anterior usaste sudo. No repitas el sudo. Vuelve a tu home con cd, comprueba con pwd, y lanza la orden otra vez con otro nombre. El archivo de root, si quedó, no lo borres a lo bestia. Anótalo. La lección 11 ya dijo para qué no sirve sudo. Una foto no está en la lista.

La cámara ocupada quiere decir que otro proceso la tiene. A veces es una ventana que no cerraste, o un intento anterior que no murió. Cierras ese proceso. No instalas un segundo paquete de cámara para «esquivar» el bloqueo: seguiría siendo el mismo ojo, ahora con dos programas peleándose. Un reinicio limpio, sudo reboot, solo si no encuentras el proceso y ya anotaste lo que ibas a grabar. No es el primer gesto. El primer gesto es mirar qué terminal sigue en la orden.

«No such file» en medio de la orden, referido a la cámara y no a tu jpg, devuelve a la lección 33: el ojo no está o el comando no es el de esta imagen. No lo conviertas en un problema de -t. El tiempo ni siquiera llega a contar si la cámara no abre. Separar las frases del error es la lección 20: la última línea dice el tipo, y el nombre del comando dice si sigues en rpicam-still o si se te coló el viejo.

Cuando las dos órdenes hayan funcionado, para. No encadenes un tercer comando copiado de un ejemplo que reduzca, recorte y publique. Recortar puede ser útil otro día y no es el mecanismo de hoy. El mecanismo es reconocer -o y -t, ver el archivo, y dejarlo quieto. En el cuaderno, una línea: foto, vídeo, carpeta que dijo pwd, y «no salió de la Pi».

Leer la orden en voz alta

Antes de pulsar Enter, lee la línea como una frase. «Con rpicam-vid, durante 5000 milisegundos, escribe video.mp4.» Si la frase que te sale es «durante 5000 segundos» o «súbelo», no pulses. Corriges la frase y luego el comando. Este hábito evita el vídeo de una hora y la subida que no pediste. El mismo hábito sirve para la foto: «escribe foto.jpg aquí». Si detrás de -o no hay nombre, la orden está a medias. Si el nombre lleva un espacio, ponlo entre comillas o, más simple, quita el espacio. foto casa.jpg son dos palabras para la consola, no un nombre. foto-casa.jpg es un nombre.

No hace falta un editor para estas dos líneas. Se escriben en el prompt, se lanzan, se comprueban con ls. Si quieres guardarlas en un archivo para no recordarlas, un archivo de texto en tu home basta, y se lanza con bash o copiando la línea. No lo conviertas en un servicio que arranca solo. Arrancar solo es otra lección, y una cámara que graba al encender, sin que estés delante, se come justo el límite de la lección 35: la casa filmada cuando no miras. Hoy estás delante. Cinco segundos. Paras.

Aviso. -o es el archivo. -t 5000 son 5000 milisegundos, cinco segundos. El jpg y el mp4 se quedan en la Pi. No se sube nada. Si -o no sale en tu help, manda el help. GPIO a 3,3 V. Sin 230 V.

Ejercicio en la Pi

En tu home, con la cámara de la lección 33 ya reconocida, lanza rpicam-still -o foto.jpg. Cuando vuelva el prompt, ls -l foto.jpg. Luego rpicam-vid -t 5000 -o video.mp4 y otra vez ls -l. En el cuaderno escribe qué flag es el nombre y qué flag es el tiempo, y que 5000 son milisegundos. No copies los archivos a ningún servicio. Si el comando rechaza -o, paras, miras --help y anotas el nombre real de la opción en tu versión, sin instalar nada. Si no hay cámara, escribe la orden completa en el cuaderno y marca qué trozo es -o y qué trozo es -t. Eso también es reconocerla.

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

La cámara mira tu casa: caras, ventanas, la mesa. No se abre al router, no se publica en internet y no hace falta ninguna cuenta ni ninguna nube. Esta lección no es de audio: el audio no tiene lección en este curso. Si alguien va a ver la imagen, es otro equipo de la misma red, y eso es un límite, no una invitación a montar un servidor.

No es una lección de audio

El título de la zona en el índice dice cámara y sonido. El sonido se queda fuera. No hay lección que enseñe a grabar voz, a elegir la salida HDMI o a lanzar un wav. Eso, si lo necesitas, está en la ficha de Software y no se copia aquí para rellenar. Quien llegue buscando el micro se equivocó de número. El número 35 es la puerta de la casa.

Tampoco se disfraza el audio de cámara. Un vídeo de cinco segundos no obliga a configurar el sonido. Un tutorial que pase de rpicam-vid a un altavoz y de ahí a una cuenta ha cambiado de tema dos veces. Ciérralo en la primera. La orden de la lección 34 ya terminó cuando el archivo existe en la Pi.

Lo que la cámara está viendo

Una cámara en la mesa no mira «un experimento». Mira lo que tenga el objetivo delante. Si delante está la habitación, mira la habitación: quién entra, qué hay en la estantería, la ventana del patio. foto.jpg es ese rectángulo, guardado. No se vuelve anónimo porque el comando sea corto. Por eso el encuadre del ejercicio era una pared o una planta, no la calle a través del cristal y no la cara de alguien que no se ha sentado a probar contigo.

Dejarla grabando sola, apuntando a la puerta de casa, no es el siguiente paso natural. Es otro uso, con otra responsabilidad, y este curso no lo monta. Cinco segundos delante de ti se acaban. Un proceso que siga vivo después de levantarte no es el -t 5000. Si al volver la cámara sigue ocupada, cierras ese proceso. No lo conviertes en vigilante porque «ya que está enchufada».

El archivo en disco es tan casa como la ventana. Quien copie la tarjeta se lleva las fotos. Por eso el archivo no se deja en una carpeta compartida que no recuerdes haber abierto, y no se manda a un servicio que lo guarde «por si se borra». La copia de la tarjeta, cuando el curso la trate, es otra lección y sigue siendo tu copia, no una cuenta. Hoy ni eso: el archivo se queda donde pwd dijo.

Lo que no se abre

El router de casa tiene una puerta hacia la calle y una red hacia dentro. Abrir un puerto hacia la calle para que la cámara se vea desde el trabajo, desde el móvil con datos o desde un enlace que le mandas a alguien, saca la imagen del recinto. No se hace en esta lección. No se hace «un momento para probar». Un puerto abierto se olvida, y lo que olvidaste es una ventana a la habitación. El curso no da los pasos. Decir que no se dan es el contenido.

Publicarla en internet es el mismo cruce con otro disfraz: una web, un álbum, una retransmisión, una cuenta que «solo guarda el vídeo». Hace falta una cuenta, una contraseña que no es la de la Pi, y un sitio que ya no es tu disco. No se crea esa cuenta para la práctica. No se pega el jpg en un formulario. El navegador de la Pi puede existir y no es el destino de foto.jpg.

Tampoco un nombre de dominio, ni un servicio que atraviese el router por ti, ni un código de emparejamiento con un móvil en otra red. Esos inventos se venden como cómodos precisamente porque evitan hablar del puerto. Siguen sacando la imagen. Si el tutorial empieza así, no es un atajo de la lección 34. Es otra casa, la de ellos.

El límite, sin montar nada

Dentro de la red de casa puede haber otro equipo: el portátil con el que grabaste la tarjeta, un ordenador de la misma mesa. Ese equipo está del mismo lado de la puerta. Ver ahí la imagen, algún día, no es publicarla. Aun así, esta lección no monta el servidor que lo haría. No instala un programa de streaming, no abre un puerto ni siquiera hacia dentro, no deja un proceso escuchando. El límite se nombra para que no lo confundas con el ejercicio. El ejercicio es no cruzar, no construir la mirilla.

SSH, en la lección siguiente, entra a la terminal desde otro equipo de casa. No es una cámara. No convierte video.mp4 en una emisión. Si más adelante copias un archivo a ese otro equipo, sigue siendo casa, y no es el trabajo de hoy. Hoy no hace falta copiarlo para dar la lección por hecha. La prueba es que sabes decir dónde se para la flecha.

Si alguien en casa te pide ver la foto, se sienta en la Pi o miráis juntos el archivo que ya está. No le mandas un enlace. No hay enlace. El cuaderno puede guardar una frase: «la imagen no cruza la puerta; no hay cuenta; no hay servidor». Es el resumen operativo, no un eslogan.

El tutorial amable es el que más confunde

El texto peligroso no grita. Dice que en tres clics ves la cámara desde el teléfono, esté donde esté el teléfono. Esos tres clics suelen ser: crear una cuenta, instalar su programa en la Pi y aceptar que el programa salga a la calle a buscarte. La imagen ya no termina en la puerta. Termina en un servidor que no es tuyo, aunque el dibujo del programa enseñe tu salón. No hay una versión «solo local» escondida que esta lección te pida activar. Si el programa no sabe vivir sin cuenta, no se instala.

Otro texto, más técnico, habla de reenviar un puerto. El número del puerto da igual. Reenviar es decirle al router: lo que llegue de fuera a esta puerta, entrégalo a la Pi. Eso es exactamente cruzar el recinto. No anotes el número «por si acaso». No entres en la administración del router a mirar si ya estaba abierto por otra prueba. Si alguna vez lo abriste y lo recuerdas, ciérralo, y no uses esta lección como guía de cómo se abría. El cierre es el contenido. El procedimiento de apertura no se escribe.

Una tercera variante usa el propio navegador de la Pi para subir foto.jpg a un álbum. Parece menos grave porque no dejas la cámara encendida. Sigue siendo publicar la casa. La foto de la planta, si de verdad es una planta y nada más, no cambia la regla del curso: el ejercicio no incluye la subida. Si en el encuadre salió una ventana a la calle o un papel con un nombre, con más razón se queda en el disco. Borrar el archivo en la Pi, si te arrepientes del encuadre, es rm de un archivo tuyo, con el nombre concreto, no un borrado de la tarjeta. La lección 11 y la 12 ya pusieron el cuidado. Aquí basta no subir y, si sobra, borrar el jpg con su nombre.

El móvil en la wifi de casa es todavía la misma red. Verlo ahí sería el límite que ya se dijo, y seguiría haciendo falta un servidor que no vamos a montar. El móvil con los datos del teléfono, fuera de esa wifi, es la calle aunque estés en el sofá. No se prepara la Pi para ese caso. Quien quiera enseñar la foto se acerca a la pantalla de la Pi. Es más corto que cualquier cuenta.

Qué anotar para no deshacerlo mañana

Mañana un ejemplo de «deja la cámara grabando» va a sonar razonable. El cuaderno de hoy es el freno. Escribe tres noes: no al puerto del router, no a la cuenta, no al proceso que sigue cuando te vas. Y un sí pequeño: el archivo local de la lección 34 puede seguir en el disco. No hace falta destruirlo para cumplir el recinto. Hace falta no ofrecerlo.

Si compartes la Pi con otra persona de casa, esa persona ya está dentro. Puede sentarse y abrir el archivo. No le des una contraseña de una web de cámaras. Si hace falta una clave, es la de la cuenta de la Pi, la que ya existe, y solo si de verdad va a usar la máquina. Inventar un segundo usuario «para la cámara» no es esta lección y no la hace más segura por sí solo. La hace más fácil de olvidar.

El header no graba. Desenchufar un GPIO no apaga el ojo. El ojo se apaga quitando el proceso, o no lanzándolo. La cinta se quita con la Pi apagada si vas a guardar la cámara en un cajón. Guardarla es una forma digna de cerrar el tema: sin cámara no hay imagen que cruzar. No es obligatorio. Es mejor que dejarla mirando el pasillo «hasta la lección que venga».

La red de casa no es un permiso

Estar en la misma wifi no significa que cualquier aparato deba recibir la imagen. El límite del que habla el curso es estrecho: si alguien la ve, será un equipo de esa red, y solo porque tú lo decides en otra lección que aquí no se escribe. Un invitado con la clave de la wifi no queda incluido. No le abras una página en la Pi para que mire el salón mientras toma un café. La clave de la wifi ya es otra conversación, y no se arregla regalando la cámara.

Tampoco hace falta desconectar la Pi de la red para cumplir. La red sirve para otras cosas del curso, y SSH, en la siguiente, usa esa misma red para una terminal. Quitar el cable para sentirte a salvo mezcla dos miedos. El gesto preciso es no publicar la imagen. El cable puede seguir. La cámara, si no está grabando, no está emitiendo solo por estar pinchada. Emite cuando un programa la lee y manda esos bytes a alguna parte. Si ningún programa la lee, no hay flujo que cruzar. Por eso el ejercicio pide mirar que no quedó un proceso, no pide aislar la placa del mundo.

Si más adelante una lección copia un archivo a otro equipo de casa, ese archivo viaja dentro del recinto. No es lo mismo que una retransmisión continua, y no es esta página. No adelantes el copiado «para tener la foto a mano en el portátil». A mano está en la Pi, que es donde la hiciste. El portátil puede esperar. La prisa de tenerla en todos los sitios es la que acaba en una cuenta.

Aviso. No es una lección de audio. La cámara mira la casa. No se abre el router, no se publica, no hay cuenta ni nube. Otro equipo de la misma red es el límite, y no se monta aquí. GPIO a 3,3 V si andas en el header. Sin 230 V.

Ejercicio en la Pi

Mira foto.jpg y video.mp4 con ls -l. No los copies a ningún sitio. En el cuaderno escribe qué encuadraste y quién puede verlo hoy: tú, en esa Pi. Comprueba que no dejaste un proceso de cámara en marcha. No abras la página de administración del router para esta lección. No crees cuentas. Si no llegaste a grabar, el ejercicio es el mismo en papel: dibuja la casa, la Pi dentro, y la flecha parada en la puerta. Anota que el audio no forma parte del número 35.

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

SSH es entrar a la terminal de la Pi desde otro equipo de casa, y por eso puedes ahorrarte el monitor. Se activa al grabar, en el Imager, o después con sudo raspi-config, en Interface Options. Sin eso el puerto no responde. Entras con el usuario que creaste, no con pi/raspberry, y por el nombre de la Pi en la red local. No se abre el puerto en el router ni se reutiliza una clave de un tutorial viejo.

Una terminal, no un monitor

Hasta ahora la terminal era la ventana del escritorio o un teclado enchufado a la Pi. SSH es la misma terminal, vista desde otro equipo de la casa: un portátil, un ordenador de sobremesa, lo que tengas en la misma red. El monitor de la Pi puede estar apagado o ni existir. El trabajo, pwd, ls, la foto que ya estaba en el disco, sigue ocurriendo en la Pi. Tú solo miras la consola desde el otro lado de la mesa.

No es la cámara de la lección 35 y no la publica. No ves el escritorio. No ves foto.jpg como imagen, salvo que más adelante copies el archivo, y copiar no es esta lección. Ves letras. Si esperabas la imagen en el móvil, este no es el camino, y el camino de sacarla a la calle sigue cerrado.

La ficha corta está en Software, SSH. Ahí está la forma de la orden. No está la ficha de la imagen: #arranque es la lección 3 y no se enlaza desde aquí. Grabar la tarjeta ya ocurrió. Hoy no se regraba para poder entrar.

Activarlo, o el puerto calla

SSH puede quedar marcado en el Imager, en el momento de grabar, junto al usuario. Si lo dejaste vacío a propósito porque ibas a usar pantalla, la Pi no escucha. Se enciende después, ya dentro, con pantalla y teclado, o con la sesión que ya tengas:

sudo raspi-config

En Interface Options está SSH. Se activa. El menú es el mismo sitio donde la lección 31 encendió I2C, otra interfaz distinta. No actives las demás «ya que estás». I2C se queda como estaba. SSH es la única que esta lección enciende.

Sin ese paso, el otro equipo puede tener la orden bien escrita y la red bien puesta, y la Pi no responde. El fallo no está en el router. Abrir un puerto en el router no enciende un servicio que la Pi tiene apagado, y además saca esa puerta a la calle. No se hace. Ni para probar, ni cinco minutos, ni con una regla que «cierre luego». Luego se olvida.

Si la Pi sigue en el asistente del primer arranque, todavía no acepta la entrada. Falta terminar usuario e idioma, con pantalla o habiéndolos puesto en el Imager. Software lo avisa. Completa eso y vuelve a probar. No regrabes la tarjeta porque la primera prueba calló durante el asistente.

Quién entra, y por qué nombre

El usuario es el que creaste. whoami en la Pi lo repite. En el otro equipo la orden tiene esta forma:

ssh TUUSUARIO@NOMBRE

TUUSUARIO lo sustituyes por ese nombre, con las mismas mayúsculas. NOMBRE es el nombre de la Pi en la red local, el que le diste, no un nombre sacado de una guía vieja. No es pi. La contraseña es la de esa cuenta, la del Imager o la que cambiaste con passwd. No hay una de fábrica que sirva. raspberry como clave, junto a pi, es el defecto viejo que Trixie no trae. Si en su día los elegiste tú, la cuenta existe porque tú la pediste: cámbiala antes de esta entrada, como ya decía la lección 10, y no la dejes de ejemplo.

La arroba separa quién entra de a qué máquina. Lo que va detrás es el nombre en la red de casa, no una dirección de internet y no el nombre de una web. Si ese nombre no contesta, no abras el router para «hacerlo visible». Buscar la Pi cuando el nombre no basta es la lección 37. Hoy no se improvisa un barrido de la red ni se reenvía el puerto. Si ya conoces el número que el router le dio por dentro, Software admite esa forma, y sigue siendo casa. No es una invitación a mirar la configuración del router.

La primera vez, el otro equipo puede preguntar si confías en la clave del host. Esa clave es la de tu Pi, no una contraseña que teclees tú. Léela como «me estoy conectando a esta máquina por primera vez». Si más adelante la Pi cambia de sistema y la pregunta vuelve con un aviso de clave distinta, paras y compruebas que sigues hablando con tu máquina, no aceptas a ciegas. No copies una clave pública de un tutorial para pegarla en la Pi. La tuya se genera en tus equipos si algún día dejas de usar contraseña. Hoy la contraseña de tu cuenta basta, y no se apunta en un papel pegado al router.

Qué haces al entrar, y qué no

Si la orden acepta la contraseña, el prompt pasa a ser el de la Pi. whoami y hostname lo confirman. hostname es el nombre de esa máquina. Tiene que cuadrar con el que pusiste detrás de la arroba, salvo que hayas entrado por el número interior. pwd sigue siendo tu home. Desde ahí puedes repetir un ls de la foto, si existe. No lances la cámara para estrenar SSH. No hace falta.

Sales con exit. Vuelves al equipo desde el que entraste. La Pi no se apaga por salir. Sigue encendida, y SSH sigue activo: es lo que pediste. Activo no significa expuesto a la calle. Significa que, en tu red, con tu usuario y tu clave, la terminal responde. La clave no se cambia a una de un ejemplo para «que sea fácil de recordar». Fácil de recordar para ti no es la palabra raspberry, que es fácil de recordar para cualquiera que haya leído el mismo ejemplo.

No instales un servidor de escritorio remoto, ni un panel en el navegador, ni un túnel. Cada uno de esos abre más de lo que esta lección abre. SSH ya ahorra el monitor. Con eso basta. Si el comando ssh no existe en el otro equipo, ese equipo no tiene el cliente: se instala el cliente allí, no se abre el router en la Pi para compensar. El nombre del cliente en ese otro sistema lo miras en su propia ayuda. No lo invento aquí mezclando distribuciones.

Cuando la orden falla, qué no tocas

Fallo típico: el otro equipo dice que no llega, o que la conexión se rechaza. Primero preguntas si SSH está activo de verdad. Rechazado suele ser la Pi despierta y el servicio apagado. No llegar suele ser nombre mal escrito, red distinta o la Pi apagada. Ninguno de los dos se cura en el router. Compruebas que el portátil está en la wifi de casa, no en la del móvil. Compruebas el usuario, letra a letra. Compruebas que no estás en el asistente del primer arranque. Luego paras. La lección 37 buscará la máquina si el nombre no basta. Adelantarla con un escáner copiado no enseña SSH: enseña a no fiarte del nombre que pusiste.

Contraseña rechazada es otra frase. La cuenta existe y la clave no coincide. Puede ser el mapa del teclado, el de la lección 7: escribes un símbolo y sale otro. Puede ser que estés tecleando la clave del portátil, no la de la Pi. No la reemplaces por raspberry para descartar. Eso deja la puerta conocida. Prueba de nuevo, despacio. Si hace falta cambiarla, se cambia en la Pi con passwd, delante del monitor, no desde un tutorial que te dicta la nueva.

Un aviso de clave de host cambiada no se acepta en automático. Significa que el otro equipo recuerda una Pi distinta de la que ahora responde a ese nombre. Puede ser inocente, porque regrabaste la tarjeta, o puede no serlo. Paras, miras que el cable y la máquina son los tuyos, y solo entonces decides. Esta página no te da el comando para borrar la clave recordada a ciegas. Si no estás seguro, no entras. Entrar «para ver» es el paso que el aviso intenta frenar.

Dentro ya, no hagas de SSH un cajón de sudo. La lección 11 sigue en pie: sudo es un préstamo, orden por orden. Actualizar el sistema entero, instalar un escritorio remoto o tocar el cortafuegos no son el saludo de entrada. hostname, whoami, exit. Si la sesión se queda abierta en un portátil que se mueve de casa, ciérrala antes de salir a la calle. La sesión abierta en una cafetería es una terminal de tu casa en una red que no es la tuya. exit es parte del ejercicio, no un adorno.

Qué queda encendido

Cuando sales, el servicio sigue. Es el precio de no depender del monitor la próxima vez. El precio no incluye el router. Puedes comprobar, otro día, que desde la calle no entra: no porque hayas hecho una prueba rara, sino porque nunca abriste esa puerta. Si un familiar técnico te ofrece «dejártelo visible por si se cuelga», se agradece y se rechaza. Una Pi colgada se recupera en casa, con pantalla o con la tarjeta, no desde el tren.

Tampoco se deja escrita la contraseña en el comando, ni en un alias, ni en el cuaderno de esta página. El cuaderno del navegador es local, y aun así no es sitio para la clave. Anota el usuario y el nombre de la máquina. La clave se recuerda en la cabeza o en el gestor del equipo, no en un ejemplo. El gestor, si lo usas, es el de ese equipo de casa, no una nota sincronizada con una cuenta fuera.

I2C, la cámara y SSH son tres interruptores distintos. Haber encendido uno no enciende los otros. Haber encendido SSH no autoriza a mirar la cámara desde el portátil como si fuera un vídeo. Sigue siendo una terminal. ls enseña el nombre del archivo. No lo reproduce en el otro equipo por el hecho de entrar. Si eso te sabe a poco, es la medida justa de la lección: entrar, mirar quién eres, salir. El resto del curso sigue en la propia Pi, con o sin ese monitor.

Aviso. SSH solo en la red de casa. Usuario tuyo, no pi/raspberry. Imager o sudo raspi-config, Interface Options. Sin eso no responde. No se abre el puerto en el router. No se enlaza #arranque. GPIO a 3,3 V si tocas el header. Sin 230 V.

Ejercicio en la Pi

Comprueba cómo quedó SSH. Si al grabar no lo marcaste, ábrelo con sudo raspi-config en Interface Options y actívalo. En el otro equipo de casa, entra con ssh, tu usuario real y el nombre de la Pi en la red local. whoami tiene que ser ese usuario. Sal con exit. En el cuaderno escribe la orden con tu usuario, no con pi, y la frase de que el router no se ha tocado. Si el nombre no contesta, no abras el router y no cambies la clave a una de tutorial: anota «nombre no resuelve» y déjalo para la lección 37. Si no tienes otro equipo, escribe la orden igual y marca que SSH está activo o que lo dejaste apagado a propósito.

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

El otro equipo de casa encuentra a la Pi por su nombre, el que termina en .local, y eso no la abre al mundo. Si el nombre no responde, miras la dirección en el router de casa o en la propia Pi, y sabes que esa dirección puede cambiar. No se reenvía ningún puerto. El reloj y config.txt no tienen lección: no son esto.

No es el reloj, no es el archivo de arranque

A veces se llega aquí buscando poner la hora o tocar el archivo de configuración del arranque. Ninguna de las dos tiene número en este curso. No las escondo en un párrafo para que parezca que sí. La hora, si está mal, se nota en la fecha de un archivo, y no se arregla encontrando la Pi en la red. El archivo de arranque no se abre «ya que estamos en la red». La lección 3 lo apartó. Esta página no lo reabre.

Lo que el otro equipo necesita es un nombre que la red de casa sepa resolver. Sin ese nombre, SSH de la lección 36 se queda en una orden con el sitio en blanco. Con el nombre, la orden tiene a quién llamar. El trabajo de hoy es ese sitio, no un servicio nuevo.

El nombre que termina en .local

En la Pi, hostname imprime el nombre de la máquina. Es el que pusiste, no un nombre de fábrica sacado de una guía, y no es el usuario. El usuario entra delante de la arroba. El nombre de la máquina va detrás. Si hostname dice cocina, el otro equipo de casa prueba cocina.local. El .local no se teclea en la Pi. Lo añade el equipo que busca, y solo tiene sentido dentro de la red local. No es un dominio que hayas comprado. No sale en un buscador. No atraviesa el router hacia la calle.

La orden, con el usuario que creaste, queda así. Sustituyes las dos palabras por las tuyas:

ssh TUUSUARIO@NOMBRE.local

NOMBRE es exactamente lo que imprimió hostname, mayúsculas incluidas. TUUSUARIO es el de whoami, no pi. La contraseña es la de esa cuenta. Si el otro equipo pregunta si confías en la máquina la primera vez, es la misma pregunta de la lección 36. No la aceptes si no estás seguro de estar hablando con tu Pi.

Que resuelva .local no enciende SSH. Si el servicio está apagado, el nombre puede existir y el puerto seguir callado. Primero la lección 36, luego el nombre. Al revés parece que «la red no va» cuando lo que falta es el interruptor.

Si el nombre no responde

Primero lo aburrido. ¿El otro equipo está en la wifi de casa, o se ha ido a los datos del teléfono? Los datos del teléfono son la calle aunque estés en el sofá. .local no cruza eso. ¿El nombre está bien copiado, sin un espacio, sin una mayúscula de más? ¿SSH está activo? Si las tres respuestas son sí y aun así no hay respuesta, no reenvíes un puerto para «forzar el nombre». El nombre no se arregla abriendo la puerta de la calle. Se mira la dirección de dentro.

En la propia Pi, con pantalla o con un teclado, hostname -I imprime la dirección o las direcciones que la red le ha dado. No es el nombre. Es un número. Anotas el que corresponda a la red de casa, no una lista entera que no entiendas. En el router de casa, el que ya administras, la lista de aparatos muestra la misma Pi y la dirección que le prestó. Las dos vías tienen que parecerse. Si no se parecen, no elijas la que «queda mejor». Vuelve a mirar.

Esa dirección puede cambiar. El router presta números y mañana puede prestar otro. Un script que deje el número escrito a fuego falla el día del cambio y parece que la Pi murió. Por eso el camino normal sigue siendo el nombre con .local. El número es el recambio de hoy, para entrar una vez y comprobar que la máquina está viva. Cuando entres, hostname te recuerda el nombre bueno. No tatúes el número en el cuaderno como si fuera eterno. Anota que puede cambiar.

Con el número, la forma es la misma orden, cambiando el sitio:

ssh TUUSUARIO@DIRECCION

DIRECCION es ese número de dentro, no una dirección pública y no la del router hacia la calle. Sigues en casa. No has publicado nada. Si ni el nombre ni el número contestan, la Pi puede estar apagada, en otra red, o con SSH aún apagado. No des por hecho un fallo de la placa. No abras el router «para hacerla visible desde fuera»: visible desde fuera es el agujero de la lección 39.

Qué no ganas al encontrarla

Encontrarla te deja donde estabas en la lección 36: una terminal. No te da la cámara en el móvil. No te da una carpeta en el navegador: eso, con sus límites, es la 38. No sincroniza el reloj. No lee config.txt. Si la sesión se abre, haces whoami, hostname y exit. Sales. La Pi sigue en la red de casa, con el mismo nombre, sin un puerto reenviado.

Si tienes dos Pi, cada una tiene su hostname. No las llames igual y esperes que .local adivine. Nombres distintos, o no sabrás a cuál entraste. El cuaderno cabe en tres líneas: el nombre, si .local respondió, y si tuviste que usar el número y que ese número puede cambiar.

Dos máquinas, una casa

El dibujo no tiene flecha hacia fuera porque no hay un tercer sitio. El portátil y la Pi están del mismo lado del router. El router, en esta lección, solo presta direcciones hacia dentro. No le pides que escuche en la calle y te traiga la visita. Si la página de administración del router te ofrece «abrir un puerto» al lado del número de la Pi, no es un atajo para el nombre que falló. Es otra acción, la que la lección 39 va a llamar agujero. La cierras si la habías abierto en una prueba vieja, y no anotas los pasos para volver a abrirla.

Cuando el nombre funciona, no hace falta volver al router cada día. cocina.local sigue siendo cocina.local aunque el número de detrás cambie. Por eso se prueba el nombre otra vez al día siguiente, no se copia el número a un papel pegado en el monitor. El papel miente en cuanto el router presta otro. El nombre, si no lo cambias tú con una herramienta de sistema, se queda.

Cambiar el nombre a mitad del curso es legal y es lioso. Los equipos que ya confiaron en la clave del host pueden quejarse, como en la lección 36. No lo cambies hoy para que el ejemplo quede bonito. Usa el que ya imprime hostname. Si está vacío o es un resto de un tutorial, lo anotas y lo dejas para cuando sepas por qué quieres otro. No lo sustituyas por raspberrypi solo porque una guía lo use: puede que no sea el tuyo, y llamar a un nombre que no existe parece el mismo fallo que un cable suelto.

GPIO no interviene. Encontrar la máquina no pasa por el físico 11 ni por el 3. Si mientras tanto el LED o el sensor siguen cableados, se quedan como estaban, a 3,3 V, sin usar esta lección de excusa para moverlos. Los físicos 27 y 28 siguen libres. La red y el header son capas distintas: que SSH responda no significa que un pin esté bien puesto, y un pin bien puesto no hace resolver .local.

Leer la respuesta sin inventar un fallo

Si el otro equipo dice que no conoce el nombre, el fallo está en la resolución de dentro, no en la Pi apagada del todo. Prueba el número una vez. Si el número entra y el nombre no, la máquina está viva y el .local es lo que falta por entender en ese equipo. No reinstales la Pi. No cambies la imagen. Anota «el número entra, el nombre no» y sigue usando el nombre en cuanto vuelva, porque el número caduca. Si ni el número entra, vuelve a la lección 36: servicio apagado, wifi distinta, o la Pi en el asistente del primer arranque. Tres causas distintas, ninguna se cura con un reenvío.

Si entras y hostname no coincide con el nombre que marcaste, estás en otra máquina de la casa. Sal con exit antes de tocar nada. Dos placas con nombres parecidos se confunden fácil, y un sudo en la que no era deja un estropicio mudo. El cuaderno con el nombre exacto evita esa prisa.

No hace falta un programa que «escanee la casa». Esos programas listan más de lo que necesitas y enseñan el gesto de mirar redes ajenas. Aquí la red es la tuya, el aparato es uno, y o sabes su nombre o le preguntas la dirección a él o a tu router. Con eso basta. Si el router no te muestra la lista porque no recuerdas cómo se entra en su administración, no es esta lección la que va a dictarte la clave del router. Se mira en la propia Pi, que ya tienes delante, con hostname -I. El router es la otra vía, no la obligatoria.

Al terminar, la calle sigue fuera del dibujo. No has creado una cuenta, no has publicado la cámara y no has dejado un número fijo para que alguien de fuera llame. Has anotado un nombre. Mañana el salón vuelve a usarlo. Eso es encontrar la Pi.

Aviso. El nombre es hostname más .local, solo en la red de casa. Si no responde, la dirección se mira en la Pi o en el router de casa, y puede cambiar. No se reenvía ningún puerto. No es el reloj ni config.txt. Usuario tuyo, no pi/raspberry. GPIO a 3,3 V si andas en el header. Sin 230 V.

Un último matiz del número: hostname -I a veces imprime más de uno, porque la Pi puede tener cable y wifi a la vez, o una dirección que no es la del salón. No hace falta entenderlas todas hoy. Prueba la que el router también muestra al lado del nombre de la Pi. Si ninguna de las dos listas coincide, no inventes una tercera. Quédate con el nombre y deja el número en blanco en el cuaderno, con la frase «no lo vi claro». Un número inventado es peor que ninguno: SSH fallará y creerás que la placa no está.

Ejercicio en la Pi

En la Pi, anota lo que digan hostname y hostname -I. En el otro equipo de casa, prueba ssh con tu usuario y ese nombre seguido de .local. Si entras, whoami y exit. Si no entra, comprueba que sigues en la wifi de casa y que SSH está activo. Solo entonces usa la dirección de dentro, una vez, y escribe en el cuaderno que puede cambiar. No abras el router para reenviar nada. No toques la hora ni el archivo de arranque. Si no tienes otro equipo, el cuaderno con el nombre, el .local y la frase de que el número caduca es el ejercicio.

Si hoy no hay segundo equipo, no pidas prestado el del vecino para probar el nombre: su red no es la tuya, y el .local de su casa no tiene por qué ver la Pi. El cuaderno basta.

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

Una carpeta de la Pi se puede mirar desde el navegador de la propia red, con el servidor mínimo que ya trae Python, sin analytics y sin CDN. La orden y el bind están en Software. Se apaga cuando no hace falta. No es un disco abierto a internet: verla desde el salón no es lo mismo que verla cualquiera.

Qué carpeta, y qué no

La carpeta es tuya. Está en tu home, o en un sitio que pwd te enseña y que reconoces. No es /etc, no es la partición de arranque y no es una carpeta de otro usuario. Metes dentro solo lo que aceptarías dejar sobre la mesa del salón: la foto de la planta, un texto, el csv de medidas si de verdad quieres verlo. No metas claves, no metas la copia de una contraseña, no metas foto.jpg si el encuadre salió con una cara o un papel con un nombre. El servidor no distingue un archivo íntimo de un archivo banal. Sirve lo que haya en la carpeta.

Entras en esa carpeta con cd. Desde ahí se lanza la orden. La orden no se copia de un blog. Está escrita en Software, servidor local. Lleva el puerto 8080 y el bind a 127.0.0.1. El bind es el límite: solo esta máquina acepta la visita. El navegador que abre la carpeta es el de la propia Pi. Si no hay escritorio a mano, esta forma segura no se «arregla» quitando el bind para mirarla desde el portátil. Se espera a tener un navegador en la Pi, o se acepta que hoy no se comparte.

No instales otro servidor con más botones. No añadas un contador de visitas, ni un script de una red externa, ni una tipografía bajada de fuera. Analytics y CDN son precisamente lo que este mínimo no trae. Traerlos convierte una carpeta en una página que habla con otros sitios. Esta lección no habla con otros sitios.

Encender y apagar

Mientras la orden está en marcha, la terminal no vuelve al prompt. Está ocupada sirviendo. Eso es bueno: ves que sigue vivo. Parar es Control y C en esa misma terminal. Al parar, el navegador deja de ver la carpeta. Los archivos siguen en el disco. Servir no los borra y parar no los borra. Si cierras la tapa del portátil y la orden sigue en la Pi, sigue sirviendo. Por eso el hábito es apagarlo cuando ya miraste, no dejarlo «por si acaso esta noche».

No hace falta sudo. Un servidor con root sirve peor un error: el error alcanza más sitio. Tu usuario basta, y solo llega a lo que tu usuario puede leer. Si un archivo no aparece, es un permiso o un nombre, no una razón para relanzar como root.

La ficha de Software lo dice en corto: sin usuario y sin contraseña. Con el bind, el que no tiene contraseña eres tú, en esa máquina, que es aceptable un rato. Sin el bind, el que no tiene contraseña es cualquiera que esté en la wifi. Un invitado, un móvil que se conectó una vez, el portátil del salón. El salón es cómodo y es ancho. No es un candado.

El salón no es cualquiera

Ver la carpeta desde el sofá, en otro equipo de la misma wifi, es la red de casa. Es el límite que las lecciones 36 y 37 ya usaron para la terminal. No es internet. No has abierto el router. Nadie en la calle escribe tu nombre y cae en la carpeta. Ese es el lado «lo veo desde el salón».

«Lo ve cualquiera» es otro lado. Es quitar el bind y además reenviar el puerto, o dejar el servicio escuchando de modo que desde fuera de casa se abra. También es, en la práctica de esta casa, olvidar que sin bind y sin contraseña la wifi entera lee. El invitado no es «la calle», pero tampoco eres tú. El curso no te manda a quitar el bind. Software dice que no lo dejes así. Si alguna vez lo quitas para una mirada de un minuto desde el portátil, el minuto acaba en Control y C. No se convierte en la forma normal.

Un CDN o una cuenta que «proteja» la carpeta la sacan de casa para luego devolverte un enlace. Eso es publicar, aunque el texto diga que el enlace es privado. No se hace. La carpeta o se ve aquí o no se ve. No hay una tercera copia en un servicio para «que no se pierda».

Qué archivos aguantan esa mirada

Un texto tuyo de notas, sí. El csv de la lección 21, si solo tiene fechas y números de temperatura, se puede mirar un momento y se apaga. Una foto de la lección 34, solo si el encuadre es el que ya decidiste que era mostrable en el salón. La cámara en directo no es una carpeta: no pongas el ojo a servir. SSH no se sustituye por este navegador. Son herramientas distintas. La terminal sigue siendo la 36. Esto es una lista de archivos, un rato.

Si la orden dice que el puerto está ocupado, no lances otra en paralelo «a ver». Ya hay una sirviendo. La encuentras y la paras, o usas esa. Dos a la vez confunden y no enseñan. Si dice que no encuentra el módulo, estás en un Python que no es el del sistema: deactivate si había un venv, y el python3 de siempre. No instales un paquete con un nombre parecido. La biblioteca estándar ya está.

Antes de pulsar Enter

Lee la orden en voz alta: carpeta concreta, bind a esta máquina, puerto 8080, y un rato. Si la frase que te sale es «que se vea desde el trabajo», no pulses. Esa frase es un reenvío, y el reenvío no está en la orden de Software. Si la frase es «quítalo del bind para que el salón entre», recuerda que no hay contraseña y que el minuto tiene que acabar en Control y C. Si la carpeta que va a servir no es la que crees, pwd y ls antes. Servir la carpeta equivocada es el error más fácil, y el bind no lo corrige: solo limita quién llega a ese error.

El navegador enseña una lista de nombres. Pulsar un nombre descarga o muestra ese archivo en la propia Pi. No es un escritorio remoto y no es SSH. No edites archivos desde esa lista como si fuera el editor de la lección 18. Si hay que cambiar el texto, se cambia en la Pi, se guarda, y se vuelve a mirar. El servidor lee el disco. No es un sitio donde el archivo «vive en la red» separado del disco.

Cuando pares, comprueba que la terminal ha vuelto al prompt. Un Control y C a medias, o en la ventana que no era, deja el puerto ocupado y la próxima vez la orden se queja. La queja no se resuelve con sudo ni con otro puerto inventado. Se encuentra el proceso que aún sirve y se cierra. Si no lo encuentras, un solo sudo reboot, el limpio, y no vuelves a lanzar el servidor al arrancar. Arrancar solo es otra lección, y un servidor de carpeta que nazca solo es justo lo que hoy quieres evitar: una puerta encendida cuando no estás mirando.

En el cuaderno, cuatro palabras bastan si son ciertas: carpeta, bind puesto, visto en la Pi, apagado. Si falta el «apagado», no has terminado. Vuelve a la terminal antes de dar la lección por hecha.

Lo que el salón puede y lo que no

Aunque un día quites el bind un minuto, el salón no gana derecho a la terminal. Ver una lista de archivos no es ssh. No te pide la contraseña de la Pi porque el servidor mínimo no sabe pedirla. Esa comodidad es el defecto. Quien llega, lee. No ejecuta tus programas por el hecho de abrir la lista, y no por eso es inofensivo: leer el csv y la foto ya es ver la casa. Por eso la carpeta se prepara vacía de secretos antes de lanzar, no después de acordarte.

Tampoco gana derecho a quedarse. El minuto del salón se mide. Si te levantas a por agua y vuelves a los diez minutos con la orden aún en marcha, paras. Diez minutos no son «dejarlo». Dejarlo es irte de casa con el proceso vivo. El dibujo de la puerta cerrada se cumple de dos maneras a la vez: no reenvías, y no dejas el proceso como si el bind fuera opcional para siempre.

Si el navegador de la Pi no abre, no culpes a la carpeta. Puede ser que la orden no esté en marcha, que el bind no sea el de Software, o que estés mirando otro equipo. Vuelve a leer la ficha. No añadas una segunda herramienta «que seguro funciona en cualquier red». Esa segunda herramienta suele ser la que habla con fuera. El curso tiene una, la estándar, y se apaga.

GPIO sigue al margen. No hay un pin que encienda este servidor, y no hace falta. El LED de la lección 25 no anuncia «la carpeta está servida». Si quieres un aviso de que algo pasa en casa, es la lección 40, con la temperatura y el umbral, no con esta lista de archivos. Mezclarlos hoy solo añade un proceso más que luego olvidarás apagar.

El puerto 8080 no es una contraseña ni un secreto. Es el número que la ficha usa para no chocar con otros servicios. Cambiarlo a otro número no esconde la carpeta: quien esté en la máquina y vea la orden, ve el número. Esconder el número y quitar el bind es la peor combinación, porque parece prudencia y es una puerta sin letrero. Deja el 8080 de Software, deja el bind, y apaga. Si alguna guía te dice que el número «bueno» es el de la web pública, esa guía está hablando de la calle. No la sigas. Esta carpeta no aspira a ese número ni a ese público.

Al día siguiente la carpeta sigue en el disco y el servidor no. Compruébalo: no hay una terminal ocupada, el navegador ya no lista los archivos. Si lista, no apagaste. Control y C, otra vez, y solo entonces cierras el tema. El cuaderno no se escribe desde esa lista. El cuaderno de la lección está en esta página, en tu navegador, y tampoco sale de aquí.

Aviso. Servidor mínimo, el de Software, con bind a 127.0.0.1 y puerto 8080. Sin analytics y sin CDN. Sin contraseña: no quites el bind y lo dejes. Control y C al acabar. El salón no es la calle. No se reenvía el puerto. GPIO a 3,3 V. Sin 230 V.

Si la lista del navegador sale vacía, la carpeta está vacía o no es la que serviste. No es un fallo de la red de casa. ls en esa misma carpeta tiene que enseñar el archivo de texto antes de culpar al bind.

Ejercicio en la Pi

Crea una carpeta en tu home con un solo archivo de texto inocuo. No metas fotos de caras ni claves. Lee la orden en Software y lánzala con el bind a 127.0.0.1. Ábrela en el navegador de la propia Pi. Para con Control y C. En el cuaderno escribe si la viste solo en la Pi o también desde el salón, y que al terminar estaba apagada. Si no tienes navegador en la Pi, no quites el bind para compensar: anota la orden que usarías y la frase de que el salón no es cualquiera. No reenvíes el puerto. No instales nada.

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

Hay cuatro agujeros que este curso no abre: un puerto en el router, la clave pi/raspberry de los tutoriales viejos, un reenvío para entrar desde la calle, y una cámara o un CSV que salen de casa. Cada uno se sustituye por la red local de las lecciones 36 a 38. No hace falta miedo teatral: el arreglo es aburrido y basta.

Un puerto abierto en el router

El router separa la calle de la casa. Un puerto abierto le dice: lo que llegue de fuera a esta puerta, entrégalo a la Pi. Quien recorra direcciones en la calle puede llamar a esa puerta. No hace falta que te conozca. El agujero es ese: dejas un servicio a la escucha del mundo, a menudo sin haber pensado qué servicio era. SSH, el servidor de una carpeta, o una cámara, dan igual en el mecanismo. El mecanismo es la puerta.

En su lugar, las lecciones 36 a 38. La terminal se usa desde un equipo que ya está en casa. El nombre .local no necesita reenvío. La carpeta, si se sirve, va con el bind y se apaga. Si en una prueba vieja abriste un puerto, lo cierras en el router que ya administras. Esta página no escribe cómo se abre. Escribirlo sería publicar el procedimiento del agujero. Cerrar es la práctica.

La clave de los tutoriales viejos

pi con contraseña raspberry fue un defecto de fábrica de imágenes antiguas. Esta, Trixie, no la crea. Quien la enseña como si aún viniera puesta está atrasado. El agujero es doble. Si la cuenta no existe, un ataque que la pruebe no entra, pero tú puedes creer que «así se entra» y crearla para que el tutorial funcione. En ese momento el agujero es tuyo: un nombre y una clave que están en miles de páginas. No hace falta suerte para probarlas. Están escritas.

En su lugar, el usuario que creaste en el Imager, el de whoami. Si alguna vez elegiste precisamente ese par, cámbialo antes de dejar SSH activo. passwd cambia la tuya: pide la actual y la nueva dos veces. No pongas otra clave sacada del mismo tutorial, solo que con un número al final. Y no anotes la nueva en el cuaderno de esta página. El cuaderno guarda el hecho de haberla cambiado, no el secreto.

Entrar desde la calle

El reenvío «para entrar desde la calle» es el primer agujero con una excusa. La excusa es cómoda: la Pi se quedó en casa y tú estás fuera, y quieres la terminal. El curso no da ese paso. Estar fuera es estar fuera de las lecciones 36 a 38. Esas lecciones son la casa. El nombre .local no te sigue al tren. La dirección de dentro tampoco, y además cambia. Forzarlas con un reenvío no las hace más tuyas. Las hace llamables por otros.

En su lugar, el trabajo de la Pi se hace en casa, con pantalla o con el otro equipo de la misma red. Si hoy no estás en casa, no entras. No es una avería. Es el recinto. Mañana, en el salón, ssh con tu usuario y el nombre. Nada nuevo que instalar para «llegar desde cualquier sitio».

La cámara o el CSV que se van

Una foto, un vídeo o un archivo de medidas no es un ataque. Es tu casa en un archivo. Sacarlo a una cuenta, a un álbum o a un mensaje hacia internet es publicarlo. El agujero no es que el número 27 sea secreto. Es que el archivo sale de un disco que controlas a un sitio que ya no es la lección 35 ni la 21. El CSV de la lección 21 vive en tu home. La foto de la 34, también. El aviso de la lección 40 será un LED o una línea más en ese archivo, no un envío.

En su lugar, se quedan. Si quieres ver el CSV en el salón, es la carpeta de la 38, un rato, con bind, y se apaga. Si quieres ver la terminal, es la 36, en casa. No hay un quinto canal «solo para avisar». Avisar en casa alcanza.

Sin teatro

Nada de esto exige imaginar un asalto. El puerto abierto se prueba solo, porque hay gente y programas que llaman a puertas. La clave publicada se prueba sola, porque está publicada. El archivo que subes deja de estar solo en tu disco en el momento de subirlo. Son hechos pequeños. El arreglo es igual de pequeño: no abrir, no usar esa clave, no reenviar, no subir. Quien te ofrezca un túnel, una cuenta o un «así lo veo desde el trabajo» te está ofreciendo el agujero con mejor vocabulario. Se agradece y se deja.

Tampoco hace falta desconectar la Pi de la wifi para estar a salvo. La wifi de casa es el sitio donde SSH y el nombre funcionan. Quitarla mezcla el miedo con el trabajo. El gesto preciso es no cruzar la puerta. El cable puede seguir. Los pines, si los tocas, siguen a 3,3 V. Esta lección no pide un montaje nuevo.

El orden de los cuatro

Conviene mirarlos en el mismo orden siempre, para no discutir el cuarto mientras el primero sigue abierto. Primero el router: ¿hay algún reenvío hacia la Pi? Si no lo sabes, no inventes que no lo hay. Entras en la administración que ya usas y miras. Si hay uno, se quita. Si no hay, se anota «no hay» y no se crea «para comprobar que la página lo permite». Segundo, el usuario: whoami no es pi, o si lo es porque así lo pediste, la clave ya no es la publicada. Tercero, la intención de entrar desde fuera: no hay un programa residente para eso, no hay una cuenta puente. Cuarto, los archivos: la foto y el CSV siguen en el disco de la Pi. ls los ve. Ningún navegador de fuera los tiene.

Ese orden cabe en el cuaderno como cuatro sí o no. Un no en el primero es un puerto aún abierto: se cierra antes de celebrar los otros tres. Un sí fingido es peor que un blanco. Si no miraste el router, escribe «no mirado», no «cerrado». La lección no premia la memoria. Premia no publicar.

Las lecciones 36, 37 y 38 no se deshacen por este cuidado. SSH puede seguir activo en la red de casa. El nombre .local puede seguir resolviendo. La carpeta puede haberse mirado y tiene que estar apagada. Apagada es parte de no publicar. Un servidor mínimo dejado toda la noche, aunque tenga el bind, es una puerta encendida en una casa vacía. Con bind el riesgo es menor y sigue siendo un proceso que no estás mirando. Control y C forma parte del cierre de la 39 tanto como del de la 38.

Qué dirás cuando te ofrezcan un atajo

El atajo suele venir de alguien que te quiere ayudar. «Te lo dejo visible por si se cuelga.» «Te creo un acceso para no ir a casa.» «Sube el CSV y lo vemos juntos.» Las tres frases son los agujeros con voz amable. La respuesta no necesita un discurso. Puede ser: en casa entro con mi usuario y el nombre; la clave no es la del tutorial; el archivo se queda en la Pi. Si la otra persona insiste, el curso no te obliga a convencerla. Te obliga a no aplicar el atajo en la placa.

Tampoco conviertas esta lección en una lista de herramientas de ataque para «comprobar que estás seguro». No se escanea la calle, no se prueba la clave vieja contra tu propia Pi desde fuera, no se deja el puerto abierto cinco minutos a ver si alguien llama. Comprobar es mirar que el reenvío no está y que la cuenta no es la publicada. El resto es teatro, y el teatro enseña el gesto que justamente no quieres tener en las manos.

Un archivo que se queda es un archivo que puedes enseñar en casa

Hay una diferencia práctica entre no publicar y esconder. Esconder sería borrar la foto por si acaso, desenchufar la red y no volver a usar SSH. El curso no pide eso. Pide que la foto, si existe, siga en la Pi, y que la persona que quiera verla se siente donde está la Pi o use la red de casa con las reglas ya dichas. Enseñar el archivo en el salón, abriendo el portátil que ya entró por SSH o mirando la pantalla de la propia placa, no es el cuarto agujero. Es la casa funcionando.

El cuarto agujero empieza en el momento en que el archivo viaja a un servicio que no es tu disco. Da igual el verbo: subir, sincronizar, compartir enlace, mandar. El archivo deja de tener un solo sitio. Borrarlo en la Pi no lo borra en el otro. Por eso no se manda «un momento». El momento crea una copia que esta lección no sabe destruir, porque no administra ese otro sitio. Lo que no se manda no hay que perseguir.

La clave vieja se parece: mientras no exista en tu Pi, no hay nada que perseguir. Crearla para una prueba y borrarla después es peor que no crearla. Durante la prueba ya era la cerradura publicada. whoami y una clave que solo tú sabes cierran ese punto sin teatro. Si la olvidaste, se cambia en casa, con pantalla, no se «resetea» siguiendo una guía que vuelve a poner raspberry al final del párrafo.

Al cerrar el cuaderno, los cuatro noes tienen que poder leerse en voz alta sin añadir «bueno, menos este». Si hay un menos, es el que falta por cerrar, no una excepción elegante. La red local no es la excepción. Es el sitio donde el trabajo sigue, con la puerta de la calle sin reenvío.

Aviso. No se abre el router, no se usa pi/raspberry, no se entra desde la calle, no salen la cámara ni el CSV. En su lugar, la red local de las lecciones 36 a 38. Sin teatro. GPIO a 3,3 V. Sin 230 V.

Si uno de los cuatro te tienta más que los otros, suele ser el de la calle, porque es el que parece trabajo de verdad. No lo es. El trabajo de verdad de esta página ya cupo en una terminal de casa, un nombre y un archivo que no viaja. Repetirlo mañana sigue siendo la lección. Abrir la puerta no la profundiza: la abandona. Anótalo así, en una frase, si el cuaderno aún tiene sitio.

Ejercicio en la Pi

Sin abrir el router, escribe en el cuaderno los cuatro agujeros y, al lado de cada uno, la frase de lo que haces en su lugar: red local, usuario tuyo, quedarte en casa, archivo en la Pi. Si sabes que alguna vez reenviaste un puerto, ciérralo y no anotes cómo se abría. Si tu usuario es pi y la clave es la del tutorial, cámbiala con passwd antes de seguir, y no copies la nueva aquí. No subas la foto ni el CSV. No hace falta un montaje.

El cuaderno, si lo prefieres corto, son cuatro líneas y ni una dirección de fuera. Una línea por agujero, cada una con su «en su lugar». No hace falta un párrafo largo para cumplir. Hace falta que ninguna línea diga «luego lo abro».

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

El cierre junta un número, el de la temperatura de la lección 30, con el umbral de la 19: si pasa de 28 °C, avisa. El aviso se queda en casa: el LED de la lección 25, o una línea en el CSV de la 21. No manda un mensaje a internet. No es un catálogo de proyectos. Los proyectos hechos viven en el módulo Proyectos.

Las tres piezas, y ninguna más

El sensor ya está elegido. Es el BME280 a 3,3 V, masa, SDA en el físico 3 y SCL en el físico 5. Si hoy el bus no contesta, no improvises otro sensor. Puedes escribir el número a mano, como en la lección 19, para ver las dos ramas, y dejar anotado que la lectura viva espera a que i2cdetect -y 1 vea la dirección. Un 85 clavado no es un aviso: es la mentira de la lección 32. No lo compares con 28 hasta que sea una temperatura creíble.

La decisión no se renegocia. Pasar de 28 es ser mayor que 28. Veintiocho exacto sigue. Veintisiete coma cinco sigue. Veintinueve avisa. No bajes el umbral para que el LED parpadee en una habitación fresca, ni lo subas para callar un 85. Si el 85 aparece, paras y miras el dato, no el umbral.

El aviso es local. El LED usa el BCM 17, físico 11, con la resistencia de unos 330 ohmios y la masa de siempre. on cuando toca avisar, off cuando no. O, si no quieres luz, una fila en el CSV: fecha y el valor, en tu home, abierto en modo añadir y cerrado con with, como en la lección 21. No hace falta las dos a la vez. Una basta para cerrar el curso. El print de «aviso» o «sigue» puede acompañar, y también se queda en la terminal.

grados = 27.5
if grados > 28:
    print("aviso")
else:
    print("sigue")

Cuando el LED esté en el archivo, on vive dentro del primer bloque y off dentro del segundo, con la sangría de la lección 19. close al terminar, como en la 25, para soltar el pin. El CSV, si es el aviso que elegiste, escribe la fila en las dos ramas o solo en la del aviso: decídelo y no lo cambies a mitad de la prueba. Una fila con la palabra aviso y el número ya es un registro. No hace falta un segundo archivo en una carpeta servida.

Lo que el aviso no es

No es un mensaje que sale de casa. No hay cuenta que recibir, ni bot, ni correo. La lección 39 acaba de decir por qué. Un LED en la mesa lo ves al pasar. Una línea en el CSV la lees cuando te sientas, con python3 o abriendo el archivo en la propia Pi. Si quieres ver ese archivo un momento desde el salón, es la carpeta de la 38, y se apaga. No es el modo normal del aviso. El modo normal es el disco y la luz.

Tampoco es un catálogo. No añado un zumbador, una pantalla y un relé «para que quede completo». Cada uno sería otra decisión, y el relé hacia la red de 230 V no entra en ninguna. El cierre es una cadena corta: número, umbral, aviso aquí. Quien quiera ver proyectos ya armados, con otra ambición, va al módulo Proyectos. Esta página no los copia. Nombrarlos basta para no confundir el ejercicio con un escaparate.

Cómo se prueba sin mentir

Con 27,5 el LED está apagado, o el CSV no marca aviso, y la terminal dice sigue. Cambias el número a 29, guardas, lanzas otra vez: el LED enciende, o el CSV gana la fila de aviso. Vuelves a 28 exacto y no avisa. Tres pruebas, las dos ramas y el borde. Si el sensor ya da grados de verdad, sustituyes la primera línea por esa lectura y repites solo si puedes variar el aire sin forzar un número falso. No soples hasta inventar 40 grados. No alimentes el sensor a 5 V para «que la cifra suba».

El programa corre con tu usuario y el Python del sistema, no con sudo y no dentro de un venv vacío. Si falta gpiozero, es el paquete de la lección 25, por apt, no por pip. Si falta el dato del sensor, no añadas otra librería en este cierre: usa el número escrito y deja la lectura para cuando el bus esté visto. close al final. Un Control y C a medias puede dejar el pin ocupado: la lección 25 ya dijo cómo soltarlo, con un archivo corto de off y close, no reiniciando a tirones.

La resistencia del LED no se quita porque el aviso sea «solo un momento». El momento es 3,3 V igual. El físico 2 no entra en este montaje. Los físicos 27 y 28 siguen sin cable. El servidor de la carpeta, si lo dejaste vivo en la 38, se apaga antes de esta prueba. Un aviso no necesita estar publicado para ser un aviso.

Una cadena corta, leída de izquierda a derecha

El dibujo se lee así. El sensor entrega un número en grados, o tú lo escribes si la lectura aún no es fiable. La Pi compara con 28. Si la comparación es cierta, el LED enciende o el archivo gana una fila. Si es falsa, el LED sigue apagado o el archivo no marca aviso. Nada de esa cadena dibuja una flecha fuera del rectángulo. Si te descubres añadiendo una caja «móvil» al margen, la borras. No es el cierre. Es la lección 39 otra vez.

El CSV no sustituye al sensor y el LED no sustituye al número. Son el último eslabón. Un LED encendido sin saber qué grados lo encendieron es una luz, no una decisión. Por eso el print dice aviso o sigue al lado de la luz: cuando vuelvas a la mesa, la terminal y el LED cuentan la misma historia. Si no coinciden, la sangría está mal o el on se ejecutó fuera del if. Se corrige el archivo. No se sube el archivo a nadie para que te lo mire.

Entre prueba y prueba no hace falta apagar la Pi. Hace falta guardar el archivo y lanzarlo de nuevo, para no hablar con el número viejo que quedó en memoria. pwd confirma que estás en tu home. El CSV, si lo usas, es medidas.csv o el nombre que ya tuviera la lección 21, no uno nuevo cada vez que el resultado no te gusta. Varios archivos son varios avisos y no sabes cuál mirar. Uno basta.

Dónde acaba el curso y dónde empiezan los proyectos

Con las tres pruebas hechas, el curso de esta página ha cerrado el círculo que abrió el umbral de la lección 19. Entonces el número lo escribías tú para aprender el if. Ahora el número puede ser el aire de la habitación, y el aviso sigue siendo tuyo y local. No hay un examen distinto de esas tres pruebas. No hay un envío. El cuaderno guarda el resultado.

Lo que venga después, si viene, no se inventa aquí como una galería. El módulo Proyectos es otro archivo, otra balda, donde un montaje ya tiene nombre y cuerpo. Ir a mirarlo no cambia el umbral ni enciende el LED por ti. Si lo abres, que sea después de close, con el pin suelto y el servidor de carpetas apagado. Y si no lo abres, esta lección está igual de completa. El cierre no depende de un quinto aparato.

Si el sensor y el LED comparten masa, es la misma masa de siempre, el físico 6 o el que ya usaras, no un cero distinto. La alimentación del sensor no sale del pin del LED. Son dos caminos. Cruzarlos «para ahorrar un cable» deja el aviso y la medida en el mismo hilo, y entonces la luz y el número se estorban. Cuatro hilos del sensor, dos del LED contando la resistencia en serie, y se acabó. No añadas el pulsador como tercer aviso. El pulsador ya tuvo su lección. Hoy decide el número, no el dedo.

Si solo tienes una de las dos salidas

No tienes LED y sí tienes el archivo: el cierre es el CSV. No tienes sensor y sí tienes el LED: el cierre es el número escrito y la luz. No tienes ninguno de los dos aparatos: el cierre es el programa con el print, y en el cuaderno dibujas sensor, Pi y LED dentro del rectángulo, con la frase de que nada sale. Las tres versiones cumplen. Lo que no cumple es saltarse el umbral o mandar el resultado fuera porque te falta el LED y «hay que avisar de alguna manera». La manera, si no hay luz, es la línea en el archivo o la frase en la terminal. Las dos están en la habitación aunque la habitación sea solo la pantalla.

Cuando el LED sí está, míralo de frente a la prueba del 27,5. Tiene que estar apagado. Si nace encendido, el on está fuera del if o quedó de un programa anterior sin close. No es que la habitación pase de 28. Se corrige antes de probar el 29, porque si no, el 29 no demuestra nada: la luz ya estaba. El mismo cuidado con el CSV: abre el archivo, mira la última fila, lanza la prueba, mira si apareció una fila nueva. Una fila vieja de otro día no es el aviso de hoy.

Y cuando las tres pruebas cuadran, paras. No dejes el programa en un bucle infinito «vigilando» solo porque ya sabes el if. Un bucle que no pediste es un proceso que se queda, y el curso aún no ha dicho que arranque solo. Arrancar solo es otra lección, más adelante, y no se adelanta dejando el archivo colgado. Lanzas, miras, cierras. El aviso ocurrió. La habitación sigue quieta. Eso es el cierre.

Aviso. Grados de verdad, umbral pasar de 28 °C, aviso en el LED o en el CSV, dentro de casa. Sin mensaje a internet. Sensor a 3,3 V. LED con su resistencia. Físicos 27 y 28 libres. Sin 230 V. Los proyectos hechos están en el módulo Proyectos, no en un catálogo improvisado aquí.

El módulo Proyectos puede esperar sentado. No lo abras a medias de una prueba, con el LED encendido y el pin sin cerrar, para copiar una idea. Primero close, primero las tres pruebas, primero la frase de que nada salió. Luego, si quieres, el otro archivo. El enlace no es un deber de hoy.

Ejercicio en la Pi

Monta, si no sigue montado, el LED de la 25 y el sensor de la 30, a 3,3 V, sin 5 V en el sensor ni en el GPIO. Escribe el if con 27,5, con 28 y con 29. El aviso que elijas, LED o CSV, tiene que callar en los dos primeros y hablar en el tercero. close al acabar. En el cuaderno: qué número usaste, si era lectura o número escrito, y que el aviso no salió de la habitación. Si el dato es absurdo, no avises: anótalo como en la 32. Si quieres ver proyectos ya hechos, abre el módulo Proyectos en otro momento. No conviertas este archivo en una lista de ideas.

Anota las tres pruebas en el cuaderno con el número y la rama: 27,5 sigue, 28 sigue, 29 avisa. Si una no salió así, no la tapes con una luz a mano. Se corrige el archivo y se repite esa sola. El cierre es aburrido a propósito: el mismo umbral de siempre, en casa.

Si el LED y el CSV te sobran los dos, elige uno y deja el otro quieto. Dos avisos a la vez no enseñan más que uno bien mirado.

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

cron con @reboot sirve cuando el programa arranca, hace una cosa y termina. Las rutas van absolutas. systemd sirve cuando el programa tiene que seguir vivo y volver a levantarse si se cae. Para saber si falló se mira systemctl status y journalctl, que ya están en las lecciones 13 y 16. Esto no es el primer encendido de la lección 3.

Un disparo, o un lazo

El programa de la lección 40, lanzado a mano, vive mientras tú lo miras. Al apagar la Pi se acaba. Al volver a encender no regresa solo. Esta lección es ese regreso, y solo ese. No es grabar la tarjeta otra vez. No es el asistente del primer día. Si buscas la ficha de la imagen, es la lección 3, y no hay enlace hacia ella desde esta página.

Hay dos ideas. La primera: el programa arranca, hace una cosa y termina. Escribir una fila en el CSV, una sola, y salir. Para eso basta un disparo al encender. La segunda: el programa tiene que seguir vivo, mirando el sensor, y si se cae tiene que volver a empezar. Para eso hace falta un lazo, alguien que note la caída y lo levante. Mezclarlas es el fallo típico: poner un bucle infinito en cron, que no lo vigila, o poner un programa que termina en systemd y creer que «no hace nada» porque ya acabó bien.

Las fichas, con la orden concreta, están en Software, cron y en Software, systemd. Aquí va el porqué y un ejemplo mínimo que se puede copiar sin dejar huecos.

cron, cuando acaba

Se edita la tabla de tu usuario con crontab -e. No hace falta sudo: es la tabla de tu cuenta, no la del sistema. Una línea. @reboot significa «al arrancar», y no espera a la red. Si tu programa necesita la red para existir, este disparo le puede llegar antes de tiempo. El de las medidas en disco no la necesita.

La ruta va absoluta. python3 a secas puede no encontrarse, porque cron no tiene el mismo camino de búsqueda que tu terminal. El archivo tampoco se nombra solo: cron no está situado en tu home.

@reboot /usr/bin/python3 /home/TUUSUARIO/medidas.py >> /home/TUUSUARIO/medidas.log 2>&1

TUUSUARIO es el de whoami, no pi. medidas.py es un programa que hace una cosa y termina: abre el CSV como en la lección 21, escribe una fila, sale. El trozo de detrás guarda la salida en un log de tu home. cron no enseña el error en pantalla. Si al encender no pasa nada, se mira ese log, no se adivina. Una ruta relativa, python3 medidas.py, falla en silencio precisamente porque el log, si también era relativo, tampoco aparece donde lo buscas. Por eso las dos rutas, la del programa y la del log, van enteras.

systemd, cuando tiene que seguir

Si el programa debe quedarse, la unidad es un archivo del sistema. Hace falta sudo para crearlo en /etc/systemd/system/. El nombre del ejemplo es medidas.service. No actives con esto el acceso remoto ni un nombre que no hayas escrito tú. La unidad completa, sin huecos, es esta. Cambias el usuario y la ruta. No dejas un campo a medias «para luego».

[Unit]
Description=Medidas en CSV
After=multi-user.target

[Service]
User=TUUSUARIO
WorkingDirectory=/home/TUUSUARIO
ExecStart=/usr/bin/python3 /home/TUUSUARIO/medidas.py
Restart=on-failure

[Install]
WantedBy=multi-user.target

ExecStart apunta al python3 del sistema y a un archivo en /home de tu usuario. Restart=on-failure es el lazo: si el programa se cae con error, systemd lo vuelve a levantar. No pongas otro valor inventado. User= es tu cuenta. Si pones pi y esa cuenta no existe, la unidad falla y el fallo parece del programa. WorkingDirectory es tu home, para que un archivo relativo del propio programa, si lo tuviera, no caiga en un sitio raro. Aun así la orden de arranque lleva rutas absolutas.

Después, una vez:

sudo systemctl daemon-reload
sudo systemctl enable --now medidas.service

daemon-reload hace que el sistema lea el archivo nuevo. enable --now lo engancha al próximo arranque y lo arranca ahora. Es el mismo gesto de la lección 14, aquí con este nombre y no con otro. El programa que cuelgas de esta unidad es el que sigue vivo: un bucle que mira, espera y repite, no el que escribe una fila y sale. Si sale enseguida con éxito, systemd no lo relanza: acabar bien no es caerse. on-failure no significa «relanza siempre».

Saber si falló, sin repetir dos lecciones

La lección 13 ya mira si una unidad está viva con systemctl status. La 16 ya lee el diario con journalctl. No se reescriben aquí. Se usan con el nombre que acabas de crear:

systemctl status medidas.service
journalctl -u medidas.service -n 30 --no-pager

Si status dice failed, el motivo está en esas líneas del diario, no en un reinicio a ciegas. Lees de abajo arriba, como el traceback de la lección 20: la última línea dice qué pasó, el archivo y la ruta dicen si apuntaste al sitio correcto. Un error de «no such file» es una ruta mal copiada. Un error de permiso es el usuario. No los tapes con otro enable.

cron no sale en ese status. Su fallo está en medidas.log, el que la línea redirige. Vacío y sin fila nueva en el CSV: o no disparó, o el programa terminó sin escribir. Abres el log. Si no existe, la ruta del log también estaba mal. No hay una pantalla que consultar.

Qué programa cuelgas de cada uno

Antes de enganchar nada, el archivo tiene que funcionar a mano. python3 /home/TUUSUARIO/medidas.py desde tu home, con tu usuario, sin sudo. Si a mano ya falla, cron y systemd solo van a repetir el fallo al encender, y el log será el mismo traceback. Se arregla el programa primero, lección 20, y luego se engancha.

El de cron no lleva un while True. Escribe y sale. Si lo dejas en bucle, el disparo no termina, el log crece sin parar y no hay un on-failure que lo ordene. El de systemd sí puede esperar entre lecturas, con una pausa, y volver a mirar el umbral de 28. Esa pausa no es un truco para esquivar cron: es la razón de haber elegido el lazo. El aviso sigue siendo local, LED o CSV, como en la lección 40. Engancharlo al arranque no autoriza a mandar un mensaje fuera.

Una sola vez el reinicio de prueba, sudo reboot, no diez. Al volver, miras status o el log antes de tocar el archivo otra vez. Si está bien y no quieres dejarlo, lo quitas hoy, no «la semana que viene». Un servicio olvidado que enciende el LED cada mañana sin que recuerdes por qué es peor que no haberlo enganchado.

El orden, para no dejar una unidad coja

Primero el programa a mano. Segundo, decides si termina o si sigue. Tercero, escribes la línea de cron o el archivo de la unidad entero, con las tres partes: Unit, Service e Install. Un archivo que solo tiene ExecStart y se olvida el Install no se engancha al arranque: enable no tiene de qué tirar. Un Service sin User= corre como root, que es justo lo que la lección 11 no quiere para un script de GPIO. No lo dejes así «para probar». El ejemplo de arriba ya está completo. Cópiarlo y cambiar el usuario es el mínimo correcto. Inventar un campo nuevo no lo mejora.

Cuarto, daemon-reload antes de enable, si tocaste la unidad. Sin esa lectura, el sistema sigue viendo la unidad vieja o ninguna. Quinto, status. Sexto, solo si falló, el diario de esa unidad, no el diario entero de la placa a ciegas. La lección 16 ya explicó cómo no borrar el registro. Aquí ni se plantea: se lee y se deja.

Si enable dice que la unidad no existe, el nombre del archivo y el nombre de la orden no coinciden, o no está en /etc/systemd/system/. No crees una segunda unidad con otro nombre para esquivar el error. Dos unidades sobre el mismo programa se pisan. Una sola, medidas.service, o el nombre que hayas elegido y que seas capaz de escribir igual en status, en disable y en el cuaderno.

Y el disparo de cron no se comprueba con status de systemd. Son listas distintas. Buscar medidas.service cuando solo escribiste crontab enseña un failed que no es el tuyo, o un not-found que te empuja a crear la unidad además. Elige uno. El cuaderno dice cuál.

Aviso. @reboot para lo que termina. systemd con Restart=on-failure para lo que debe seguir. Rutas absolutas. ExecStart con /usr/bin/python3 y un archivo en tu home. sudo solo para la unidad del sistema. status y journalctl si falló. No se enlaza la lección 3. GPIO a 3,3 V. Sin 230 V. Sin reenvío de puertos.

GPIO, si el programa lo usa, sigue a 3,3 V y el proceso no va como root. Una unidad con User=tu cuenta puede tocar el pin igual que cuando lanzas el archivo a mano. Si status enseña un permiso denegado sobre el pin, no pases la unidad a root para callar el error. Mira el grupo en la placa, como en la lección 12, sin inventar la lista, y deja el usuario. El lazo que vuelve a empezar no es una excusa para saltarse esa cuenta. Y si hoy no vas a enganchar nada, el ejercicio puede quedarse en el cuaderno: una frase para el disparo, una para el lazo, y la orden con la que mirarías el fallo. Eso también distingue las dos ideas.

Ejercicio en la Pi

Elige una de las dos, no las dos a la vez sobre el mismo archivo. Si el programa escribe una fila y sale, una línea @reboot con rutas absolutas y un log en tu home. Reinicia una vez con sudo reboot y mira el log y el CSV. Si el programa debe seguir, escribe la unidad completa con tu usuario, daemon-reload y enable --now solo de medidas.service. Mira systemctl status y, si falló, journalctl de esa unidad. No actives ningún otro nombre. En el cuaderno: cuál de las dos ideas usaste y qué viste al fallar o al ir bien. Si no vas a dejarlo puesto, sudo systemctl disable --now medidas.service con ese nombre completo, o borra la línea de cron. No dejes un lazo que no estás mirando y que además publique algo: el aviso sigue siendo el de la lección 40, dentro de casa.

No enganches el servidor de la carpeta de la lección 38 a este arranque. Ese se apaga a mano. Un lazo que lo deje sirviendo solo cruzaría lo que la 39 acaba de cerrar.

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

La tarjeta es el disco, no un adorno de la placa. La copia se hace con la Pi apagada, como en la lección 9, leyendo la tarjeta desde otro equipo. Si no arranca, se mira la alimentación de la lección 4, la tarjeta y el LED de actividad. No se abre la Pi y no se toca config.txt: eso no es lección de este curso.

La tarjeta es el disco

El header, el LED del GPIO y la cámara se quedan en la mesa si sacas la tarjeta. Lo que se va contigo es el sistema. Raspberry Pi OS vive en esa tarjeta, no en un disco interno que la placa esconda. Por eso una tarjeta a medias metida parece una placa muerta, y una tarjeta con el sistema de archivos roto parece lo mismo. No es elegir otra Pi. Es mirar el disco que ya usas.

Tu home está ahí. El programa, el CSV, la foto que no salió de casa. Perder la tarjeta sin copia es perder eso. La copia no es una cuenta en internet: es otro archivo, en el otro equipo, hecho mientras la Pi está apagada. Sigue siendo tu casa, en un cajón, no un servicio.

Apagar, y luego sacar

La lección 9 no se salta porque «solo es la tarjeta». sudo shutdown -h now. Esperas a que el sistema cierre. En muchas placas el LED de actividad deja de parpadear cuando ya puede cortarse la corriente. Entonces, y solo entonces, quitas la alimentación. Sacar la tarjeta con la Pi encendida, o cortar la corriente a mitad del apagado, es la manera de necesitar esta lección de verdad. El dibujo lo pone delante: corriente cortada, y después la tarjeta.

Con la tarjeta fuera, el otro equipo la lee. El mismo cuidado que al grabar en la lección 3: lector bien puesto, no la tarjeta de fotos de casa si es la única que te importa, y sabes que escribir encima borra. Leer para copiar no borra la original si de verdad estás leyendo y no escribiendo. Si la herramienta pregunta si puede borrar, paras y lees. No confirmes por inercia.

No doy un comando mágico. Dentro de una Pi que no arranca no hay dónde escribirlo, y un comando copiado en el otro equipo, con el disco equivocado, puede borrar el disco de ese equipo. La copia la hace la herramienta de ese equipo que sepa guardar una tarjeta entera en un archivo, la misma familia de gesto con la que grabaste la imagen, no una línea adivinada. El archivo resultante tiene que ser la tarjeta entera, no una carpeta suelta que hayas copiado a mano con el sistema aún vivo: eso no restaura un arranque.

Si no arranca

Tres miradas, en este orden, antes de cualquier archivo. Alimentación, lección 4: fuente, cable, y que de verdad llega corriente. Una fuente floja o un cable que solo carga a medias deja la placa negra y no es la tarjeta. Tarjeta: metida hasta el clic, la que grabaste, no otra que se parece. LED de actividad: si no llega a parpadear al dar corriente, la placa no está leyendo un sistema. Si parpadea y luego se queda en negro, ya es otro caso, y sigue sin ser una invitación a abrir la caja.

No abras la Pi. No hay un tornillo de esta lección. Un conector interno suelto que no sabes nombrar no se «revisa por si acaso». Se deja. No abras config.txt. Ese archivo no es lección de este curso. Editarlo con la tarjeta montada en el otro equipo, a ciegas, es la manera de convertir un fallo de cable en un sistema que tampoco arrancará después. Si alguien te lo señala como el primer paso, es el paso que no das.

Tampoco regrabas la tarjeta buena en el primer minuto. Regrabar sin copia borra el home. Si tienes la copia hecha otro día, restaurar es escribir esa imagen en una tarjeta que aceptas borrar, con el mismo cuidado de la lección 3, y probar. Si no tienes copia, no fabriques una desde el sistema muerto. Anotas lo que viste: ¿había corriente? ¿el LED de actividad se movió? ¿la tarjeta estaba bien metida? Con esas tres respuestas se decide el siguiente gesto, no antes.

Qué guarda la copia, y qué no

Guarda el sistema y tus archivos tal como estaban en el momento de apagar bien. No guarda un LED que dejaste encendido, ni una sesión SSH abierta: eso no es disco. No guarda la hora si el reloj se pierde al cortar, y el reloj no tiene lección aquí. Al volver a arrancar desde la copia, el primer arranque puede ser el de siempre, un poco más lento, y tu usuario es el que estaba en esa tarjeta, no uno nuevo.

Una copia vieja de hace meses restaura un sistema viejo. El CSV de ayer no estará. Por eso la copia se renueva cuando el home ya tiene algo que dolería perder, no cada hora. Y se guarda en el otro equipo, con un nombre que diga de qué tarjeta es y de qué día. Dos copias sin nombre son dos dudas. No la subas a una cuenta: la lección 39 sigue valiendo. Un disco de casa o el propio otro equipo basta.

Si la Pi arranca y solo falla un programa, esta lección no toca. Eso es status, el log, el traceback. Una tarjeta que arranca no se restaura «por si el LED del GPIO no luce». Se arregla el circuito. Confundir la placa con el disco alarga las dos reparaciones.

La copia no sustituye al apagado

Hay quien copia a menudo y apaga mal. La copia de la semana pasada no arregla el archivo que se rompió hoy al cortar la corriente. El orden es al revés: apagas bien cada día, y de vez en cuando, con ese apagado ya hecho, sacas la tarjeta y la lees en el otro equipo. Una copia hecha con la Pi aún encendida, arrancando la tarjeta en caliente del lector mientras el sistema escribía, puede guardar un disco a medias. Por eso no se «saca un momento» con el escritorio abierto. Se cierra el sistema. Se espera. Se corta. Se saca.

En el otro equipo, antes de que la herramienta toque nada, mira qué disco ha reconocido. Tiene que ser la tarjeta, por tamaño y por el momento en que la insertaste, no el disco grande donde vive el otro sistema. Si dudas, quita la tarjeta y la lista debe perder ese disco. Si no lo pierde, estabas mirando otro. No confirmes. Este cuidado es el contenido de «no un comando mágico»: la magia elige el disco sola y se equivoca. Tú eliges cuando estás seguro, y solo para leer.

Al devolver la tarjeta a la Pi, la corriente sigue cortada. Se mete hasta el clic. Luego la alimentación. Si no arranca después de una copia que solo leyó, no has restaurado nada: la original debería seguir igual. Vuelve a las tres miradas. No concluyas que leer estropea. Casi siempre es la tarjeta mal metida al volver, o la fuente.

Restaurar es borrar una tarjeta a propósito

Escribir la copia sobre una tarjeta borra lo que esa tarjeta tuviera. Se hace cuando aceptas ese borrado: una tarjeta vacía, o una que ya no guarda nada que quieras. No se hace sobre la única copia que te queda «a ver si arranca mejor». Primero aseguras que el archivo de la copia sigue en el otro equipo. Luego escribes. Luego pruebas. Si la prueba falla, la copia sigue en el otro equipo y puedes repetir, no se ha consumido.

El nombre del archivo importa al cabo de un mes. «copia» y «copia2» no dicen si llevan el CSV de ayer o el sistema vacío del primer día. Un nombre con el día basta. No hace falta una base de datos. Hace falta no restaurar la vacía creyendo que era la llena. El cuaderno de esta lección puede guardar ese nombre y el sitio, en el otro equipo de casa. No hace falta pegar el archivo aquí.

Tres miradas, y luego paras

Alimentación: el cable que usas es el de la fuente, no un cable suelto de datos que a veces alimenta a medias. La lección 4 ya separó 5 V, 3,3 V y masa en el header. Aquí la pregunta es anterior: ¿la placa recibe corriente? Si el indicador de alimentación no se enciende, no sigas a la tarjeta. Cambia cable o fuente conocida antes de culpar al disco. No puentees el físico 2 con otra fuente «para probar». Eso no arranca el sistema y puede romper el header.

Tarjeta: fuera, miras que no esté doblada ni con los contactos sucios de dedos. La limpias en seco si hace falta, sin mojarla. La metes del lado que el modelo indica, hasta el clic, con la corriente cortada. Si entra forzada, no es la ranura. No uses un adaptador dudoso el día que no arranca: un adaptador malo parece una tarjeta mala.

LED de actividad: das corriente y miras un rato, no un parpadeo que te inventas. Si no se mueve, la placa no está leyendo. Si se mueve y el sistema no llega a pedirte usuario, anotas «actividad sí, sistema no» y paras. Esa nota vale más que un config.txt editado. Mañana, con la copia si la tienes, restauras en una tarjeta que aceptes borrar. Hoy no desmontas la placa para ver «si el LED está soldado». El LED de actividad se mira por fuera.

Aviso. Apaga con la lección 9 antes de sacar la tarjeta. La copia se lee en otro equipo. Si no arranca: alimentación, tarjeta, LED de actividad. No abras la Pi. No edites config.txt. No hay un comando mágico dentro del sistema muerto. GPIO a 3,3 V cuando vuelva a haber sistema. Sin 230 V.

Y no es el momento de probar otra placa. Si una segunda Pi arranca con la misma tarjeta, el fallo no era la primera caja: era el disco o la fuente que dejaste atrás. Si la misma tarjeta no arranca en ninguna, sigues en la tarjeta, no en un catálogo. Elegir modelo es Hardware, y no desatasca un sistema que no lee. Anótalo si hiciste esa prueba, y no abras ninguna de las dos.

Ejercicio en la Pi

Si el sistema vive, apágalo bien. Cuando el LED de actividad se quede quieto, corta la corriente y saca la tarjeta. En el otro equipo, haz una copia de la tarjeta entera con la herramienta que sepa leerla, sin confirmar ningún aviso de borrado que no hayas leído. Vuelve a meter la tarjeta, enciende y comprueba que sigue siendo tu usuario. En el cuaderno: día de la copia y dónde está el archivo, en casa, no en una cuenta. Si hoy no puedes copiar, escribe el orden de las tres miradas si no arrancara, y la frase de que no hay comando dentro del sistema muerto. No abras la caja. No abras config.txt.

Si el otro equipo ni siquiera ve la tarjeta, el fallo puede ser el lector, no la Pi. Prueba el lector con una tarjeta que sepas que se lee, si tienes una que no te importe. No concluyas que la placa murió porque un lector no montó nada. Y no escribas sobre esa tarjeta de prueba por error: leer y escribir siguen siendo gestos distintos.

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno

Ya sabes encender y apagar bien, usar la terminal, escribir un programa en Python, encender un LED, leer un pulsador, leer un sensor, guardar una foto en casa, entrar por SSH en la red local y dejar un aviso que no sale a internet. El catálogo de placas está en Hardware, los comandos de consulta en Software y los proyectos hechos en Proyectos. El Pico no es este curso. No hay examen con nota.

Lo que ya puedes hacer

Apagar es sudo shutdown -h now y esperar, no tirar del cable. Encender es dar corriente cuando la tarjeta está bien metida. La terminal es tuya: whoami, pwd, el usuario que creaste, no pi/raspberry. Python es python3 sobre un archivo de tu home, con un if que avisa si el número pasa de 28 y no avisa si es 28 justo.

El LED es el BCM 17, físico 11, resistencia de unos 330 ohmios, masa, gpiozero, y close al acabar. El pulsador es otro pin, el BCM 23, físico 16, cerrado a masa, con el pull-up de Button. El sensor es el BME280 a 3,3 V, SDA en el físico 3 y SCL en el físico 5, un número en grados. Si el número es absurdo o el bus sale vacío, no lo llamas temperatura: miras cable, alimentación y que el bus esté encendido.

La foto es rpicam-still -o foto.jpg. El vídeo corto, cinco segundos, es -t 5000 porque va en milisegundos. El archivo se queda en la Pi. SSH es tu usuario y el nombre que termina en .local, en la red de casa. El aviso de cierre es el LED o el CSV, no un mensaje. Si quieres que vuelva solo al encender, ya sabes distinguir el disparo de cron del lazo de systemd, y mirar status o el diario si falló.

Lo que esta página no es

No es el catálogo de placas. Modelos, medidas, qué conector trae cada una: eso vive en Hardware. No es la balda de comandos para consultar una opción que ya olvidaste: eso vive en Software. No es la colección de proyectos ya armados: eso vive en el módulo Proyectos. Esta página te ha traído hasta poder hacer el círculo tú. Esos tres sitios están al lado para cuando el círculo ya no alcanza, no para sustituir una lección que sí está escrita.

El Pico no es este curso. Tiene entradas analógicas y no arranca este Linux. Una frase basta, y el sitio donde se cuenta como aparato es el mismo catálogo, Hardware, Pico. No se monta allí el LED de estas lecciones y se dice que era lo mismo.

Tampoco hay examen con nota. Nadie puntúa el cuaderno. El cuaderno se queda en este navegador y no se envía. Si una prueba de las tres del umbral no sale, se repite esa prueba. No se aprueba con un cinco. O el LED calla a 27,5 y habla a 29, o aún no está.

El mapa

Un fallo corto cabe en una frase. La frase señala una lección, no un estado de ánimo. «No arranca» no se mira en el programa de Python: se mira la alimentación, la tarjeta y el LED de actividad, lección 42, y no se abre config.txt. «La orden vieja de la cámara no existe» se mira en la 33, en rpicam-still, no en un paquete al azar. «La tabla del bus sale vacía» se mira en la 31 y en la 32: cable, 3,3 V, bus encendido, antes que el umbral. «Quiero verlo desde la calle» se mira en la 39: no se publica. «Pasa de 28 y no avisa» se mira en la 19 y en la 40: la comparación y el aviso local.

Si dos lecciones parecen posibles, se mira la de más abajo en el orden físico. Sin corriente no hay SSH. Sin tarjeta no hay programa. Sin número creíble no hay aviso. El mapa no suma puntos. Acertar la lección significa saber dónde abrir el cuaderno, no ganar una nota.

La lista, sin adorno

Encender y apagar bien es no romper el disco por prisa. La terminal es saber en qué carpeta estás y con qué usuario. El programa es un archivo que mañana sigue diciendo lo mismo, con el umbral de 28 escrito en claro. El LED es una salida a 3,3 V con resistencia, no un pin de 5 V. El pulsador es una entrada que cierra a masa, no un sensor de voltaje. El sensor es un número en grados, por el bus, no un GPIO leído como botón. La foto es un archivo en la Pi. SSH es una terminal desde el salón. El aviso es luz o una fila, aquí.

Si una de esas frases ya no la puedes repetir, la lección correspondiente sigue en el índice. No se repasa entera en este cierre. Se vuelve a abrir esa, se hace el gesto, y se sale. El mapa sirve para eso: no para demostrar que memoricaste los cuarenta y tres títulos, sino para no abrir la 41 cuando el fallo es que no hay corriente.

Hardware no te enseña el if. Software no te elige el sensor. Proyectos no te apaga la Pi. Cada uno hace su trabajo cuando ya sabes cuál abrir. Perderse entre los tres el primer día era normal. Perderse hoy, con la lista de arriba escrita en el cuaderno, es no haber separado las baldas. Esta página es la balda del camino. Las otras tres están enlazadas para no copiarlas aquí a medias.

Un fallo, una lección

«El LED no se apaga al salir del programa» se mira en el close de la 25, no en una unidad systemd nueva. «cron no escribió el CSV» se mira en la ruta absoluta y en el log de la 41, no en la tarjeta. «La foto quiere subirse» se mira en la 35 y en la 39, y no se sube. «El nombre .local no contesta» se mira en la 37, y si hace falta la dirección, se anota que puede cambiar. «28 exactos avisan» se mira en la comparación de la 19: tiene que ser mayor que 28, no mayor o igual. Cada frase tiene un sitio. Si no lo tiene, no inventes una lección 44. Dilo en el cuaderno como «aún no está» y no lo fuerces con un archivo de configuración que el curso no enseña.

El último gesto del día, si la Pi sigue encendida, es el de la lección 9. El cierre de la página no sustituye al apagado. Cierras el navegador cuando quieras. La placa se apaga con la orden, se espera, y se corta la corriente. Mañana la tarjeta sigue siendo el disco, y la copia, si la hiciste, sigue en el otro equipo.

Qué queda en la casa cuando cierras la página

Queda una Pi que se apaga con una orden. Queda un usuario que no es el de un tutorial viejo. Queda un programa en tu home. Queda, si lo montaste, un LED que no se alimenta a 5 V y un sensor que tampoco. Queda una foto que no cruzó la puerta. Queda la posibilidad de entrar desde el salón, no desde la calle. Queda, si lo enganchaste, un disparo o un lazo, y la manera de ver si falló sin reiniciar a ciegas. Queda una tarjeta que es el disco, y ojalá una copia en el otro equipo.

No queda una nota. No queda un deber de publicar. No queda el Pico disfrazado de esta máquina. No queda permiso para abrir el router porque el curso ya se acabó. El final no afloja las lecciones 35 y 39. Las confirma: lo que mira la casa se queda en la casa, y el aviso también.

Si mañana solo recuerdas una frase, que sea esta: un fallo corto tiene una lección, y la lección se puede abrir. El índice está arriba. El pinout también. Hardware, Software y Proyectos están al lado cuando el fallo ya no cabe en el camino. Mientras quepa, no hace falta salir de esta página para saber dónde mirar.

El cuaderno de esta última lección puede ser la lista de los gestos, en tus palabras, más corta que la mía. Si al escribirla descubres un hueco, el número de lección al lado del hueco es el mapa funcionando. No lo tapes con un eslogan. Un hueco nombrado se puede volver a hacer. Un eslogan no enciende el LED.

El mapa cabe en el cuaderno

Puedes copiar, con tus palabras, una tabla de dos columnas. A la izquierda el fallo, en una línea. A la derecha el número. «Se apagó del cable» y la 9. «No sé en qué carpeta estoy» y la 8 o la 10. «El programa no guarda» y la 18. «El error no se lee» y la 20. «El pin y el físico no coinciden» y la 23. «El LED sin resistencia» y la 24. «El botón a 5 V» y la 26. «Medio brillo confundido con medio voltio» y la 27. «Soldar la Pi» y la 28, que no se suelda. No hace falta llenar las cuarenta y tres. Hace falta que las que llenes sean ciertas. Una fila equivocada enseña más si la corriges que si la dejas bonita.

Nadie va a pedirte esa tabla. Por eso puedes ser preciso. Si no recuerdas el número, ábrelo en el índice y escríbelo. Mirar el índice no es hacer trampa: el índice es el mapa. Un examen escondería el índice. Aquí el índice se queda visible, y por eso no hay nota. Saber usar el índice es parte de saber hacer.

Cuando la tabla tenga cinco filas buenas, para. Más filas no cierran mejor el curso. Cierran mejor el día el apagado y, si toca, la copia de la tarjeta hecha con calma otro rato, no a las tantas con la fuente a medias. El curso cabe en gestos repetibles. Esta página ya los nombró.

Aviso. No hay examen con nota. El Pico no es este curso. Hardware, Software y Proyectos están al lado, no dentro de esta lista. GPIO a 3,3 V. La imagen y el aviso se quedan en casa. Sin 230 V.

Ejercicio en la Pi

Sin montar nada nuevo, escribe en el cuaderno cinco fallos cortos que ya sepas colocar: uno de apagado, uno de LED, uno de sensor o de bus, uno de foto o de SSH, y uno de «no arranca». Al lado, el número de lección. No les pongas puntos. Si quieres, comprueba uno de verdad: whoami es tu usuario, o el LED aún obedece a on y a off con la resistencia puesta. Luego close si tocaste el pin, y apaga bien si acabas el día. Los proyectos hechos, si los miras, son el otro módulo, no un deber de esta página.

Si una fila te sale con dos números, escribe los dos y cuál mirarías primero. El orden físico manda: sin disco no hay programa, sin programa no hay aviso, sin red de casa no hay SSH. Esa segunda columna, la del «primero», evita abrir tres lecciones a la vez y no hacer ninguna.

Y si al terminar no te apetece ni una fila, también vale decir en voz alta tres gestos que sí harías mañana sin mirar. Si no te salen tres, abre el índice y elige uno para repetir otro día. Repetir uno es mejor que releer los cuarenta y tres títulos del tirón.

El pinout de esta misma página sigue ahí para el físico que dudes. No hace falta memorizar los cuarenta. Hace falta no inventar un analógico donde no lo hay.

Tu cuaderno

Lo que escribas aquí se queda en este navegador. No se envía a ningún sitio.

Tu cuaderno