Practica 2 Salidas Digitales

Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Está en la página 1de 6

Salidas Digitales

En este ejercicio se tienen conectados a la protoboard 5 leds, cada uno con un resistor de 330
Ohms, que se conectan a las salidas digitales del arduino 2, 3, 4, 5 y 6 respectivamente. El
programa tiene que encender el primer led, esperar un tiempo de 200 ms, después de los
cuales el led se apaga y se enciende el siguiente hasta alcanzar el último led, cuando se
alcanza el último led el siguiente en encender es el anterior y así recorre todos los leds en
sentido contrario, cuando llega al primer led se repite el ciclo.

Alambrar el circuito de acuerdo a la explicación, se pueden apoyar en el diagrama gráfico que


se proporciona. Es necesario que la tierra del Arduino se conecte directamente con la tierra de
la protoboard, porque en todo circuito se necesita una referencia de voltaje, por convención
siendo la tierra, y todas las referencias de voltaje deben ser la misma para que, digamos, 5 [V]
en un primer circuito sean también 5 [V] en el segundo circuito.

Aunque Arduino integra varios esquemas de protección internos, se recomienda que al


momento de alambrar se mantenga la tarjeta desconectada, para evitar que algún corto circuito
accidental fuerce a actuar a las protecciones, cerrando temporalmente el puerto usb.

Arreglos
Debido a que se tienen varios leds es impráctico escribir el código para cada uno de manera
independiente, para esto nos podemos apoyar en los arreglos, estas son estructuras de
variables en las que podemos guardar varios elementos y acceder a ellos a través de un
indicador. Puede pensarse en un arreglo como un “vector” o “lista” de cosas, todas del mismo
“tipo”, que podemos “accesar” por medio de su posición en el vector.

Por ejemplo para nuestro caso tenemos un grupo de pines que van a representar nuestros
leds, podemos hacer una variable en el formato de arreglo que nos indique esto así:

int ledPins[5] = {2, 3, 4, 5, 6};

En este ejemplo podemos ver la estructura básica de la definición de un arreglo, primero


ponemos el tipo de dato de las variables, luego el nombre del arreglo y entre corchetes
podemos colocar el número de elementos dentro del arreglo, en nuestro caso son cinco, para
asignar los elementos ponemos el símbolo de igual y entre llaves los elementos separados por
una coma. La forma alternativa de hacerlo sin arreglos es:

int ledPin1 = 2, ledPin2 = 3, ledPin3 = 4, ledPin4 = 5, ledPin5 = 6;

Para acceder a cada elemento del arreglo podemos hacerlo colocando el nombre del arreglo y
entre corchetes el número de elemento que deseamos, hay que tomar en C/C++, el primer
elemento del arreglo tiene un índice cero, por lo cual:

ledPins[0] -> 2
ledPins[2] -> 4
ledPins[4] -> 6

Ciclos de control

Cuando se tienen estructuras de código que hay que repetir muchas veces es tedioso e
impráctico el volver a escribir el código varias veces, para esto se tienen estructuras de control
que nos ayudan a hacer ciclos de ciertos pedazos de código, la más básica es la estructura
while.

En la estructura while se repite un cierto código mientras se cumpla una condición lógica, se
escribe de la siguiente manera:

// sentencia es una expresión que puede evaluarse como true o false


// en C/C++ el 0 es false y todo los demás es true, sin embargo
// por ejemplo, while(1) se ejecutará eternamente, en tanto while(0)
// no se ejecutará jamás.
while( sentencia )
{
// código contiene varias instrucciones, que se ejecutarán si
// la evaluación de sentencia es verdadera. Por ende, es posible
// que lo que está en código no se ejecute ninguna vez
codigo
}

Otra estructura similar es do while, que a diferencia del while evalúa la condición después de
haber ejecutado las instrucciones, por lo que estas se llevan a cabo al menos una vez.

int i = 0;
do
{
i++;
}
while(0)
// aunque la condición de while es siempre falsa, como se evalúa
// al final la variable i toma el valor de 1

Muchas veces queremos poder controlar lo que ocurre dentro de un while, definir cuántas
veces queremos que se repita el código y también tener una variable que nos indique en qué
ciclo vamos, esta estructura un poco más avanzada se llama for.

for( iniciar variable de trabajo; sentencia; cambio de variable)


{
codigo
}

Los argumentos de la estructura for se separan en tres partes, por punto y coma, la primer
parte nos ayuda a iniciar la variable con la que vamos a trabajar, esta variable es la que
podremos modificar en cada ciclo, la segunda es una sentencia que mientras sea verdadera el
ciclo va a continuar, y por último ponemos como es que va a cambiar nuestra variable de
trabajo, podemos querer que vaya de uno en uno, o de dos en dos, etc. En el inicio y en el
cambio podemos poner varias instrucciones separadas por comas simples.

Para nuestro caso podemos utilizar esta estructura para recorrer nuestro arreglo de pines e ir
definiendo cada pin como salida, esto nos ahorra el tener que escribir de uno en uno y lo
podemos hacer de la siguiente manera:

// nótese la ausencia de llaves, cuando no hay llaves se asume que el


// for repetirá SOLO la siguiente sentencia (esto es, lo que hay
// antes del punto y coma que sigue del paréntesis de cierre del for)
for( int i = 0; i < 5; i++)
pinMode( ledPins[i], OUTPUT );
Las variables inicializadas en el primer argumento del for son LOCALES. Esto es, solamente
existen dentro de las llaves del for (o si no hay llaves, en la sentencia inmediata al for). El
siguiente código, por ejemplo, no podrá ser compilado porque el programa no podrá localizar a
la j, ya que existe sólo temporalmente en el for y luego se “desecha”:

// En la primer parte y última parte podemos poner varias cosas


// separadas por comas simples
for( int i = 0, j = 0; i < 5; i++, j++)
pinMode( ledPins[i], OUTPUT ); j++;

Una variable declarada al principio de todo el programa, no puesta dentro de ningún método o
función es GLOBAL, todas las funciones posteriores podrán usarla, leerla, cambiarla. Esto
puede parecer bueno, pero entonces hay que tener cuidado de que no suceda que varias
partes del programa cambien esa variable de forma conflictiva, lo que puede generar errores
difíciles de detectar que sin embargo, son compilados sin problema (porque no es un error de
sintaxis).

Estructura de un programa en Arduino

Todo programa de Arduino necesita de dos funciones fundamentales, una de inicialización, que
se ejecuta una única vez, llamada setup(), y una que se ejecutará perpetuamente, ciclandose
tan rápido como sea posible, llamada loop(). El siguiente programa, por ejemplo, es válido
aunque no haga absolutamente nada:

void setup() { }
void loop() { }

Por “arriba” de setup() se acostumbra poner a las variables globales que se usen en el resto
del programa, y por debajo de loop() se acostumbra poner a las funciones o métodos usados
en el loop().

Salidas digitales en Arduino

Todos los pines de Arduino pueden usarse como “salidas” digitales, esto es, pueden mantener
un valor de 0 [V], o LOW, o un valor de 5 [V], o HIGH. Para dejar establecido un pin con uno de
tales valores, necesitamos primero establecer el pin al que se quiere “escribir” como una salida:

// pinMode -> (pin, Mode)


// otros modos son INPUT e INPUT_PULLUP
pinMode(pin, OUTPUT);

Y para escribir el valor de 0 [V] o 5 [V] usamos la instrucción:

// valor puede ser LOW, para 0 [V], o HIGH, para 5 [V]. En Arduino:
// 0 = LOW = false, 1 = HIGH = true
digitalWrite(pin, valor);

Podemos generar “retrasos” en Arduino también. Básicamente, esto simplemente es que una
función toma como argumento el número de milisegundos que queremos esperar antes de
continuar con el resto del flujo del programa, y ejecutará un bucle hasta que ese número de
milisegundos haya pasado.

// valor es una cantidad en milisegundos


delay(valor);

Código

Una vez que aprendimos a utilizar los arreglos y los ciclos de control podemos aplicarlos a
nuestro ejercicio y el código del programa queda de la siguiente manera:

int ledPins[5] = {2,3,4,5,6};


int retardo = 200;

// en setup() se inicializa Arduino, en particular, si queremos usar


// pines como salida, hay que usar la instrucción pinMode(pin, modo),
// para establecer pin como OUTPUT
void setup(){
for(int i=0; i<5; i++)
pinMode(ledPins[i], OUTPUT);
}

// Y lo que está en el loop se ejecutará justo después de setup(),


// por siempre, hasta que se reinicie Arduino
void loop(){
for(int i=0; i<5; i++){
digitalWrite(ledPins[i], HIGH);
delay(retraso);
digitalWrite(ledPins[i], LOW);
}

for(int i=3; i>0; i--){


digitalWrite(ledPins[i], HIGH);
delay(retraso);
digitalWrite(ledPins[i], LOW);
}
// por que el primer for fue de 0 a 4 pero el segundo de 3 a 1?
// pensar en la secuencia 0, 1, 2, 3, 4, 3, 2, 1, ...
}
Algunas observaciones finales

Aunque podemos alimentar LEDs sin mayores problemas, los LEDs consumen una corriente
muy pequeña. No podemos alimentar dispositivos que demanden mucha energía directamente
a los pines de salida digital presentes en Arduino, porque no podrá proporcionar suficiente
corriente en el pin, y corremos el riesgo de dañar el pin o el microcontrolador de forma
permanente. Los dispositivos de protección deberían proteger a la computadora, sin embargo.

No se recomienda usar los pines 0 y 1 por razones varias.

También podría gustarte