<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://funduinoshop.com/es/blog/raspberry-pi/?sAtom=1" rel="self" type="application/atom+xml" />
    <author>
        <name>Funduinoshop</name>
    </author>
    <title>Blog / Atom Feed</title>
    <id>https://funduinoshop.com/es/blog/raspberry-pi/?sRss=1</id>
    <updated>2026-04-29T19:43:40+02:00</updated>
    
        <entry>
            <title type="text">Botón en la Raspberry Pi</title>
            <id>https://funduinoshop.com/es/boton-en-la-raspberry-pi</id>
            <link href="https://funduinoshop.com/es/boton-en-la-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            En los primeros ejemplos, conocimos los pines GPIO como salidas que pusimos en ALTO para que se encendiera un LED. Pero GPIO significa Entrada/Salida de Propósito General. Así que también puedes utilizar los pines como entrada...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  En los primeros ejemplos, conocimos los pines GPIO como salidas que pusimos en ALTO para que se encendiera un LED. Pero GPIO significa Entrada/Salida de Propósito General. Así que también puedes programar los pines como entradas. Entonces se puede determinar si hay tensión en la entrada (HIGH) o no (LOW). La Raspberry Pi sólo tiene entradas digitales (más adelante conoceremos una solución para medir tensiones analógicas), pero la tensión aplicada no tiene que ser exactamente 3,3V para ser reconocida como ALTA y no 0V para ser reconocida como BAJA. Hasta aproximadamente 1,4 V se reconoce como BAJA, todo lo que esté por encima de 1,9 V se reconoce sin duda como ALTA. Sólo el pequeño rango alrededor de ½ de 3,3V y un pin libre sin nada conectado son problemáticos.  
  Vamos a conocer varios sensores digitales que deben activar una alarma o una acción determinada en nuestro programa (por ejemplo, un detector de movimiento). El más sencillo de estos sensores es el botón, un interruptor con resorte que cierra un circuito cuando se pulsa el botón y lo vuelve a abrir cuando se suelta.  
  Si conectamos un contacto del botón a un pin GPIO y el otro a 3,3 V, se detecta claramente la señal ALTA cuando se pulsa el botón. El problema comienza después de soltar el botón. ¿Qué estado tiene entonces el GPIO? ¡Uno indefinido! No puedes programar con esto. Por tanto, en el estado desconectado, el GPIO debería estar permanentemente a potencial GND. Sin embargo, esto provocaría un cortocircuito al pulsar el botón. El remedio es una resistencia que debe ser lo suficientemente grande como para que sólo fluya una pequeña corriente. Son habituales las resistencias de 4,7 k&amp;nbsp;(=4700 Ohm) o 10 kΩ&amp;nbsp;(=10.000 Ohm). Estas resistencias se denominan resistencias pull-down.  
  Sin embargo, también puedes programar el GPIO para que normalmente indique ALTO y reconozca la pulsación de la tecla contra GND como un cambio a BAJO. Entonces la resistencia se llama resistencia pull-up. Y para hacerlo aún más confuso para los principiantes, los GPIO de la Raspberry Pi tienen una resistencia pull-up o pull-down interna que se puede activar o desactivar en el programa. Afortunadamente, esto hace que los circuitos iniciales sean muy sencillos.  
  El esquema del circuito: Pulsador de la Raspberry Pi  
     
     
  El código del programa: Pulsador en la Raspberry Pi  
  from gpiozero import LED, Botón
from señal import pausa
led = LED ( 12)
 botón  = Botón ( 16)
 botón  .al_presionar  = led . encendido
 botón  .al_soltar  = led . apagado
  pausa  ()    
   Desde el módulo gpiozero, se importan las clases LED y botón, separadas por comas, y luego se instancian los objetos led y botón con los respectivos números GPIO.     En lugar de la función    dormir()   -Del módulo    tiempo   &amp;nbsp;del módulo    pausa   &amp;nbsp;del módulo    señal   &amp;nbsp;sleep() significaría la paralización completa, no se notaría la pulsación de la tecla durante ese tiempo. Sin pause(), el programa terminaría y no pasaría nada.     La instanciación del botón fue muy sencilla porque sólo especificamos el número de GPIO y, por lo demás, utilizamos la configuración por defecto (ver definición de la clase en la línea siguiente). Si quieres desviarte de esto, tienes que introducir más parámetros como argumentos de palabra clave.   
   class  gpiozero .Button  (pin , *,  pull_up=True ,  active_state=None ,  bounce_time=None ,
 hold_time=1 ,  hold_repeat=False ,  pin_factory=None )  
   Puedes encontrar más detalles sobre gpiozero      aquí     .    
  Ampliación de la configuración experimental: Se va a iniciar un ciclo de semáforo con una Raspberry Pi cuando se pulse un botón.  
  El montaje experimental se basa en el primer ejemplo. En lugar de un LED, se utiliza el semáforo LED. Éste lleva incorporadas resistencias en serie. Instanciamos tres objetos LED y definimos una función semáforo, a la que se llama cuando se pulsa un botón.  
  El código del programa: Ciclo del semáforo en la Raspberry Pi   
  from gpiozero  import  LED, Botón
from señal  import  pausa
from tiempo  import  dormir
redled = LED ( 16)
amarilloled = LED ( 20)
verdeled = LED ( 21)
botón = Botón ( 12)
def semáforo():
       redled.on()
    dormir(1)
    amarilloled.on()
    dormir(1)
    verdeled.encendido()
    redled.apagado()
    amarilloled.apagado()
    dormir(1)
    amarilloled.encendido()
    greenled.apagado()
    dormir(1)
    redled.encendido()
    amarilloled.apagado()
    dormir(1)
    redled.apagado()
button.when_pressed = semáforo
pausa()  
  Extensión: Juego de reacción con dos botones en la Raspberry Pi  
   Necesitas dos botones, un zumbador y un LED rojo y otro amarillo. Al iniciar el Juego de Reacción, se enciende primero el LED amarillo. Con    tiempo = uniforme(5, 10)   &amp;nbsp;el LED rojo se enciende después de un tiempo aleatorio entre cinco y diez segundos. A continuación, dos jugadores pueden pulsar cada uno su botón lo más rápido posible. Si pulsan demasiado pronto, les pillarán haciendo trampas y el zumbador sonará durante medio segundo.   
  El código del programa: Sonda de reacción con dos botones en la Raspberry Pi   
   /usr/bin/python3 
 # Juego de Reacción - pulsa el botón, cuando se encienda el LED rojo 
 # basado en la documentación de gpiozero, Recetas Básicas 
 # mejorado para reconocer trampas por Bernd Albrecht 
 # El LED rojo se enciende 5 - 10 seg. después del LED amarillo 
 from  gpiozero  import  Botón, LED, Zumbador
 from  tiempo  import  dormir
 from  random  import  uniforme
 from  sys  import  salida
led_rojo = LED ( 16)
led_amarillo = LED ( 20)
zumbador = Zumbador ( 12)
jugador_1 = Botón ( 23)
jugador_2 = Botón ( 18)

led_amarillo .on ()
tiempo = uniforme (5 ,  10 )
sleep(tiempo)
 si  jugador_1.es_presionado
    print (&quot; ¡El jugador 1 está haciendo trampas!&quot; )
    zumbador . on()
    dormir(0 .5 )
    zumbador. apagado ()
    led_amarillo. apagado ()
    salir()
 si  jugador_2.es_presionado
    print (&quot; ¡El jugador 2 está haciendo trampas!&quot; )
    zumbador .on ()
    dormir (0.5 )
    zumbador. apagado ()
    led_amarillo. apagado ()
    salir()
led_rojo . encendido()
led_amarillo . apagado()
 mientras  sea True
    if  jugador_1.es_presionado
        print (&quot; ¡El jugador 1 gana!&quot; )
        rompe 
    si  jugador_2.está_presionado
        print (&quot;¡Gana el jugador 2 ! &quot;)
        interrupción 
led_rojo .apagado ()  
                ]]>
            </content>

                            <updated>2022-07-27T14:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">LED RGB en la Raspberry Pi</title>
            <id>https://funduinoshop.com/es/led-rgb-en-la-raspberry-pi</id>
            <link href="https://funduinoshop.com/es/led-rgb-en-la-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                             Un LED RGB es la combinación de tres LED de distintos colores en una misma carcasa. El término RGB hace referencia a los colores &quot;rojo&quot;, &quot;verde&quot; y &quot;azul&quot;. Los LED respectivos pueden controlarse mediante modulación por ancho de pulsos (PWM).
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Controlar un LED RGB con un microcontrolador Raspberry Pi 
 ¿Qué es un LED RGB? 
 Un LED RGB es la combinación de tres LED de distintos colores en una misma carcasa. El término RGB hace referencia a los colores &quot;rojo&quot;, &quot;verde&quot; y &quot;azul&quot;. Los LED respectivos pueden controlarse mediante modulación por ancho de pulsos (PWM). Esto hace posibles multitud de combinaciones de colores. 
 Un LED RGB tiene cuatro patas, una para cada color y una común para los tres colores. Según la versión, la más larga de las cuatro patas es el ánodo común (+) o el cátodo (-). La única pata junto a esta más larga es la conexión para el componente rojo. Los componentes verde y azul se controlan mediante las patas del otro lado.    
 Qué tipo de LED RGB tienes, ánodo común o cátodo común, no es visible desde el exterior. Afortunadamente, no se puede dañar nada por ensayo y error. El LED RGB no se ilumina en la dirección de bloqueo. Importante: Los tres LEDs implementados también necesitan resistencias en serie. Si quieres hacerlo de forma académica, puedes calcular distintas resistencias en serie a partir de las respectivas tensiones de flujo. En aras de la simplicidad, también puedes utilizar las mismas resistencias entre 100 y 330 Ω (Ohm). 
 Versión a: &quot;Cátodo común&quot; - La pata más larga del LED es &quot;-&quot; y las tres patas más cortas se controlan en los GPIOs con &amp;nbsp;&quot;+&quot; (tensión). 
 Versión b) &quot;Ánodo común&quot; - La pata más larga del LED es &quot;+&quot; y las tres patas más cortas se controlan con &quot;-&quot; (GND) en los GPIOs. 
 Mezclando los colores, se pueden crear muchos más colores. Por ejemplo, controlando los colores &quot;azul&quot; y &quot;verde&quot; se produce el color &quot;turquesa&quot;, rojo y verde producen amarillo, rojo y azul producen magenta, y los tres colores con cantidades iguales producen blanco. 
       El esquema del circuito: LED RGB en la Raspberry Pi   
 El código del programa: LED RGB en la Raspberry Pi 
 Programa de ejemplo para un LED RGB con cátodo común: 
 from gpiozero  import  RGBLED
from tiempo  import  dormir
 led  = RGBLED (rojo=14,   verde=15,   azul=18) 
 duración  =  2 

 # aumenta lentamente la intensidad de todos los colores (5seg) 
para n  en  rango (100 )
    led .azul  =  n/100 
    led .  rojo =  n/100 
    led .  verde =  n/100    
    dormir (0.05 )
led .color  = (0 ,  0 ,  0 )  # apagado 
dormir(duración)
led .rojo  =  1   # rojo completo 
dormir(duración)
led .rojo  = 0  ,  5 #   medio rojo
dormir(duración)
led .color  = (1 ,  1 ,  0 ) #   amarillo 
dormir(duración)
led .  color = (0 ,  1 ,  0 ) # verde   completo 
dormir(duración)
color .  led = ( 0,  1 ,  1 ) #   cian 
dormir(duración)
color .  led = ( 0,  0 ,  1 ) #   azul completo
dormir(duración)
color .  led = ( 1 ,  0 ,  1 ) #   magenta 
dormir(duración)
led .  color = ( 1 ,  1 ,  1 ) #   blanco 
dormir(duración)
color .  led = (0 ,  0 ,  0 ) #   apagado 
dormir(duración) 
 Más adelante veremos cómo utilizar tres potenciómetros para ajustar los componentes de color. Sin embargo, para ello necesitamos un conversor analógico-digital externo, porque la Raspberry Pi sólo conoce las señales digitales: ALTO o BAJO. 
    
                ]]>
            </content>

                            <updated>2022-07-19T09:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">LED pulsante en la Raspberry Pi (modulación por ancho de pulso)</title>
            <id>https://funduinoshop.com/es/led-pulsante-en-la-raspberry-pi-modulacion-por-ancho-de-pulso</id>
            <link href="https://funduinoshop.com/es/led-pulsante-en-la-raspberry-pi-modulacion-por-ancho-de-pulso"/>
            <summary type="html">
                <![CDATA[
                
                                            Se dice que un LED se vuelve pulsantemente más brillante y más oscuro. (También se llama &quot;desvanecer&quot;, por el verbo desvanecer). Nos gustaría ponerlo en práctica con la llamada modulación por ancho de pulsos...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Se dice que un LED se vuelve pulsantemente más brillante y más oscuro. (También se llama &quot;desvanecer &quot;, por el verbo inglés  to fade  = desvanecerse, disminuir). Nos gustaría ponerlo en práctica con la llamada modulación por ancho de pulso. A continuación encontrarás más información sobre la modulación por ancho de pulso en la Raspberry Pi.  En primer lugar, echaremos un vistazo al esquema del circuito. 
 El esquema del circuito: LED pulsante en la Raspberry Pi (PWM) 
   
  Para variar el brillo de un LED, no basta con variar la tensión. Debido a su diseño (¡diodos!), se requiere una tensión mínima determinada; esta denominada tensión de avance se sitúa entre 1,6 y 3 V aproximadamente, dependiendo del color del LED. Por encima de esta tensión directa, el LED se vuelve conductor y la corriente está limitada por una resistencia en serie. Por tanto: a diferencia de las lámparas incandescentes, el brillo no se regula por el nivel de tensión. Por cierto, los pines GPIO sólo suministran exactamente 3,3 V. 
 El remedio en este caso es la modulación por ancho de pulsos (PWM). Esto activa y desactiva la tensión continua con alta frecuencia. La energía total transmitida viene determinada por la relación entre el ciclo de trabajo y la duración total de un ciclo. Este ciclo de trabajo puede estar entre 0 y 100%. 
 En la Raspberry Pi, puedes utilizar el PWM por software en todos los pines GPIO. Pero también hay dos pines PWM hardware especiales. ¡Vamos allá! 
 El primer código de programa: LED pulsante en la Raspberry Pi con modulación por ancho de pulsos 
  # Empezamos importando los módulos del programa 
import RPi.GPIO as GPIO  # Atención: Fíjate en la notación: i pequeña 
importar  tiempo 
GPIO.setmode(GPIO.BCM) #   Establecemos el modo a BCM 
 LED=23  #   La palabra &quot;LED&quot; representa ahora el número &quot; 23 &quot; .
GPIO.setup(LED,GPIO.OUT) # &quot;  LED&quot; (pin  23 ) es una salida .
Dimmer = GPIO.PWM(LED ,100 ) #   Configuramos el LED como PWM con una frecuencia de  100  
Dimmer.start (0 ) #   Se inicia el Dimmer
 # El bucle comienza aquí 
 prueba :
    while   True :  #buclewhile para que el programa se ejecute continuamente 
        for  dc  in  range (0  ,101  ,5 ):          # Haz un bucle con el ciclo de trabajo en  pasos de 5 . 
             Dimmer.ChangeDutyCycle(dc) #   Cambia el ciclo de trabajo del dimmer. 
            time  .sleep  (0,1 )  # Espera  0,1  segundos. 
        for  dc  in  range (100  ,-1  ,-5 ):      # Recorre el ciclo de trabajo en pasos de -5 . 
            Dimmer.ChangeDutyCycle(dc) #   Cambia el ciclo de trabajo del regulador. 
            time  .sleep  (0.1 )  # Espera  0.1  segundos. 
except InterrupciónTeclado:  # Con CTRL+C interrumpimos el programa 
    print (&quot;Finalizado&quot;) #   Escribe &quot;Finalizado&quot; en la ventana del intérprete de comandos 
    Dimmer .stop () #   Detén el dimmer. 
    GPIO.cleanup() #   Finaliza el programa.  
 En este ejemplo conocemos otra forma de bucle: el bucle for. Esta línea de comandos también termina con dos puntos seguidos de la sangría de las líneas que se van a repetir. 
 La variable dc (de ciclo de trabajo) se incrementa en el intervalo  de 0 hasta 101, excluido, en incrementos de cinco:  for dc in range(0,101,5) : 
 El segundo bucle for cuenta hacia atrás desde 100 hasta -1 en -5:  para dc en rango(100,-1,-5):  
 El segundo código del programa: LED pulsante en Raspberry Pi con modulación por ancho de pulso con el comando gpiozero    
 # Empezamos importando los módulos del programa
from gpiozero import PWMLED
import tiempo
pwmled = PWMLED (23 ) #  parámetro opcional  frecuencia=xxx  (por defecto 100) 

#  El bucle comienza aquí
prueba
    while  True: # bucle while para que el programa  se ejecute   continuamente 
        for  dc in range(0,101,5):   # Incrementa el tasgrado en pasos de 5. 
            pwmled.value  = (  dc/100 ) # Cambia el ciclo de trabajo (entre  0  y  1 ) del regulador de intensidad.
            time .sleep  (0,1 ) # Espera  0,1  segundos.
        para  dc en rango (100  ,-1  ,-5 ): # Cuenta hacia atrás el ciclo de trabajo en   pasos de -5 .
            pwmled.value = (dc/100 )  # Cambia el ciclo de trabajo (entre 0 y 1) del regulador. 
            time.sleep(0.1) # Espera  0.1 segundos .

except  InterrupciónTeclado: # Con CTRL+C interrumpimos el programa 
    print  ( &quot;Finalizado &quot;  ) # Escribe  &quot;Finalizado &quot;  en la ventana del intérprete de comandos 
# pwmled.value  = 0 # 1er método para  borrar el LED al final del programa
    pwmled.close()  # 2º método para borrar el LED  al final del programa 
 En general, el código del programa es más sencillo con gpiozero. 
 Tenlo en cuenta: El ciclo de trabajo está entre 0 y 100%. Mientras que el argumento para el ciclo de trabajo en RPi.GPIO es el valor %, gpiozero espera el valor como un número de coma  flotante  (número&amp;nbsp;) entre 0,0 y 1,0, es decir, 0,5 en lugar de 50 [%]. 
                ]]>
            </content>

                            <updated>2022-06-17T10:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Conectar el zumbador y el LED a la Raspberry Pi</title>
            <id>https://funduinoshop.com/es/conectar-el-zumbador-y-el-led-a-la-raspberry-pi</id>
            <link href="https://funduinoshop.com/es/conectar-el-zumbador-y-el-led-a-la-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            En esta entrada del blog queremos hacer que un zumbador y un LED se enciendan o suenen con la ayuda de un microcontrolador Raspberry Pi. Este programa se utiliza a menudo en las escuelas para demostrar...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Nota: Para este programa se necesita un zumbador activo (la explicación sigue más adelante), hay que prestar atención a la polaridad. No se necesita una resistencia en serie para el zumbador (altavoz). 
 En esta entrada del blog, queremos hacer que un zumbador y un LED se enciendan o suenen con la ayuda de un microcontrolador Raspberry Pi. Este programa se utiliza a menudo en las escuelas para mostrar cómo se pueden utilizar señales de salida simples utilizando una Raspberry Pi con componentes sencillos.  Antes de entrar en la cuestión de cuál es la diferencia entre un altavoz activo y uno pasivo, veamos primero el esquema del circuito y el código del programa. 
 El esquema del circuito: Conexión del zumbador y el LED a la Raspberry Pi 
   
 El código fuente: Conexión del zumbador y el LED a la Raspberry Pi 
  # Esta vez también utilizamos la primera sección del programa. Aquí se introducen las variables. Esto significa que hay un número detrás de una letra o una palabra. En nuestro caso, el LED está conectado a la patilla 23 y el altavoz piezoeléctrico a la patilla 4. Para evitar confundir las dos patillas más adelante, simplemente renombramos la patilla 23 y la patilla 24. 
 # Empezamos importando los módulos del programa 
 import  RPI.GPIO  as  GPIO
 importar  tiempo
GPIO.setmode(GPIO.BCM) #   Establecemos el modo a BCM 
 LED=23 ; # La palabra &quot;  LED&quot; ahora representa el número &quot;23&quot; .
 Bip=24 ; # La palabra &quot;  Bip &quot; ahora representa el número &quot;24&quot;.
GPIO.setup(LED,GPIO.OUT) #   El pin &quot;LED&quot; (pin 23) es una salida .
GPIO.setup(Pieps,GPIO.OUT) # El pin &quot;  Pieps &quot; (pin 24) es una salida
 # El bucle comienza aquí 
 prueba :
 while   True :  # Bucle while para que el programa se ejecute continuamente 
GPIO.output(LED,GPIO.HIGH) #   Enciende el LED. 
GPIO.output(Pieps,GPIO.HIGH) # Enciende   el altavoz piezoeléctrico .
time.sleep (1 )  # Espera 1 segundo 
GPIO.output(LED,GPIO.LOW) #   Apaga el LED.
GPIO.output(Pieps,GPIO.LOW) # Apaga   el altavoz piezoeléctrico.
time.sleep (1 )
 # Aquí al final, el programa salta al inicio del bucle while. Así que está a punto de pitar y encenderse de nuevo. Si aumentas o reduces la pausa (tiempo.dormir), pita y se enciende más rápido o más lento. 
 except  InterrupciónTeclado:  # Con CTRL+C interrumpimos el programa 
 print  (&quot;Finalizado&quot;) #   Escribe &quot;Finalizado&quot; en la ventana del intérprete de comandos 
GPIO.cleanup() #   Sal del  programa 
 Diferencia entre zumbador activo y pasivo 
 El zumbador activo tiene un oscilador incorporado que produce un  zumbido  cuando se aplica una tensión de 3,3 V o 5 V. Debido a su diseño, tienes que prestar atención a la polaridad del zumbador. En el momento de la entrega, estos zumbadores suelen tener una pequeña pegatina con el signo más y la pegatina &quot;QUITA EL SELLO DESPUÉS DE LAVAR&quot;. También hay un signo más + de nuevo en el cuerpo del propio componente. Tienes que mirar dos veces para ver la pata más larga. O puedes coger una pequeña placa breakout; aquí los contactos están marcados con S (significa señal) y - (menos, masa).&amp;nbsp; 
 Puedes probar el zumbador con un programa sencillo como el del LED parpadeante, en el que el pin (casi) cualquiera se pone en ALTO durante un segundo y en BAJO durante un segundo. 
 El zumbador pasivo no tiene oscilador incorporado, por lo que la Raspberry Pi tiene que hacerse cargo de esta función. Si pruebas el programa anterior en un zumbador pasivo, oirás un suave sonido de &quot;clic&quot; cada segundo. Sin embargo, si acortas extremadamente el tiempo de pausa (sleep(0,001) o sleep(0,002)) y repites el encendido/apagado durante cierta duración, podrás oír un sonido cuya frecuencia podemos calcular fácilmente: un milisegundo cada uno de ALTO o BAJO significa (sin tener en cuenta el tiempo de ejecución de los demás comandos) unos 500 ciclos de encendido/apagado por segundo, es decir, unos 500 Hz. 
 Si quieres emitir un tono de aviso breve, debes utilizar un zumbador activo que se encienda y apague como un LED. Debes prestar atención a la polaridad. 
 Si quieres programar una sirena de dos tonos (que se oiga más claramente) o una breve melodía de reconocimiento (jingle), debes utilizar un zumbador pasivo o un pequeño altavoz. 
    
 &amp;nbsp; 
 &amp;nbsp; 
                ]]>
            </content>

                            <updated>2022-06-15T15:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">LEDs que parpadean alternativamente en el microcontrolador Raspberry Pi</title>
            <id>https://funduinoshop.com/es/leds-que-parpadean-alternativamente-en-el-microcontrolador-raspberry-pi</id>
            <link href="https://funduinoshop.com/es/leds-que-parpadean-alternativamente-en-el-microcontrolador-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            También puedes conectar los componentes electrónicos en la protoboard sin un T-cobbler. En este caso, sin embargo, necesitas cables puente del tipo hembra - macho para la conexión a la regleta de conectores J6 de la Raspberry Pi....
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 ¿Cómo hacer que dos LED de la Raspberry Pi parpadeen alternativamente? 
 También puedes conectar los componentes electrónicos en la protoboard sin un T-cobbler. En este caso, sin embargo, necesitas un cable puente del tipo hembra - macho para la conexión a la regleta de conectores J6 de la Raspberry Pi, es decir, enchufe para la Raspberry Pi y clavija para la protoboard. 
   
  El código del programa (LED parpadeando alternativamente en la Raspberry Pi)   
  # Desde aquí se puede copiar el código directamente en el software Python. 
 # Negro, coloreado = código y gris = explicaciones 
 # Empezamos importando los módulos del programa 
import RPI.GPIO  as  GPIO
importar  tiempo 
GPIO.setmode(GPIO.BCM)  #Ajustamos el modo a BCM 
GPIO.setup (23 ,GPIO.OUT) #El   pin 23 es una salida .
GPIO.setup (24 ,GPIO.OUT) #El pin 24 es una salida  . 
 # El bucle comienza aquí 
 prueba :
    while  True:  #Bucle while para que el programa se ejecute continuamente 
        GPIO.output (23 ,GPIO.HIGH) #   Enciende el LED en el pin 23 .
        GPIO.output (24 ,GPIO.LOW) # Apaga   el LED de la patilla 24.
        time .sleep (1 )  # Espera 1 segundo 
        GPIO.output (23 ,GPIO.LOW) # Apaga   el LED de la patilla 23.
        GPIO.output (24 ,GPIO.HIGH) # Enciende   el LED en el pin 24.
        time .sleep (1 )
 # Aquí al final el programa salta al inicio de la parte del bucle. Entonces.. 
 # ...enciende el LED en la patilla 23. 
 # ... etc... etc... etc.. 
except InterrupciónTeclado:  # Con CTRL+C interrumpimos el programa 
    print ( &quot;Final izado&quot; ) # Escribe &quot;Finalizado&quot; en la ventana del intérprete de comandos
    GPIO.cleanup() # Finaliza el programa
  
 En el ejemplo nº 01 LED parpadeante habíamos realizado el bucle infinito con while True y la sangría de las siguientes líneas de código. Si has cancelado este bucle infinito con la combinación de teclas Ctrl-C, te habrás dado cuenta de que, en primer lugar, recibes un mensaje de error y, en segundo lugar, el LED puede seguir encendiéndose. Para evitar estos dos efectos indeseables, se han añadido algunas líneas de código a este ejemplo. La línea  try:  se inserta antes del bucle while true. Los dos puntos llevan a la sangría de todo el bucle. Si se produce un error en este bucle mientras se ejecuta el programa, no aparece ningún mensaje de error, sino que el programa continúa en  except KeyboardInterrupt: . Con el comando print, se imprime el final del programa en el shell de Python (ventana inferior en Thonny), con GPIO.cleanup(), se apagan los GPIOs (es decir, nuestros LEDs) y se liberan para otros fines. 
 Ejemplo: Ciclo de semáforos en la Raspberry Pi 
 Aquí tienes una propuesta de solución para un ciclo de semáforos utilizando el módulo gpiozero: 
   
   
   
                ]]>
            </content>

                            <updated>2022-06-06T08:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">LED parpadeante en el microcontrolador Raspberry Pi</title>
            <id>https://funduinoshop.com/es/led-parpadeante-en-el-microcontrolador-raspberry-pi</id>
            <link href="https://funduinoshop.com/es/led-parpadeante-en-el-microcontrolador-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            A diferencia del Arduino, la Raspberry Pi no tiene acceso a los LED integrados. Sólo indican la alimentación y el acceso a la tarjeta µSD. Para hacer que un LED parpadee, se necesita un LED externo con...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 ¿Cómo se hace parpadear un LED en la Raspberry Pi? 
  A diferencia del Arduino, en la Raspberry Pi no tienes acceso a los LED integrados. Sólo indican la alimentación y el acceso a la tarjeta µSD.  
 Para hacer que un LED parpadee, necesitas un LED externo con una resistencia en serie adecuada y cables de puente. La forma más sensata de montar el circuito es en una protoboard con un T-cobbler. Este tipo de disposición también facilita los experimentos posteriores con varios LED, botones y sensores. La programación se realiza en el lenguaje de programación Python. 
 El esquema del circuito (LED parpadeante en la Raspberry Pi) 
   
 ¿Qué es un LED? 
 LED significa Diodo Emisor de Luz. La última palabra indica las propiedades electrónicas. Un diodo es un semiconductor que sólo deja pasar la corriente en un sentido y la bloquea en el otro. Las dos &quot;patas&quot; se llaman ánodo y cátodo. Si te fijas bien, verás que las patas tienen longitudes diferentes. La tensión positiva se aplica a la pata más larga, el ánodo; la pata más corta, el cátodo, está conectada a masa mediante una resistencia. La resistencia es necesaria debido a otra propiedad de los diodos. En primer lugar, se necesita una tensión mínima para que pueda fluir la corriente: Esto se denomina tensión directa. A tensiones más altas, el diodo se vuelve totalmente conductor. Por eso necesitas una resistencia en serie para limitar la corriente, porque los pines del microcontrolador y también de la Raspberry Pi deben cargarse con un máximo de 15 a 20 mA. Utilizamos resistencias en serie en el rango de 100 a 330 Ω (Ohm). 
 El lenguaje de programación Python puede ampliarse mediante módulos de programa, de forma similar a C/C++ con las bibliotecas. Para nuestro LED parpadeante, necesitamos dos de estos módulos: en primer lugar, &quot;tiempo&quot; para definir la duración del parpadeo. Y en segundo lugar, un módulo para acceder a los GPIOs (General Purpose Input/Output). 
 ¿Cómo controlo un LED con una Raspberry Pi? 
 La importación de los módulos se hace al principio del programa Python; tienes varias opciones para hacerlo. Ejemplos: 
 La siguiente línea importa el módulo  tiempo : 
  import   tiempo  
 Cuando llames al método  dormir  , el nombre del módulo  tiempo  debe ir precedido de un punto: 
  time  .sleep  (1 ) 
 A diferencia de delay(), donde el intervalo de tiempo se da como argumento en milisegundos, con time.  sleep()  los valores se dan en segundos, si es necesario con un punto decimal. 
  importar  RPi.GPIO  como  GPIO 
 Esto simplifica las llamadas a los métodos del programa, por ejemplo 
  GPIO  .setmode  (GPIO  .BCM ) 
 Tercer ejemplo para otro módulo de acceso GPIO: 
 from gpiozero  import  LED 
 Sólo se importa la clase LED del módulo  gpiozero . Con este método de importación, ya no se antepone el nombre del módulo cuando se llama al método/función. 
 Programas de ejemplo para controlar un LED con un microcontrolador Raspberry Pi 
 Primer ejemplo con el módulo RPi.GPIO: 
 import RPi.GPIO as GPIO
importar  tiempo 
GPIO.setmode(GPIO.BCM) # Nombre del pin para el procesador Broadcomm 
GPIO.setup (26 ,GPIO.OUT) # GPIO26 (=pin 37) se convierte en salida 

 while  True: # Bucle sin fin, cancelar con Ctrl-C 
    GPIO .output  (26  ,1 ) # GPIO 26 se  pone en ALTO 
    time  .sleep  (1 )
    GPIO . salida (26  , 0) #  GPIO 26 pasa a BAJO
    time  . sleep ( 1)
 
 Segundo ejemplo con el módulo gpiozero. Sólo se importan  LED  y  sleep . 
  from  gpiozero import LED
 from   tiempo  import  sueño 
redLED = LED (26 ) # redLED se instancia en el GPIO  26  

 mientras   sea True :
    redLED.on() #  redLED se enciende 
    dormir  (1 )
    redLED.off() # redLED  está apagado 
    dormir  ( 1)
 
 Reto: Ampliar el circuito y programarlo para un ciclo de semáforo, por ejemplo, rojo(3s), rojo/amarillo(1s), verde(3s), amarillo(1s), reiniciar con rojo. 
 Solución sugerida ver nº 02 El intermitente alterno 
                ]]>
            </content>

                            <updated>2022-06-01T00:45:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Primeros pasos con la Raspberry Pi - Parte 3: Programación</title>
            <id>https://funduinoshop.com/es/primeros-pasos-con-la-raspberry-pi-parte-3-programacion</id>
            <link href="https://funduinoshop.com/es/primeros-pasos-con-la-raspberry-pi-parte-3-programacion"/>
            <summary type="html">
                <![CDATA[
                
                                            Básicamente, también puedes instalar el IDE de Arduino en la Raspberry Pi o utilizar el programa preinstalado Geany, un editor muy funcional, en varios lenguajes de programación.....
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 En principio, también puedes instalar el IDE de Arduino en la Raspberry Pi o programar en varios lenguajes de programación con el programa preinstalado Geany, un editor muy funcional, pero la Raspberry Pi toma su nombre del lenguaje de programación Python; originalmente, sólo estaba prevista como  intérprete de   Python . Por tanto: quien dice programar la Raspberry Pi suele referirse al lenguaje Python, muy extendido y fácil de aprender. 
 En los últimos años, el programa Thonny se ha establecido como un Entorno de Desarrollo Integrado (IDE) para  programas Python. 
 &amp;nbsp;  
 Se distingue básicamente entre el editor de la parte superior de la ventana, donde se escriben los programas, y el shell de la parte inferior, donde se ejecutan los programas con sus posibles entradas y salidas. Sin embargo, también puedes introducir comandos cortos directamente en el intérprete de comandos. 
 Los programadores avanzados deben hacer clic en &quot;Cambiar al modo normal&quot;, en la parte superior derecha de la pantalla, para que se muestre también la barra de menús. 
 &amp;nbsp;  
 Si quieres aprender el lenguaje de programación de forma autodidacta, puedes hacerlo con la ayuda de un gran número de libros. En este punto, se recomienda el método &quot;aprender haciendo&quot;, es decir, copiar simplemente los ejemplos de programación. La mayor parte del código del programa se explica por sí mismo. Esa es la belleza de Python. 
 Para evitar frustraciones innecesarias, hay que mencionar algunas reglas en este punto, que están dirigidas principalmente a los que cambian de Arduino C/C++: 
 A diferencia de C/C++, no es necesario declarar el tipo de variable. Python reconoce el tipo la primera vez que se utiliza. Si introduces type  (&quot;abc&quot;)  en el intérprete de comandos, por ejemplo, obtendrás como salida &amp;lt;clase &#039;str&#039;&amp;gt;; la cadena de tipo se reconoce por las comillas. 
 La línea de comandos no se termina con punto y coma. En su lugar, Python exige una cuidadosa atención a la sangría. Así: cada comando comienza siempre en la primera posición del párrafo. 
 Se hacen sangrías (normalmente tabulador=cuatro espacios) (normalmente de forma automática) para las ramas, bucles o funciones autodefinidas, posiblemente varias veces. 
 Los nombres de programas y variables empiezan siempre por una letra o el guión bajo _. Después también se pueden utilizar números. El guión bajo es el único carácter especial permitido y suele utilizarse con fines especiales. 
 Lo dicho: más explicaciones sobre Python con los ejemplos de programas. 
                ]]>
            </content>

                            <updated>2022-05-24T11:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Primeros pasos con la Raspberry Pi - Parte 2: Hardware y software</title>
            <id>https://funduinoshop.com/es/primeros-pasos-con-la-raspberry-pi-parte-2-hardware-y-software</id>
            <link href="https://funduinoshop.com/es/primeros-pasos-con-la-raspberry-pi-parte-2-hardware-y-software"/>
            <summary type="html">
                <![CDATA[
                
                                            Una breve introducción a los componentes más importantes para la Raspberry Pi. Ya sea un cable enchufable, una resistencia o un LED, te mostramos qué componentes necesitas para empezar. También nos adentramos en la instalación del software para la Raspberry Pi y...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Hardware y software para la Raspberry Pi 
 Hardware para la Raspberry Pi 
     
 Accesorios básicos para la Raspberry Pi 
 Además de sensores y actuadores, necesitas los cables enchufables &amp;nbsp;&amp;nbsp; junto con una protoboard&amp;nbsp; como base para realizar montajes experimentales rápidos y flexibles. Esto ahorra el laborioso trabajo de soldadura. Además, los diodos emisores de luz &amp;nbsp;&amp;nbsp; son muy adecuados para comprobar la salida de señal de la placa. 
 La protoboard 
 Una protoboard es una buena herramienta para construir circuitos sin soldar. En una protoboard, siempre hay varios contactos conectados en fila. Por tanto, se pueden conectar muchos cables entre sí en estos puntos sin tener que soldarlos o atornillarlos. 
 La siguiente imagen muestra en color qué contactos están conectados entre sí. 
 &amp;nbsp;  
 Placa enchufable estándar para Raspberry Pi y microcontrolador.   Las líneas verdes de la imagen muestran el recorrido de los conductores. 
 Para una buena conexión de la Raspberry Pi a la protoboard, existen los llamados T-cobbler con un cable plano que lleva hacia fuera los 40 pines. 
   
 Diodo emisor de luz (LED) para la Raspberry Pi 
 Con los LED puedes comprobar muy rápidamente los resultados de un proyecto. Por eso son útiles para casi todos los proyectos Arduino. Puedes leer mucho sobre los LED en la red. Aquí tienes sólo la información más importante. 
   
 
 La corriente sólo puede circular por el LED en una dirección. Por tanto, debe conectarse correctamente. Un LED tiene un contacto más largo y otro más corto. El contacto más largo es + y el más corto es -. 
 Un LED está diseñado para una tensión determinada. Si esta tensión es inferior, el LED se ilumina menos o permanece apagado. Sin embargo, si se supera la tensión, el LED se quema muy rápidamente y se calienta mucho en los contactos (¡ATENCIÓN!). 
 Valores típicos de tensión según los colores del LED Azul:3,1V, Blanco:3,3V, Verde:3,7V, Amarillo:2,2V, Rojo:2,1V La tensión en los puertos digitales de la placa es de 5V. Cuando se conectan directamente a estos puertos, cada LED abandona el fantasma con bastante rapidez. Por tanto, hay que conectar una resistencia al circuito. Hay muy buena ayuda en Internet bajo el término de búsqueda &quot;resistencia calculadora LED&quot;. 
 Recomendación no vinculante de resistencias para los siguientes LED (cuando se conectan a los pines de 5 V de la placa del microcontrolador.   
 
 
 
 
 LED 
 Blanco 
 Rojo 
 Amarillo 
 Verde 
 Azul 
 Infrarrojo (IR) 
 
 
 Resistencia 
 100 ohmios 
 200 ohmios 
 200 ohmios 
 100 ohmios 
 100 ohmios 
 100 ohmios 
 
 
 
 &amp;nbsp; 
 Cable enchufable o de puente para la Raspberry Pi 
 Los cables de puente están disponibles en diferentes versiones, la mayoría de 10 cm o 20 cm de longitud, tanto con clavijas como con enchufes. Aquí mm=macho-macho=conector en ambos lados, mf=macho-hembra=conector en un lado, enchufe en el otro, y ff=hembra-hembra= con enchufes en ambos lados. 
   
 Botones e interruptores para la Raspberry Pi 
 El primer sensor, y el más sencillo, es el botón, un interruptor accionado por resorte que vuelve a abrir el contacto eléctrico cuando se suelta. 
   
 Software para la Raspberry Pi 
 El sistema operativo Raspberry Pi OS puede descargarse gratuitamente de la  página web de la Fundación Raspberry Pi . La versión de 32 bits es actualmente idéntica para todos los modelos. Para escribir en la tarjeta µSD (de 8 a 32 GB) del PC, se recomienda el programa Imager, que también se puede descargar de la página web de la Fundación. 
 Instalación del software 
   
 Puesta en marcha de la Raspberry Pi 
 Durante la primera puesta en marcha, se configura el sistema operativo. Entre otras cosas, se introducen los datos de acceso a la WLAN local. Desde primavera, ya no se utiliza automáticamente el nombre de usuario pi, sino que se te pide que introduzcas un nombre de usuario y una contraseña. Tras un reinicio al final de la inicialización, se inicia una interfaz gráfica de usuario. Este proceso dura algo más de un minuto. 
 Cuando haces clic en el icono, se te pregunta si sólo quieres que se muestren las posibles actualizaciones o si quieres iniciarlas directamente. 
 La siguiente captura de pantalla se tomó con el programa preinstalado &quot;scrot&quot; (para captura de   pantalla ). 
 &amp;nbsp;  
                ]]>
            </content>

                            <updated>2022-05-22T12:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Primeros pasos con la Raspberry Pi - Parte 1: El prefacio</title>
            <id>https://funduinoshop.com/es/primeros-pasos-con-la-raspberry-pi-parte-1-el-prefacio</id>
            <link href="https://funduinoshop.com/es/primeros-pasos-con-la-raspberry-pi-parte-1-el-prefacio"/>
            <summary type="html">
                <![CDATA[
                
                                            Esta guía pretende servir de base para el aprendizaje del sistema operativo Raspberry Pi OS, centrándose en el lenguaje de programación Python. Pretende proporcionar a los principiantes una guía fácil, interesante y...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  ¿Qué es &quot;Raspberry Pi&quot;?  
 Esta guía pretende servir de base para el aprendizaje del sistema operativo Raspberry Pi, centrándose en el lenguaje de programación Python. Pretende ofrecer a los principiantes una introducción sencilla, interesante y guiada de cerca a los temas del &quot;pensamiento computacional&quot; y la &quot;informática física&quot;. El manual está orientado principalmente a tareas prácticas, con una introducción teórica previa. Es imprescindible leerlo previamente para no fracasar en las tareas prácticas posteriores debido a trivialidades. 
 Este manual se elaboró en el contexto de una actividad docente. Puede utilizarse gratuitamente para aprender los conceptos básicos sobre los ordenadores Raspberry Pi, pero no puede copiarse ni utilizarse de ninguna otra forma sin permiso. El manual se ha elaborado cuidadosamente y se mantiene continuamente, pero no se garantiza su exactitud e integridad. 
 Para las tareas prácticas, debes disponer de algunos componentes electrónicos. En el sitio web funduinoshop.de puedes pedir conjuntos de sensores adecuados, especialmente diseñados para estas instrucciones. 
 A diferencia del microcontrolador (por ejemplo, Funduino Uno o Nano), la Raspberry Pi, que actualmente cuenta con un gran número de modelos diferentes, es un auténtico ordenador con un sistema operativo basado en Linux (Raspberry Pi OS, antes Raspbian). El sistema operativo, así como los programas de aplicación y los datos, están en una tarjeta µSD (de 8 a 32 GB), que se carga al arrancar. Las interfaces más importantes son inicialmente las tomas USB para el teclado y el ratón y la(s) interfaz(es) HDMI para el monitor.    
 Raspberry Pi B (2012) 
 El gran éxito de la Raspberry Pi se basa tanto en la programación con el lenguaje de programación Python, ampliamente utilizado, como en la posibilidad de conectar componentes electrónicos al cabezal J6 de 40 patillas (a menudo llamado regleta GPIO). Esto es idéntico en todos los modelos desde 2014. En cuanto a la nomenclatura, debes tener cuidado si te refieres al pin físico (en la imagen de la izquierda los números impares del 1 al 39, a la derecha los pares del 2 al 40) o a la designación GPIO. Por ejemplo, el pin físico 11 se corresponde con el GPIO17 (conector General Purpose Input Output 17 del procesador). Por tanto, los GPIO son entradas o salidas digitales, como en el microcontrolador. 
   
 Imagen de la cabecera J6: 40 patillas, de las cuales 2x3,3V, 2x5V, 8xGround, 26xGPIOs, 2 reservadas 
  Algunos de los pines tienen una asignación secundaria como interfaz electrónica, por ejemplo, One Wire en el pin 7, I2C (= Circuito Integrado) en los pines 3 y 5, UART (= Receptor y Transmisor Asíncrono Universal) en los pines 8 y 10 y SPI (= Interfaz Periférica Serial) en los pines 19, 21, 23 y 24 o 26. Esta asignación secundaria se define en el sistema operativo en la configuración de la Raspberry Pi. Más información en los ejemplos correspondientes. 
                ]]>
            </content>

                            <updated>2022-05-19T13:30:00+02:00</updated>
                    </entry>

    
</feed>
