Yahoo refuse tous les emails du site. Si vous avez une adresse chez un autre prestataire, c'est le moment de l'utiliser
En cas de soucis, n'hésitez pas à aller faire un tour sur la page de contact en bas de page.
Topic "Fabriquer un afficheur analogique externe pour PC avec une carte Arduino / Genuino"
Flux RSS des posts récents dans ce topic ( Flux Atom)
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
#353 |
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 :
Une fois les composants bien rangés :
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
#355 |
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
#359 |
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.
Derniére modification le
#361 |
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 +
#363 |
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+
#986 |
par user
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.![]()
Tout bonnement à cause des machines d'insertion automatiques (des années 80) qui prenaient les CI à partir de barrettes et avec des mâchoires resserrant les pins au bon écartement. Ces mâchoires ne pouvaient que resserrer les pins, pas les écarter, alors les fabricants fournissent les CI aux pattes écartées.
Sur les documentation de certains constructeurs, la cote d'écartement est même spécifiée : voir à la page 26 ou 32 de cette doc.
http://www.ti.com/lit/ds/symlink/sn7400.pdf
Derniére modification le