viernes, 4 de mayo de 2018

Programa para pruebas ultrasonido sin librerías

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
}

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);
}

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;
}

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


Pulsando más abajo en el vínculo, os dirigirá directamente al canal. Igual no podeis hacer grande la imagen, pero se verá bien....

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.

arduino-serial-monitor-IDE


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.

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.


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.