Semana 6

Ejemplos de código

Estructura básica en todo programa de Arduino

/* 
  Esta función corre 1 sola vez al principio, esto sucede en caso de: 
  - Prendo el Arduino al conectarlo.
  - Undo el boton "reset" en la placa.
*/
void setup() {
  // El código que pongo aquí en general sirve para decirle a la placa que
  // partes voy a utilizar - por ejemplo, en que pins tengo algo conectado -
  // y de qué manera los voy a usar - por ejemplo, si el pin debe ser de entrada o salida -.

  // Si en la lógica de mi programa quiero hacer una operación solo una vez y al principio,
  // ese código lo pongo acá.
};

/*
  Al terminar de ejecutar lo que está en "void setup()" y nunca antes,
  el microcontrolador comenzará a ejecutar lo que escriba en esta función indefinidamente.
  De ahí su nombre loop, apenas termina con la última instrucción (la última línea de código), 
  vuelve al principio y ejecuta el código de nuevo.
*/
void loop() {
  // Aquí escribimos nuestro programa principal, las instrucciones que le damos a la placa.

  // El orden en el que escriban el código es importante ya que el código se ejecuta
  // en orden, linea por linea.
}

El Arduino IDE viene con una serie de ejemplos que nos ayudan a entender la manera de usar la placa y todas sus funciones. Veamos uno de los ejemplos básicos que describen como prender un LED.

En el Arduino IDE, lo encuentran en: File -> Examples -> 01.Basics -> Blink

/*
  A continuación les explico lo que hace el código del ejemplo Blink.
  El Arduino UNO viene con un led conectado al pin 13. En este ejemplo,
  vamos a conectar el Arduino con el cable USB y
  ver cómo podemos controlar el LED que viene en la placa.
 */

// Recuerden, estas instrucciones se ejecutan una sola vez al principio.
void setup() {
  // Le decimos al Arduino que vamos a usar uno de los pins, en este caso el número 13.
  // Para eso usamos la función llamada "pinMode(param1, param2)" que acepta dos parametros:
  // 1. El número del pin que queremos usar, esto es una variable "int" o simplemente el número.
  // 2. Las palabras OUTPUT o INPUT - en mayúsculas y sin comillas. 
  //    Estas son constantes que Arduino ya conoce.

  // En nuestro caso, queremos que por el pin 13 SALGA energía para prender el LED,
  // Entonces le decimos al programa que el pin 13 se usa con OUTPUT.

  pinMode(13, OUTPUT);
}

// Aquí vemos la lógica del programa: prende el led en el pin 13,
// espera 1 segundo, lo apaga y espera 1 segundo.
// Luego comienza de nuevo y hace lo mismo infinitamente. 

void loop() {
  // Para prender y apagar el LED debemos pasar corriente por el pin 13.
  // En este caso queremos que sea intermitente - prendiendo y apagando cada segundo.
  // Para eso podemos usar la función "digitalWrite(param1, param1)" que acepta dos parametros: 
  // 1. El número del pin (en este caso el 13).
  // 2. Las palabras HIGH o LOW - en mayúsculas y sin comillas. 
  //    Estas también son constantes que Arduino conoce.
  //    La constante HIGH, le dice a la placa, ahora pase corriente. 
  //    LOW, hace lo contrario y en nuestro caso apaga el LED.

  digitalWrite(13, HIGH);   // Pone el pin 13 en voltaje alto - HIGH -.
  delay(1000);              // Espera 1 segundo - 1000 milisegundos -.
  digitalWrite(13, LOW);    // Pone el pin 13 en voltaje bajo - LOW -.
  delay(1000);              // Espera 1 segundo.
}

Para modificar cualquiera de los ejemplos de Arduino debemos guardarlos por separado.

  • Crean una carpeta nueva.
  • En el Arduino IDE abren el ejemplo Blink.
  • Van a File -> Save As
  • Y lo guardan en su carpeta con el nombre Blink-v1
/*
  Para aprender sobre variables, hagamos una simple alteración al código inicial.
  Piensen por ejemplo que no quieren usar el pin 13, o están haciendo pruebas con varios pins.
  El código anterior tenia el numero del pin escrito 3 veces. 
  Si lo quieren cambiar lo tendrían que cambiar en los 3 lugares donde aparece.
  En este caso es bastante trivial y no es mucho trabajo, pero a medida que su
  código se complejiza, esto puede ser un problema porque cada que quiero hacer un pequeño cambio,
  me tocaría ir a todas las instancias y cambiarlas manualmente. 
  Mejoremos entonces el código anterior asignando el numero del pin a una variable.
*/ 

/*
  Yo quiero tener acceso a esta variable desde cualquier lugar, 
  dentro de setup() y tambien dentro de loop()
  En este caso declaro la variable por fuera de ambas funciones. 
  Esto se llama una variable global.
  En este caso, el tipo de variable es un numero, así que la declaro con la palabra "int" de integral.
  Luego le asigno un nombre, el que yo quiera mientras no comience con números, 
  no tenga espacios y no sea el nombre de algo que el lenguaje ya tiene asignado
  para otras cosas como int, float, etc...
*/

int numPin = 13;

void setup() {
  pinMode(numPin, OUTPUT);
}

void loop() {
  digitalWrite(numPin, HIGH);   // Pone el pin 13 en voltaje alto - HIGH -.
  delay(1000);                  // Espera 1 segundo - 1000 milisegundos -.
  digitalWrite(numPin, LOW);    // Pone el pin 13 en voltaje bajo - LOW -.
  delay(1000);                  // Espera 1 segundo.
}

Ahora, en los cambios que acabamos de hacer, hemos declarado el número del pin una sola vez en una variable global llamada numPin. Ahora la podemos usar en las diferentes partes del programa con tan solo cambiar el valor de esa variable. Es decir, si lo cambio de 13 a 8 y conecto mi LED en el pin 8, fácilmente mantengo la lógica de mi programa y el led debería prender y apagar desde el pin 8.

int led1 = 13;
int led2 = 8;
int led3 = 14; // Pero la placa solo tiene hasta el 13!! ¿funciona?

void setup() {
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
}

void loop() {
  // LED 1
  digitalWrite(led1, HIGH);
  delay(1000);
  digitalWrite(led1, LOW);
  delay(1000);

  // LED 2
  digitalWrite(led2, HIGH);
  delay(1000);
  digitalWrite(led2, LOW);
  delay(1000);

  // LED 3
  digitalWrite(led3, HIGH);
  delay(1000);
  digitalWrite(led3, LOW);
  delay(1000);
}

Haciendo uso de lo que aprendimos en clase, veamos la siguiente versión del Blink donde aprovechamos otras partes del lenguaje de programación: 

int misPins[] = {13, 8, 14};
int pinActual = 0;
int numeroLeds = sizeof(misPins) / sizeof(int);

void setup() {
  for (int i = 0; i < numeroLeds; i++) {
    pinMode(misPins[i], OUTPUT);
  }
}

int quieroElSiguientePin() {
  pinActual++;

  if (pinActual == numeroLeds) {
    pinActual = 0;
  }

  return misPins[pinActual];
}

void loop() {
  int pin = quieroElSiguientePin();

  digitalWrite(pin, HIGH);
  delay(100);
  digitalWrite(pin, LOW);
  delay(100);
}

Pueden ver una simulación del circuito en: https://www.tinkercad.com/things/ejZrOhQ9KNt-control-de-leds-con-array Para verlo deben crear una cuenta gratis en Tinkercard y darle clic al botón "modificar". En el editor pueden modificar el código, re-diseñar el circuito y reproducir una simulación.

Ejercicio Extra

No es obligatorio y tampoco da nota extra, esto es solo para quienes estén interesados en aprender programación. Pueden hacer todos o al menos el primero. Cuando terminen, me mandan el link de sus circuitos por email y yo lo reviso y les hago comentarios.

  1. En su propia cuenta de Tinkercard, hacer una copia del circuito: https://www.tinkercad.com/things/ejZrOhQ9KNt-control-de-leds-con-array
  2. Comentar el código linea por linea para explicar lo que hace. Si hay algo que no entienden, pueden escribir preguntas y les explico.

Ejercicio Extra Extra

  1. Crear una nueva copia del circuito anterior.
  2. Conectar otro LED para que el circuito tenga 4 LEDs en total.
  3. Crear una nueva función variacionDeSiguientePin() que haga lo que dice abajo.
  4. Comentar su código explicando la solución (hay muchas maneras de hacerlo).
int variacionDeSiguientePin() {
  /*
    La idea en éste es prender y apagar los LEDs saltándonos uno. 
    Es decir, antes los encendíamos en orden: 
    LED1, LED2, LED3 (fin del array, continua en loop)
    Ahora el orden es: 
      LED1, LED3 (pasa una vez por el array saltándose uno)
      LED2, LED4 (reinicia la cuenta en el array saltando uno)
      LED1, LED3 (reinicia el loop)
      LED2, LED4
      LED1... 


    Los pasos serian: 

    1. Defino pinActual saltándome 1 LED, ya no sumo 1 sino 2.
    2. Reviso si el nuevo valor de pinActual supera el numero de LEDs 
       que tengo registrados en mi array.
       Pista: Los arrays empiezan en 0 y la variable pinActual hace referencia
       a la posición en el array y no al numero del pin en el Arduino.
    3. Si lo anterior resulta verdadero, debo prender ya sea el primer LED
    o el segundo para seguir saltándome 1.
    4. La función debe devolver (return) el pin que quiero prender y apagar.

  */ 

}

Ejercicio Extra Extra Extra

  1. Crear una nueva copia del circuito anterior.
  2. Conectar más de 4 LEDs.
  3. Crear su propia función con su propio patron de como se encienden y apagan los LEDs.

results matching ""

    No results matching ""