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.


EL PROGRAMITA DEL DICHOSO LED

--------------------------------------------------------------------------------------------------------------------------------------------

#define REPETICIONES 800     // Número de repeticiones para operar
#define DIVISOR 24     // Número de fracciones en las que se dividen las repeticiones
#define ESCALONES 28  // Escalones que se producen en la gráfica determinada por REPETICIONES y DIVISOR
#define TIEMPO_LOW 2    // Tiempo que estará en estado bajo en cada repetición. Determinará la frecuencia.

int level;
int rep;      // Para ir variando el número de repeticiones de forma no lineal

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {

  rep = REPETICIONES;    // Igualamos en cada ciclo para evitar la suma de errores por los decimales.
  level = 0;            // Tiempo inicial encendido, que equivale a la mínima iluminación.

  for (int i = 0; i < ESCALONES; i = i + 1)    // Realizamos un número determinado de escalones, cada uno con un tiempo y luminosidad no lineal.
  {
    rep = (REPETICIONES - ( i * i)) / DIVISOR;  // Calculamos el número de repeticiones para cada uno de los escalones.
    for (int j = 0; j < rep; j++)   // Número de repeticiones en cada una de los escalones.
    {
      digitalWrite(13, HIGH);
      delayMicroseconds(level);
      digitalWrite(13, LOW);
      delay(TIEMPO_LOW);
    }
    level = (i * i);    // El nivel de luminosidad, o tiempo de encendido aumenta de forma no lineal.
  }

  for (int i = ESCALONES; i > 0; i = i - 1)   // Realizamos un número determinado de escalones, cada uno con un tiempo y luminosidad no lineal.
  {
    rep = (REPETICIONES - ( i * i)) / DIVISOR;    // Calculamos el número de repeticiones para cada una de los escalones.
    for (int j = rep; j >= 0; j--)    // Númoero de repeticiones en cada una de los escalones.
    {
      digitalWrite(13, HIGH);
      delayMicroseconds(level);
      digitalWrite(13, LOW);
      delay(TIEMPO_LOW);
    }
    level = (i * i);    // El nivel de luminosidad, o tiempo de encendido disminuye de forma no lineal.
  }
}

-----------------------------------------------------------------------------------------------------------------------------------------

Si quereis comentar algo, os comento lo que querais.