<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://funduinoshop.com/es/blog/?sAtom=1" rel="self" type="application/atom+xml" />
    <author>
        <name>Funduinoshop</name>
    </author>
    <title>Blog / Atom Feed</title>
    <id>https://funduinoshop.com/es/blog/?sRss=1</id>
    <updated>2026-05-09T08:30:44+02:00</updated>
    
        <entry>
            <title type="text">WRO Alemania Final 2025</title>
            <id>https://funduinoshop.com/es/wro-alemania-final-2025</id>
            <link href="https://funduinoshop.com/es/wro-alemania-final-2025"/>
            <summary type="html">
                <![CDATA[
                
                                            Este año hemos vuelto a exponer en la final alemana de la Olimpiada Mundial de Robots, esta vez del 27 al 28 de junio de 2025 en la Westfalenhalle de Dortmund.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Un año más, tuvimos el honor de exponer en la final alemana de la World Robot   Robot   - esta vez   los días 27 y 28 de junio de 2025   en   el Westfalenhalle   Dortmund. Ya estuvimos en la salida de Passau en 2024, y fue una gran experiencia para nosotros   gran   Sensación formar parte de esta especial (y   (¡y en constante crecimiento!)   Evento por segunda vez.   
 
 
       
   Hemos reunido un número increíble de impresiones y   grandes   Tuvimos grandes conversaciones, especialmente con niños y jóvenes de todas las edades. El entusiasmo y la curiosidad con que se acercan a la tecnología y la robótica es sencillamente contagioso y una verdadera alegría. Para nosotros, la final no sólo fue emocionante, sino también absolutamente enriquecedora.   
 
 
   Nos gustaría aprovechar esta oportunidad para elogiar a Markus   Fleige   y a su equipo, que una vez más hicieron un gran trabajo organizando el evento. Se notaba en todo momento que el evento se había hecho con el corazón y el alma.   
 
 
   En la   Funduino  -Presentamos algunos de nuestros productos, como el Starter Kit   y el Cubo   el   Unitree   Go2. El joven público se mostró especialmente entusiasmado, haciendo innumerables preguntas y maravillándose ante el perro con ojos brillantes.   
 
 
   En general, fue un fin de semana muy fructífero, lleno de inspiración, diálogo y grandes encuentros. Estamos agradecidos de haber estado allí, ¡y ya estamos deseando que llegue la próxima vez!   
    Tu equipo de Funduino       
 &amp;nbsp; 
 
 
                ]]>
            </content>

                            <updated>2025-08-22T11:45:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Foro Europeo de Robótica 2025</title>
            <id>https://funduinoshop.com/es/foro-europeo-de-robotica-2025</id>
            <link href="https://funduinoshop.com/es/foro-europeo-de-robotica-2025"/>
            <summary type="html">
                <![CDATA[
                
                                            Del 25 al 27 de marzo de 2025, estuvimos representados en el Foro Europeo de Robótica de Stuttgart, uno de los puntos de encuentro más importantes para los expertos en robótica de toda Europa.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Desde     25. al 27 de marzo de 2025     estuvimos en el     Foro Europeo de Robótica de Stuttgart     uno de los puntos de encuentro más importantes para los expertos en robótica de toda Europa.   
 
 
   En esta ocasión   estuvimos allí exclusivamente con los     Brazos robóticos de   Dobot     i  n el Centro de Cultura y Congresos de   Stuttgart   y pudimos presentarlos a un público internacional de expertos. Para nosotros, fue una oportunidad apasionante de demostrar las versátiles posibilidades de aplicación del   Dobot  -En directo y entablar un diálogo con los visitantes interesados.   
 
 
       
   La respuesta fue magnífica: muchos expertos de la investigación, la industria y la educación aprovecharon la oportunidad para ver los robots en acción. Nos complació especialmente el asombro y el entusiasmo que pudimos sentir en nuestro stand, ya fuera durante el primer encuentro o en los intensos debates técnicos que siguieron.   
 
 
   Volvemos a casa desde Stuttgart con muchas impresiones nuevas. Fue especialmente valioso para nosotros formar parte de esta red internacional y presentar los   Dobots   a un público especializado tan amplio. Los debates y las reacciones nos animan a seguir promoviendo activamente la robótica en la educación y la práctica. Para nosotros, la primera aparición en el     Foro Europeo de Robótica     ha sido un paso importante para nosotros, y sin duda no será el último.   
    Tu equipo de Funduino   
       
 
 
                ]]>
            </content>

                            <updated>2025-08-22T11:30:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Didacta 2025 en Stuttgart</title>
            <id>https://funduinoshop.com/es/didacta-2025-en-stuttgart</id>
            <link href="https://funduinoshop.com/es/didacta-2025-en-stuttgart"/>
            <summary type="html">
                <![CDATA[
                
                                            Del 11 al 15 de febrero de 2025, volvimos a estar representados en Didacta, en Stuttgart, y como en años anteriores, la feria volvió a estar a la altura de sus promesas.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Desde     11. al 15 de febrero de 2025     estuvimos una vez más en la     Didacta de Stuttgart     y, como en años anteriores, la feria ha vuelto a   una vez más   una vez más   cumplido lo prometido  .   
 
 
   Pudimos mantener muchas conversaciones apasionantes   con vosotros y nos alegró mucho el gran interés que despertaron nuestros productos. Presentamos una colorida mezcla en nuestro stand: desde nuestro   nuestro   clásico     Funduino  -Productos     hasta el     Dobot  -Brazos robóticos     hasta    Cortadoras láser de flujo    . Fue especialmente agradable ver que visitantes de todas las edades se mostraban entusiasmados con nuestra tecnología: desde alumnos curiosos hasta profesores experimentados. Es precisamente este diálogo con tantas personas diferentes lo que hace que Didacta sea tan especial para nosotros.   
     
 
 
   Un verdadero acontecimiento este año   w  fue   el     Unitree   Go2    . El ágil perro robot atrajo inmediatamente la atención de todos, hizo que se iluminaran los ojos y se convirtió en un reclamo para la multitud. Se hicieron muchas fotos y muchos aprovecharon la oportunidad para interactuar con él. El entusiasmo   era francamente   era palpable, y nosotros también lo disfrutamos mucho.   
 
 
     
   Podemos echar la vista atrás a cinco días intensos en la feria, llenos de inspiración, diálogo y nuevas ideas. Además de muchas impresiones, también nos llevamos   EUER   valiosos comentarios y nuevos impulsos que nos animarán en nuestro trabajo. Muchas gracias a todos los que nos visitasteis: hicisteis de Didacta 2025 un acontecimiento muy especial para nosotros   muy   una experiencia muy especial para nosotros. ¡Ya estamos deseando volver a veros el año que viene!   
 &amp;nbsp; 
 
 
    Vuestro equipo   de   Funduino    
 
 
                ]]>
            </content>

                            <updated>2025-08-22T11:15:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">LED Halloween Kürbis</title>
            <id>https://funduinoshop.com/es/led-halloween-kuerbis</id>
            <link href="https://funduinoshop.com/es/led-halloween-kuerbis"/>
            <summary type="html">
                <![CDATA[
                
                                            Halloween steht kurz bevor und das Gruselfieber steigt. Daher ist es allerhöchste Zeit, uns in diesem Jahr einen echt gruseligen (oder niedlichen?) Kürbis zu basteln. 
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  LED&amp;nbsp;Halloween&amp;nbsp;Kürbis  
 Halloween steht kurz bevor und das Gruselfieber steigt. Daher ist es allerhöchste Zeit, uns in diesem Jahr einen echt gruseligen (oder niedlichen?) Kürbis zu basteln.&amp;nbsp; 
 Wie Ihr alle wisst, wird traditionell ein Gesicht in einen ausgehölten Kürbis geschnitzt und anschließend von Innen mit einer Kerze beleuchtet. Doch leider hält der Kürbis nur wenige Tage und die Kerze brennt häufig zu schnell aus.  Glück für uns Tüftler: Mit einem 3D-gedruckten Kürbis und einem LED-Ring können wir uns schnell Abhilfe schaffen. Dieser kann die ganze Nacht durchleuchten und länger.&amp;nbsp; 
   
  Bauanleitung  
  Materialien:  
 
  3D-Drucker  
  3D-Modell&amp;nbsp;des&amp;nbsp;Kürbisses  
 
 &amp;nbsp; 
  Schritt&amp;nbsp;1: Kürbis 3D-Modell&amp;nbsp;ausdrucken  
 Lade&amp;nbsp;dir&amp;nbsp;das&amp;nbsp; 3D-Modell&amp;nbsp;des&amp;nbsp;Kürbis &amp;nbsp;herunter&amp;nbsp;und&amp;nbsp;drucke&amp;nbsp;es&amp;nbsp;mit&amp;nbsp;deinem&amp;nbsp;3D-Drucker&amp;nbsp;aus. 
   Schritt&amp;nbsp;2:&amp;nbsp;Elektronik&amp;nbsp;zusammenbauen  
 Stecke&amp;nbsp;die&amp;nbsp;Kabel&amp;nbsp;des&amp;nbsp;LED-Rings&amp;nbsp;an&amp;nbsp;den&amp;nbsp;Arduino&amp;nbsp;kompatiblen&amp;nbsp;Nano.&amp;nbsp;Verbinde&amp;nbsp;dann&amp;nbsp;den&amp;nbsp;Nano&amp;nbsp;mit&amp;nbsp;einem&amp;nbsp;USB-Kabel&amp;nbsp;mit&amp;nbsp;deinem&amp;nbsp;Computer.&amp;nbsp; 
   
  Schritt&amp;nbsp;3:&amp;nbsp;Code&amp;nbsp;übertragen  
 Öffne&amp;nbsp;die&amp;nbsp;Arduino&amp;nbsp;IDE&amp;nbsp;und&amp;nbsp;füge&amp;nbsp;den&amp;nbsp;folgenden&amp;nbsp;Code&amp;nbsp;ein: 
 # include &amp;nbsp;&amp;lt;Adafruit_NeoPixel.h&amp;gt;&amp;nbsp;//&amp;nbsp;Die&amp;nbsp;Adafruit&amp;nbsp;NeoPixel&amp;nbsp;Bibliothek&amp;nbsp;wird&amp;nbsp;verwendet&amp;nbsp;um&amp;nbsp;den&amp;nbsp;LED-Ring&amp;nbsp;anzusteuern 
 # ifdef &amp;nbsp;__AVR__ 
 # include &amp;nbsp;&amp;lt;avr/power.h&amp;gt; 
 # endif  
 # define &amp;nbsp;PIN&amp;nbsp;5&amp;nbsp;//&amp;nbsp;Datenleitung&amp;nbsp;an&amp;nbsp;Pin&amp;nbsp;5 
 Adafruit_NeoPixel&amp;nbsp;strip&amp;nbsp;=&amp;nbsp;Adafruit_NeoPixel(8,&amp;nbsp;PIN,&amp;nbsp;NEO_GRB&amp;nbsp;+&amp;nbsp;NEO_KHZ800);&amp;nbsp;//&amp;nbsp;In&amp;nbsp;diesem&amp;nbsp;Beispiel&amp;nbsp;sind&amp;nbsp;am&amp;nbsp;LED&amp;nbsp;Ring&amp;nbsp;8&amp;nbsp;Pixel. 
 void&amp;nbsp;setup()&amp;nbsp;{ 
 &amp;nbsp;&amp;nbsp;strip.begin(); 
 &amp;nbsp;&amp;nbsp;strip.show();&amp;nbsp;//&amp;nbsp;Alle&amp;nbsp;Pixel&amp;nbsp;zu&amp;nbsp;Beginn&amp;nbsp;ausschalten 
 } 
 void&amp;nbsp;loop()&amp;nbsp;{ 
 &amp;nbsp;&amp;nbsp;for&amp;nbsp;(int&amp;nbsp;i&amp;nbsp;=&amp;nbsp;0;&amp;nbsp;i&amp;nbsp;&amp;lt;&amp;nbsp;strip.numPixels();&amp;nbsp;i++)&amp;nbsp;{ 
 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;strip.setPixelColor(i,&amp;nbsp;strip.Color(255,&amp;nbsp;random(100,183),&amp;nbsp;random(20)));&amp;nbsp;//&amp;nbsp;Die&amp;nbsp;Pixel&amp;nbsp;leuchten&amp;nbsp;jeweils&amp;nbsp;rot-orange&amp;nbsp;in&amp;nbsp;zufälligen&amp;nbsp;Farben 
 &amp;nbsp;&amp;nbsp;} 
 &amp;nbsp;&amp;nbsp;strip.show(); 
 &amp;nbsp;&amp;nbsp;delay(random(100)); 
 } 
 Klicke&amp;nbsp;dann&amp;nbsp;auf&amp;nbsp;die&amp;nbsp;Schaltfläche&amp;nbsp;&quot;Hochladen&quot;,&amp;nbsp;um&amp;nbsp;den&amp;nbsp;Code&amp;nbsp;auf&amp;nbsp;den&amp;nbsp;Arduino&amp;nbsp;kompatiblen&amp;nbsp;Nano&amp;nbsp;zu&amp;nbsp;übertragen. 
 &amp;nbsp; 
  Schritt&amp;nbsp;4:&amp;nbsp;LED-Ring&amp;nbsp;in&amp;nbsp;den&amp;nbsp;Kürbis&amp;nbsp;einsetzen  
 Lege&amp;nbsp;den&amp;nbsp;LED-Ring&amp;nbsp;in&amp;nbsp;den&amp;nbsp;Kürbis&amp;nbsp;und&amp;nbsp;stecke&amp;nbsp;die&amp;nbsp;Kabel&amp;nbsp;durch&amp;nbsp;die&amp;nbsp;Öffnung&amp;nbsp;in&amp;nbsp;dem&amp;nbsp;Kürbis. 
 Fertig! 
 Jetzt&amp;nbsp;kannst&amp;nbsp;du&amp;nbsp;deinen&amp;nbsp;Halloween&amp;nbsp;Kürbis&amp;nbsp;mit&amp;nbsp;dem&amp;nbsp;LED-Ring&amp;nbsp;bewundern.    
 &amp;nbsp; 
                ]]>
            </content>

                            <updated>2025-08-21T22:15:00+02:00</updated>
                    </entry>

    
    
        <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">Construye un coche teledirigido con Arduino: Vehículo autónomo - Parte 3</title>
            <id>https://funduinoshop.com/es/construye-un-coche-teledirigido-con-arduino-vehiculo-autonomo-parte-3</id>
            <link href="https://funduinoshop.com/es/construye-un-coche-teledirigido-con-arduino-vehiculo-autonomo-parte-3"/>
            <summary type="html">
                <![CDATA[
                
                                            Bienvenido a la tercera entrega de nuestra serie de blogs sobre coches robot. En la primera parte, aprendimos los fundamentos del vehículo básico. En la segunda parte, desarrollamos un sistema de código universal que podemos utilizar para establecer los niveles de conducción d...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Comprender la movilidad del futuro con los coches robot, parte 3  
 Bienvenido a la tercera entrega de nuestra serie de blogs sobre coches robot. En la   primera parte  &amp;nbsp;conocimos los fundamentos del vehículo básico. En la   segunda parte  &amp;nbsp;desarrollamos un sistema de código universal para definir los pasos de conducción del coche robot y realizamos un sencillo control remoto con un mando a distancia por infrarrojos. Debido a las limitaciones físicas de este mando a distancia, me gustaría mostrar en este episodio la transmisión de instrucciones de conducción con Bluetooth, por ejemplo, desde un smartphone al receptor BT HC-05. Bluetooth es una señal de radio de 2,4 GHz de corto alcance. Es seguro hasta unos 10 m y no produce interferencias bajo la luz del sol. 
 El módulo Bluetooth HC-05 es en realidad un  transceptor=transmisor + receptor . Sin embargo, nosotros sólo lo utilizamos como receptor, para enviar las instrucciones de conducción utilizamos una APP Bluetooth en un smartphone Android (debido a la forma especial de Apple con el Bluetooth, no funciona con un iPhone). En principio, también es posible construir un mando a distancia Bluetooth con el HC-05; sin embargo, para ello se necesita un segundo HC-05, otro microcontrolador y un dispositivo de entrada (mando joystick). 
 &amp;nbsp;  
  De los seis pines del módulo HC-05, sólo se necesitan cuatro: VCC (5V) y GND para la alimentación del módulo, y RXD y TXD para la conexión a dos pines del microcontrolador donde se configura el SoftwareSerial. Sin embargo, no puedes ignorar la inscripción NIVEL: 3,3V para no dañar el módulo. En nuestro microcontrolador con lógica de 5V, necesitamos un divisor de tensión de 5V a 3,3V al menos para el pin RXD, por ejemplo, resistencias de 1 kOhm y 2,2 kOhm. 
 Esquema del circuito: Módulo HC-05 en el microcontrolador    
 Los comandos AT del módulo HC-05 para microcontroladores Arduino 
 A la izquierda del conector marcado como Key hay un pequeño botón que es importante para la configuración. Si se pulsa este botón al encender el módulo, entramos en el modo de comandos AT (el LED parpadea lentamente a un ritmo de 2s), en el que realizamos la configuración con los llamados comandos AT (por Atención, Achtung). Para ello utilizamos un programa de ejemplo modificado, en el que la interfaz serie habitual se conecta al Monitor serie del IDE Arduino y al HC-05 mediante SoftwareSerial. 
  /*
  SoftwareSerial Prueba serie múltiple
 Recibe del hardware serie, envía al software serie.
 Recibe del software serie, envía al hardware serie.
 El circuito:
 * RX es el pin digital 10 (conectar a TX de otro dispositivo)
 * TX es el pin digital 11 (conectar a RX de otro dispositivo) // ¡divisor de tensión!
 creado en la noche de los tiempos
 modificado el 25 de mayo de 2012
 por Tom Igoe
 basado en el ejemplo de Mikal Hart
 Este código de ejemplo es de dominio público.
 */ 
  #include   &amp;lt;SoftwareSerial.h&amp;gt;  
 SoftwareSerial  BTSerial (10 ,  11 );  // RX, TX // mySerial cambiado a BTSerial 
 char  c= &#039; &#039; ;  // Declaración de variable para transmisión 

 void   setup () {
   // Open serial communications and wait for port to open: 
   Serial . begin ( 9600 );                                                                                    // Baud rate changed to 9600 
   Serial . println ( &quot;Serial started!&quot; );

   // set the data rate for the SoftwareSerial port 
  BTSerial. begin ( 38400 );                                                                             // Baud rate for BT 38400 
   Serial . println ( &quot;BTSerial started!&quot; );
}

 void   bucle () {  // ejecutar una y otra vez 
  if  (BTSerial . available()) {
    c=BTSerial. read ();
     Serial . write (c);
  }
  if  (Serial  .available ()) {
    c= Serial . read ();
    BTSerial. write (c);
     Serial . write (c);                                                                                        // re-transmission of input in Serial Monitor 
  }
} 
 En la siguiente imagen se utilizan los comandos AT esenciales. La estación remota, el HC-05, envía una respuesta si es necesario y acusa recibo con OK. 
 Nos interesan principalmente el nombre y la dirección HEX para identificar de forma única el módulo más adelante en el smartphone. Los comandos AT se introducen en el monitor serie del microcontrolador. En la siguiente imagen puedes ver el monitor serie del IDE Arduino. 
 Si quieres, puedes cambiar la contraseña por defecto 1234 con &quot;AT+PSWD=xxxx &quot;, donde x representa un dígito del 0 al 9. A continuación, comprueba con &quot;AT+PSWD? &quot; si la entrada se ha realizado correctamente.    Una vez completadas las entradas, desconecta brevemente el módulo de la fuente de alimentación. Tras volver a encenderlo sin pulsar ningún botón, el módulo HC-05 se encuentra en modo estándar. El LED parpadea rápidamente (unas 5 veces/s). 
 Modificaciones en el coche teledirigido: escudo motor diferente 
 Pasemos ahora al Coche Robot. Después de que la última vez utilizáramos el Controlador de Motor V2, que sólo necesita los dos conectores I2C SDA=A4 y SCL=A5 para las señales de control, esta vez quiero introducir el antiguo Controlador de Motor V1, que bloquea muchos pines digitales, pero que a menudo se puede comprar a precio de ganga.     También he modificado un poco este Motorshield para tener acceso a los sensores y receptores de radio. En el lado de los pines digitales, sólo hay un pin al que se puede acceder mediante un conector acodado: Pin 2. Esto es bueno para quienes quieran conectar aquí el receptor de infrarrojos. Hay más posibilidades de ampliación en el otro lado, donde puedes acceder a todas las entradas analógicas, así como a la fuente de alimentación, con la ayuda de conectores hembra (también llamados conectores de zócalo). 
 Como todas las entradas analógicas también se pueden utilizar como entradas o salidas digitales, aquí tenemos la posibilidad de conectar nuestros receptores de radio. Esto funciona de maravilla con el transceptor de 433 MHz HC-12 (ver próximo episodio), pero para el receptor BT HC-05 sólo con restricciones. En primer lugar, no podemos conectar la patilla RXD directamente, necesitamos el divisor de tensión, y en segundo lugar, las patillas no proporcionan suficiente corriente para alimentar el módulo en estas patillas. 
 La siguiente imagen muestra un pequeño adaptador que hicimos nosotros mismos, que alimenta el HC-05 con 5V y masa desde los pines apropiados, conecta TXD directamente a RX de la interfaz SoftwareSerial A1 =D15 y RXD a A2 = D16 a través del divisor de tensión.   
 El diagrama de cableado: Módulo HC-05 con Motorshield L293D en el microcontrolador Arduino     
 Por supuesto, el circuito también se puede realizar en una mini protoboard con cables de puente. 
 Como la última vez, el código de las instrucciones de conducción aumenta o disminuye pulsando un botón; esta vez, sin embargo, no con el mando a distancia por infrarrojos, sino con la función táctil de la APP del smartphone y la consulta Bluetooth mediante SoftwareSerial. 
 Emparejar el módulo Bluetooth HC-05 con una aplicación Android (APP) 
 Antes de que la APP pueda conectarse al Coche Robot, tenemos que emparejarla con el módulo Bluetooth en los ajustes. Esto debería ser bastante fácil, ya que anteriormente hemos utilizado los comandos AT para consultar el nombre y la dirección HEX del HC-05. 
 Cuando el emparejamiento ha funcionado y se ha instalado una aplicación BT adecuada, se puede iniciar y configurar. Pulsando sobre la lupa de la imagen de la izquierda, se muestran los dispositivos adecuados. Pulsamos sobre el HC-05 y recibimos el mensaje &quot;conectado&quot;. La aplicación que utilizo ofrece varias interfaces para su funcionamiento (imagen central). Decidí utilizar el mando del juego. En la parte superior derecha de la imagen central, hay dos flechas que forman un pequeño círculo. Toca aquí si se ha perdido la conexión. 
 La imagen de la derecha muestra los botones de un mando de juego. Antes de utilizarlos por primera vez, hay que asignar a los botones los valores numéricos que se transmitirán al pulsarlos. 
 Para los botones del cursor he asignado los valores numéricos 1 a 4 en el sentido de las agujas del reloj. A los demás botones les he asignado el valor numérico 5. Estos valores se pasan en el boceto a la variable  blueToothVal &amp;nbsp;y conducen en los &amp;nbsp;if-pointers de  la función  loop(  ) a la determinación del código para el nivel de conducción.    
 Los cambios de Infrarrojos a Bluetooth y de Controlador de Motor V2 a V1 provocan algunas modificaciones en la parte principal del sketch. En cambio, en la función motor() no cambia casi nada. Sólo en la notación, las funciones motor1-&amp;gt;setSpeed() se convierten ahora en motor1.setSpeed() debido a las diferentes bibliotecas del programa (librerías). 
 El código del programa: Construir un Coche RC para Arduino 
 * Código de ejemplo  para  Coche Robot con Motor Shield V1 y receptor BT   HC-05 , a partir de  20220515 
* basado en la biblioteca Adafruit Motor shield V2, copyright Adafruit Industries LLC
*  este  código es de dominio  público , ¡disfrútalo!
* modificado  para  Funduino
* Pines
* BT VCC a salida de  5V de Arduino.
* BT GND a GND
* Arduino  A1=15  (SS RX) - BT TX no necesita divisor de tensión
* Arduino  A2=16  (SS TX) - BT RX a través de un divisor de tensión (5v a  3,3v )
*/

  #include   &amp;lt;AFMotor.h&amp;gt;  
AF_DCMotor motor1 (2 );
AF_DCMotor motor2 ( 3);

  #include   &amp;lt;SoftwareSerial.h &amp;gt; 
 // Inicializar HC-05 
 SoftwareSerial  BTSerial (15 ,  16 );  // RX, TX cruzar a TX, RX(divisor de tensión) 
 char  blueToothVal;
 int  x =  0 
 int  y =  0 
 int  izquierda =  0 
 int  derecha = 0
 int  código =  5555 
 int  velocidadL =  0 
 float  factor =  1.8 ;  // Corrección para speedLevel 255/100 * 6V/VBatt 

 void   setup () {
   Serial . begin ( 9600 );  // set up Serial Monitor at 9600 bps 
   Serial . println ( &quot;Motor test!&quot; );
  BTSerial. begin ( 9600 );  // set up transmission speed for HC-12 
   Serial . println ( &quot;SoftwareSerial initialized!&quot; );
}  // fin de la configuración 

 void   bucle () {
  if (BTSerial .available ())  //si se reciben datos  ... 
 Serial.print(&quot;disponible&quot;);     
{
    blueToothVal=BTSerial. read (); //..sollen diese ausgelesen werden 
 Serial.println(blueToothVal); 
  }
    if  (blueToothVal== &#039;1&#039; ) //si   el módulo Bluetooth recibe un &quot;1&quot;.... 
   {
       if  (code&amp;lt; 9000 )   code = code +  1000 ;      
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);
    }
    else   if  (blueToothVal== &#039;2&#039; ) //si el módulo Bluetooth recibe un &quot;2  &quot;.... 
   {
       if  ((code -1000 * int (code/ 1000 ))&amp;lt; 900 )  code = code +  100 ;
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);
    }
    else   if  (blueToothVal== &#039; 3&#039;) //si el módulo Bluetooth recibe   un &quot;3&quot;....
   {
       if  (code&amp;gt; 2000 )   code = code -  1000 ;        
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);
    }
    else   if  (blueToothVal== &#039;4&#039; ) //si el módulo Bluetooth recibe un &quot;4  &quot;.... 
    {
     if  (code -1000 * int (code/ 1000 ) &amp;gt;  200 )   code = code -  100 ;
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);
    }  
    else   if  (blueToothVal== &#039; 5&#039;) //si el módulo Bluetooth recibe un  &quot; 5&quot;...
   {           
      code =  5555 ;
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);    
    }
    delay  (200 );  //un poco de retraso para mejorar la comunicación serie y evitar rebotes 
    motor();
}  //fin del bucle 

 void  motor(){
  int  velocidadNivel [9 ]={ -100 , -80 , -60 , -40 , 0 , 40 , 60 , 80 , 100 };
  y =  int (código /  1000 );
  x =  int ((código -  1000*y ) /  100 );
  velocidadL = velocidadNivel [y-1 ];
  Serial  .print ( &quot;código = &quot; );
  Serial  . print(código);
  Serial  . print( &quot; y = &quot;);
  Serial  . print(y);
  Serial  . print(&quot;  x = &quot;);
  Serial  . print(x);
  Serial  . print(&quot;  velocidadL = &quot;);
  Serial  .println (velocidadL);

  //Corrección de los pasos de velocidad para las curvas 
  si   ( x==1){
    right = speedL+ 20 ;
    left = speedL -20 ;
  }
  si   ( x==2){
    right = speedL+ 15 ;
    left = speedL -15 ;
  }
  si  ( x==3 ) {
    right = speedL+ 10 ;
    left = speedL -10 ;
  }
  si  no ( x==4 ) {
    right = speedL+ 5 ;
    left = speedL -5 ;
  }
  si   no   (x==6 ) {
    right = speedL  -5 ;
    left = speedL+ 5 ;
  }
  si   no  ( x==7 ) {
    right = speedL -10 ;
    left = speedL+ 10 ;
  }
  si  ( x==8 ) {
    right = speedL -15 ;
    left = speedL+ 15 ;
  }
  si  ( x==9 ) {
    right = speedL -20 ;
    left = speedL+ 20 ;
  }
  si  no  {
    right = speedL;
    left = speedL;
  }

  //Introducción de los pasos de conducción para &quot;izquierda&quot; y &quot;derecha 
  Serial  .print (&quot;izquierda = &quot; );
  Serial  . print(izquierda);
  Serial  . print( &quot;  derecha = &quot;);
  Serial  .println (derecha);

  si  (izquierda &amp;lt;  40  &amp;amp; izquierda &amp;gt;  -40 ) {
    motor1. run (RELEASE);
  }
  si  (derecha &amp;lt;  40  y derecha &amp;gt;  -40 ) {
    motor2. run (RELEASE);
  }
  si  ( izquierda&amp;gt;=40 ) {
     if  (left&amp;gt; 100 ) left= 100 ;
      motor1. run (FORWARD);
      motor1. setSpeed (left * factor);
  }
  si  ( derecha&amp;gt;=40 ) {
     if  (right&amp;gt; 100 ) right= 100 ;
      motor2. run (FORWARD);
      motor2. setSpeed (right * factor);
  }
  si  (izquierda&amp;lt;=  -40 ) {
     if  (left&amp;lt; -100 ) left= -100 ;
      motor1. run (BACKWARD);
      left = -left;
      motor1. setSpeed (left * factor);
  }
  si  (derecha&amp;lt;=  -40 ) {
     if  (right&amp;lt; -100 ) right= -100 ;
      motor2. run (BACKWARD);
      right = -right;
      motor2. setSpeed (right * factor);
  }
}  // fin motor  
 Hasta aquí la segunda solución más barata para un Coche Robot con mando a distancia (suponiendo que tengas un smartphone Android). La próxima vez mostraré lo fácil que es integrar un transceptor HC-12 de 433 MHz. Con él se pueden conseguir incluso varios cientos de metros de alcance. Sin embargo, los costes aumentan porque ahora se necesitan dos transceptores y otro microcontrolador. Hasta entonces. 
                ]]>
            </content>

                            <updated>2022-06-20T08: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">Construye un coche teledirigido con Arduino: Vehículo autónomo - Parte 2</title>
            <id>https://funduinoshop.com/es/construye-un-coche-teledirigido-con-arduino-vehiculo-autonomo-parte-2</id>
            <link href="https://funduinoshop.com/es/construye-un-coche-teledirigido-con-arduino-vehiculo-autonomo-parte-2"/>
            <summary type="html">
                <![CDATA[
                
                                            Bienvenido a la segunda entrega de nuestra nueva serie de blogs sobre coches robot. En la primera parte, conocimos los fundamentos del vehículo básico. Esta vez queremos hablar de las posibilidades del control remoto, desarrollar un sistema de código...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Comprender la movilidad del futuro con los coches robot, parte 2  
 Bienvenido a la segunda entrega de nuestra nueva serie de blogs sobre coches robot. En la  primera parte , conocimos los fundamentos del vehículo básico. Esta vez queremos hablar de las posibilidades del control remoto, desarrollar un sistema de códigos con el que podamos determinar los niveles de velocidad del coche robot y, por último, realizar un control remoto sencillo con un mando a distancia por infrarrojos. 
 ¿Por qué necesito pasos de velocidad para un coche teledirigido para microcontroladores Arduino? 
 1. Para controlar las velocidades del motor desde otro dispositivo, existe básicamente la posibilidad de determinar y transmitir continuamente valores con un potenciómetro (poti), o de aumentar o disminuir el valor del paso de velocidad pulsando un botón. Las siguientes imágenes muestran algunos ejemplos seleccionados, en la primera imagen controles de joystick: 
 &amp;nbsp;  
 &amp;nbsp; 
 En la segunda imagen vemos mandos a distancia por infrarrojos, una aplicación para smartphone con receptor Bluetooth, y el escudo del teclado LCD1602, que puede funcionar con un transceptor de 433 MHz, entre otras cosas: 
 &amp;nbsp;  
 &amp;nbsp; 
 Para conseguir un esquema uniforme, tiene sentido utilizar la función map() para reducir los valores analógicos de la olla a valores que puedan transmitirse por radio. El convertidor analógico-digital proporciona números de 10 bits, es decir, valores entre 0 y 1023. La posición media de los mini joysticks es aproximadamente 511. Dividiendo el valor por 100, un joystick puede determinar dos valores (dirección x e y) que se encuentran entre 0 y 10 o, si se utiliza la función map()-, entre 1 y 9. Esto es suficiente para introducir la velocidad y para tomar las curvas. Independientemente de si determinamos valores 11 ó 9, la parada significa el valor 5 en la dirección y y para la conducción en línea recta también el valor 5. 
 Mirando el mando con los dos joysticks (parte del  kit del brazo robótico Mini 4DOF con joysticks y servomotor ), dada la variedad de sistemas diferentes, me decido por un código entre 1111 y 9999 que sea fácil de transmitir. El primer dígito se puede utilizar para la dirección y del joystick izquierdo, el segundo dígito para la dirección x del joystick izquierdo, el tercer y cuarto dígitos para un segundo joystick opcional o determinadas teclas. En el primer ejemplo con el mando a distancia por infrarrojos, sólo necesitamos los dos primeros dígitos del código de cuatro cifras. 
 El control de velocidad del Coche teledirigido para Arduino 
 El control de velocidad de los motores se realiza mediante modulación por ancho de pulsos (PWM). El valor del llamado ciclo de trabajo es un número de 8 bits, es decir, un valor entre 0 y 255 (=2 a la potencia de 8 -1). Si aplicas tensiones de entre 0 y 6 V al motor con una fuente de alimentación ajustable, observarás que hasta aproximadamente 1,5 V no se nota nada. Después, el motor empieza a zumbar, pero no se mueve. Si mides la corriente al mismo tiempo, notarás un valor relativamente alto. La energía se convierte en calor y zumbidos, nada bueno. A partir de 2,4 - 3 voltios, el motor empieza a girar, el amperaje baja un poco cuando el motor está descargado. Después, la velocidad aumenta en función de la tensión aplicada. Al regular la tensión a la baja, el motor girará por debajo de 2 voltios, pero si se detiene, por ejemplo debido a un aumento de la resistencia a la fricción o a un obstáculo, no volverá a arrancar. Conclusión: deben evitarse los valores por debajo de 2,4 voltios aproximadamente, la entrada debe ajustarse igual a 0 (cero) para evitar un desgaste y un consumo de energía innecesarios. Excepto para la parada (código=5) necesitamos Duty Cycle entre aprox. 40% y 100% con una tensión de alimentación de 6V para los motores. 
 La fuente de alimentación del Coche RC para Arduino 
 Ya hemos hablado de varias posibilidades para la fuente de alimentación en la primera parte. Cuatro pilas AA de 1,5 V cada una dan 6 V, la tensión máxima de los pequeños motores amarillos. Cuatro pilas AA de 1,2 V cada una no son suficientes para la fuente de alimentación. Entonces necesitas un portapilas para 6 pilas y eso da 7,2 voltios. Y dos pilas de iones de litio (tensión nominal de 3,7 V) dan más de 8 voltios cuando están totalmente cargadas. Así que tiene sentido establecer un factor en el programa que limite la tensión del nivel de accionamiento más alto a 6 V. 
 Control del coche teledirigido por Arduino 
 Si las instrucciones de conducción se dan con botones, que pueden estar incluso en una aplicación de smartphone, se aumenta o disminuye el valor adecuado para el valor de salida 55xx (parada) sin superar el máximo. 
 Leer correctamente el código 
 La asignación del primer dígito del código a los valores requeridos de las etapas de desplazamiento se realiza mediante el índice de una lista con los respectivos valores numéricos. 
 Conclusión: con un código de cuatro dígitos, podemos controlar la velocidad y el paso por curva con los dos primeros dígitos, los dos dígitos posteriores se utilizan para otras funciones (no necesarias al principio). Así, por ejemplo, el código95xx para la mayor velocidad en línea recta, 55xx para la parada, 77xx para el avance hacia la derecha.&amp;nbsp; 
 
 
 
 
 
 y ↓ 0&amp;nbsp; x→ 
 
 
 1 
 
 
 2 
 
 
 3 
 
 
 4 
 
 
 5 
 
 
 6 
 
 
 7 
 
 
 8 
 
 
 9 
 
 
 
 
 9 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  ↑  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 8 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  ↑  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 7 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  ↑  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 6 
 
 
 ← 
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
 ↑ 
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
 → 
 
 
 
 
 5 
 
 
 ← 
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  0  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
 → 
 
 
 
 
 4 
 
 
 ← 
 
 
 &amp;nbsp; 
 
 
 ↙ 
 
 
 &amp;nbsp; 
 
 
 ↓ 
 
 
 &amp;nbsp; 
 
 
 ↘ 
 
 
 &amp;nbsp; 
 
 
 → 
 
 
 
 
 3 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 
  ↙  
 
 
 &amp;nbsp; 
 
 
  ↓  
 
 
 &amp;nbsp; 
 
 
  ↘  
 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 2 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 
  ↙  
 
 
 &amp;nbsp; 
 
 
  ↓  
 
 
 &amp;nbsp; 
 
 
  ↘  
 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 1 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 
  ↙  
 
 
 &amp;nbsp; 
 
 
  ↓  
 
 
 &amp;nbsp; 
 
 
  ↘  
 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 
 &amp;nbsp; 
 Ahora queremos construir nuestro primer Coche Robot Inteligente con el kit, un microcontrolador ATmega328 (diseño UNO R3), un MotorShield V2 y un transmisor y receptor de infrarrojos. 
 El Motor Shield V2 puede controlar hasta cuatro motores, utilizando el llamado bus I2C con las conexiones SDA (=Datos serie) en la entrada analógica A4 y SCL (=Reloj serie) en A5 para la conexión de las líneas de control. Adafruit también ha desarrollado y proporcionado una biblioteca de programas adecuada para ello. Atención: Las librerías para Motor Shields V1 y V2 no son compatibles. 
 &amp;nbsp;  
 Imagen Motor Shield V2 con modificación:  Conectores hembra soldados (conectores hembra) para conectar equipos adicionales 
 Independientemente de la Motor Shield que quieras utilizar -V1 o V2-,&amp;nbsp; tiene sentido soldar conectores hembra adicionales para ambas Motor Shields, con el fin de conectar posteriormente transmisores/receptores o sensores Bluetooth o de 433 MHz. Más sobre esto en las siguientes entradas del blog. El receptor de infrarrojos sólo necesita alimentación de las patillas 3 y 4, así como de la patilla 2 para el receptor de infrarrojos. El soldador puede permanecer frío. 
 Para el control utilizaremos primero el pequeño mando a distancia por infrarrojos de Funduino y un receptor IR. Aunque el sensor IR &quot;desnudo&quot; es suficiente, recomiendo la pequeña placa breakout, ya que aquí un LED parpadea cuando se reciben señales IR; una herramienta valiosa a la hora de buscar un fallo. 
 El boceto se compone de dos piezas probadas: El sketch de ejemplo de Armin Joachimsmeyer, que añadió a su estupenda biblioteca de programas IRremote, y un sketch de Coche Robot del autor basado en la biblioteca de programas de Adafruit. 
 El código del programa del Coche RC para Arduino 
  /* Código de ejemplo para Coche Robot con Motor Shield V2 y receptor IR, a partir de 20220515
* basado en la biblioteca Adafruit Motor shield V2, copyright Adafruit Industries LLC, 2009
* y SimpleReceiver.cpp, parte de Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote
* Licencia MIT Copyright (c) 2020-2022 Armin Joachimsmeyer
* modificado para Funduino
* Motor Shield V2 utiliza I2C con SDA=A4 y SCL=A5
* El receptor IR utiliza el pin 2
 ************************************************************************************
 * Por la presente se concede permiso, de forma gratuita, a cualquier persona que obtenga una copia
 * de este software y de los archivos de documentación asociados (el &quot;Software&quot;), a comerciar
 * con el Software sin restricción alguna, incluyendo sin limitación los derechos
 * de usar, copiar, modificar, fusionar, publicar, distribuir, sublicenciar y/o vender
 * sublicenciar y/o vender copias del Software, y a permitir que las personas a las que se proporcione el Software
 * a hacerlo, con sujeción a las siguientes condiciones:
 *
 * El anterior aviso de copyright y este aviso de permiso se incluirán en todas
 * copias o partes sustanciales del Software.
 *
 * EL SOFTWARE SE PROPORCIONA &quot;TAL CUAL&quot;, SIN GARANTÍA DE NINGÚN TIPO, EXPRESA O IMPLÍCITA,
 * INCLUIDAS, PERO SIN LIMITARSE A ELLAS, LAS GARANTÍAS DE COMERCIABILIDAD, IDONEIDAD PARA UN FIN DETERMINADO Y NO INFRACCIÓN
 * PARA UN FIN DETERMINADO Y DE NO INFRACCIÓN. EN NINGÚN CASO LOS AUTORES O LOS TITULARES
 * DERECHOS DE AUTOR SERÁN RESPONSABLES DE NINGUNA RECLAMACIÓN, DAÑO U OTRA RESPONSABILIDAD, YA SEA
 * CONTRACTUAL, EXTRACONTRACTUAL O DE OTRO TIPO, DERIVADA O RELACIONADA CON EL SOFTWARE
 * O EL USO U OTRAS OPERACIONES CON EL SOFTWARE.
 *************************************************************************************/ 
 
  #include   &amp;lt;Adafruit_MotorShield.h&amp;gt;  
 // Crea el objeto escudo motor con la dirección I2C por defecto 0x60 
Adafruit_MotorShield AFMS = Adafruit_MotorShield();
 // Selecciona qué &#039;puerto&#039; M1, M2, M3 o M4.  
Adafruit_DCMotor *motor1 = AFMS.getMotor (2 );
Adafruit_DCMotor *motor2 = AFMS.getMotor ( 3);

 // define el protocolo para el control remoto, para más información consulta el código de ejemplo SimpleReceiver.cpp 
  #define  DECODE_NEC  // Incluye Apple y Onkyo, también para el minúsculo control remoto Funduino  
 //#define INFO // Para ver información valiosa del decodificador universal para los protocolos de ancho de pulso o distancia de pulso 
  #define  PIN_RECIBIDO_IR 2 //   en lugar de #include &quot;PinDefinitionsAndMore.h&quot;  
  #include   &amp;lt;Arduino.h &amp;gt; 
  #include   &amp;lt;IRremote.hpp&amp;gt;  

 // Señal del receptor IR conectada a Pin2, VCC a Pin3, GND a Pin4 
 int  IR_GND = 4 
 int  IR_VCC =  3 ;

 int  x =  0 
 int  y =  0 
 int  izquierda =  0 
 int  derecha =  0 
 int  código =  5555 ;
 int  velocidadL =  0 
 float  factor =  1.8 ;  // Corrección para speedLevel 255/100 * 6V/VBatt 

 void   setup () {
  Serial  .begin  (9600 );
  Serial  .print ln(&quot; ¡Prueba motor! &quot;);
  Serial  .print ln(&quot; ¡Escudo motor v2 - Prueba motor CC !&quot;);
  si  (!AFMS .begin ()) {          // create with the default frequency 1.6KHz 
     Serial . println ( &quot;Could not find Motor Shield. Check wiring.&quot; );
     while  ( 1 );
  }
  Serial  .print ln(&quot; Escudo motor encontrado. &quot;);
  // Sólo para saber qué programa se está ejecutando en mi Arduino 
  Serial  .println (F( &quot;START &quot;  __FILE__  &quot; de &quot;  __DATE__  &quot;\r\nUsando la versión de la biblioteca &quot;  VERSIÓN_IRREMOTA));
  // Inicia el receptor 
  IrReceiver .begin (IR_RECEIVE_PIN);  //, ENABLE_LED_FEEDBACK); 
  Serial  .print (F( &quot;Listo para recibir señales IR de los protocolos: &quot; ));
  printActiveIRProtocols (&amp;amp;Serial );
  Serial  . print(F(&quot; en el pin &quot; ));
  Serial  .println (IR_RECEPCION_PIN);  
  // inicializa los pines digitales como salida para la fuente de alimentación 
  pinMode (IR_GND ,SALIDA );
  pinMode (IR_VCC , SALIDA);
  digitalWrite (IR_GND ,BAJO );
  digitalWrite (IR_VCC , HIGH);    
}  // fin de la configuración 

 void   bucle () {
  si  (IrReceiver.decode()) {
      // Imprime un breve resumen de los datos recibidos 
      IrReceiver.printIRResultShort (&amp;amp;Serial );
      if  (IrReceiver.decodedIRData.protocol == UNKNOWN) {
           // We have an unknown protocol here, print more info 
          IrReceiver.printIRResultRawFormatted(&amp;amp; Serial , true);
      }
      Serial  .println ();
      /*
       * ¡¡¡!!!¡¡¡Importante!!! Activa la recepción del siguiente valor
       * ya que la recepción se ha detenido tras el final del actual paquete de datos recibido.
       */ 
      delay  (100 );  // Rebote, sin reintento rápido      
      IrReceiver.resume(); // Activar la recepción del siguiente   valor 
      /*
       * Por último, comprueba los datos recibidos y realiza acciones según el comando recibido
       */ 
  if  (IrReceiver.decodedIRData.command ==  0x46 )  {
     if  (code&amp;lt; 9000 )   code = code +  1000 ;         
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  else   if  (IrReceiver.decodedIRData.command ==  0x15 ) {
     if  (code&amp;gt; 2000 )   code = code -  1000 ;      
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    } 
  else   if  (IrReceiver.decodedIRData.command ==  0x43 )  {
     if  ((code -1000 * int (code/ 1000 ))&amp;lt; 900 )  code = code +  100 ;      
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  si  no (IrReceiver.decodedIRData.command ==  0x44 )  {
     if  (code -1000 * int (code/ 1000 ) &amp;gt;  200 )   code = code -  100 ;
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  else   if  (IrReceiver.decodedIRData.command ==  0x40 )  {
    code =  5555 ;
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  si  no {
     Serial . print ( &quot;invalid code&quot; );
    }
  motor();
  }
}  // fin de bucle 

 void  motor(){
  int  velocidadNivel [9 ]={ -100 , -80 , -60 , -40 , 0 , 40 , 60 , 80 , 100 };
  y =  int (código /  1000 );
  x =  int ((código -  1000*y ) /  100 );
  velocidadL = velocidadNivel [y-1 ];
  Serial  .print ( &quot;código = &quot; );
  Serial  . print(código);
  Serial  . print( &quot; y = &quot;);
  Serial  . print(y);
  Serial  . print(&quot;  x = &quot;);
  Serial  . print(x);
  Serial  . print(&quot;  velocidadL = &quot;);
  Serial  .println (velocidadL);

  //Corrección de los pasos de velocidad para las curvas 
  si   ( x==1){
    right = speedL+ 16 ;
    left = speedL -16 ;
  }
  si   ( x==2){
    right = speedL+ 13 ;
    left = speedL -13 ;
  }
  si  ( x==3 ) {
    right = speedL+ 10 ;
    left = speedL -10 ;
  }
  si  no ( x==4 ) {
    right = speedL+ 7 ;
    left = speedL -7 ;
  }
  si   no   (x==6 ) {
    right = speedL  -7 ;
    left = speedL+ 7 ;
  }
  si   no  ( x==7 ) {
    right = speedL -10 ;
    left = speedL+ 10 ;
  }
  si  ( x==8 ) {
    right = speedL -13 ;
    left = speedL+ 13 ;
  }
  si  ( x==9 ) {
    right = speedL -16 ;
    left = speedL+ 16 ;
  }
  si  no  {
    right = speedL;
    left = speedL;
  }

  //Introducción de los pasos de conducción para &quot;izquierda&quot; y &quot;derecha 
  Serial  .print (&quot;izquierda = &quot; );
  Serial  . print(izquierda);
  Serial  . print( &quot;  derecha = &quot;);
  Serial  .println (derecha);

  si  (izquierda &amp;lt;  40  &amp;amp; izquierda &amp;gt;  -40 ) {
    motor1-&amp;gt; run (RELEASE);
  }
  si  (derecha &amp;lt;  40  y derecha &amp;gt;  -40 ) {
    motor2-&amp;gt; run (RELEASE);
  }
  si  ( izquierda&amp;gt;=40 ) {
     if  (left&amp;gt; 100 ) left= 100 ;
      motor1-&amp;gt; run (FORWARD);
      motor1-&amp;gt; setSpeed (left * factor);
  }
  si  ( derecha&amp;gt;=40 ) {
     if  (right&amp;gt; 100 ) right= 100 ;
      motor2-&amp;gt; run (FORWARD);
      motor2-&amp;gt; setSpeed (right * factor);
  }
  si  (izquierda&amp;lt;=  -40 ) {
     if  (left&amp;lt; -100 ) left= -100 ;
      motor1-&amp;gt; run (BACKWARD);
      motor1-&amp;gt; setSpeed (-left * factor);
  }
  si  (derecha&amp;lt;=  -40 ) {
     if  (right&amp;lt; -100 ) right= -100 ;
      motor2-&amp;gt; run (BACKWARD);
      motor2-&amp;gt; setSpeed (-right * factor);
  }
}  // fin motor 
 
 Explicaciones del código del programa para el Coche teledirigido 
 Tras incluir las librerías Motor Shield V2 e IRremote, se instancian dos motores con el número en el bloque de terminales del controlador y se declaran algunas variables globales (tipo de datos) y se inicializan (valor inicial). 
 En la función  setup  () se inicializan la interfaz serie y el receptor IR y se configuran los pines para la alimentación del receptor IR como salidas con el estado HIGH o LOW. 
 En la función  bucle  (), primero se recibe la señal del mando a distancia IR, después se cambia el código para el control del motor en función de la tecla pulsada. Las teclas de cursor arriba y abajo cambian el primer dígito, izquierda y derecha el segundo dígito del código en el rango de valores de 1 a 9. La tecla X lleva a la parada con el código 5555. El tercer y cuarto dígito del código no son actualmente significativos. Al final, se llama a la función autodefinida motor(  )  sin argumentos, ya que habíamos definido las variables globalmente, es decir, válidas en todas las funciones. 
 En la función autodefinida motor(  ) , que también utilizaremos en otras configuraciones con otros mandos a distancia, los niveles de velocidad del motor izquierdo y derecho se determinan a partir del código. El valor porcentual del nivel de velocidad se convierte finalmente en el valor PWM para  setSpeed  utilizando el factor definido al principio. 
 &amp;nbsp;  
 El Coche Robot ya está listo para su uso. Funciona bien siempre que puedas mantener la conexión óptica entre el mando a distancia y el receptor de infrarrojos. Sin embargo, al conducir por carretera, he experimentado que la luz solar intensa dificulta la recepción. Por eso voy a cambiar al mando a distancia por radio. Hasta pronto. 
                ]]>
            </content>

                            <updated>2022-06-09T07:30: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">Construye un coche teledirigido con Arduino: Vehículo autónomo - Parte 1</title>
            <id>https://funduinoshop.com/es/construye-un-coche-teledirigido-con-arduino-vehiculo-autonomo-parte-1</id>
            <link href="https://funduinoshop.com/es/construye-un-coche-teledirigido-con-arduino-vehiculo-autonomo-parte-1"/>
            <summary type="html">
                <![CDATA[
                
                                            Bienvenido a una nueva serie de blogs sobre coches robot. En la primera parte, conoceremos sus fundamentos, por así decirlo, como ayuda para la decisión de compra, qué chasis, qué microcontrolador y qué tipo de mando a distancia...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Comprender la movilidad del futuro con los coches robot  
 Bienvenido a una nueva serie de blogs sobre coches robot. En la primera parte, conoceremos sus fundamentos, por así decirlo, como ayuda para decidir qué chasis, qué microcontrolador y qué tipo de mando a distancia son los más adecuados. 
 Dos o cuatro ruedas - sopesando los pros y los contras de construir coches RC para Arduino 
 Empecemos por el chasis y veamos las ventajas e inconvenientes de los kits económicos con dos o cuatro ruedas motorizadas. Todos tienen en común los motores eléctricos, así que éstos por sí solos no son un criterio de selección. Los coches robot de dos ruedas son inicialmente más baratos porque no tienen el coste de dos motores eléctricos y ruedas más. En cambio, tienen una o dos ruedas de apoyo, que dan a los coches teledirigidos una gran maniobrabilidad. Así que si quieres &quot;hacer girar el plato&quot;, éste es el camino a seguir. Sin embargo, en este rango de precios de los motores de corriente continua, no puedes esperar que funcionen suavemente con gran precisión. Por lo tanto, la marcha en línea recta no es tan buena como con la versión de cuatro ruedas. Especialmente cuando los motores se ponen en marcha, muestran una mayor estabilidad direccional, pero las curvas sólo son posibles con radios significativamente mayores. Otra ventaja del chasis de cuatro ruedas es que hay más espacio para las baterías, el microcontrolador, posiblemente el convertidor CC/CC y los sensores. 
   
 La elección del microcontrolador para construir un coche RC 
 La siguiente cuestión está relacionada con el microcontrolador y cómo se programa. Por ejemplo, un microordenador del tipo Raspberry Pi tiene la mayor potencia de cálculo en un chasis pequeño. Especialmente en lo que respecta al control remoto, los tipos con WiFi y Bluetooth incorporados ofrecen ventajas, e incluso puedes transmitir imágenes desde una cámara Raspberry Pi. La programación se realiza en el lenguaje de programación Python, ampliamente utilizado, pero el inicio del sistema operativo Raspberry Pi OS, basado en Linux, tarda aproximadamente un minuto. Otro inconveniente de la Raspis (abreviatura de Raspberry Pi) es la necesidad de una buena fuente de alimentación de 5 V. Esto requiere un buen convertidor CC/CC. 
 En relación con el tema del control remoto por Bluetooth, en un episodio posterior se mostrará un ejemplo con la Raspberry Pi y la APP BlueDot para Android de Martin O&#039;Hanlon (miembro del personal de la Fundación Raspberry Pi). 
 La puesta en marcha del sistema es mucho más rápida con un microcontrolador basado en el ATmega 328, por ejemplo el  Funduino Uno  o el  Funduino&amp;nbsp;Nano . Aproximadamente un segundo después de encenderlo, puedes empezar con las entradas de control, sin arrancar desde la tarjeta microSD, el programa una vez cargado no se olvida. La tensión de entrada puede estar entre 5 y 9 voltios. La programación se realiza en el  IDE Arduino , un entorno de desarrollo similar a C/C++ (para más explicaciones, consulta  https://funduino.de/hardware-software) . Por tanto, primero veremos ejemplos con el Funduino Uno R3, para el que existen controladores de motor perfectos en forma de los llamados escudos. Éstos simplemente se conectan al Uno y las llamadas bibliotecas nos ayudan con la programación. 
 Excurso: ¿Qué es un controlador/motor driver? 
 Debido a la corriente muy limitada que llega a las salidas de los microcontroladores, los grandes consumidores -y esto incluye todo tipo de motores eléctricos y relés- necesitan una fuente de alimentación externa y un circuito electrónico que convierta la señal de control del microcontrolador. Sin embargo, los requisitos para este circuito integrado son aún mayores: por un lado, debe permitir una velocidad variable del motor y, por otro, también queremos poder cambiar el sentido de giro del motor invirtiendo la polaridad. 
 Utilizando el IC L293D como ejemplo, explicaremos a continuación cómo funciona. Básicamente, este componente DIP con dieciséis &quot;patas&quot;/conexiones es suficiente como controlador de motor para dos motores eléctricos.     
 El CI se alimenta de tensión en las conexiones VCC1 y Masa. Podemos aprovechar esta tensión en el microcontrolador. La alimentación de tensión para los motores se realiza a través de VCC2 y Masa. Aquí conectamos la(s) pila(s) (por ejemplo, de 6 ó 9 voltios). Con motores más grandes es necesario refrigerar el CI, con los pequeños amarillos del kit no. 
 Conectamos un motor a 1Y y 2Y, las líneas de control correspondientes a la MCU (Unidad Microcontroladora) son 1A, 2A y 1,2EN. 
 La inversión de la polaridad de los motores para cambiar el sentido de la marcha se realiza básicamente con el llamado circuito H. Lo realizamos con nuestro microcontrolador poniendo dos pines de salida (que van a 1A y 1B) en ALTO o BAJO. 
 El cambio de velocidad se realiza como en  el ejemplo nº 04 - LED pulsante  con modulación por ancho de pulsos (PWM), es decir, conexión y desconexión muy rápidas de la tensión. Por lo tanto, para la conexión 1,2EN (&quot;Activar&quot;) necesitamos una salida compatible con PWM en la MCU (son los pines con la tilde ~). 
 Para el segundo motor, las conexiones 3A, 4A y 3,4EN se conectan a pines de la MCU. 
 La imagen de la derecha (Diagrama lógico) explica cómo funciona el CI. Podemos ver los cuatro amplificadores que dan las señales de entrada 1A a 4A respectivamente con la tensión de la batería a las salidas 1Y a 4Y. Sin embargo, esto sólo ocurre si las entradas PWM 1,2EN y 3,4EN también están en ALTO. 
 Dos de estos circuitos integrados L293D están instalados en el Motor Shield V1, de modo que aquí se pueden conectar hasta cuatro motores. 
 Para no utilizar demasiados pines, hay un denominado registro de desplazamiento (SN74HC595) en el centro del Escudo Motor V1. Explicar cómo funciona iría más allá del alcance de este artículo. Afortunadamente, nuestros colegas de Adafruit en Nueva York hicieron la mayor parte de la programación por nosotros y nos proporcionaron una biblioteca para controlar los motores fácilmente.    
 Foto Motor Shield V1 con modificación:   Conectores hembra soldados (conectores hembra) para conectar equipos adicionales 
 &amp;nbsp; 
 El Motor Shield V2 también puede controlar hasta cuatro motores y utiliza un CI similar, pero para la conexión de las líneas de control el llamado bus I2C con las conexiones SDA (=Datos serie) en la entrada analógica A4 y SCL (=Reloj serie) en A5. Adafruit también ha desarrollado y proporcionado una biblioteca de programas adecuada para ello. 
   
 Imagen Motor Shield V2 con modificación:  Conectores hembra soldados (conectores hembra) para conectar equipos adicionales 
 Ambos Motor Shields tienen conectores hembra adicionales soldados para conectar posteriormente transmisores/receptores Bluetooth o de 433 MHz o sensores. Más información sobre esto en una de las siguientes entradas del blog. 
 Alimentación y control de un coche teledirigido para microcontroladores Arduino 
 Si queremos que nuestro coche robot se conduzca solo, tenemos que desconectarlo del puerto USB del PC. Esto significa que también se perderá la fuente de alimentación. A partir de ahora, el centro de mando (MCU) y los motores eléctricos se alimentarán con pilas o baterías recargables. Los motores son, con diferencia, los que más consumen. El portapilas que viene con la mayoría de los kits es para cuatro pilas Mignon (AA), es decir, 6 voltios para la MCU y los motores. Si quieres utilizar pilas recargables, debes utilizar seis pilas Mignon (AA) o dos pilas de ión-litio 18650, debido a su menor voltaje. 
 Como controles, primero conoceremos los mandos a distancia con control remoto por infrarrojos, los transceptores Bluetooth con APP para smartphone o un segundo microcontrolador también con el transceptor BT HC-05, así como los mandos a distancia por radio con 433Mhz y 2,4 GHz en los próximos episodios. La serie de blogs concluirá con aspectos de la conducción autónoma, principalmente la detección de obstáculos. Hasta pronto. 
 &amp;nbsp; 
                ]]>
            </content>

                            <updated>2022-06-03T11: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>

    
    
        <entry>
            <title type="text">Convertidor de nivel en microelectrónica</title>
            <id>https://funduinoshop.com/es/convertidor-de-nivel-en-microelectronica</id>
            <link href="https://funduinoshop.com/es/convertidor-de-nivel-en-microelectronica"/>
            <summary type="html">
                <![CDATA[
                
                                            A menudo, en los circuitos electrónicos, dos dispositivos o módulos deben comunicarse entre sí. Más a menudo aún, estos dos módulos requieren un nivel de tensión diferente. En microelectrónica...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 ¿Dónde se utilizan los convertidores de nivel en microelectrónica? 
 A menudo, dos dispositivos o módulos deben comunicarse entre sí en circuitos electrónicos. Más a menudo aún, estos dos módulos requieren un nivel de tensión diferente. En microelectrónica, por ejemplo en un microcontrolador Arduino, este nivel de tensión suele ser de 3,3 V o 5 V. Si se conectaran directamente un módulo de 3,3 V y otro de 5 V, el módulo con una tensión máxima de funcionamiento de 3,3 V se destruiría si se le aplicara un nivel de 5 V.&amp;nbsp; 
 Para evitarlo, se utilizan los llamados convertidores de nivel. Por tanto, los convertidores de nivel permiten la comunicación entre dos módulos con niveles de tensión diferentes. Es especialmente interesante que los convertidores de nivel funcionen en dos direcciones sin tener que cambiar nada en la conexión. Por tanto, la señal puede enviarse de un módulo a otro. Los convertidores de nivel también son adecuados para las líneas I2C. Además, es posible subir o bajar el nivel de tensión de las entradas o salidas de conmutación.&amp;nbsp; 
   
 Convertidores de nivel: ¿cómo funcionan? 
 La imagen anterior muestra claramente cómo funciona la transmisión de señales dentro de un convertidor de nivel para 3,3 y 5V. En la placa, el nivel de 5V (HV, &quot;Alta Tensión&quot;) y el nivel de 3,3V (LV, &quot;Baja Tensión&quot;) están directamente enfrentados. Hay que tener en cuenta que el módulo utilizado en este ejemplo (el artículo está enlazado más abajo) sólo puede &quot;conmutar&quot; unos pocos miliamperios. El módulo no es adecuado para conmutar motores o lámparas, por ejemplo. 
                ]]>
            </content>

                            <updated>2022-05-17T00:15:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">El módulo MPU-6050: Giroscopio y acelerómetro</title>
            <id>https://funduinoshop.com/es/el-modulo-mpu-6050-giroscopio-y-acelerometro</id>
            <link href="https://funduinoshop.com/es/el-modulo-mpu-6050-giroscopio-y-acelerometro"/>
            <summary type="html">
                <![CDATA[
                
                                            Hay pocos módulos en el mercado que hayan provocado tanto revuelo en los últimos meses como el módulo MPU-6050. La placa de circuitos dos en uno combina dos...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Hay pocos módulos en el mercado que hayan provocado tanto revuelo en los últimos meses como el módulo MPU-6050. Esta placa &quot;dos en uno&quot; combina dos funciones de sensor muy populares: El módulo puede utilizarse como giroscopio y como sensor de aceleración al mismo tiempo.  ¿Cómo? El sensor incluye un giroscopio de 3 ejes y un acelerómetro de 3 ejes en un mismo chip. Esto significa que&amp;nbsp;puede consultar todos (!) los valores del sensor al mismo tiempo. Esto significa que los aficionados siempre están bien informados sobre la posición actual del sensor. Esta función es especialmente interesante para la construcción de maquetas, sobre todo para equilibrar chasis o drones. Además, se puede acceder a magnetómetros externos u otros sensores a través de un bus I2C maestro adicional, de modo que estos datos de los sensores también se pueden registrar completamente.&amp;nbsp; 
 Los datos de los sensores del MPU-6050 (GY-521) de un vistazo: 
 
 Chipset: MPU-6050 (también conocido como GY-521) 
 Fuente de alimentación: 3,3 - 5 V CC 
 Línea de libertad: 6 
 Interfaz: I2C 
 Distancia entre pines: 2,54 mm   
 
 Ahora llegamos a la parte emocionante: la práctica. Para que tengas una buena visión general de las útiles funciones del módulo MPU-6050, hemos desarrollado para ti un esquema de circuito de ejemplo. Un Funduino UNO R3 lee el módulo MPU-6050 y evalúa los datos registrados.  Nos interesan sobre todo los datos del sensor del giroscopio. Queremos leer los valores de los ejes X, Y y Z y determinar si se ha producido un cambio en la posición del sensor. El cambio de posición se nos mostrará mediante LEDs de colores. 
   
 Hasta aquí todo bien, pero ¿cómo lo hacemos? 
 El código del programa del módulo MPU-6050 
 Ha llegado la hora de la verdad: bueno, la mitad. Primero tenemos que descargar la biblioteca adecuada para el módulo MPU6050 e integrarla en nuestro IDE Arduino. La biblioteca se llama &quot;&amp;lt;MPU6050_tockn.h&amp;gt;&quot; y se puede encontrar e instalar directamente a través de la gestión de bibliotecas del IDE de Arduino. 
 Tras este primer paso, empezamos con el código propiamente dicho. En primer lugar, definimos las conexiones para nuestros LEDs, que nos servirán como indicadores de la posición del eje. Después definimos dos variables para la posición de cada uno de los tres ejes.&amp;nbsp; 
 Probablemente te preguntes por qué necesitamos dos variables por eje. Como queremos determinar si la posición del eje respectivo ha cambiado, primero debemos determinar qué valor ha registrado el sensor para la posición actual. Guardamos este valor del sensor del MPU-6050 durante un breve periodo de tiempo en la primera variable. El valor de la posición del eje se guarda de nuevo en la segunda variable un poco más tarde. Ahora podemos comparar entre sí los dos valores medidos registrados. En la medida en que se haya registrado una desviación de la posición por un mínimo previamente definido (+-3 en nuestro código de ejemplo), podemos suponer que el sensor ha modificado la posición. En este caso, encendemos el LED asignado.&amp;nbsp; 
 Especialmente agradable: los datos de medición capturados se pueden visualizar bien en el trazador en serie del IDE de Arduino.   
  // Este sketch compara los ángulos de los ejes X/Y/Z con los valores anteriores. 
 // Si difieren en +/-3°, el sketch conmuta los LEDs. (cada.1 para POS o para NEG) 
 // Atención: No se trata de valores absolutos, sino de valores RELATIVOS comparados con la medición anterior 


  #include   &amp;lt;MPU6050_tockn.h&amp;gt;   // Incluir bibliotecas  
  #include   &amp;lt;Wire.h  &amp;gt;  // &amp;lt;-  

MPU6050 mpu6050 (Alambre ,  0,1 ,  0,1 ); //   Amortiguación de los valores. Cuanto más pequeños (dirección &quot;0&quot;), más nerviosos son los valores 
                                  // cuanto más grandes (dirección &quot;1&quot;), más nerviosos los valores 

 const   int  ledXpos  =2 ;  //*** 
 const   int  ledXneg  =3 ;  // *
 const   int  ledYpos  =4 ; // *   Establecer las conexiones del LED 
 const   int  ledYneg  =5 ;  // *
 const   int  ledZpos  =6 ;  // *
 const   int  ledZneg  =7 ;  //*** 

 int  xPosAhora; //   variable POS X ACTUAL 
 int  yNowPos; // Variable   Y-Pos ACTUAL
 int  zPosAhora; // Variable   POS-Z ACTUAL

 int  xPrePos; // Variable POS X   ANTERIOR 
 int  yPrePos; // Variable Y-Pos   ANTERIOR 
 int  zPrePos; // Variable   ANTERIOR Z-Pos

 int  diferencia =  3 ;

 void   setup () {                   // Beginn Setup-Funktion 
   Serial . begin ( 115200 );          // Öffne serielle Übertragung (115200Baud) !!! Am Monitor ebenfalls einstellen !!! 
  
   pinMode (ledXpos,  OUTPUT );      //*** 
   pinMode (ledXneg,  OUTPUT );      //  * 
   pinMode (ledYpos,  OUTPUT );      //  * Festlegen dass LED-Anschlüsse Ausgänge sind 
   pinMode (ledYneg,  OUTPUT );      //  * 
   pinMode (ledZpos,  OUTPUT );      //  * 
   pinMode (ledZneg,  OUTPUT );      //*** 
  
   Wire . begin ();                  // Beginn I2C Protokoll 
  mpu6050. begin ();               // Start des Gyros 
  mpu6050.calcGyroOffsets();     // Gyro kalkuliert seine Offsets !!! Währenddessen ruhig liegen lassen !!! 
                                 // Benutze mpu6050.calcGyroOffsets(true), um es im seriellen Monitor zu verfolgen. 
 delay ( 1000 );                     // Darauf warten wir... 
}

 void   bucle () {  // inicio del bucle bucle 

  mpu6050.update();  // Crea un nuevo conjunto de datos en el giroscopio 

xNowPos=(mpu6050.getGyroAngleX());  // Solicita un nuevo conjunto de datos al giroscopio, escribe en la variable X 
yNowPos=(mpu6050.getGyroAngleY()); // Solicitar un nuevo conjunto de datos al giroscopio, escribir en la variable   Y 
zPosAhora=(mpu6050.getÁnguloGiroZ()); // Solicitar un nuevo conjunto de datos al   giroscopio , escribir en la variable Z

 if  (xNowPos &amp;lt; xPrePos-(diferencia))  // Compara el conjunto de datos antiguo con el nuevo. Diferencia &amp;lt; -3 ? 
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  HIGH );}  // Entonces cambia los LEDs en consecuencia 
 else   if  (xNowPos &amp;gt; xVorPos+(diferencia)) // Compara el conjunto de   datos antiguo con el nuevo.   ¿Diferencia &amp;lt; +3 ? 
{ digitalWrite (ledXpos,  HIGH );  digitalWrite (ledXneg,  LOW );}  // Conecta los LEDs según corresponda 
 else   // O apaga todos los LEDs X ...
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  LOW );}  // Entonces enciende los LEDs según corresponda 

 if  (yNowPos &amp;lt; yPrePos-(diferencia))  // Compara el conjunto de datos antiguo con el nuevo. Diferencia &amp;lt; -3 ? 
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  HIGH );}  // Conecta los LEDs según corresponda 
 else   if  (yNowPos &amp;gt; yVorPos+(diferencia)) // Compara el conjunto de datos antiguo   con el nuevo.   ¿Diferencia &amp;lt; +3 ? 
{ digitalWrite (ledYpos,  HIGH );  digitalWrite (ledYneg,  LOW );}  // Conecta los LEDs según corresponda 
 else   // O apaga todos los LEDs Y ...
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  LOW );}  // Entonces enciende los LEDs según corresponda 

 if  (zNowPos &amp;lt; zPrePos-(diferencia))  // Compara el conjunto de datos antiguo con el nuevo. Diferencia &amp;lt; -3 ? 
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  HIGH );}  // Conecta los LEDs según corresponda 
 else   if  (zNowPos &amp;gt; zPrePos+(diferencia)) // Compara el conjunto de datos antiguo   con el nuevo.   ¿Diferencia &amp;lt; +3 ? 
{ digitalWrite (ledZpos,  HIGH );  digitalWrite (ledZneg,  LOW );}  // Conecta los LEDs según corresponda 
 else   // O apaga todos los LEDs Z ...
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  LOW );}  // Entonces enciende los LEDs según corresponda 

xVorPos=xJetztPos; // Actualiza el   conjunto de datos antiguos ( hasta ahora)
yVorPos=yJetztPos; // Actualiza el conjunto de datos antiguos (hasta ahora  ) 
zVorPos=zJetztPos; // Actualiza el   registro antiguo (hasta ahora)
                                     // Luego, en la siguiente ejecución, se puede volver a comparar con el &quot;antes&quot; 

 Serial  .print (xAhoraPos);  // &amp;gt;&amp;gt; trazador serie&amp;lt;&amp;lt; ortografía justa [salida X] 
 Serial . print (&quot; &quot; ) ;Serial  .print (yJetztPos); //  (&quot; &quot;) = (\t) = Nuevo color [salida Y] 
 Serial  . print(&quot; &quot; ); Serial  .println (zJetztPos); // (&quot;  &quot;) = (\t) = Nuevo color [salida Z]
  delay  (15 );  // (un retardo mínimo calma la salida serie) 
}  // fin del bucle 


 // Siéntete libre de experimentar un poco con la amortiguación en la tercera línea del programa 
 //-&amp;gt; MPU6050 mpu6050(Alambre, 0,3, 0,3); 
 // o con el delay() del final. Luego observa los valores en el &amp;gt;&amp;gt;PLOTTER serial &amp;lt;&amp;lt;  
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Regulador de velocidad PWM en microelectrónica</title>
            <id>https://funduinoshop.com/es/regulador-de-velocidad-pwm-en-microelectronica</id>
            <link href="https://funduinoshop.com/es/regulador-de-velocidad-pwm-en-microelectronica"/>
            <summary type="html">
                <![CDATA[
                
                                            Antes del desarrollo de la electrónica de potencia, el control de velocidad de los motores de CC (con escobillas) se resolvía con reguladores lineales o resistencias en serie. En sentido figurado, la...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Origen de los reguladores de velocidad PWM 
 Antes del desarrollo de la electrónica de potencia, el control de velocidad&amp;nbsp;de los motores de CC (con escobillas) se resolvía con reguladores lineales o resistencias en serie&amp;nbsp;. En sentido figurado, se reducía la tensión&amp;nbsp;(y por tanto también la corriente) para modificar la velocidad. 
 Sin embargo, esto tiene algunas desventajas, que se hacen evidentes especialmente en el funcionamiento con batería&amp;nbsp;. La tensión y la corriente se convierten en energía térmica (no utilizada) (&quot;quemada&quot;) en la unidad de control (o&amp;nbsp;la resistencia). 
 El consumo total sigue siendo muy alto, mientras que la potencia utilizable&amp;nbsp;se reduce.&amp;nbsp;Como el par depende del flujo de corriente, esto también se colapsa. 
 Cómo funcionan los reguladores de velocidad PWM 
 Con el (ulterior) desarrollo de la electrónica de potencia, el problema se ha abordado con una&amp;nbsp;idea diferente.&amp;nbsp;Al conectar y desconectar (muy) rápidamente la tensión de alimentación&amp;nbsp;, la tensión (y por tanto la corriente) se &quot;pulsa&quot;.&amp;nbsp;No se pierde potencia en el interruptor (electrónico) durante el tiempo de &quot;desconexión&quot;.&amp;nbsp;Esto significa que (casi) no hay pérdidas en el regulador. 
 Durante el tiempo de &quot;ENCENDIDO&quot;, se aplica la tensión COMPLETA al motor. Como resultado,&amp;nbsp;la corriente -y por tanto el par- es correspondientemente alta.&amp;nbsp;Por desgracia, un motor con sus bobinas y núcleo de hierro no es un consumidor óhmico&amp;nbsp;ideal, por lo que esta afirmación no es&amp;nbsp;completamente correcta desde un punto de vista físico.&amp;nbsp; 
 &amp;nbsp;Sin embargo, la combinación de la inductancia de la bobina y la inercia del motor ayuda a&amp;nbsp;suavizar la velocidad, de modo que el motor se comporta como&amp;nbsp;si funcionara con una tensión continua de CC. 
 &amp;nbsp; 
   
 &amp;nbsp; 
 Esto nos lleva a las desventajas de la modulación por ancho de pulsos.&amp;nbsp;La modulación con una tensión de onda cuadrada provoca la emisión de&amp;nbsp;múltiples radiofrecuencias. Esto da lugar a interferencias EMC, que pueden provocar errores traicioneros, especialmente con los controladores&amp;nbsp;. 
 En la gama baja de frecuencias PWM (1-2kHz), se producen en el motor desagradables&amp;nbsp;silbidos.&amp;nbsp;Ahora se podría simplemente aumentar más la frecuencia de conmutación.&amp;nbsp;Sin embargo, entonces la corriente no tiene tiempo suficiente para alcanzar su estado máximo&amp;nbsp;en la bobina/bobinado.&amp;nbsp;Oscila entonces entre dos valores de estado no estables, lo que provoca&amp;nbsp;una ondulación de la corriente. 
 Una ondulación excesiva de la corriente aumenta el calentamiento en el paquete de bobinado,&amp;nbsp;lo que disminuye el rendimiento del motor y afecta a su vida útil&amp;nbsp;. 
 ... mucha física para un componente pequeño. 
 Ahora las buenas noticias:&amp;nbsp;Para motores de esta clase de potencia, estas desventajas son bastante aceptables&amp;nbsp;. Alegrémonos de las ventajas descritas anteriormente. 
                ]]>
            </content>

                            <updated>2022-05-12T09:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Módulo RFID NFC PN532 - Comunicación de campo cercano</title>
            <id>https://funduinoshop.com/es/modulo-rfid-nfc-pn532-comunicacion-de-campo-cercano</id>
            <link href="https://funduinoshop.com/es/modulo-rfid-nfc-pn532-comunicacion-de-campo-cercano"/>
            <summary type="html">
                <![CDATA[
                
                                            En este artículo queremos mostrarte cómo leer etiquetas de identificación. El artículo se centra en el módulo RFID NFC PN532. El módulo se basa en el chip PN532 de NXP. Este chipset es especialmente popular en el campo de la NFC (comunicación de campo cercano)....
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 ¿RFID? ¿NFC? ¿Qué es eso? 
 En este artículo, nos gustaría mostrarte cómo leer etiquetas de identificación. El artículo se centra en el módulo RFID PN532 NFC.&amp;nbsp; 
 El módulo se basa en el chip NXP PN532. Este chipset se utiliza ampliamente en el campo de la NFC (Comunicación de Campo Cercano). Un objeto habilitado para NFC, a menudo una tarjeta cheque con un chip NFC, se acerca a un lector NFC. Esto permite intercambiar información en una fracción de segundo.&amp;nbsp; 
 ¿Te parece abstracto? Si tienes una tarjeta CE más reciente y la utilizas para pagar sin contacto, entonces ya conoces la NFC incluso en la vida cotidiana. Al colocar la tarjeta en el terminal, se inicia la transacción, de forma rápida y sencilla. 
 Nos gustaría echar un vistazo más de cerca a los procesos técnicos que hay detrás de esto. El módulo PN532 es ideal para ello, ya que es capaz tanto de I2C como de SPI. El tipo de comunicación deseado se puede seleccionar directamente en la placa PN532 accionando los interruptores situados en ella. La posición de los interruptores necesaria para cada interfaz se encuentra a la derecha del esquema de conexiones, un poco más abajo. 
 &amp;nbsp; 
 El esquema del circuito: 
   
 Consejo: Puedes encontrar una versión de alta resolución de esta imagen  aquí . Allí puedes ver la asignación de pines un poco mejor.   
 El código del programa (versión I2C) 
  //******************************************************************************************************* 
 //** Esquema de ejemplo para leer etiquetas de identificación. Si el ID coincide, el PIN 13 se enciende durante 2 segundos ** 
 //** se enciende (LED). Si el ID es erróneo, se genera un tono en el pin 12. (zumbador / piezzo pasivo) ** 
 //** uso. En lugar de un LED, también se puede conmutar una cerradura de puerta (mediante el amplificador de conmutación TIP120 ** 
 //******************************************************************************************************* 

  #include   &amp;lt;Wire.h&amp;gt;   // Biblioteca para el protocolo I2C  
 ¡¡¡ #include   &amp;lt;Adafruit_PN532.h  &amp;gt; // Biblioteca   para el módulo NFC/RFID !!!   ¡¡¡Por favor, cárgala a través del IDE de Arduino !!!  


  #define  PN532_IRQ (2) //   Define el conector IRQ  
  #define  PN532_RESET (3) // Define   la conexión reset  

 const   int  ClavijaAlarma =  12 ; //   Clavija 12 salida para altavoz piezoeléctrico 
 const   int  SalidaPin =  13 ; // Salida pin 13   para LED o mediante TIP120 a una cerradura magnética 
 unsigned   long  cardid; //   Variable para el TAG-ID de lectura 

 unsigned   long  TAGid1 =  1702536620 ; //   Aquí se pueden introducir los ID que se van a aceptar 
 unsigned   long  TAGid2 =  4070796058 ; //   Si no, déjalo en blanco. El ID de los TAG individuales se puede introducir con 
 unsigned   long  TAGid3 ; //   el monitor serie (establecer 115200 baudios) 

Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);  // Crear instancia con protocolo I2C 


 void    setup() { // inicia la función de configuración 
  pinMode (PinAlarma,  OUTPUT ); //   Define el PIN como salida 
   pinMode (ClavijaSalida,  OUTPUT ); // Define el PIN   como salida
  Serial  .begin  (115200 );  // Abre la transmisión serie con 115200 baudios (¡ser monitoriza la misma configuración de baudios!) 
  Serial  .println ( &quot;¡Hola! &quot;); //   Envía el texto &quot;¡Hola!&quot; al monitor serie
  nfc .begin ();  // Iniciar la comunicación con el lector RFID 
  unsigned   long  versiondata = nfc.getFirmwareVersion(); //   Leer el número de versión del firmware 
  if  (! versiondata) {                                    // Wenn keine Antwort kommt 
     Serial . print ( &quot;Kann kein Board finden !&quot; );             // Sende Text &quot;Kann kein...&quot; an seriellen Monitor 
     while  ( 1 );                                            // so lange Stopp 
  }

  Serial . print (&quot; Chip PN5 encontrado&quot; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX); //   Enviar texto e información de la versión al puerto   serie del lector RFID
  Serial  .print ( &quot;Firmware ver. &quot; );  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC);  // Monitoriza cuándo llega la respuesta de la placa 
  Serial  .print ( &#039;.&#039; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC);  //  
  
  nfc.SAMConfig();  // Configura la placa para leer etiquetas RFID 

  Serial  .println ( &quot;Esperando un chip ISO14443A ...&quot; );  // Envía el texto que espera al monitor serie 
}


 void   bucle () {  // Iniciar función bucle 
  uint8_t éxito;  // Crear variable 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // Búfer para almacenar el UID 
  uint8_t uidLength;  // Longitud del UID (4 ó 7 bytes según el tipo de tarjeta/chip ISO14443A) 

  // Espera a que haya un chip ISO14443A. Si se detecta uno, la variable 
  // se rellena con el UID. Dependiendo de la longitud (4 bytes (Mifare Classic) o 
  // 7 bytes (Mifare Ultralight) se reconoce el tipo de tarjeta. 
  
  éxito = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength);

  if  (éxito) {  // Si se detecta, procesa.... 
    Serial  .println (&quot; Encontrada una tarjeta ISO14443A&quot; );
    Serial . print (&quot; Longitud UID : &quot; );  Serial  .print (uidLength, DEC);  Serial  .println (&quot;  bytes &quot;);
    Serial  . print(&quot;  Valor U ID: &quot;);
    nfc.PrintHex(uid, uidLength);  // envía la información al monitor serie 

    if  (uidLength ==  4 ) {                                   // Hat die Karte/der Chip 4 byte Länge... 
                                                            // Mifare Classic Karte 
      cardid = uid[ 0 ];                                      // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // Setze die 4 byte Blöcke 
      cardid |= uid[ 1 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zu einem einzigen Block 
      cardid |= uid[ 2 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zusammen 
      cardid |= uid[ 3 ];                                     // 
       Serial . print ( &quot;Scheint eine Mifare Classic zu sein #&quot; );   // 
       Serial . println (cardid);                                  // Gib die Informationen aus 
       Serial . println ( &quot;&quot; );                                      //  
       Serial . println ( &quot;&quot; );                                      //  
    }
      if  ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3)) //   consulta si los TAGs 1..2..3 están conectados con el respectivo 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // Encendido o apagado 
 si no 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }  // Fin de la consulta/bucle IF 
} // Fin del   bucle  
 El código del programa (versión SPI) 
  //******************************************************************************************************* 
 //** Sketch de ejemplo para leer etiquetas de identificación. Si el identificador es adecuado, el PIN 13 ** durante 2 segundos 
 //** se enciende (LED). Si el ID es erróneo, se genera un tono en el pin 12. (zumbador / piezzo pasivo) ** 
 //** uso. En lugar de un LED, también se puede conmutar una cerradura de puerta (mediante el amplificador de conmutación TIP120 ** 
 //******************************************************************************************************* 

  #include   &amp;lt;Wire.h&amp;gt;  //   Biblioteca para el protocolo I2C  
  #include   &amp;lt;SPI.  h&amp;gt; // Biblioteca para   el protocolo SPI  
 ¡¡¡ #include   &amp;lt;Adafruit_PN532.h  &amp;gt; //   Biblioteca para el módulo NFC/RFID !!! ¡¡¡Cárgala a través del IDE de Arduino !!!  

 const   byte  PN532_SCK =  2 ;  // 
 const   byte  PN532_MOSI  =3 ; //   Define las conexiones para  
const  byte  PN532_SS =  4 ; //   la conexión SPI al RFID  
 const   byte  PN532_MISO  =5 ; //   la placa 

 const   int  ClavijaAlarma =  12 ; //   Define  las conexiones para 
 const   int  ClavijaSalida =  13 ; //   las salidas (de conmutación )
 unsigned   long  cardid; //   Variable para el TAG-ID leído 

 unsigned   long  TAGid1 =  1702536620 ;  // Aquí se pueden introducir los ID que se van a aceptar 
 unsigned   long  TAGid2 =  4070796058 ; //   Si no, déjalo en blanco. El ID de los TAG individuales se puede introducir con 
 unsigned   long  TAGid3 ; //   el monitor serie (establecer 115200 baudios) 

Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS);  // crea una instancia con protocolo SPI 

 void    setup() { // Inicia la función de configuración 
  pinMode (PinAlarma,  OUTPUT );  // Define el PIN como salida 
   pinMode (ClavijaSalida,  OUTPUT ); //   Define el PIN como salida
  Serial  .begin  (115200 );  // Abre la transmisión serie con 115200 baudios (¡ser monitoriza la misma configuración de baudios!) 
  Serial  .println ( &quot;¡Hola! &quot;); //   Envía el texto &quot;¡Hola!&quot; al monitor serie
  nfc .begin ();  // Iniciar la comunicación con el lector RFID 
  unsigned   long  versiondata = nfc.getFirmwareVersion(); //   Leer el número de versión del firmware 
  if  (! versiondata) {                                    // Wenn keine Antwort kommt 
     Serial . print ( &quot;Kann kein Board finden !&quot; );             // Sende Text &quot;Kann kein...&quot; an seriellen Monitor 
     while  ( 1 );                                            // so lange Stopp 
  }

  Serial . print (&quot; Encontrado chip PN5&quot; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX); //   Enviar texto e información de la versión al puerto   serie del lector RFID
  Serial  .print ( &quot;Firmware ver. &quot; );  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC);  // Monitoriza cuándo llega la respuesta de la placa 
  Serial  .print ( &#039;.&#039; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC);  //  

  nfc.SAMConfig();  // Configura la placa para leer etiquetas RFID 

  Serial  .println ( &quot;Esperando un chip ISO14443A ...&quot; );  // Envía el texto que espera al monitor serie 
}


 void   bucle () {  // Iniciar función bucle 
  uint8_t éxito;  // Crear variable 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // Buffer para almacenar el UID 
  uint8_t uidLength;  // Longitud del UID (4 ó 7 bytes según el tipo de tarjeta/chip ISO14443A) 

  // Espera a que haya un chip ISO14443A. Si se detecta uno, la variable 
  // se rellena con el UID. Dependiendo de la longitud (4 bytes (Mifare Classic) o 
  // 7 bytes (Mifare Ultralight) se reconoce el tipo de tarjeta. 
 
  éxito = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength);

  if  (éxito) {  // Si se detecta, procesa.... 
    Serial  .println (&quot; Encontrada una tarjeta ISO14443A&quot; );
    Serial . print (&quot; Longitud UID : &quot; );  Serial  .print (uidLength, DEC);  Serial  .println (&quot;  bytes &quot;);
    Serial  . print(&quot;  Valor U ID: &quot;);
    nfc.PrintHex(uid, uidLength);  // envía la información al monitor serie 

    if  (uidLength ==  4 ) {                                   // Hat die Karte/der Chip 4 byte Länge... 
                                                            // Mifare Classic Karte 
      cardid = uid[ 0 ];                                      // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // Setze die 4 byte Blöcke 
      cardid |= uid[ 1 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zu einem einzigen Block 
      cardid |= uid[ 2 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zusammen 
      cardid |= uid[ 3 ];                                     // 
       Serial . print ( &quot;Scheint eine Mifare Classic zu sein #&quot; );   // 
       Serial . println (cardid);                                  // Gib die Informationen aus 
       Serial . println ( &quot;&quot; );                                      //  
       Serial . println ( &quot;&quot; );                                      //  
    }
      if  ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3)) //   consulta si los TAGs 1..2..3 están conectados con el respectivo 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // Encendido o apagado 
 si no 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }  // Fin de la consulta/bucle IF 
} // Fin del   bucle  
 &amp;nbsp; 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Embarcación de Desembarco con Cojín de Aire Clase WISENT</title>
            <id>https://funduinoshop.com/es/embarcacion-de-desembarco-con-cojin-de-aire-clase-wisent</id>
            <link href="https://funduinoshop.com/es/embarcacion-de-desembarco-con-cojin-de-aire-clase-wisent"/>
            <summary type="html">
                <![CDATA[
                
                                            En muchas exposiciones de maquetas de barcos, la mayoría de los barcos están construidos hasta el último detalle y con una calidad muy alta. Es una pena que a menudo los espectadores pasen esto por alto. Modelos espectaculares y no cotidianos...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Modelismo: Cojín Aéreo para Embarcaciones de Desembarco Clase WISENT &quot;LCAC&quot; 
 En muchas exposiciones de modelismo naval, la mayoría de los barcos están construidos con una calidad muy alta y hasta el último detalle&amp;nbsp;. Es una pena que a menudo&amp;nbsp;los espectadores pasen esto por alto. Los modelos espectaculares y no cotidianos de&amp;nbsp;tienen más probabilidades de llamar la atención. Sin&amp;nbsp;duda, los aerodeslizadores son uno de ellos.&amp;nbsp;¿Por qué no construir un modelo del más grande de su clase?&amp;nbsp;Con un desplazamiento de 550 toneladas, la clase Zubr (clase Wisent) es un gigante.&amp;nbsp;Hay un modelo de plástico en 1:110. Me resultó demasiado pequeño. pensé que 1:75 era justo lo que necesitaba&amp;nbsp;. Así que ¡construye el tuyo propio! 
 Construye tu propio aerodeslizador: ¿Pero cómo? 
 El libro &quot;RC Luftkissenboote&quot; (Aerodeslizadores RC) de&amp;nbsp;K.Jackson &amp;amp; M.Porter de la editorial VTH fue una valiosa ayuda. Había que probar qué componentes técnicos de&amp;nbsp;debían hacer flotar el modelo&amp;nbsp;. Los cálculos no fueron muy útiles en este caso. Al final del texto se incluye una lista&amp;nbsp;de la tecnología de baterías y accionamientos utilizada. No existe un plano de construcción de&amp;nbsp;este tipo, por lo que hubo que utilizar fotos y hacer muchos cálculos&amp;nbsp;. 
 La carcasa se construyó con una plancha de espuma de poliuretano y un pegamento potente&amp;nbsp;de la tienda de bricolaje. Esto fue bastante rápido. Un impulsor de 70 mm , que se suele utilizar para los aeromodelos de poliestireno, debería hacer que el Wisent&amp;nbsp;&quot;revoloteara&quot;. El faldón de aire está hecho con rip-nylon.&amp;nbsp;Un material que se utiliza para las lonas de las tiendas de campaña y por los paracaidistas&amp;nbsp;. 
 La fuente de alimentación del aerodeslizador 
 Con el tamaño previsto de 900 x 400 mm, estaba claro desde el principio que no sería un modelo de bajo consumo. Una batería de 18 V con 2,5 Ah de la gama de herramientas&amp;nbsp;-combinada con un convertidor de tensión- va a proporcionar la tensión deseada de 12 V uniforme.&amp;nbsp;Un segundo convertidor de tensión regula los 12 V hasta 9 V de nuevo&amp;nbsp;y proporciona así a la hélice y a la iluminación náutica una tensión&amp;nbsp;uniforme.&amp;nbsp;De este modo, toda la alimentación eléctrica procede de una sola batería.&amp;nbsp;Dos de las hélices exteriores están diseñadas para la propulsión, el motor central&amp;nbsp;se ha invertido y esta hélice se ha enchufado &quot;al revés&quot; en el eje de transmisión . De este modo, la marcha atrás es posible sin problemas.&amp;nbsp;Las tres góndolas de propulsión fueron impresas para mí por la empresa -Ray Haller de Eibenstock- en&amp;nbsp;la impresora 3D. Se controlan de forma sincronizada mediante un servo.&amp;nbsp;Este concepto de accionamiento ha demostrado su eficacia.&amp;nbsp;Las hélices de 3,5 pulgadas (unos 9 cm) proceden de la gama de piezas de repuesto para cuadricópteros.&amp;nbsp;A pesar de su consistente construcción ligera, el modelo pesa 4,7 kg con todos los accesorios&amp;nbsp;. Esto hace posible el aterrizaje, pero no es adecuado para viajes&amp;nbsp;en tierra. Incluso el original es un 99% en el agua&amp;nbsp;. Se construyeron 18 de estos &quot;bisontes gigantes&quot;.&amp;nbsp;Ucrania, Corea, Rusia, China y Grecia los utilizaron. 
 Se utilizaron componentes de Funduino: 
 1x&amp;nbsp; R4-E-0-1 :  Impulsor de turbina EDF de 70 mm ADF70-28XL PLUS KV3900  1x R6-C-7-4:  Hobbywing SkyWalker 60A UBEC Brushless ESC&amp;nbsp;(el controlador de 40A se calienta demasiado)  3x R5-E-4-3:  Ready ToSky 1306 KV3100 para 150 quadcopter  3x R6-E-1-4: Hobbywing  SkyWalker 12AE Br ushless ESC 2x R12-B-8-2:  DC-DC Step Down Module 300W 20A 6-40V to 1.2-36V  
 1x batería 2,5 Ah 18 V de Einhell (tiempo de conducción aprox. 15 min) El modelo se controla con un mando a distancia Carson de 6 canales y 2,4 GHz. 
                ]]>
            </content>

                            <updated>2022-05-04T15:30:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">¿Cómo instalar un controlador CH340/CH341?</title>
            <id>https://funduinoshop.com/es/como-instalar-un-controlador-ch340/ch341</id>
            <link href="https://funduinoshop.com/es/como-instalar-un-controlador-ch340/ch341"/>
            <summary type="html">
                <![CDATA[
                
                                            Cada vez con más frecuencia nos contactáis para preguntarnos cómo instalar el controlador CH340 para microcontroladores compatibles con Arduino. Por eso, en esta entrada del blog nos gustaría explicarte...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  ¿Cómo instalar un controlador CH340/CH341 para microcontroladores compatibles con Arduino?  
 Cada vez con más frecuencia nos contactáis para preguntarnos cómo instalar el controlador CH340 para microcontroladores compatibles con Arduino. En esta entrada del blog nos gustaría explicar    - Cuál es la diferencia entre las placas de microcontroladores con chipset CH340 y las &quot;originales&quot;  - Dónde puedes descargar el controlador CH340  - Cómo instalar el controlador CH340 en Windows  - Cómo programar microcontroladores compatibles con Arduino con el controlador CH340 dentro del IDE de Arduino 
 Después de leer la entrada del blog, ¡estarás al tanto de todos los escollos para poner en marcha clones baratos de Arduino! 
  La diferencia entre los microcontroladores con CH340 y el chipset ATmega328P  
 Lo primero es lo primero: las placas de microcontroladores compatibles con Arduino con chipset CH340 son ligeramente más baratas que las placas clásicas con ATmega328p. Esto se debe en parte a que las placas clásicas con el chipset &quot;original&quot; se pueden conectar al ordenador doméstico mediante USB inmediatamente después de la compra y, por tanto, están listas para usar.     Antes de sacar conclusiones precipitadas en este punto, veamos en detalle las ventajas y desventajas más importantes de las placas CH340: 
 Desventaja 1: &amp;nbsp;¡El chipset CH340 no es compatible con todos los sistemas operativos! 
 Especialmente con los sistemas Windows, el chipset CH340 a menudo conduce a la frustración: el sistema operativo Windows no suele estar equipado con el controlador CH340 de fábrica. Las placas compatibles con Arduino con controladores CH340/CH341 que se conectan a un PC con Windows no suelen ser reconocidas como tales por el PC. Por lo tanto, aparecen mensajes de error en el IDE de Arduino cuando se cargan los bocetos. 
 Desventaja 2: ¡La carga de bocetos en placas CH340 lleva más tiempo (probado a 5 V)! 
 Lo admitimos: puede que esta desventaja sea insignificante en la creación de prototipos caseros, pero existe. La forma más fácil de ver la diferencia es observar la siguiente serie de datos. 
 
 
 
 
 Tamaño del boceto (byte) 
 
 
 R3 Tiempo de carga (segundos) 
 
 
 CH340 Tiempo de carga (segundos) 
 
 
 
 
 500 
 
 
 5.3 
 
 
 5.6 
 
 
 
 
 5000 
 
 
 9.3 
 
 
 9.7 
 
 
 
 
 7000 
 
 
 9.6 
 
 
 10.2 
 
 
 
 
 &amp;nbsp;  De media, la carga del programa tarda unos 0,4 segundos más con las placas CH340. 
 Ventaja 1: ¡El consumo de energía de la placa CH340/CH341 es menor! 
 Por supuesto, el tiempo de carga de los bocetos puede despreciarse, especialmente en la creación rápida de prototipos. Pero, ¿qué pasa con el consumo de energía? De nuevo, observamos el comportamiento de la placa con dos bocetos estándar que seguro que todos conocéis: &quot;Bare Minimum&quot; y &quot;Blink&quot;. 
 
 
 
 
  Ejemplo de boceto  
 
 
  Consumo de energía R3 (mA)  
 
 
  Consumo CH340 (mA)  
 
 
 
 
 Mínimo 
 
 
 32.3 
 
 
 14 
 
 
 
 
 Parpadeo 
 
 
 37.1 
 
 
 20.1 
 
 
 
 
 ¡Estamos tan sorprendidos como tú! El consumo de energía de la placa microcontroladora CH340 es sólo la mitad que el de la R3... ¡emocionante! 
  Así que lleguemos a la conclusión:  
 Para aquellos que puedan vivir con el esfuerzo adicional debido a la instalación del controlador requerido adicionalmente, los microcontroladores compatibles con Arduino con chipset CH340/CH341 son sin duda una buena alternativa. La desventaja técnica de la versión CH340, el tiempo de carga, es ciertamente insignificante para el aficionado. En este caso, ¡la ganancia debida al bajo consumo de energía compensa incluso la desventaja! 
 ¿Dónde puedes descargar el controlador CH340? 
 Ahora la cosa se complica un poco: a continuación te enlazamos a los controladores del CH340 para las plataformas Windows, OS y Linux. Los enlaces para los controladores de Windows y OS enlazan a un sitio web con caracteres chinos. No dejes que esto te desanime: puedes descargar el controlador simplemente haciendo clic en la barra azul (símbolo de la nube). En el momento de nuestra prueba, los bocetos estaban, por supuesto, ¡libres de virus! 
 Windows:  http://www.wch.cn/download/CH341SER_ZIP.html  Linux:&amp;nbsp;   https://github.com/juliagoda/CH341SER   SO: http:  //www.wch.cn/download/CH341SER_MAC_ZIP.html  
 Actualización 21.11.2022: Un cliente nos ha informado de que el uso del controlador anterior para SO puede provocar complicaciones. Por tanto, recomendamos el siguiente controlador (de pago).&amp;nbsp;   https://www.mac-usb-serial.com/dashboard/   Puedes encontrar más información en&amp;nbsp; https://thingsmatic.com/2017/08/07/using-ch340-devices-with-osx/ &amp;nbsp;. 
 En este punto nos gustaría señalar que es posible que se necesiten derechos de administrador para la instalación. 
 ¿Cómo instalo ahora el controlador CH340? 
 Una vez que hayas descargado el archivo correspondiente, puedes descomprimirlo (por ejemplo, con WinRar). A continuación, abre el archivo Setup.exe. Se abrirá una nueva ventana. En esta ventana, selecciona el archivo &quot;CH341SER.INF&quot; en &quot;Seleccionar INF&quot;. A continuación, confirma tu selección con el botón &quot;Instalar&quot;. Si la instalación se ha realizado correctamente, aparecerá una ventana emergente confirmando la instalación. 
 ¿Y cómo puedo utilizar ahora mi placa microcontroladora compatible con el controlador CH340? 
 Muy sencillo: (casi) exactamente igual que una placa con chipset ATmega328p o ATmega16U2. En primer lugar, establece la conexión USB entre el microcontrolador y tu ordenador. El microcontrolador debería aparecer en el administrador de dispositivos. 
 A continuación, abre el IDE de Arduino. En &quot;Herramientas&quot; y &quot;Placa&quot;, selecciona el tipo de tu microcontrolador. A continuación, en &quot;Herramientas&quot; y &quot;Puerto&quot;, selecciona el llamado puerto COM de tu controlador. Por regla general, se trata del puerto COM con el número más alto.     Importante: En el siguiente paso, debes seleccionar el ATmega329p (antiguo gestor de arranque) en &quot;Herramientas&quot; y &quot;Procesador&quot;. ¡Sólo entonces podrás cargar el controlador CH340!    No ha sido tan difícil, ¿verdad? Si quieres empezar ya tu próximo proyecto, te recomendamos nuestra plataforma de aprendizaje gratuita  www.funduino.de  con más de 250 tutoriales gratuitos sobre los sensores, actuadores y mucho más más populares 
                ]]>
            </content>

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

    
</feed>
