Archivo de la etiqueta: Programación

Tratamiento Avanzado de Strings

Como ya se ha visto anteriormente el tratamiento de strings es un parte muy importante en Arduino puesto que se usa muy frecuentemente y principalmente usamos en las comunicaciones, ya sea puerto serie, bluetooth, XBee, http, etc…

El uso de strings hace un uso intensivo de memoria lo que hace que podamos tener comportamientos extraños en los sketchs o incluso tengamos desbordamiento de memoria.

A la hora de usar strings en Arduino, podemos hacer uso de la clase String https://www.arduino.cc/en/Reference/StringObject que nos ofrece unos métodos y es muy sencilla de usar, a cambio de ser poco eficiente a nivel de SRAM o usar los strings https://www.arduino.cc/en/Reference/String como arrays de chars https://www.arduino.cc/en/Reference/Char que es más complejo de manejar pero más potente y tenemos más control del uso de memoria.

String (Objeto)

Ahora que ya sabemos que son las clases, Arduino nos ofrece una clase llamada String que facilita el uso de de las cadenas de caracteres con unos métodos muy sencillos de usar y poder los operadores que conocemos para los Strings.

Se trata de una clase que permite usar y manipular cadenas de texto de una forma más sencilla que los strings. Puedes concatenar, añadir, buscar, etc… usando los métodos/funciones que ofrece esta clase.

Los Strings tienen un uso intensivo de memoria, pero son muy útiles y se van a utilizar mucho en el apartado de comunicación, por ese motivo es importante aprender a manejar los Strings.

Tener en cuenta que al no ser un tipo de dato propiamente dicho sino una clase, tienes unas funciones asociadas (métodos), operadores y unas propiedades. Es una abstracción del dato y para aprender a usarlo hay que leerse la documentación correspondiente.

Toda la información de la clase String está en https://www.arduino.cc/en/Reference/StringObject

Ver documentación de Arduino sobre la clase String:

string (Array de chars)

Un string es un array de chars. Cuando se trabaja con grandes cantidades de texto, es conveniente usar un array de strings. Puesto que los strings son en si mismo arrays.

El core de Arduino me ofrece varias funciones de análisis de caracteres:

Una cadena en C++ es un conjunto de caracteres, o valores de tipo char, terminados con el carácter nulo, es decir el valor numérico 0 (\0). Internamente, en el ordenador, se almacenan en posiciones consecutivas de memoria. Este tipo de estructuras recibe un tratamiento muy especial, ya que es de gran utilidad y su uso es continuo. La manera de definir una cadena es la siguiente: char <identificador> [<longitud máxima>];

Cuando se declara una cadena hay que tener en cuenta que tendremos que reservar una posición para almacenar el carácter nulo terminador, de modo que si queremos almacenar la cadena “HOLA”, tendremos que declarar la cadena como: char Saludo[5]; Las cuatro primeras posiciones se usan para almacenar los caracteres “HOLA” y la posición extra, para el carácter nulo.

También nos será posible hacer referencia a cada uno de los caracteres individuales que componen la cadena, simplemente indicando la posición. Por ejemplo el tercer carácter de nuestra cadena de ejemplo será la ‘L’, podemos hacer referencia a él como Saludo[2].

Se puede manipular las cadenas de caracteres de la misma manera en que manipula cualquier otro tipo de array, sin embargo, es preferible hacer uso de una librería estándar especialmente escrita para manipulación de cadenas de caracteres, se trata de la librería <string.h> y que viene incluida con todo compilador de C, C++.

Los compiladores de C, C++ dan soporte a la biblioteca de funciones <string.h>, a la que accede por medio de la directiva #include <string.h>. No veremos en detalle todas las funciones contenidas en dicha biblioteca, y nos limitaremos a mostrar algunos ejemplos de ciertas funciones importantes.

  • strlen(): Obtener longitud de cadenas. Sintaxis: size_t strlen(const char *s);
  • strcpy(): Copiar cadenas. Sintaxis: char *stpcpy(char *dest, const char *src);
  • strcat(): Concatenar cadenas. Sintaxis: char *strcat(char *dest, const char *src);
  • strlwr(): Convertir a minúsculas. Sintaxis: char *strlwr(char *dest);
  • strupr(): Convertir a mayúsculas. Sintaxis: char *strupr(char *dest);
  • strchr(): Buscar carácter (hacia adelante). Sintaxis: char *strchr(char *s, int c);
  • strrchr(): Buscar carácter (hacia atras). Sintaxis: char *strrchr(char *s, int c);
  • strstr(): Buscar subcadena. Sintaxis: char *strstr(const char *s1, char *s2);
  • memset(): Establece el primer num bytes del bloque de memoria apuntado por ptr al valor especificado en value (interpretado como un unsigned char).. Sintaxis: void * memset ( void * ptr, int value, size_t num );

Práctica: Manejo de Strings

Ejercicio16: Conectarse a www.aprendiendoarduino.com y analizar el texto descargado. El texto descargado es una página web que contiene datos de una música a tocar por el buzzer

Hacerlo usando la clase String,

Obtener y sacar por el puerto serie:

  • Tamaño de la web (número de caracteres)
  • Localizar las cadenas: “Inicio Notas”, “Fin Notas”, “Inicio Duración” y “Fin Duración”
  • Obtener las notas (frecuencia) y la duración de las notas. Luego reproducirlo.

Github clone link: https://github.com/curso-programacion-arduino/Ejercicio16.git

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino

Estructuras Propias de Arduino

Lo visto hasta ahora son estructuras y sintaxis de programación que es casi genérica a C++, pero el core de Arduino incluye algunas funciones propias para el uso de Arduino como la lectura de entradas analógicas y digitales y la escritura de salidas analógicas y digitales.

Para saber más de C y de la API de Arduino:

Veamos estas estructuras más específicas que están documentadas en el reference de Arduino https://www.arduino.cc/en/Reference/HomePage

Cómo Leer el Reference Arduino

En el reference de Arduino tenemos toda la información necesaria para entender cómo funciona el lenguaje o core de programación de Arduino. Esta todo perfectamente documentado de cómo funciona cada estructura y cómo se comportan las funciones,

Reference: https://www.arduino.cc/en/Reference/HomePage

Cuando entramos en el reference y vemos un nuevo método o función deberemos leer:

  • Description: Hace una descripción de lo que hace ese método y función
  • Syntax: Sintaxis de la función con todas las formas de llamarlo y los parámetros a pasar. Puede haber varias formas de llamar a una función, por ejemplo https://www.arduino.cc/en/Reference/EthernetBegin
  • Parameters: Descripción de los parámetros a pasar a esa función. Puede que no haya que pasar ninguno: https://www.arduino.cc/en/Reference/Millis
  • Returns: que valor me devuelve y qué tipo de dato es. Puede que no devuelva nada como https://www.arduino.cc/en/Reference/PinMode
  • Note: Nota sobre el uso de la función
  • Example: Un ejemplo de cómo usar la función
  • See Also: Otras funciones relacionadas

Entradas y Salidas Digitales

En arduino para tratar las entradas y salidas digitales usamos las siguientes funciones:

En la imagen siguiente se muestra el estado por defecto de una I/O digital en un microcontrolador de Arduino. Se ha simplificado con interruptores la compleja electrónica que hay dentro. Por defecto los digital I/O pins están configurados como inputs en un estado de alta impedancia (equivalente a una resistencia de 100 Mohms en frente del pin), es decir, SW3 a ON y no hace falta llamar a la función pinMode() aunque es recomendable para aclarar el código.

  • PinMode(x, INPUT) –> SW3 = ON (resto a OFF). Los valores leídos serán aleatorios si el pin de Arduino está al aire. El pin está en un estado de alta impedancia (resistencia de 100 Mohms).
  • PinMode(x,INPUT_PULLUP) –> SW3 = ON & SW4 = ON (resto a OFF). Los valores leídos sin nada conectado al pin es HIGH. La Resistencia R1 tiene un valor dependiendo del microcontrolador, pero tiene un valor entre 20kOhm y 150kOhm.
  • PinMode(x, OUTPUT) & digitalWrite(x,HIGH) –> SW2 = ON & SW1 = +5V (resto a OFF). Estado de baja impedancia, no hay resistencia interna y es necesario poner una resistencia adecuada a la salida el pin para no superar los 40mA (source) máximos admitidos
  • PinMode(x, OUTPUT) & digitalWrite(x,LOW) –> SW2 = ON & SW1 = GND (resto a OFF). Estado de baja impedancia, no hay resistencia interna y es necesario poner una adecuada para no superar los 40mA (sink) máximos admitidos

Entradas y Salidas Analógicas

En arduino para tratar las entradas y salidas digitales usamos las siguientes funciones:

Otras funciones interesantes con entradas/salidas analóicas:

La mayoría de Arduino no tienen salidas analógicas puras sino PWM. Algunos pines digitales pueden usarse como salidas analógicas PWM:

Las Salidas PWM (Pulse Width Modulation) permiten generar salidas analógicas desde pines digitales. Arduino Uno no posee salidas analógicas puras, sin embargo el Arduino Due sí tiene salidas analógicas puras mediante dos DAC. El arduino due, posee dos salidas analógicas puras mediante dos conversores digital a analógico. Estos pines pueden usarse para crear salidas de audio usando la librería correspondiente.

La modulación por ancho de pulsos (también conocida como PWM, siglas en inglés de pulse-width modulation) de una señal o fuente de energía es una técnica en la que se modifica el ciclo de trabajo de una señal periódica (una senoidal o una cuadrada, por ejemplo), ya sea para transmitir información a través de un canal de comunicaciones o para controlar la cantidad de energía que se envía a una carga.

El ciclo de trabajo de una señal periódica es el ancho relativo de su parte positiva en relación con el período. duty cycle = (tiempo que la salida está a uno o HIGH)/ (periodo de la función)

Diferentes valores de una señal PWM:

Entradas y Salida Avanzadas

Advanced I/O

  • tone() – Genera una onda cuadrada (ciclo y 50% de servicio) de la frecuencia especificada en un pin. Una duración se puede especificar, de lo contrario la onda continúa hasta una llamada a noTone (). El pin puede ser conectado a un zumbador piezo u otro altavoz para reproducir tonos.
  • noTone() – Detiene la generación de una onda cuadrada provocada por tone(). No tiene ningún efecto si no se está generando el tono.
  • shiftOut() – Desplaza un byte de datos de un bit cada vez. Comienza a partir del más o menos significativo. Cada bit es escrito en un pin cada vez que se produce un pulso de reloj.
  • shiftIn() – Desplaza un byte de datos de un bit cada vez. Comienza a partir dell más o menos significativo. Para cada bit, el reloj es puesto a HIGH, el siguiente bit es leído de la línea de datos y entonces el reloj es puesto a LOW.
  • pulseIn() – Lee un pulso de un pin. Si el valor es HIGH, la función espera a que el pin se ponga a HIGH, comienza a temporizar y espera hasta que el pin vuelve a LOW, devolviendo la longitud del pulso en microsegundos.

Ejemplo de uso: https://www.arduino.cc/en/Tutorial/ShiftOut

Bits y Bytes

Bits and Bytes

  • lowByte(): extrae el byte más a la derecha (low-order o menos significativo de una variable.
  • highByte(): extrae el byte más a la izquierda (high-order o más significativo de una variable.
  • bitRead(): lee el bit de una variable numérica.
  • bitWrite(): escribe el bit de una variable numérica
  • bitSet(): pone a 1 un bit de una variable numérica
  • bitClear(): pone a 0 un bit de una variable numérica
  • bit(): Calcula el valor del bit especificado (el bit 0 es 1, el bit 1 es 2, el bit 2 es 4, etc.)

Constantes

Constants

  • HIGH | LOW – Al leer o escribir en un pin solo hay estas dos posibilidades. Su significado es diferente si el pin está configurado como INPUT o OUTPUT.
  • INPUT | OUTPUT | INPUT_PULLUP – Modo en el que pueden configurarse los pines digitales.
  • LED_BUILTIN – La mayoría de las placas Arduino tienen un pin conectado a un led en la placa y esta constante devuelve el número de pin en función de la placa.
  • true | false – Representación de las constantes booleanes en arduino
  • integer constants – son los números usados directamente en un sketch como ‘123’. Por defecto estos números son tratados como enteros pero puede cambiarse con los modificadores U y L. Las constante enteras se tratan como base 10 (decimal) pero puede usarse otra notación.
  • floating point constants – al igual que las constantes enteras, las constantes de coma flotante permite definir los número decimales. Son posibles varias notaciones para expresar constantes de coma flotante, por ejemplo: n = .005. También pueden expresarse en notación científica como 2.34E5.

Utilidades

Utilities

  • sizeof() – devuelve el número de bytes en una variable o el número de bytes ocupados por un array.
  • PROGMEM – se usa para guardar en la memoria flash en lugar de en la SRAM. Al usarlo le dice al compilador que ponga la información de la variable en la memoria flash en lugar de la SRAM, donde iría normalmente.

PROGMEM es parte de la librería pgmspace.h http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html que solo está disponible para la arquitectura AVR, así que para usarlo hay que inclirla al principio del sketch con #include <avr/pgmspace.h>

La macro F() se puede usar para facilitar el manejo de PROGMEM en las instrucciones print, de forma que todo el texto a imprimir (ya sea en Serial, Ethernet u otra librería) se lea de la Flash y no ocupando tamaño en la SRAM. Esta macro está incluida en el core de Arduino.

Operadores Bit a Bit

Bitwise Operators

  • & (bitwise and)
  • | (bitwise or)
  • ^ (bitwise xor)
  • ~ (bitwise not)
  • << (bitshift left)
  • >> (bitshift right)

Operadores Compuestos

Compound Operators

  • ++ (increment)
  • (decrement)
  • += (compound addition)
  • -= (compound subtraction)
  • *= (compound multiplication)
  • /= (compound division)
  • %= (compound modulo)
  • &= (compound bitwise and)
  • |= (compound bitwise or)

Ambito de las Variables y Calificadores

Variable Scope & Qualifiers

  • variable scope – ámbito de la variable
  • static – hace que el valor de una variable local persista más alla de la función haciendo que su valor se mantenga entre llamadas a funciones
  • volatile – Declarar una variable volátil es una directiva para el compilador. Específicamente, dice al compilador que cargue la variable desde la RAM y no desde un registro de almacenamiento, que es una ubicación de memoria temporal donde se almacenan y manipulan las variables del programa. Bajo ciertas condiciones, el valor de una variable almacenada en registros puede ser inexacto.
  • const – es un cualificador de variable que modifica el comportamiento de la variable haciendo que sea de solo lectura.

Se deben declarar como “volatile” cualquier variable que sea modificada dentro de la función llamada por una interrupción.

Qué es la Programación

Un lenguaje de programación es un lenguaje formal diseñado para realizar procesos que pueden ser llevados a cabo por máquinas como las computadoras.

Pueden usarse para crear programas que controlen el comportamiento físico y lógico de una máquina, para expresar algoritmos con precisión, o como modo de comunicación.

Está formado por un conjunto de símbolos y reglas sintácticas y semánticas que definen su estructura y el significado de sus elementos y expresiones. Al proceso por el cual se escribe, se prueba, se depura, se compila (de ser necesario) y se mantiene el código fuente de un programa informático se le llama programación.

También la palabra programación se define como el proceso de creación de un programa de computadora, mediante la aplicación de procedimientos lógicos, a través de los siguientes pasos:

  • El desarrollo lógico del programa para resolver un problema en particular.
  • Escritura de la lógica del programa empleando un lenguaje de programación específico (codificación del programa).
  • Ensamblaje o compilación del programa hasta convertirlo en lenguaje de máquina.
  • Prueba y depuración del programa.
  • Desarrollo de la documentación.

Existe un error común que trata por sinónimos los términos ‘lenguaje de programación’ y ‘lenguaje informático’. Los lenguajes informáticos engloban a los lenguajes de programación y a otros más, como por ejemplo HTML (lenguaje para el marcado de páginas web que no es propiamente un lenguaje de programación, sino un conjunto de instrucciones que permiten estructurar el contenido de los documentos).

En el caso de Arduino estamos programando un microcontrolador y su comportamiento físico. Programar en general y en Arduino en particular es traducir al lenguaje de programación las acciones que queremos hacer.

Más información: https://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n

Paradigmas de programación

Un paradigma de programación es una propuesta tecnológica adoptada por una comunidad de programadores y desarrolladores cuyo núcleo central es incuestionable en cuanto que únicamente trata de resolver uno o varios problemas claramente delimitados. Un paradigma de programación representa un enfoque particular o filosofía para diseñar soluciones. Los paradigmas difieren unos de otros, en los conceptos y la forma de abstraer los elementos involucrados en un problema, así como en los pasos que integran su solución del problema, en otras palabras, el cómputo.

El paradigma de programación que actualmente es el más utilizado es la “orientación a objetos” (OO). El núcleo central de este paradigma es la unión de datos y procesamiento en una entidad llamada “objeto”, relacionable a su vez con otras entidades “objeto”.

Los paradigmas de programación más comunes son:

  • Programación imperativa o por procedimientos: es el más usado en general, se basa en dar instrucciones al ordenador de como hacer las cosas en forma de algoritmos. La programación imperativa es la más usada y la más antigua, el ejemplo principal es el lenguaje de máquina. Ejemplos de lenguajes puros de este paradigma serían el C, BASIC o Pascal.
  • La programación estructurada es un paradigma de programación orientado a mejorar la claridad, calidad y tiempo de desarrollo de un programa, utilizando únicamente subrutinas y tres estructuras: secuencia, selección (if y switch) e iteración (bucles for y while), considerando innecesario y contraproducente el uso de la instrucción de transferencia incondicional (GOTO), que podría conducir a “código estropajo”, que es mucho más difícil de seguir y de mantener, y era la causa de muchos errores de programación.
  • Programación orientada a objetos: está basada en el imperativo, pero encapsula elementos denominados objetos que incluyen tanto variables como funciones. Está representado por C++, C#, Java o Python entre otros.
  • Programación dirigida por eventos: la programación dirigida por eventos es un paradigma de programación en el que tanto la estructura como la ejecución de los programas van determinados por los sucesos que ocurran en el sistema, definidos por el usuario o que ellos mismos provoquen.
  • Programación multiparadigma: es el uso de dos o más paradigmas dentro de un programa. El lenguaje Lisp se considera multiparadigma. Al igual que Python, que es orientado a objetos, reflexivo, imperativo y funcional

Más información: https://es.wikipedia.org/wiki/Paradigma_de_programaci%C3%B3n

Existen otros paradigmas de programación como:

  • De flujo: ejemplo Node red para IoT
  • De cartas: ejemplo IFTTT https://ifttt.com/
  • De bloques: Scratch o S4A

Lenguajes Compilados vs Interpretados

Un lenguaje compilado es un lenguaje de programación cuyas implementaciones son normalmente compiladores (traductores que generan código de máquina a partir del código fuente) y no intérpretes (ejecutores paso a paso del código fuente, donde no se lleva a cabo una traducción en la preejecución).

Los programas compilados a código nativo en tiempo de compilación tienden a ser más rápidos que los traducidos en tiempo de ejecución, debido a la sobrecarga del proceso de traducción.

Los lenguajes de programación de bajo nivel son típicamente compilados, en especial cuando la eficiencia es la principal preocupación, en lugar de soporte de plataformas cruzadas. Para los lenguajes de bajo nivel, hay más correspondencias uno a uno entre el código programado y las operaciones de hardware realizadas por el código máquina, lo que hace que sea más fácil para los programadores controlar más finamente la CPU y uso de memoria.

Intérprete es un programa informático capaz de analizar y ejecutar otros programas. Los intérpretes se diferencian de los compiladores o de los ensambladores en que mientras estos traducen un programa desde su descripción en un lenguaje de programación al código de máquina del sistema, los intérpretes sólo realizan la traducción a medida que sea necesaria, típicamente, instrucción por instrucción, y normalmente no guardan el resultado de dicha traducción.

Un lenguaje interpretado es un lenguaje de programación para el que la mayoría de sus implementaciones ejecuta las instrucciones directamente, sin una previa compilación del programa a instrucciones en lenguaje máquina. El intérprete ejecuta el programa directamente, traduciendo cada sentencia en una secuencia de una o más subrutinas ya compiladas en código máquina.

Más información:

Presentación del Curso Programación

Objetivos

El objetivo de este curso es que el alumno aprenda los principales conceptos de la programación de Arduino en particular y por extensión los principios y técnicas de programación general que podrían aplicarse a casi cualquier lenguaje de programación.

Dado que las comunicaciones, la conexión a Internet y los dispositivos conectados es otro aspecto importante actualmente y los conceptos de computación y comunicaciones van unidos de la mano cuando hablamos de las TIC (Tecnologías de la Información y de la Comunicación), vamos a tratar también en este curso las comunicaciones y la programación de los dispositivos conectados.

En este curso se programará usando la plataforma Arduino, pero se verán de una forma superficial otros lenguajes de programación como Processing, Python, PHP, javascript y lenguajes de marcas como HTML y XML.

Este curso está diseñado para personas que conocen Arduino y el mundo de los microcontroladores y la electrónica pero no tienen conocimientos o solo básicos de programación.

Requisitos

El único requisito para realizar este curso es conocer la plataforma de hardware libre Arduino y tener conocimientos básicos de electrónica.

Es recomendable un conocimiento medio de Inglés puesto que gran parte de la documentación está en Inglés.

Metodología

El curso se compone de una combinación de teoría y práctica para aprender programación con Arduino, con una duración de 30 horas. También se realizará un proyecto más complejo al final del curso donde se pondrán en práctica los conocimientos y habilidades adquiridas.

Los recursos utilizados para la realización de este curso son:

Además están disponibles otros recursos para ampliar información:

Para interactuar en el curso se puede hacer mediante:

  • Twitter con el hashtag #aprendiendoarduino
  • En el blog poniendo comentarios en los post con la documentación del curso
  • Correo a aprendiendoarduino@gmail.com

Para realizar las prácticas de este curso se incluye un Arduino Starter Kit (https://www.arduino.cc/en/Main/ArduinoStarterKit) que contiene un Arduino Uno, una serie de sensores y actuadores y diversos elementos electrónicos necesarios para realizar las prácticas y proyectos.

Todo el material entregado es en préstamo y debe cuidarse al máximo, a la hora del montaje de las prácticas se seguirán las instrucciones para evitar dañar los componentes.

La documentación está disponible on line con el objetivo de mantenerla actualizada y no como un documento físico que se queda obsoleto al día siguiente. Además la documentación irá creciendo durante el curso y después de finalizar el curso seguirá estando disponible para todos. La documentación principal se encuentra en http://www.aprendiendoarduino.com/.

El repositorio de código del curso y mucho más código está disponible en github en http://github.com/jecrespo y está aumentando continuamente con nuevos ejemplos y prácticas.

Toda la documentación y código es liberado con licencia Creative Commons.

Reconocimiento – NoComercial – CompartirIgual (by-nc-sa): No se permite un uso comercial de la obra original ni de las posibles obras derivadas, la distribución de las cuales se debe hacer con una licencia igual a la que regula la obra original.

Aprendiendo Arduino by Enrique Crespo is licensed under a Creative Commons Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.

Organización del curso

Duración total de 30 horas. El curso se realiza del 3 al 14 de julio de 2017 de Lunes a Viernes en horario de 17.30 a 20.30. Se hará un descanso de 10 minutos aproximadamente a mitad de la sesión antes de empezar con la parte práctica.

Capítulos del curso:

  • Repaso Conceptos Arduino
  • Programación Básica Arduino
  • Librerías Arduino
  • Programación Avanzada Arduino
  • Comunicaciones Arduino
  • Proyectos de Programación

Detalle del temario: http://www.aprendiendoarduino.com/programacion-arduino/

Cada día de curso de compone de 3 partes diferenciadas:

  • Saber más: Al principio de la clase se verán durante 10-15 minutos temas relacionados con Arduino propuestos por los alumnos o que hayan surgido anteriormente.
  • Teoría: Contenidos más teóricos
  • Práctica: Ejercicios prácticos

Los contenidos teóricos y prácticos se irán combinando cada día.

Acerca de Enrique Crespo

El autor del curso es Enrique Crespo. Llevo trabajando con Arduino desde el año 2011 y en el año 2014 empecé mi andadura como profesor de Arduino y otros temas relacionados. Desde entonces he impartido muchos cursos presenciales de Arduino, talleres y conferencias en diversos lugares. También colaboro en el makerspace de la Universidad de la Rioja UR-maker.

Todos los cursos, talleres y conferencias que he impartido puedes verlos en http://www.aprendiendoarduino.com/, donde publico toda la documentación y código.

Twitter @jecrespo: https://twitter.com/jecrespom

Linkedin: https://www.linkedin.com/in/enriquecrespo/

Contacto

Para cualquier consulta durante el curso y en cualquier otro momento mediante email: aprendiendoarduino@gmail.com

Twitter @jecrespo: https://twitter.com/jecrespom

Y más información sobre el curso y el autor: http://www.aprendiendoarduino.com/acerca-de/

Presentaciones

¿Qué experiencia/conocimientos tienes con Arduino?

¿Qué experiencia/conocimientos tienes de programación?

¿Qué lenguajes de programación conoces?

¿Qué experiencia/conocimientos tienes de comunicaciones?

Funciones Definidas por Usuario

En programación, una función es un grupo de instrucciones con un objetivo particular y que se ejecuta al ser llamada desde otra función o procedimiento. Una función puede llamarse múltiples veces e incluso llamarse a sí misma (función recurrente).

Las funciones pueden recibir datos desde afuera al ser llamadas a través de los parámetros y puede entregar un resultado.

Una función tiene un nombre y un conjunto de instrucciones que son ejecutadas cuando se llama a la función. Son funciones setup() y loop() de las que ya se ha hablado anteriormente.

Las funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el tamaño de un programa. Segmentar el código en funciones permite crear piezas de código que hacen una determinada tarea y volver al área del código desde la que han sido llamadas.

Las funciones se declaran asociadas a un tipo de valor. Este valor será el que devolverá la función, por ejemplo ‘int’ se utilizará cuando la función devuelva un dato numérico de tipo entero. Si la función no devuelve ningún valor entonces se colocará delante la palabra “void”, que significa “función vacía”

Sintaxis:

 
tipo nombreFunción (parámetros) {
   instrucciones;
}

Anatomía de una función en C:

Para llamar a una función, simplemente:

 
nombreFunción(parámetros);

Una función que devuelve un valor siempre debe tener la instrucción Return, esta termina una función y devuelve un valor a quien ha llamado a la función: http://arduino.cc/en/Reference/Return

Si se define una función y no ponemos return el valor devuelto es cero. No da error de compilación.

Ventajas del uso de funciones:

  • Ayuda a tener organizado el código.
  • Una función codifica una tarea en un lugar de nuestro sketch, así que la función solo debe ser pensada una sola vez.
  • Reduce la probabilidad de errores al modificar el código.
  • Hacen que el tamaño del sketch sea menor porque el código de la función es reutilizado.
  • Facilita la lectura del código.
  • Hace más sencillo reutilizar código en otros sketches.

Más información: http://arduino.cc/en/Reference/FunctionDeclaration

Funciones Arduino en playground: http://playground.arduino.cc/Code/Function

Nombres de funciones

Generalmente los nombres de las funciones deben ser en minúscula, con las palabras separadas por un guión bajo, aplicándose éstos tanto como sea necesario para mejorar la legibilidad.

“mixedCase” (primera palabra en minúscula) es aceptado únicamente en contextos en donde éste es el estilo predominante con el objetivo de mantener la compatibilidad con versiones anteriores.

En el caso de las clases, los nombres deben utilizar la convención “CapWords” (palabras que comienzan con mayúsculas).

Las funciones en Arduino pueden estar dentro del mismo fichero .ino o en otro fichero con extensión .ino dentro del directorio del sketch principal.

Funciones vs Librerías

Ejemplo de blink usando funciones:

 
void setup() {
  Serial.begin(9600);
  pinMode(13, OUTPUT);
}
 
void loop() {
  digitalWrite(13, HIGH); 
  enciendo();
  delay(1000);  
  digitalWrite(13, LOW);    
  apago();
  delay(1000);  
}
 
void enciendo() {
  Serial.println("Enciendo...");
}
 
void apago(){
  Serial.println("Apago...");
}

Ejemplo de blink usando funciones en ficheros diferentes, fijarse que el IDE de Arduino abre ambos ficheros en dos pestañas diferentes: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio02-Funciones

Ejemplo de blink usando una librería: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio03-Librerias