approfondimento libreria LCD_44780

Buongiorno a tutti, dopo aver studiato il meraviglioso corso XC18, aver acquistato la freedom 2, ho iniziato ad analizzare
le librerie. Premetto che sono a digiuno di C, conosco molto bene l'assembler Z8 ma questa è tutta un altra cosa.

Comunque, al di la dei tantissimi dubbi che ho e dei quali chiederò il vostro aiuto, la questione è la seguente: nella libreria LCD_44780.c trovo

//************************************************************
// cursor_LCD Implementation
//************************************************************
void LCD_cursor (unsigned char active, unsigned char blinking) {

send_command_LCD (0,0,0,0);
send_command_LCD (1,1,active,blinking);
}


//************************************************************
// back_light_LCD Implementation
//************************************************************
void LCD_backlight (unsigned char active) {

LCD_LED = active;
}

la variabile "active" la trovo in entrambe le implementazioni, perchè?
Non si tratta di una ripetizione? non occorre definire due variabili con nomi diversi?

Inoltre, per esempio, riguardo il comando LCD_backlight, nel programma principale, per accendere il led scrivo:

LCD_backlight (TURN_ON_LED_LCD);

Ora, TURN_ON_LED_LCD è una costante, definita in LCD_44780.h e vale 1, quindi se ho capito bene il compilatore, porrà LCD_LED (associato a RC1 in LCD_44780.h (#define LCD_LED PORTCbits.RC1) a 1, ossia a 1 l'uscita RC1. Ma che centra la variabile "active"?


Aggiungo altro atroce dubbio, sempre sulla libreria in questione ma anche in generale per altre:

nella libreria LCD_44780.c trovo

//************************************************************
// cursor_LCD Implementation
//************************************************************
void LCD_cursor (unsigned char active, unsigned char blinking) {

send_command_LCD (0,0,0,0);
send_command_LCD (1,1,active,blinking);
}

le variabili sono "active" e "blinking". Nel file LCD_44780.h, riferito a questa funzione, trovo:

#define BLINKING_ON 1
#define BLINKING_OFF 0
#define LCD_BLINKING_ON 1
#define LCD_BLINKING_OFF 0
che dovrebbe essere la definizioni delle suddette costanti

e poi, più in basso, trovo:

void LCD_cursor(unsigned char active, unsigned char blinking);
#define CursorLCD LCD_cursor
#define cursor_LCD LCD_cursor

La domanda è: #define CursorLCD LCD_cursor e #define cursor_LCD LCD_cursor vengono associati alla variabile "active"?
In quale modo? Non capisco.

Anche per il comando blinking, come viene associata la variabile "blinking" a #define BLINKING_ON 1 e #define BLINKING_OFF 0 se scrivo per esempio nel file main

LCD_cursor (BLINKING_ON);

Scusate per queste domande basilari ma ho una valanga di dubbi!!!

Grazie. Massimiliano

buon giorno
Comincio con darti qualche risposta poi eventualmente proseguo alla prossima puntata
Ai definito active 1, ai semplicemente cambiato il nome di 1 perchè ti è più comodo logicamente pensare a active invece che 1,
anche se abituato al linguaggio macchina potrebbe sembrarti non necessario, quindi puoi usare active quante volte e dove vuoi invece di scrivere 1.

LCD_backlight (TURN_ON_LED_LCD); è lo stesso invece di dire porta a 1 il pin 1 di RC definisci quindi quale è la tua porta a cui e collegato il Led poi gli dici che deve andare a 1 quindi active (se ho capito bene perchè mi manca un pezzo)

send_command_LCD (0,0,0,0);
send_command_LCD (1,1,active,blinking); sei sicuro che non ci sia un qualche legame tra Blinking e LCD_BLINKING_ON è come dicessi
send_command_LCD (1,1,1,1);

#define CursorLCD LCD_cursor
#define cursor_LCD LCD_cursor
Se è così vuol semplicemente dire che se scrivi CursorLcd oppure cursor_LCD sono la stessa cosa ossia LCD_cursor

LCD_cursor (BLINKING_ON); Scusami non ti capisco vista così è una chiamata a una funzione che fa lampeggiare il cursore

Spero di esserti stato un po' d'aiuto, ma purtroppo non conosco ne la libreria ne il sistema di sviluppo, ma se provi a compilare un esempio e poi fai un debug passo passo andando a vedere porte e registri scopri quale è il giro del fumo poi puoi leggere a conferma ciò che cita il C. Se non varo errando il Mauro ha fatto più che un discreto lavoro.
Ciao
Paolo

Grazie Paolo della risposta, ma sono comunque molto confuso.

Spero che Mauro mi possa spiegare i miei dubbi di cui sopra, specialmente riguardo le definizioni nel file .h. Non riesco a capire le associazioni tra definizioni etc.

Anche riguardo "active" nel caso specifico della funzione LCD_cursor vedo che ci sono due variabili, active e blinking.
Active si riferisce al far apparire il cursore o meno, blinking se questo deve lampeggiare o meno.
Ma allora perchè al posto della variabile blinking non è stato usato ancora una volta "active"?
Oppure, viceversa, al posto di active (che è quella che attiva o meno il cursore) nella funzione non si è usato una variabile tipo, per esempio, "cursor"?

void LCD_cursor (unsigned char cursor, unsigned char blinking) {

send_command_LCD (0,0,0,0);
send_command_LCD (1,1,cursor,blinking);
}

Sempre più confuso...

Ciao
send_command_LCD (1,1,cursor,blinking);
Con la funzione definisci in quella posizione devi scrivere come vuoi il cursore .
Se nella definizione della funizione, in terza posizione hai definito il cursore, e vuoi che questo sia 1 gli dici actve , è solo una questione di comodità, così ti ricordi che in terza posizione c'è il cursore, poi se la gratterà il compilatore ad associare cursor=active=1.
Nel corso della funzione:
send_command_LCD (1,1,cursor,blinking);
verrà poi presa in considerazione la variabile cursor che varrà active quindi 1.
Paolo

Penso di aver capito i tuoi dubbi.

la variabile "active" la trovo in entrambe le implementazioni, perchè?
Non si tratta di una ripetizione? non occorre definire due variabili con nomi diversi?

Le due variabili sono parametri di funzioni per cui sono locali alle funzioni stesse. Quando la funzione termina le risorse sono rilasciate.
Diversamente dall'assembly, in cui hai nomi univoci nel progetto, in C come anche altri linguaggi ad alto livello, hai dei livelli di astrazione diversi e a seconda di dove viene dichiarata una variabile puoi o meno creare un conflitto con altre, anche se hai lo stesso nome. Nel testo XC8 step by step trovi i dettagli nel paragrafo relativo alla visibilità delle variabili o scope.

Relativamente al punto:

void LCD_cursor(unsigned char active, unsigned char blinking);
#define CursorLCD LCD_cursor
#define cursor_LCD LCD_cursor

La domanda è: #define CursorLCD LCD_cursor e #define cursor_LCD LCD_cursor vengono associati alla variabile "active"?
In quale modo? Non capisco.

il nome della funzione e' LCD_cursor, mentre i define sotto rappresentano la storia del nome delle funzioni.
Inizialmente avevo usato il nome CursorLCD, poi cursor_LCD mentre ora ho standardizzato tutte le librerie precedendo il nome della funzione con il nome della libreria, ovvero nel caso LCD LCD_cursor. Questo semplifica l'autocompleting scrivendo LCD e premendo CTRL+SPACE (ottenendo tutta la lista delle funzioni che iniziano con LCD). In questo modo e' piu' facile usare una libreria.


I define servono solo per permettere di usare la nuova libreria con i nuovi nomi di funzione, anche con gli esempi di programmi vecchi che usano i vecchi nomi.

Relativamente al punto:

LCD_cursor (BLINKING_ON);

Alla funzione LCD_cursor devi passare un parametro per dire se vuoi o meno il cursore. Facendo uso delle costanti scrivi semplicemente un nome mnemonico che semplifica il tutto.
Passare il valore della variabile potrebbe equivalere in assembly all'impostare delle variabili prima della chiamata ad una subroutine per mezzo di CALL. La subroutine utilizza poi il contenuto delle variabili come parametri in ingresso.

Saluti,

Mauro