Corso programmazione PICMicro in C – Approfondimenti – Gestione di un tastierino a matrice

Ecco un’ altra diavoleria elettronica dal costo irrisorio e davvero caruccia da utilizzare per le nostre applicazioni: il tastierino a matrice (matrix keypad).

Questi tastierini si trovano comunemente nei formati 3×4 (che è in pratica uguale a quello usato sui telefoni, ovvero numeri da 0 a 9 e quindi asterisco e cancelletto) oppure come quello in foto da 4×4 (che ha in aggiunta le lettere ABCD), che è quello che userò per questa prova.

Questi tastierini sono in realtà una semplice serie di pulsanti collegati in maniera un po’ particolare in maniera da minimizzare i collegamenti necessari.

Il collegamento è a matrice, ovvero: sono organizzati in una serie di righe e colonne ed ogni pulsante mette in comunicazione una riga con una colonna.

Vi schematizzo qui come sono effettuati i collegamenti dei pulsanti in un tastierino a matrice 4×4:

In pratica se premiamo il pulsante “1” metteremo in comunicazione la riga 1 con la colonna 2, premendo la “C” metteremo in comunicazione la riga 3 con la colonna 4 e così via.

Gestire una cosa del genere, per chi è alle prime armi, può risultare una cosa abbastanza complicata. In realtà vi dimostrerò che è più semplice di quello che si immagina e che inoltre esiste più di un sistema per poterlo fare.

Vari sistemi di lettura di un tastierino a matrice

Uno dei sistemi che prevede l’utilizzo delle tastiere a matrice richiede addirittura un solo pin del picmicro! Si tratta in pratica di collegare i rami del tastierino a resistenze di precisione con valore noto e diverso tra loro: premendo ogni pulsante si avrà in uscita, su un unico ramo, una tensione caratteristica per ogni pulsante premuto, la quale ovviamente, per essere letta, avrà bisogno di un picmicro dotato di convertitore A/D abbastanza veloce e con una buona risoluzione.

Vi illustro qui lo schema concettuale prelevato dall’Application Note 234 della Microchip (scaricabile in fondo all’articolo):

Anche se tale soluzione permette l’utilizzo di un tastierino a matrice anche con i picmicro a 8 pin (ma anche con quelli a 6pin!), è abbastanza complicato perchè richiede resistenze di precisione e soprattutto un accurato calcolo dei loro valori  in maniera tale che ogni tasto produca in uscita una tensione caratteristica e ben distinta da quella degli altri tasti. Non mi occuperò di questo sistema in questo articolo (magari in un prossimo).

Un altro sistema per ridurre il numero di I/O necessari al collegamento dei tasterini a matrice è quello di utilizzare appositi circuiti integrati come il 74C922 e il 74C923 (datasheet in fondo all’articolo). Il 74C922 è un encoder per tastiere a 16 tasti: si collegano le 8 uscite della tastiera e l’integrato riporta il tasto premuto su 4 uscite (ABCD), il debounce è eseguito dall’integrato stesso. Il 74C923 è per tastiere a 20 tasti e quindi riporta il tasto su 5 pin (ABCDE). Tali integrati sono comunque molto costosi e a mio avviso non ne vale la pena.

Mi occuperò invece del sistema classico che prevede una linea di I/O per ogni riga e per ogni colonna. Utilizzando un tastierino da 4×4 avremo quindi bisogno di 8 linee di I/O e quindi di un banco di porte completo.

Il concetto che sta alla base del funzionamento è molto semplice. Basta seguire questo schema mentale:

  • Le 4 righe sono collegate a 4 pin predisposti come ingressi, questi ingressi hanno una resistenza di pullup (esterna o integrata) che permette loro di trovarsi a livello logico alto in condizioni di riposo.
  • Le 4 colonne sono collegate a 4 pin predisposti come uscite.
  • Partiamo da una situazione in cui le 4 uscite si trovano a livello logico 1.
  • Poniamo quindi, una alla volta, le colonne a livello logico basso.
    Le 4 colonne seguiranno in pratica questa sequenza di stati logici:
    0111 > 1011 > 1101 > 1110 per poi ricominciare daccapo.
  • Subito dopo aver posto una colonna a zero, scansioneremo una alla volta le 4 righe per controllare se una di loro si trova a livello logico basso indicando che un pulsante è stato premuto.
  • Confrontando quale colonna e quale riga si trovano a livello logico basso, è possibile risalire al pulsante premuto.

Ovviamente si sarebbe potuto fare anche il contrario: righe come uscita e colonne come ingressi, non sarebbe cambiato nulla. Basta partire da una base di ragionamento.

In questo esempio vi illustrerò il mio personale sistema software per controllare i pulsanti su una tastiera a matrice e visualizzare il tasto premuto su un display lcd.

Questa è una buona base di partenza per potersi realizzare da soli svariati sistemi come ad esempio serrature elettroniche a combinazione o semplici menù su dispositivi elettronici.

Collegamento di un tasterino a matrice sulla scheda Freedom II

Come sempre utilizzerò la scheda di sviluppo Freedom II, per cui l’esempio sarà riferito all’utilizzo di tale scheda.

Per prima cosa dobbiamo procurarci un tastierino a matrice, su Ebay si trovano a prezzi irrisori, se ne avete uno da 3×4 anzichè da 4×4 va bene lo stesso: penso che chi è arrivato a leggere i miei articoli fino a questo sarà sicuramente in grado di adattarsi da solo il codice per eliminare una colonna di tasti.

Con un tester controllate per bene quali sono i pin delle righe e quali sono quelli delle colonne e il loro ordine, se sapete usare il tester e seguite lo schema di come sono collegati i pulsanti, illustrato più in alto, non vi dovrebbe essere difficile capirlo.

Comunque vi illustro qui la piedinatura tastierino che ho usato io, il vostro al 90% dovrebbe seguire la stessa disposizione o comunque variare di poco:

Collegherò il tastierino al banco PORTB, individuiamo quindi sulla FreedomII dove andare a fare i collegamenti:

Trovandomi sulla Freedom II le porte pari da un lato e quelle dispari dall’altro, personalmente ho fatto una scelta che forse potrebbe risultare “infelice” a livello di gestione del codice (ma non tanto: tutto infatti sta ad “organizzarsi mentalmente”),  ma sicuramente più semplice a livello di cablaggio: ho collegato le colonne alle porte pari e le righe alle porte dispari. Ovviamente ognuno è libero di fare come vuole, basta poi saper adattare il codice.

Se, come me, sulla FreedomII avete un connettore a pettine (cioè maschio),  e se, come me, adorate per i vostri progetti farvi tutto in casa con quello che avete a disposizione, per collegare il tastierino potete utilizzare il mio semplicissimo sistema, che vi illustro:

Da uno strip femmina, utilizzando un seghetto o un minitrapano (tipo dremel) con dischetto diamantato, ritagliatene due spezzoni da 4 pin e rifiniteli per benino con una limetta (può andare bene pure quella per le unghie se vostra moglie non si arrabbia):

Prendete poi una piattina da 8 fili saldatela ai due connettori così ottenuti, isolando i pin con degli spezzoni di termorestringente di opportuno diametro, fino ad ottenere una cosa del genere:

I due connettori li ho poi incollati insieme con una goccia di super-attak per ottenere un connettore 4×2.

Si sarebbe potuto utilizzare direttamente un connettore femmina 4×2 ma poi sarebbe stato molto più difficile eseguire le saldature. Tenete conto difatti che questo tipo di connettore è da stampato e non da cavo.

Infine l’altra estremità della piattina la collegate al vostro tastierino saldandola oppure tramite un altro connettore. Il risultato è sicuramente pulito e riutilizzabile facilmente:

Ci vorrà un secondo per innestarlo in maniera semplice sulla nostra FreedomII:

L’importante è che vi ricordiate perfettamente dove avete collegato le righe e dove le colonne, per questo motivo l’utilizzo di una piattina colorata è sicuramente d’aiuto. Come già detto, io seguirò questo schema di collegamento:

  • Colonna 1 > RB0
  • Colonna 2 > RB2
  • Colonna 3 > RB4
  • Colonna 4 > RB6
  • Riga 1 > RB1
  • Riga 2 > RB3
  • Riga 3 > RB5
  • Riga 4 > RB7

Per cui il mio codice sarà ottimizzato e fatto apposta per tali connessioni.

Il software di gestione del tastierino numerico

Partiamo dal presupposto che sapete utilizzare l’LCD e avete letto le precedenti lezioni che illustrano come utilizzare la libreria che ho fornito qui.

Innanzitutto, dovendo utilizzare l’LCD per la visualizzazione, mi definirò alcune variabili che mi permetteranno di andare a capo in automatico quando avrò raggiunto la fine della riga e di ritornare alla prima cella della prima riga una volta giunto alla fine del display.

Tali variabili e defines rappresentano in pratica il numero di righe e di colonne del display a nostra disposizione, andranno quindi variati se avete un display diverso, così come dovranno essere variati anche nel file lcd.c come già spiegato nella lezione sull’LCD.

Nel nostro file settings.h avremo quindi:

unsigned char lcdXpos=0; // posizione colonna attuale
unsigned char lcdYpos=0; // posizione riga attuale
#define MAX_X 16 // numero di colonne del display
#define MAX_Y 2 // numero di righe del display

Mi definisco quindi un array, da scansionare con un ciclo FOR, che mi permetterà di mettere a massa le colonne una alla volta e riportare a livello logico alto le altre:

unsigned char colMask[]=
	{
	0b11111110, // Colonna 1 => RB0 a massa
	0b11111011, // Colonna 2 => RB2 a massa
	0b11101111, // Colonna 3 => RB4 a massa
	0b10111111 // Colonna 4 => RB6 a massa
	};

andando quindi dal valore colMask[0] al valore colMask[3], porterò a massa le colonne una alla volta. L’indice dell’array (ovvero il numeretto da mettere tra parentesi quadre per identificare quale elemento dell’array sto utilizzando attualmente) lo memorizzo in un’altra variabile:

unsigned char colScan=0; // va da 0 a 3 per scansionare l'array colMask

Se non sapete cos’è un array e come lo si utilizza, cercate informazioni su un testo qualsiasi che parla del linguaggio C, come il Tricky C presente anche nell’area risorse.

Allo stesso modo mi creo un altro array che mi servirà per effettuare la scansione delle righe e controllare quindi quale riga è andata a massa, e di conseguenza una variabile per contenere l’indice della riga scansionata:

unsigned char rowMask[]=
	{
	0b00000010, // Riga 1
	0b00001000, // Riga 2
	0b00100000, // Riga 3
	0b10000000 // Riga 4
	};
unsigned char rowScan=0;

Tutte queste operazioni di verifica e confronto andranno fatte utilizzando gli operatori logici come già spiegato in un precedente articolo, ecco perchè scrissi un articolo a parte solo per spiegare questi concetti: se vogliamo che i nostri programmi siano davvero efficienti e occupino il minimo indispensabile di risorse, dobbiamo imparare ad utilizzarli.

Mi creo, inoltre, ancora un altro array che contiene i simboli disegnati sui pulsanti del tastierino, disposti in un certo ordine:

unsigned char keys[]={'1','4','7','*','2','5','8','0','3','6','9','#','A','B','C','D'};

Da notare che, come già detto altre volte, i simboli definiti sono racchiusi tra singoli apici (‘). In questo modo il picmicro in realtà non leggerà “il numero 1” ma il suo corrispondente valore ascii, ovvero 49. Per cui l’array si sarebbe potuto pure scrivere come:

unsigned char keys[]={49,52,55,42 ...

Come vedete il simbolo 1 si trova in posizione zero, il simbolo 4 in posizione 1 ecc: ad ogni elemento del tastierino ho in pratica associato in qualche modo un peso numerico che segue l’ordine di scansione dei pulsanti schematizzato qui:

Dal momento che la tastiera ha 16 tasti potete ben capire perchè gli anglosassoni chiamano questi dispositivi Hex Keypad.

Questo mi renderà le cose estremamente semplici in seguito, in quanto facendo una semplice operazione confrontando riga e colonna, mi tirerò fuori un numero che mi permetterà appunto di risalire al pulsante premuto.

Infine ho ancora altre due variabili: una che mi conterrà appunto il numero risultato dell’operazione appena descritta e un flag che mi segnalerà l’avvenuta pressione di un pulsante qualsiasi e attiverà quindi la routine che  si occuperà di scrivere sull’LCD il simbolo disegnato sul tasto:

unsigned char keypressed=0; // peso numerico del pulsante premuto
bit keyok; // flag di pulsante premuto

Per il resto, le porte andranno settate opportunamente per avere le colonne come uscita e le righe con ingresso e predisponendo tutti i pin a livello logico alto e (importante!) attivando le resistenze di pullup su portB ponendo a zero l’apposito bit:

PORTB=0xFF;
TRISB=0b10101010;
RBPU=0; // resistenze di pullup su portb attivate

Le resistenze di PullUp su porta B ovviamente saranno attive soltanto sui pin definiti come ingressi.

Nel main, oltre all’inizializzazione dell’LCD, ecco che finalmente arriva il codice.

Mi effettuo la scansione delle colonne contando da zero a 3 e ponendo i relativi pin a livello logico basso uno alla volta e ripristinando a 1 gli altri facendo uso dell’array colMask che ho descritto prima:

for (colScan=0; colScan<4; colScan++) // porto a massa una colonna alla volta
	{
	PORTB &= colMask[colScan]; // porto a zero la colonna attuale

Per ogni colonna posta a zero mi effettuo quindi un ciclo di scansione delle 4 righe più o meno allo stesso modo:

// mi controllo le righe
for (rowScan=0; rowScan<4; rowScan++)
	{

Controllo quindi se la riga attuale si trova a massa effettuando un AND con l’elemento dell’array rowScan che mi permetterà di verificare soltanto il bit che mi interessa su tutta la porta:

if (!(PORTB & rowMask[rowScan])) // Riga rowScan trovata a massa

Questa verifica andrà fatta come sempre due volte con un piccolo ritardo per evitare il rimbalzo (anti-rimbalzo).

Se viene confermato che un pulsante è stato premuto, imposto il valore che permette di risalire al tasto e indico al programma che un pulsante è stato premuto:

keypressed=rowScan+(4*colScan); // numero di pulsante premuto
keyok=1; // è stato premuto un pulsante

Come vedete l’operazione è semplice: moltiplico per 4 l’indice di colonna attualmente messa a livello bass0 e  sommo l’indice di riga che è stato trovato a massa, in questo modo ottengo un numero da 0 a 15 diverso per ogni pulsante premuto.

Alla fine della scansione, se un pulsante è stato premuto (verificando che keyok=1) attivo un’altra routine che mi permette appunto di stampare sull’LCD il valore impresso sul tasto facendo uso dell’array “keys” definito prima e del valore numerico calcolato:

LCD_PUTCH(keys[keypressed]);

Utilizzo la funzione LCD_PUTCH che mi permette di stampare un singolo carattere. In più alla pressione di un tasto si sentirà un piccolo suono dal cicalino.

In aggiunta, dal momento che mi piace fare le cose per benino, ho fatto in modo da non permettere la stampa continua se si tiene premuto il pulsante.

Senza prevedere una cosa del genere, se si tenesse premuto il pulsante, il carattere relativo sarebbe stampato di continuo, e questo è davvero una seccatura se decidessimo di utilizzare questo programma per crearci una serratura elettronica a combinazione. Per tale motivo metto in pausa il programma fino a che il tasto non viene rilasciato:

// rimango in un ciclo continuo fino a che il pulsante non viene rilasciato
PORTB=0b10101010;
while(PORTB != 0b10101010)
      {continue;}

In pratica: dopo aver stampato il carattere, metto il banco B in uno stato in cui tutte le colonne sono a massa, se qualche pulsante risulta premuto, subito dopo la porta B non si troverà nello stato 10101010 per cui il while mi farà rimanere in un ciclo infinito che mi impedirà quindi di proseguire nel programma.

Rilasciato il pulsante, la condizione non sarà verificata per cui il ciclo non verrà eseguito e il programma potrà ripartire e continuare ad operare normalmente.

Downloads



Questo articolo ti è stato utile? Ti ha permesso di risolvere un problema o di migliorare le tue applicazioni? Ci lavori? Ti ha permesso di scrivere la tua tesina? Ti ha semplicemente fatto spendere un po' del tuo tempo in maniera costruttiva? Allora clicca il banner qui sotto:

Puoi andare alla fine dell'articolo e lasciare un commento. I trackback e i ping non sono attualmente consentiti.

  1. #1 da Francesco il 13 giugno 2010

    Mi vengono le lacrime ogni volta, e a dire che io stavo tempo fa cercando appunto un modo per crearmi una serratura elettronica da me, ma avevo trovato solo schemi che non utilizzavano pic, e a quel tempo imparai bene come utilizzare la tastierina, ora grazie a te e al tuo corso posso anche realizzarla tramite pic, sei un grande :D

  2. #2 da smart56 il 15 giugno 2010

    Ciao
    Innanzi tutto un OKKK al lavoro svolto.
    Volevo segnalare che il link (http://www.settorezero.com/wordpress/wp-content/plugins/download-monitor/download.php?id=113)
    non funziona
    Grazie anticipatamente
    Roberto P.

    • #3 da Giovanni Bernardo il 15 giugno 2010

      Ciao.
      Grazie di avermi avvisato. Ho sistemato… Eppure è strano, ci sono già stati oltre 40 download. Se fossero tutti come te, che avvisano quando c’è un problema, sarebbe tutto molto più semplice.

  3. #4 da stefano il 28 luglio 2010

    Ciao, premetto che sono un insegnante di elettronica in un istituto tecnico(ITI informatico) ed ho cercato di inserire nei programmi scolastici i microcontrollori iniziando in terza con il classico PIC16F84 e programmazione in assembler. Nelle classi successive introduco microcontrollori più avanzati con programmazione ad alto livello MIKROC.
    Vorrei chiederti un parere a riguardo, se conviene avventurarsi in questi argomenti a scuola, chiaramente per le ore a disposizione che abbiamo occorre sacrificare qualche altro argomento classico di elettronica. Se ti fa piacere inserisco questo link sul gruppo di Facebook. “corso sui componenti elettronici programmabili ITI VALITUTTI Roccadaspide(SA)”
    http://www.facebook.com/group.php?gid=161212338428
    Complimenti per il tuo lavoro…

    • #5 da Giovanni Bernardo il 28 luglio 2010

      Salve. Io sono contrario al MikroC perchè non segue lo standard ANSI e poi ci si trova male quando per caso si vuole passare al C18 e quindi al C30. Alla fine sono tutti compilatori che si trovano gratis per uso scolastico, quindi non vedo perchè non usare un prodotto standard. In molti adorano MikroC per il semplice motivo che ha già tante librerie belle e fatte. Ma usare cose già pronte sono del parere che non aiuta a imparare niente. Imparando bene come funzionano i registri e compagnia bella (e come si legge un datasheet), si può tranquillamente passare alle serie di pic a 16 bit (pic24, dsPic) perchè si avrà già familiarità con alcuni concetti, e vi assicuro che i pic a 16bit sono in grado di fare delle cose stupefacenti. Se si vuole parlare solo di programmazione, senza rifarsi all’hardware, allora tanto vale usare Arduino, che costa pochissimo, ha tutte le librerie già pronte, è supportato da una community molto vasta, ed è tutto opensource, si trovano esempi di programmazione per qualsiasi cosa venga in mente… Però ovviamente il livello di astrazione è altissimo e non si ha la consapevolezza di cosa si sta facendo. Per quanto riguarda la questione dell’insegnamento.. non glielo saprei dire perchè non sono un professore, nè tantomeno ho studiato elettronica a scuola. Però dal momento che in molti ragazzi dell’università mi scrivono e chiedono consigli, penso sia una cosa buona. Sono convinto che sacrificare qualche lezione a favore dell’utilizzo dei microcontrollori sia a tutto vantaggio degli studenti dal momento che oggi si usano i microcontrollori pure al posto di un NE555.. il futuro dell’elettronica è questo e penso che qui siano tutti d’accordo. Per il link: si mi fa piacere, mettetelo pure.

  4. #6 da Andrea il 6 agosto 2010

    Sapresti dove poter scaricare il software per pickit3? perche io davvero non riesco a trovarlo…

    • #8 da bleish il 7 agosto 2010

      Ho da poco installato la nuova versione di MPLAB 8.53 utilizzandola assieme al pickit3.
      Una volta compilato il programma e settato il programmatore attraverso la voce di menù Programmer>Select Programmer>…, nella stessa voce di menù compaiono le voci per le operazioni di scrittura e lettura sul pic utilizzando gli hex appena generati.
      Non è necessario l’uso di programmi esterni per le operazioni di programmazione.
      Addirittura è possibile gestire il reset e l’alimentazione del circuito con il pic.

      • #9 da Giovanni Bernardo il 7 agosto 2010

        Beh questo lo si sapeva… E’ l’IDE per il pickit3 che manca (c’è solo la beta) rispetto al pickit2… e anche i programmi per l’analizzatore logico e seriale. Il fatto che manchi l’ide lo rende utilizzabile solo con MPLAB mentre in molti utilizzano altri ambienti di programmazione diversi da MPLAB per cui sono loro che risentono della mancanza dell’ide

  5. #10 da zampimarco il 27 dicembre 2011

    Grandeeeeeeeeeeee, sono giorni che cerco info del genere e spiegate cosi` bene.
    Sono novizio di questo mondo, ma desideroso di imparare (anche se ho 37 anni la cosa mi stimola).
    Sto iniziando un progetto che utilizzera` proprio questo tipo di tastierino a 16 tasti (4×4) da interfacciare con arduino UNO per far apparire su un display a led (non come quello su questo tuo progetto, ma un pannello piu` grande di 1 riga x 10 cartteri), devo far apparire sul displey solo 4 o 5 caratteri (dipende dal caso), lo dovro` utilizzare durante le gare di tuffi in piscina, il tuffo viene codificato con numeri e lettere (ma solo A, B, C, D) e questa tastierina sembra perfetta, il display e` molto + grande (10 caratteri) xche` ho avuto la fortuna di acquistarlo usato a 10 euro ed e` comandato da diversi chip CD4094BC a 8-Bit. Stavo cercando qualcuno che puo` darmi una mano x i collegamenti e la programmazione (i materiali che ho elencato li ho gia` acquistati)

  6. #11 da peppers il 27 agosto 2012

    “In pratica se premiamo il pulsante “1″ metteremo in comunicazione la riga 1 con la colonna 2, premendo la “C” metteremo in comunicazione la riga 3 con la colonna 4 e così via.”

    Ciao Gianni,
    secondo me c’è un piccolo errore di battitura… mi sebra che sia corretto dire :
    “pratica se premiamo il pulsante “1″ metteremo in comunicazione la riga 1 con la colonna 1″…
    Comunque ottimo articolo…
    Pier

  7. #12 da Chighemezu il 8 aprile 2018

    Salve, mi chiamo Alessandro e trovo il sito molto interessante, tra l’altro anche in mezzo al panorama oltreoceano. Mi sono avvicinato alla programmazione dei Pic da poco e alcune cose anche se spiegate bene mi risultano ancora oscure. Magari è anche una banalità ma nel flusso del codice non riesco a inquadrare il “flag di pulsante premuto”, cioè l’istruzione “bit keyok;”. Se è un altra variabile “unsigned char” che per dimenticanza non è stata dichiarata, come mai nel programma la utilizzi come “(keybit) anziché “(bit keyok)”? Oppure è qualche tipo di variabile che non conosco? Un commento sarebbe veramente gradito, grazie e buon lavoro a te e a tutti gli appassionati in questo meraviglioso settore.

    • #13 da Giovanni Bernardo il 8 aprile 2018

      Ciao Alessandro e grazie dei complimenti :)
      Bit Keyok => BIT è un tipo di dato, alcuni compilatori lo trattano come un semplice CHAR, keyok è il nome della variabile… Ho usato il tipo bit per risparmiare 7 bit casomai servano :D anche se in realtà non era necessario, ma spesso lo utilizzo proprio per una questione di chiarezza, nel senso che è per ricordare che stiamo operando con un valore booleano che può quindi essere vero o falso, 1 o 0. Su Arduino per esempio quel tipo si chiama BOOL.
      L’XC8 ha il tipo BIT, XC16 e XC32 non lo supportano. Spero di aver chiarito i tuoi dubbi.

    • #14 da Giovanni Bernardo il 8 aprile 2018

      Aggiungo che anche XC8 ha il tipo Bool, che è in pratica la stessa cosa di BIT. Ma Bool non è un tipo standard e viene definito includendo l’header , che definisce anche i valori true e false.
      Per ulteriori approfondimenti leggi questo articolo, che è aggiornato ai nuovi compilatori XC:

      http://www.settorezero.com/wordpress/corso-di-programmazione-picmicro-in-c-transizione-da-mplab-ide-8-a-mplab-x-ide-e-da-hi-tech-picc-a-xc8/

      • #15 da Chighemezu il 9 aprile 2018

        Grazie mille, scrivendo BIT (in maiuscolo quindi), XC8 me lo riconosce. Bello anche il link che mi hai inserito. Ho diverse lacune sull’utilizzo dei files header e Source. L’articolo è chiaro, ci devo dedicare un pò di tempo ma confido di riuscire a inquadrare la logica nella loro gestione. Grazie ancora.
        AO

      • #16 da Giovanni Bernardo il 9 aprile 2018

        Se includi stdbool, puoi definirlo come bool e usare true e false al posto di 1 e 0, forse così il significato è più immediato ed è anche una soluzione più portabile dato che il tipo BIT non è standard e non tutti i compilatori lo utilizzano. All’epoca mi sembrava una soluzione elegante ma sono cambiate tante cose.

Devi essere collegato per lasciare un commento.

  1. Ancora nessun trackback
Settorezero.com e il logo Zroid™ ©2007÷2018 Giovanni Bernardo - E' vietata la copia e la distribuzione anche parziale dei contenuti di questo sito web senza l'esplicito consenso dell'autore. I contenuti di settorezero.com sono distribuiti sotto una licenza Creative Commons Attribuzione-Non Commerciale-Non Opere derivate 2.5 Italia e sono soggetti alle condizioni definite nel disclaimer. Settorezero.com e tutti i suoi contenuti sono tutelati dalla legge sul diritto d'autore per cui i trasgressori sono perseguibili a norma di legge. Settorezero fa uso dei cookie leggi l'informativa estesa. Il tema di questo sito è basato sul tema Fusion per wordpress, realizzato originariamente da digitalnature e fa uso del plugin Wassup per il computo delle statistiche. Per contattare l'autore siete pregati di utilizzare la sezione contatti. Siamo presenti anche su Facebook e, meno assiduamente, anche su Twitter - Tumblr - Google+ - Blogspot - Youtube.
Creative Commons BY-NC-ND 2.5