7.1: Introducción

Última actualización
Guardar como PDF

Page ID: 83138

\( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \) \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)\(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\) \(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\)\(\newcommand{\AA}{\unicode[.8,0]{x212B}}\)

En este ejercicio examinaremos la salida digital básica utilizando tanto las bibliotecas de código Arduino como el “twiddling de bits” más directo. El objetivo de este esfuerzo será controlar un LED, incluyendo circuitos controladores apropiados.

Primero, usemos una versión modificada del programa Blink de ejemplo. Esto parpadea el LED de prueba a bordo conectado al pin 13 de Arduino a una velocidad de dos segundos encendido, un segundo apagado. Añadiremos salida de texto en serie para verificar la funcionalidad.

Escriba el siguiente código en el editor:

/*
      MyBlink
      Turns on an LED then off, repeatedly.
      With serial output
*/

// Pin 13 has an LED connected on most Arduino boards. Give it a name:
#define LEDPIN 13

void setup()
{
      // initialize the digital pin as an output.
      pinMode( LEDPIN, OUTPUT );   
      // initialize serial communication at 9600 bits per second:
      Serial.begin( 9600 );
}

void loop()
{
      Serial.println("On");
      digitalWrite( LEDPIN, HIGH ); // turn the LED on
      delay(2000);                  // wait for 2 secs

      Serial.println("Off");
      digitalWrite( LEDPIN, LOW );  // turn the LED off
      delay(1000);                  // wait for 1 sec
}

Compilar el código y transferirlo a la placa. Abra el Monitor Serial. Debería ver mensajes en el Monitor Serial reflejando el estado del LED de a bordo.

El código es más o menos autoexplicativo pero algunos detalles pueden estar en orden. Primero, el pin 13 en el encabezado digital del Arduino Uno se conecta a un pequeño LED de montaje en superficie. El pin está conectado a una resistencia limitadora de corriente que está conectada al ánodo del LED, cuyo cátodo vuelve a tierra. Así, un alto voltaje enciende el LED. La rutina de configuración establece este pin para la salida y establece el sistema de comunicación serie. La rutina de bucle utiliza DigitalWrite () para enviar alternativamente este pin alto o bajo, encendiendo y apagando así el LED. La función delay se utiliza para mantener los niveles por un momento para que puedan verse fácilmente a simple vista. La función de retardo funciona lo suficientemente bien aquí, pero es un simple bucle de espera de ocupación, lo que significa que el controlador no puede realizar ningún otro trabajo útil durante el tiempo de retardo. Se trata de una seria limitación para tareas de programación más intensivas pero por ahora es suficiente.

Vamos a pasar del LED interno a un LED externo. Si bien el AVR 328P puede entregar más de 20 miliamperios por pin, si elegimos conducir varios LEDs puede ser mejor usar controladores de transistores para ellos con el fin de reducir las demandas de corriente y potencia en el controlador. El estilo básico sigue:

Figura\(\PageIndex{1}\): Controlador NPN

Figura\(\PageIndex{2}\): Controlador PNP

El controlador NPN saturará y encenderá el LED con un voltaje base alto mientras que la versión PNP se satura con un voltaje base bajo. En ambos casos la corriente LED es la corriente de saturación que se puede aproximar como la tensión de alimentación menos la tensión del LED, dividida por la resistencia del colector. Por ejemplo, para lograr 10 miliamperios con un suministro de 5 voltios y un LED rojo (aproximadamente 2 voltios de polarización directa), la resistencia del colector necesitaría ser de unos 300 ohmios. La resistencia base sería aproximadamente veinte veces este valor dando como resultado una corriente base de aproximadamente 700 microamperios. Esto garantizaría saturación para cualquier transistor beta razonable. Los 2N3904 o 2N3906 son opciones comunes, pero si se va a accionar una gran cantidad de dispositivos, podría ser aconsejable considerar un IC de controlador como el ULN2003.

Modifiquemos el ejemplo anterior para usar un controlador NPN externo en el pin digital Arduino 8. Para referencia futura, esto corresponde al Puerto B, bit 0. Primero, conecte el controlador en una placa de prototipos usando valores de resistencia estándar (un 330 y un 6.8k deberían hacer). Salta la conexión Vcc al pin de cabecera +5V en el Uno y salta la conexión a tierra al pin de cabecera GND de Uno (ambos en el lado POWER de la placa). Conecte la conexión lógica de entrada (Vbb) al pin digital Arduino 8. Modifique el código de la siguiente manera:

/*    External LED Blink   */

#define LEDPIN 8

void setup()
{

      pinMode( LEDPIN, OUTPUT );   
}

void loop()
{
      digitalWrite( LEDPIN, HIGH );
      delay(2000);                  // wait for 2 secs

      digitalWrite( LEDPIN, LOW );
      delay(1000);                  // wait for 1 sec
}

Compilar el código, transferirlo y ejecutarlo. Deberías tener un bonito LED parpadeante. Tenga en cuenta el tiempo. Construya el controlador PNP y conéctelo al pin 8 en lugar de la versión NPN (no desmonte el controlador NPN, simplemente desengancharlo del controlador). No cambies el código. Debe notar una diferencia en el tiempo de encendido/apagado. Si no nota un cambio, vuelva a conectar el NPN y vuelva a buscar.

Ahora consideremos el acceso directo al hardware sin usar las bibliotecas Arduino. Hay dos formas de hacer esto; la primera es buscando las direcciones reales para los puertos y registros de hardware y asignándoles variables de puntero. El segundo método (algo más fácil) implica usar las variables predefinidas para los puertos y registros.

La siguiente es una variación del programa de parpadeo usando acceso directo al puerto a través de punteros. Tenga en cuenta que las variables para los registros de dirección de puerto y datos se declaran y luego se asignan direcciones numéricas duras. Estos variarían de procesador a procesador por lo que el código no es portátil. Eso no es deseable; sin embargo, el proceso sí ilustra con precisión lo que está sucediendo con el controlador y lo hace con una reducción en el código de ensamblaje resultante. Tenga en cuenta el uso de LEDMask. Cambiar el valor de esto permite acceder a diferentes bits de ese puerto. Además, tenga en cuenta el uso de los operadores OR, AND y COMPLEMENT (|&~) a nivel de bits para establecer los bits apropiados en los registros.

/* Direct Blink: Using direct bit fiddling via pointers */

// This is Port B bit 0, Arduino digital output number 8

#define LEDMASK 0x01

void setup()
{
      unsigned char *portDDRB; 

      portDDRB = (unsigned char *)0x24;

      // initialize the digital pin as an output.
      *portDDRB |= LEDMASK;
}
void loop()
{
      unsigned char *portB;

      portB = (unsigned char *)0x25;

      // turn LED on
      *portB |= LEDMASK;
      delay(2000); 

      // turn LED off
      *portB &= (~LEDMASK);
      delay(1000); 
}

Escriba el código anterior y conecte el controlador NPN al pin 8. Compilar y transferir el código, y probarlo. Debería funcionar como antes.

Una mejor versión de Direct Blink utiliza variables predefinidas como PORTB. Estos se pueden definir dentro de un archivo de encabezado y, como tal, se pueden ajustar entre dispositivos. Esto hace que el código sea portátil a través de una familia de controladores en lugar de estar atado a una unidad específica. Como puede notar, el código también tiende a ser algo más fácil de leer.

/* Direct Blink 2: Using direct bit fiddling via pre-defined variables */

// This is Port B bit 0, Arduino digital output number 8

#define LEDMASK 0x01

void setup()
{
      // initialize the digital pin as an output.
      DDRB |= LEDMASK;
}

void loop()
{
      // turn LED on
      PORTB |= LEDMASK;
      delay(2000);

      // turn LED off
      PORTB &= (~LEDMASK);
      delay(1000);
}

Escriba el código anterior, compile y transfiera el código, y pruébelo. Debería funcionar como antes.

Todas las versiones de este programa se pueden ampliar para controlar varios bits de salida, cada uno conectado a algo diferente. Por ejemplo, un bit podría controlar un LED mientras que otro bit controla un relé o transistor de potencia que controla un motor. Usando Direct Blink 2, se pueden controlar múltiples bits con una sola operación simplemente creando una máscara de bits adecuada. Para un ejemplo rápido, simplemente establezca LEDMASK en 0x21 en Direct Blink 2 para controlar tanto los LED externos como los integrados en tándem. La limitación con este enfoque es que cada ítem no se puede controlar con tiempos completamente diferentes; todos los artículos generalmente tendrán el mismo tiempo. Es posible romper las llamadas de retardo en trozos más pequeños e insertar llamadas para activar y desactivar bits individuales entre ellos. Sin embargo, este es un método bastante torpe y no es particularmente preciso ni flexible si es necesario controlar muchos artículos. Examinaremos formas de evitar esto en futuros trabajos.