Ho deciso di realizzare questo piccolo corso, tra una cosa e l’altra, perchè in molti mi hanno chiesto come si fa a programmare un microcontrollore, che linguaggio si usa, quali programmi e programmatori utilizzare ecc.
Premetto già da ora che l’argomento è davvero complesso perchè tocca davvero molti rami, bisogna avere comunque delle basi di elettronica, una certa attitudine alla programmazione e tanta tanta voglia di imparare e soprattutto costanza e capacità di non scoraggiarsi, nonchè fantasia e creatività. Se questi articoli avranno successo (le persone li gradiscono, mi lasciano commenti, richieste ecc) allora continuerò su questa strada. Oggetto di questa trattazione saranno i microcontrollori PIC della Microchip, i famosi PICMicro (o PIC come ancora a qualcuno piace chiamarli) e il linguaggio che preferisco per programmarli: il C. Prima di cominciare a parlare di come si programma un picmicro, bisogna per forza di cose dare una visione d’insieme del protagonista di questa trattazione.
Cos’è un microcontrollore? Un microprocessore e un microcontrollore sono la stessa cosa?
Chiariamo innanzitutto che un microcontrollore è qualcosa di molto più elaborato di un microprocessore. In parole molto povere: un microprocessore è un circuito integrato destinato unicamente ad effettuare calcoli. Un microcontrollore contiene al suo interno un microprocessore (CPU – sempre destinato a fare calcoli) più numerose altre periferiche che gli permettono di interagire con il mondo esterno: linee di comunicazione, un certo quantitativo di memoria per immagazzinare dati e programmi, convertitori analogico/digitali ecc. Si capisce quindi che un microcontrollore è in realtà un computer completo racchiuso all’interno di un circuito integrato; non per niente una delle definizioni che viene data della sigla PIC è proprio “Programmable Intelligent Computer” anche se io preferisco la definizione più classica “Programmable Interface Controller”. E’ chiaro che quando parlo di PIC o PICMicro mi riferisco sempre ai circuiti integrati prodotti dalla Microchip, ma di microcontrollori ne esistono una grande varietà, ognuno diverso dall’altro nell’architettura, sviluppo, linguaggi di programmazione disponibili, costi ecc (ci sono gli AVR della Atmel, gli OOPic – che sono sempre PICMicro venduti preprogrammati ma non dalla Microchip -, i Basic stamp della Parallax ecc) .
La Microchip commercializza i suoi microcontrollori con il nome di PICMicro e non PIC (PIC era il nome che avevano inzialmente quando venivano prodotti da un’altra società chiamata General Instruments)
Un microcontrollore generico viene anche identificato con la sigla MCU (Micro Controller Unit – Unità a micro controllore).
I microcontrollori PIC hanno una architettura di tipo RISC (Reduced Instruction Set Computer) ovvero questi MCU sono in grado di svolgere tutte le loro funzioni facendo affidamento ad un set ridotto di istruzioni (si parte dai PICMicro semplici che hanno soltanto 35 istruzioni per arrivare a quelli di ultima generazione che ne hanno 77), in parole povere: per scrivere il nostro programma in un linguaggio di basso livello (assembler) avremo bisogno di imparare soltanto 33 istruzioni. Se invece programmiamo in un altro linguaggio… Allora dovremo imparare le istruzioni del linguaggio che abbiamo deciso di utilizzare.
Quali sono le periferiche di cui possono essere dotati i PICMicro?
Una delle “periferiche” principali di cui è dotato un microcontrollore è sicuramente la memoria interna. La memoria di un microcontrollore ha il compito principale di immagazzinare il programma che deve eseguire e quindi anche di immagazzinare i dati (le variabili) provenienti dall’esterno o elaborate dal programma. Generalmente vengono utilizzati microcontrollori che hanno una memoria di tipo Flash (perchè più pratica e riutilizzabile). Le memorie Flash sono una varietà di memoria EEPROM (o E2PROM) (Electrically Erasable and Programmable Read Only Memory – memoria a sola lettura programmabile e cancellabile elettricamente): i dati vengono immagazzinati all’interno della memoria e lì rimangono anche in assenza di alimentazione elettrica (come le memorie delle macchine fotografiche o le pendrive insomma), quando si ha bisogno possono anche essere cancellati elettricamente. Esistono anche microcontrollori “finestrati” che hanno bisogno della luce ultravioletta per la cancellazione della memoria o anche microcontrollori che possono essere programmati una volta sola (OTP – One Time Programming) e non possono più essere cancellati (ovviamente questa è una scelta pessima per un hobbysta!).
Rimanendo in tema di memoria, bisogna aggiungere che i PICMicro hanno anche un’architettura di tipo Harvard: questo significa che la memoria è sezionata: vengono mantenute separate la memorizzazione dati e le istruzioni. Difatti la memoria dei PICMicro è suddivisa in 2 o più banchi. Programmando in linguaggi di basso livello (assembler) per eseguire le operazioni è necessario difatti specificare su quale banco di memoria stiamo lavorando, nei linguaggi di alto livello (C, Basic ecc) non è necessario specificare il banco di memoria dal momento che queste istruzioni vengono aggiunte direttamente dal compilatore senza che ce ne preoccupiamo (questo è uno dei tanti vantaggi dei linguaggi ad alto livello).
Linee di I/O. Tramite le linee di Input/Output, che non possono mai mancare in nessun microcontrollore, il nostro PICMicro è in grado di rilevare “stimoli” digitali provenienti dall’ambiente esterno (Input: pressione di un tasto, ricezione di un segnale digitale, chiusura di un contatto ecc) oppure trasmetterli (Output: accensione di un led, di un relè, azionamento di una valvola o di una serratura, scritte su un display ecc). Difatti tramite il programma che andremo ad inserire nel nostro microcontrollore, saremo in grado di dire ad esso quali pin (piedini) dovranno funzionare come ingressi (input) e quali come uscite (output).
Convertitori analogico/digitali (A/D). Tramite questo tipo di periferiche siamo in grado di acquisire un segnale analogico proveniente dall’esterno e convertirlo in un segnale digitale per poterci lavorare su ed elaborarlo nel nostro programma (es: sonde di temperatura, sonde analogiche in generale ecc). Una bella cosa davvero se dobbiamo realizzare , ad esempio, un sistema di irrigazione per il nostro giardino! Scriveremo un programma che leggerà la temperatura esterna e l’umidità del terreno, se questi dati letti rientrano in un certo intervallo, allora faremo aprire l’elettrovalvola dell’acqua per innaffiare le piante. Magari potremo farlo soltanto se è sera (leggiamo la luminosità esterna tramite una fotoresistenza!) o soltanto se siamo in una fascia oraria stabilita. Ovviamente questa è soltanto una delle innumerevoli applicazioni che possono essere realizzate da un PICMicro ma rende bene l’idea delle potenzialità di questi dispositivi, della loro capacità di interfacciarsi con oggetti di uso comune e di renderci facile il lavoro!
Moduli PWM. I moduli PWM sono in grado di generare delle onde quadre che possiamo utilizzare per svariate applicazioni, la più comune è quella della regolazione della velocità dei motori, della luminosità delle lampade ecc. Per conoscere bene il PWM fate riferimento all’ottimo tutorial scritto da Mauro Laurenti, accessibile dall’area Risorse di Settorezero.
Bus di comunicazione. Tramite i bus di comunicazione (che non sono nient’altro che linee di I/O seriali) siamo in grado di comunicare con altri dispositivi: USB, CAN, SPI, USART, I2C. L’Usart ci permette di comunicare con la porta seriale RS232 del pc o di altri strumenti (e non solo), e quindi scambiare informazioni o dare istruzioni. Il protocollo di comunicazione CAN ad esempio è molto utilizzato sulle automobili per far comunicare tra loro i vari dispositivi. Il protocollo I2C è usatissimo per comunicare con piccoli dispositivi tipo integrati realtime-clock (orologi), misuratori di distanza ad ultrasuoni, integrati che permettono di espandere gli I/O ecc ecc.
Timer. I timer o temporizzatori sono importantissimi e indispensabili. Ogni PICMicro ha almeno un timer ad 8 bit. Il compito di queste periferiche è appunto quello di effettuare conteggi in maniera regolare e vengono utilizzati un po’ per tutto: generare onde quadre, eseguire operazioni allo scadere di un tempo prefissato, realizzare applicazioni multitasking ecc.
Ovviamente non tutti i PICMicro hanno al loro interno tutti questi moduli, ci sono PICMicro che li contengono tutti o quasi (ad esempio il PIC16F877A, un vero e proprio cavallo di battaglia della Microchip, con il suo package da 40 pin e tutte le periferiche che ha… è uno dei più versatili, così come il fratello minore PIC16F876 o il maggiore PIC18F4520 per citarne alcuni), altri che non ne contengono qualcuno ecc. (ma non mancano mai gli I/O e almeno un timer). Per cui: quando decidiamo di realizzare qualcosa, bisogna sempre sapere quale PICMicro utilizzare. A volte la cosa bella risiede proprio nel fatto che anche se il nostro PICMicro non ha questo o quell’altro dispositivo al suo interno, se siamo bravi, possiamo sempre emularlo via software o tramite dei circuiti esterni che possono comunicare con il nostro dispositivo!
La scelta di uno o dell’altro microcontrollore molto spesso risiede anche in motivi di compattezza e/o economicità del dispositivo che intendiamo realizzare e quindi ci ritroviamo a scegliere PICMicro con solo 8 pin che magari possono non avere delle periferiche, ma se riusciamo ad emularle via software, qual è il problema? Soprattutto se si può risparmiare? Nell’immagine vediamo ad esempio (sul mio dito!) un PIC12F675: in uno spazio così compatto (solo 8 pin) abbiamo 6 linee di I/O delle quali 4 utilizzabili come convertitori A/D, 2 timer di cui uno a 16bit, un oscillatore interno che ci permette di minimizzare la circuiteria esterna, e una tensione di funzionamento che arriva fino a 2Volt soltanto, per un prezzo davvero irrisorio (si può acquistare per 2 euro circa). Questo ad esempio lo utilizzo personalmente per fare i telecomandi a infrarossi (anche se è sprecato per questo scopo, ma perlomeno è facile da reperire).
Quali sono i linguaggi di programmazione che si possono utilizzare per scrivere il programma da inserire nel nostro PICMicro?
Il linguaggio di programmazione predefinito dei PICMicro è l’assembler. L’assembler è sicuramente un modo molto potente di gestire il nostro microcontrollore ma non è certo il più semplice da apprendere. Per programmare in assembler bisogna avere prima di tutto una profonda conoscenza dell’architettura interna del PICMicro che stiamo utilizzando e una mente davvero molto elastica: realizzare le cose in assembler richiede spesso davvero molte righe di codice, che magari in C vengono scritte in maniera molto più semplice e/o intuitiva. Ma l’assembler in alcuni rari casi è davvero necessario. Le istruzioni assembler disponibili per ogni PICMicro sono contenute nel suo Datasheet, così come la descrizione della segmentazione della memoria e di tutte le funzioni. Per cui: quando programmate un PICMicro, abbiate sempre l’accortenza di avere a portata di mano il suo Datasheet, che si può scaricare gratuitamente dal sito della Microchip. I Datasheet sono disponibili unicamente in inglese e questo non dovrebbe costituire un problema dal momento che chi si appresta a fare una cosa del genere dovrebbe sapere in partenza che la grande maggioranza del materiale è sempre scritto in inglese (ma questa “regola” è valida per qualsiasi disciplina in generale).
Il linguaggio che personalmente preferisco per la programmazione dei PICMicro è il C. Ogni casa produttrice di software ha implementato (purtroppo) una propria versione del C, questo porta ad una tragica conseguenza: non tutti i programmi scritti in C per un compilatore possono funzionare con un diverso compilatore C per PICMicro. I linguaggi C che seguono gli standard vengono chiamati ANSI-C, uno di questi è l’HITEC-C della HTSoft (che però è a pagamento, a meno che non si scarichi la versione Lite, gratuita anche per scopi commerciali, che però presenta delle limitazioni – ed è questa quella che utilizzeremo in questi articoli). Oltre all’assembler e al C, esistono anche il Basic e di recente anche il Pascal. Ma procediamo per passi: a cosa serve il compilatore?
Noi scriviamo il nostro programma col linguaggio che preferiamo: ovvero digitiamo una serie di istruzioni per dire al PICMicro COSA deve fare, COME si deve comportare ecc. Ovviamente il PICMicro non è in grado di eseguire questo programma così come noi l’abbiamo scritto, per cui allo stesso modo con cui si scrive un programma per PC è necessario in qualche modo convertire (passatemi il termine, assolutamente inappropriato) il nostro codice sorgente in codice eseguibile (linguaggio macchina), ovvero: interpretabile dal dispositivo che lo deve eseguire.
Il compilatore esegue appunto questa operazione: trasforma il codice sorgente in linguaggio macchina. Nel caso dei PICMicro, il compilatore che sceglieremo avrà il duro compito di analizzare innanzitutto il programma che abbiamo scritto per andare alla ricerca di errori, e successivamente compilarlo per tirare fuori un file con l’estensione .HEX: è questo il file (il programma scritto in linguaggio macchina) che andrà ad essere inserito nel Microcontrollore tramite un programmatore.
Possiamo fare affidamento ad una grande varietà di linguaggi: teniamo conto, però, che non tutte le suite di programmazione possono essere integrate in MPLAB, anche se esistono altri sistemi di sviluppo (elencati più in basso) oltre MPLab:
C
Hitec-C (versioni complete -a pagamento- e Lite -free anche a scopi commerciali ma con limitazioni, segue lo standard ANSI)
Mikro-C (a pagamento, la versione demo è completamente funzionante ma limita l’HEX a 2Kwords)
SDCC (completamente Free e Open Source, segue lo standard ANSI, ma a quanto pare è difficile da integrare nel sistema di sviluppo della Microchip, è possibile però integrarlo in Piklab, vedi sotto)
CCS-C (a pagamento)
BoostC e BoostC++ (a pagamento e free con limitazioni)
MPC C Compiler (a pagamento, disponibile versione dimostrativa)
CC5X (a pagamento e free)
CPik (solo per Linux e per PIC18)
BASIC
PicBasic (a pagamento)
GCBasic (Free, Open Source)
MikroBasic (a pagamento)
BoostBasic (a pagamento e free con limitazioni)
PASCAL
JAL (free)
JALV2 (free)
MikroPascal (a pagamento)
PMP (Pic Micro Pascal) (Free)
FLOW CHART/ALTRO
Flowcode (a pagamento)
KTechLab (open source, per Linux)
Visual Parsic (Editor visuale, ? pare che lo sviluppo sia fermo)
Ladder Logic (Compilatore linguaggio Ladder, free)
SUITE DI SVILUPPO
Microchip MPLAB IDE (free)
Piklab (free – molti sistemi operativi supportati)
Pikdev (free, solo per Linux, supporta solo assembler e C per PIC18)
GPUtils (free – attualmente non c’è la versione per windows)
Pic Simulator Ide (free e a pagamento) – Suite di sviluppo e simulazione in Basic
L’unico che ho utilizzato io (per ora) è HITEC-C della HTSoft, ed è con questo che illustrerò le lezioni. Il motivo di tale scelta (HITEC-C) è semplice: segue lo standard ANSI e, in applicazioni del genere, seguire uno standard per me è una caratteristica che deve essere primaria: vuol dire che potremo utilizzare lo stesso codice sorgente anche per altri compilatori, su più piattaforme, senza la necessità di dover fare adattamenti, poi è supportato ufficialmente dalla Microchip (difatti il compilatore C di base viene integrato automaticamente nel setup di MPLAB).
Appena ho tempo mi piacerebbe riuscire ad utilizzare l’SDCC (che è completamente free ed opensource) abbinato alla suite Piklab. Appena ci riuscirò, pubblicherò di certo qualcosa.
Esistono anche le versioni C18 del C. Il C18 viene utilizzato unicamente per le ultime generazioni dei PICMicro (i 18Fxx e successivi) e comprendono un set di istruzioni più ampio (perchè i 18F e successivi hanno appunto un set di istruzioni maggiorato). La stessa HTSoft ha una versione C18, nonchè la Microchip che ne distribuisce una versione gratuita per gli studenti (C18 Student Edition).
Ovviamente il C18 può essere utilizzato esclusivamente per programmare i PICMicro della famiglia PIC18, PIC24, PIC32 e dsPIC, per cui non può essere utilizzato con le altre famiglie (PIC12, PIC16 ecc).
I compilatori possono essere utilizzati così come sono oppure essere integrati nel sistema di sviluppo della Microchip: l’MPLab IDE, che è la soluzione che preferisco, anche perchè l’HITEC-C è a riga di comando e viene integrato in automatico nell’MPLab, per cui non devo fare tanta fatica per compilare il programma ;)
Quale programmatore utilizzare?
Beh… Qui la scelta dipende molto dai gusti personali, da cosa si vuole programmare ecc. Generalmente si inizia sempre con un programmatore autocostruito, questa è sicuramente una buona scelta perchè ci permette di capire il meccanismo con il quale i PICMicro vengono programmati ed è una cosa che consiglio di fare a tutti anche perchè avere un programmatore costruito con le proprie mani da sicuramente molta soddisfazione.
Anni fa molti utilizzavano un programmatore su porta seriale con pochissimi componenti (l’arcinoto JDM programmer), che riusciva a programmare (a stento per il vero) i PIC16F84 e 16C84. La costruzione di un programmatore del genere la sconsiglio vivamente: i PIC per essere programmati hanno bisogno che vengano rispettate delle specifiche altrimenti o la programmazione non va a buon fine (e starete a sbattere la testa pensando che è il PIC ad essere difettoso, quando invece la colpa è soltanto del programmatore) o in rari casi il PIC viene danneggiato irreparabilmente. Molti ignorano che per far entrare un PICMicro in modalità programmazione è necessario fornire esattamente 13.5 Volt sul pin denominato MCLR, e tanti programmatori tralasciano questa semplice, necessaria, regola.
Un programmatore molto buono e semplice da costruire è quello ideato da Sergio Fiocco che è basato su uno schema molto classico. Potete trovare schema e descrizione sul suo sito (al quale ho fatto riferimento pure io per incominciare la programmazione in C). Tale programmatore è un classico a prova di bomba, l’unico neo (forse) è che prevede l’uso della porta parallela per il collegamento al PC, per cui sui portatili di ultima generazione non lo potete utilizzare (a meno che non utilizziate un adattatore usb/parallelo… ma per esperienza vi dirò che questi adattatori fanno tutto fuorchè il lavoro per il quale sono stati progettati! E non immaginate che nervi!). Sui portatili sprovvisti di parallela, se si ha la fortuna di disporre di uno slot PCMCIA si può ricorrere all’utilizzo di schede pcmcia che forniscono una porta parallela (questa soluzione è sicuramente funzionante rispetto all’utilizzo di un adattatore usb anche se il costo è elevato).
Ogni programmatore ha poi ovviamente bisogno del suo software di programmazione: ovvero un programma che ha il compito di leggere il file HEX generato dal compilatore e quindi comunicare con il programmatore per farli inserire il programma all’interno del PICMicro. Io per anni, insieme al programmatore di Fiser ho utilizzato il mitico IC-Prog (Free).
Personalmente dopo il programmatore autocostruito di Fiser, mi sono rivolto a uno strumento ideato dalla stessa Microchip: il PICKit2, un vero piccolo gioiello (oggi giunto alla versione 3 ma con un prezzo molto più elevato, anche perchè viene fornito con una scheda di sviluppo):

Tale programmatore oltre a presentare il netto vantaggio di essere davvero piccolo e funzionante su USB senza alimentazioni aggiuntive, ha anche altri lati positivi: costa poco, il firmware è aggiornabile, lo si può utilizzare anche come tester per segnali digitali e ha un suo software di programmazione realizzato dalla stessa Microchip. Il “problema” dei 13.5 Volt è stato risolto dalla Microchip in questo programmatore con un survoltore integrato in grado di elevare la 5 volt fornita dall’usb al voltaggio richiesto. La stessa Microchip ha anche reso disponibile lo schema elettrico di questo piccolo prodigio della tecnica, e questa è sicuramente una cosa degna di nota.
Per quelli che si chiedono: come fa il PICKit2 a programmare i PICMicro se su di esso non c’è nessuno zoccolo? La risposta è: il PICKit2 utilizza un connettore ICSP (continua a leggere) per la programmazione dei PICMicro: la programmazione avviene direttamente sulla scheda in cui è montato il microcontrollore, oppure potete farvi voi una schedina con gli zoccoli e il connettore ICSP.
Aggiornamento
Abbiamo inserito un articolo su come realizzarsi una piccola scheda adattatrice per programmare i vari tipi di picmicro e le eeprom con il pickit2:
Adattatore multizoccolo per pickit2
I PICMicro possono essere programmati in vari modi qualora il PICMicro scelto abbia disponibile la modalità di programmazione desiderata. Di default tutti i PICMicro possono essere programmati in maniera standard, ovvero con i normali programmatori che danno i 13.5 V sull’MCLR più i normali segnali di programmazione e alimentazione.
Molti altri PICMicro hanno anche disponibile la funzione LVP (Low Voltage Programming) che permette la programmazione a basso voltaggio (ovvero non dovremo più fornire i 13.5 V sul pin MCLR ma soltanto 5V) ma richiede per la programmazione l’utilizzo di un pin aggiuntivo (contrassegnato come PGM, normalmente non utilizzato per la programmazione standard).
Altra buona modalità di programmazione di alcuni PIC è quella tramite BootLoader: si programma per la prima volta il PIC in maniera normale, inserendo al suo interno un programma particolare che prende il nome di Bootloader (ne esistono tanti, la stessa MicroChip ne rende disponibile una sua versione), che occupa poco spazio. Le volte successive, quando dobbiamo riprogrammarlo, si farà utilizzo unicamente della porta seriale del PC: sarà il PIC, tramite le funzioni svolte dal bootloader, a capire se si deve mettere in modalità di programmazione oppure in modalità di esecuzione programma.
Quest’ultima è sicuramente una soluzione molto comoda, a parte il fatto che il Bootloader andrà ad occupare parte di memoria che verrà sottratta alla nostra applicazione, ma permette di non smontare il PIC dal circuito e di non disporre di un programmatore vero e proprio (almeno per le volte successive alla prima in cui è comunque necessario un normale programmatore per caricare il bootloader).
Predisponendo però opportunamente il nostro circuito, possiamo programmare il PIC in modalità normale (quindi senza bootloader e senza programmazione a basso voltaggio) anche mantenendolo montato nel circuito di utilizzo. In questi casi si fa uso di quella comodissima funzione chiamata ICSP (In-Circuit Serial Programming) che ormai tutti i PICMicro hanno già di serie e questa è la modalità che preferisco: programmazione normale, senza problemi di ingegnerizzazione (a patto di avere un buon programmatore) e soprattutto senza smontarlo dal circuito di utilizzo.
» Vai all’ indice delle lezioni e delle risorse del corso di programmazione
Articoli che potrebbero interessarti
Se desiderate che settorezero continui a rimanere gratuito e fruibile da tutti, non copiate il nostro materiale e segnalateci se qualcuno lo fa

Questo sito e tutto il suo contenuto sono distribuiti sotto la licenza








#1 da Guglia il 26 febbraio 2011
Posso dirti di pù, è stato scortese quando ho chiesto delle informazioni sulla prgrammazione della scheda stessa.
#2 da Giovanni Bernardo il 26 febbraio 2011
Pure! E nonostante questo l’hai comprata ugualmente? In ogni caso potresti riuscire a farci funzionare qualcosa leggendoti il datasheet e comparando con un corso già fatto… ma avrai di sicuro molte difficoltà proprio perchè ti ci stai addentrando ora. L’avere esperienze di programmazione aiuta sicuramente a ragionare in un certo modo e a ragionare nella maniera corretta quando si va a programmare… ma qui è un’altra cosa.
#3 da Guglia il 26 febbraio 2011
La scheda è stat comprata da un’altra persona. Comunque non ho trovato una scheda gsm simile a questa con lo stesso prezzo. L unica cosa che mi ha dato è questo:
#define out1 PORTD, 0
#define out2 PORTD, 1
#define out3 PORTD, 2
#define out4 PORTD, 3
#define out5 PORTD, 4
#define out6 PORTD, 5
#define out7 PORTD, 6
#define out8 PORTD, 7
#define apricanc2_emb LATE, 5
#define apricanc1_emb LATE, 6
#define outA PORTC, 2
#define outB LATE, 7
#define tasto_onoff LATE, 0
#define cts PORTG, 3
#define emergoff PORTB,2
#define led_on LATE,2
#define dcd PORTG,4
INB1 PORTB,4
INB2 PORTB,5
INB3 PORTB,6
INB4 PORTB,7
#define adc1 PORTA,0
#define adc2 PORTA,1
#define adc3 PORTA,2
#define adc4 PORTA,3
#define adc5 PORTA,5
#define adc6 PORTE,0
#define adc7 PORTE,1
#define adc8 PORTE,2
;noadc-an4-an0-an1-an2-an3-an6-an7-an8-an9-an10-an11
;PORTA,4 (non è adc) – PORTA,5 (an4*) – PORTA,0 (an0) – PORTA,1 (an1) -PORTA,2 (an2) – PORTA,3 (an3) – PORTF,1 (an6) – PORTF,2 (an7) – PORTF,3(an8) – PORTF,4 (an9) – PORTF,5 (an10) – PORTF,6 (an11)
#4 da Giovanni Bernardo il 26 febbraio 2011
Ci fai ben poco con quello che ti ha dato. Diciamo che non ci fai proprio niente. Comunque sia già voler partire a usare un modulo GSM non è cosa semplice… in ogni caso, per me, era meglio imparare a programmare un pic più comune, capire le basi soprattutto dell’UART (necessario per comunicare col modulo) e quindi in seguito interfacciare un modulo GSM, acquistabile a parte pure a meno di 20 euro
#5 da Guglia il 26 febbraio 2011
ma poi come farei ad interfacciare un modulo gsm ad una scheda?
#6 da Giovanni Bernardo il 26 febbraio 2011
l’ho detto: con l’UART
#7 da Guglia il 26 febbraio 2011
Intanto di ringrazio tantissimo per la disponibilità.
Scritto questo mi devi scusare ma non capisco cosa intendi per UART
#8 da Giovanni Bernardo il 26 febbraio 2011
UART = Universal Asynchronous Receiver Transmitter. E’ il modulo del picmicro che ti permette di comunicare su linea seriale (tipo rs232). I moduli GSM in genere comunicano tramite UART
#9 da Guglia il 26 febbraio 2011
grazie per la tempestività. Cmq mi stavo documentando proprio su questo. Rcapitolando:
dovrei acquistare una scheda relè con porta USB che mi permetterebbe la programmazione del Pic e poi di interfacciarmi con um modulo gsm che abbia un’inteffaccia UART. Giusto?
Correggimi se sbaglio, perciò dovrei programmare il pic in maniera tale che, a secondo i casi, invii mediante intefaccia UART al modulo GSM e che dovrebbe far partire l sms. Giusto?
Hai qualche link da consigliarmi per far ciò che ti ho appena detto? spero di essere stato chiaro! Prometto che se riesco arrivaerà una “donazione”. Grazie
#10 da gugliait il 4 marzo 2011
hai ragione… penso di fare come mi stai suggerendo. ma toglimi una curiosità: ho una scheda con degli esempi di programmi ma che si basano su picF18, mi sapresti linhare il software mplab, con compilatore C, da poter utilizzare?
grazieeeeee
#11 da Giovanni Bernardo il 4 marzo 2011
sfogliati la sezione “picmicro”, ci sono tutti i link di cui hai bisogno e anche di più
#12 da slavin89 il 14 marzo 2011
salve, spero di scrivere nel posto giusto.
mi sto cimentando nella programmazione solo da poco ma avendo solo qualche base di elettronica ma nulla di programmazione faccio una fatica estrema a capire il tutto; nonostante questo la vostra guida mi sta davvero rendendo la cosa più semplice e piacevole.sono arrivato a leggere fino alla lezione sul prescaler ma ancora non capisco alcune cose.
si parla di file di delay che da quanto ho capito sono file per impostare dei tempi.ma a cosa si riferiscono? e soprattutto come faccio a creare un file delay per applicazioni diverse da quelle proposte da voi?..magari sono domande stupide ma spero mi possiate rispondere cosi un poco alla volta entro a capire sto linguaggio e soprattutto la logica che ne consegue.
grazie e complimenti per la guida
#13 da Giovanni Bernardo il 14 marzo 2011
I delay sono i ritardi. Ci sono delle librerie per creare dei ritardi. Un ritardo è uno dei concetti di base in qualsiasi linguaggio di programmazione. Non hai bisogno di creare un delay per un’ applicazione diversa e a dire il vero non ho nemmeno idea di cosa vuoi dire con questa frase… Basta una libreria, punto. E poi non è detto che nella tua applicazione ci sia strettamente necessità di usare i ritardi.
#14 da slavin89 il 14 marzo 2011
volevo dire che se io costruisco un progettino poi realizzo il programma..come faccio a capire il deelay di cui ho bisogno e come lo creo ?..per esempio devo costruire un timer che ogni tot di tempo avvia un altro programma..o alimenta un circuito..come faccio a creare il deelay per pilotare il circuito?
#15 da Giovanni Bernardo il 14 marzo 2011
Scusa ma… io davvero non arrivo a capire il concetto che vuoi esprimere… Il problema forse sta nel fatto che tu non hai mai programmato per cui magari non sai nemmeno come esprimerti. Secondo me non devi farti ora queste domande, ma focalizzarti sui programmi semplici e capire ogni singola istruzione di programma cosa fa e in che modo la fa. E’ cosi che si incomincia: si scrive un programma già realizzato da qualcun altro, si analizzano le singole istruzioni e si cerca di capire come va il flusso del programma, poi si inizia a fare le prime timide modifiche giusto per capire se ciò che si è imparato lo si è imparato in maniera corretta e quindi si va avanti.
#16 da slavin89 il 14 marzo 2011
mm si bè senza ombra di dubbio non sono preparato sull’argomento quindi ho le idee molto confuse..più che sul linguaggio sulla logica ce devo seguire..il fatto delle librerie per esempio non mi è chiaro.
quali e perchè le devo caricare..e altra cosa non ho capito se per esempio il prescaler e le temporizzazioni vanno impostate su un’altro file e poi richiamate oppure si possono compilare nel main..ho un po di confusione scusate..però vi ringrazio di cuore per questa guida e spero mi aiuti a raggiungere il mio obbiettivo
#17 da mirks il 16 marzo 2011
Ciao, intato complimenti per la guida ! sono arrivato alla sesta lezione senza nessuna difficolta, una guida davvero per tutti quelli che si affacciano a questo nuovo mondo. Oggi mi arrivato il pickit2 e avrei una domanda da farti:
Nella lezione numero 2, nel circuito di funzionamento si vede che il pic necessita di una alimentazione di +5 sul piedino 32,11 mclr ecc ecc… Notando pero il connettore del pickit2 si vede che c’è un uscita di 5 volt. La domanda è : Posso usare l’uscita del pickit2 a 5 volt per far funzionare l’integrato, o è necessario uno stabilizzatore tipo LM ? (Perche proprio non riesco a capire a cosa servono quei 5 volt)
Grazie
#18 da Giovanni Bernardo il 16 marzo 2011
I 5 volt servono ovviamente per alimentare il picmicro durante la programmazione… se no come lo programmi? I 13.5V su mclr servono solo per far andare il pic in modalità programmazione, non per alimentarlo durante la programmazione. In ogni caso si puoi usare la 5V anche per alimentare il circuito, il software del pickit ha difatti una checkbox che se la spunti fa arrivare tensione. Con questo sistema hai due problemi:
- non puoi permetterti di “tirare” via troppa corrente (non so dirti quanto ma non puoi certo farci girare un motorino)
- i pin RB6 e RB7, che sono quelli usati per la programmazione, sono sempre tirati a massa. Per cui se realizzi un circuito che usa quei due pin e alimenti il circuito col pickit, sappi che su RB6 e RB7 non ci puoi fare affidamento
#19 da mirks il 16 marzo 2011
Perfetto, ho capito ! Ti ringrazio .
#20 da slavin89 il 23 marzo 2011
salve a tutti
grazie alla vostra guida sto facendo passi avanti e oggi ho deciso di mettere un po in pratica quello che sto imparando e dopo aver compilato il programma mi trovo davanti un’ostacolo;
io utilizzo la connessione rs 232 come comunicazione tra pc e pragrammatore e quindi una volta copilato il programma come lo trasferisco sul pic?..nella guida ho letto solo l’esempio per pickit2 e per seriale come devo fare?
#21 da Giovanni Bernardo il 24 marzo 2011
Mi dispiace ma dei programmatori su seriale non me ne devi proprio parlare. Se proprio lo vuoi usare esistono un sacco di programmi-dinosauro del tipo icprog. Ma avrai tanti problemi.
#22 da slavin89 il 24 marzo 2011
quindi dovrei acquistare il pickit2 per stare tranquillo?..comunque sono soddisfattissimo dei risultati che sto ottenendo grazie a voi anche se praticamente non ho ancora applicato nulla ho imparato un sacco di cose
GRAZIE
#23 da Giovanni Bernardo il 24 marzo 2011
Prova a usare il programmatore che hai tu con ICPROG. Però i programmatori su seriale sono fuori specifica e non è sicuro che riesci a programmare tutto, di certo non puoi fare il debug. Col pickit vai tranquillo
#24 da slavin89 il 24 marzo 2011
sto provando infatti con ic prog ma apparte che quando vado ad aprire il file hex creato con mp lab mi carica qualche stringa di dato che senza dubbio non è il programma completo e in secondo luogo mi da un errore di verifica fallita all’adress 0000h e il circuito poi non funziona
#25 da Giovanni Bernardo il 24 marzo 2011
Tipico errore dovuto al fatto che i programmatori su seriale non sono in grado di fornire 13.5V su MCLR durante la programmazione. I programmatori su seriale potevano andare coi pic vecchi, e manco andavano bene. Prova piuttosto con un programmatore su parallela
#26 da slavin89 il 24 marzo 2011
sinceramente non mi è molto chiaro questo concetto di parallela..quali sarebbero? scusa l’ignoranza
#27 da Giovanni Bernardo il 24 marzo 2011
I programmatori che utilizzano la porta parallela… Nei primi articoli ho messo qualche link…
#28 da slavin89 il 24 marzo 2011
ok ho capito qual’è..mm e si può fare una connessione da rs232 a parallela ?
#29 da Giovanni Bernardo il 24 marzo 2011
….ehm… no!
#30 da alex il 6 aprile 2011
ciao tutti!! ho bisogno di una mano!!
devo creare un programma in c per il microcontrollore pic 16f84a
in cui 4 line di ingresso pilotano 4 led
e mi accendono e spengono!!!
#31 da Giovanni Bernardo il 6 aprile 2011
Qui non si risolvono i compiti per casa. Le lezioni su come accendere un led ci sono, basta leggere e applicarsi per fare le modifiche di cui si ha bisogno.
#32 da carobot il 12 aprile 2011
Salve,
premesso che sono un principiante, attraverso questa guida che ritengo la più completa nel suo genere, ho imparato e continuo ad imparare tantissime cose.Mi sto cimentando in un progetto che prevede il pilotaggio di 4
motori mediante joystiks. Al momento con un programma caricato su un pic 16f877A riesco a pilotarne due con
i due moduli pwm presenti nel suddetto micro.Ne mancano due che dovrei pilotare con pwm software ma non saprei da dove cominciare.Ho letto da qualche parte che potrei utilizzare un’altro pic 16f877A collegato al primo.
Questo collegamento come può avvenire? Via UART? via I2C? Potrei avere qulche suggerimento? Grazie. Carobot
#33 da GiacomoDalSasso il 20 aprile 2011
Ciao . Ho un problema forse grave . oggi mi è arrivato il pickit3 e ho installato il relativo software di programmazione . ho connesso il programmatore e quando tento di fare il download del firmware mi viene scritto “protocol error:unable tu send DDS” , cosa può essere ?
Grazie
#34 da Giovanni Bernardo il 20 aprile 2011
Il Pickit3 non ha il software di programmazione, si usa integrato in MPLab. A meno che non stai utilizzando la versione beta. Non è che per caso hai scaricato il software del pickit2 e stai cercando di farlo funzionare col pickit3 ?
#35 da giacomo il 20 aprile 2011
No utilizzo il suo software si chiama proprio Pickit 3 programmer , praticamente è identico a quello del 2. purtroppo anche eseguendo la programmazione da mplab non mi rileva il dispositivo dicendo di connettere di dispositivo (microcontrollore) per far funzionare pickit. ho seguito alla lettera anche il circuito descritto sopra … ma niente .
#36 da Giovanni Bernardo il 20 aprile 2011
Non ti saprei dire… forse il pickit è uscito difettoso, magari non è programmato… non ti saprei dire. Prova a chiedere sul forum della microchip
#37 da GiacomoDalSasso il 20 aprile 2011
C’è un modo per verificare le tensioni su pickit 3 ? penso non arrivino i 13,5 V . Eppure ho seguito il circuito alla lettera . cpmunque anche usandolo da mplab mi dice di connettere un dispositivo(microcontrollore) al pickit.
#38 da Giovanni Bernardo il 20 aprile 2011
Ma hai provato a collegare un pic al pickit? Voglio dire… MPlab non ti sta dicendo che il pickit non c’è… ti sta dicendo forse “a che ti serve il pickit se non c’è un pic collegato?”
#39 da GiacomoDalSasso il 20 aprile 2011
sono riuscito a superare questo punto morto . avevo dimenticato di settare nelle impostazioni che l’alimentazione venisse fornita direttamente dal pickit. ora riconosce il pic fa l’erase e la lettura ma quando lo programmo mi da l’errore ” all’indirizzo 00000020 è atteso 00003fff ma viene trovato 00000000.
#40 da Electroemme il 16 giugno 2011
Ciao,
sono un nuovo utente del sito. Innanzitutto voglio fare i complimenti a Giovanni e a tutti quelli che lavorano per queste interessanti pagine. Gli argomenti sono esposti in modo chiaro e comprensibile.
Ho iniziato anche io con il mitico corso di Tanzilli, che mi ha aperto le porte a questo fantastico mondo! Conosco anche il C, a livello di base. Mi sto esercitando con l’assembler, con il quale sto facendo programmini vari, nei ritagli di tempo, iniziando con effetti di luce coi led ecc… con alcuni 16F627. Prima di addentrarmi con il C vorrei ancora “smanettare” un po’ con l’assembler.
Ho trovato interessante il programma del contatore, quello in assembler redatto da Roberto Carraro. Smanettando con l’assembler però ho trovato un problema con la direttiva RES.. mi spiego: ho due versioni di MPASM, la 5.37 e la 5.01… Mi sono accorto che la 5.37 non riconosce la direttiva RES (da errore di compilazione), mentre l’altra più vecchia sì… come mai accade questo? Non riesco a capire… Compilando due sorgenti identici con una o più direttive RES il primo mi da errore, l’altro no… boh…
Grazie per l’eventuale risposta e ancora complimenti!
#41 da Giovanni Bernardo il 16 giugno 2011
Mi dispiace ma sull’assembler non sono ferrato, dovresti chiedere a Roberto Carraro.
#42 da Electroemme il 16 giugno 2011
Ok, grazie mille lo stesso.
#43 da Guglia il 23 giugno 2011
Spero di postare nel punto giusto…
Ho una scheda con un pic18f2620 (8 uscite digitali, 4 ingressi analogici, 4 ingressi digitali) e un software che mi ha dato colui che mi ha venduto la scheda ma che si scarica dal sito della micro. Ho modificato questo softaware secondo le mie esigenze ma quando cerco di inviare i dati letti da una porta analogica tramite tcp, si verifica una cosa strana. la funzione che uso è questa:
void ANALOGIC_pot3(TCP_SOCKET MioSocket)
{
BYTE AN0String[8];
WORD ADval;
Delay10TCYx(3);
ADCON0=0×25; // B3
ADCON1=0×0;
ADCON2=0×3C;
// Wait until A/D conversion is done
ADCON0bits.GO = 1;
while(ADCON0bits.GO);
// Convert 10-bit value into ASCII string
ADval = (WORD)ADRES;
//ADval *= (WORD)10;
//ADval /= (WORD)102;
if (ADval 5*TICK_SECOND)
{
// Close the socket so it can be used by other modules
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
GenericTCPExampleState–;
}
//RESPONSE_SISTEMACONTROLLO1 = FALSE;
//RESPONSE_SISTEMACONTROLLO2 = FALSE;
break;
}
Timer = TickGet();
// Make certain the socket can be written to
if(TCPIsPutReady(MySocket) < 1u) {
//RESPONSE_SISTEMACONTROLLO1 = FALSE;
//RESPONSE_SISTEMACONTROLLO2 = FALSE;
break;
}
// Place the application protocol data into the transmit buffer. For this example, we are connected to an HTTP server, so we'll send an HTTP GET request.
TCPPutROMString(MySocket, (ROM BYTE*)"GET ");
TCPPutROMString(MySocket, RemoteURL);
if (RESPONSE_SISTEMACONTROLLO1 || RESPONSE_SISTEMACONTROLLO2){
TCPPutROMString(MySocket, (ROM BYTE*)"T=1&");
TCPPutROMString(MySocket, (ROM BYTE*)"IDOper=");
TCPPutString(MySocket, IDOper);
TCPPutROMString(MySocket, (ROM BYTE*)"&");
TCPPutROMString(MySocket, (ROM BYTE*)"IDImp=");
TCPPutString(MySocket, IDImp);
TCPPutROMString(MySocket, (ROM BYTE*)"&");
}
if (RESPONSE_SISTEMACONTROLLO1){
RESPONSE_SISTEMACONTROLLO1 = FALSE;
TCPPutROMString(MySocket, (ROM BYTE*)"StepOper=2&");
}
if (RESPONSE_SISTEMACONTROLLO2){
RESPONSE_SISTEMACONTROLLO2 = FALSE;
TCPPutROMString(MySocket, (ROM BYTE*)"StepOper=3&");
TCPPutROMString(MySocket, (ROM BYTE*)"IDSist=");
TCPPutString(MySocket, IDSist);
TCPPutROMString(MySocket, (ROM BYTE*)"&");
TCPPutROMString(MySocket, (ROM BYTE*)"PC=4&VC=");
ANALOGIC_pot(MySocket);
TCPPutROMString(MySocket, (ROM BYTE*)"&");
TCPPutROMString(MySocket, (ROM BYTE*)"P1=5&V1=");
ANALOGIC_pot1(MySocket);
TCPPutROMString(MySocket, (ROM BYTE*)"&");
TCPPutROMString(MySocket, (ROM BYTE*)"P2=6&V2=");
ANALOGIC_pot2(MySocket);
}
if (RESPONSE_SISTEMA1 || RESPONSE_SISTEMA2) {
TCPPutROMString(MySocket, (ROM BYTE*)"T=2&");
TCPPutROMString(MySocket, (ROM BYTE*)"IDOper=");
TCPPutString(MySocket, IDOper);
TCPPutROMString(MySocket, (ROM BYTE*)"&");
TCPPutROMString(MySocket, (ROM BYTE*)"IDImp=");
TCPPutString(MySocket, IDImp);
TCPPutROMString(MySocket, (ROM BYTE*)"&");
TCPPutROMString(MySocket, (ROM BYTE*)"PS=9&"); //ID Pannello, legato alla stringa
if (RESPONSE_SISTEMA2) {
TCPPutROMString(MySocket, (ROM BYTE*)"StepOper=11&");
TCPPutROMString(MySocket, (ROM BYTE*)"&");
TCPPutROMString(MySocket, (ROM BYTE*)"VS=");
ANALOGIC_pot3(MySocket);
RESPONSE_SISTEMA2 = FALSE;
}
else if (RESPONSE_SISTEMA1){
TCPPutROMString(MySocket, (ROM BYTE*)"StepOper=10&");
TCPPutROMString(MySocket, (ROM BYTE*)"&");
TCPPutROMString(MySocket, (ROM BYTE*)"VS=");
ANALOGIC_pot3(MySocket);
RESPONSE_SISTEMA1 = FALSE;
}
}
TCPPutROMString(MySocket, (ROM BYTE*)" HTTP/1.0\r\nHost: ");
TCPPutString(MySocket, ServerName);
TCPPutROMString(MySocket, (ROM BYTE*)"\r\nConnection: close\r\n\r\n");
// Send the packet
TCPFlush(MySocket);
GenericTCPExampleState++;
break;
case SM_PROCESS_RESPONSE:
if(RESPONSE_SISTEMACONTROLLO1){
//RESPONSE_SISTEMACONTROLLO1 = FALSE;
}
if(RESPONSE_SISTEMACONTROLLO2){
// RESPONSE_SISTEMACONTROLLO2 = FALSE;
}
// Check to see if the remote node has disconnected from us or sent us any application data
// If application data is available, write it to the UART
if(!TCPIsConnected(MySocket))
{
GenericTCPExampleState = SM_DISCONNECT;
// Do not break; We might still have data in the TCP RX FIFO waiting for us
}
// Get count of RX bytes waiting
w = TCPIsGetReady(MySocket);
// Obtian and print the server reply
i = sizeof(vBuffer)-1;
vBuffer[i] = '';
while(w)
{
if(w < i)
{
i = w;
vBuffer[i] = '';
}
w -= TCPGetArray(MySocket, vBuffer, i);
#if defined(STACK_USE_UART)
putsUART((char*)vBuffer);
#endif
// putsUART is a blocking call which will slow down the rest of the stack
// if we shovel the whole TCP RX FIFO into the serial port all at once.
// Therefore, let's break out after only one chunk most of the time. The
// only exception is when the remote node disconncets from us and we need to
// use up all the data before changing states.
if(GenericTCPExampleState == SM_PROCESS_RESPONSE)
break;
}
break;
case SM_DISCONNECT:
// Close the socket so it can be used by other modules
// For this application, we wish to stay connected, but this state will still get entered if the remote server decides to disconnect
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
GenericTCPExampleState = SM_DONE;
break;
case SM_DONE:
// Do nothing unless the user pushes BUTTON1 and wants to restart the whole connection/download process
//if(BUTTON0_IO == 0u)
if(RESPONSE_SISTEMACONTROLLO2){
GenericTCPExampleState = SM_HOME;
break;
}
if(RESPONSE_SISTEMACONTROLLO1){
GenericTCPExampleState = SM_HOME;
break;
}
if(RESPONSE_SISTEMA2){
GenericTCPExampleState = SM_HOME;
break;
}
if(RESPONSE_SISTEMA1){
GenericTCPExampleState = SM_HOME;
break;
}
/* if (MotoreSistemaAvviato) {
GenericTCPExampleState = SM_HOME;
RELAY7_IO_Prec = RELAY7_IO;
break;
}
if (RELAY7_IO_Prec && !RELAY7_IO) {
GenericTCPExampleState = SM_HOME;
break;
} */
break;
}
}
la cosa strana che si verifica è quando invio tramite tcp il valore letto nella porta analogica mi si attiva una porta digitale.
AIUTOOOOOOOOOO
#44 da odessos il 30 settembre 2011
Ho un problema di questo tipo: sto utilizzando il software hi-tech C, versione free ovviamente, ma mi accorgo che all’interno della cartella delle librerie, nei file da includere relativi ai PIC da utilizzare non c’è il PIC che vorrei usare: un 12F629.
Devo rassegnarmi a creare io la libreria o sarà possibile scaricarla da qualche parte?
salutissimi da
Ste.
#45 da Giovanni Bernardo il 30 settembre 2011
Le versioni dalla 9.81 in poi hanno il file pic12f629.h , le versioni dalla 9.80 compresa in giù hanno il file pic12f6x.h
#46 da odessos il 20 novembre 2011
Ma se un PIC, come ad esempio il 16F877 o similari non avesse abbastanza memoria di programma, c’è qualche modo per aumentarla con una mem. esterna?
saluti
Stefano
#47 da Giovanni Bernardo il 20 novembre 2011
Una eeprom esterna la puoi usare soltanto per contenere dati, no memoria programma. Se hai bisogno di più spazio per il programma passi ad un pic con più memoria programma.
#48 da Giovanni Bernardo il 26 febbraio 2011
La scheda col pic puoi programmarla con un programmatore. Anche se c’è l’usb, per poterla programmare da usb è necessario che il pic montato sia dotato di bootloader e che ti abbiano fornito il programma per caricare il firmware tramite bootloader. Io penso che se stai a digiuno completo stai correndo troppo. Guarda che interfacciarsi con un gsm non è cosa facile.