Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

22/01/2016 #1

Avatar de mecatrodatos

Tutorial y proyectos con Arduino
Corría el año 2005 cuando unos chicos de Italia querían crear una placa electrónica simple para alumnos, más barata y más fácil de usar que los diseños disponibles en ese momento.Y lo nombraron Arduino.
La versión inicial fue voluminosa, complicada para conectar, y carecía de USB, y otras características se encuentran comúnmente en estos días. Ahora, Arduino es famoso por su simplicidad y facilidad de uso. Los niños están construyendo proyectos con Arduino que solamente hace 10 años habría requerido de ingenieros.

Todo el diseño es de código abierto y los clones de la placa se pueden encontrar en todas partes del mundo. No hay un número conocido de placas Arduino pero es en el rango de cientos de miles o incluso más. Todo el mundo puede diseñar su propia implementación personalizada. Hoy en día, Arduino se usa en todos los rincones del planeta, e incluso ha impulsado otras revoluciones, con el código abierto el desarrollo y fabricación de impresión en 3D.

Pero, ¿Qué es Arduino?

Arduino es una placa electrónica, diseñada para conectar a la electrónica y realizar control.
Podemos escribir código para el Arduino que recibirá los datos del medio ambiente, y hacer decisiones y realizar acciones basadas en los datos. Robots, impresoras 3D, juguetes e incluso drones.

Este tutorial contiene proyectos que muestran cómo implementar los temas clave del Arduino, comenzando con la interacción básica con botones y LEDs, y escalonando a la interacción con el Sistema de Posicionamiento (GPS), hacer música, o comunicarse con Internet. Se pretende este espacio para los amantes de programación o electrónica que quieren combinar lo mejor de ambos mundos para construir proyectos interactivos y funcionales a la vanguardia con la tecnología y entorno Android.

La descarga del software de Arduino

Lo primero que necesitamos es el Arduino entorno de desarrollo integrado (IDE). Una de las mejores partes de Arduino es que el software en el que tenemos que programar las tarjetas es de código libre y abierto. El Arduino IDE es compatible con Windows, Mac OS X y Linux.

Sólo necesitamos una cosa para completar esta paso un ordenador conectado a Internet.

Cómo hacerlo…

Siga estos sencillos pasos:

1. Visite el sitio web de Arduino en http://arduino.cc/.
2. En el menú principal, vaya a la sección de descargas.
3. Seleccione su sistema operativo y descargar la última versión estable del Software de Arduino.
4. Una vez realizada la descarga, instale el software de Arduino.


NUESTRO PRIMER PROGRAMA EN ARDUINO

PREPARAR LA CONEXIÓN

En primer lugar, conectamos nuestra placa Arduino mediante un cable USB A-B, del tipo que se emplean habitualmente para conectar impresoras. Abrimos el entorno IDE de Arduino seleccionamos el modelo de placa que estemos empleando, seleccionamos el puerto de comunicación al que está conectado. Ya tenemos la conexión configurada y lista para realizar la carga de nuestro primer programa.

Fundamentos Código C - Arduino


El Arduino utiliza un lenguaje de programación C /C / ++. En este tutorial, vamos a recordar algunos conceptos básicos de C / C ++. Un buen libro de referencia para C: http://es.wikipedia.org/wiki/El_leng...amaci%C3%B3n_C.


Aquí está un ejemplo simple de básica Arduino C / C ++ manipulación de dos variables:
Código PHP:
// Variables globales
int var1 10;
int var2 20;
void setup () {
// Sólo ejecutar una vez cuando se inicia el Arduino
var2 5// Var2 se convierte en 5 una vez que las botas de Arduino
}
void loop () {
// Código ejecuta de arriba hacia abajo y repite continuamente
if (var1 var2) {// Si var1 es mayor que var2
var2 ++; // Incremento var2 por 1

else {
// Si var1 no es mayor que var2
var2 0// Var2 se convierte en 0
}

El código juega con dos variables enteras. Aquí tenemos un desglose del código para explicar mejor cada paso.

En primer lugar, declaramos de dos variables var1 y var2-y les asignamos los valores de 10 y 20 respectivamente.

Código:
// Variables globales

int var1 = 10;
int var2 = 20;
Cuando arranca el Arduino, primero asigna las variables globales en la memoria.
En la función setup (), cambiamos el valor de var2 a 5:

Código:
void setup () {
// Sólo ejecutar una vez cuando se inicia el Arduino
var2 = 5; // Var2 se convierte en 5 una vez que las botas de Arduino
}
Después Arduino asigna las variables globales, ejecuta el código dentro de la función setup () una vez.
Después de esto, la función loop () se ejecutará en varias ocasiones.
En el interior, tenemos una condición que jugará con los valores de var2.
Si var1 es mayor que var2, aumentamos var2 por uno.
Finalmente, var1 no será mayor que var2, y luego establece var2 a 0.
Esto dará lugar a la adición de un infinito e igualando de var2.
Este es un ejemplo de cómo el Arduino ejecuta el código en sus dos funciones principales.
22/01/2016 #2

Avatar de Juan Tamarit

Muy bien explicado. Aunque tengo la siguiente consulta:

¿Cuál es el sentido de asignar 20 a var2 en el comienzo del programa si luego va a ser reasignada a 5 en la función "setup"?

¿No resulta innecesario y podría solo declararse var1 al principio y que var2 se declare en el "setup"?

Es decir: al declarar o modificar una variable en el setup ¿no permanece ésta registrada en el programa? ¿Es necesario declararla antes y, de ser así, es necesario declararle algún valor?

Muchas gracias por tu post
23/01/2016 #3

Avatar de TRILO-BYTE

es como hacer esto

unsigned char numero=10;

void main()
{
numero =0;
}

¿que hise?

nada solo me comi unas instrucciones en la ROM jaja

es un error que muchos cometen a la hora de programar.
24/01/2016 #4

Avatar de J2C

.



Pues todo muy lindo, pero nos estamos yendo en palabras y apreciaciones personales y solo el ejemplo inicial que subio Mecatrodatos.

A mi entender lo mejor seria subir mas ejemplos aunque no funcionen y en "forma colaborativa" tratar de ir salvando los problemas para que el mismo sea 100% funcional.




Recuerdo haberlo leído apenas lo subio y recomendado que lo colocaran en este F47 cosa que se encargo de realizar D@rkbytes y borro mi comentario totalmente Off Topic .




Saludos, JuanKa.-
24/01/2016 #5

Avatar de mecatrodatos

Fundamentos Código - pines de Arduino

La característica más importante de la Arduino es su control sobre la entrada / salida digital (I / O) de sus pines.

En cada pin, podemos establecer un valor de tensión de 5 V, lo que representa lógica ALTA, o 0 V, lo que representa lógico bajo. También, podemos leer si un valor de 5 V o 0 V se aplica externamente.

Aquí vamos a aprender cómo.


Para esta práctica, asegúrese de que tiene el Arduino IDE ejecutado en un ordenador.

Cómo hacerlo…

El siguiente código convierte un pin en Alto y Bajo lógico en repetidas ocasiones durante la lectura de la tensión externa aplicado a otro:

Código:
void setup() {
// Establecer el pin 2 como salida digital
pinMode(2, OUTPUT);
// Establecer el pin 3 como entrada digital
pinMode(3, INPUT);
}
void loop(){
//Establecer  pin 2 en Alto logico
digitalWrite(2, HIGH);
// Espera 100 milisegundos
delay(100);
// Establecer  pin 2 en Bajo logico
digitalWrite(2, LOW);
// Espera 100 milisegundos
delay(100);
// Leer el valor del pin 3 y almacenarlo en una variable
int pinValue = digitalRead(3);
}
Cómo funciona…

El código establece la configuración de dos pines y el modo de entrada de ellos.

Aquí está el desglose del código:

En setup (), se utiliza la función pinMode () para establecer pin número 2 como una salida. Cuando nosotros configurar un pin como salida, podemos establecer que el pin ya sea como Alto (5 V) o bajo (0 V). Adicional, hemos establecido el pin número 3 como entrada. Un pin configurado como entrada puede leer tensiones externas aplicadas a la misma. El pin puede leer ALTO si la tensión es de alrededor de 5 V y BAJO si la tensión está cerca o igual a 0 V:

void setup () {
// Establecer el pin 2 como salida digital
pinMode (2, OUTPUT);
// Establecer el pin 3 como entrada digital
pinMode (3, INPUT);
}
En la función loop (), se utiliza la función digitalWrite () para establecer el pin número 2 en ALTO. Entonces, esperamos a 100 milisegundos mediante la función delay (). Esta función detiene la ejecución del código durante el tiempo especificado, en milisegundos. Después de eso, establece el pin en BAJO y espera otros 100 milisegundos. Al final, se lee el valor del pin 3 en una variable:

Código:
void loop () {
// Establecer pin 2 ALTO
digitalWrite (2, HIGH);
// Espera 100 milisegundos
delay (100);
// Establecer el pin 2 BAJO
digitalWrite (2, LOW);
// Espera 100 milisegundos
delay(100);
// Leer el valor del pin 3 y almacenarlo en una variable
int pinValue = digitalRead (3);
}
25/01/2016 #6

Avatar de mecatrodatos

Uso de Arduino

Problema:
¿Quieres empezar con un proyecto que es fácil de construir y divertido de usar.

Solución:
Este proyecto ofrece una muestra de algunas de las técnicas que se tratan en detalle en las secciones del tutorial.

El circuito se basa en el código intermitente LED de la anterior entrada, pero en vez de estar utilizando un retardo fijo, la tasa se determina por un sensor sensible a la luz llamado LDR .

Código:
const int ledPin = 13; // Asigna LED a pin digital 13
const int sensorPin = 0; // connectar sensor a entrada analogico pin  0
void setup()
{
pinMode(ledPin, OUTPUT); // Habilitar salida pin LED
}
void loop()
{
int rate = analogRead(sensorPin); // leer entrada analogica
digitalWrite(ledPin, HIGH); //  LED on
delay(rate); // Esperar duración dependiendo del nivel de luz
digitalWrite(ledPin, LOW); //  LED off
delay(rate);
}
Explicación:

El valor de la resistencia de 4.7K no es crítico. Cualquier desde 1K a 10K puede ser utilizada. El nivel de luz en la LDR cambiará el nivel de tensión en el pin analógico 0. El comando analogRead proporciona un valor que oscila entre alrededor de 200, cuando el LDR es oscuro a 800 o así que cuando es muy brillante. Este valor determina la duración de la LED de encendido y apagado, por lo que el tiempo de parpadeo aumenta con la intensidad de la luz.

Puede escalar la velocidad de parpadeo mediante la función de Map de Arduino de la siguiente manera:
Código:
const int ledPin = 13; // conectar LED em pin digital numero 13
const int sensorPin = 0; // conectar sensor a entrada analogica numero 0
// las dos líneas siguientes establecen el mínimo y el retardo máximo entre parpadeos
const int minDuration = 100; //espera mínimo entre parpadeos
const int maxDuration = 1000; // espera maxima entre parpadeos
void setup()
{
pinMode(ledPin, OUTPUT); // Habilitar pin led como entrada
}
void loop()
{
int rate = analogRead(sensorPin); // Leer entrada analogica
// la línea siguiente escala la frecuencia de parpadeo entre los valores mínimos y máximos
rate = map(rate, 200,800,minDuration, maxDuration); // convertir tasa de parpadeo
rate = constrain(rate, minDuration,maxDuration); // limitar el valor
digitalWrite(ledPin, HIGH); // establecer el LED en ON
delay(rate); // espere duración depende del nivel de luz
digitalWrite(ledPin, LOW); // establecer el LED en OFF
delay(rate);
}
La función delay() es un comando de retardo, que no hace otra cosa que incrementar milisegundos que asignamos entre los paréntesis.

En los ejercicios anteriores vimos el ejemplo más sencillo que se encuentra en la carpeta de Arduino en la sección de ejemplos, que consiste que un LED prenda y apague en los intervalos de tiempo con la función delay().

En la función de retardo, Arduino lo que hace es contar los milisegundos. En un proyecto sencillo como el del ejercicio de apertura de este tutorial no hay problema en tener al microcontrolador ocupado en la tarea de contar milisegundos, pero en desarrollos complejos no es permitido, ya nuestro Arduino tiene que ocuparse de otras tareas.

Por esta razón podemos recurrir a otra función millis() de Arduino para controlar el tiempo que está encendido el LED mientras el microcontrolador queda libre para hacer otras cosas. En otros entornos de programación hay otras alternativas aplicables a nuestros criterios y necesidades.
31/01/2016 #7

Avatar de mecatrodatos

Arduino usa un pequeño micro-controlador, que ejecuta un programa a la vez, pero puede hacer tareas simultáneamente. Vamos a desear que Arduino realice programas perceptibles a nosotros (como en el caso, del parpadeo de un led), Mientras la placa Arduino está ejecutando un delay no se pueden, leer eventos ejemplo sensores.

Recuerdas el código de Blink?

Código:
 /*
int led = 13;
 
void setup()
{                
  pinMode(led, OUTPUT);     
}
 
void loop() {
  digitalWrite(led, HIGH);
  delay(500);
  digitalWrite(led, LOW);
  delay(500);
}
¿Por qué no al delay?

A pesar de que es lo primero que aprendimos a programar con Arduino y es muy sencillo, resulta que congela el procesador por completo y no hará más tareas hasta pasado el delay. Cuando tenemos un código de varias líneas que contiene una instrucción delay para esperar a que pase un tiempo determinado nos encontramos que Arduino está inoperativo la mayor parte del tiempo y tiene que estar esperando el resto del tiempo sin capacidad de responder a ninguno de los eventos que suceden a su alrededor. Este ejemplo de Aduino se la pasa casi todo el tiempo en la función delay, Por ese motivo vamos controlar el tiempo que está encendido el LED sin recurrir a la función delay() .

Código:
/* Parpadeo sin delay()
Enciende y apaga un LED conectado a un pin digital sin utilizar la función delay(). Esto significa que otro código se puede ejecutar al mismo tiempo sin ser interrumpido por el código que controla el parpadeo del LED
Circuito: Un LED conectado entre el pin 13 y el pin GND.
Nota: en muchos Arduinos hay un LED en la placa conectado al pin 13, por lo que no sería necesario un LED externo para este ejemplo.*/

// Las constantes no cambian. Las usamos aquí para establecer los números de los pines.
int ledPin = 13;   // el número del pin conectado al LED

//  variables que cambiarán de valor.
int ledState = LOW;   // ledState se usará para establecer el estado del LED

long previousMillis = 0;   // almacenará la última vez que el estado del LED
//se actualizó

// La siguiente variable es del tipo long porque el tiempo medido en
// milisegundos supera rápidamente al número que puede ser almacenado en una
// variable del tipo int
long interval = 1000;   // intervalo del parpadeo (en milisegundos)

void setup() 
{
// establece el pin digital como salida:
pinMode(ledPin, OUTPUT);
}

void loop()
{
// Aquí es donde se consigna el código que debe ejecutarse 

// Se comprobará si es el momento de parpadear el LED, esto es, si la
// diferencia entre el tiempo transcurrido y el tiempo en que parpadeó
// por última vez el LED es mayor que el intervalo que establecimos en
// la declaración de variables.

unsigned long currentMillis = millis();    // Se toma el tiempo actual

// se comprueba si el tiempo actual menos el tiempo en que el LED cambió
// de estado por última vez es mayor que el intervalo.
if (currentMillis - previousMillis > interval){

// Si se cumple la condición se guarda el nuevo tiempo
// en el que el LED cambia de estado
previousMillis = currentMillis;

// Y ahora cambiamos de estado el LED, si está encendido a
// apagado o viceversa.
if (ledState == LOW)
ledState = HIGH;
else
ledState = LOW;

// Hacemos que el contenido de la variable llegue al LED
digitalWrite(ledPin, ledState);
}
}
Por defecto, Arduino utiliza el timer0 para las funciones de tiempo por el software báse: delay(), millis() y micros(). El timer1 lo utiliza la librería servo. Y el timer2 lo utiliza la función tone().
La función millis() nos devuelve el tiempo en milisegundos transcurridos desde que trabaja la placa Arduino con el programa actual. Esta función establece un unsigned long, es decir un número de 32 bits. Puesto que la función millis() cuenta milisegundos, la precisión es suficiente para la mayoría de los proyectos habituales. Si necesitamos más precisión recurriremos a la función micros ().

Algunos dirán es un código demasiado complicado para una tarea tan sencilla de parpadeo de un LED. Es un código complejo, pero eficiente. Si deseas que tu placa de Arduino no se quede al hacer tareas. Aquí hay un código multitarea que nos abre el camino a la programación Orientada a Objetos

Código:
//No se requiere nada adicional para poder ejecutar este código en tu Arduino 

int ledPin1 = 13; // LED VERDE
int ledState1 = HIGH; // Inicialmente está apagado
unsigned long previousMillis1 = 0; //Sera el que almacene en que ms fue la última vez que se encendió o apago
long OnTime1 = 300; //Tiempo que el led VERDE permanecerá encendido
long OffTime1 = 800; // Tiempo que el led VERDE permanecerá apagado

int ledPin2 = 14; // LED AZUL
int ledState2 = HIGH; // Inicialmente está apagado
unsigned long previousMillis2 = 0; //Sera el que diga en que ms fue la última vez que se encendio o apago
long OnTime2 = 250; //Tiempo que el led AZUL permanecerá encendido
long OffTime2 = 500; //Tiempo que el led AZUL permanecerá apagado

void setup()
{
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
}
void loop()
{
  //Revisa si es momento de apagar el LED
  unsigned long currentMillis = millis();
  if((ledState1 == LOW) && (currentMillis - previousMillis1 >= OnTime1)) //Si el LED VERDE esta prendido y la última vez que se encendió fue hace más de 300 ms entonces vamos a apagarlo!
  {
    ledState1 = HIGH; // Cambia el valor de la variable para luego escribirla
    previousMillis1 = currentMillis; // "La última vez fue AHORA"
    digitalWrite(ledPin1, ledState1); // Hace efectivo el cambio en el LED
  }
  else if ((ledState1 == HIGH) && (currentMillis - previousMillis1 >= OffTime1))
  {
    ledState1 = LOW;
    previousMillis1 = currentMillis;
    digitalWrite(ledPin1, ledState1);
  }
  
  
  if((ledState2 == HIGH) && (currentMillis - previousMillis2 >= OnTime2))
  {
    ledState2 = LOW;
    previousMillis2 = currentMillis;
    digitalWrite(ledPin2, ledState2);
  }
  else if ((ledState2 == LOW) && (currentMillis - previousMillis2 >= OffTime2)) //Si el LED AZUL está apagado y la última vez que se apago fue hace más de 500 ms entonces vamos a prenderlo!
  {
    ledState2 = HIGH; // Cambia el valor de la variable para luego escribirla
    previousMillis2 = currentMillis; // "La última vez fue AHORA"
    digitalWrite(ledPin2, ledState2); // Hace efectivo el cambio en el LED
  }
}
29/09/2016 #8

Avatar de Scooter

Cuidado con milis, cuando desborde hará una temporización rara.
Respuesta
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Buscar más temas sobre:
Lupa Arduino y Raspberry Pi

Cerrar
Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.