<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://funduinoshop.com/it/blog/?sAtom=1" rel="self" type="application/atom+xml" />
    <author>
        <name>Funduinoshop</name>
    </author>
    <title>Blog/Atomi</title>
    <id>https://funduinoshop.com/it/blog/?sRss=1</id>
    <updated>2026-05-02T01:37:02+02:00</updated>
    
        <entry>
            <title type="text">Finale WRO Germania 2025</title>
            <id>https://funduinoshop.com/it/finale-wro-germania-2025</id>
            <link href="https://funduinoshop.com/it/finale-wro-germania-2025"/>
            <summary type="html">
                <![CDATA[
                
                                            Anche quest&#039;anno abbiamo potuto esporre alla finale tedesca delle Olimpiadi Mondiali di Robot, questa volta dal 27 al 28 giugno 2025 presso la Westfalenhalle di Dortmund.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Anche quest&#039;anno abbiamo avuto l&#039;onore di esporre alla finale tedesca delle Olimpiadi Mondiali di Robotica   Olimpiade dei Robot   - questa volta   dal 27 al 28 giugno 2025   presso   la Westfalenhalle   Dortmund. Siamo già stati al via a Passau nel 2024 e per noi è stata una grande esperienza   grande   Sensazione di far parte di questa speciale (e   (e in costante crescita!)   Evento per la seconda volta.   
 
 
       
   Abbiamo raccolto un numero incredibile di impressioni e di   grandi   E abbiamo avuto grandi conversazioni, soprattutto con bambini e ragazzi di diverse fasce d&#039;età. L&#039;entusiasmo e la curiosità con cui si avvicinano alla tecnologia e alla robotica sono semplicemente contagiosi e rappresentano una vera gioia. Per noi la finale non è stata solo emozionante, ma anche assolutamente arricchente.   
 
 
   Vorremmo cogliere l&#039;occasione per elogiare Markus   Fleige   e il suo team, che ancora una volta hanno fatto un ottimo lavoro nell&#039;organizzazione dell&#039;evento. Si poteva percepire in ogni momento quanto cuore e anima ci fossero nell&#039;evento.   
 
 
   Al   Funduino  -Abbiamo presentato alcuni dei nostri prodotti, tra cui lo Starter Kit e il Cube   e il Cubo   il   Unitree   Go2. Il pubblico giovane è stato particolarmente entusiasta, facendo innumerevoli domande e meravigliandosi del cane con gli occhi lucidi.   
 
 
   Nel complesso, è stato un fine settimana di successo, ricco di ispirazione, dialogo e grandi incontri. Siamo grati di aver partecipato e non vediamo l&#039;ora che arrivi la prossima volta!   
    Il tuo team di Funduino       
 &amp;nbsp; 
 
 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Forum europeo sulla robotica 2025</title>
            <id>https://funduinoshop.com/it/forum-europeo-sulla-robotica-2025</id>
            <link href="https://funduinoshop.com/it/forum-europeo-sulla-robotica-2025"/>
            <summary type="html">
                <![CDATA[
                
                                            Dal 25 al 27 marzo 2025 siamo stati presenti all&#039;European Robotics Forum di Stoccarda, uno dei più importanti luoghi di incontro per gli esperti di robotica di tutta Europa.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Dal     25. al 27 marzo 2025     eravamo presenti al     European Robotics Forum di Stoccarda     uno dei luoghi di incontro più importanti per gli esperti di robotica di tutta Europa.   
 
 
   Questa volta   eravamo presenti esclusivamente con i     Bracci robotici di   Dobot     i  l Centro Cultura e Congressi di   Stoccarda   e abbiamo potuto presentarli a un pubblico internazionale di esperti. È stata un&#039;occasione entusiasmante per dimostrare le versatili possibilità di applicazione del Dobot   Dobot  -E di dialogare con i visitatori interessati.   
 
 
       
   La risposta è stata ottima: molti esperti del settore della ricerca, dell&#039;industria e dell&#039;istruzione hanno colto l&#039;occasione per vedere i robot in azione. Siamo stati particolarmente soddisfatti dello stupore e dell&#039;entusiasmo che abbiamo percepito al nostro stand, sia durante il primo incontro che nelle intense discussioni tecniche che ne sono seguite.   
 
 
   Torniamo a casa da Stoccarda con molte nuove impressioni. È stato particolarmente prezioso per noi far parte di questa rete internazionale e presentare i   Dobot   a un pubblico di specialisti così ampio. Le discussioni e il feedback ci incoraggiano a continuare a promuovere attivamente la robotica nell&#039;istruzione e nella pratica. Per noi, la prima apparizione al     European Robotics Forum     è stato un passo importante per noi, e sicuramente non l&#039;ultimo.   
    Il tuo team di Funduino   
       
 
 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Didacta 2025 a Stoccarda</title>
            <id>https://funduinoshop.com/it/didacta-2025-a-stoccarda</id>
            <link href="https://funduinoshop.com/it/didacta-2025-a-stoccarda"/>
            <summary type="html">
                <![CDATA[
                
                                            Dall&#039;11 al 15 febbraio 2025 siamo stati nuovamente presenti a Didacta a Stoccarda e, come negli anni precedenti, la fiera è stata all&#039;altezza delle sue promesse.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Dal     11. al 15 febbraio 2025     siamo stati ancora una volta al     Didacta a Stoccarda     e, come negli anni precedenti, la fiera ha ancora una volta   ancora una volta   ancora una volta   mantenuto ciò che aveva promesso  .   
 
 
   Abbiamo avuto modo di avere molte conversazioni interessanti   con voi e siamo rimasti entusiasti del grande interesse suscitato dai nostri prodotti. Nel nostro stand abbiamo presentato un mix variopinto di prodotti: dal nostro   nostro   classico     Funduino  -Ai prodotti     al     Dobot  -Bracci robotici     fino a    Taglierine laser a flusso    . È stato particolarmente bello vedere che i visitatori di tutte le fasce d&#039;età erano entusiasti della nostra tecnologia, dagli alunni curiosi agli insegnanti esperti. È proprio questo dialogo con tante persone diverse che rende Didacta così speciale per noi.   
     
 
 
   Un vero e proprio momento di gloria quest&#039;anno   w  è stato   l&#039;evento     Unitree   Go2    . L&#039;agile cane robot ha attirato immediatamente l&#039;attenzione di tutti, ha fatto illuminare gli occhi e ha attirato la folla. Sono state scattate numerose foto e molti hanno colto l&#039;occasione per interagire con lui. L&#039;entusiasmo   era davvero   era palpabile - e anche a noi è piaciuto molto.   
 
 
     
   Possiamo guardare indietro a cinque giorni intensi di fiera, pieni di ispirazione, dialogo e nuove idee. Oltre a tante impressioni, prendiamo anche   EUER   un prezioso feedback e nuovi impulsi che ci incoraggeranno nel nostro lavoro. Un grande ringraziamento a tutti coloro che ci hanno visitato: avete reso Didacta 2025 un evento davvero speciale per noi   molto   un&#039;esperienza davvero speciale per noi. Non vediamo l&#039;ora di rivedervi l&#039;anno prossimo!   
 &amp;nbsp; 
 
 
    Il vostro team   di   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/it/led-halloween-kuerbis</id>
            <link href="https://funduinoshop.com/it/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">Pulsante sul Raspberry Pi</title>
            <id>https://funduinoshop.com/it/pulsante-sul-raspberry-pi</id>
            <link href="https://funduinoshop.com/it/pulsante-sul-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            Nei primi esempi, abbiamo imparato a conoscere i pin GPIO come uscite da commutare su HIGH per far accendere un LED. Ma GPIO è l&#039;acronimo di General Purpose Input/Output. Quindi puoi usare i pin anche come ingresso...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Nei primi esempi, abbiamo imparato a conoscere i pin GPIO come uscite da commutare su HIGH per far accendere un LED. Ma GPIO è l&#039;acronimo di General Purpose Input/Output. Quindi puoi anche programmare i pin come ingressi. In questo modo è possibile determinare se c&#039;è una tensione all&#039;ingresso (HIGH) o meno (LOW). Il Raspberry Pi dispone solo di ingressi digitali (più avanti vedremo un workaround per misurare le tensioni analogiche), ma la tensione applicata non deve essere esattamente di 3,3V per essere riconosciuta come ALTA e non di 0V per essere riconosciuta come BASSA. Fino a circa 1,4V viene riconosciuto come BASSO, mentre tutto ciò che supera 1,9V viene sicuramente riconosciuto come ALTO. Solo il piccolo intervallo intorno a ½ di 3,3V e un pin libero senza alcun collegamento sono problematici.  
  Conosceremo diversi sensori digitali che dovrebbero attivare un allarme o una determinata azione nel nostro programma (ad esempio un rilevatore di movimento). Il più semplice di questi sensori è il pulsante, un interruttore a molla che chiude un circuito quando il pulsante viene premuto e lo riapre quando viene rilasciato.  
  Se colleghiamo un contatto del pulsante a un pin GPIO e l&#039;altro a 3,3V, il segnale ALTO viene chiaramente rilevato quando il pulsante viene premuto. Il problema inizia dopo il rilascio del pulsante. Qual è lo stato del GPIO? Uno stato non definito! Non è possibile programmare con questo stato. Nello stato di spegnimento, il GPIO dovrebbe essere permanentemente a potenziale GND. Tuttavia, questo porterebbe a un cortocircuito quando si preme il pulsante. Il rimedio è un resistore che deve essere abbastanza grande da far passare solo una piccola corrente. Sono comuni resistenze di 4,7 k&amp;nbsp;(=4700 Ohm) o 10 kΩ&amp;nbsp;(=10.000 Ohm). Questi resistori sono chiamati resistenze di pull-down.  
  Tuttavia, puoi anche programmare il GPIO in modo che indichi normalmente ALTO e riconosca la pressione del tasto su GND come un passaggio a BASSO. In questo caso il resistore si chiama resistenza di pull-up. Per confondere ancora di più i principianti, i GPIO di Raspberry Pi hanno una resistenza interna di pull-up o pull-down che può essere attivata o disattivata nel programma. Fortunatamente, questo rende i circuiti iniziali molto semplici.  
  Lo schema del circuito: Pulsante su Raspberry Pi  
     
     
  Il codice del programma: Pulsante su Raspberry Pi  
  da gpiozero importa LED, Pulsante
da signal import pause
led = LED (12 )
 pulsante  = pulsante (16 )
 pulsante  .quando_premuto  = led .on 
 pulsante  .quando_rilasciato  = led .off 
  pausa  ()    
   Dal modulo gpiozero vengono importate le classi LED e button, separate da virgole, quindi gli oggetti led e button vengono istanziati con i rispettivi numeri GPIO.     Al posto del metodo    sleep()   -Del modulo    time   &amp;nbsp;modulo,    pausa   &amp;nbsp;dal modulo    segnale   &amp;nbsp;sleep() significherebbe un arresto completo, la pressione dei tasti non verrebbe notata durante il tempo. Senza pause(), il programma terminerebbe e non accadrebbe nulla.     L&#039;istanziazione del pulsante è stata molto semplice perché abbiamo specificato solo il numero di GPIO e per il resto abbiamo utilizzato le impostazioni predefinite (vedi la definizione della classe nella riga successiva). Se vuoi discostarti da questa impostazione, devi inserire altri parametri come argomenti delle parole chiave.   
   classe  gpiozero .Button  (pin , *,  pull_up=True ,  active_state=None ,  bounce_time=None ,
 hold_time=1 ,  hold_repeat=False ,  pin_factory=None )  
   Maggiori dettagli su gpiozero si possono trovare      qui     .    
  Estensione del setup sperimentale: un ciclo semaforico deve essere avviato con un Raspberry Pi quando viene premuto un pulsante.  
  Il setup sperimentale si basa sul primo esempio. Al posto di un LED, viene utilizzato un semaforo a LED. Questo ha resistenze in serie integrate. Istanziamo tre oggetti LED e definiamo una funzione trafficLight, che viene richiamata quando viene premuto un pulsante.  
  Il codice del programma: Ciclo del semaforo su Raspberry Pi   
  da gpiozero  import  LED, Button
da signal  import  pause
da time  import  sleep
redled = LED (16 )
yellowled = LED (20 )
greenled = LED (21 )
pulsante = pulsante (12 )
def trafficLight():
       redled.on()
    sleep(1)
    yellowled.on()
    dormire(1)
    greenled.on()
    redled.off()
    yellowled.off()
    dormire(1)
    yellowled.on()
    greenled.off()
    dormire(1)
    redled.on()
    yellowled.off()
    dormire(1)
    redled.off()
button.when_pressed = trafficLight
pausa()  
  Estensione: gioco di reazione con due pulsanti su Raspberry Pi  
   Hai bisogno di due pulsanti, un cicalino e un LED rosso e giallo. Dopo aver avviato il gioco di reazione, il LED giallo si accende per primo. Con    tempo = uniforme(5, 10)   &amp;nbsp;il LED rosso si accende dopo un tempo casuale compreso tra cinque e dieci secondi. A questo punto due giocatori possono premere ciascuno il proprio pulsante il più velocemente possibile. Se si preme troppo presto, si verrà scoperti a barare e il cicalino suonerà per mezzo secondo.   
  Il codice del programma: Sonda di reazione con due pulsanti su Raspberry Pi   
   #! /usr/bin/python3 
 # Gioco di reazione - premi il pulsante, quando il LED rosso si accende 
 # basato sulla documentazione di gpiozero, Ricette di base 
 # migliorato per riconoscere gli imbrogli da Bernd Albrecht 
 # Il LED rosso si accende 5-10 secondi dopo il LED giallo 
 da  gpiozero  import  Button, LED, Buzzer
 da  time  import  sleep
 da  random  import  uniform
 da  sys  import  exit
led_rosso = LED (16 )
led_giallo = LED( 20 )
buzzer = cicalino (12 )
giocatore_1 = Pulsante (23 )
player_2 = Pulsante( 18 )

led_giallo .on ()
tempo = uniforme (5 ,  10 )
sleep(time)
 se  player_1.is_pressed:
    print ( &quot;Il giocatore 1 sta barando!&quot; )
    cicalino .on ()
    sleep (0,5 )
    cicalino .off ()
    led_giallo .off ()
    exit()
 se  player_2.is_pressed:
    print ( &quot;Il giocatore 2 sta barando!&quot; )
    cicalino .on ()
    sleep (0,5 )
    cicalino .off ()
    led_giallo .off ()
    exit()
led_rosso .on ()
led_giallo .off ()
 mentre  Vero:
    se  player_1.is_pressed:
        print ( &quot;Il giocatore 1 vince!&quot; )
        pausa 
    se  player_2.is_pressed:
        print ( &quot;Il giocatore 2 vince! &quot;)
        pausa 
led_red .off ()  
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">LED RGB su Raspberry Pi</title>
            <id>https://funduinoshop.com/it/led-rgb-su-raspberry-pi</id>
            <link href="https://funduinoshop.com/it/led-rgb-su-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                             Un LED RGB è la combinazione di tre LED di colori diversi in un unico alloggiamento. Il termine RGB si riferisce ai colori &quot;rosso&quot;, &quot;verde&quot; e &quot;blu&quot;. I rispettivi LED possono essere controllati tramite modulazione di larghezza di impulso (PWM).
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Controllare un LED RGB con un microcontrollore Raspberry Pi 
 Che cos&#039;è un LED RGB? 
 Un LED RGB è la combinazione di tre LED di colori diversi in un unico alloggiamento. Il termine RGB si riferisce ai colori &quot;rosso&quot;, &quot;verde&quot; e &quot;blu&quot;. I rispettivi LED possono essere controllati con la modulazione di larghezza degli impulsi (PWM). Questo rende possibile una moltitudine di combinazioni di colori. 
 Un LED RGB ha quattro gambe, una per ogni colore e una comune per tutti e tre i colori. A seconda della versione, la più lunga delle quattro gambe è l&#039;anodo comune (+) o il catodo (-). La singola gamba accanto a quella più lunga è il collegamento per il componente rosso. I componenti verde e blu sono controllati tramite le gambe sull&#039;altro lato.    
 Il tipo di LED RGB, anodo comune o catodo comune, non è visibile dall&#039;esterno. Fortunatamente, non è possibile danneggiare nulla a causa di tentativi ed errori. Il LED RGB non si illumina nella direzione di blocco. Importante: i tre LED implementati necessitano anche di resistenze in serie. Se vuoi fare un lavoro accademico, puoi calcolare le diverse resistenze in serie a partire dalle rispettive tensioni di flusso. Per semplicità, puoi anche utilizzare le stesse resistenze tra 100 e 330 Ω (Ohm). 
 Versione a: &quot;Catodo comune&quot; - La gamba più lunga del LED è &quot;-&quot; e le tre gambe più corte sono controllate dai GPIO con &amp;nbsp;&quot;+&quot; (tensione). 
 Versione b) &quot;Anodo comune&quot;: il LED più lungo è &quot;+&quot; e i tre più corti sono controllati con &quot;-&quot; (GND) sui GPIO. 
 Mescolando i colori è possibile creare molti altri colori. Ad esempio, controllando i colori &quot;blu&quot; e &quot;verde&quot; si ottiene il colore &quot;turchese&quot;, il rosso e il verde producono il giallo, il rosso e il blu producono il magenta e tutti e tre i colori con quantità uguali producono il bianco. 
       Lo schema del circuito: LED RGB su Raspberry Pi   
 Il codice del programma: LED RGB su Raspberry Pi 
 Esempio di programma per un LED RGB con catodo comune: 
 da gpiozero  importa  RGBLED
da time  import  sleep
 led  = RGBLED (rosso=14,   verde=15,   blu=18) 
 durata  =  2 

 # Aumenta lentamente l&#039;intensità di tutti i colori (5sec) 
per n  in  range (100 ):
    led .blue  =  n/100 
    led .rosso  =  n/100 
    led .verde  =  n/100    
    sleep (0.05 )
led .color  = (0 ,  0 ,  0 )  # spento 
sleep(durata)
led .red  =  1   # rosso pieno 
sleep(duration)
led .red  =  0.5   # mezzo rosso 
sleep(duration)
led .color  = (1 ,  1 ,  0 )  # giallo 
sleep(duration)
led .color  = (0 ,  1 ,  0 ) #   verde pieno 
sleep(duration)
led .color  = (0 ,  1 ,  1 ) #   ciano 
sleep(duration)
led .color  = (0 ,  0 ,  1 ) #   blu pieno 
sleep(duration)
led .color  = (1 ,  0 ,  1 ) #   magenta 
sleep(duration)
led .color  = (1 ,  1 ,  1 ) #   bianco 
sleep(duration)
led .color  = (0 ,  0 ,  0 ) #   spento 
sleep(duration) 
 Più avanti vedremo come utilizzare tre potenziometri per impostare i componenti del colore. Tuttavia, per questo abbiamo bisogno di un convertitore analogico-digitale esterno, perché il Raspberry Pi conosce solo i segnali digitali - HIGH o LOW. 
    
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Costruire un&#039;auto RC con Arduino: Veicolo autonomo - Parte 3</title>
            <id>https://funduinoshop.com/it/costruire-un-auto-rc-con-arduino-veicolo-autonomo-parte-3</id>
            <link href="https://funduinoshop.com/it/costruire-un-auto-rc-con-arduino-veicolo-autonomo-parte-3"/>
            <summary type="html">
                <![CDATA[
                
                                            Benvenuto alla terza puntata della nostra serie di blog sulle auto robot. Nella prima parte abbiamo appreso le basi del veicolo di base. Nella seconda parte abbiamo sviluppato un sistema di codici universali che ci permette di impostare i livelli di guida dell&#039;auto robot....
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Capire la mobilità del futuro con le auto robot, parte 3  
 Benvenuto alla terza puntata della nostra serie di blog sulle auto robot. Nella   prima parte  &amp;nbsp;abbiamo appreso le basi del veicolo di base. Nella   seconda parte  &amp;nbsp;abbiamo sviluppato un sistema di codici universali per definire le fasi di guida dell&#039;auto robot e abbiamo realizzato un semplice controllo a distanza con un telecomando a infrarossi. A causa dei limiti fisici di questo telecomando, in questa puntata vorrei mostrare la trasmissione delle istruzioni di guida con il Bluetooth, ad esempio da uno smartphone al ricevitore BT HC-05. Il Bluetooth è un segnale radio a 2,4 GHz con una portata ridotta. È sicuro fino a circa 10 metri e non subisce interferenze alla luce del sole. 
 Il modulo Bluetooth HC-05 è in realtà un  ricetrasmettitore = trasmettitore + ricevitore . Tuttavia, noi lo utilizziamo solo come ricevitore, mentre per inviare le istruzioni di guida utilizziamo un&#039;APP Bluetooth su uno smartphone Android (a causa del modo particolare in cui Apple utilizza il Bluetooth, non funziona con un iPhone). In linea di principio, è anche possibile costruire un telecomando Bluetooth con l&#039;HC-05; tuttavia, ciò richiede un secondo HC-05, un altro microcontrollore e un dispositivo di input (controller joystick). 
 &amp;nbsp;  
  Dei sei pin del modulo HC-05, solo quattro sono necessari: VCC (5V) e GND per l&#039;alimentazione del modulo e RXD e TXD per il collegamento ai due pin del microcontrollore in cui è impostato il SoftwareSerial. Tuttavia, non puoi ignorare la scritta LEVEL: 3.3V per non danneggiare il modulo. Sul nostro microcontrollore con logica a 5V, abbiamo bisogno di un partitore di tensione da 5V a 3,3V almeno per il pin RXD, ad esempio resistenze da 1 kOhm e 2,2 kOhm. 
 Lo schema del circuito: Modulo HC-05 sul microcontrollore    
 I comandi AT del modulo HC-05 per i microcontrollori Arduino 
 A sinistra del connettore contrassegnato dalla dicitura Key si trova un piccolo pulsante importante per la configurazione. Se questo pulsante viene premuto quando il modulo è acceso, entriamo nella modalità di comando AT (il LED lampeggia lentamente con un ritmo di 2s), in cui effettuiamo le impostazioni con i cosiddetti comandi AT (per Attenzione, Achtung). A questo scopo utilizziamo un programma di esempio modificato, in cui la solita interfaccia seriale è collegata al Serial Monitor dell&#039;IDE Arduino e all&#039;HC-05 tramite SoftwareSerial. 
  /*
  Test seriale multiplo del software
 Riceve dalla seriale hardware, invia alla seriale software.
 Riceve dalla seriale software, invia alla seriale hardware.
 Il circuito:
 * RX è il pin digitale 10 (collegato al TX di un altro dispositivo)
 * TX è il pin digitale 11 (collegato all&#039;RX di un altro dispositivo) // divisore di tensione!
 creato nella notte dei tempi
 modificato il 25 maggio 2012
 da Tom Igoe
 basato sull&#039;esempio di Mikal Hart
 Questo esempio di codice è di pubblico dominio.
 */ 
  #include   &amp;lt;SoftwareSerial.h&amp;gt;  
 SoftwareSerial  BTSerial (10 ,  11 );  // RX, TX // mySerial è stato cambiato in BTSerial 
 char  c= &#039; &#039; ;  // Dichiarazione della variabile per la trasmissione 

 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   loop () {  // Esegui ripetutamente 
  se  (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 
  }
} 
 Nella figura seguente vengono utilizzati i comandi AT essenziali. La stazione remota, l&#039;HC-05, invia una risposta se necessario e conferma con OK. 
 A noi interessano soprattutto il nome e l&#039;indirizzo HEX per poter identificare in modo univoco il modulo in seguito sullo smartphone. I comandi AT vengono inseriti nel monitor seriale del microcontrollore. Nell&#039;immagine seguente puoi vedere il monitor seriale dell&#039;IDE Arduino. 
 Se vuoi, puoi cambiare la password predefinita 1234 con &quot;AT+PSWD=xxxx &quot;, dove x sta per una cifra da 0 a 9. Poi controlla con &quot;AT+PSWD? &quot; se l&#039;inserimento è andato a buon fine.    Dopo aver completato gli inserimenti, il modulo viene brevemente scollegato dall&#039;alimentazione. Dopo la riaccensione senza premere alcun pulsante, il modulo HC-05 si trova in modalità standard. Il LED lampeggia rapidamente (circa 5 volte/s). 
 Modifiche all&#039;auto RC: un diverso scudo motore 
 Passiamo ora all&#039;auto robot. Dopo aver utilizzato la volta scorsa il controller del motore V2, che necessita solo dei due connettori I2C SDA=A4 e SCL=A5 per i segnali di controllo, questa volta voglio introdurre il più vecchio controller del motore V1, che blocca molti pin digitali, ma che spesso può essere acquistato a un prezzo vantaggioso.     Ho anche modificato un po&#039; questo motorshield per ottenere l&#039;accesso ai sensori e ai ricevitori radio. Sul lato dei pin digitali, c&#039;è solo un pin a cui si può accedere utilizzando un connettore angolato: Pin 2. Questo è utile per chi vuole collegare il ricevitore IR in questo punto. Ci sono più possibilità di estensione sull&#039;altro lato, dove puoi accedere a tutti gli ingressi analogici e all&#039;alimentazione con l&#039;aiuto di connettori femmina (chiamati anche connettori a presa). 
 Poiché tutti gli ingressi analogici possono essere utilizzati anche come ingressi o uscite digitali, abbiamo la possibilità di collegare qui i nostri ricevitori radio. Questo funziona benissimo con il ricetrasmettitore a 433 MHz HC-12 (vedi la prossima puntata), ma per il ricevitore BT HC-05 ci sono solo delle restrizioni. In primo luogo, non possiamo collegare direttamente il pin RXD, abbiamo bisogno del partitore di tensione, e in secondo luogo, i pin non forniscono una corrente sufficiente per alimentare il modulo su questi pin. 
 L&#039;immagine seguente mostra un piccolo adattatore che abbiamo realizzato noi stessi, che alimenta l&#039;HC-05 con 5 V e la massa dai pin appropriati, collega TXD direttamente a RX dell&#039;interfaccia SoftwareSerial A1 =D15 e RXD a A2 = D16 tramite il partitore di tensione.   
 Lo schema di cablaggio: Modulo HC-05 con Motorshield L293D sul microcontrollore Arduino     
 Naturalmente il circuito può essere realizzato anche su una mini breadboard con dei cavi di collegamento. 
 Come l&#039;ultima volta, il codice per le istruzioni di guida viene aumentato o diminuito con la semplice pressione di un pulsante; questa volta, però, non con il telecomando IR, ma con la funzione touch dell&#039;APP dello smartphone e l&#039;interrogazione Bluetooth tramite SoftwareSerial. 
 Accoppiamento del modulo Bluetooth HC-05 con un&#039;applicazione Android (APP) 
 Prima che l&#039;APP possa connettersi alla Robot Car, dobbiamo accoppiarla con il modulo Bluetooth nelle impostazioni. Dovrebbe essere abbastanza facile, visto che in precedenza abbiamo utilizzato i comandi AT per interrogare il nome e l&#039;indirizzo HEX dell&#039;HC-05. 
 Una volta che l&#039;accoppiamento ha funzionato e che è stata installata un&#039;app BT adatta, è possibile avviare e configurare il sistema. Toccando la lente di ingrandimento nell&#039;immagine a sinistra, vengono visualizzati i dispositivi adatti. Toccando l&#039;HC-05, viene visualizzato il messaggio &quot;connesso&quot;. L&#039;applicazione che utilizzo offre diverse interfacce per il funzionamento (immagine centrale). Ho deciso di utilizzare il controller di gioco. In alto a destra dell&#039;immagine centrale, ci sono due frecce che formano un piccolo cerchio. Tocca qui se la connessione è stata persa. 
 L&#039;immagine di destra mostra i pulsanti di un controller di gioco. Prima di utilizzarli per la prima volta, è necessario assegnare ai pulsanti i valori numerici che devono essere trasmessi quando si toccano. 
 Ai pulsanti del cursore ho assegnato i valori numerici da 1 a 4 in senso orario. Ho assegnato il valore numerico 5 agli altri pulsanti. Questi valori vengono passati nello sketch alla variabile  blueToothVal &amp;nbsp;e portano nei puntatori if della  funzione  loop()   &amp;nbsp;  alla determinazione del codice per il livello di guida.    
 I cambiamenti da infrarossi a Bluetooth e da controller motore V2 a V1 comportano alcune modifiche nella parte principale dello sketch. D&#039;altra parte, non cambia quasi nulla nella funzione motor(). Solo nella notazione, la funzione motor1-&amp;gt;setSpeed() diventa motor1.setSpeed() a causa delle diverse librerie del programma (librerie). 
 Il codice del programma: Costruire un&#039;auto RC per Arduino 
 * Codice di esempio  per  auto robot con Motor Shield V1 e ricevitore BT   HC-05 , al  20220515 
* basato sulla libreria Adafruit Motor shield V2, copyright Adafruit Industries LLC
*  questo  codice è di  pubblico  dominio, divertiti!
* modificato  per  Funduino
* Pin
* BT VCC a Arduino  5V out.
* BT GND a GND
* Arduino  A1=15  (SS RX) - BT TX non ha bisogno di un partitore di tensione
* Arduino  A2=16  (SS TX) - BT RX attraverso un partitore di tensione (da 5v a  3,3v )
*/

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

  #include   &amp;lt;SoftwareSerial.h&amp;gt;  
 // Inizializza HC-05 
 SoftwareSerial  BTSerial (15 ,  16 );  // RX, TX incrociati con TX, RX (divisore di tensione) 
 char  blueToothVal;
 int  x =  0 ;
 int  y =  0 ;
 int  left =  0 ;
 int  right =  0 ;
 int  codice =  5555 ;
 int  speedL =  0 ;
 float  factor =  1.8 ;  // Correzione per 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; );
}  // fine setup 

 void   loop () {
  if (BTSerial .available ())  //se i dati vengono ricevuti  ... 
 Serial.print(&quot;disponibile&quot;);     
{
    blueToothVal=BTSerial. read (); //..sollen diese ausgelesen werden 
 Serial.println(blueToothVal); 
  }
    if  (blueToothVal== &#039;1&#039; )  //se il modulo Bluetooth riceve 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; ) //se il   modulo Bluetooth riceve 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; ) //se il   modulo Bluetooth riceve 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; ) //se il   modulo Bluetooth riceve 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; ) //se il   modulo Bluetooth riceve un &quot;5&quot; ...
   {           
      code =  5555 ;
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);    
    }
    delay  (200 );  /piccolo ritardo per una migliore comunicazione seriale e per evitare rimbalzi 
    motor();
}  // termina il ciclo 

 void  motor(){
  int  speedLevel [9 ]={ -100 , -80 , -60 , -40 , 0 , 40 , 60 , 80 , 100 };
  y =  int (codice /  1000 );
  x =  int ((codice -  1000*y ) /  100 );
  speedL = speedLevel [y-1 ];
  Serial  .print ( &quot;codice = &quot; );
  Serial  .print (codice);
  Serial  .print ( &quot; y = &quot;);
  Serial . print (y);
  Serial  .print ( &quot; x = &quot;);
  Serial  .print (x);
  Serial  . print( &quot; velocitàL = &quot;);
  Serial  .println (speedL);

  //Correzione dei passi di velocità per le curve 
  se   (x==1 ){
    right = speedL+ 20 ;
    left = speedL -20 ;
  }
  altrimenti   se   (x==2 ){
    right = speedL+ 15 ;
    left = speedL -15 ;
  }
  se   (x==3 ) {
    right = speedL+ 10 ;
    left = speedL -10 ;
  }
  se   (x==4 ) {
    right = speedL+ 5 ;
    left = speedL -5 ;
  }
  se   (x==6 ) {
    right = speedL  -5 ;
    left = speedL+ 5 ;
  }
  se   (x==7 ) {
    right = speedL -10 ;
    left = speedL+ 10 ;
  }
  se   (x==8 ) {
    right = speedL -15 ;
    left = speedL+ 15 ;
  }
  se   (x==9 ) {
    right = speedL -20 ;
    left = speedL+ 20 ;
  }
  altrimenti  {
    right = speedL;
    left = speedL;
  }

  //Input dei passi di guida per &quot;sinistra&quot; e &quot;destra 
  Serial  .print ( &quot;sinistra = &quot; );
  Serial  .print (left);
  Serial  . print( &quot; destra = &quot; );
  Serial . println (right);

  se  (left &amp;lt;  40  &amp;amp; left &amp;gt;  -40 ) {
    motor1. run (RELEASE);
  }
  se  (destra &amp;lt;  40  &amp;amp; destra &amp;gt;  -40 ) {
    motor2. run (RELEASE);
  }
  se   (sinistra&amp;gt;=40 ) {
     if  (left&amp;gt; 100 ) left= 100 ;
      motor1. run (FORWARD);
      motor1. setSpeed (left * factor);
  }
  se   (destra&amp;gt;=40 ) {
     if  (right&amp;gt; 100 ) right= 100 ;
      motor2. run (FORWARD);
      motor2. setSpeed (right * factor);
  }
  se  (sinistra&amp;lt;=  -40 ) {
     if  (left&amp;lt; -100 ) left= -100 ;
      motor1. run (BACKWARD);
      left = -left;
      motor1. setSpeed (left * factor);
  }
  se  (destra&amp;lt;=  -40 ) {
     if  (right&amp;lt; -100 ) right= -100 ;
      motor2. run (BACKWARD);
      right = -right;
      motor2. setSpeed (right * factor);
  }
}  // fine motore  
 Questo è quanto per la seconda soluzione più economica per un&#039;auto robot con telecomando (supponendo che tu abbia uno smartphone Android). La prossima volta ti mostrerò come è facile integrare un ricetrasmettitore HC-12 a 433 MHz. In questo modo si possono raggiungere anche diverse centinaia di metri di portata. Tuttavia, i costi aumentano perché ora sono necessari due ricetrasmettitori e un altro microcontrollore. Ci vediamo allora. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">LED pulsante su Raspberry Pi (modulazione di larghezza di impulso)</title>
            <id>https://funduinoshop.com/it/led-pulsante-su-raspberry-pi-modulazione-di-larghezza-di-impulso</id>
            <link href="https://funduinoshop.com/it/led-pulsante-su-raspberry-pi-modulazione-di-larghezza-di-impulso"/>
            <summary type="html">
                <![CDATA[
                
                                            Si dice che un LED diventi sempre più luminoso e sempre più scuro. (Chiamato anche &quot;fade&quot;, dal verbo to fade). Vorremmo implementare questo fenomeno con la cosiddetta modulazione di larghezza degli impulsi...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Si dice che un LED diventi sempre più luminoso e sempre più scuro. (Chiamato anche &quot;fade &quot;, dal verbo inglese  to fade  =  svanire , diminuire). Vorremmo implementare questo fenomeno con la cosiddetta modulazione di ampiezza degli impulsi. Puoi trovare maggiori informazioni sulla modulazione dell&#039;ampiezza degli impulsi su Raspberry Pi qui sotto.  Nella prima fase, daremo un&#039;occhiata allo schema del circuito. 
 Lo schema del circuito: LED pulsante su Raspberry Pi (PWM) 
   
  Per variare la luminosità di un LED, non è sufficiente variare la tensione. A causa del design (diodo!), è necessaria una certa tensione minima; questa cosiddetta tensione di andata è compresa tra circa 1,6 e circa 3 V, a seconda del colore del LED. Al di sopra di questa tensione, il LED diventa conduttivo e la corrente è limitata da una resistenza in serie. Quindi, a differenza delle lampade a incandescenza, la luminosità non è regolata dal livello di tensione. Tra l&#039;altro, i pin GPIO forniscono esattamente 3,3V. 
 Il rimedio è la modulazione di larghezza degli impulsi (PWM). In questo modo la tensione continua viene attivata e disattivata ad alta frequenza. L&#039;energia totale trasmessa è determinata dal rapporto tra il duty cycle e la durata totale di un ciclo. Il ciclo di lavoro può essere compreso tra 0 e 100%. 
 Su Raspberry Pi, puoi utilizzare il PWM software su tutti i pin GPIO. Ma ci sono anche due speciali pin PWM hardware. Andiamo! 
 Il primo codice del programma: LED a impulsi su Raspberry Pi con modulazione di larghezza di impulso 
  # Iniziamo importando i moduli del programma 
import RPi.GPIO as GPIO  # Attenzione: nota la notazione: piccola i 
importare  tempo 
GPIO.setmode(GPIO.BCM)  # Impostiamo la modalità su BCM 
 LED=23   # La parola &quot;LED&quot; ora sta per il numero &quot; 23 &quot; .
GPIO.setup(LED,GPIO.OUT) #  &quot;LED&quot; (pin  23 ) è un&#039;uscita .
Dimmer = GPIO.PWM(LED ,100 )  # Impostiamo il LED come PWM con una frequenza di  100  
Dimmer.start (0 )  # Dimmer avviato 
 # Il ciclo inizia qui 
 try :
    while   True :  #while loop in modo che il programma venga eseguito continuamente 
        per  dc  in  range (0  ,101  ,5 ):          # Esegui un loop del ciclo di funzionamento a  passi di 5 . 
             Dimmer.ChangeDutyCycle(dc)  # Cambia il ciclo di funzionamento del dimmer. 
            time  .sleep  (0.1 )  # Aspetta  0.1  secondi. 
        for  dc  in  range (100  ,-1  ,-5 ):      # Esegui un loop del ciclo di funzionamento a passi di -5 . 
            Dimmer.ChangeDutyCycle(dc)  # Cambia il ciclo di funzionamento del dimmer. 
            time  .sleep  (0.1 )  # Aspetta  0.1  secondi. 
except KeyboardInterrupt:  # Con CTRL+C interrompiamo il programma 
    print (&quot;Finito&quot;)  # Scrivi &quot;Finito&quot; nella finestra della shell 
    Dimmer .stop ()  # Arresta il dimmer. 
    GPIO.cleanup()  # Termina il programma.  
 In questo esempio impariamo a conoscere un&#039;altra forma di ciclo: il ciclo for. Anche questa riga di comando termina con i due punti seguiti dall&#039;indentazione delle righe da ripetere. 
 La variabile dc (per il ciclo di lavoro) viene incrementata nell&#039;intervallo 0 fino a 101 escluso, con incrementi di cinque:  for dc in range(0,101,5) : 
 Il secondo ciclo for conta all&#039;indietro da 100 a -1 per -5:  for dc in range(100,-1,-5):  
 Il codice del secondo programma: LED a impulsi su Raspberry Pi con modulazione di larghezza di impulso con comando gpiozero    
 # Iniziamo importando i moduli del programma
da gpiozero importa PWMLED
importare tempo
pwmled = PWMLED (23 ) #  parametro  opzionale frequenza=xxx  (default 100) 

#  Il ciclo inizia qui
prova:
    while  True: # ciclo while in modo che il programma  venga eseguito   continuamente 
        per  dc in range(0,101,5):   # Incrementa il tasgrade a passi di 5. 
            pwmled.value  = (  dc/100 ) # Cambia il duty cycle (tra  0  e  1 ) del dimmer.
            time .sleep  (0.1 ) # Aspetta  0.1  secondi.
        per  dc in range (100  ,-1  ,-5 ): # Conta alla rovescia il ciclo di funzionamento a   passi di -5 .
            pwmled.value = (dc/100 ) #  Cambia il ciclo di funzionamento (tra 0 e 1) del dimmer. 
            time.sleep(0.1) # Aspetta  0.1 secondi .

except  KeyboardInterrupt: # Con CTRL+C interrompiamo il programma 
    print  (  &quot;Finito&quot;  ) # Scriviamo  &quot;Finito &quot; nella  finestra della shell 
# pwmled.value  = 0 # Primo metodo per  cancellare il LED al termine del programma 
    pwmled.close()  # 2° metodo per cancellare il LED  alla fine del programma 
 In generale, il codice del programma è più snello con gpiozero. 
 Nota bene: Il ciclo di lavoro è compreso tra 0 e 100%. Mentre l&#039;argomento per il ciclo di lavoro in RPi.GPIO è il valore %, gpiozero si aspetta che il valore sia un numero  in virgola  mobile (&amp;nbsp;) compreso tra 0,0 e 1,0, cioè 0,5 invece di 50 [%]. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Collegare il cicalino e il LED a Raspberry Pi</title>
            <id>https://funduinoshop.com/it/collegare-il-cicalino-e-il-led-a-raspberry-pi</id>
            <link href="https://funduinoshop.com/it/collegare-il-cicalino-e-il-led-a-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            In questo post vogliamo far illuminare o suonare un cicalino e un LED con l&#039;aiuto di un microcontrollore Raspberry Pi. Questo programma viene spesso utilizzato nelle scuole per dimostrare...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Nota: per questo programma è necessario un cicalino attivo (la spiegazione seguirà più avanti); è necessario prestare attenzione alla polarità. Non è necessaria una resistenza in serie per il cicalino (altoparlante). 
 In questo post vogliamo far illuminare o suonare un cicalino e un LED con l&#039;aiuto di un microcontrollore Raspberry Pi. Questo programma viene spesso utilizzato nelle scuole per mostrare come sia possibile utilizzare semplici segnali di uscita utilizzando un Raspberry Pi con semplici componenti.  Prima di entrare nel merito della differenza tra un altoparlante attivo e uno passivo, diamo un&#039;occhiata allo schema del circuito e al codice del programma. 
 Lo schema del circuito: Collegamento del cicalino e del LED al Raspberry Pi 
   
 Il codice sorgente: Collegamento del cicalino e del LED al Raspberry Pi 
  # Questa volta utilizziamo anche la prima sezione del programma. Le variabili vengono inserite qui. Ciò significa che c&#039;è un numero dietro una lettera o una parola. Nel nostro caso, il LED è collegato al pin 23 e l&#039;altoparlante piezoelettrico al pin 4. Per evitare di confondere i due pin in seguito, rinominiamo semplicemente il pin 23 e il pin 24. 
 # Iniziamo importando i moduli del programma 
 importa  RPI.GPIO  come  GPIO
 importare  tempo
GPIO.setmode(GPIO.BCM)  # Impostiamo la modalità su BCM 
 LED=23 ;  # La parola &quot;LED&quot; ora sta per il numero &quot;23&quot; .
 Beep=24 ;  # La parola &quot;Beep&quot; ora corrisponde al numero &quot;24&quot; .
GPIO.setup(LED,GPIO.OUT)  # Il pin &quot;LED&quot; (pin 23) è un&#039;uscita .
GPIO.setup(Pieps,GPIO.OUT) # Il   pin &quot;Pieps&quot; (pin 24) è un&#039;uscita 
 # Il ciclo inizia qui 
 try :
 while   True :  # ciclo while in modo che il programma venga eseguito continuamente 
GPIO.output(LED,GPIO.HIGH)  # Accende il LED. 
GPIO.output(Pieps,GPIO.HIGH) # Accende l&#039; altoparlante piezoelettrico .
time.sleep (1 )  # Aspetta 1 secondo 
GPIO.output(LED,GPIO.LOW)  # Spegne il LED. 
GPIO.output(Pieps,GPIO.LOW) #   Spegne l&#039;altoparlante piezoelettrico. 
time.sleep (1 )
 # Alla fine, il programma salta all&#039;inizio del ciclo while. Quindi sta per emettere un segnale acustico e accendersi di nuovo. Se aumenti o diminuisci la pausa (time.sleep), il bip e le luci si accendono più velocemente o più lentamente. 
 except  KeyboardInterrupt:  # Con CTRL+C interrompiamo il programma 
 print  (&quot;Finito&quot;)  # Scrivi &quot;Finito&quot; nella finestra della shell 
GPIO.cleanup()  # Esci dal programma  
 Differenza tra cicalino attivo e passivo 
 Il cicalino attivo ha un oscillatore incorporato che produce un  ronzio  quando viene applicata una tensione di 3,3V o 5V. A causa del design, devi prestare attenzione alla polarità del cicalino. Alla consegna, questi cicalini hanno solitamente un piccolo adesivo con il segno più e l&#039;indicazione &quot;RIMUOVERE IL SIGILLO DOPO IL LAVAGGIO&quot;. C&#039;è anche un segno più + sempre sul corpo del componente stesso. Devi guardare due volte per vedere la parte più lunga. Oppure puoi prendere una piccola scheda breakout; in questo caso i contatti sono contrassegnati da S (che sta per segnale) e - (meno, terra).&amp;nbsp; 
 Puoi provare il cicalino con un semplice programma come quello per il LED lampeggiante, in cui il pin (quasi) qualsiasi viene commutato su HIGH per un secondo e su LOW per un secondo. 
 Il cicalino passivo non ha un oscillatore incorporato, quindi è il Raspberry Pi a doversi occupare di questa funzione. Se provi il programma di cui sopra su un cicalino passivo, sentirai un leggero &quot;click&quot; ogni secondo. Tuttavia, se accorci il tempo di pausa (sleep(0.001) o sleep(0.002)) e ripeti l&#039;accensione e lo spegnimento per una certa durata, potrai sentire un suono la cui frequenza può essere facilmente calcolata: un millisecondo di HIGH o LOW significa (trascurando il tempo di esecuzione degli altri comandi) circa 500 cicli di accensione e spegnimento al secondo, cioè circa 500Hz. 
 Se vuoi emettere un breve segnale acustico, devi utilizzare un cicalino attivo che si accende e si spegne come un LED. Bisogna prestare attenzione alla polarità. 
 Se vuoi programmare una sirena a due toni (che si sente più chiaramente) o una breve melodia di riconoscimento (jingle), devi utilizzare un cicalino passivo o un piccolo altoparlante. 
    
 &amp;nbsp; 
 &amp;nbsp; 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Costruire un&#039;auto RC con Arduino: Veicolo autonomo - Parte 2</title>
            <id>https://funduinoshop.com/it/costruire-un-auto-rc-con-arduino-veicolo-autonomo-parte-2</id>
            <link href="https://funduinoshop.com/it/costruire-un-auto-rc-con-arduino-veicolo-autonomo-parte-2"/>
            <summary type="html">
                <![CDATA[
                
                                            Benvenuti alla seconda puntata della nostra nuova serie di blog sulle auto robot. Nella prima parte abbiamo conosciuto le basi del veicolo di base. Questa volta vogliamo parlare delle possibilità di controllo remoto, sviluppare un sistema di codici...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Capire la mobilità del futuro con le auto robot, parte 2  
 Benvenuti alla seconda puntata della nostra nuova serie di blog sulle auto robot. Nella  prima parte  abbiamo conosciuto le basi del veicolo di base. Questa volta vogliamo discutere le possibilità di controllo a distanza, sviluppare un sistema di codici con cui determinare i livelli di velocità dell&#039;auto robot e infine realizzare un semplice controllo a distanza con un telecomando a infrarossi. 
 Perché ho bisogno di livelli di velocità per un&#039;auto RC per microcontrollori Arduino? 
 1. Per controllare la velocità del motore da un altro dispositivo, c&#039;è fondamentalmente la possibilità di determinare e trasmettere continuamente i valori con un potenziometro (poti), oppure di aumentare o diminuire il valore del passo di velocità premendo un pulsante. Le immagini seguenti mostrano alcuni esempi selezionati, nella prima immagine i comandi del joystick: 
 &amp;nbsp;  
 &amp;nbsp; 
 Nella seconda immagine vediamo i telecomandi a infrarossi, un&#039;applicazione per smartphone con ricevitore Bluetooth e la tastiera LCD1602, che può essere utilizzata con un ricetrasmettitore a 433 MHz, tra le altre cose: 
 &amp;nbsp;  
 &amp;nbsp; 
 Per ottenere uno schema uniforme, è opportuno utilizzare la funzione map() per ridurre i valori analogici del piatto in valori che possano essere trasmessi via radio. Il convertitore analogico-digitale fornisce numeri a 10 bit, cioè valori compresi tra 0 e 1023. La posizione centrale dei mini-joystick è di circa 511. Dividendo il valore per 100, un joystick può determinare due valori (direzione x e y) compresi tra 0 e 10 o, se si utilizza la funzione map(), tra 1 e 9. Questo valore è sufficiente per inserire la velocità e la velocità di un veicolo. Questo è sufficiente per inserire la velocità e per le curve. Indipendentemente dal fatto che si determini un valore di 11 o 9, l&#039;arresto significa un valore di 5 nella direzione y e per la guida in rettilineo anche un valore di 5. 
 Guardando il controller con i due joystick (parte del  kit  del  braccio robotico Mini 4DOF con joystick e servoazionamento ), data la varietà di sistemi diversi, ho scelto un codice tra 1111 e 9999 che è facile da trasmettere. La prima cifra può essere utilizzata per la direzione y del joystick sinistro, la seconda cifra per la direzione x del joystick sinistro, la terza e la quarta cifra per un secondo joystick opzionale o per alcuni tasti. Nel primo esempio con il telecomando IR, abbiamo bisogno solo delle prime due cifre del codice a quattro cifre. 
 Il controllo della velocità dell&#039;auto RC per Arduino 
 Il controllo della velocità dei motori avviene con la modulazione di larghezza degli impulsi (PWM). Il valore del cosiddetto duty cycle è un numero a 8 bit, cioè un valore compreso tra 0 e 255 (=2 alla potenza di 8 -1). Se applichi al motore una tensione compresa tra 0 e 6 V con un alimentatore regolabile, noterai che fino a circa 1,5 V non si nota nulla. Poi il motore inizia a ronzare, ma non si muove. Se misuri contemporaneamente la corrente, noterai un valore relativamente alto. L&#039;energia viene convertita in calore e ronzio: non è proprio il massimo. A partire da 2,4 - 3 volt, il motore inizia a girare, l&#039;amperaggio scende leggermente quando il motore è scarico. Successivamente, la velocità aumenta in base alla tensione applicata. Quando si regola la tensione verso il basso, il motore gira fino a meno di 2 volt, ma se si ferma, ad esempio a causa di una maggiore resistenza di attrito o di un ostacolo, non riparte. Conclusione: i valori inferiori a circa 2,4 volt devono essere evitati, l&#039;ingresso deve essere impostato su 0 (zero) per evitare un&#039;inutile usura e consumo di energia. Ad eccezione dell&#039;arresto (codice=5), è necessario un Duty Cycle compreso tra circa il 40% e il 100% con una tensione di alimentazione di 6V per i motori. 
 L&#039;alimentazione dell&#039;auto RC per Arduino 
 Abbiamo già discusso diverse possibilità per l&#039;alimentazione nella prima parte. Quattro batterie AA da 1,5 V ciascuna forniscono 6 V, la tensione massima dei piccoli motori gialli. Quattro batterie AA da 1,2 V ciascuna non sono sufficienti per l&#039;alimentazione. È quindi necessario un portabatterie per 6 batterie, che fornisce 7,2 volt. Due batterie agli ioni di litio (tensione nominale di 3,7 V) forniscono oltre 8 volt quando sono completamente cariche. Quindi ha senso impostare un fattore nel programma che limiti la tensione del livello di pilotaggio più alto a 6V. 
 Controllare l&#039;auto RC con Arduino 
 Se le istruzioni di guida vengono impartite con dei pulsanti, che possono essere anche in un&#039;app per smartphone, il valore appropriato viene aumentato o diminuito per il valore di uscita 55xx (arresto) senza superare il massimo. 
 Leggere correttamente il codice 
 L&#039;assegnazione della prima cifra del codice ai valori richiesti delle fasi della corsa avviene tramite l&#039;indice di un elenco con i rispettivi valori numerici. 
 Conclusione: con un codice a quattro cifre, possiamo controllare la velocità e la curva con le prime due cifre, mentre le altre due cifre sono utilizzate per altre funzioni (non richieste all&#039;inizio). Quindi, ad esempio, codice95xx per la velocità massima in rettilineo, 55xx per l&#039;arresto, 77xx per l&#039;avanzamento a destra.&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; 
 Ora vogliamo costruire la nostra prima Smart Robot Car con il kit, un microcontrollore ATmega328 (progetto UNO R3), un MotorShield V2 e un trasmettitore e ricevitore IR. 
 Il Motor Shield V2 può controllare fino a quattro motori, utilizzando il cosiddetto bus I2C con i collegamenti SDA (=Serial Data) all&#039;ingresso analogico A4 e SCL (=Serial Clock) ad A5 per il collegamento delle linee di controllo. Adafruit ha anche sviluppato e fornito una libreria di programmi adatta a questo scopo. Attenzione: le librerie per i Motor Shield V1 e V2 non sono compatibili. 
 &amp;nbsp;  
 Immagine Motor Shield V2 con modifica:  Connettori a presa saldata (connettori femmina) per il collegamento di apparecchiature aggiuntive 
 Indipendentemente dalla Motor Shield che vuoi utilizzare - V1 o V2 -,&amp;nbsp; è opportuno saldare connettori aggiuntivi per entrambe le Motor Shield per poter collegare in seguito trasmettitori/ricevitori Bluetooth o a 433 MHz o sensori. Maggiori informazioni in merito nei prossimi post del blog. Il ricevitore IR ha bisogno di alimentazione solo dai pin 3 e 4 e dal pin 2 per il ricevitore IR. Il saldatore può rimanere freddo. 
 Per il controllo utilizzeremo innanzitutto il piccolo telecomando a infrarossi di Funduino e un ricevitore IR. Anche se il sensore IR &quot;nudo&quot; è sufficiente, ti consiglio di utilizzare la piccola scheda breakout, perché in questo caso un LED lampeggia quando vengono ricevuti i segnali IR; uno strumento prezioso quando si cerca un guasto. 
 Lo sketch è composto da due parti collaudate: Lo sketch di esempio di Armin Joachimsmeyer, che ha aggiunto alla sua fantastica libreria di programmi IRremote, e uno sketch di Robot Car realizzato dall&#039;autore sulla base della libreria di programmi di Adafruit. 
 Il codice del programma per l&#039;auto RC per Arduino 
  /* Codice di esempio per Robot Car con Motor Shield V2 e ricevitore IR, al 20220515
* basato sulla libreria Adafruit Motor shield V2, copyright Adafruit Industries LLC, 2009
* e SimpleReceiver.cpp, parte di Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote
* Licenza MIT Copyright (c) 2020-2022 Armin Joachimsmeyer
* modificato per Funduino
* Motor Shield V2 utilizza I2C con SDA=A4 e SCL=A5
* Il ricevitore IR utilizza il pin 2
 ************************************************************************************
 * Con la presente si concede il permesso, a titolo gratuito, a chiunque ottenga una copia di questo software e dei file di documentazione ad esso associati (vedi pagina 5)
 * di questo software e dei file di documentazione associati (il &quot;Software&quot;), di utilizzare il Software senza alcuna restrizione, compresi i seguenti diritti
 * nel Software senza alcuna restrizione, compresi, senza limitazioni, i diritti di
 * di utilizzare, copiare, modificare, unire, pubblicare, distribuire, concedere in sublicenza e/o vendere
 * copie del Software, e di permettere alle persone a cui il Software è fornito
 * di farlo, alle seguenti condizioni:
 *
 * Il suddetto avviso di copyright e il presente avviso di autorizzazione devono essere inclusi in tutte le copie o parti sostanziali del Software
 * copie o parti sostanziali del Software.
 *
 * IL SOFTWARE VIENE FORNITO &quot;COSÌ COM&#039;È&quot;, SENZA GARANZIE DI ALCUN TIPO, ESPRESSE O IMPLICITE,
 * INCLUSE, A TITOLO ESEMPLIFICATIVO E NON ESAUSTIVO, LE GARANZIE DI COMMERCIABILITÀ, IDONEITÀ PER UNO SCOPO PARTICOLARE E NON VIOLAZIONE
 * SCOPO PARTICOLARE E NON VIOLAZIONE. IN NESSUN CASO GLI AUTORI O I TITOLARI DEL COPYRIGHT
 * SARANNO RESPONSABILI DI QUALSIASI RECLAMO, DANNO O ALTRA RESPONSABILITÀ, SIA IN UN&#039;AZIONE LEGALE CHE IN UN ILLECITO O ALTRO, DERIVANTI DA
 * CONTRATTO, ILLECITO O ALTRO, DERIVANTI DA, IN RELAZIONE AL SOFTWARE O ALL&#039;USO O AD ALTRI RAPPORTI CON ESSO
 * O ALL&#039;USO O AD ALTRI RAPPORTI CON IL SOFTWARE.
 *************************************************************************************/ 
 
  #include   &amp;lt;Adafruit_MotorShield.h&amp;gt;  
 // Crea l&#039;oggetto motor shield con l&#039;indirizzo I2C predefinito 0x60 
Adafruit_MotorShield AFMS = Adafruit_MotorShield();
 // Seleziona quale &quot;porta&quot; M1, M2, M3 o M4.  
Adafruit_DCMotor *motor1 = AFMS.getMotor (2 );
Adafruit_DCMotor *motor2 = AFMS.getMotor (3 );

 // definiamo il protocollo per il controllo remoto, per maggiori informazioni consulta il codice di esempio SimpleReceiver.cpp 
  #define  DECODE_NEC  // Include Apple e Onkyo, anche per il piccolo telecomando Funduino  
 //#define INFO // Per visualizzare informazioni preziose dal decodificatore universale per i protocolli di larghezza o distanza degli impulsi 
  #define  IR_RECEIVE_PIN 2  // invece di #include &quot;PinDefinitionsAndMore.h&quot;  
  #include   &amp;lt;Arduino.h&amp;gt;  
  #includere   &amp;lt;IRremote.hpp&amp;gt;  

 // Segnale del ricevitore IR collegato al Pin2, VCC al Pin3, GND al Pin4 
 int  IR_GND =  4 ;  
 int  IR_VCC =  3 ;

 int  x =  0 ;
 int  y =  0 ;
 int  left =  0 ;
 int  destra =  0 ;
 int  codice =  5555 ;
 int  speedL =  0 ;
 float  factor =  1.8 ;  // Correzione per speedLevel 255/100 * 6V/VBatt 

 void   setup () {
  Serial  .begin  (9600 );
  Serial  .println ( &quot;Test del motore! &quot;);
  Serial  .println ( &quot;Motorshield v2 - Test motore DC!&quot; );
  se  (!AFMS .begin ()) {          // create with the default frequency 1.6KHz 
     Serial . println ( &quot;Could not find Motor Shield. Check wiring.&quot; );
     while  ( 1 );
  }
  Serial  .println ( &quot;Motor Shield trovato.&quot; );
  // Solo per sapere quale programma è in esecuzione sul mio Arduino 
  Serial  .println (F( &quot;START &quot;  __FILE__  &quot; da &quot;  __DATE__  &quot;\r\nUsing library version &quot;  VERSION_IRREMOTE));
  // Avvia il ricevitore 
  IrReceiver .begin (IR_RECEIVE_PIN);  //, ENABLE_LED_FEEDBACK); 
  Serial  .print (F( &quot;Pronto a ricevere i segnali IR dei protocolli: &quot; ));
  printActiveIRProtocols (&amp;amp;Serial );
  Serial  . print(F( &quot;al pin &quot; ));
  Serial  .println (IR_RECEIVE_PIN);  
  // inizializzare i pin digitali come uscita per l&#039;alimentazione 
  pinMode (IR_GND ,OUTPUT );
  pinMode (IR_VCC ,OUTPUT );
  digitalWrite (IR_GND ,LOW );
  digitalWrite (IR_VCC ,HIGH );    
}  // fine della configurazione 

 void   loop () {
  se  (IrReceiver.decode()) {
      // Stampa un breve riassunto dei dati ricevuti 
      IrReceiver.printIRResultShort (&amp;amp;Serial );
      se  (IrReceiver.decodedIRData.protocol == UNKNOWN) {
           // We have an unknown protocol here, print more info 
          IrReceiver.printIRResultRawFormatted(&amp;amp; Serial , true);
      }
      Serial  .println ();
      /*
       * importante!!! Abilita la ricezione del valore successivo,
       * poiché la ricezione si è interrotta dopo la fine dell&#039;attuale pacchetto di dati ricevuti.
       */ 
      delay  (100 );  // Debounce, nessun fast retry      
      IrReceiver.resume(); // Abilita la ricezione del   valore successivo 
      /*
       * Infine, controlla i dati ricevuti ed esegue le azioni in base al comando ricevuto
       */ 
  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);
    }
  else   if  (IrReceiver.decodedIRData.command ==  0x44 )  {
     if  (code -1000 * int (code/ 1000 ) &amp;gt;  200 )   code = code -  100 ;
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  se  (IrReceiver.decodedIRData.command ==  0x40 )  {
    code =  5555 ;
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  altrimenti  {
     Serial . print ( &quot;invalid code&quot; );
    }
  motore();
  }
}  // fine del ciclo 

 void  motor(){
  int  speedLevel [9 ]={ -100 , -80 , -60 , -40 , 0 , 40 , 60 , 80 , 100 };
  y =  int (codice /  1000 );
  x =  int ((codice -  1000*y ) /  100 );
  speedL = speedLevel [y-1 ];
  Serial  .print ( &quot;codice = &quot; );
  Serial  .print (codice);
  Serial  .print ( &quot; y = &quot;);
  Serial . print (y);
  Serial  .print ( &quot; x = &quot;);
  Serial  .print (x);
  Serial  . print( &quot; velocitàL = &quot;);
  Serial  .println (speedL);

  //Correzione dei passi di velocità per la curva 
  se   (x==1 ){
    right = speedL+ 16 ;
    left = speedL -16 ;
  }
  altrimenti   se   (x==2 ){
    right = speedL+ 13 ;
    left = speedL -13 ;
  }
  se   (x==3 ) {
    right = speedL+ 10 ;
    left = speedL -10 ;
  }
  se   (x==4 ) {
    right = speedL+ 7 ;
    left = speedL -7 ;
  }
  se   (x==6 ) {
    right = speedL  -7 ;
    left = speedL+ 7 ;
  }
  se   (x==7 ) {
    right = speedL -10 ;
    left = speedL+ 10 ;
  }
  se   (x==8 ) {
    right = speedL -13 ;
    left = speedL+ 13 ;
  }
  se   (x==9 ) {
    right = speedL -16 ;
    left = speedL+ 16 ;
  }
  altrimenti  {
    right = speedL;
    left = speedL;
  }

  //Input dei passi di guida per &quot;sinistra&quot; e &quot;destra 
  Serial  .print ( &quot;sinistra = &quot; );
  Serial  .print (left);
  Serial  . print( &quot; destra = &quot; );
  Serial . println (right);

  se  (left &amp;lt;  40  &amp;amp; left &amp;gt;  -40 ) {
    motor1-&amp;gt; run (RELEASE);
  }
  se  (destra &amp;lt;  40  &amp;amp; destra &amp;gt;  -40 ) {
    motor2-&amp;gt; run (RELEASE);
  }
  se   (sinistra&amp;gt;=40 ) {
     if  (left&amp;gt; 100 ) left= 100 ;
      motor1-&amp;gt; run (FORWARD);
      motor1-&amp;gt; setSpeed (left * factor);
  }
  se   (destra&amp;gt;=40 ) {
     if  (right&amp;gt; 100 ) right= 100 ;
      motor2-&amp;gt; run (FORWARD);
      motor2-&amp;gt; setSpeed (right * factor);
  }
  se  (sinistra&amp;lt;=  -40 ) {
     if  (left&amp;lt; -100 ) left= -100 ;
      motor1-&amp;gt; run (BACKWARD);
      motor1-&amp;gt; setSpeed (-left * factor);
  }
  se  (destra&amp;lt;=  -40 ) {
     if  (right&amp;lt; -100 ) right= -100 ;
      motor2-&amp;gt; run (BACKWARD);
      motor2-&amp;gt; setSpeed (-right * factor);
  }
}  // fine del motore 
 
 Spiegazione del codice del programma per l&#039;auto RC 
 Dopo aver incluso le librerie Motor Shield V2 e IRremote, i due motori vengono istanziati con il numero alla morsettiera del controller e alcune variabili globali vengono dichiarate (tipo di dati) e inizializzate (valore iniziale). 
 Nella funzione  setup()  vengono inizializzati l&#039;interfaccia seriale e il ricevitore IR e i pin per l&#039;alimentazione del ricevitore IR vengono impostati come uscite con lo stato HIGH o LOW. 
 Nella funzione  loop() , prima viene ricevuto il segnale del telecomando IR, poi il codice per il controllo del motore viene cambiato a seconda del tasto premuto. I tasti cursore in alto e in basso modificano la prima cifra, a sinistra e a destra la seconda cifra del codice nell&#039;intervallo di valori da 1 a 9. Il tasto X porta all&#039;arresto con il codice 5555. La terza e la quarta cifra del codice non sono ancora significative. Alla fine, la funzione autodefinita  motor()  viene richiamata senza argomenti, poiché abbiamo definito le variabili in modo globale, cioè valide per tutte le funzioni. 
 Nella funzione autodefinita  motor() , che utilizzeremo anche in altre configurazioni con altri telecomandi, i livelli di velocità per il motore destro e sinistro sono determinati dal codice. Il valore percentuale del livello di velocità viene infine convertito nel valore PWM per  setSpeed  utilizzando il fattore definito all&#039;inizio. 
 &amp;nbsp;  
 L&#039;auto robot è ora pronta per essere utilizzata. Funziona bene finché riesci a mantenere la connessione ottica tra il telecomando e il ricevitore IR. Tuttavia, durante la guida su strada, ho sperimentato che la forte luce del sole ostacola la ricezione. Ecco perché sto passando al radiocomando. A presto. 
                ]]>
            </content>

                            <updated>2022-06-09T07:30:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">I LED del microcontrollore Raspberry Pi lampeggiano in modo alternato</title>
            <id>https://funduinoshop.com/it/i-led-del-microcontrollore-raspberry-pi-lampeggiano-in-modo-alternato</id>
            <link href="https://funduinoshop.com/it/i-led-del-microcontrollore-raspberry-pi-lampeggiano-in-modo-alternato"/>
            <summary type="html">
                <![CDATA[
                
                                            Puoi collegare i componenti elettronici sulla breadboard anche senza un T-cobbler. In questo caso, però, hai bisogno di cavetti del tipo femmina - maschio per il collegamento alla striscia di connettori J6 del Raspberry Pi....
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Come si fa a far lampeggiare alternativamente due LED su Raspberry Pi? 
 Puoi collegare i componenti elettronici sulla breadboard anche senza T-cobbler. In questo caso, però, hai bisogno di un cavallotto del tipo femmina-maschio per il collegamento alla striscia di connettori J6 del Raspberry Pi, cioè presa per il Raspberry Pi e spina per la breadboard. 
   
  Il codice del programma (LED lampeggiante in alternanza sul Raspberry Pi)   
  # Da qui il codice può essere copiato direttamente nel software Python. 
 # Nero, colorato = codice e grigio = spiegazioni 
 #Iniziamo con l&#039;importare i moduli del programma 
importa RPI.GPIO  come  GPIO
importare  tempo 
GPIO.setmode(GPIO.BCM)  #Imposteremo la modalità su BCM 
GPIO.setup (23 ,GPIO.OUT) #Il   pin 23 è un&#039;uscita .
GPIO.setup (24 ,GPIO.OUT) #Il pin   24 è un&#039;uscita. 
 # Il ciclo inizia qui 
 try :
    while  True:  #Ciclo While in modo che il programma venga eseguito continuamente 
        GPIO.output (23 ,GPIO.HIGH)  # Accende il LED sul pin 23 .
        GPIO.output (24 ,GPIO.LOW) #   Spegne il LED sul pin 24 .
        time .sleep (1 )  # Aspetta 1 secondo 
        GPIO.output (23 ,GPIO.LOW) #   Spegne il LED sul pin 23 .
        GPIO.output (24 ,GPIO.HIGH) # Accende il LED sul   pin 24 .
        time .sleep (1 )
 # Alla fine il programma salta all&#039;inizio del ciclo. Quindi.. 
 # ... accende il LED al pin 23. 
 # ... ecc... ecc... ecc.. 
except KeyboardInterrupt:  # Con CTRL+C interrompiamo il programma 
    print ( &quot;Finito &quot; ) # Scriviamo &quot;Finito&quot; nella finestra della shell
    GPIO.cleanup() # Termina il programma
  
 Nell&#039;esempio n. 01 LED lampeggiante abbiamo realizzato il ciclo infinito con il while True e l&#039;indentazione delle righe di codice successive. Se hai annullato questo ciclo infinito con la combinazione di tasti Ctrl-C, avrai notato che in primo luogo viene visualizzato un messaggio di errore e in secondo luogo il LED potrebbe continuare ad accendersi. Per evitare questi due effetti indesiderati, in questo esempio sono state aggiunte alcune righe di codice. La riga  try:  è stata inserita prima del ciclo while true. I due punti indicano l&#039;indentazione dell&#039;intero ciclo. Se si verifica un errore in questo ciclo durante l&#039;esecuzione del programma, non viene visualizzato alcun messaggio di errore, ma il programma continua a  eccezione di KeyboardInterrupt: . Con il comando print, la fine del programma viene stampata nella shell Python (finestra inferiore di Thonny), mentre con GPIO.cleanup(), i GPIO (cioè i nostri LED) vengono spenti e liberati per altri scopi. 
 Esempio: ciclo di semafori su Raspberry Pi 
 Ecco una soluzione proposta per un ciclo di semafori utilizzando il modulo gpiozero: 
   
   
   
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Costruire un&#039;auto RC con Arduino: Veicolo autonomo - Parte 1</title>
            <id>https://funduinoshop.com/it/costruire-un-auto-rc-con-arduino-veicolo-autonomo-parte-1</id>
            <link href="https://funduinoshop.com/it/costruire-un-auto-rc-con-arduino-veicolo-autonomo-parte-1"/>
            <summary type="html">
                <![CDATA[
                
                                            Benvenuto in una nuova serie di blog sulle auto robot. Nella prima parte, ne conosceremo le basi, per così dire come aiuto alla decisione di acquisto, quale telaio, quale microcontrollore e quale tipo di telecomando...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Capire la mobilità del futuro con le auto robot  
 Benvenuto in una nuova serie di blog sulle auto robot. Nella prima parte ne conosceremo le basi, per così dire, come aiuto per decidere quale telaio, quale microcontrollore e quale tipo di telecomando sono più adatti. 
 Due o quattro ruote: valutare i pro e i contro della costruzione di auto RC per Arduino 
 Partiamo dal telaio e analizziamo i vantaggi e gli svantaggi dei kit economici con due o quattro ruote motorizzate. Tutti hanno in comune i motori elettrici, quindi questi da soli non sono un criterio di selezione. I robot a due ruote sono inizialmente più economici perché non hanno il costo di altri due motori elettrici e ruote. Al contrario, hanno una o due ruote di supporto, che conferiscono alle auto RC una grande manovrabilità. Quindi, se vuoi &quot;far girare il piatto&quot;, questa è la strada da percorrere. Tuttavia, in questa fascia di prezzo dei motori DC, non puoi aspettarti che funzionino in modo fluido e preciso. Pertanto, la corsa rettilinea non è così buona come quella della versione a quattro ruote. Soprattutto all&#039;avvio, i motori mostrano una maggiore stabilità direzionale, ma le curve sono possibili solo con raggi molto più ampi. Un altro vantaggio del telaio a quattro ruote è il maggiore spazio per le batterie, il microcontrollore, eventualmente il convertitore DC/DC e i sensori. 
   
 La scelta del microcontrollore per costruire un&#039;auto RC 
 La domanda successiva riguarda il microcontrollore e la sua programmazione. Ad esempio, un micro computer del tipo Raspberry Pi ha la massima potenza di calcolo su un telaio di dimensioni ridotte. Soprattutto per quanto riguarda il controllo remoto, i tipi con WiFi e Bluetooth integrati offrono dei vantaggi e puoi persino trasmettere le immagini da una fotocamera Raspberry Pi. La programmazione avviene nel linguaggio di programmazione Python, molto diffuso, ma l&#039;avvio del sistema operativo Raspberry Pi OS basato su Linux richiede circa un minuto. Un altro svantaggio del Raspis (abbreviazione di Raspberry Pi) è la necessità di un buon alimentatore a 5V. Ciò richiede un buon convertitore DC/DC. 
 In relazione all&#039;argomento del controllo remoto Bluetooth, in una prossima puntata verrà mostrato un esempio con Raspberry Pi e l&#039;APP Android BlueDot di Martin O&#039;Hanlon (membro dello staff della Raspberry Pi Foundation). 
 L&#039;avvio del sistema è molto più rapido con un microcontrollore basato su ATmega 328, ad esempio  Funduino Uno  o  Funduino&amp;nbsp;Nano . Dopo circa un secondo dall&#039;accensione, puoi iniziare a controllare gli ingressi, senza dover avviare il sistema da una scheda microSD; il programma caricato non viene dimenticato. La tensione di ingresso può essere compresa tra 5 e 9 volt. La programmazione avviene nell&#039; IDE Arduino , un ambiente di sviluppo simile a C/C++ (per ulteriori spiegazioni vedi  https://funduino.de/hardware-software) . Per questo motivo, vedremo prima degli esempi con la Funduino Uno R3, per la quale sono disponibili dei controllori di motori perfetti come i cosiddetti shield. Questi vengono semplicemente inseriti nella Uno e le cosiddette librerie ci aiutano nella programmazione. 
 Excursus: Cos&#039;è un controller/motor driver? 
 A causa della corrente molto limitata alle uscite dei microcontrollori, le utenze più grandi - e questo include tutti i tipi di motori elettrici e relè - richiedono un&#039;alimentazione esterna e un circuito elettronico che converta il segnale di controllo del microcontrollore. Tuttavia, i requisiti di questo circuito integrato sono ancora più elevati: da un lato, deve consentire una velocità variabile del motore e, dall&#039;altro, vogliamo anche essere in grado di cambiare il senso di rotazione del motore invertendo la polarità. 
 Utilizzando il circuito integrato L293D come esempio, ora ne spiegheremo il funzionamento. In pratica, questo componente DIP con sedici &quot;gambe&quot;/collegamenti è sufficiente come controllore di due motori elettrici.     
 Il circuito integrato viene alimentato con la tensione nelle connessioni VCC1 e Ground. Possiamo prelevare questa tensione dal microcontrollore. L&#039;alimentazione dei motori avviene tramite VCC2 e Terra. Qui si collega la batteria (o le batterie) (ad esempio 6 o 9 volt). Con i motori più grandi è necessario raffreddare il circuito integrato, mentre con i piccoli motori gialli del kit non è necessario. 
 Colleghiamo un motore a 1Y e 2Y, le linee di controllo corrispondenti alla MCU (Micro Controller Unit) sono 1A, 2A e 1.2EN. 
 L&#039;inversione della polarità dei motori per cambiare la direzione di marcia si effettua con un cosiddetto circuito ad H. Lo realizziamo con il nostro microcontrollore impostando due pin di uscita (questi vanno a 1A e 1B) su HIGH o LOW. 
 Il cambio di velocità avviene come nell&#039; esempio n. 04 - LED pulsante  con modulazione dell&#039;ampiezza degli impulsi (PWM), ovvero con l&#039;accensione e lo spegnimento molto rapido della tensione. Pertanto, per i collegamenti 1,2EN (&quot;Enable&quot;) è necessaria un&#039;uscita PWM sull&#039;MCU (sono i pin con la tilde ~). 
 Per il secondo motore, i collegamenti 3A, 4A e 3,4EN sono collegati ai pin dell&#039;MCU. 
 L&#039;immagine a destra (Diagramma logico) spiega il funzionamento del circuito integrato. Possiamo vedere i quattro amplificatori che danno i segnali di ingresso da 1A a 4A rispettivamente con la tensione della batteria alle uscite da 1Y a 4Y. Tuttavia, questo avviene solo se anche gli ingressi PWM 1,2EN e 3,4EN sono commutati su HIGH. 
 Due di questi circuiti integrati L293D sono installati sulla Motor Shield V1, in modo da poter collegare fino a quattro motori. 
 Per non utilizzare troppi pin, al centro della Motor Shield V1 è presente un cosiddetto registro a scorrimento (SN74HC595). Spiegarne il funzionamento andrebbe oltre lo scopo di questo articolo. Fortunatamente, i nostri colleghi di Adafruit a New York hanno fatto la maggior parte della programmazione per noi e hanno fornito una libreria per controllare facilmente i motori.    
 Immagine Motor Shield V1 con modifica:   Connettori a presa saldata (connettori femmina) per collegare altre apparecchiature 
 &amp;nbsp; 
 Anche la Motor Shield V2 può controllare fino a quattro motori e utilizza un circuito integrato simile, ma per il collegamento delle linee di controllo si utilizza il cosiddetto bus I2C con le connessioni SDA (=Serial Data) all&#039;ingresso analogico A4 e SCL (=Serial Clock) ad A5. Adafruit ha anche sviluppato e fornito una libreria di programmi adatta a questo scopo. 
   
 Immagine Motor Shield V2 con modifica:  Connettori a presa saldati (connettori femmina) per il collegamento di apparecchiature aggiuntive 
 Entrambi i Motor Shield hanno connettori femmina aggiuntivi saldati per collegare in seguito trasmettitori/ricevitori Bluetooth o 433 MHz o sensori. Maggiori informazioni in uno dei seguenti post del blog. 
 Alimentazione e controllo di un&#039;auto RC per microcontrollori Arduino 
 Se vogliamo che la nostra auto robot si guidi da sola, dobbiamo scollegarla dalla porta USB del PC. Questo significa che anche l&#039;alimentazione viene meno. D&#039;ora in poi, la centrale di comando (MCU) e i motori elettrici saranno alimentati da batterie o pile ricaricabili. I motori sono di gran lunga i maggiori consumatori. Il portabatterie fornito con la maggior parte dei kit è per quattro batterie Mignon (AA), cioè 6 volt per MCU e motori. Se vuoi usare batterie ricaricabili, devi usare sei batterie Mignon (AA) o due batterie 18650 agli ioni di litio a causa del voltaggio più basso. 
 Per quanto riguarda i controlli, nelle prossime puntate conosceremo i telecomandi con telecomando a infrarossi, i ricetrasmettitori Bluetooth con APP per smartphone o un secondo microcontrollore sempre con ricetrasmettitore BT HC-05 e i radiocomandi a 433Mhz e 2,4 GHz. La serie di blog si concluderà con gli aspetti della guida autonoma, in particolare il rilevamento degli ostacoli. A presto. 
 &amp;nbsp; 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">LED lampeggiante sul microcontrollore Raspberry Pi</title>
            <id>https://funduinoshop.com/it/led-lampeggiante-sul-microcontrollore-raspberry-pi</id>
            <link href="https://funduinoshop.com/it/led-lampeggiante-sul-microcontrollore-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            A differenza di Arduino, il Raspberry Pi non ha accesso ai LED integrati. Questi indicano solo l&#039;alimentazione e l&#039;accesso alla scheda µSD. Per far lampeggiare un LED, è necessario un LED esterno con...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Come si fa a far lampeggiare un LED su Raspberry Pi? 
  A differenza di Arduino, su Raspberry Pi non hai accesso ai LED integrati. Questi indicano solo l&#039;alimentazione e l&#039;accesso alla scheda µSD.  
 Per far lampeggiare un LED, è necessario un LED esterno con una resistenza in serie adeguata e dei cavi di collegamento. Il modo più sensato per realizzare il circuito è su una breadboard con un T-cobbler. Questo tipo di configurazione facilita anche gli esperimenti successivi con diversi LED, pulsanti e sensori. La programmazione avviene con il linguaggio di programmazione Python. 
 Lo schema del circuito (LED lampeggiante su Raspberry Pi) 
   
 Che cos&#039;è un LED? 
 LED è l&#039;acronimo di Light Emitting Diode (diodo a emissione luminosa). L&#039;ultima parola indica le proprietà elettroniche. Un diodo è un semiconduttore che lascia passare la corrente solo in una direzione e la blocca nell&#039;altra. Le due &quot;gambe&quot; sono chiamate anodo e catodo. Se guardi da vicino, puoi notare che le gambe sono di lunghezza diversa. La tensione positiva viene applicata alla gamba più lunga, l&#039;anodo; la gamba più corta, il catodo, è collegata a terra tramite un resistore. Il resistore è necessario a causa di un&#039;altra proprietà dei diodi. Innanzitutto, è necessaria una tensione minima affinché possa scorrere una corrente: Questa si chiama tensione di andata. A tensioni più elevate, il diodo diventa completamente conduttivo. Per questo motivo è necessario un resistore in serie per limitare la corrente, perché i pin del microcontrollore e anche del Raspberry Pi devono essere caricati con un massimo di 15-20 mA. Utilizziamo resistenze in serie con valori compresi tra 100 e 330 Ω (Ohm). 
 Il linguaggio di programmazione Python può essere esteso con moduli di programma, in modo simile al C/C++ con le librerie. Per il nostro LED lampeggiante, abbiamo bisogno di due di questi moduli: il primo, &quot;time&quot;, per definire la durata del lampeggio. In secondo luogo, un modulo per accedere ai GPIO (General Purpose Input/Output). 
 Come si controlla un LED con un Raspberry Pi? 
 L&#039;importazione dei moduli avviene all&#039;inizio del programma Python; hai diverse opzioni per farlo. Esempi: 
 La riga seguente importa il modulo  time : 
  import   time  
 Quando si chiama il metodo  sleep  , il nome del modulo  time  deve essere preceduto da un punto: 
  time  .sleep  (1 ) 
 A differenza di delay(), dove l&#039;intervallo di tempo è indicato come argomento in millisecondi, con  time.sleep()  i valori sono indicati in secondi, se necessario con un punto decimale. 
  importa  RPi.GPIO  come  GPIO 
 Questo semplifica le chiamate ai metodi del programma, ad esempio 
  GPIO  .setmode  (GPIO  .BCM ) 
 Terzo esempio per un altro modulo per l&#039;accesso a GPIO: 
 da gpiozero  importa  LED 
 Solo la classe LED viene importata dal modulo  gpiozero . Con questo metodo di importazione, il nome del modulo non ha più il prefisso quando viene chiamato il metodo/funzione. 
 Programmi di esempio per controllare un LED con un microcontrollore Raspberry Pi 
 Primo esempio con il modulo RPi.GPIO: 
 importa RPi.GPIO come GPIO
importare  tempo 
GPIO.setmode(GPIO.BCM) # Nome del pin per il processore Broadcomm 
GPIO.setup (26 ,GPIO.OUT) #  GPIO26 (=pin 37) diventa un&#039;uscita 

 while  True: # Ciclo infinito, annulla con Ctrl-C 
    GPIO .output  (26  ,1 ) # GPIO 26 viene portato in ALTO 
    time  .sleep  (1 )
    GPIO .output  (26  ,0 ) # Il GPIO  26 viene commutato a BASSO 
    time  .sleep  (1 )
 
 Secondo esempio con il modulo gpiozero. Vengono importati solo  LED  e  sleep . 
  da  gpiozero importa LED
 da   time  import  sleep 
redLED = LED (26 ) # redLED è istanziato sul GPIO  26  

 mentre   True :
    redLED.on() #  redLED è acceso 
    sleep  (1 )
    redLED.off() #  redLED è spento 
    dormi  (1 )
 
 Sfida: Estendi il circuito e il programma per un ciclo semaforico, ad esempio rosso(3s), rosso/giallo(1s), verde(3s), giallo(1s), riavvia con il rosso. 
 Soluzione suggerita vedi n. 02 L&#039;indicatore alternato 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Come iniziare con il Raspberry Pi - Parte 3: Programmazione</title>
            <id>https://funduinoshop.com/it/come-iniziare-con-il-raspberry-pi-parte-3-programmazione</id>
            <link href="https://funduinoshop.com/it/come-iniziare-con-il-raspberry-pi-parte-3-programmazione"/>
            <summary type="html">
                <![CDATA[
                
                                            Di base, puoi anche installare l&#039;IDE Arduino sul Raspberry Pi o utilizzare il programma preinstallato Geany, un editor molto funzionale, in vari linguaggi di programmazione....
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 In linea di principio, puoi anche installare l&#039;IDE Arduino sul Raspberry Pi o programmare in vari linguaggi di programmazione con il programma preinstallato Geany, un editor molto funzionale, ma il Raspberry Pi prende il nome dal linguaggio di programmazione Python; in origine, era previsto solo come  interprete   Python . Quindi: chi dice di programmare il Raspberry Pi di solito intende il linguaggio Python, molto diffuso e facile da imparare. 
 Negli ultimi anni, il programma Thonny si è affermato come ambiente di sviluppo integrato (IDE) per i  programmi Python. 
 &amp;nbsp;  
 Di base si distingue tra l&#039;editor nella parte superiore della finestra, dove vengono scritti i programmi, e la shell nella parte inferiore, dove i programmi vengono eseguiti con eventuali input e output. Tuttavia, puoi anche inserire brevi comandi direttamente nella shell. 
 I programmatori esperti devono cliccare su &quot;Passa alla modalità normale&quot; nell&#039;angolo in alto a destra dello schermo per visualizzare la barra dei menu. 
 &amp;nbsp;  
 Se vuoi imparare il linguaggio di programmazione in modo autodidattico, puoi farlo con l&#039;aiuto di un gran numero di libri. A questo punto, si consiglia il metodo &quot;learning by doing&quot;, cioè di copiare semplicemente gli esempi di programmazione. La maggior parte del codice del programma è autoesplicativo. Questo è il bello di Python. 
 Per evitare inutili frustrazioni, a questo punto è bene ricordare alcune regole, rivolte soprattutto a chi passa da Arduino C/C++: 
 A differenza del C/C++, il tipo di variabile non deve essere dichiarato. Python riconosce il tipo al primo utilizzo. Se inserisci type  (&quot;abc&quot;)  nella shell, ad esempio, otterrai come output &amp;lt;class &#039;str&#039;&amp;gt;; la stringa del tipo viene riconosciuta grazie alle virgole. 
 La riga di comando non viene terminata con un punto e virgola. Al contrario, Python richiede un&#039;attenta attenzione all&#039;indentazione. Quindi: ogni comando inizia sempre nella prima posizione del paragrafo. 
 Le rientranze (di solito tab=quattro spazi) vengono fatte (di solito automaticamente) per i rami, i cicli o le funzioni autodefinite, eventualmente più volte. 
 I nomi dei programmi e delle variabili iniziano sempre con una lettera o con il trattino basso _. Successivamente possono essere utilizzati anche i numeri. Il trattino basso è l&#039;unico carattere speciale consentito e di solito viene utilizzato per scopi speciali. 
 Come detto: ulteriori spiegazioni su Python con esempi di programmi. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Iniziare con il Raspberry Pi - Parte 2: Hardware e software</title>
            <id>https://funduinoshop.com/it/iniziare-con-il-raspberry-pi-parte-2-hardware-e-software</id>
            <link href="https://funduinoshop.com/it/iniziare-con-il-raspberry-pi-parte-2-hardware-e-software"/>
            <summary type="html">
                <![CDATA[
                
                                            Una breve introduzione ai componenti più importanti per Raspberry Pi. Che si tratti di cavi, resistenze o LED, ti mostriamo quali sono i componenti necessari per iniziare. Inoltre, ci occupiamo dell&#039;installazione del software per Raspberry Pi e...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Hardware e software per il Raspberry Pi 
 Hardware per il Raspberry Pi 
     
 Accessori di base per il Raspberry Pi 
 Oltre ai sensori e agli attuatori, hai bisogno di&amp;nbsp; cavi plug-in &amp;nbsp;in combinazione con una breadboard&amp;nbsp; come base per un set-up sperimentale veloce e flessibile. In questo modo si risparmia il lavoro di saldatura che richiede molto tempo. Inoltre, i diodi luminosi &amp;nbsp;&amp;nbsp; sono molto adatti per controllare il segnale in uscita dalla scheda. 
 La breadboard 
 La breadboard è un ottimo strumento per costruire circuiti senza saldare. In una breadboard, diversi contatti sono sempre collegati in fila. Pertanto, molti cavi possono essere collegati tra loro in questi punti senza doverli saldare o avvitare. 
 L&#039;immagine seguente mostra a colori quali contatti sono collegati tra loro. 
 &amp;nbsp;  
 Scheda plug-in standard per Raspberry Pi e microcontrollore.   Le linee verdi nell&#039;immagine mostrano il percorso dei conduttori. 
 Per una buona connessione del Raspberry Pi alla breadboard, esistono i cosiddetti T-cobbler con un cavo a nastro che porta fuori tutti i 40 pin. 
   
 Diodo a emissione luminosa (LED) per Raspberry Pi 
 Con i LED puoi verificare molto rapidamente i risultati di un progetto. Per questo motivo sono utili per quasi tutti i progetti Arduino. In rete puoi trovare molte informazioni sui LED. Ecco solo le informazioni più importanti. 
   
 
 La corrente può attraversare il LED in una sola direzione. Pertanto, deve essere collegato correttamente. Un LED ha un contatto più lungo e uno più corto. Il contatto più lungo è + e quello più corto è -. 
 Un LED è progettato per una determinata tensione. Se questa tensione viene superata, il LED si illumina meno o rimane spento. Tuttavia, se la tensione viene superata, il LED si brucia molto rapidamente e si scalda molto sui contatti (ATTENZIONE!). 
 Valori tipici di tensione in base ai colori dei LED: Blu:3,1V, Bianco:3,3V, Verde:3,7V, Giallo:2,2V, Rosso:2,1V La tensione delle porte digitali della scheda è di 5V. Se collegato direttamente a queste porte, ogni LED si spegne abbastanza rapidamente. Pertanto, è necessario collegare un resistore al circuito. Su Internet trovi un&#039;ottima guida con il termine di ricerca &quot;resistore calcolatore LED&quot;. 
 Raccomandazioni non vincolanti per i resistori dei seguenti LED (se collegati ai pin a 5 V della scheda del microcontrollore).   
 
 
 
 
 LED 
 Bianco 
 Rosso 
 Giallo 
 Verde 
 Blu 
 Infrarossi (IR) 
 
 
 Resistenza 
 100 Ohm 
 200 Ohm 
 200 Ohm 
 100 Ohm 
 100 Ohm 
 100 Ohm 
 
 
 
 &amp;nbsp; 
 Cavo a innesto o filo di ponticello per Raspberry Pi 
 I cavi di collegamento sono disponibili in diverse versioni, per lo più di lunghezza pari a 10 cm o 20 cm, sia con spina che con presa. Qui mm=maschio-maschio=spina su entrambi i lati, mf=maschio-femmina=spina su un lato, presa sull&#039;altro e ff=femmina-femmina=con prese su entrambi i lati. 
   
 Pulsanti e interruttori per Raspberry Pi 
 Il primo e più semplice sensore è il pulsante, un interruttore a molla che riapre il contatto elettrico quando viene rilasciato. 
   
 Software per Raspberry Pi 
 Il sistema operativo Raspberry Pi OS può essere scaricato gratuitamente dalla  homepage della Raspberry Pi Foundation . La versione a 32 bit è attualmente identica per tutti i modelli. Per scrivere sulla scheda µSD (da 8 a 32 GB) del PC, si consiglia il programma Imager, anch&#039;esso scaricabile dalla homepage della Fondazione. 
 Installare il software 
   
 Avvio del Raspberry Pi 
 Durante il primo avvio, viene impostato il sistema operativo. Tra le altre cose, vengono inseriti i dati di accesso alla WLAN locale. Dalla primavera, il nome utente pi non viene più utilizzato automaticamente, ma ti viene chiesto di inserire un nome utente e una password. Dopo un riavvio al termine dell&#039;inizializzazione, si avvia l&#039;interfaccia grafica. Questo processo dura poco più di un minuto. 
 Quando fai clic sull&#039;icona, ti viene chiesto se vuoi che vengano visualizzati solo i possibili aggiornamenti o se vuoi avviarli direttamente. 
 La seguente schermata è stata scattata con il programma preinstallato &quot;scrot&quot; (per lo screenshot ). 
 &amp;nbsp;  
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Iniziare con il Raspberry Pi - Parte 1: La prefazione</title>
            <id>https://funduinoshop.com/it/iniziare-con-il-raspberry-pi-parte-1-la-prefazione</id>
            <link href="https://funduinoshop.com/it/iniziare-con-il-raspberry-pi-parte-1-la-prefazione"/>
            <summary type="html">
                <![CDATA[
                
                                            Questa guida vuole essere una base per imparare il sistema operativo Raspberry Pi OS con particolare attenzione al linguaggio di programmazione Python. Si propone di fornire ai principianti una guida facile, interessante e...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Che cos&#039;è &quot;Raspberry Pi&quot;?  
 Questa guida vuole essere una base per l&#039;apprendimento del sistema operativo Raspberry Pi con particolare attenzione al linguaggio di programmazione Python. Il suo scopo è quello di fornire ai principianti un&#039;introduzione semplice, interessante e strettamente guidata ai temi del &quot;pensiero computazionale&quot; e del &quot;physical computing&quot;. Il tutorial è orientato principalmente a compiti pratici con un&#039;introduzione teorica preliminare. È fondamentale leggerla in anticipo per non fallire nelle attività pratiche successive a causa di banalità. 
 Questo manuale è stato sviluppato nel contesto di un&#039;attività didattica. Può essere utilizzato gratuitamente per imparare le basi dei computer Raspberry Pi, ma non può essere copiato o utilizzato in altro modo senza autorizzazione. Il manuale è stato preparato con cura e viene costantemente aggiornato, ma non si garantisce la sua accuratezza e completezza. 
 Per le attività pratiche, devi procurarti alcuni componenti elettronici. Sul sito web funduinoshop.de puoi ordinare i set di sensori adatti, progettati appositamente per queste istruzioni. 
 A differenza del microcontrollore (ad esempio Funduino Uno o Nano), il Raspberry Pi, che oggi conta un gran numero di modelli diversi, è un vero e proprio computer con un sistema operativo basato su Linux (Raspberry Pi OS, precedentemente Raspbian). Il sistema operativo, i programmi applicativi e i dati si trovano su una scheda µSD (da 8 a 32 GB), che viene caricata all&#039;avvio. Le interfacce più importanti sono inizialmente le prese USB per tastiera e mouse e le interfacce HDMI per il monitor.    
 Raspberry Pi B (2012) 
 Il grande successo del Raspberry Pi si basa sia sulla programmazione con il diffusissimo linguaggio di programmazione Python, sia sulla possibilità di collegare componenti elettronici all&#039;header J6 a 40 pin (spesso chiamato GPIO strip). Questo è identico per tutti i modelli dal 2014. Quando si parla di nomenclatura, bisogna fare attenzione se si intende il pin fisico (nell&#039;immagine a sinistra i numeri dispari da 1 a 39, a destra i numeri pari da 2 a 40) o la designazione GPIO. Ad esempio, il pin fisico 11 corrisponde al GPIO17 (connettore General Purpose Input Output 17 del processore). I GPIO sono quindi ingressi o uscite digitali, come nel caso del microcontrollore. 
   
 Immagine del connettore J6: 40 pin, di cui 2x3,3V, 2x5V, 8xGround, 26xGPIO, 2 riservati 
  Alcuni dei pin hanno un&#039;assegnazione secondaria come interfaccia elettronica, ad esempio One Wire al pin 7, I2C (= Inter-Integrated Circuit) ai pin 3 e 5, UART (= Universal Asynchronous Receiver and Transmitter) ai pin 8 e 10 e SPI (=Serial Peripheral Interface) ai pin 19, 21, 23 e 24 o 26. Questa assegnazione secondaria è definita nel sistema operativo nella configurazione del Raspberry Pi. Maggiori informazioni in merito nei rispettivi esempi. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Convertitore di livello in microelettronica</title>
            <id>https://funduinoshop.com/it/convertitore-di-livello-in-microelettronica</id>
            <link href="https://funduinoshop.com/it/convertitore-di-livello-in-microelettronica"/>
            <summary type="html">
                <![CDATA[
                
                                            Spesso nei circuiti elettronici, due dispositivi o moduli devono comunicare tra loro. Ancora più spesso, questi due moduli richiedono un livello di tensione diverso. Nella microelettronica...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Dove vengono utilizzati i convertitori di livello nella microelettronica? 
 Spesso nei circuiti elettronici due dispositivi o moduli devono comunicare tra loro. Ancora più spesso, questi due moduli richiedono un livello di tensione diverso. Nella microelettronica, ad esempio in un microcontrollore Arduino, questo livello di tensione è solitamente di 3,3V o 5V. Se si dovesse collegare direttamente un modulo da 3,3V e uno da 5V, il modulo con una tensione massima di funzionamento di 3,3V si distruggerebbe con un livello di 5V applicato.&amp;nbsp; 
 Per evitare questo inconveniente, si utilizzano i cosiddetti convertitori di livello. I convertitori di livello consentono quindi la comunicazione tra due moduli con livelli di tensione diversi. È particolarmente interessante il fatto che i convertitori di livello funzionino in due direzioni senza dover cambiare nulla nel collegamento. Il segnale può quindi essere inviato da un modulo all&#039;altro. I convertitori di livello sono quindi adatti anche alle linee I2C. Inoltre, è possibile aumentare o diminuire il livello di tensione degli ingressi o delle uscite di commutazione.&amp;nbsp; 
   
 Convertitori di livello: come funzionano? 
 L&#039;immagine qui sopra mostra chiaramente come funziona la trasmissione del segnale all&#039;interno di un convertitore di livello per 3,3 e 5V. Sulla scheda, il livello di 5V (HV, &quot;High Voltage&quot;) e il livello di 3,3V (LV, &quot;Low Voltage&quot;) sono direttamente opposti. Va notato che il modulo utilizzato in questo esempio (l&#039;articolo è linkato qui sotto) può &quot;commutare&quot; solo pochi milliampere. Il modulo non è adatto a commutare motori o lampade, ad esempio. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Il modulo MPU-6050: Giroscopio e accelerometro</title>
            <id>https://funduinoshop.com/it/il-modulo-mpu-6050-giroscopio-e-accelerometro</id>
            <link href="https://funduinoshop.com/it/il-modulo-mpu-6050-giroscopio-e-accelerometro"/>
            <summary type="html">
                <![CDATA[
                
                                            Ci sono pochi moduli sul mercato che hanno suscitato un tale clamore negli ultimi mesi come il modulo MPU-6050. Il circuito stampato due in uno combina due popolari...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Sono pochi i moduli sul mercato che hanno suscitato un tale clamore negli ultimi mesi come il modulo MPU-6050. La scheda due-in-uno combina due popolari funzioni di sensore: Il modulo può essere utilizzato sia come giroscopio che come sensore di accelerazione.  Come? Il sensore comprende un giroscopio a 3 assi e un accelerometro a 3 assi su uno stesso chip. Ciò significa che&amp;nbsp;può richiamare tutti (!) i valori del sensore allo stesso tempo. Ciò significa che gli hobbisti sono sempre ben informati sulla posizione attuale del sensore. Questa caratteristica è particolarmente interessante per il modellismo, soprattutto per il bilanciamento di telai o droni. Inoltre, è possibile accedere a magnetometri esterni o ad altri sensori tramite un bus I2C master aggiuntivo, in modo da poter registrare completamente anche i dati di questi sensori.&amp;nbsp; 
 I dati dei sensori della MPU-6050 (GY-521) in sintesi: 
 
 Chipset: MPU-6050 (noto anche come GY-521) 
 Alimentazione: 3,3 - 5V DC 
 Linea di libertà: 6* 
 Interfaccia: I2C 
 Spaziatura tra i pin: 2,54 mm   
 
 Ora veniamo alla parte più interessante: la pratica. Per darti una buona panoramica delle funzioni utili del modulo MPU-6050, abbiamo sviluppato per te uno schema di circuito di esempio. Il modulo MPU-6050 viene letto da una Funduino UNO R3 e i dati registrati vengono valutati.  Siamo interessati soprattutto ai dati del sensore del giroscopio. Vogliamo leggere i valori degli assi X, Y e Z e determinare se c&#039;è stato un cambiamento nella posizione del sensore. La variazione di posizione deve essere visualizzata con dei LED colorati. 
   
 Fin qui tutto bene: ma come possiamo implementare tutto questo? 
 Il codice di programma del modulo MPU-6050 
 Ora è il momento di passare ai dettagli, o meglio alla metà di essi. Per prima cosa dobbiamo scaricare la libreria appropriata per il modulo MPU6050 e integrarla nel nostro IDE Arduino. La libreria si chiama &quot;&amp;lt;MPU6050_tockn.h&amp;gt;&quot; e può essere trovata e installata direttamente tramite la gestione delle librerie dell&#039;IDE di Arduino. 
 Dopo questo primo passo, iniziamo con il codice vero e proprio. Per prima cosa, definiamo i collegamenti per i nostri LED, che serviranno come indicatori della posizione dell&#039;asse. Poi definiamo due variabili per la posizione dell&#039;asse di ciascuno dei tre assi.&amp;nbsp; 
 Probabilmente ti starai chiedendo perché abbiamo bisogno di due variabili per asse. Poiché vogliamo determinare se la posizione del rispettivo asse è cambiata, dobbiamo prima determinare il valore che il sensore ha registrato per la posizione corrente. Salviamo questo valore del sensore dell&#039;MPU-6050 per un breve periodo di tempo nella prima variabile. Il valore della posizione dell&#039;asse viene salvato nuovamente nella seconda variabile poco dopo. Ora possiamo confrontare i due valori misurati registrati tra loro. Se viene registrata una deviazione della posizione di un minimo precedentemente definito (+-3 nel nostro esempio di codice), possiamo supporre che il sensore abbia modificato la posizione. In questo caso, accendiamo il LED assegnato.&amp;nbsp; 
 Particolarmente interessante: i dati di misurazione acquisiti possono essere visualizzati nel plotter seriale dell&#039;IDE di Arduino.   
  // Questo sketch confronta gli angoli degli assi X/Y/Z con i valori precedenti. 
 // Se differiscono di +/-3°, lo sketch commuta i LED. (ogni 1 per POS o per NEG) 
 // Attenzione: non si tratta di valori assoluti ma di valori RELATIVI rispetto alla misurazione precedente 


  #include   &amp;lt;MPU6050_tockn.h&amp;gt;   // Include librerie  
  #include   &amp;lt;Wire.h&amp;gt;   // &amp;lt;-  

MPU6050 mpu6050 (Wire ,  0.1 ,  0.1 );  // Smorzamento dei valori. Più piccoli (direzione &quot;0&quot;), più nervosi sono i valori
                                  // più grandi (direzione &quot;1&quot;), più lenti sono i valori 

 const   int  ledXpos  =2 ;  //*** 
 const   int  ledXneg  =3 ;  // * 
 const   int  ledYpos  =4 ;  // * Imposta i collegamenti dei LED 
 const   int  ledYneg  =5 ;  // *
 const   int  ledZpos  =6 ;  // *
 const   int  ledZneg  =7 ;  //*** 

 int  xNowPos;  // variabile CURRENT X-Pos 
 int  yNowPos;  // variabile CURRENT Y-Pos 
 int  zNowPos; // Variabile CURRENT   Z-Pos 

 int  xPrePos;  // Variabile X-Pos PRECEDENTE 
 int  yPrePos;  // Variabile Y-Pos PRECEDENTE 
 int  zPrePos;  // Variabile Z-Pos PRECEDENTE 

 int  difference =  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   loop () {  // inizio del ciclo di loop 

  mpu6050.update();  // crea un nuovo set di dati nel giroscopio 

xNowPos=(mpu6050.getGyroAngleX());  // Richiedi un nuovo set di dati dal giroscopio, scrivi nella variabile X 
yNowPos=(mpu6050.getGyroAngleY()); //   Richiedi un nuovo set di dati dal giroscopio, scrivi nella variabile Y 
zNowPos=(mpu6050.getGyroAngleZ());  // Richiedi un nuovo set di dati dal giroscopio, scrivi nella variabile Z 

 if  (xNowPos &amp;lt; xPrePos-(difference))  // Confronta il vecchio set di dati con quello nuovo. Differenza &amp;lt; -3 ? 
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  HIGH );}  // Allora cambia i LED di conseguenza 
 else   if  (xNowPos &amp;gt; xVorPos+(differenza))  // Confronta i dati vecchi con quelli nuovi. Differenza &amp;lt; +3 ? 
{ digitalWrite (ledXpos,  HIGH );  digitalWrite (ledXneg,  LOW );}  // Allora commuta i LED di conseguenza 
 else   // Oppure spegni tutti i LED X ...
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  LOW );}  // Allora cambia i LED di conseguenza 

 if  (yNowPos &amp;lt; yPrePos-(difference))  // Confronta il vecchio set di dati con quello nuovo. Differenza &amp;lt; -3 ? 
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  HIGH );}  // Allora commuta i LED di conseguenza 
 else   if  (yNowPos &amp;gt; yVorPos+(differenza))  // Confronta il vecchio set di dati con quello nuovo. Differenza &amp;lt; +3 ? 
{ digitalWrite (ledYpos,  HIGH );  digitalWrite (ledYneg,  LOW );}  // Allora commuta i LED di conseguenza 
 else   // Oppure spegni tutti i LED Y ...
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  LOW );}  // Allora commuta i LED di conseguenza 

 if  (zNowPos &amp;lt; zPrePos-(difference))  // Confronta il vecchio set di dati con quello nuovo. Differenza &amp;lt; -3 ? 
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  HIGH );}  // Allora commuta i LED di conseguenza 
 else   if  (zNowPos &amp;gt; zPrePos+(differenza))  // Confronta il vecchio set di dati con quello nuovo. Differenza &amp;lt; +3 ? 
{ digitalWrite (ledZpos,  HIGH );  digitalWrite (ledZneg,  LOW );}  // Allora commuta i LED di conseguenza 
 else   // Oppure spegni tutti i LED Z ...
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  LOW );}  // Allora commuta i LED di conseguenza 

xVorPos=xJetztPos;  // Aggiorna il vecchio set di dati (finora) 
yVorPos=yJetztPos;  // aggiorna il vecchio set di dati (finora) 
zVorPos=zJetztPos;  // Aggiorna il vecchio record (finora) 
                                     // Poi, nell&#039;esecuzione successiva, può essere confrontato di nuovo con &quot;prima&quot; 

 Serial  .print (xNowPos);  // &amp;gt;&amp;gt; plotter seriale&amp;lt;&amp;lt; ortografico [output X] 
 Serial  .print ( &quot; &quot; ) ;Serial  .print (yJetztPos);  // (&quot; &quot;) = (\t) = Nuovo colore [output   Y] 
 Serial  . print( &quot; &quot; ) ;Serial  .println (zNowPos);  // (&quot; &quot;) = (\t) = Nuovo colore [uscita   Z] 
  delay  (15 );  // (un ritardo minimo calma l&#039;uscita seriale) 
}  // fine del ciclo 


 // Sentiti libero di sperimentare un po&#039; con lo smorzamento nella terza riga del programma 
 //-&amp;gt; MPU6050 mpu6050(Wire, 0.3, 0.3); 
 // o con il delay() alla fine. Osserva poi i valori nel PLOTTER &amp;gt;&amp;gt;seriale &amp;lt;&amp;lt;  
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Controllore di velocità PWM in microelettronica</title>
            <id>https://funduinoshop.com/it/controllore-di-velocita-pwm-in-microelettronica</id>
            <link href="https://funduinoshop.com/it/controllore-di-velocita-pwm-in-microelettronica"/>
            <summary type="html">
                <![CDATA[
                
                                            Prima dello sviluppo dell&#039;elettronica di potenza, il controllo della velocità dei motori DC (a spazzole) veniva risolto con regolatori lineari o resistenze in serie. In senso figurato, il...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Origine dei regolatori di velocità PWM 
 Prima dello sviluppo dell&#039;elettronica di potenza, il controllo della velocità&amp;nbsp;dei motori DC (a spazzole) veniva risolto con regolatori lineari o&amp;nbsp;resistenze in serie. In pratica, la tensione&amp;nbsp;(e quindi anche la corrente) veniva ridotta per modificare la velocità. 
 Tuttavia, questa soluzione presenta alcuni svantaggi, che diventano evidenti soprattutto nel funzionamento a batteria&amp;nbsp;. La tensione e la corrente vengono convertite in energia termica (non utilizzata) (&quot;bruciata&quot;) nell&#039;unità di controllo (o&amp;nbsp;nella resistenza). 
 Il consumo totale rimane molto alto, mentre la potenza&amp;nbsp;utilizzabile diventa minore.&amp;nbsp;Poiché la coppia dipende dal flusso di corrente, anche questo crolla. 
 Come funzionano i regolatori di velocità PWM 
 &amp;nbsp;Con l&#039;ulteriore sviluppo dell&#039;elettronica di potenza, il problema è stato affrontato con un&#039;idea&amp;nbsp;diversa.&amp;nbsp;Accendendo e spegnendo (molto) rapidamente la tensione di alimentazione, la tensione (e quindi la corrente) viene &quot;pulsata&quot;.&amp;nbsp;Durante il periodo di &quot;OFF&quot;, l&#039;interruttore (elettronico) non perde potenza.&amp;nbsp;Ciò significa che non ci sono (quasi) più perdite nel regolatore. 
 Durante il tempo di &quot;ON&quot;, al motore viene applicata la tensione completa.&amp;nbsp;Di conseguenza,&amp;nbsp;la corrente - e quindi la coppia - è corrispondentemente alta.&amp;nbsp;Sfortunatamente, un motore con le sue bobine e il suo nucleo di ferro non è un&amp;nbsp;consumatore ohmico ideale, motivo per cui questa affermazione non è completamente corretta da un punto di vista fisico.&amp;nbsp; 
 &amp;nbsp;Tuttavia, la combinazione dell&#039;induttanza della bobina e dell&#039;inerzia del motore aiuta a&amp;nbsp;smussare la velocità, in modo che il motore si comporti come&amp;nbsp;se funzionasse con una tensione continua. 
 &amp;nbsp; 
   
 &amp;nbsp; 
 Questo ci porta agli svantaggi della modulazione di larghezza di impulso.&amp;nbsp;La modulazione con una tensione a onda quadra porta all&#039;emissione di&amp;nbsp;più frequenze radio. Questo comporta un&#039;interferenza EMC che può portare a errori insidiosi, soprattutto con i controllori&amp;nbsp;. 
 Nella bassa gamma di frequenze PWM (1-2kHz), si verificano sgradevoli&amp;nbsp;rumori di fischio sul motore.&amp;nbsp;A questo punto si potrebbe semplicemente aumentare la frequenza di commutazione.&amp;nbsp;Tuttavia, la corrente non ha il tempo sufficiente per raggiungere il suo stato massimo&amp;nbsp;nella bobina/avvolgimento.&amp;nbsp;Oscilla quindi tra due valori di stato non stabili, il che porta a&amp;nbsp;un&#039;ondulazione di corrente. 
 Un&#039;ondulazione di corrente eccessiva aumenta il riscaldamento dell&#039;avvolgimento,&amp;nbsp;riducendo le prestazioni e la durata del motore&amp;nbsp;. 
 ... un bel po&#039; di fisica per un piccolo componente. 
 Ora la buona notizia:&amp;nbsp;Per i motori di questa classe di potenza, questi svantaggi sono abbastanza accettabili&amp;nbsp;. Accontentiamoci dei vantaggi precedentemente descritti. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Il modulo PN532 NFC RFID - Comunicazione in campo vicino</title>
            <id>https://funduinoshop.com/it/il-modulo-pn532-nfc-rfid-comunicazione-in-campo-vicino</id>
            <link href="https://funduinoshop.com/it/il-modulo-pn532-nfc-rfid-comunicazione-in-campo-vicino"/>
            <summary type="html">
                <![CDATA[
                
                                            In questo articolo vogliamo mostrarti come leggere i tag ID. Il fulcro dell&#039;articolo è il modulo PN532 NFC RFID. Il modulo si basa sul chip PN532 di NXP. Questo chipset è particolarmente popolare nel campo dell&#039;NFC (near field communication)....
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 RFID? NFC? Che cos&#039;è? 
 In questo articolo vogliamo mostrarti come leggere i tag ID. Il fulcro dell&#039;articolo è il modulo PN532 NFC RFID.&amp;nbsp; 
 Il modulo si basa sul chip PN532 di NXP. Questo chipset è molto utilizzato nel campo dell&#039;NFC (Near Field Communication). Un oggetto abilitato alla NFC, spesso una carta assegni con un chip NFC, viene avvicinato a un lettore NFC. In questo modo è possibile scambiare informazioni in una frazione di secondo.&amp;nbsp; 
 Ti sembra astratto? Se hai una carta EC più recente e la usi per i pagamenti contactless, allora conosci l&#039;NFC anche nella vita di tutti i giorni. Appoggiando la carta sul terminale, la transazione viene avviata in modo semplice e veloce. 
 Vogliamo dare un&#039;occhiata più da vicino ai processi tecnici che stanno alla base di tutto questo. Il modulo PN532 è ideale per questo scopo, in quanto è in grado di gestire sia I2C che SPI. Il tipo di comunicazione desiderata può essere selezionata direttamente sulla scheda PN532, agendo sugli interruttori presenti su di essa. La posizione degli interruttori necessaria per le rispettive interfacce si trova a destra dello schema elettrico, un po&#039; più in basso nella pagina. 
 &amp;nbsp; 
 Lo schema elettrico: 
   
 Suggerimento: puoi trovare una versione ad alta risoluzione di questa immagine  qui . Qui puoi vedere meglio l&#039;assegnazione dei pin.   
 Il codice del programma (versione I2C) 
  //******************************************************************************************************* 
 //** Schizzo di esempio per la lettura di tag ID. Se l&#039;ID corrisponde, il PIN 13 viene acceso per 2 secondi ** 
 //** si accende (LED). Se l&#039;ID è sbagliato, viene generato un segnale acustico al pin 12. (cicalino passivo / piezzo) ** 
 //** utilizzo. Al posto del LED, è possibile attivare la serratura della porta (tramite l&#039;amplificatore di commutazione TIP120) 
 //******************************************************************************************************* 

  #include   &amp;lt;Wire.h&amp;gt;   // Libreria per il protocollo I2C  
  #include   &amp;lt;Adafruit_PN532.h&amp;gt;   // Libreria per il modulo NFC/RFID !!!   Si prega di caricare tramite l&#039;IDE Arduino!!!  


  #define  PN532_IRQ (2)  // Definisce il connettore IRQ  
  #define  PN532_RESET (3)  // Definisce il collegamento di reset  

 const   int  AlarmPin =  12 ;  // Uscita pin 12 per l&#039;altoparlante piezoelettrico 
 const   int  OutputPin =  13 ;  // Uscita del pin 13 per il LED o per il blocco magnetico tramite TIP120 
 unsigned   long  cardid;  // Variabile per la lettura del TAG-ID 

 unsigned   long  TAGid1 =  1702536620 ;  // Gli ID da accettare possono essere inseriti qui 
 unsigned   long  TAGid2 =  4070796058 ;  // Altrimenti lascia in bianco. L&#039;ID dei singoli TAG può essere inserito con 
 unsigned   long  TAGid3 ;  // il monitor seriale (impostare 115200 baud) 

Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);  // Crea un&#039;istanza con il protocollo I2C 


 void    setup() { // avvia la funzione di setup 
  pinMode (AlarmPin,  OUTPUT );  // Definisce il PIN come uscita 
   pinMode (OutputPin,  OUTPUT );  // Definisce il PIN come uscita
  Serial  .begin  (115200 );  // Aprire la trasmissione seriale con 115200 baud (ser monitorare la stessa impostazione di baud!) 
  Serial  .println ( &quot;Ciao! &quot;);  // Invia il testo &quot;Ciao!&quot; al monitor seriale 
  nfc .begin (); //   Inizia la comunicazione con il lettore RFID 
  unsigned   long  versiondata = nfc.getFirmwareVersion();  // Leggi il numero di versione 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 trovato&quot; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX);  // Invia testo e informazioni sulla versione alla porta   seriale del lettore RFID
  Serial  .print ( &quot;Firmware ver. &quot; );  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC);  // Controlla quando arriva la risposta dalla scheda 
  Serial  .print ( &#039;.&#039; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC);  //  
  
  nfc.SAMConfig();  // Configura la scheda per leggere i tag RFID 

  Serial  .println ( &quot;In attesa di un chip ISO14443A ...&quot; );  // Invia il testo in attesa al monitor seriale 
}


 void   loop () {  // Avvia la funzione loop 
  uint8_t success;  // Crea una variabile 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // Buffer per memorizzare l&#039;UID 
  uint8_t uidLength;  // Lunghezza dell&#039;UID (4 o 7 byte a seconda del tipo di scheda/chip ISO14443A) 

  // Attendere un chip ISO14443A. Se ne viene rilevato uno, la variabile 
  // viene riempita con l&#039;UID. A seconda della lunghezza (4 byte (Mifare Classic) o 7 byte (Mifare Classic) 
  // 7 byte (Mifare Ultralight) viene riconosciuto il tipo di carta. 
  
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength);

  if  (success) {  // Se viene rilevato, elabora.... 
    Serial  .println ( &quot;Trovata una carta ISO14443A&quot; );
    Serial  .print ( &quot; Lunghezza UID: &quot; );  Serial  .print (uidLength, DEC);  Serial  .println ( &quot; bytes&quot; );
    Serial  . print( &quot; Valore UID: &quot; );
    nfc.PrintHex(uid, uidLength);  // invio delle informazioni al monitor seriale 

    se  (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))  // interroga se i TAG 1..2..3 sono collegati con il rispettivo 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // On o off 
 altrimenti 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }  // Fine della query/loop IF 
}  // Fine del ciclo  
 Il codice del programma (versione SPI) 
  //******************************************************************************************************* 
 //** Esempio di sketch per la lettura di tag ID. Se l&#039;ID è adatto, il PIN 13 viene ** per 2 secondi 
 //** si accende (LED). Se l&#039;ID è sbagliato, viene generato un segnale acustico al pin 12. (cicalino passivo / piezzo) ** 
 //** utilizzo. Al posto del LED, è possibile attivare la serratura della porta (tramite l&#039;amplificatore di commutazione TIP120) 
 //******************************************************************************************************* 

  #include   &amp;lt;Wire.h&amp;gt;   // Libreria per il protocollo I2C  
  #include   &amp;lt;SPI.h&amp;gt;   // Libreria per il protocollo SPI  
  #include   &amp;lt;Adafruit_PN532.h&amp;gt;   // Libreria per il modulo NFC/RFID !!! Si prega di caricarla tramite l&#039;IDE Arduino!!!  

 const   byte  PN532_SCK =  2 ;  // 
 const   byte  PN532_MOSI  =3 ;  // Definisci le connessioni per  
 const   byte  PN532_SS =  4 ;  // la connessione SPI all&#039;RFID  
 const   byte  PN532_MISO  =5 ;  // Scheda 

 const   int  AlarmPin =  12 ;  // Definisci  le connessioni per 
 const   int  OutputPin =  13 ;  // le uscite (di commutazione) 
 unsigned   long  cardid;  // Variabile per la lettura del TAG-ID 

 unsigned   long  TAGid1 =  1702536620 ;  // gli ID da accettare possono essere inseriti qui 
 unsigned   long  TAGid2 =  4070796058 ;  // Altrimenti lascia in bianco. L&#039;ID dei singoli TAG può essere inserito con 
 unsigned   long  TAGid3 ;  // il monitor seriale (impostare 115200 baud) 

Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS);  // crea un&#039;istanza con protocollo SPI 

 void    setup() { // Avvia la funzione di setup 
  pinMode (AlarmPin,  OUTPUT );  // Definisce il PIN come uscita 
   pinMode (OutputPin,  OUTPUT );  // Definisce il PIN come uscita
  Serial  .begin  (115200 );  // Aprire la trasmissione seriale con 115200 baud (ser monitorare la stessa impostazione di baud!) 
  Serial  .println ( &quot;Ciao! &quot;);  // Invia il testo &quot;Ciao!&quot; al monitor seriale 
  nfc .begin (); //   Inizia la comunicazione con il lettore RFID 
  unsigned   long  versiondata = nfc.getFirmwareVersion();  // Leggi il numero di versione 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;Trovato chip PN5&quot; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX);  // Invia il testo e le informazioni sulla versione alla porta   seriale del lettore RFID
  Serial  .print ( &quot;Firmware ver. &quot; );  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC);  // Controlla quando arriva la risposta dalla scheda 
  Serial  .print ( &#039;.&#039; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC);  //  

  nfc.SAMConfig();  // Configura la scheda per leggere i tag RFID 

  Serial  .println ( &quot;In attesa di un chip ISO14443A ...&quot; );  // Invia il testo in attesa al monitor seriale 
}


 void   loop () {  // Avvia la funzione loop 
  uint8_t success;  // Crea una variabile 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // Buffer per memorizzare l&#039;UID 
  uint8_t uidLength;  // Lunghezza dell&#039;UID (4 o 7 byte a seconda del tipo di scheda/chip ISO14443A) 

  // Attendere un chip ISO14443A. Se ne viene rilevato uno, la variabile 
  // viene riempita con l&#039;UID. A seconda della lunghezza (4 byte (Mifare Classic) o 7 byte (Mifare Classic) 
  // 7 byte (Mifare Ultralight) viene riconosciuto il tipo di carta. 
 
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength);

  if  (success) {  // Se viene rilevato, elabora.... 
    Serial  .println ( &quot;Trovata una carta ISO14443A&quot; );
    Serial  .print ( &quot; Lunghezza UID: &quot; );  Serial  .print (uidLength, DEC);  Serial  .println ( &quot; bytes&quot; );
    Serial  . print( &quot; Valore UID: &quot; );
    nfc.PrintHex(uid, uidLength);  // invio delle informazioni al monitor seriale 

    se  (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))  // interroga se i TAG 1..2..3 sono collegati con il rispettivo 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // On o off 
 altrimenti 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }  // Fine della query/loop IF 
}  // Fine del ciclo  
 &amp;nbsp; 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Imbarcazione da sbarco a cuscino d&#039;aria di classe WISENT</title>
            <id>https://funduinoshop.com/it/imbarcazione-da-sbarco-a-cuscino-d-aria-di-classe-wisent</id>
            <link href="https://funduinoshop.com/it/imbarcazione-da-sbarco-a-cuscino-d-aria-di-classe-wisent"/>
            <summary type="html">
                <![CDATA[
                
                                            In molte mostre di modellismo navale, la maggior parte delle imbarcazioni sono costruite nei minimi dettagli e di altissima qualità. È un peccato che questo aspetto venga spesso trascurato dagli spettatori. Modelli spettacolari e non da tutti i giorni...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Modellismo: WISENT-Class Landing Craft Air Cushion &quot;LCAC&quot; 
 In molte mostre di modellismo navale, la maggior parte delle navi sono costruite con una qualità molto alta e nei minimi dettagli&amp;nbsp;. È un peccato che questo aspetto venga spesso trascurato dagli&amp;nbsp;spettatori. I modelli&amp;nbsp;spettacolari e non comuni hanno maggiori probabilità di attirare l&#039;attenzione. Senza&amp;nbsp;dubbio, gli hovercraft sono uno di questi.&amp;nbsp;Perché non costruire un modello del più grande del suo genere?&amp;nbsp;Con un dislocamento di 550 tonnellate, la classe Zubr (classe Wisent) è un gigante.&amp;nbsp;Esiste un modello in plastica in 1:110. Era troppo piccolo per me. ho pensato che 1:75 fosse giusto&amp;nbsp;. Quindi costruisci il tuo! 
 Costruisci il tuo hovercraft: Ma come? 
 Il libro &quot;RC Luftkissenboote&quot; (Hovercraft RC) di&amp;nbsp;K.Jackson &amp;amp; M.Porter della casa editrice VTH è stato un valido aiuto. Per capire quali componenti&amp;nbsp;tecnici dovevano far galleggiare il modello, è stato necessario fare delle prove&amp;nbsp;. I calcoli non sono stati molto utili in questo caso. Alla fine del testo è presente un&amp;nbsp;elenco delle batterie e delle tecnologie di azionamento utilizzate. Non esiste un piano di costruzione per&amp;nbsp;questo tipo, quindi è stato necessario utilizzare delle foto e fare molti&amp;nbsp;calcoli. 
 Il guscio è stato costruito con un pannello di schiuma PU e una colla di potenza&amp;nbsp;dal negozio di bricolage. Il lavoro è stato abbastanza veloce. Una girante da 70 mm, spesso utilizzata per gli aeromodelli in polistirolo, dovrebbe far &quot;librare&quot; il Wisent&amp;nbsp;. La gonna d&#039;aria è realizzata in rip-nylon.&amp;nbsp;Un materiale che viene utilizzato per i teloni delle tende e dai paracadutisti&amp;nbsp;. 
 L&#039;alimentazione dell&#039;hovercraft 
 Con le dimensioni previste di 900 x 400 mm, era chiaro fin dall&#039;inizio che non si sarebbe trattato di un modello a risparmio energetico. Una batteria da 18 V con 2,5 Ah della gamma di strumenti&amp;nbsp;- combinata con un convertitore di tensione - fornisce la tensione desiderata di 12 V.&amp;nbsp;Un secondo convertitore di tensione regola i 12 V fino a 9 V&amp;nbsp;e fornisce così all&#039;elica e all&#039;illuminazione nautica una tensione&amp;nbsp;uniforme.&amp;nbsp;In questo modo l&#039;intera alimentazione proviene da un&#039;unica batteria.&amp;nbsp;Due delle eliche esterne sono progettate per la propulsione, il motore&amp;nbsp;centrale è stato invertito e questa elica è stata inserita &quot;al contrario&quot; nell&#039;albero motore . La marcia indietro è quindi possibile senza problemi.&amp;nbsp;Le tre gondole di trasmissione sono state stampate per me dall&#039;azienda - Ray Haller di Eibenstock - sulla&amp;nbsp;stampante 3D. Sono controllate in modo sincrono da un servo.&amp;nbsp;Questo concetto di propulsione si è dimostrato valido.&amp;nbsp;Le eliche da 3,5 pollici (circa 9 cm) provengono dalla gamma di pezzi di ricambio per quadcopter.&amp;nbsp;Nonostante la costruzione leggera, il modello pesa 4,7 kg con tutti i componenti&amp;nbsp;. Questo rende possibile l&#039;atterraggio, ma non è adatto a viaggi&amp;nbsp;sulla terraferma. Anche l&#039;originale è al 99% sull&#039;acqua&amp;nbsp;. Sono stati costruiti 18 esemplari di questo &quot;bisonte gigante&quot;.&amp;nbsp;Ucraina, Corea, Russia, Cina e Grecia li hanno utilizzati. 
 Componenti utilizzati da Funduino: 
 1x&amp;nbsp; R4-E-0-1 :  Girante a turbina EDF 70mm ADF70-28XL PLUS KV3900  1x R6-C-7-4:  Hobbywing SkyWalker 60A UBEC Brushless ESC&amp;nbsp;(il controller da 40A si scalda troppo)  3x R5-E-4-3:  Ready ToSky 1306 KV3100 per 150 quadcopter  3x R6-E-1-4:  Hobbywing SkyWalker 12AE Brushless ESC  2x R12-B-8-2:  Modulo DC-DC Step Down 300W 20A da 6-40V a 1.2-36V  
 1x batteria 2,5 Ah 18 V di Einhell (tempo di guida circa 15 min) Il modello è controllato con un telecomando Carson a 6 canali da 2,4 GHz. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Come installare un driver CH340/CH341?</title>
            <id>https://funduinoshop.com/it/come-installare-un-driver-ch340/ch341</id>
            <link href="https://funduinoshop.com/it/come-installare-un-driver-ch340/ch341"/>
            <summary type="html">
                <![CDATA[
                
                                            Sempre più spesso ci contattate per chiederci come installare il driver CH340 per i microcontrollori compatibili con Arduino. In questo blog post vogliamo quindi spiegarti...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Come installare un driver CH340/CH341 per i microcontrollori compatibili con Arduino?  
 Sempre più spesso ci contattano per chiederci come installare il driver CH340 per i microcontrollori compatibili con Arduino. In questo blog post vogliamo spiegarti    - Qual è la differenza tra le schede per microcontrollori con chipset CH340 e le &quot;originali&quot;  - Dove puoi scaricare il driver CH340  - Come installare il driver CH340 in ambiente Windows  - Come programmare i microcontrollori Arduino compatibili con il driver CH340 all&#039;interno dell&#039;IDE Arduino 
 Dopo aver letto questo post, sarai consapevole di tutte le insidie che si possono incontrare nel mettere in funzione dei cloni Arduino economici! 
  La differenza tra i microcontrollori con CH340 e il chipset ATmega328P  
 Prima di tutto: le schede per microcontrollori compatibili con Arduino con chipset CH340 sono leggermente più economiche delle classiche schede con ATmega328p. Questo è dovuto in parte al fatto che le schede classiche con il chipset &quot;originale&quot; possono essere collegate al computer di casa via USB subito dopo l&#039;acquisto e sono quindi pronte all&#039;uso.     Prima di saltare alle conclusioni, diamo un&#039;occhiata dettagliata ai principali vantaggi e svantaggi delle schede CH340: 
 Svantaggio 1: &amp;nbsp;Il chipset CH340 non è compatibile con tutti i sistemi operativi! 
 Soprattutto con i sistemi Windows, il chipset CH340 è spesso fonte di frustrazione: il sistema operativo Windows di solito non è dotato del driver CH340 ex works. Le schede Arduino compatibili con i driver CH340/CH341 collegate a un PC Windows spesso non vengono riconosciute come tali dal PC. Per questo motivo vengono visualizzati dei messaggi di errore nell&#039;IDE di Arduino quando si caricano gli sketch. 
 Svantaggio 2: il caricamento degli sketch sulle schede CH340 richiede più tempo (testato a 5V)! 
 Lo ammettiamo: forse questo svantaggio è trascurabile nella prototipazione domestica, ma esiste. Il modo più semplice per vedere la differenza è osservare la seguente serie di dati. 
 
 
 
 
 Dimensione dello sketch (byte) 
 
 
 R3 Tempo di caricamento (secondi) 
 
 
 CH340 Tempo di caricamento (secondi) 
 
 
 
 
 500 
 
 
 5.3 
 
 
 5.6 
 
 
 
 
 5000 
 
 
 9.3 
 
 
 9.7 
 
 
 
 
 7000 
 
 
 9.6 
 
 
 10.2 
 
 
 
 
 &amp;nbsp;  In media, il caricamento del programma richiede circa 0,4 secondi in più con le schede CH340. 
 Vantaggio 1: il consumo energetico della scheda CH340/CH341 è inferiore! 
 Ovviamente il tempo di caricamento degli schizzi può essere trascurato, soprattutto nella prototipazione rapida. Ma che dire del consumo energetico? Anche in questo caso abbiamo analizzato il comportamento della scheda con due sketch standard che sicuramente tutti voi conoscete: &quot;Bare Minimum&quot; e &quot;Blink&quot;. 
 
 
 
 
  Esempio di sketch  
 
 
  Consumo di energia R3 (mA)  
 
 
  Consumo di energia CH340 (mA)  
 
 
 
 
 Minimo indispensabile 
 
 
 32.3 
 
 
 14 
 
 
 
 
 Lampeggio 
 
 
 37.1 
 
 
 20.1 
 
 
 
 
 Siamo sorpresi quanto te! Il consumo energetico della scheda a microcontrollore CH340 è solo la metà di quello della R3... entusiasmante! 
  Arriviamo quindi alle conclusioni:  
 Per coloro che possono sopportare lo sforzo extra dovuto all&#039;installazione del driver aggiuntivo richiesto, i microcontrollori compatibili con Arduino con chipset CH340/CH341 sono sicuramente una buona alternativa. Lo svantaggio tecnico della versione CH340, il tempo di caricamento, è sicuramente trascurabile per l&#039;hobbista. In questo caso, il guadagno dovuto al basso consumo energetico supera addirittura lo svantaggio! 
 Dove si può scaricare il driver CH340? 
 Ora le cose si complicano un po&#039;: di seguito ti proponiamo i driver del CH340 per le piattaforme Windows, OS e Linux. I link per i driver di Windows e OS rimandano a un sito web con caratteri cinesi. Non farti scoraggiare: puoi scaricare il driver semplicemente cliccando sulla barra blu (simbolo della nuvola). Al momento del nostro test, gli schizzi erano ovviamente privi di virus! 
 Windows:  http://www.wch.cn/download/CH341SER_ZIP.html  Linux:&amp;nbsp;   https://github.com/juliagoda/CH341SER   OS: http:  //www.wch.cn/download/CH341SER_MAC_ZIP.html  
 Aggiornamento 21.11.2022: un cliente ci ha informato che l&#039;utilizzo del driver per il sistema operativo di cui sopra potrebbe causare complicazioni. Raccomandiamo pertanto il seguente driver (a pagamento).&amp;nbsp;   https://www.mac-usb-serial.com/dashboard/   Ulteriori informazioni sono disponibili all&#039;indirizzo&amp;nbsp; https://thingsmatic.com/2017/08/07/using-ch340-devices-with-osx/ &amp;nbsp;. 
 A questo punto vorremmo sottolineare che per l&#039;installazione potrebbero essere necessari i diritti di amministratore. 
 Come faccio a installare il driver CH340? 
 Una volta scaricato il file corrispondente, puoi decomprimerlo (ad esempio con WinRar). Quindi apri il file Setup.exe. Si aprirà una nuova finestra. In questa finestra, seleziona il file &quot;CH341SER.INF&quot; alla voce &quot;Seleziona INF&quot;. Conferma quindi la selezione con il pulsante &quot;Installa&quot;. Se l&#039;installazione è andata a buon fine, apparirà un pop-up di conferma dell&#039;avvenuta installazione. 
 E come posso utilizzare la mia scheda a microcontrollore compatibile con il driver CH340? 
 È molto semplice: (quasi) esattamente come una scheda con chipset ATmega328p o ATmega16U2. Per prima cosa, stabilisci la connessione USB tra il microcontrollore e il tuo computer. Il microcontrollore dovrebbe essere visibile nella gestione dispositivi. 
 Quindi apri l&#039;IDE di Arduino. In &quot;Strumenti&quot; e &quot;Scheda&quot;, seleziona il tipo di microcontrollore. Quindi, in &quot;Strumenti&quot; e &quot;Porta&quot;, seleziona la cosiddetta porta COM del tuo controller. Di norma, si tratta della porta COM con il numero più alto.     Importante: nel passaggio successivo, in &quot;Strumenti&quot; e &quot;Processore&quot; devi selezionare l&#039;ATmega329p (vecchio bootloader). Solo allora potrai caricare il controller CH340!    Non è stato così difficile, vero? Se vuoi iniziare subito il tuo prossimo progetto, ti consigliamo la nostra piattaforma di apprendimento gratuita  www.funduino.de  con oltre 250 tutorial gratuiti sui sensori, gli attuatori e molto altro ancora! 
                ]]>
            </content>

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

    
</feed>
