Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Make your likes visible on Facebook?

Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.

No, thanks

Programación para Arduino - Clase 5

No description
by

Laura Molina

on 22 May 2014

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Programación para Arduino - Clase 5

Modularización
Hasta ahora podíamos resolver problemas pequeños sin problemas, pero los problemas reales son complejos, extensos y casi siempre requieren modificaciones.
La programación modular es una de las técnicas fundamentales a la hora de resolver problemas complejos.

Modularizar
significa dividir un problema en problemas más simples y resolver éstos con módulos
independientes. Las soluciones de los sub-problemas pueden combinarse para resolver el problema original.

Cuando una tarea debe realizarse más de una vez en un mismo programa, la modularización evita la programación redundante, ya que una vez definida la tarea como un módulo independiente, puede ser invocada desde cualquier parte del código; se aprecia también una menor longitud del programa.

De lo general a lo particular:
dividir, resolver y conectar

Modularización
Módulo: Es un conjunto de instrucciones que cumplen una tarea específica bien definida. Puede devolver ninguno, uno o más valores.

Modularización
Los módulos se clasifican en
funciones
y
procedimientos

Las
funciones
son un conjunto de instrucciones que luego de ser ejecutadas, retornan un valor.
La sintaxis es la siguiente:

tipo_retorno nombre_función (parámetros )
{
instruccion1;
instruccion2;
.....
instrucciónN;
return

valor;
}
tipo_retorno:
puede ser cualquier tipo de dato conocido: int, char, byte, long, float.
nombre_función
:
es el nombre que describe la tarea que realiza el módulo, puede ser cualquiera pero mejor recordemos las reglas mnemotécnicas.
parámetros :
son los datos que entran y/o salen del módulo para comunicarse con el programa principal o con otros módulos.
return :
es la palabra clave que indica que variable va a devolver la función, esta debe coincidir con el tipo_de_retorno de la declaración. Cuando se ejecuta esta instrucción, finaliza la función y vuelve al modulo que la llamó, ignorando todo código que se encontraba dentro de la función luego del return.

int multiplicar(int i, int r) {

int valor = i*r;

return
valor;
valor = 5;
}

Modularización
Los procedimientos son conjuntos de instrucciones que realizan una tarea pero no retornan ningún valor. La sintaxis es idéntica, pero tipo_retorno es
void
, y la palabra
return
no se utiliza. Para invocar a un procedimiento, sólo escribimos su nombre, no es posible asignarlo como valor de una variable.

void
contar
(int cantidad)
{
for(int i = 1 ; i <= cantidad ; i++) {
Serial.println(i);
}
}

void
loop
()
{
int valor = multiplicar(3,2);
Serial.println(contar(valor));
}

void
loop
()
{
contar(multiplicar(3,2));
}

Programación para Arduino - Clase 5
Comunicación entre módulos
Parámetros: indican de manera explicita qué datos utilizará el modulo.
Pueden ser de entrada como de salida, solo utilizaremos parámetros de Entrada.
Los parámetros de entrada realizan una una copia de la variable, uno puede trabajar con la variable dentro del modulo pero no modificará la variable original, cuando termina la función la copia de la variable se destruye.
La cantidad de parámetros y el tipo de cada uno de ellos utilizados en la invocación debe coincidir en cantidad y tipo con los parámetros de la declaración del modulo.

Por ejemplo, si tenemos el procedimiento:

void procEjemplo (char letra, int numero) {
.....
}
procEjemplo (3,’R’); (no coincide la invocación con la definición)
procEjemplo ('R',3) (invocación correcta)



Como un módulo resuelve un problema lo mas independiente posible, puede reutilizarse para abarcar otro problema que lo requiera.
Es fácil mantenerlo, si tenemos algún error sabremos dónde encontrarlo y así repararlo rápidamente.
Con el tiempo, el programa puede crecer. La modularización permite disminuir el riesgo y agregar fácilmente nueva funcionalidad sin modificar el programa entero.
Permite leer y comprender con mayor claridad el código. Si el nombre del módulo fuera lo suficientemente descriptivo, no necesitaríamos saber como funciona para entender código de terceros.

Por ejemplo, se puede tener un módulo que se encargue de calcular el factorial de un número:
int resultado = factorial(12);


Interrupciones
Si quisiéramos asegurarnos de que una aplicación siempre capture las lecturas de un sensor, sin perder nunca un pulso, sería muy complicado escribir un programa que además, pueda realizar muchas más acciones, puesto que debería estar constantemente consultando las líneas del sensor, de forma que capture los pulsos cuando tienen lugar y no cuando el programa pueda medirlos.
Si estamos usando un teclado, por ejemplo, desconocemos en que momento serán presionadas las teclas y no podemos hacer que Arduino decida cuando leer.

Interrupciones
Ejemplo : uno esta muy cómodamente en su casa mirando televisión y de repente suena el timbre;
La actividad principal (mirar televisión) se ve interrumpida por una llamada externa, uno decide qué hacer ante esa interrupción.
Atiende el timbre, y cuando termina, vuelve a mirar televisión.

Actividad principal:
Mirar televisión
Quién interrumpe?
El timbre
Cuándo interrumpe?
Cuando el timbre suena
Cómo responde uno?
Atiende el timbre y pregunta quién es.

En Arduino es exactamente igual:

Actividad principal
: Programa en ejecución
Quién interrumpe?
Alguno de los pines de interrupciones.
Cuándo interrumpe?
hay cinco modos :
LOW; HIGH; CHANGE; RISING; FALLING;
Cómo responde Arduino?
Ejecuta la función declarada por nosotros para esa interrupción

Interrupciones
attachInterrupt(pin_interrupcion, función, modo);

Asocia una interrupción con : quién interrumpe,(pin); cómo responde ; cuando interrumpe .
La función que maneje la interrupción es del tipo de retorno
void
y no puede recibir parámetros. Tambien se la llama rutina de servicio de interrupción (ISR)
Todas las variables que modifique la ISR deben declararse como global

Dentro de la ISR
· no funciona delay()
· millis() no incrementa
· Serial puede perder datos.

Detección por estado bajo o
LOW

Detección por cambio de estado o
CHANGE

Detección por flanco ascendente o
RISING

Detección por flanco descendente o
FALLING



Interrupciones: ejemplo
Encender un led cuando se presione un pulsador
Sin interrupciones:
int pbIn = 2;
int ledOut = 4;

void setup(){
pinMode(pbIn, INPUT);
pinMode(ledOut, OUTPUT);
}

void loop(){
state = digitalRead(pbIn); //Leer el botón
digitalWrite(ledOut, state); //escribir el LED
//Simulando una ejecución larga y compleja
for (int i = 0; i < 100; i++) {
.....
delay(10);
}
}

Con interrupciones:
int pbIn = 0; // Interrupcion 0 está en PIN 2
int ledOut = 4; // LED pin
volatile int state = LOW;

void setup(){
pinMode(ledOut, OUTPUT);
attachInterrupt(pbIn, stateChange, CHANGE);
}
void loop(){
for (int i = 0; i < 100; i++) {
......
delay(10);
}
}

void stateChange(){
state = !state;
digitalWrite(ledOut, state);
}

Comunicación de Arduino con otros Sistemas
La forma más sencilla que tiene Arduino para comunicarse con otros dispositivos electrónicos es la comunicación Serial. A través de este tipo de comunicación podremos enviar datos a y desde Arduino a otros microcontroladores o a una computadora corriendo alguna software (Processing, PD, Flash, VVVV, etc.).
El protocolo consiste en transmitir información bit a bit, a un ritmo o frecuencia acordada entre los dos dispositivos.
La comunicación serial puede hacerse a través de los pines digitales 0 (RX) y 1 (TX) o mediante USB. Cuando se utiliza la comunicación serial, no se pueden usar los pines 0 y 1 como entrada o salida digital.
Comunicación Serial
La herramienta más básica de la Comunicación Serial es el Monitor Serial. que nos permite visualizar datos en pantalla a través del puerto Serie.

int analogValue = 0;

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

void loop() {
analogValue = analogRead(0);

Serial.println(analogValue);
delay(10);
}
int potPin = 2;
int val = 0;

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

void loop()
{
// lee el Pote y lo divide entre 4 para quedar entre 0-255
val = analogRead(potPin)/4;
Serial.write(val, BYTE);
}
Recepción de datos
Para obtener los datos enviados desde otro
procesador por puerto Serie, se usa la función
read().
int incomingByte = 0; // para el byte leido

void setup() {

Serial.begin(9600)
; // abre el puerto serie a 9600 bps
}

void loop() {
if (
Serial.available()
> 0) {
incomingByte =
Serial.read()
;

Serial.print
("He recibido: ");

Serial.println
(incomingByte, DEC);
}

import processing.serial.*;

Serial puerto; // Variable para el puerto serial
byte pote; // valor entrante
int PosX;

void setup(){
size(400, 256);
println(Serial.list()); /
port = new Serial(this, Serial.list()[0], 9600);
fill(255,255,0);
PosX = 0;
pote = 0;
}

void draw() {
if(puerto.available() > 0) {
pote = puerto.read();
.......
}
}

Ejemplo de Comunicación con Processing
Arduino:
Processing:
Envío de datos
Para enviar datos hacia otro procesador, tenemos la función
write()
(escribe datos binarios) o
print()
(escribe en ASCII)
Serial.write(val)
Serial.write(str)
Serial.write(buf, len)

val: un valor para enviar como un solo byte

str: una cadena 'string' para enviar como una serie de bytes

buf: un 'array' para enviar como una serie de bytes

len: longitud del búfer
Serial.print(data, DEC); // decimal
Serial.print(data, HEX); // hexadecimal
Serial.print(data, OCT); // octal
Serial.print(data, BIN); // binario
Serial.print(data, BYTE); // un Byte

Sintaxis write()
Sintaxis print()
Full transcript