|
Traduzione in italiano della pagina
originale di Jonathan Westhues: http://cq.cx/index.pl
LDmicro tutorial
In questo tutorial, verrà mostrato come scrivere un semplice programma. Si
assume che si abbia già scritto in ladder logic e che si abbiano alcune
famigliarità di base con i micro-controllori, ma che non si abbia mai usato il
programma LDmicro. Se non si conoscono molto bene gli argomenti riguardanti i
ladder logic oppure PLCs, allora il
plcs.net tutorial
potrebbe essere d'aiuto.
Il nostro circuito avrà un pulsante ed un LED. All'accenzione il LED sarà
spento. Quando si presserà la prima volta il pulsante il LED si accenderà.
Quando si presserà il pulsante una seconda volta il LED inizierà a lampeggiare.
La terza volta che si preme il pulsante il LED si spegnerà di nuovo. Nella
sequenza successiva, il ciclo verrà ripetuto.
Selezione del micro-controllore e schema
Verrà usato un PIC61F876, il quale è facilmente reperibile presso Digikey o
altri distributori on-line. Il micro-controllore ha diverse forme; si è scelto
il formato DIP.
Questo è il nostro schema:
Il micro-controllore (IC1) il cui suo mumero identificativo è PIC16F876-20I/SP-ND
presso Digikey.
Quasi tutti i risuonatori a tre termilali (U1) andranno bene; si può provare
un 535-9356-ND oppure un X909-ND.
L'unica cosa che potrebbe confondere è che il pulsante (pushbutton)
va alla Vdd, e che c'è un pull-down. Forse è più solito vedere un pulsante a
ground con un pull-up. Per i TTL, questo ha importanza, invece, per i moderni
CMOS non ne ha molta, e ho trovato, comunque, questo "attivo alto" (active HIGH)
una disposizione meno confusionaria rispetto al tradizionale circuito basato in "attivo
basso" (active LOW)
Si è anche scelto di adoperare un risuonatore ceramico provvisto di
condensatori interni, U1, al posto di un quarzo e due condensatori ~20 pF.
Un quarzo va senz'altro bene ed è più preciso, ma verrebbe ad costare un pò di
più ed inoltre servirebbero altri componenti come, appunto, i due condensatori.
Il circuito si può costruire in molti differenti modi. Nel nostro caso si è
preferito l'uso di una breadboard come quella che è, alla fine, a colleganemti
effettuati, come quella mostrata nella foto:
(Il valore della resistenza mostrata non è abbastanza simile a quello dello
schema; nessuno di loro è critico)
Ladder Diagram per il Programma
Primo, a noi servirà un oscillatore per generare il segnale lampeggiante per
il LED. C'è un modo standard (schema fondamentale) per fare questo in ladder logic:
|| Rosc Tosc_on Tosc_off Rosc ||
1 ||-------] [--------[TON 250.0 ms]---[TOF 250.0 ms]---------(/)-------||
Questo farà accendere a 1/((250+250) ms), or 2 Hz, or due volte al
secondo. Il duty cycle sarà 50%—250 ms acceso, poi
250 ms spento. Questo circuito può fare ogni tipo di oscillazione, con ogni
tipo di duty cycle sia richiesto, per cui è un buon esempio da ricordare.
Si noti pure che si è scelto di usare un relè interno ('Rfoo') invece di uno
collegato a un pin I/O ('Yfoo' or 'Xfoo'). Questo ha un senso perchè non c'è
nessuna particolare ragione per portare questo segnale fuori, esternamente, al
pin. LDmicro automaticamente assegnerà della memoria per il relè interno.
Il nostro programma avrà tra stati; off, stead on, e lampeggainte
(blinking)
. Il programma cambierà il suo stato ad ogni
rising edge
(fronte di salita del segnale) del pulsante (Vdd). Questa è una buona
applicazione per un contatore circolare. Diciamo che "stato 0" è spento, "stato
1" è acceso e "stato 3" lampeggia. Il contatore conta 0, 1, 2, 0, 1, 2, ...,
per cui se facciamo in modo che all'interno del rung la condizione del
contatore sia legata al pulsante d'ingresso, allora ogni cosa andrà come
vogliamo:
|| Xbutton Cstate ||
2 ||-------] [---------------------------------------------{CTC 0:2}----||
In breve, faremo in modo di usare le condizioni di stato del programma per far
si che queste siano quelle del LED, o meglio, degli stati del LED. E questo si
può fare in questo modo:
|| [Cstate ==] Yled ||
3 ||---[ 1 ]-------------------+------------------------( )-------||
|| | ||
|| [Cstate ==] Rosc | ||
||---[ 2 ]----------] [------+ ||
E' abbastanza facile vedere attraverso il grafico che tutto andrà come
volevamo. Se il programma è allo stato 1, allora l'istruzione 'Cstate'==1
attiverà 'Yled', come desideravamo. Nello stao 2, l'istruzione 'Cstate 2=='
attiverà 'Yled', ma solo quando 'Rosc' è anche vero. Per cui tutte le volte che
'Rosc' oscilla, vorrà dire che il LED lampeggia, come desideravamo. Finalmente,
nello stato 0, nessuna delle istruzioni di uguale è soddisfatta per la
condizione vero, per cui non c'è nessun modo che 'Yled' si possa accendere.
Editiamo il Ladder Diagram
Adesso che abbiamo il nostro circuito, possiamo disegnarlo con LDmicro. Quando
si lancia LDmicro appare un vuoto rung:
(una linea orizzontale tra due linee verticali che rappresentano le polarità: a
sinistra la polarità positiva ed a destra la polarità negativa o groud)
Vogliamo adesso inserire la prima rung in relazione a quanto detto più sopra.
Inizieremo con la bobina 'coil', per cui selezioneremo Instruction ->
Insert Coil. Con questa operazione avremo inserito nella riga del nostro foglio
di lavoro, un simbolo convenzionale di una bobina a cui, di default, è dato il nome di
'Ynew'. Questo era ciò che si voleva eccetto il nome e che deve essere 'negated'.
Quindi, per introdurre i valori che si desiderano, occorre dare doppio click
sul simbolo per fare apparire una finestra di dialogo dove possiamo configurare
appropriatamente la nostra bobina:
Adesso possiamo costruire completare il resto del rung inserendo, allo stesso
modo, gli altri componenti, nel nostro caso, i simboli. Clicca su il fronte
sinistro della bobbina in modo tale che il cursore si ponga, rispetto al
simbolo, in verticale e (importante), alla sinistra del simbolo. Adesso selezione
Instruction -> Insert TON
(Delayed Turn On). Ancora una volta doppio click sul timer per far apparire la
finestra di dialogo e inseriremo il nome "on" ed un periodo di ritardo di 250
ms. Aggiungiamo allo stesso modo 'TOF' (nome 'OF' e delay 250 ms). In ultimo
portandoci alla sinistra di 'TON' aggiungiamo dei contatti.
Adesso, per completare il nostro schema, vogliamo inserire un secondo rung,
così, selezioniamo Edit -> Insert Rung After. Adesso portati con
l'indicatore del mouse proprio sul secondo rung appena creato e clicca su, il
cursore si porterà proprio lì:
Il secondo rung è facile: basta completare due istruzioni nel giusto ordine
mettendo il cursore dove si vuole equindi selezionare Instruction -> Insert
....contact....ricordarsi di assegnare il nome ('Xbotton') ai contatti poi ,
allo stesso modo, selezionare Instruction -> Insert...CTC (Count Circular)
... assegnare un nome (ad esempio "state" e nel MAX VALUE inserire 2 (infatti
0, 1, 2, ....0, 1, 2, ricordate?) che è il limite massimo del contatore. A questo
punto, di nuovo, seleziona Edit -> Insert Rung After. Il foglio di lavoro
dovrebbe presentarsi così:
Il terzo rung sarà un pò più "furfante", perché conterrà delle ramificazioni in
parallelo. Questo vuol dire che bisogna considerare l'ordine nel quale si
inseriscono le istruzioni. Primo, inserire il segno grafico della bobina
(coil) ed assegnare un nome, nel nostro esempio"name"= Led "tipo"=normale:
Adesso inseriamo la prima istruzione "Equal" alla sinistra della nostra coil
che avevamo appena inserito, come al solito, e attraverso la maschera di
dialogo inseriamo le giuste variabili del nome e del valore. Dopo che abbiamo
fatto questo, precederemo ad aggiungere il ramo posto in parallelo: cliccando
sulla parte bassa del simbolo "uguale" il cursore si disporrà in orizzontale al
simbolo stesso dell'istruzione di "equal".
A questo punto, con il cursore posto lungo il lato basso del simbolo
selezioneremo Instruction -> Insert EQU (Compare for Equals). Da notare che
sino a quando il cursore è sotto la prima istruzione di "equal", l'istruzione
successiva si verrà a disporre in parallelo ad essa. A questo punto, come di
solito, rinomineremo ed aggiuorneremo i valori della variabile. Per finire il
rung dovremo inserire i contatti "Rosc" alla destra della seconda istruzione
di "equal". Per fare questo, bisogna cliccare sul lato destro della seconda
istruzione di "equal":
A questo punto selezionare Instruction -> Insert Coil; il simbolo di coil
verrà inserito in serie alla seconda istruzione, come da noi richiesto.
Rinomina ed attribuisci i giusti valori, e con questo hai concluso la fase di
programmazione.
Simulando il Programma
Adesso siamo pronti per simulare il nostro circuito. Selezione Simulate ->
Simulation Mode. Lo schermo cambierà; e il grafico ladder apparirà
prevalentemente griggio, e non si vedranno, al momento, che le cose cambino
anche perché il PLC non è ancora sottoposto ai cicli. Per lanciare i cicli
bisogna selezionare Simulate -> Start Real-Time Simulation. Fatto questo, si
può vedere che qualcosa cambia, i'oscillatore è in esecuzione ma il LED
('Yled') resta spento, come d'altra parte avevamo progettato, perché ancora non
è stato pigiato il pulsante. Per simulare la pressione sul pulsante, perciò,
fare doppio click sul testo 'Xbotton' nella lista che appare nella sotto
finestra in fondo allo schermo. Con questa operazione si è simulato di portare
il pulsante a livello alto
(input high)
; Questo è quello che accadrà se si tiene mantenuto pressato il pulsante senza
rilasciarlo.
Si può vedere che il programma lavora: il contatore 'Cstate' è, adesso, uguale
ad 1, il che corrisponde allo stato 'steady on', che è quello che volovamo. Il
LED output è high; si può vedere che il suo valore è 1 nella lista, e il 'Yled'
appare red nel grafico. Doppio clic sulla scritta 'Xbotton' nella solita list
in fondo al monitor, e quindi doppio click ancora per simulare il rilascio del
pulsante. La bobbina 'Yled' inizierà a lampeggiare, come desiderato. Se si
simula la terza pressione si vedrà che l'output andrà steady low basso
Compilando l'IHEX File
Adesso siamo abbastanza sicuri che il programma lavora. A questo punto siamo
pronti per generare il codice attuale, e provarlo nel micro. Innanzi tutto
usciamo dal modo simulazione de-selezionando dal menu principale Simulate ->
Simulation Mode, oppure Escape.
Subito dopo dobbiamo selezionare un micro-controllore. Prima avevamo deciso
che avremmo usato un PIC16F876, per cui selezioniamo Settings ->
Microcontroller -> Microchip PIC16F876 28-PDIP oppure 28-SOIC. Inoltre,
dobbiamo ancora dire al pregramma LDmicro che tipo di quarzo useremo e quale
sarà cycle time. Selezioniamo, allora, Settings -> MCU Parameters e
completiamo il clock speed con of 20 MHz.. Lasciamo il cycle time a 10 ms; questo, usualmente, è un buon valore.
Adesso possiamo assegnare i pins ai nostri input ed output. Doppio click si 'Xbotton' nella lista in basso allo schermo, e scegliamo pin 14 del PIC, che corrisponde alla porta RC3 della MCU. (Non c'è nessuna ragione per prendersi cura di quale porta si userà; basta guardare ai numeri dei pin).
Clicca 'OK' e quindi ripeti il procedimanto per 'Yled' che, come si può vedere dallo schema eletrico, va al pin 15. Gli altri elemeti contenuti nella lista sono variabili interne e bits in memoria, per cui non c'è nessun bisogno di assegnare a loro dei pins. LDmicro allocherà memoria per loro quando si andrà a compilare.
Adesso si è pronti per compilare. Seleziona Compile -> Compile, e specificare dove si vuole mettere l'IHEX file. Quindi, usare qualunque tipo di didpositivo di programmazione si ha a disposizione per trasferire dentro il micro il codice, ed adesso si è pronti per provare il nostro circuito.
Questo completa il mio tutorial. E' possibile scrivere programmi molto più complessi di questo, naturalmente. Un programma come questo usa veramente una frazione di poca memoria rispetto a quella disponibile nella memoria del micro, per cui c'è abbastanza spazio per molti altri rungs di logica. LDmicro offre anche istruzioni specializzate per cose come artimentca, analogici input ed output, PWM, e anche caratteri da inviare a dei LCD. Consultare il manuale per ulteriori dettagli.
Non si vede la ragione di daunloddare il file gia fatto ma, se si desdera, quì puoi effetuare il download
download il programma tutorial
Traduzione in italiano della pagina originale di Jonathan Westhues: http://cq.cx/index.pl
|