Topic "Fabriquer un afficheur analogique externe pour PC avec une carte Arduino / Genuino"

Flux RSS des posts récents dans ce topic ( Flux Atom)


Photo de profil de skywodd

skywodd

Membre

Membre du staff

#331 | Signaler ce message


Dans ce projet, nous allons fabriquer un afficheur analogique externe pour ordinateur avec une carte Arduino / Genuino et des afficheurs analogiques à aiguille.

Lire la suite de l'article sur le site

Derniére modification le par skywodd


Pas de photo de profil

user

Membre

#353 | Signaler ce message


Salut,

J'avais déjà fais un truc comme ça avec un PIC18 (avec juste un LCD 16 char et un port série virtuel). J’avais jamais pensé à adjoindre des cadrants à aiguille. Après multiples recherches, je vais partir sur Atmega 328P, car impossible de trouver un PIC avec autant de canaux PWM et si peu de broches.

Voilà ce que je vais faire :

schéma

Une fois les composants bien rangés :

3d

3d

Je vais faire un prototype et voir ce que ça donne. Les 4/5 BP c'est pour choisir quel graphe sera affiché sur l'afficheur graphique. Les 4/5 LED c'est pour indiquer qu'une ressource est à la limite (par exemple, un CPU à 95%). Il me reste à faire le code de tout ça.

Voilà les fichiers du projet (Kicad) pour ceux que ça intéressent.

A+

Edit : j'ai redimensionné l'image.

Edit : il semble qu'il y ait un problème avec la justification automatique.

Derniére modification le par skywodd


Photo de profil de skywodd

skywodd

Membre

Membre du staff

#355 | Signaler ce message


Edit : il semble qu'il y ait un problème avec la justification automatique.

par user

Oui il y a un probléme d'affichage, je m'arrache les cheveux sur ce bug depuis un moment. J'en ai tellement marre de ce bug que je suis en train de refaire la partie affichage de zéro.

Edit : J'ai modifié ton message pour enlever les balises pre et br.

Derniére modification le par skywodd


Pas de photo de profil

user

Membre

#359 | Signaler ce message


Re, Ok, bon courage et merci pour les balises. Je viens de recevoir les Atmega328P. J'ai utilisé une Uno pour claquer un bootloader dedans avec l'IDE 1.01 car avec le dernier IDE ça ne fonctionne pas. Au moment d'injecter le bootloader ("Graver la séquence 'amorçage") il y a une belle erreur. A terme, il est prévu que le programme soit injecté via la RS232. A+
PS : pourquoi les circuits neufs au format DIP ont-ils toujours les pins si écartées ? Je suis obligé de passer les circuits au marbre pour les insérer dans la breadbord. :D

Derniére modification le par user


Pas de photo de profil

user

Membre

#361 | Signaler ce message


Re,
Je viens de finir le code. J'ai aucune idée si ça peut fonctionner ou non. Si quelqu'un a une idée pour améliorer la choucroute, je suis preneur.
J'utilise deux bibliothèques : U8glib et StackArray.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
#include "U8glib.h" // Inclut la librairie U8G
#include "StackArray.h"
/**
 * Afficheur analogique externe pour ordinateur avec graphe et indicateur d'over limit
 */

/* Taille du buffer de réception série */
const byte BUFFER_SIZE = 64;

/* Broches PWM */
const byte ANALOG_0_PIN = 9;
const byte ANALOG_1_PIN = 8;
const byte ANALOG_2_PIN = 5;
const byte ANALOG_3_PIN = 3;
const byte ANALOG_CONTRAST_PIN = 6;

/* Bus série pour l'afficheur SPI*/
const byte GLCD_RS = 10;
const byte GLCD_RW = 11;
const byte GLCD_E = 13;

/* Sorties TOR */
const byte GLCD_RESET = 7; //reset du LCD graphique
const byte Q1 = 5;
const byte Q2 = 6;
const byte Q3 = 2;
const byte Q4 = 4;

/* Entrées TOR */
const byte I0 = 1;
const byte I1 = 2;
const byte I2 = 3;
const byte I3 = 4;
const byte I4 = 12;

//Afficheur graphique
U8GLIB_ST7920_128X64 AfficheurGraphique(GLCD_E, GLCD_RW, GLCD_RS, ANALOG_CONTRAST_PIN, GLCD_RESET); // Câblage SPI

/* Buffer de réception série  */
static char buffer[BUFFER_SIZE] = { 0 };
 
//Flags
boolean new_data_avaible;
boolean decrease;

//Prototypes
void display_msg(char msg[], U8GLIB_ST7920_128X64 *GLCD);
void Graph(StackArray <byte> *stack,char msg[], U8GLIB_ST7920_128X64 *GLCD);
void test_cadrans_leds(void);
void OverLimit_display (int *CPU, int *NET, int *RAM, int *DISK);

//Piles FIFO
StackArray <byte> CPU_stack;
StackArray <byte> NET_stack;
StackArray <byte> DISK_stack;
StackArray <byte> RAM_stack;

//Quelle info ?
byte num_info = 0;

//Le contraste
byte contrast = 128;

/* setup() */
void setup(void) {  
  noInterrupts(); //On est pas pret, merci de ne pas déranger
  AfficheurGraphique.setColorIndex(1); // Affichage en mode N&B
  AfficheurGraphique.firstPage(); // Sélectionne la 1er page mémoire de l'écran
  display_msg("Please wait, loading",&AfficheurGraphique);
  
  /* Initialise le port série */
  Serial.begin(115200);
  
  /*Interruptions */
  attachInterrupt(I0, interrupt_I0, RISING);
  attachInterrupt(I1, interrupt_I1, RISING);
  attachInterrupt(I2, interrupt_I2, RISING);
  attachInterrupt(I3, interrupt_I3, RISING);
  attachInterrupt(I4, interrupt_I4, RISING);

  /* Valeurs par défaut */
  analogWrite(ANALOG_0_PIN, 0);
  analogWrite(ANALOG_1_PIN, 0);
  analogWrite(ANALOG_2_PIN, 0);
  analogWrite(ANALOG_3_PIN, 0);
  analogWrite(ANALOG_CONTRAST_PIN, 0);
  
  digitalWrite(Q1,0);
  digitalWrite(Q2,0);
  digitalWrite(Q3,0);
  digitalWrite(Q4,0);
  
  //Init
  new_data_avaible = false;
  decrease = false;
}
 
/* loop() */
void loop(void) {
  //Test du matériel
  display_msg("Testing ...",&AfficheurGraphique);
  test_cadrans_leds();
  interrupts(); //Ready,on autorise à nouveau les interruptions
  display_msg("Awaiting computer",&AfficheurGraphique);
  Serial.setTimeout(2000); // Timeout de réception série
  Serial.print(6); //Envoi d'un AK
  /*
  do {
    //draw(); // Redessine tout l'écran
  } while(GLCD.nextPage()); // Sélectionne la page mémoire suivante */
  
  if (new_data_avaible) //Ah ! Quelque chose à traiter, allons y !
  {
    //Traitement
    
    /* Extrait les valeurs A, B, C et D */
    int a, b, c, d;
    
    if (sscanf(buffer,"%d %d %d %d", &a, &b, &c, &d) == 4) {

      /* On empile */      
      CPU_stack.push(a);     
      RAM_stack.push(b);     
      NET_stack.push(c);     
      DISK_stack.push(d);
      
      //On redessinne l'affichage selon la demande
      switch(num_info)
      {
        case 1:
          Graph(&RAM_stack,"RAM",&AfficheurGraphique);  
        break;
        
        case 2:
          Graph(&NET_stack,"NETWORK",&AfficheurGraphique);  
        break;
        
        case 3:
          Graph(&DISK_stack,"DISK",&AfficheurGraphique);        
        break;
        
        case 4: //Le contraste
        
          contrast =decrease? contrast - 50:contrast + 50;
          
          if(contrast >254)
          {
            decrease = true;
          }
          else if (contrast <= 50)
          {
            decrease = false;
          }
          AfficheurGraphique.setContrast(contrast);
        break;
        
        default: //Par défaut, on affiche le CPU
          
          Graph(&CPU_stack,"CPU",&AfficheurGraphique);        
        break;
      }
      
      //On gère les leds d'over limit
      OverLimit_display (&a, &c, &b, &d);
    }
    //Voilà qui est fait, on indique qu'on est pret à continuer
    Serial.print(6); //Envoi d'un AK
    new_data_avaible = false; // On abaisse le drapeau
  }
}

/* Fonction permettant d'afficher un message */
void display_msg(char msg[], U8GLIB_ST7920_128X64 *GLCD) {
  GLCD->setFont(u8g_font_unifont); // Utilise la police de caractère standard
  GLCD->drawStr( 3, 23, msg); // Message
  GLCD->drawLine(0,20,127,20);
  GLCD->drawLine(0,20,0,35);
  GLCD->drawLine(0,36,127,36);
  GLCD->drawLine(127,20,127,35);
  //et on encadre
}

/*Fonction qui affiche un graphe sur un écran avec une entete et le pourcentage de la dernière valeur */
void Graph(StackArray <byte> *stack,char msg[], U8GLIB_ST7920_128X64 *GLCD)
{
  //Affichage du graphe entre les lignes 14 et 64
  //Première ligne verticale et destruction du premier élément de la pile
  GLCD->drawLine(0,63,0,stack->pop()/5+14);
  
  //On dessine le reste des trais
  for(byte i =0; i < 127; i++)
  {
    GLCD->drawLine(i,63,i,stack->peek()/5+14);
  }
  
  //Pour la dernière valeur : on veut aussi un affichage numérique :
  byte tmp = stack->peek();
  GLCD->drawLine(127,63,127,tmp/5+14);
  tmp =(tmp/255)*100;
  //Conversion de ce *#*!@* de pourcentage en 5 caractères ASCII :
  char msg_val [] = {tmp/100 + 48,(tmp%100)/10 + 48,tmp%10 + 48,' ','%'};
  
  //Maintenant, un peu de dessin :
  GLCD->setFont(u8g_font_unifont); // Utilise la police de caractère standard
  GLCD->drawStr( 3, 5, msg); // Entete
  GLCD->drawStr( 96, 5, msg_val); // Valeur
  //Pour faire joli
  GLCD->drawLine(0,12,127,12);
  GLCD->drawLine(64,0,64,11);
}

//Gestion des indicateurs over limit
void OverLimit_display (int *CPU, int *NET, int *RAM, int *DISK)
{
   if(*CPU > 250) 
     digitalWrite(Q1, 1);
    else
     digitalWrite(Q1, 0);
     
     
   if(*NET > 250) 
     digitalWrite(Q2, 1);
    else
     digitalWrite(Q2, 0);
     
     
   if(*RAM > 250) 
     digitalWrite(Q3, 1);
    else
     digitalWrite(Q3, 0);
     
     
   if(*DISK > 250) 
     digitalWrite(Q4, 1);
    else
     digitalWrite(Q4, 0);    
}
static void test_cadrans_leds()
{
  //On fait bouger l'aiguille sur l'ensemble du cadrant pour les quartes ammeter (comme dans les dernières Peugeot 206)
  //On allume tous les voyants
  digitalWrite(Q1,1);
  digitalWrite(Q2,1);
  digitalWrite(Q3,1);
  digitalWrite(Q4,1);
  //dans un sens
  for(byte i = 0;i <= 255;i++)
  {
    analogWrite(ANALOG_0_PIN, i);
    analogWrite(ANALOG_1_PIN, i);
    analogWrite(ANALOG_2_PIN, i);
    analogWrite(ANALOG_3_PIN, i);
    delay(40);
  }
  delay(400);
  //puis dans l'autre
  for(byte i = 255;i >= 0;i--)
  {
    analogWrite(ANALOG_0_PIN, i);
    analogWrite(ANALOG_1_PIN, i);
    analogWrite(ANALOG_2_PIN, i);
    analogWrite(ANALOG_3_PIN, i);
    delay(20);
  }
  
  digitalWrite(Q1,0);
  digitalWrite(Q2,0);
  digitalWrite(Q3,0);
  digitalWrite(Q4,0);
}

//ROUTINES d'INTERRUPTIONS // IRC section

//Pour le port série
void serialEvent() {
  if(new_data_avaible) // Overrun
    Serial.print(21); //Envoi d'un NAK
  else //Tout est Ok, on lit
  {
    while (Serial.available()); //Attente de la fin de réception
    //On récupère les @BUFFER_SIZE derniers octets
    int read = Serial.readBytesUntil('\n', buffer, BUFFER_SIZE - 1);
    if (read) {    
        /* Cloture la chaine de caractéres */
        buffer[read] = '\0';     
    }
    new_data_avaible = true; // On lève le drapeau
  }
}


void interrupt_I0 ()
{
  num_info = 0;
}
void interrupt_I1 ()
{
  num_info = 1;
}
void interrupt_I2 ()
{
  num_info = 2;
}
void interrupt_I3 ()
{
  num_info = 3;
}
void interrupt_I4 ()
{
  num_info = 4;
}

A +


Pas de photo de profil

user

Membre

#363 | Signaler ce message


Re,
J'ai refait le code et découpé le projet en plusieurs fichiers.
Le .ino :

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
#include <Arduino.h>
#include "StackArray.h"
#include "U8glib.h"
#include "afficheur_graphique128_64.h"
#include "materiel.h"

/**
 * Afficheur analogique externe pour ordinateur avec graphe et indicateur d'over limit
 */

/* Taille du buffer de réception série */
const byte BUFFER_SIZE = 64;

//Afficheur graphique
U8GLIB_ST7920_128X64 AfficheurGraphique(GLCD_E, GLCD_RW, GLCD_RS, ANALOG_CONTRAST_PIN, GLCD_RESET); // Câblage SPI

/* Buffer de réception série  */
static char buffer[BUFFER_SIZE] = { 0 };
 
//Flags
boolean new_data_avaible;
boolean decrease;

//Piles FIFO
StackArray <byte> CPU_stack;
StackArray <byte> NET_stack;
StackArray <byte> DISK_stack;
StackArray <byte> RAM_stack;

//Quelle info ?
byte num_info = 0;

//Le contraste
byte contrast = 128;

/* setup() */
void setup(void) {  
  noInterrupts(); //On est pas pret, merci de ne pas déranger
  
  //Initialisation de l'affiheur graphique
  aff128_64_Init (&AfficheurGraphique);

  aff128_64_msg("Boot",&AfficheurGraphique);
  
  //Intialisation des entrées sorties
  Init_IO();
  
  /* Initialise le port série */
  Serial.begin(115200);
  
  /*Interruptions */
  attachInterrupt(I0, interrupt_I0, RISING);
  attachInterrupt(I1, interrupt_I1, RISING);
  attachInterrupt(I2, interrupt_I2, RISING);
  attachInterrupt(I3, interrupt_I3, RISING);
  attachInterrupt(I4, interrupt_I4, RISING);
  
  //Init
  new_data_avaible = false;
  decrease = false;
  
  /* Test du matériel */
  Test_Materiel();
  
  /*Ready,on autorise à nouveau les interruptions*/
  interrupts();
  aff128_64_msg("Ready. Awaiting input ...",&AfficheurGraphique);
  Serial.setTimeout(2000); // Timeout de réception série
  Serial.print(6); //Envoi d'un AK
}
 
/* loop() */
void loop(void) {
  //Dès qué les données sont disponibles :
  if (new_data_avaible) //Ah ! Quelque chose à traiter, allons y !
  {
    //Traitement
    
    /* Extrait les valeurs A, B, C et D */
    int a, b, c, d;
    
    if (sscanf(buffer,"%d %d %d %d", &a, &b, &c, &d) == 4) {

      /* On empile */      
      CPU_stack.push(a);     
      RAM_stack.push(b);     
      NET_stack.push(c);     
      DISK_stack.push(d);
      
      //On redessinne l'affichage selon la demande
      switch(num_info)
      {
        case 1:
          aff128_64_graph(&RAM_stack,"RAM",&AfficheurGraphique);  
        break;
        
        case 2:
          aff128_64_graph(&NET_stack,"NETWORK",&AfficheurGraphique);  
        break;
        
        case 3:
          aff128_64_graph(&DISK_stack,"DISK",&AfficheurGraphique);        
        break;
        
        case 4: //Le contraste
        
          contrast =decrease? contrast - 50:contrast + 50;
          
          if(contrast >254)
          {
            decrease = true;
          }
          else if (contrast <= 50)
          {
            decrease = false;
          }
          AfficheurGraphique.setContrast(contrast);
        break;
        
        default: //Par défaut, on affiche le CPU
          
          aff128_64_graph(&CPU_stack,"CPU",&AfficheurGraphique);        
        break;
      }
      
      //On gère les leds d'over limit
      OverLimit_display (&a, &c, &b, &d);
    }
    //Voilà qui est fait, on indique qu'on est pret à continuer
    Serial.print(6); //Envoi d'un AK
    new_data_avaible = false; // On abaisse le drapeau
  }
  
  delay(500);
}


//ROUTINES d'INTERRUPTIONS // IRC section

//Pour le port série
void serialEvent() {
  if(new_data_avaible) // Overrun
    Serial.print(21); //Envoi d'un NAK
  else //Tout est Ok, on lit
  {
    while (Serial.available()); //Attente de la fin de réception
    //On récupère les @BUFFER_SIZE derniers octets
    int read = Serial.readBytesUntil('\n', buffer, BUFFER_SIZE - 1);
    if (read) {    
        /* Cloture la chaine de caractéres */
        buffer[read] = '\0';     
    }
    new_data_avaible = true; // On lève le drapeau
  }
}


void interrupt_I0 ()
{
  num_info = 0;
}
void interrupt_I1 ()
{
  num_info = 1;
}
void interrupt_I2 ()
{
  num_info = 2;
}
void interrupt_I3 ()
{
  num_info = 3;
}
void interrupt_I4 ()
{
  num_info = 4;
}



afficheur_graphique128_64.h :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
#include "U8glib.h"
#include "StackArray.h"

//Includ guard
#ifndef afficheur_graphique128_64
#define afficheur_graphique128_64
  /*Transtypage (conversion d'un chiffre en un caractère ASCI*/
  const byte Dec_To_Char[] = {'0','1','2','3','4','5','6','7','8','9'};
  //Prototypes
  void aff128_64_Init (U8GLIB_ST7920_128X64 *GLCD);
  void aff128_64_msg(char msg[], U8GLIB_ST7920_128X64 *GLCD);
  void aff128_64_graph(StackArray <byte> *stack,char msg[], U8GLIB_ST7920_128X64 *GLCD);
#endif



Le .cpp qui va avec :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include "afficheur_graphique128_64.h"

/* Fonction d'initialisation de l'afficheur*/
void aff128_64_Init (U8GLIB_ST7920_128X64 *GLCD)
{
  GLCD->setFont(u8g_font_unifont); //La police par défaut
  GLCD->setColorIndex(1); // Affichage en mode N&B
}

/* Fonction permettant d'afficher un message */
void aff128_64_msg(char msg[], U8GLIB_ST7920_128X64 *GLCD) {
  GLCD->firstPage(); //Première page mémoire
  do { // Redessine tout l'écran
    GLCD->setFont(u8g_font_unifont); // Utilise la police de caractère standard
    GLCD->drawStr( 3, 23, msg); // Message
    GLCD->drawLine(0,20,127,20);
    GLCD->drawLine(0,20,0,35);
    GLCD->drawLine(0,36,127,36);
    GLCD->drawLine(127,20,127,35);
  //et on encadre   
  } while( GLCD->nextPage());// Sélectionne la page mémoire suivante */
}

/*Fonction qui affiche un graphe sur un écran avec une entete et le pourcentage de la dernière valeur */
void aff128_64_graph(StackArray <byte> *stack,char msg[], U8GLIB_ST7920_128X64 *GLCD)
{
  GLCD->firstPage(); //Première page mémoire
  do { // Redessine tout l'écran
    //Affichage du graphe entre les lignes 14 et 64
    //Première ligne verticale et destruction du premier élément de la pile
    GLCD->drawLine(0,63,0,stack->pop()/5+13);
    
    //On dessine le reste des trais
    for(byte i =0; i < 127; i++)
    {
      GLCD->drawLine(i,63,i,stack->peek()/5+13);
    }
    
    //Pour la dernière valeur : on veut aussi un affichage numérique :
    byte tmp = stack->peek();
    GLCD->drawLine(127,63,127,tmp/5+13);
    tmp =(tmp/255)*100;
    //Conversion de ce *#*!@* de pourcentage en 5 caractères ASCII :
    char msg_val [] = {Dec_To_Char[tmp/100],Dec_To_Char[(tmp%100)/10],Dec_To_Char[tmp%10],' ','%'};
    
    //Maintenant, un peu de dessin :
    GLCD->setFont(u8g_font_unifont); // Utilise la police de caractère standard
    GLCD->drawStr( 3, 5, msg); // Entete
    GLCD->drawStr( 96, 5, msg_val); // Valeur
    //Pour faire joli
    GLCD->drawLine(0,12,127,12);
    GLCD->drawLine(64,0,64,11);
    
  } while( GLCD->nextPage());// Sélectionne la page mémoire suivante */
}



materiel.h :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <Arduino.h>

//Includ guard
#ifndef materiel
  #define materiel
  /* Broches PWM */
  #define ANALOG_0_PIN 9
  #define ANALOG_1_PIN 8
  #define ANALOG_2_PIN 5
  #define ANALOG_3_PIN 3
  #define ANALOG_CONTRAST_PIN 6
  
  /* Bus série pour l'afficheur SPI*/
  #define GLCD_RS 10
  #define GLCD_RW 11
  #define GLCD_E 13
  
  /* Sorties TOR */
  #define GLCD_RESET 7 //reset du LCD graphique
  #define Q1 5
  #define Q2 6
  #define Q3 2
  #define Q4 4
  
  /* Entrées TOR */
  #define I0 1
  #define I1 2
  #define I2 3
  #define I3 4
  #define I4 12
  
  
  //Prototype
  void Init_IO(void);
  void OverLimit_display (int *CPU, int *NET, int *RAM, int *DISK);
  void Test_Materiel(void);
#endif


|br] … et le .cpp :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include "materiel.h"

void Init_IO(void)
{
   /* Valeurs par défaut */
  analogWrite(ANALOG_0_PIN, 0);
  analogWrite(ANALOG_1_PIN, 0);
  analogWrite(ANALOG_2_PIN, 0);
  analogWrite(ANALOG_3_PIN, 0);
  analogWrite(ANALOG_CONTRAST_PIN, 0);
  
  digitalWrite(Q1,0);
  digitalWrite(Q2,0);
  digitalWrite(Q3,0);
  digitalWrite(Q4,0);
}


//Gestion des indicateurs over limit
void OverLimit_display (int *CPU, int *NET, int *RAM, int *DISK)
{
   if(*CPU > 250) 
     digitalWrite(Q1, 1);
    else
     digitalWrite(Q1, 0);
     
     
   if(*NET > 250) 
     digitalWrite(Q2, 1);
    else
     digitalWrite(Q2, 0);
     
     
   if(*RAM > 250) 
     digitalWrite(Q3, 1);
    else
     digitalWrite(Q3, 0);
     
     
   if(*DISK > 250) 
     digitalWrite(Q4, 1);
    else
     digitalWrite(Q4, 0);    
}

//Test du matériel
void Test_Materiel()
{
  //On fait bouger l'aiguille sur l'ensemble du cadrant pour les quartes ammeter (comme dans les dernières Peugeot 206)
  //On allume tous les voyants
  digitalWrite(Q1,1);
  digitalWrite(Q2,1);
  digitalWrite(Q3,1);
  digitalWrite(Q4,1);
  //dans un sens
  for(byte i = 0;i <= 255;i++)
  {
    analogWrite(ANALOG_0_PIN, i);
    analogWrite(ANALOG_1_PIN, i);
    analogWrite(ANALOG_2_PIN, i);
    analogWrite(ANALOG_3_PIN, i);
    delay(40);
  }
  delay(400);
  //puis dans l'autre
  for(byte i = 255;i >= 0;i--)
  {
    analogWrite(ANALOG_0_PIN, i);
    analogWrite(ANALOG_1_PIN, i);
    analogWrite(ANALOG_2_PIN, i);
    analogWrite(ANALOG_3_PIN, i);
    delay(20);
  }
  
  digitalWrite(Q1,0);
  digitalWrite(Q2,0);
  digitalWrite(Q3,0);
  digitalWrite(Q4,0);
}



A+