Iniciacion a arduino

De La Brecha digital HackLab Madrid
Revisión del 17:43 27 mar 2017 de Fanta (discusión | contribuciones) (Conseguir una placa Arduino.)
(dif) ← Revisión anterior | Revisión actual (dif) | Revisión siguiente → (dif)
Saltar a: navegación, buscar

Descripción de la primera sesión de charlas/talleres sobre arduino

En la primera sesión se hablará sobre lo que es arduino, donde conseguir un arduino y material para comenzar (kits), instalar arduino IDE, un simulador (simuino), software para mostrar gráficamente las conexiones de los diferentes elementos y placas (fritzing). Se realizarán varios ejemplos con LEDs y pulsadores. Se hablará de la estructura base de un programa en Arduino así como las variables y sus tipos. Se hablará de los tipos de entradas/salidas.

¿Qué es Arduino?

Arduino es una compañía de hardware libre y una comunidad tecnológica que diseña y manufactura placas de desarrollo de hardware y software, compuesta respectivamente por circuitos impresos que integran un microcontrolador y un entorno de desarrollo (IDE), en donde se programa cada placa.

Arduino se enfoca en acercar y facilitar el uso de la electrónica y programación de sistemas embebidos en proyectos multidisciplinarios. Toda la plataforma, tanto para sus componentes de hardware como de software, son liberados con licencia de código abierto (lo cual permite libertad de acceso a ellos).

El hardware consiste en una placa. Un circuito impreso con un microcontrolador (usualmente Atmel AVR) y puertos digitales y analógicos de entrada/salida. Esos puertos pueden conectarse a placas de expansión (shields), que amplían las características de funcionamiento de la placa Arduino. Asimismo, posee un puerto de conexión USB desde donde se puede alimentar la placa y establecer comunicación con el computador.

Existen múltiples tipos de placas arduino. La más vendida y común que suele servir para la mayoría de proyectos es Arduino uno (es la que usaremos).

Placas arduino.png


Arduino1.jpg


Por otro lado, el software consiste en un entorno de desarrollo (IDE) basado en el entorno de Processing y lenguaje de programación basado en Wiring, así como en el cargador de arranque (bootloader) que es ejecutado en la placa.

Mas información en Wikipedia


Conseguir una placa Arduino.

Es posible obtener una placa Arduino Uno rev.3 (por ejemplo) en estos sitios a buen precio:

También en tiendas de electrónica e informática posiblemente. En los sitios indicados se pueden obtener muchas veces también kits que incorporan motores, resistencias, cables, leds, sensores, ... Son solamente unas urls de ejemplo. Existen miles de sitios más.

En Madrid se pueden comprar componentes, cables, ... fisicamente en electrónica embajadores por ejemplo (en la calle embajadores 138).

Instalación de Arduino IDE en GNU/Linux.

El Arduino IDE lo podremos obtener de la web oficial: https://www.arduino.cc/en/main/software .

También suele venir en muchas distros GNU/Linux. Por ejemplo en Debian puedes instalarlo así:

apt-get install arduino

Arduinoide.png

Instalación de Simuino en GNU/Linux.

Con simuino vamos a poder simular el código que se ejecutará en el arduino. Nos permite ir viendo paso a paso lo que ocurre.

Instalamos algunas dependencias:

apt-get install ncurses-dev git

Clonamos el repositorio de simuino:

git clone https://github.com/bsaxen/simuino.git
cd simuino
git clone https://github.com/bsaxen/servuino.git

Compilamos simuino:

g++ -o simuino simuino.c -lncurses

Lo ejecutamos por primera vez así:

./simuino

Simuino001.png

Simuino tiene un directorio llamado sketchbook en el que meteremos los archivo con el código *.ino. Por defecto traerá algunos ejemplos. Lo ideal es añadir este otro más que es muy sencillo y permite ir viendo como funciona simuino.

int ledPin = 13;

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

void loop() {
        digitalWrite(ledPin, HIGH);
        delay(1000);
        digitalWrite(ledPin, LOW);
        delay(1000);
}

Lo guardamos dentro del directorio sketchbook con el nombre de ejemplo.ino . Este mismo código puede usarse para compilarlo y mandarselo a arduino usando Arduino IDE y conectando por USB el arduino.

Una vez abierto simuino podemos escribir help para obtener una lista de comandos.

Usaremos list para ver los archivos que contiene el directorio sketchbook y seleccionar uno. Seleccionaremos el número que tenga a la izquierda el archivo ejemplo.ino

Una vez lo tenemos seleccionado escribimos: load y luego run.

Una vez estamos en el modo de ejecución pulsaremos la tecla s y luego con la tecla f vamos para adelante paso a paso y viendo como se va ejecutando el código.

Simuino002.png


Nuestro primer programa para Arduino

Nuestro primer programa será para la placa arduino UNO rev.3. Esta placa incorpora un led que podemos encender y apagar, un led en el PIN 13.


Ledpin13arduino.jpg


Abriremos pues Arduino IDE y copiamos y pegamos allí este código:


int ledPin = 13;

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

void loop() {
        digitalWrite(ledPin, HIGH);
        delay(1000);
        digitalWrite(ledPin, LOW);
        delay(1000);
}

Es el mismo código que hemos usado con simuino para simular el comportamiento. Ahora lo veremos realmente en un arduino, pero antes es bueno entender como funcionan los programas en Arduino.

La estructura básica del lenguaje de programación de Arduino es bastante simple y se compone de al menos dos partes. Estas dos partes necesarias, o funciones, encierran bloques que contienen declaraciones, estamentos o instrucciones.

void setup() //Primera Parte
{
  estamentos;
}
void loop() //Segunda Parte
{
  estamentos;
}

En donde setup() es la parte encargada de recoger la configuración y loop() es la que contiene el programa que se ejecutará cíclicamente (de ahí el término loop –bucle-). Ambas funciones son necesarias para que el programa trabaje.

En nuestro caso hemos declarado antes de nada una variable int llamada ledPin. De ese modo indicamos que pin será el que pondremos en modo OUTPUT. Pinmode básicamente acepta 2 modos: OUTPUT e INPUT.

Es dentro de setup() donde indicaremos si un PIN o varios son de entrada o de salida (I/O). En nuestro programa solo vamos a indicar que el PIN 13 es de salida.

        pinMode(ledPin, OUTPUT);

El programa pasará por setup() una vez y cargará los datos que necesita. Luego irá a loop() y ejecutará en bucle lo que escribamos allí. En nuestro caso esto:

        digitalWrite(ledPin, HIGH);
        delay(1000);
        digitalWrite(ledPin, LOW);
        delay(1000);

Ese código mandará alimentación por el pin13 (5v HIGH y 0v para LOW) y luego dejará de enviar esperando un segundo (delay 1000). Si compilamos y mandamos a arduino el código veremos esto:

Pin13luces.gif

Nuestro segundo programa: Encendiendo 3 leds externos

Ahora vamos a configurar 3 pines como OUTPUT. Servirán para iluminar 3 Leds, uno rojo, uno verde y uno azul.

Enchufaremos a cada uno de ellos gnd y el pin correspondiente al positivo (la pata más larga de los leds).

Arduino-led-patillaje.png

Para ello usaremos una placa de pruebas (Protoboard o breadboard) temporal.


int ledPinAzul = 2;
int ledPinRojo = 3;
int ledPinVerde = 4;

void setup() {
        pinMode(ledPinAzul, OUTPUT);
        pinMode(ledPinRojo, OUTPUT);
        pinMode(ledPinVerde, OUTPUT);
}

void loop() {
        digitalWrite(ledPinAzul, HIGH);
        digitalWrite(ledPinRojo, HIGH);
        digitalWrite(ledPinVerde, HIGH);
        delay(1000);
        digitalWrite(ledPinAzul, LOW);
        digitalWrite(ledPinRojo, LOW);
        digitalWrite(ledPinVerde, LOW);
        delay(1000);
}

Leds.jpg

Como vemos es más de lo mismo. Para crear luz blanca se precisa de leds RGB (RGB). En nuestro caso hemos encendido 3 leds de forma intermitente y sin control alguno. En el estado HIGH pasarán 5v y en el estado LOW 0v. Luego veremos que colocar los LEDs a pelo es una mala idea.

Nuestro tercer programa: Un pulsador y un LED

Es necesario este material:

  • Un LED azul (por ejemplo).
  • Un pulsaodor.
  • Cables.
  • Arduino Uno Rev. 3.


Arduinopulsador.jpg


La conexión es simple.

Conectamos GND a la pata corta del LED. Conectamos la pata larga del LED a 2 sitios: Al Pin 2 y a uno de los lados del pulsador. Conectamos el lado opuesto diagonal del pulsador a la salida de 5v del arduino.

El programa podría ser este:

int pinLectura = 2; // Usaremos este pin para leer el estado del LED.
int statusPulsador = 0; // Por defecto lo ponemos a 0 y si se pulsa cambia a 1.

void setup() {
  pinMode(pinLectura, INPUT); // El PIN 2 en modo INPUT
  Serial.begin(9600); // Indicamos 9600 baudios para el puerto serie.
}

void loop() {
  statusPulsador = digitalRead(pinLectura); // Almacenamos en variable el estado del pulsador
  if (statusPulsador == 1){ // Si es 1 es que esta pulsado
     Serial.print("Pulsador activado\n"); // imprimimos por el puerto serie el mensaje.
  }
}

Lo peculiar es que tenemos un programa en el que por fin hemos usado un if para comprobar si la entrada en un PIN es HIGH o es LOW (1 o 0) y que hemos usado el serial para escribir un mensaje que puede verse por pantalla en arduino IDE si activamos "Monitor serial".

Arduinoserialwindow.png

Comentarios en el código

  • Bloques de comentarios.
    /*... */
  • Linea de comentarios.
    //

Los bloques de comentarios, o comentarios multi-línea son áreas de texto ignorados por el programa que se utilizan para las descripciones del código o comentarios que ayudan a comprender el programa. Comienzan con / * y terminan con * / y pueden abarcar varias líneas.

/* Esto es un bloque de comentarios bla bla bla
y es importante no olvidarse de cerrarlo adecuadamente
para que la cosa funcione bien. */

Los comentarios son ignorados por el compilador y no ocupan espacio en la memoria de Arduino. Pueden ser utilizados con generosidad.

Línea de comentarios


Una línea de comentario empieza con // y terminan con la siguiente línea de código. Al igual que los comentarios de bloque, los de línea son ignoradas por el programa y no ocupan espacio en la memoria.

// esto es un comentario

Una línea de comentario se utiliza a menudo después de una instrucción, para proporcionar más información acerca de lo que hace esta o para recordarla más adelante.

Estructura de un sketch

  • Declaración de variables al inicio.
  • setup()
  • loop()
  • Funciones

Variables y tipos de datos

  • Declaración de variables.

bla bla bal

  • Utilización de variables.

ble ble ble

  • Tipos de datos:
    • byte
    • int
    • long
    • float
    • arrays

describir los tipos de datos. blu blu blu


Entradas y Salidas Digitales

  • pinMode(pin, mode)
  • digitalRead(pin)
  • digitalWrite(pin, value)


Es posible utilizar también los pines analógicos como digitales.

Entradas y Salidas Analógicas

  • pinMode(pin, mode)
  • analogRead(pin)
  • analogWrite(pin, value)

Nuestro cuarto programa: Luz de bajo consumo temporizada para baños

Normalmente la gente suele entrar al baño a hacer sus necesidades y no precisa de mucho tiempo para ello. Unos minutos y andan listos. Lo que ocurre normalmente es que nos dejamos las luces del baño dadas cuando no las necesitamos. Para solucionar eso se puede hacer un sencillo programa que incorpora luces led (o una) y un pulsador.


Luz-baño.png

int pulsador = 4;
int led = 5;
int status;

void setup() {
  pinMode(pulsador, INPUT);
  pinMode(led, OUTPUT);
}

void loop() {
  status = digitalRead(pulsador);
  if (status==HIGH){
    digitalWrite(led,HIGH);
    delay(60000);
    digitalWrite(led,LOW);
  }
}

Se puede variar el tiempo que tardará


Resistencias para los leds

Hasta ahora no hemos usado resistencias con los leds. Es una mala idea y una mala practica no ponerles una resistencia.

El LED se caracteriza por su forward voltage (Vf), el voltaje que hay que aplicar en sus polos para que se ilumine, y la corriente (If) que fluye por él a ese voltaje. Si pasa muy poca corriente no se ilumina, si en cambio pasa mucha corriente… ¡lo quemas!

Led-vf-if.png


Lo ideal es que tengamos una hoja de datos del LED que vamos a usar, pero la realidad es que muchas veces el típico LED que suele venir en los kits arduino (LEDs de 5mm) no trae información alguna.

El amperio (símbolo A) es la unidad de intensidad (I) de corriente eléctrica. El voltio (Símbolo V) es la unidad de voltaje, tensión o diferencia de potencial.

Los LEDs que usaremos en las breadboards son de 2,1V y 20mA,

La placa arduino trabaja con 5V o 3.3V y eso es por tanto un voltaje mayor para el que está diseñado el LED. Estará pasando mayor voltaje entre sus polos y se deteriorará el LED.

La solución es ponerle una resistencia.


La Ley de Ohm relaciona el valor de resistencia con el voltaje y la corriente que la atraviesa. Vf tiene que ser 2,1V. Si el pin de mi microcontrolador da 5V, el voltaje que debe caer por la resistencia es 5V – 2,1V = 2,9V.

V = I·R

despejando: R = V/I

Tenemos que V es 2,9V y que I es 20mA

Por lo que R = 2,9V / 0,02A = 145 Ohm.


Resistencias de 145 Ohm necesitaremos. Si no tenemos una resistencias de 145 Ohm seleccionaremos una por encima.


Fritzing

Se trata de un programa que nos vendrá de perlas para crear gráficos del arduino y las conexiones con diferentes elementos.

website: http://fritzing.org

Instalación en Debian:

apt-get install fritzing

Fritzing.png

Trabajar desde la línea de comandos con nuestro editor de textos favorito

Si nos gusta usar nano, vim, emacs, joe, ... podemos usar estos editores para programar arduino. Nada nos impide que los archivos *.ino sean editados mediante estos editores no obstante perderemos la posibilidad de actualizar el arduino con nuestros programas. Eso lo solucionamos con platformio.

Instalación de platformio:

python -c "$(curl -fsSL https://raw.githubusercontent.com/platformio/platformio/master/scripts/get-platformio.py)"

Una vez instalado podemos visualizar la lista de placas que soporta. En nuestro caso usaremos un arduino uno de modo que esa es la que tendremos que indicar posteriormente.

platformio boards

Nos vamos a un directorio o lo creamos:

mkdir prueba
cd prueba
platformio init --board=uno
cd src
nano/vi/emacs prueba.ino

Metemos nuestro código allí.

Ahora simplemente si queremos compilar el programa y mandarlo a arduino:

platformio run -t upload

Si queremos dejar limpio de programas el arduino:

platformio run -t clean

Si deseamos monitorizar el puerto serie:

platformio device monitor

Monitor serie desde línea de comandos

Monitorizar variables por el puerto serie nos puede ayudar a depurar nuestro programa.

Si utilizamos platformio podemos hacerlo así:

platformio device monitor

Si no usamos platformio y utilizamos por ejemplo el Arduino IDE eso se puede hacer en "Herramientas --> Monitor serial".

Otra opción es usar por ejemplo ttylog. En debian puede instalarse así:

apt-get install ttylog

Y podemos utilizarlo por ejemplo así:

ttylog -b 9600 -d /dev/ttyACM0

Placa de Pruebas y modelos 3D para unirlas a Arduino

Una placa de pruebas (en inglés: protoboard o breadboard) es un tablero con orificios que se encuentran conectados eléctricamente entre sí de manera interna, habitualmente siguiendo patrones de líneas, en el cual se pueden insertar componentes electrónicos y cables para el armado y prototipado de circuitos electrónicos y sistemas similares.

Para trabajar con Arduino Uno y una placa de pruebas podemos optar por imprimir en 3D este diseño: [[1]]

Arduino sujetador01.jpg Arduino sujetador02.jpg

De esa forma el arduino y la placa estarán a la misma distancia siempre y podremos cablear sin mucho problema.


Controlando Pulsador de luces led compradas en alcampo

Podemos construir nuestros propios diseños de algo o tambien usar otros ya existentes. Un ejemplo es el del pulsador de luces led.

En el Alcampo venden por un euro con 50 céntimos unos leds con caja pulsador. Son estos que se ven en la siguiente foto:


Leds alcampo.jpg


Lo bueno que tienen es que llevan un led, una resistencia, un pulsador, muelles y 4 pilas. Todo eso por un euro y medio no es mal precio pero sobre todo lo bueno es que tenemos un pulsador grande que no tendremos que imprimirnos y que funciona bien.

Con arduino podemos abrir estos cacharros y conectar a algún pin analógico el pulsador (tiene 3 patas, una libre que es la que conectaremos al pin INPUT analógico).


Procesopulsador00.jpg Procesopulsador01.jpg Procesopulsador02.jpg

Procesopulsador03.jpg Procesopulsador04.jpg Procesopulsador05.jpg

Procesopulsador06.jpg Procesopulsador07.jpg Procesopulsador08.jpg


De esta forma sacamos 2 cables del cacharro que usaremos para saber cuando está encendido y cuando no lo está (con la función analogRead()).

Un ejemplo de código con el pin A0 a la espera de datos:


int pulsador1 = A0;

void setup(){
  pinMode(pulsador1, INPUT);
  Serial.begin(9600);
}
void loop(){
  int lectura = analogRead(pulsador1);
  Serial.print(lectura);
  Serial.print("\n");
  delay(500);
}

Cuando se pulse el cacharro se encenderá la luz y nos ofrecerá valores diferentes de 0 por el puerto serie.

Una idea es que al monitorizar luces podemos saber cuando se encienden normalmente, llevar estadísticas de estas o por ejemplo simplemente que se nos notifique por email que la luz del baño está encendida.

Otras finalidades pueden ser que suene un sonido, que pongamos 3 de estos pulsadores y juguemos a un trivial. Quien pulsa antes tiene que contestar ! :).

En fin. es un ejemplo para usar analogRead() y cacharros externos a los que podemos siempre enchufar un arduino para monitorizarlos o controlarlos.


Ejemplos de arrays

Un array es un medio de guardar un conjunto de objetos de la misma clase. Se accede a cada elemento individual del array mediante un número entero denominado índice. 0 es el índice del primer elemento.

Este ejemplo puede servir para entender el array:

// Ejemplos de array

char mensaje[3] = "hola";
int pin[] = {2, 3, 4, 5, 6, 7};

void setup(){
        Serial.begin(9600);
        for (int x = 0; x < 6; x++){
                pinMode(pin[x], OUTPUT);
        }
}

void loop() {
        Serial.print(mensaje[0]);
        Serial.print(mensaje[1]);
        Serial.print(mensaje[2]);
        Serial.print(mensaje[3]);
        Serial.print("\n");
        delay(3000); // tras 3 segundos los pines se activan. poner un led para verlo.
        for (int y = 0; y < 6; y++){
                digitalWrite(pin[y], HIGH);
        }
        delay(1000);
}

El array nos puede servir para almacenar por ejemplo valores de diferentes sensores. En el ejemplo se ve como se usa para mostrar un mensaje que podrá verse por el monitor serial y al mismo tiempo se usa para inicializar el modo de los pines 2,3,4,5,6 y 7 como OUTPUT. En el loop se ve como se usa de nuevo un for para activar los pines. Si colocamos un led con una resistencia a GND y luego en la pata positiva le vamos cambiando el cable de un pin del arduino a otro veremos que del 2 al 7 se ilumina, pero en el 8 por ejemplo no.

Leddebugging.jpg


Array de 2 dimensiones.

Para entenderlo imaginemos un tablero de ajedrez (o pongámoslo de ejemplo).

Tablero-de-ajedrez.png

Tiene 8x8 = 64 casillas.

// Ejemplo de array 2d

int x;
int y;
int tablero[8][8] = {
        {1,0,1,0,1,0,0,1},
        {0,0,0,0,0,0,1,0},
        {0,1,1,1,1,1,0,0},
        {0,0,0,0,1,0,0,0},
        {0,0,0,1,0,0,0,0},
        {0,0,1,0,0,0,0,0},
        {0,1,0,0,0,1,1,0},
        {1,0,0,0,0,0,0,0},
};

void setup(){
        Serial.begin(9600);
}

void loop() {
        for (int x = 0; x < 8; x++){
                for (int y = 0; y < 8; y++){
                        Serial.print(tablero[x][y]);
                        delay(100);
                }
                Serial.print("\n");
        }

        Serial.print("\n--------\n");
        delay(4000);
}

Si compilamos el programa y lo cargamos en un arduino uno veremos algo como lo que se ve en la siguiente captura (en el lado izquierdo):

Array2d.png

Un array que contiene otro array y un for que anida otro for para ir leyendo las posiciones. He colocado 1 y 0 como valores pero si por ejemplo fuesen fichas de ajedrez tendriamos que darle un valor diferente a cada ficha. Por ejemplo:

vacío = 0 peón = 1 torre = 2 caballo = 3 ...

Tendríamos la posición inicial de las fichas y tendríamos que cargar nuevos movimientos en la posición en la que se muevan. Por ejemplo así:

tablero[0][0] = 0;

Eso cargaria en la posición 0,0 del tablero el valor 0, es decir, ninguna ficha allí.

Esto es un ejemplo y es bueno controlar los arrays 2d para por ejemplo manejar matrices de leds.

Control de tiempo

  • delay()

Permite generar pausas en el programa de x tiempo. El tiempo se lo indicaremos en milimetros. Ejemplo: delay(1000); pausará 1 segundo el programa. Se utiliza dentro de la función loop() y de otras funciones que generemos.

  • millis()

Devuelve el número de milisegundos desde que la tarjeta Arduino empezó a ejecutar el programa actual. Este número se desbordará después de aproximadamente 50 días.

  • micros()

Devuelve el número de microsegundos desde que la tarjeta Arduino empezó a ejecutar el programa actual. Este número se desbordará después de aproximadamente 70 minutos. En las tarjetas Arduino de 16 MHz (por ejemplo Nano), esta función tiene una resolución de cuatro microsegundos (es decir, el valor devuelto es siempre un múltiplo de cuatro). En tarjetas de 8 MHz Arduino (por ejemplo, el LilyPad), esta función tiene una resolución de ocho microsegundos.

Números aleatorios

randomSeed(seed) - Establece un valor, o semilla, como punto de partida para la función random().

randomSeed(valor);

Debido a que Arduino es incapaz de crear un verdadero número aleatorio, randomSeed le permite colocar una variable, constante, u otra función de control dentro de la función random, lo que permite generar números aleatorios al azar. Hay una variedad de semillas, o funciones, que pueden ser utilizados en esta función, incluido millis() o incluso analogRead() que permite leer ruido eléctrico a través de un pin analógico.

random(max) - Devuelve un valor aleatorio entre 0 y max.

random(min, max) - La función random devuelve un número aleatorio entero de un intervalo de valores especificado entre los valores min y max.

El siguiente ejemplo genera un valor aleatorio entre 0 y 255 y lo envía a una salida analógica:

              
int randNumber;   // variable que almacena el valor aleatorio
int led = 10;     // define led como 10

void setup() {}   // no es necesario configurar nada

void loop() {
    randomSeed(millis());    // genera una semilla para aleatorio a partir de la función millis()
    randNumber = random(255);    // genera número aleatorio entre 0 y 255 
    analogWrite(led, randNumber); // envía a la salida led de tipo PWM el valor 
    delay(500);     // espera 0,5 seg.
}

Para generar números aleatorios más aleatorios es buena cosa utilizar la función analogRead() así:

  • Pilllamos un cable y le quitamos la protección plástica para que se quede al aire.
  • Enchufamos el cable a un pin analógico (por ejemplo a A0) como INPUT.
  • Leemos con analogRead() el ruido del ambiente.
  • Filtramos para coger solamente el rango que nos interese.

Control de un Potenciómetro

Suelen llevar 3 pines. Uno el +, otro el - y del medio que ofrece el valor regulado. En nuestro caso si enchufamos el del medio a la función analogRead() en por ejemplo el pin A0 podemos leer el valor del regulador y aplicarlo a por ejemplo un zumbador. El valor irá entre 0 a 1024.

Potentiometer.jpg

Potenciometro.png

Ejemplo de código:

int potPin = A0;
int potValor = 0;

void setup() {
  pinMode(potPin, INPUT);
  Serial.begin(9600);
}

void loop() {
  potValor = analogRead(potPin);
  Serial.print(potValor);
  Serial.print("\n");
}


Control de un Zumbador con un potenciómetro

Explicar bien en otro momento

int potPin = A0;
int speakerPin = 2;
int potValor = 0;
int speakerValor = 0;

void setup() {
  pinMode(potPin, INPUT);
  pinMode(speakerPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  potValor = analogRead(potPin);
  tone(speakerPin,potValor);
  Serial.print(potValor);
  Serial.print("\n");
}

Zumbadorypotenciometro.jpeg

Programa usando potenciometro, zumbador y display de 7 segmentos

Explicar bien en otro momento

Seven segment led pins.jpg 7seg-2.gif Tablapines.png

3 y 8 a GND (los del medio).

int potPin = A0;
int speakerPin = A1;
int potValor = 0;
int speakerValor = 0;

byte seven_seg_digits[10][7] = {
  { 1,1,1,1,1,1,0 },  // = 0
  { 0,1,1,0,0,0,0 },  // = 1
  { 1,1,0,1,1,0,1 },  // = 2
  { 1,1,1,1,0,0,1 },  // = 3
  { 0,1,1,0,0,1,1 },  // = 4
  { 1,0,1,1,0,1,1 },  // = 5
  { 1,0,1,1,1,1,1 },  // = 6
  { 1,1,1,0,0,0,0 },  // = 7
  { 1,1,1,1,1,1,1 },  // = 8
  { 1,1,1,0,0,1,1 }   // = 9
};

void setup() {
  pinMode(potPin, INPUT);
  pinMode(speakerPin, OUTPUT);
  Serial.begin(9600);
  pinMode(2, OUTPUT);  
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  writeDot(0);  
  
}

void loop() {
  potValor = analogRead(potPin);
  tone(speakerPin,potValor);
  Serial.print(potValor);
  Serial.print("\n");
  if (potValor < 100 && potValor > 0){
    sevenSegWrite(0);
  }
  if (potValor < 200 && potValor > 100){
    sevenSegWrite(1);
  }
  if (potValor < 300 && potValor > 200){
    sevenSegWrite(2);
  }
  if (potValor < 400 && potValor > 300){
    sevenSegWrite(3);
  }  
  if (potValor < 500 && potValor > 400){
    sevenSegWrite(4);
  }
  if (potValor < 600 && potValor > 500){
    sevenSegWrite(5);
  }  
  if (potValor < 700 && potValor > 600){
    sevenSegWrite(6);
  }    
  if (potValor < 800 && potValor > 700){
    sevenSegWrite(7);
  }  
  if (potValor < 900 && potValor > 800){
    sevenSegWrite(8);
  }    
  if (potValor < 1000 && potValor > 900){
    sevenSegWrite(9);
  }  
}


void writeDot(byte dot) {
  digitalWrite(9, dot);
}
   
void sevenSegWrite(byte digit) {
  byte pin = 2;
  for (byte segCount = 0; segCount < 7; ++segCount) {
    digitalWrite(pin, seven_seg_digits[digit][segCount]);
    ++pin;
  }
}


7segmentoszumbadorpotenciometro1.jpg 7segmentoszumbadorpotenciometro2.jpg

Diseños 3D para elementos de Arduino uno

Algunos diseños que pueden ser de utilidad para elementos que se suelen utilizar con arduino:

Programación colectiva mediante pad

Un pad permite que la gente pueda conectar a una url mediante el navegador ( por ejemplo: https://pad.elbinario.net/p/arduino ) y permite que este pueda ser exportado en texto plano.

Usando un pad etherpad esa url de pad quedará así: https://pad.elbinario.net/p/arduino/export/txt

Por tanto desde línea de comandos se puede bajar con wget por ejemplo:

wget -q "https://pad.elbinario.net/p/arduino/export/txt" -O arduino.ino

y abrilo con el editor que queramos y compilarlo cuando se precise. O no abrirlo y simplemente actualizarlo si usamos platformio.