const int Trigger = 2; //Pin digital 2 para el Trigger del sensor const int Echo = 3; //Pin digital 3 para el Echo del sensor void setup() { Serial.begin(9600);//iniciailzamos la comunicación pinMode(Trigger, OUTPUT); //pin como salida pinMode(Echo, INPUT); //pin como entrada digitalWrite(Trigger, LOW);//Inicializamos el pin con 0 } void loop() { long t; //timepo que demora en llegar el eco long d; //distancia en centimetros digitalWrite(Trigger, HIGH); delayMicroseconds(10); //Enviamos un pulso de 10us digitalWrite(Trigger, LOW); t = pulseIn(Echo, HIGH); //obtenemos el ancho del pulso d = t/59; //escalamos el tiempo a una distancia en cm Serial.print("Distancia: "); Serial.print(d); //Enviamos serialmente el valor de la distancia Serial.print("cm"); Serial.println(); delay(100); //Hacemos una pausa de 100ms }
MAKERS GROUP ROBOTICS
Todo y de todo sobre robótica, programación, impresión 3D, diseño 3D, y lo que se nos pase por la cabeza.
viernes, 4 de mayo de 2018
Programa para pruebas ultrasonido sin librerías
martes, 30 de enero de 2018
Moviendo un motor paso a paso bipolar.
Este es el programa más simple para mover un motor bipolar. Lo único que hace es girar en un sentido de forma indefinida. Sirva de punto de partida para vuestros programas.
#define Motor_Pin1 8
#define Motor_Pin2 9
#define Motor_Pin3 10
#define Motor_Pin4 11
int tiempo = 5;
void setup()
{
pinMode(Motor_Pin1, OUTPUT);
pinMode(Motor_Pin2, OUTPUT);
pinMode(Motor_Pin3, OUTPUT);
pinMode(Motor_Pin4, OUTPUT);
}
void loop()
{
digitalWrite(Motor_Pin1, HIGH);
digitalWrite(Motor_Pin2, LOW);
digitalWrite(Motor_Pin3, LOW);
digitalWrite(Motor_Pin4, LOW);
delay (tiempo);
digitalWrite(Motor_Pin1, LOW);
digitalWrite(Motor_Pin2, HIGH);
digitalWrite(Motor_Pin3, LOW);
digitalWrite(Motor_Pin4, LOW);
delay (tiempo);
digitalWrite(Motor_Pin1, LOW);
digitalWrite(Motor_Pin2, LOW);
digitalWrite(Motor_Pin3, HIGH);
digitalWrite(Motor_Pin4, LOW);
delay (tiempo);
digitalWrite(Motor_Pin1, LOW);
digitalWrite(Motor_Pin2, LOW);
digitalWrite(Motor_Pin3, LOW);
digitalWrite(Motor_Pin4, HIGH);
delay (tiempo);
}
Ánimo, y a ver si este programa de 5 pelado, se convierte en un programa de 10.
Este otro programa, lo he hecho para aunar todas las técnicas para alimentar un motor bipolar, en el que podemos cambiar los parámetros, para variar la velocidad, el par, los pasos, etc....
Como siempre, le he quitado los comentarios, para que penseis, y penseis, y penseis..... y como podeis ver, poco código para hacer más que el programa anterior.
#define Motor_Pin1 8
#define Motor_Pin2 9
#define Motor_Pin3 10
#define Motor_Pin4 11
/*****************************************************************************************************************
************************************** parametrización del motor ************************************************
*****************************************************************************************************************/
#define pasospv 4096 //Pasos por vuelta del reductor
#define vueltas 1 //Número de vueltas que queremos que de el motor
#define tipo_pasos 4 //Paso completo (4) o medio paso (8)
#define par_motor 0 //Bajo par (0) Alto par (1)
float delayTime = 8; //Segundos por vuelta. Tiempo mínimo 5 segundos.
/*****************************************************************************************************************/
bool paso[8][4]= {{1,0,0,0},
{1,1,0,0},
{0,1,0,0},
{0,1,1,0},
{0,0,1,0},
{0,0,1,1},
{0,0,0,1},
{1,0,0,1}};
void setup()
{
for (int i = 0; i <= 3; i++){
pinMode(i+8,OUTPUT);
}
delayTime = ((((delayTime * 1000)/4096)*(8/tipo_pasos))*1000);
}
void loop()
{
for (int k = 0; k < ((pasospv/8)*vueltas); k ++){
for (int i = par_motor; i < 8; i = i + (8/tipo_pasos)){
for (int j = 0; j < 4; j ++){
digitalWrite(j+8, paso[i][j]);
}
delayMicroseconds (abs (delayTime));
}
}
delay (2000);
}
#define Motor_Pin1 8
#define Motor_Pin2 9
#define Motor_Pin3 10
#define Motor_Pin4 11
int tiempo = 5;
void setup()
{
pinMode(Motor_Pin1, OUTPUT);
pinMode(Motor_Pin2, OUTPUT);
pinMode(Motor_Pin3, OUTPUT);
pinMode(Motor_Pin4, OUTPUT);
}
void loop()
{
digitalWrite(Motor_Pin1, HIGH);
digitalWrite(Motor_Pin2, LOW);
digitalWrite(Motor_Pin3, LOW);
digitalWrite(Motor_Pin4, LOW);
delay (tiempo);
digitalWrite(Motor_Pin1, LOW);
digitalWrite(Motor_Pin2, HIGH);
digitalWrite(Motor_Pin3, LOW);
digitalWrite(Motor_Pin4, LOW);
delay (tiempo);
digitalWrite(Motor_Pin1, LOW);
digitalWrite(Motor_Pin2, LOW);
digitalWrite(Motor_Pin3, HIGH);
digitalWrite(Motor_Pin4, LOW);
delay (tiempo);
digitalWrite(Motor_Pin1, LOW);
digitalWrite(Motor_Pin2, LOW);
digitalWrite(Motor_Pin3, LOW);
digitalWrite(Motor_Pin4, HIGH);
delay (tiempo);
}
Ánimo, y a ver si este programa de 5 pelado, se convierte en un programa de 10.
Este otro programa, lo he hecho para aunar todas las técnicas para alimentar un motor bipolar, en el que podemos cambiar los parámetros, para variar la velocidad, el par, los pasos, etc....
Como siempre, le he quitado los comentarios, para que penseis, y penseis, y penseis..... y como podeis ver, poco código para hacer más que el programa anterior.
#define Motor_Pin1 8
#define Motor_Pin2 9
#define Motor_Pin3 10
#define Motor_Pin4 11
/*****************************************************************************************************************
************************************** parametrización del motor ************************************************
*****************************************************************************************************************/
#define pasospv 4096 //Pasos por vuelta del reductor
#define vueltas 1 //Número de vueltas que queremos que de el motor
#define tipo_pasos 4 //Paso completo (4) o medio paso (8)
#define par_motor 0 //Bajo par (0) Alto par (1)
float delayTime = 8; //Segundos por vuelta. Tiempo mínimo 5 segundos.
/*****************************************************************************************************************/
bool paso[8][4]= {{1,0,0,0},
{1,1,0,0},
{0,1,0,0},
{0,1,1,0},
{0,0,1,0},
{0,0,1,1},
{0,0,0,1},
{1,0,0,1}};
void setup()
{
for (int i = 0; i <= 3; i++){
pinMode(i+8,OUTPUT);
}
delayTime = ((((delayTime * 1000)/4096)*(8/tipo_pasos))*1000);
}
void loop()
{
for (int k = 0; k < ((pasospv/8)*vueltas); k ++){
for (int i = par_motor; i < 8; i = i + (8/tipo_pasos)){
for (int j = 0; j < 4; j ++){
digitalWrite(j+8, paso[i][j]);
}
delayMicroseconds (abs (delayTime));
}
}
delay (2000);
}
sábado, 20 de enero de 2018
TRABAJANDO CON ARRAYS
El código que adjunto más abajo está sin comentarios, pero ha sido explicado en clase, por lo que no estaría mal que ahora lo explicaseis vosotros.
El código compila perfectamente, por lo que con un copiar pegar lo podeis meter en vuestro IDE, y hacer pruebas, cambios, y todo lo que haga falta para comprenderlo mejor.
Y como no, un poco de tarea fácil. Este programa introduce los números del 1 al 10 en un array, empecemos por cambiar eso, y ahora meterá las decenas hasta el 100 (10,20,30.....100) y seguidamente, sorpresa, no los sumaremos, los invertiremos dentro del array, se me acaba de ocurrir, y cuando digo que los invertiremos digo eso, invertirlos, del 100 al 10, y no pido repetir el algoritmo invertido, no, eso sería muy fácil, me interesa más que el programa invierta el contenido del array, haya lo que haya dentro del array. Intentemos no utilizar demasiada memoria, variables, y código. Seguro que se nos ocurre un algoritmo interesante.
Si veo que sale fácil, cosa que estoy seguro, a mitad de semana igual se me ocurre algo nuevo.
______________________________________________________________________
/* SUMA DE NUMEROS DE UN ARRAY */
int count=0;
int NUMEROS[10];
bool FLAG = 1;
int RESULTADO = 0;
void setup()
{
pinMode(8,INPUT);
Serial.begin(9600);
Serial.println("PROGRAMA DE SUMA DE LOS NÚMEROS DE UN ARRAY");
Serial.println("");
}
void loop()
{
if (digitalRead(8) & FLAG){
Serial.print("Pulsado botón____ ");
delay (2);
count ++;
Serial.print("Pulsaciones = ");
Serial.println(count);
NUMEROS[count -1]=count;
Serial.print("NUMEROS[");
Serial.print(count-1);
Serial.print("] = ");
Serial.println(NUMEROS[count-1]);
Serial.print("\t");
FLAG = 0;
}
if (count == 10){
Serial.print("SUMANDO LOS NÚMEROS DEL ARRAY - ");
for (int i = 0; i < 10; i ++){
RESULTADO = RESULTADO + NUMEROS[i];
Serial.print("* ");
delay(250);
}
Serial.print("\t");
Serial.print("RESULTADO = ");
Serial.println(RESULTADO);
count = 0;
for (int i = 0; i < 10; i ++)NUMEROS[i] = 0;
RESULTADO = 0;
}
if (!digitalRead(8)) FLAG = 1;
}
El código compila perfectamente, por lo que con un copiar pegar lo podeis meter en vuestro IDE, y hacer pruebas, cambios, y todo lo que haga falta para comprenderlo mejor.
Y como no, un poco de tarea fácil. Este programa introduce los números del 1 al 10 en un array, empecemos por cambiar eso, y ahora meterá las decenas hasta el 100 (10,20,30.....100) y seguidamente, sorpresa, no los sumaremos, los invertiremos dentro del array, se me acaba de ocurrir, y cuando digo que los invertiremos digo eso, invertirlos, del 100 al 10, y no pido repetir el algoritmo invertido, no, eso sería muy fácil, me interesa más que el programa invierta el contenido del array, haya lo que haya dentro del array. Intentemos no utilizar demasiada memoria, variables, y código. Seguro que se nos ocurre un algoritmo interesante.
Si veo que sale fácil, cosa que estoy seguro, a mitad de semana igual se me ocurre algo nuevo.
______________________________________________________________________
/* SUMA DE NUMEROS DE UN ARRAY */
int count=0;
int NUMEROS[10];
bool FLAG = 1;
int RESULTADO = 0;
void setup()
{
pinMode(8,INPUT);
Serial.begin(9600);
Serial.println("PROGRAMA DE SUMA DE LOS NÚMEROS DE UN ARRAY");
Serial.println("");
}
void loop()
{
if (digitalRead(8) & FLAG){
Serial.print("Pulsado botón____ ");
delay (2);
count ++;
Serial.print("Pulsaciones = ");
Serial.println(count);
NUMEROS[count -1]=count;
Serial.print("NUMEROS[");
Serial.print(count-1);
Serial.print("] = ");
Serial.println(NUMEROS[count-1]);
Serial.print("\t");
FLAG = 0;
}
if (count == 10){
Serial.print("SUMANDO LOS NÚMEROS DEL ARRAY - ");
for (int i = 0; i < 10; i ++){
RESULTADO = RESULTADO + NUMEROS[i];
Serial.print("* ");
delay(250);
}
Serial.print("\t");
Serial.print("RESULTADO = ");
Serial.println(RESULTADO);
count = 0;
for (int i = 0; i < 10; i ++)NUMEROS[i] = 0;
RESULTADO = 0;
}
if (!digitalRead(8)) FLAG = 1;
}
domingo, 7 de enero de 2018
sábado, 30 de diciembre de 2017
PROGRAMA CAJA FUERTE
Diagrama de flujo del programa. Sobre esto iremos creando el programa.
Iniciamos nuestro código de programa.
/************************************************************************
PROGRAMA CAJA FUERTE
************************************************************************/
// Podemos iniciar nuestro código definiendo algunos argumentos
// Le damos nombre a nuestros pulsadores, y les definimos su correspondiente entrada
#define ROJO 5
#define VERDE 6
#define AZUL 7
#define BLANCO 10
//Incluimos las variables que creemos que nos harán falta para nuestro programa.
// Fijaros que he quitado el número entre los corchetes, puesto que lo determina de forma automática
bool FLAG = 0;
byte PASSWORD [] = {ROJO, VERDE, AZUL, VERDE, ROJO}; //Array con la clave correcta.
byte CLAVE [] = {0, 0, 0, 0, 0}; //Array para guardar la contraseña que se mete, al inicio a cero
byte PULSACION = 0; //Variable que me cuenta las pulsaciones
byte ERRORES = 0; // Variable que cuenta los errores
//void FALLO (); //Subprograma al que se llama cuando se ha pulsado mal la Contraseña
//void COMPROBACION(); //Cuando se pulsa el nº 10, se entra en un subprograma que comprueba la coincidencia o no de la clave
void setup() {
//Definición de los pines de los pulsadores
pinMode(ROJO, INPUT);
pinMode(VERDE, INPUT);
pinMode(AZUL, INPUT);
pinMode(BLANCO, INPUT);
//Definición de los pines de los leds
pinMode(12, OUTPUT); //LED Rojo - NOK
pinMode(11, OUTPUT); //LED Verde- OK
//Iniciamos el puerto serie, que nos servirá para monitorizar parámetros.
Serial.begin(9600);
}
void loop() {
// Empezamos el programa según nuestro diagrama comprovando las pulsaciones
if (digitalRead(ROJO)) {
delay(10);
if (FLAG != 1) { // Si no hay ningún botón pulsado
FLAG = 1; // Activamos la marca de pulsación de botón.
if (PULSACION <= 4)CLAVE[PULSACION] = ROJO; // Si todavía cabe, lo guardamos
PULSACION++; // Sumamos pulsación
}
}
if (digitalRead(VERDE)) {
delay(10);
if (FLAG != 1) { // Si no hay ningún botón pulsado
FLAG = 1; // Activamos la marca de pulsación de botón.
if (PULSACION <= 4)CLAVE[PULSACION] = VERDE; // Si todavía cabe, lo guardamos
PULSACION++; // Sumamos pulsación
}
}
if (digitalRead(AZUL)) {
delay(10);
if (FLAG != 1) { // Si no hay ningún botón pulsado
FLAG = 1; // Activamos la marca de pulsación de botón.
if (PULSACION <= 4)CLAVE[PULSACION] = AZUL; // Si todavía cabe, lo guardamos
PULSACION++; // Sumamos pulsación
}
}
if (digitalRead(BLANCO)) { // Si se pulsa el blanco, pasamos a comprovar
delay(10);
if (FLAG != 1) { // Si no hay ningún botón pulsado
FLAG = 1; // Activamos la marca de pulsación de botón.
COMPROBACION();
}
}
if (!digitalRead(ROJO) && !digitalRead(VERDE) && !digitalRead(AZUL) && !digitalRead(BLANCO)) {
FLAG = 0;
}
}
void COMPROBACION() {
}
void FALLO() {
if (ERRORES < 3) { // Si la cantidad de errores que llegan es inferior a 2 solo debemos parpadear el led rojo
for (int i = 1; i <= ERRORES; i++) {
pinMode(12, HIGH);
delay(1000);
pinMode(12, LOW);
}
}
else // Sin embargo si nos llegan 3 errores debemos bloquear el programa 30 segundos y reiniciar la variables
{
pinMode(12, HIGH);
delay(30000);
pinMode(12, LOW);
PULSACION = 0;
ERRORES = 0;
memset(CLAVE, 0, sizeof(CLAVE)); // Usamos este truco para inicializar a 0 todo el array de manera rápida http://www.utopiamechanicus.com/article/arduino-setup-arrays/
}
}
jueves, 28 de diciembre de 2017
MASTER CLAS DIRECTO
EL PUERTO SERIE Y EL MONITOR SERIAL DE ARDUINO
El puerto serie, es el medio de comunicación entre el arduino y el ordenador, el cual utilizamos para pasar nuestro programa a la memoria del procesador.
Existen muchos tipos de puertos serie, como el más conocido por todos, USB, (Universal Serial port), y otros, como el casi extinto RS-232, I2C, RS485,.....
Una vez trasmitido nuestro programa al arduino, podemos aprovecharnos del puerto serie tanto para que el Arduino se comunique con nosotros, como nosotros con nuestro arduino. Esto lo conseguiremos activando el puerto serie en nuestro programa para que esté atento, y mediante monitor serie que incluye nuestro IDE arduino.
Arduino UNO dispone de un solo puerto serie, el cual debemos compartir para programar, y para las posibles aplicaciones. Otros modelos disponen de más puertos serie, también llamados UART.
Para salvar esta limitación existen librerías que nos permitirá tener más puestos serie, aunque por software, precio a pagar en espacio, y velocidad, pero nos permitirá manejar más de un dispositivo serie en nuestros sistemas, como un transmisor Bluetooth, a la vez que el monitor serial, y otros módulos dependientes de UART.
Tras este pequeño rollo vamos a por unos ejemplos para poder entender como manejar el monitor serial.
Arduino dispone de unas instrucciones para el manejo de la UART (puerto serie).
Serial.begin(baud) .- Instrucción para inicializar el puerto UART. El puerto que se inicia es el que nos ha asignado el ordenador para nuestro dispositivo.
baud .- velocidad de trasmisión de datos. Las velocidades posibles son 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200
Serial.print() .- Instrucción que utilizaremos para mostrar la información en la pantalla del terminal serie.
Serial.println() .- Igual a la anterior, pero añade un salto de linea.
Todo esto se entenderá más con un pequeño ejemplo.
Provamos este programa y realizamos cambios. En comentarios incluimos nuestros programas para que los demás aprendan.
Hay mucho más sobre el terminal serie, pero con esto podemos ya ir controlando nuestros programas.
Venga, a comentar y preguntar.
Existen muchos tipos de puertos serie, como el más conocido por todos, USB, (Universal Serial port), y otros, como el casi extinto RS-232, I2C, RS485,.....
Una vez trasmitido nuestro programa al arduino, podemos aprovecharnos del puerto serie tanto para que el Arduino se comunique con nosotros, como nosotros con nuestro arduino. Esto lo conseguiremos activando el puerto serie en nuestro programa para que esté atento, y mediante monitor serie que incluye nuestro IDE arduino.
Arduino UNO dispone de un solo puerto serie, el cual debemos compartir para programar, y para las posibles aplicaciones. Otros modelos disponen de más puertos serie, también llamados UART.
Para salvar esta limitación existen librerías que nos permitirá tener más puestos serie, aunque por software, precio a pagar en espacio, y velocidad, pero nos permitirá manejar más de un dispositivo serie en nuestros sistemas, como un transmisor Bluetooth, a la vez que el monitor serial, y otros módulos dependientes de UART.
Tras este pequeño rollo vamos a por unos ejemplos para poder entender como manejar el monitor serial.
Arduino dispone de unas instrucciones para el manejo de la UART (puerto serie).
Serial.begin(baud) .- Instrucción para inicializar el puerto UART. El puerto que se inicia es el que nos ha asignado el ordenador para nuestro dispositivo.
baud .- velocidad de trasmisión de datos. Las velocidades posibles son 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200
Serial.print() .- Instrucción que utilizaremos para mostrar la información en la pantalla del terminal serie.
Serial.println() .- Igual a la anterior, pero añade un salto de linea.
Todo esto se entenderá más con un pequeño ejemplo.
Provamos este programa y realizamos cambios. En comentarios incluimos nuestros programas para que los demás aprendan.
Hay mucho más sobre el terminal serie, pero con esto podemos ya ir controlando nuestros programas.
Venga, a comentar y preguntar.
sábado, 9 de diciembre de 2017
LA CAJA FUERTE
Os propongo este ejercicio, que a la vez, ya empieza a tomar forma, puesto que ya es algo que puede implementarse.
Una caja fuerte, con tres botones de combinación, donde se debe introducir una combinación en orden correcto, de cinco pulsaciones, tras lo cual, se pulsará el botón de apertura.
Si la combinación es correcta, un led verde simulando el cerrojo se iluminará.
Si la combinación es incorrecta, un led rojo se iluminará una vez durante un segundo aproximadamente.
Si por segunda vez la combinación no es correcta, el led rojo se iluminará dos veces en pulsos de un segundo.
Si por un casual la combinación es errónea una tercera vez, el led rojo se iluminará de forma continua durante 30 segundos, tras lo cual el led se apagará y se inicializará el ciclo, con sus correspondientes tres pruebas.
Si abrimos la puerta, pulsamos de nuevo el pulsador de apertura para bloquear de nuevo la puerta.
Igual no queda algo claro en la propuesta, así que me lo comentáis.
Animo, que ya os veo poniendo combinación a todo.
Una caja fuerte, con tres botones de combinación, donde se debe introducir una combinación en orden correcto, de cinco pulsaciones, tras lo cual, se pulsará el botón de apertura.
Si la combinación es correcta, un led verde simulando el cerrojo se iluminará.
Si la combinación es incorrecta, un led rojo se iluminará una vez durante un segundo aproximadamente.
Si por segunda vez la combinación no es correcta, el led rojo se iluminará dos veces en pulsos de un segundo.
Si por un casual la combinación es errónea una tercera vez, el led rojo se iluminará de forma continua durante 30 segundos, tras lo cual el led se apagará y se inicializará el ciclo, con sus correspondientes tres pruebas.
Si abrimos la puerta, pulsamos de nuevo el pulsador de apertura para bloquear de nuevo la puerta.
Igual no queda algo claro en la propuesta, así que me lo comentáis.
Animo, que ya os veo poniendo combinación a todo.
jueves, 7 de diciembre de 2017
EL PROGRAMA DEL RGB
Bueno, Angel Marco, nos ha enviado el programa del RGB. Como podeis ver, está muy bien comentado, muy organizado y utilizando todo lo que sabemos.
No quiero que este programa sea para no estudiar, si no todo lo contrario. Es cierto que esperaba un programa mejorable, para proponer mejoras, pero es lo que hay, un programa casi inmejorable con lo que sabemos.
Por lo menos, espero que lo analiceis, porque el próximo día lo analizaremos entre todos.
No quiero que este programa sea para no estudiar, si no todo lo contrario. Es cierto que esperaba un programa mejorable, para proponer mejoras, pero es lo que hay, un programa casi inmejorable con lo que sabemos.
Por lo menos, espero que lo analiceis, porque el próximo día lo analizaremos entre todos.
domingo, 3 de diciembre de 2017
PEQUEÑO PROGRAMA.
Pongo un pequeño programa, que fácilmente analizareis, pero que teneis que recordar, puesto que este pequeño truco lo utilizareis en muchas ocasiones en programas.
Suscribirse a:
Entradas (Atom)