Projet électronique : Libraire Open Source en C pour la Gestion de l’afficheur LCD RGB 12 bits de NOKIA 132×132 avec le PIC18F4680

Caractéristiques de l’afficheur LCD de NOKIA 6610 :

Les objectifs du projet :

Donner une brève aperçue sur le principe de fonctionnement de l’afficheur LCD de NOKIA
Comprendre le codage 12 bits et 8 bits et leurs effets sur la mémoire
Description du script matlab qui permet de convertir une image quelconque en une image 12 bits
Une astuce simple pour générer et intégrer une fonction mathématique non existante sur le compilateur MikroC (dans ce projet on va programmer les deux fonctions sin (x) et cos(x))
Obtenir le fichier du libraire MikroC pour la gestion de l’afficheur & le mo modèle de l’afficheur NOKIA6610 sur le logiciel ISIS.

Les spécifications importantes de l’afficheur :

132×132 pixels
12 bits couleur RGB (4 bits Rouge, 4 bits Bleu et 4 bits Vert) (4096 couleurs)
Alimentation 3.3V
Communication avec SPI 9 bits
Le contrôleur graphique compatible est avec Epson S1D15G00 ou Philips PCF8833

Orientation de l’afficheur LCD

Le point de référence du compteur des pixels se trouve en bas à gauche (0,0) et le point final en haut à droite (131,131). Les points en rouge montrent la référence du l’image en matlab, on constate un écart de 90° entre les deux. Pour mettre les deux images en phase il ne faut pas oublie d’effectuer une rotation de 90° de l’image (voir script matlab) !

Remarque : Vous pouvez tourner manuellement l’afficheur à 90° sans faire recours à la rotation logiciel de l’image générée 🙂

Format de données (12 bits)

La sélection du mode 12 bits/ pixel est réalise grâce à la commande 0x3A suivie par trois octets contient la valeur des couleurs (voir l’image ci-dessous) :

Remarque :

Au niveau stockage de l’image en mémoire, chaque pixel nécessite deux octets, un autre format de codage de l’image qui va nous permettre de gagner 50% de l’espace mémoire est le format 8 bits. Il consiste de coder la composante rouge à 3bits, vert à 3 bits et 2 bits pour la composante bleue (voir image ci-dessous).

L’espace occupée par une image 12 bits en mémoire = 132x123x2 =34ko

L’espace occupée par une image de 8 bits :132*132=34k/2 = 17ko

Le fait d’utiliser une image de 8 bits réduit l’espace mémoire mais dégrade aussi la qualité de l’image. Le rapport des nombres des couleurs entre l’image de 8 bits et celle de 12 bits est égal à 256/4096 = 2^8/2^12 = 1/2^4=1/16 ! Donc une perte de 15/16 !

Plus de détails sur l’afficheur (fichier PDF) : Afficheur NOKIA LCD

Comment convertir une image quelconque en une image 12 bits ?

Le script matlab permet de lire une image dans le dossier qui contient le script, de redimensionner l’image au format 132×132, calculer l’image 12 bits et stocker l’image dans un fichier texte sous forme d’un tableau 1D. Les données sont concaténées ligne par ligne dans le tableau.

Le script permet aussi de générer deux vecteurs de 361 valeurs (0-360° avec un pas de 1°) des signaux sin(x) et cons(x). Ces deux vecteurs sont enregistrés en bas du fichier texte.

Important :

Dans le fichier texte trois paramètres sont enregistrés : L’image, le vecteur sin(x) et cos(x). À la fin de chaque tableau vous n’oubliez pas d’enlever un virgule ‘,’ (voir l’image ci-dessous) avant de copier le code et l’intégrer dans le projet.

A quoi sert les deux fonctions sin(x) et cos(x) y a-t-il pas une libraire pour les fonctions mathématique sur MikroC ?

Les deux fonctions vont nous servir pour tracer un cercle dans l’afficheur LCD. Les coordonnées (X, Y) d’un cercle sont données sous la forme suivante en fonction du rayon R et l’angle phi :

X = R.cos(x)
Y= R.sin(phi)

Effectivement les deux fonctions sont disponibles dans le compilateur MikroC, l’intérêt et surtout de montrer une façon de programmer une fonction en un tableu indexé.

On prend l’exemple de la fonction cos(x), elle est présentée par le tableau cosx[361], pour trouver la valeur de cos(1°) il suffit d’accéder à la valeur du tableau cosx[1] ! L’inconvénient de la méthode est qu’elle demande beaucoup d’espace mémoire (361×4 octet) et qu’on ne peut pas adresser des indices non entiers (Ex : cosx[0.5]) en revanche on peut doubler la taille du tableau donc doubler la mémoire occuper affin de gagner en résolution (0.5° au lieu de 1°).

Ya des méthodes itératives pour le calcul des fonctions trigonométriques, ça peut être l’objet d’un autre projet.

Comment choisir le microcontrôleur PIC ?

La taille de la mémoire de donnée (>34 ko)
La disponibilité du modèle dans le logiciel ISIS
La disponibilité du micro dans le logiciel MikroC
La vitesse de l’horloge (vitesse d’affichage dans la limite physique des temps d’accès à la mémoire de l’afficheur)

Tableau comparatif des microcontrôleurs PIC18

Comment intégrer la libraire dans le projet ?

C’est très simple ! Il suffit de copier les fichier du dossier ‘Libraire LCD NOKIA’ puis de les ajoutés à votre projet.

Comment utiliser la libraire du NOKIA LCD ?

Le projet contient un programme de test des différentes fonctions pour la gestion de l’afficheur, vous pouvez en servir pour développer vos propres applications.

Les fonctions importantes de la libraire :

void GRAPHICS_DRAW_LINE(POINT START, POINT END, unsigned int COLOR)
void GRAPHICS_DRAW_CIRCLE(POINT CENTER, double RADIUS, unsigned int COLOR);
void GRAPHICS_DRAW_RECTANGLE(POINT P1, POINT P2, unsigned int COLOR);
void GRAPHICS_CLEAR(unsigned int COLOR);
void GRAPHICS_DRAW_PIXEL(POINT P, unsigned int COLOR);
void GRAPHICS_DRAW_IMAGE_2D(const char im[128][128]);
void GRAPHICS_DRAW_IMAGE_1D(const char im[X_Length*Y_Length], unsigned char row, unsigned char col);

Exemples d’appels des fonctions :

Programme de conversion de l’image en 12 bits :

clear all ;
close all;
clc;

% Dimensions de l'afficheur LCD
m1=132;
n1=132;

% Lecture de l'image dans le fichier en cours
im_in = imread('im1.jpg');

% Récupération des paramètres de l'image (longueur (m), largeur (n) et nombre des composantes (p))
[m n p ]= size(im_in);

% Redimensionner l'image d'origine
im_out=imresize(im_in,[m1 n1]);

% Récupération des trois composantes (Red,Green et Bleu)
if(p==3)
    % Pour une image couleur
    R=im_out(:,:,1);
    G=im_out(:,:,2);
    B=im_out(:,:,3);

else
    % Pour une image noir est blanc
    R=im_out;
    G=im_out;
    B=im_out;
end

% Conversion de l'image en image RGB 12 bits

% Résolution de chaque composante en bits (3x4=12)
N_bits = 4;
my_pixel_depth = 2 ^ N_bits;

% Convertir chaque composante du niveau de gris Ã  une image indexée avec 12 niveaux
R1 = gray2ind(R, my_pixel_depth);
G1 = gray2ind(G, my_pixel_depth);
B1 = gray2ind(B, my_pixel_depth);

% Reconstruction de l'image finale à partir des trois composantes
Im_12bits=double(B1) + double(G1)*2^4 +double(R1)*2^8 ;

%  Rotation de l'image à 90°
Im_12bits=imrotate(Im_12bits,90);


% Génération des signaux sin(x) et cos(x)
x = linspace(0,360,361);
cosx=cos(2*pi*x/360);
sinx=sin(2*pi*x/360);

% Codage du signal du double en long (optimiser la mémoire)
cosx_u=round(1e6*cosx);
sinx_u=round(1e6*sinx);

% Enregistrement de l'image & les signaux dans le fichier texte

fileID = fopen('im.txt','w');

fprintf(fileID,'const unsigned int ImageName[%d]={',m1*n1);
for i=1:m1
    im0=Im_12bits(:,i);
    fprintf(fileID,'%d, ',im0);
    fprintf(fileID,'\n');
end
fprintf(fileID,'};');

fprintf(fileID,'\n \n const unsigned long cosx[361]={');
fprintf(fileID,'%d, ',cosx_u);
fprintf(fileID,'};');

fprintf(fileID,'\n \n const unsigned long sinx[361]={');
fprintf(fileID,'%d, ',sinx_u);
fprintf(fileID,'};');

fclose(fileID);

Programme MikroC de test de l’afficheur NOKIA LCD :

#include "Graphics.h"
#include "Image.h"

#define    CONFIG3H_ADD  0x300005

// Couleur codées sur 12 bits
#define RED  0x0f00
#define GREEN 0x00f0
#define BLUE   0x000f
#define WHITE 0x0fff
#define BLACK 0x0000

// Affectation des pins du LCD au PORTD
sfr sbit DATA_PIN   at RD2_bit;
sfr sbit SCK_PIN    at RD3_bit;
sfr sbit CS_PIN     at RD4_bit;
sfr sbit RESET_PIN  at RD1_bit;


sfr sbit DATA_PIN_DIRECTION    at TRISD2_bit;
sfr sbit SCK_PIN_DIRECTION     at TRISD3_bit;
sfr sbit CS_PIN_DIRECTION      at TRISD4_bit;
sfr sbit RESET_PIN_DIRECTION   at TRISD1_bit;

// Pointeur du registre CONFIG3H pour configurer le pin MCLR comme étant RESET
unsigned char *CONFIG3H_REG;

// Variables POINT (structure à deux paramètres POINT.X et POINT.Y voir Graphics.h)
POINT p1={45,50};
POINT p2={66,66};
POINT p3={20,20};

POINT p4={32,32};
POINT p5={25,30};

unsigned char  i=0,j=0;

void main()
{
   // Initialisation de l'afficheur
   GRAPHICS_INIT(PHILLIPS_CONTROLLER);
   delay_ms(100);
   
   // Effacer l'afficheur avec la couleur noir
   GRAPHICS_CLEAR(BLACK);

   TRISD=0x00;
   CONFIG3H_REG = CONFIG3H_ADD;
   *CONFIG3H_REG = 0x80;     // bit7=1 CONFIG3H , MCLR enabled


   while(1)
   {

     //GRAPHICS_DRAW_IMAGE_1D(ImageName,X_Length,Y_Length);
     //delay_ms(2000);

     //GRAPHICS_DRAW_LINE(p1,p2,GREEN);
     
     for(i=0;i<60;i++) GRAPHICS_DRAW_CIRCLE(p2,5+i,(GREEN +i)&0x0fff);
     //for(i=0;i<60;i++) GRAPHICS_DRAW_CIRCLE(p2,5+i,(RED +i)&0x0fff);
     
     //GRAPHICS_DRAW_RECTANGLE(p1,p2,BLUE);
     //delay_ms(100);

     //GRAPHICS_CLEAR(BLUE);
     //delay_ms(2000);

     //GRAPHICS_DRAW_IMAGE(ImageName);
     //delay_ms(2000);

     GRAPHICS_DRAW_RECTANGLE( p1,  p2, GREEN);
     //GRAPHICS_DRAW_CIRCLE( p2,  30, RED);

     //GRAPHICS_DRAW_IMAGE_2D(ImageName,X_Length,Y_Length);
     //delay_ms(2000);

     //GRAPHICS_DRAW_IMAGE_1D(ImageName,X_Length,Y_Length);
     //delay_ms(2000);

     //GRAPHICS_CLEAR(GREEN);

   }
}