<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://funduinoshop.com/it/blog/raspberry-pi/?sAtom=1" rel="self" type="application/atom+xml" />
    <author>
        <name>Funduinoshop</name>
    </author>
    <title>Blog/Atomi</title>
    <id>https://funduinoshop.com/it/blog/raspberry-pi/?sRss=1</id>
    <updated>2026-04-25T19:40:31+02:00</updated>
    
        <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">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">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">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>

    
</feed>
