Multiplexage 7 Segment affiche avec Arduino et enregistre la MAJ (3 / 5 étapes)

Étape 3: Le temps de Code !

Pour commencer, voici un simple croquis qui affiche 456 avec décimale d’une manière temporisé pour démontrer le multiplexage. Je l’ai fait aussi flexible pour s’adapter à diverses configurations, que vous pourriez avoir. La source est également disponible en bas pour télécharger. Assurez-vous de comprendre le code tout d’abord, puis copier et coller dans une nouvelle esquisse. Ensuite, faites les ajustements nécessaires aux variables et affectation des broches car ils peuvent être différents dans votre situation. Une fois fait, télécharger sur l’Arduino.

Une chose à noter est la direction du flux de données. Si vous vous souvenez de mon schéma, la gauche plus Registre à décalage va recevoir le premier octet, mais va vider ces données hors du SER OUT si un autre octet est reçu. Donc, si vous voulez envoyer 11111111 au chiffre plus à droite, vous devez passer à 11111111 puis 00000000 et enfin 00000000. Ne vous inquiétez pas, ceci est géré automatiquement par le code.

BEGIN CODE

/*
Code pour l’interfaçage avec affichage à 7 segments
à l’aide de la méthode de multiplexage
et le registre à décalage TPIC6B595 (1 par chiffre)
Par K.O.
*/

Affectation des broches (vous devriez changer ces)
const int CLK = 9 ;           Connecté à la broche 13 de TPIC : SRCLK (aka horloge)
const int loquet = 10 ;          Connecté à la broche 12 de TPIC : RCLK (aka loquet/charge/CS/SS...)
const int OE = 11 ;          Connecté à la broche 9 de TPIC: OE (sortie active)
const int DOUT = 12 ;          Connecté à la broche 3 de TPIC : SER (aka MOSI)

Séries numériques (0-9)
Drains de 0-7 il faut relier respectivement aux segments A-DP ***
const byte [numTable] =
{
B11111100,
B01100000,
B11011010,
B11110010,
B01100110,
B10110110,
B10111110,
B11100000,
B11111110,
B11110110
};

Variables globales
int numDevices = 1 ;                       Le nombre de chiffres x afficher les modules vous envisagez d’utiliser
int maxDisplays = 3 ;                      Les affichages maximales qui pouvaient être satisfaits (voir note 1)
int maxDigits = 3 ;                        Le nombre maximal de chiffres par que vous prévoyez d’afficher affiche le module (chaque SR peut gérer un maximum de 8 chiffres)
int SRData [3] [3] ;                         L’emplacement de stockage pour les informations de chiffres. Nous devons spécifier un tableau fixe au moment de la compilation (voir note 2)
booléenne debug = true ;                     Changer à true pour afficher des messages
int delayTime = 1000 ;                     En option (juste pour avoir fait preuve de multiplexage)

/*
Notes
1. il est recommandé d’utiliser une alimentation externe pour éviter oversource/naufrage du microcontrôleur
ou si vous avez besoin à haute tension, un courant élevé s’affiche. Ce code va activer/désactiver tous les segments dans un chiffre pour *** chaque *** afficher.
Donc, si à l’aide de 2 x 3 chiffres affiche tous affichant un 8 + DP, la consommation max sera :
20mA (désiré courant) * 8 (les segments qui sont sur) * 2 (écrans à affichage d’informations identiques) = le 320mA
2. la première dimension doit être égal à maxDisplays. La deuxième dimension doit être égal au nombre de chiffres
*/

void setup()
{
Serial.Begin(9600) ;

Modes de mettre broche
pinMode(CLK,OUTPUT) ;
pinMode(LATCH,OUTPUT) ;
pinMode (DOUT, sortie) ;
pinMode (OE, sortie) ;

Afficheur 7 segments Init
digitalWrite(OE,LOW) ;        Permet un fonctionnement de SR
initializeSRData() ;          Prépare les SR et efface les données sur la ligne série

Test
setDigit(0,0,4,true) ;
setDigit(0,1,5,true) ;
setDigit(0,2,6,true) ;
}

void loop()
{
refreshDisplay() ;            Parcourt tous les affichages et les chiffres
}

=== Fonctions de SR BEGIN ===
Sub initializeSRData()
{
Afficher Scanner (boucle par le biais de chaque module d’affichage)
digitalWrite(LATCH,LOW) ;      Indique tous les SRs qu’uController envoie des données

pour (dispID int = 0; dispID < maxDisplays ; dispID ++)
{
Scanner de chiffre (boucle à travers chaque SR (chiffre) dans un module d’affichage)
pour (chiffre int = 0; chiffres < maxDigits ; chiffres ++)
{
Efface des ordures sur la ligne série
shiftOut(DOUT,CLK,LSBFIRST,0) ;          Passer à 0 s à tous les écrans
SRData [dispID] [chiffre] = 0 ;              Stocke un 0 pour chaque chiffre alors son complètement éteint
}
}
digitalWrite(LATCH,HIGH) ;      Indique tous les SRs qu’uController se fait envoie des données
}

Sub printSRData()
{
if(!Debug)
retour ;

Serial.println ("impression de SR Data...") ;

Scanner de l’affichage
pour (dispID int = 0; dispID < maxDisplays ; dispID ++)
{
Serial.Print ("# afficher") ;
Serial.println(DISPID) ;

Scanner à chiffres
pour (chiffre int = 0; chiffres < maxDigits ; chiffres ++)
{
Serial.Print ("Digit") ;
Serial.Print(digit) ;
Serial.Print(":") ;
Serial.println(SRData[DISPID][digit],bin) ;
}
Serial.println() ;
}
}

void setDigit (int dispID, int digit, valeur int, boolean dp)
{
Vérificateur de paramètre
Si (dispID < 0 || dispID > = numDevices)
{
Serial.println ("dispID OoB!") ;         OoB = hors des limites
retour ;
}

Si (chiffre < 0 || chiffres > maxDigits)
{
Serial.println ("chiffre OoB!") ;
retour ;
}

Si (valeur < 0 || valeur > 9)
{
Serial.println ("Invalid value!") ;
retour ;
}

valeur = numTable [valeur] ;

Activer/désactiver dp si nécessaire
if(DP)
valeur | = B00000001 ;          Se met en marche le premier chiffre binaire (segment) à l’aide d’un masque de bits OR

Stocker le chiffre
SRData [dispID] [chiffre] = value ;

if(Debug)
printSRData() ;
}

void setSegments (int dispID, int digit, valeur d’octet)
{
Vérificateur de paramètre
Si (dispID < 0 || dispID > = numDevices)
{
Serial.println ("dispID OoB!") ;
retour ;
}

Si (chiffre < 0 || chiffres > maxDigits)
{
Serial.println ("chiffre OoB!") ;
retour ;
}

Si (valeur < 0 || valeur > 255)
{
Serial.println ("Invalid byte!") ;
retour ;
}

Stocker le chiffre
SRData [dispID] [chiffre] = value ;

if(Debug)
printSRData() ;
}

Sub clearDisplay(int dispID)
{
initializeSRData() ;
refreshDisplay() ;
}

Sub refreshDisplay()
{
Scanner à chiffres
pour (chiffre int = 0; chiffres < maxDigits ; chiffres ++)
{
Scanner de l’affichage
digitalWrite(LATCH,LOW) ;
pour (int dispID = numDevices - 1; dispID > = 0; dispID--)
{
Chiffres avant blanker (déplacements sur 0 pour corriger les chiffres avant d’envoyer des données de segment au nombre souhaité)
pour (flans int = (maxDigits - 1 - digit); flans > 0; flans--)
shiftOut(DOUT,CLK,LSBFIRST,0) ;

shiftOut(DOUT,CLK,LSBFIRST,SRData[dispID][digit]) ;

Après chiffre blanker (déplacements sur 0 s à chiffres restants)
pour (int blancs = chiffre ; flans > 0; flans--)
shiftOut(DOUT,CLK,LSBFIRST,0) ;
}
digitalWrite(LATCH,HIGH) ;

Illustre le fonctionnement de multiplexage
Delay(delayTime) ;
delayTime-= 10 ;
Si (delayTime < = 0)
delayTime = 0 ;
}
}

=== FIN SR fonctions ===

FIN DU CODE