Menu mobile
LECCIÓN 13: Cronómetro - Stopwatch
Introducción
En esta lección, utilizaremos una pantalla de cuatro dígitos de 7 segmentos para hacer un cronómetro.
Componentes
{Product:2000}{Product:739}{Product:256}{Product:1436}{Product:536}{Product:603}{Product:1220}
Principio del experimento
Antes de comenzar a trabajar con pantallas de 7 segmentos, necesitamos comprender algunos de los conceptos básicos de los LED y cómo controlarlos.
Para alimentar el LED, conecta el cátodo a tierra y el ánodo a la fuente de voltaje. El LED se puede encender o apagar cambiando la alimentación en el ánodo o el cátodo.
El Diodo LED y placa Arduino
Caso 1 – el ánodo a pin digital
El ánodo de LED conectado a un pin digital, el cátodo está conectado a tierra:
Para encender un LED con el ánodo conectado a un pin digital, configure el pin digital en ALTO:
void setup(){
pinMode(7, OUTPUT);
digitalWrite(7, HIGH);
}
void loop(){
Caso 2 - el cátodo a pin digital
El cátodo de LED conectado a un pin digital, el ánodo está conectado a Vcc.
Para encender el LED, el pin digital se cambia a BAJO, lo que completa el circuito a tierra:
digitalWrite(7, LOW);
Cuando se utiliza la pantalla de 7 segmentos de un solo dígito (generalmente tiene 10 pines – 2 pines comunes y 8 pines de los segmentos)
- en caso de display cátodo común
Los dos pines comunes se conectan a tierra, y los otros 8, cada uno de los segmentos a los pines digitales correspondientes, tal y como se indica en la imagen de abajo.
El display cátodo común es aquel que tiene el pin común conectado a los negativos de los LED (cátodo). Esto significa que este tipo de display se “controla” con ‘1’ lógico o con voltaje positivo.
Conexionado del display de un dígito de 7 segmentos, en cátodo común:
- en caso de display ánodo común
dos pines comunes se conectan a la fuente de alimentación y los otros 8 - cada uno de los segmentos a pines digitales.
El display ánodo común es aquel que tiene el pin común conectado a los positivos de los LED (ánodo).
Este tipo de display es controlado por ceros (0).
El display de un dígito de 7 segmentos, cátodo común:
El display de un dígito de 7 segmentos, ánodo común:
Aquí hay un diagrama de pin del popular 5161AS - cátodo común.
En pantallas de varios dígitos, como la que se muestra en la imagen inferior en la que tenemos 4 dígitos, un solo pin de segmento (A, B, C, D, E, F, G y DP) controla el mismo segmento en todos los dígitos. Cada dígito tiene su pin (D1, D2, D3, D4) con los que se puede activar o desactivar un dígito y así controlar cada segmento.
En nuestro ejemplo de código usamos esta pantalla:
Procedimiento
Paso 1: Conecte el circuito
El diagrama esquemático correspondiente es el siguiente:
Paso 2: Programa (consulta el código de ejemplo en el CD o sitio web oficial)
//
/*
* Seconds timer
* Use a timer 1 time of 0.1 seconds overflow,
* set the count count, plus one every 0.1 seconds, then set a variable n
* When the count to ten, namely 1 second, n + 1, namely n is n seconds
* Timing to zero to 10000 seconds
*/
#include <TimerOne.h>
int a = 2;
int b = 3;
int c = 4;
int d = 5;
int e = 6;
int f = 7;
int g = 8;
int p = 9;
int d4 = 10;
int d3 = 11;
int d2 = 12;
int d1 = 13;
//设置变量
long n = 0;
int x = 100;
int del = 5;
int count = 0;
void setup()
{
pinMode(d1, OUTPUT);
pinMode(d2, OUTPUT);
pinMode(d3, OUTPUT);
pinMode(d4, OUTPUT);
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);
pinMode(p, OUTPUT);
Timer1.initialize(100000); // set a timer of length 100000 microseconds (or 0.1 sec - or 10Hz => the led will blink 5 times, 5 cycles of on-and-off, per second)
Timer1.attachInterrupt( add ); // attach the service routine here
/***************************************/
void loop()
clearLEDs();
pickDigit(0);
pickNumber((n/1000));
delay(del);
pickDigit(1);
pickNumber((n%1000)/100);
pickDigit(2);
pickNumber(n%100/10);
pickDigit(3);
pickNumber(n%10);
/**************************************/
void pickDigit(int x)
digitalWrite(d1, HIGH);
digitalWrite(d2, HIGH);
digitalWrite(d3, HIGH);
digitalWrite(d4, HIGH);
switch(x)
case 0:
digitalWrite(d1, LOW);
break;
case 1:
digitalWrite(d2, LOW);
case 2:
digitalWrite(d3, LOW);
default:
digitalWrite(d4, LOW);
void pickNumber(int x)
zero();
one();
two();
case 3:
three();
case 4:
four();
case 5:
five();
case 6:
six();
case 7:
seven();
case 8:
eight();
case 9:
nine();
void clearLEDs()
digitalWrite(a, LOW);
digitalWrite(b, LOW);
digitalWrite(c, LOW);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
digitalWrite(p, LOW);
void zero()
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
void one()
void two()
digitalWrite(g, HIGH);
void three()
void four()
void five()
void six()
void seven()
void eight()
void nine()
/*******************************************/
void add()
// Toggle LED
count ++;
if(count == 10)
count = 0;
n ++;
if(n == 10000)
n = 0;
Paso 3: Compila el programa
Paso 4: Graba el programa en la placa Uno.
Ahora puedes ver el número más uno por segundo en la visualización del segmento.