sabato 23 gennaio 2021

RSHELL un ottimo sistema per gestire ESP32 da terminale

Nel mio percorso di approfondimento della conoscenza dell'ESP32, ho incontrato questo interessante programma per Python; RSHELL  che consente una connessione tra una macchina Linux ed il nostro ESP32 tramite cavo USB e gestisce alla perfezione l'upload ed il download dei file sulla scheda.

Attraverso RSHELL si potranno caricare i file di programma sulla scheda ESP e scaricare eventuali file o log registrati sulla scheda stessa, direttamente da shell attraverso una macchina Linux.

Abbiamo gia' visto come connettere la ESP via WiFi attraverso WebRepl nel precedente post, adesso vediamo come poter fare lo stesso attraverso una semplice shell Linux. Sulla mia macchina in questo momento ho il sistema Win10,  e l'ambiente virtuale WSL che ho costruito per utilizzare Linux con i programmi per la programmazione in Python, non gestisce le porte seriali della macchina, o almeno non lo fa nelle impostazioni di base che attualmente girano sul mio sistema, quindi per poter testare RSHELL ho dovuto "passare" da una Raspberry Pi che, attraverso una shell remota, mi consente di "parlare" con l'ESP via seriale.

Quindi ho collegato ESP32 con il cavo USB alla Raspberry Pi. Ho connesso la Raspberry Pi via WiFi in SSH, ed ho cosi' ottenuto quando necessario per funzionare.


Installato rshell sul sistema Linux con 

$ pip install rshell

Collegato la ESP32 alla presa USB della Raspberry Pi  bisogna trovare il nome della seriale che e' stato assegnato al device, semplicemente leggendo con il comando:

$ ls /dev/tty*

Nel mio sistema il nome assegnato e' il solito  ttyUSB0

Quindi basta chiamare con il comando sotto, la connessione con il parametro -p e se tutto e' andato regolarmente, ci troviamo connessi alla nostra ESP32 

$  rshell -p /dev/ttyUSB0





Il manuale onlne del programma spiega con dovizia di particolari l'utilizzo di ogni comando, e se ne volete sapere di piu' vi consiglio di andare a leggere

Io per fare conoscenza ho testato il comando -d  che mette  RSHELL in modalita' debug, quindi la connessione e' molto piu' verbose, ma consente di capire meglio cosa succede dopo ogni comando

Adesso vediamo come mettere su il sistema in modo da far connettere in automatico il nostro ESP32 al router di casa, senza utilizzare il metodo gia' spiegato nel post precedente.

La prima cosa connettere con RSHELL e questi comandi:

$ rshell -p /dev/ttyUSB0 --buffer-size 30 -a -e nano

Il comando -e nano consente di scegliere l'editor nano anziche' il predefinito vi che come sappiamo e' molto piu' ostico !!

A questo punto possiamo andare a leggere il contenuto  della flash dell'ESP32 con il comando 

$ ls /pyboard     

nb. pytboard e' il nome che viene dato in automatico all'ESP se non e' settato in maniera differente dentro il file board.py  che contenga un attributo simile a :  name = "myboard"

A questo punto possiamo editare il file boot.py che risiede gia' di default sulla ESP32 con l'editor che abbiamo definito con il parametro -e (cioe' nano)

> edit /pyboard/boot.py    





Le istruzioni da inserire nel file sono le stesse del precedente post, cioe':

# This file is executed on every boot (including wake-boot from deepsleep)
import esp
esp.osdebug(None)
import webrepl
webrepl.start()
def do_connect():
    import network
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        print('connecting to network...')
        wlan.connect('XXXXXXXXXXXXXXXXX''XXXXXXXXXXX')
        while not wlan.isconnected():
            pass
    print('network config:', wlan.ifconfig())
do_connect()

Al posto delle X dovete inserire i dati relativi al vostro router, naturalmente.

Per uscire e salvare da nano, i comandi sono Ctrl-X  e poi confermare il salvataggio delle modifiche effettuate.

Con queste semplici modifiche il ESP32 al successivo riavvio si colleghera' al router ed entrera' nella vostra rete locale.

Un'altra cosa che si puo' fare e' far partire REPL, chiamandolo direttamente dal prompt:

> repl pyboard         
 nb. il nome della scheda puo' essere omesso, serve solo se abbiamo piu' schede insieme, che possono essere collegate  chiamandole per nome

Qui ci troviamo direttamente nell'ambiente MicroPython del nostro ESP32


Buon divertimento.

TecnoGeppetto







ESP32 gestione di striscia Led indirizzabile Neopixel WS2812

 I miei test sul sistema MicroPython ed ESP32 vanno avanti di gran lena, oggi ho completato il montaggio di un semplice circuito con un ESP32 ed una barretta di Led WS2812 molto comoda e facilmente inseribile nei vari circuiti che possiamo costruire "sulla scrivania".

Ho montato il circuito come da schema qui sotto, ma ho avuto dei problemi allo startup del ESP, che "sente" il GPIO basso, e si mette in Dounload mode, cioe' pronto a ricevere il firmware, e non entra in posizione lavoro. Quindi ho deciso di utilizzare un'altra porta (ce ne sono tante!) per evitare l'inconveniente


La verisone di ESP sulla quale sto lavorando, probabilmente ha dei problemi di circuito, infatti non funziona il Pin dei 5V (il Vin, cioe' il pin che e' collegato all'alimentazione proveniente  dalla USB, di conseguenza sono sato costretto a collegarmi alla 3,3V per alimentare la barretta di Led ( siamo un po' sotto il limite della minima tensione ammessa, che e' di 4V, ma dai testi funziona ugualmente!!). Con questa configurazione pero' devo stare attento ad accendere i Led mai alla massima potenza, in quanto assorbirebbero tropo per il componente stabilizzatore di tensione installato sulla scheda (infatti , se funzionasse!, sarebbe certamente meglio usare l'alimentazione diretta dalla USB per alimentare la barretta di LED, questo modo che ho scelto io, passa attraverso lo stabilizzatore di tensione che si occupa di alimentare il microcontrollore ed il wifi, quindi ha gia' il suo bel da fare!)

Di seguito il codice uploadato sull ESP che fa accendere i led di un colorino arancione uno per volta fino ad accendere tutta la barretta, poi fa il percorso inverso e spenge tutti uno alla volta. Fa' questo di continuo, fino a che non riceve un break (Ctrl-C) da terminale.

from machine import Pin
from neopixel import NeoPixel
import time

pin = Pin(16, Pin.OUT)   # set GPIO16 to output to drive NeoPixels
np = NeoPixel(pin, 8)   # create NeoPixel driver on GPIO0 for 8 pixels
while True:
    for i in range(8):
        np[i] = (2555)      # set the first pixel to orange
        np.write()              # write data to all pixels
        time.sleep_ms(500)
    for i in range(80, -1):
        np[i-1] = (000)      # set the first pixel to orange
        np.write()              # write data to all pixels
        time.sleep_ms(500)


Buon divertimento 

TecnoGeppetto




venerdì 22 gennaio 2021

ESP32Cam gestione dei Led della scheda

 Continua la serie di articoli sulla scheda ESP32Cam che inquesto periodo e' sotto i miei riflettori; Con questo articolo parliamo della attivazione e della gestione del LED principale e del Led di servizio. Infatti la scheda ha un bel Led 5050 sulla parte frontale, molto luminoso, che risponde al GPIO 4 ed un Led Rosso sulla scheda interna, vicino al modulo ESP vero e proprio, che viene utilizzato anche dal sistema per messaggi di stato.

Il MicroPython ci consente di gestire piuttosto facilmente questi due led semplicemente alzando o abbassando il livello dei Pin relativi. Bisogna comunque fare attenzione al fatto che il GPIO 4 al quale e' collegato il Led principale Bianco, e' anche utilizzato per la gestione della scheda MicroSD, infatti sul GPIO 4 e' collegata anche il segnale DATA1 della comunicazione tra il microcontrollore e la MicroSD, quindi non e' possibile utilizzare le due periferiche contemporaneamente.


Per il LED Bianco

from machine import Pin
import time

LEDb = Pin(4, Pin.OUT) 
while True:
    LEDb.value(1)
    time.sleep_ms(500)
    LEDb.value(0)
    time.sleep_ms(500)


Per il LED Rosso

#gestione del LED di servizio Rosso della scheda sul GPIO33
LEDr = Pin(33, Pin.OUT) 
while True:
    LEDr.value(1)
    time.sleep_ms(500)
    LEDr.value(0)
    time.sleep_ms(500)

Nota che il LED Rosso funziona alla rovescia rispetto all'altro quindi si accendera' con il Pin 33 basso, mentre si spengera' con il Pin 33 tenuto alto.


Buoni esperimenti

TecnoGeppetto



ESP32Cam primi approcci

 Veramente orami e' qualche mese che ho ricevuto dalla Cina il mio primo ESP32Cam, un mostriciattolo che ha a bordo il ESP32 uno slot per MicroSD card, una telecamera ed una serie di pin a cui poter collegare il ....resto del mondo!



Ho gia' fatto un sacco di progettini con l'ESP32, tutti in C, utilizzando la IDE di Arduino e la modalita' "classica" di programmazione: upload via seriale del firmware compilato attraverso la Ide di Arduino .

Su questo sistema di operare, ci sono in rete migliaia di Tutorial anche blasonati, come per esempio quelli di Adafruit, mentre per quanto riguarda Python e MicroPython, ancora non si trova un granche'.

Considerato pero' che ho imparato a programmare con Python, vorrei imparare anche a sviluppare qualcosa di mio su ESP con questo linguaggio.


Quindi , vediamo un po' come fare per far diventare produttiva la giornata!

Intanto, primo consiglio, in rete si trovano diverse fonnti che vendono la scheda ESP32Cam, io consiglio quella completa  della sua basetta con presa USB e interfaccia seriale integrata, che e' molto comoda, viene riconosciuta subito dal sistema operativo, e ci evita di dover ricorre a fili volanti e interfacce seriali posticce, per poter lavorare. Costa pochissino (meno di 1 euro) e non ci sono motivi per non utilizzarla, almeno per la fase di prototipazione, quando fare l'upload del firmware e' una operazione frequente. Quando la parte di sviluppo sara' terminata, se volessimo utilizzare bene gli spazi, potremmo sempre sfilare la basetta seriale e, magari costruirne una apposita con i sensori di cui necessitiamo gia' previste e montati onboard.Quindi nel caso si volesse optare per la soluzione con scheda seriale esterna questi sono le connessioni da effettuare:


Il ponticello tra GPIO0 e GND e' indispensabile per "dire" al microcontrollore che siamo in flash mode e che stiamo per inviare il firmware.

Recuperare l'ultima versione del firmware dal sito 

Dal alto pc, se siamo su Linux, il comando per fare upload del sistema operativo MicroPython si deve utilizzare :

$ esptool.py –chip esp32 -p <nome_porta> write_flash -z 0x1000 <path_del_firmware>

Se siamo su windows ed abbiamo difficolta' ad installare il sistema di siluppo di Espressif (esptools), possiamo :

Scaricare il Flash Dowload Tools qui   ( questa e' l'ultima versione, prebdere ovviamente la versione piu' recente) basta scompattarlo in una cartella ed siamo  subito operativi.

Fare click sul file  flash_download_tool_3.8.5.exe e scegliere il tasto Developer Mode e nella successiva finestra il tasto relativo al modello di ESP che abbiamo a disposizione.

Si aprira' questa finestra:


All'interno della quale va soltanto caricato il path del firmware appena scaricato del MicroPython. Gli altgri parametri dovrebbero andare bene senza essere toccati.

 A questo punto fare ERASE per cancellare la memoria flash da alti eventuali upload.

Poi  START, per iniziare l'upload.

Se tutto e' andato bene. ci trovermo, al termine del processo, il nostro ESP32Cam che sara' pronto per essere programmato in Python. Bastera' quindi collegarlo con PuTTY (per esempio) sulla porta COM che windows gli avra' assegnato. nel mio caso la COM10.

Alla prima connessione il nostro ESP rispondera' con il prompt di Python e sara' gia' pienamente operativo.

Cosa fare adesso?

Adesso abbiamo il mostriciattolo che risponde ai comandi, ma ancora non e' collegato alla rete e non puo' essere collegato da remoto. Quindi la prima cosa da fare e' farlo collegare alla rete.

Ci viene in aiuto la documentazione ufficiale di MicroPython per ESP32

import network

wlan = network.WLAN(network.STA_IF) # create station interface
wlan.active(True)       # activate the interface
wlan.scan()             # scan for access points
wlan.isconnected()      # check if the station is connected to an AP
wlan.connect('essid', 'password') # connect to an AP
wlan.config('mac')      # get the interface's MAC address
wlan.ifconfig()         # get the interface's IP/netmask/gw/DNS addresses

ap = network.WLAN(network.AP_IF) # create access-point interface
ap.config(essid='ESP-AP') # set the ESSID of the access point
ap.config(max_clients=10) # set how many clients can connect to the network
ap.active(True)         # activate the interface

Fatta la connessione al router casalingo (modificare opportunamente essid e password nel codice sopra con quelli corretti per la connessione al proprio router)

Attiviamo il WEBREPL per poter effettuare la connessione da remoto ed utilizzare la funzionalita' di upload e download dei file dal sistema operativo del ESP32Cam ( si perche' il sistema che abbiamo caricato si comporta come un vero e proprio sistema operativo sul quale possiamo caricare, scrivere leggere e cancellare file.

PS Se utilizziamo Linux e' tutto piu' semplice, come sempre, esiste infatti una applicazione ampy che basta chiamare per fare direttamente l'upload da terminale cosi:

$ ampy -p dev/ttyUSB0 put boot.py

Ma stiamo utilizzando windows, mio malgrado, quindi , secondo me, la maniera piu' veloce per ottenere il buon funzionamento del ESP32Cam e' questo, cioe' passare da WEBREPL per fare l'upload dei file che ci interessa caricare sul sistema.

import webrepl_setup

Con questa riga, e poi seguendo le richieste del programma, si stabilisce una password e si abilita la partenza del WEBREPL ad ogni restart o reset del sistema.

Proviamo se tutto funziona a dovere:

Da un qualsiasi browser connettere: http://micropython.org/webrepl/#1p2.168.NUMERO_IP_ESP:8266/

Inserire naturalmente l' IP dell'ESP32Cam, ed utilizzare la porta 8266 come specificato. Dovrebbe rispondere il nuovo sistema con la richiesta diella password di accesso che abbiamo creato con la prima chiamata del WEBREPL. Dare la password corretta ed il sistema rispondera' con il prompt di MicroPython

Ok a questo punto che siamo connessi e abbiamo il WEBREPL attivato, non ci resta altro che rendere queste modifiche permanenti in maniera che ad ogni statup del sistema questo si connetta al router in automatico e renda disponibile l'interfaccia remota per poter essere contattato anche se non direttamente collegato al pc.

Dal WEBREPL scarichiamo il file boot.py e modifichiamo la parte relativa ala connessione, per renderla automatica cosi:

fare il get del file boot.py


modificarlo con :

<code>

# This file is executed on every boot (including wake-boot from deepsleep)
import esp
esp.osdebug(None)
import webrepl
webrepl.start()
def do_connect():
    import network
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        print('connecting to network...')
        wlan.connect('essid''password')
        while not wlan.isconnected():
            pass
    print('network config:', wlan.ifconfig())
do_connect()

</code>

E fare l'upload del file appena modificato con l'apposita funzione disponibile sul browser



A questo punto siamo pronti. Basta resettare (anche togliendo l'alimentazione) il nostro ESP32Cam ed al riavvio, in automatico si collleghera' al router e sara' connettibile tramite interfaccia WEBREPL all'indirizzo : IP_del_ESP:8266 da un qualsiasi browser.

Buon divertimento 

TecnoGeppetto



 





mercoledì 13 gennaio 2021

Collegare un Encoder rotativo con switch a Raspberry Pi

 Alla ricerca di una soluzione valida per la costruzione della Radio Web, ma soprattutto per sperimentare nel senso piu' ampio del termine, mi sono imbattuto su questa libreria che gestisce tutte le fuinzionalita' del' encoder compreso lo switch a pulsante. Fa al caso mio!


L'Encoder consente di associare alla rotazione del suo asse a funzioni gestite da un programma, la funzione piu' comune e' quella di alzare o abbassare il volume, ma puo' essere anche utilizzato per spostarsi in un menu', per guidare un robot, per gestire lo spostamento della frequenza di un VFO di una radio, ecc..

La libreria che ho trovato consente di fare tutte queste cose con estrema facilita'.

La prima cosa che ho fatto e' cablare il mio Encoder con la Raspberry deputata al sacrificio di queste ultime prove.


Ho collegato  il segnale di CLOCK al PIN 18,il DATA al PIN 17 ed infine il PIN SWITCH al PIN 27, ma la disposizione dei PIN e' completamente arbitraria.

Le resistenze di pull-up che si vedono indicate nello schema qui accanto (se avete un encoder di questo tipo, sono gia' inserite nel circuito) invece non lo ho collegate, ma ho utilizzato la funzione di pull-up interna sui PIN della mia Raspberry Pi, per rendere ancora piu' semplice il circuito.



Nella foto qui accanto ho segnato i PIN che ho utilizzato nel mio circuito ed il positivo a 3,3 volts, non ho segnato il GND che e' presente in abbondanza sui PIN di Raspberry Pi.
A questo punto installiamo la libreria come indicato sulla documentazione:

Installation

  • Install the pigpio library (check pigpio documentation for alternative installation method)
  • sudo apt-get update
  • sudo apt-get install pigpio python-pigpio python3-pigpio
  • Install the pigpio_encoder library
  • pip install pigpio_encoder (consider add --user option)
  • start pigpio daemon
  • sudo pigpiod

Con l'uso della libreria bastano solo poche righe di codice per ottenere un programma funzionante che rileva attraverso gli interrupt di sistem, il movimento dell'asse dell'Encoder o la pressione dello stesso che attivera' lo switch. Viene anche tenuto conte del tempo di pressione del tasto per consentire di associare due funzioni differenti alla pressione dell'asse dell'Encoder, come vedremo con le funzioni: sw_short() e sw_long()

Questo un semplice programma di test che se fatto girare consente di assicurarsi che tutto sia montato correttamente.

from pigpio_encoder import pigpio_encoder

def rotary_callback(counter):
    print("Counter value: ", counter)

def sw_short():
    print("Switch short press")

def sw_long():
    print("Switch long press")

my_rotary = pigpio_encoder.Rotary(clk=18, dt=17, sw=27)
my_rotary.setup_rotary(min=10, max=300, scale=5, debounce=200, rotary_callback=rotary_callback)
my_rotary.setup_switch(debounce=200, long_press=True, sw_short_callback=sw_short, sw_long_callback=sw_long)

my_rotary.watch()

Qui a fianco il montaggio su una basetta di legno

Buon divertimento

TecnoGeppetto


Collegare un display I2C alla Raspberry Pi

 Molto spesso nello sviluppo dei progettini con Raspberry si rende necessario visualizzare lo stato di esecuzione dei comandi o lo stato dei pin, insomma abbiamo bisogno di "vedere" a che punto ci stiamo trovando nell'esecuzione del nostro sistema. La maniera piu' veloce ed economica e' quella di utilizzare un display 1602 con integrata l'interfaccia I2c.


Il display in questione costa circa 2 euro su Aliexpress e consente di visualizzare 2 righe di 16 caratteri totalmente gestibili dal nostro programma. L'utilizzo della interfaccia I2C velocizza la comunicazione tra Raspberry e Display e fa risparmiare un po' di cavetteria che crea solo confusione e aumenta il rischio di malfunzionamenti.

Effettuati i collegamenti come da schema, non ci resta che utilizzare una libreria per cominciare a comunicare con il Display.

Ho trovato questa libreria  che aiuta nella gestione del Display e che e' molto facile installare ed utilizzare.

Cominciamo: (da Github)

Installation

  • Install git

    sudo apt install git
    
  • Clone the repo in your pi home directory

    cd /home/pi/
    git clone https://github.com/the-raspberry-pi-guy/lcd.git
    cd lcd/
    
  • Run the automatic installation script with sudo permission

    sudo ./install.sh
    
  • After rebooting, try one of the demos

    cd /home/pi/lcd/
    ./demo_clock.py


Ecco il risultato:



Questo e' il circuito completo che ho montato per farlo diventare una Radio Web.







Ascoltare Radio in Streaming con Raspberry Pi

 Tra le altre cose, durante le vacanze di Natale nell'anno della pandemia, mi sono divertito a costruire una radio web con raspberry ed mpc - mpd. Ho scoperto infatti il progetto Music Player Daemon (MPD) un'applicazione lato server flessibile e potente per la riproduzione di musica. Attraverso plugin e librerie può riprodurre una grande varietà di file audio e anche le trasmissioni delle radio in streaming web.


Il sistema e' testuale, cioe' lo si avvia attraverso comandi via shell. E' stato sviluppato un client per il sistema, che ne rende l'utilizzo  estremamente semplice e veloce, il Client si chiama MPC lo puoi trovare qui 

Come funziona?
Molto semplicemente, basta fornire il link allo streaming della radio che ci interessa, ad mpc che automaticamente parte la riproduzione. E' possibile aggiungere una playlist di radio (una sorta di cambio canale) che possono essere selezionate in modo da poter cambiare la programmazione ogni volta si voglia.

Con il comando :

$ mpc add "link_completo_di_http_allo_streaming_audio"

si aggiunge lo streaming alla coda della playlist

$ mpc play

si avvia la riproduzione dello streaming sul device audio di default del sistema.

Per l'utilizzo si Raspberry Pi possiamo creare il sistema pulito si microSD, operazione che oggi e' molto facile e veloce!, installare mpd e mpc direttamente dal repository ufficiale con

$ sudo apt-get install mpd

Possiamo provare subito se tutto funziona ( a me e' andata cosi!):

$ mpc add http://livex.radiopopolare.it/radiopop

$ mpc play

Con questi semplici comandi (sempre che la Raspberry Pi sia collegata ad internet via rete o via WiFi, ovviamente!) dal jack audio, collegando un paio di cuffiette o gli altoparlanti amplificati, si dovrebbe il flusso audio della radio web.

Nel caso che qualcosa non funzioni, possiamo fermare il servizio mpd che parte in automatico appena scaricato con:

$ sudo /etc/init.d/mpd stop

Ci possiamo creare una copia di backup del file di configurazione 

$ sudo cp /etc/mpd.conf /etc/mpd.conf.originale

E controllare che la configurazione sia simile a questa, aprendo iol file di configurazione attraverso un editor di testo (nano):

$ sudo nano /etc/mpd.conf

quindi cercare e controllare :

audio_output {
type               “alsa”
name            “Raspberry Onboard Audio” (verra’ visualizzato sul client)
device           “hw:0,0”
mixer-device “default”
mixer-control “PCM”
mixer-index   “0”
}

Nel caso modificare ed uscire dall'editor salvando.

Per far ripartire il servizio mpd:

$ sudo /etc/init.d/mpd start

Tutto dovrebbe funzionare correttamente.


Buon divertimento 

TecnoGeppetto

domenica 10 gennaio 2021

Ambiente virtuale in Python

 Creare un ambiente virtuale e' molto utile per evitare di continuare ad installare librerie direttamente nel sistema principale. infatti quando facciamo i nostri test e prove varie, abbiamo spesso bisogno di caricare nuove librerie e driver per tentare di far funzionare quelle che sono le nostre idee di progetto. Continuando a caricare tutto nel sistema princpale e' possibile che alcune delle librerie caricate possano andare in conflitto con altre, gia' presenti nel sistema. 


Per evitare tutto cio' allora, si puo' utilizzare  questa funzione interna di Python che consente di costruire un ambiente virtuale all'interno del quale poi potremo caricare qualsiasi libreria senza con questo fare delle modifiche permanenti al sistema. Cioe' tutto quello che caricheremo nel sistema virtuale, rimarra' valido li dentro, ma non avra' nessun effetto sul sitema principale.

Come si fa' ? 


$ python -m virtualenv .venv

$ source .venv/bin/activate

Fatto!

con activate lo attiviamo e siamo gia' pronti per poter caricare qualsiasi cosa vogliamo senza fare piu' nessun danno nel sistema principale.


sabato 2 gennaio 2021

utilizzare Github per sviluppare codice

 Durante l'ultimo mese, ho imparato ad utilizzare Git  per il versionamento del codice (almeno per le operazioni principali), la conseguenza naturale, poi, e' quella di usare Github per appoggiare il siftware dei vari progetti in sviluppo ed avere cosi' la possibilita' di averlo disponibile da qualsiasi computer in qualsiasi momento, con tutte le peculiarita' del verisonamento.

Riepilogo  qui sotto le principali operazioni da effettuare per tenere aggiornato il proprio account ed le relative verisoni del codice prodotto.

Prima cosa ovviamente e' essere a disposizione di un account su Github, poi avere installato  Git sul proprio pc. Io mi trovo bene ad utilizzare Linux per lo sviluppo, dove  l'installazione e' immediata con:

$ sudo apt-get update

$ apt-get install git

La prima operazione da fare in Git, dentro la cartella contenente il progetto, e' dire a Git che quella e' una cartella da considerare, con il comando :

$ git init

Questo crea una caretlla nascosta .git  che il sistema utilizzara' per tutte le operazioni necessarie.

Per maggiore praticita', nel caso che si voglia pubblicare su Github il nostro codice, e' preferibile creare il progetto vuoto direttamente su Github, scaricarlo in locale e popolare in un secondo momento la cartella del progetto, per poi fare l' upload sul sito. Vediamo come.

Su Github creo un nuovo Repository:


Scelgo il nome del progetto:


ed aggiungo i file necessari per il versionamento. Il README e' il file che descrive in modo testuale il progetto, una sorta di home page del progetto stesso. .gitignore servira' poi per evitare di caricare degli eventuali file non necessari nel repository (spesso utilizzato per evitare di caricare i file di configurazione che possono contenere  Token o Password personali). Per quanto riguarda license, non e' indispensabile, anche perche' stiamo "giocando" ed i file non sono certo importanti, comunque aggiungerne una  non fa male e costa pochissimo!. smile!



Aggiunto il nome del file e salvato il nuovo repository, possiamo passare lato pc, per completare il processo:
Entriamo nella cartella dei progetti,
con il comando $ git clone https://INDIRIZZO_DEL_REPOSITORY.GIT
Il corretto indirizzo del nuovo repository appena costruito sara reperibile qui:



Con il tasto evidenziato nella immagine qui sopra sara' semplice copiare il link direttamente in memoria facendo semplicemente un click.

Questo comando crea una cartella con il nome del progetto e scarica tutti i file del progetto appena creati su Github, direttamente nella nuova cartella creata sul pc.
 Ci troveremo quindi la cartella .../progetti/NOME_DEL_NUOVO_PROGETTO

A questo punto se abbiamo gia' del materiale bastera' copiarlo in questa cartella, oppure creare nella catella almeno un nuovo file nel linguaggio desiderato.
Per esempio test.py con il comando 


Scrivere il codice necessario, salvare.
Per aggiungere il nuovo file al repository c'e' bisogno ancora di alcuni passaggi:


git status rende la situazione del git, evidenziando appunto il nuovo file aggiunto alla coda. 
Nel caso voglio aggiungere un file che in precendeza avevo ignorato (cioe' aggiunto nel file .gitignore per non tenerne traccia in git) dovr' utilizzare la forma:
$ git add -f file_in_precedenza_ignorato
A questo punto deve essere fatto il commit che serve per rendere ufficiali e registrate le modifiche effettuate.

con il comando :

$ git commit -m "testo descrittivo della modifica appena effettuata"

Che rende, come vedete in figura, la lista dei file aggiunti al commit

Per pubblicare sul nostro repository su Github a questo punto basta fare :


Con $ git push tutte le variazioni effettuate nel commit vengono rese disponibili su Github, quindi tutti i file si troveranno anche sul repository del progetto


Buon divertimento 

TecnoGeppetto