jueves, 27 de agosto de 2015

TUTORIAL - CONTROL DE STOCK DE ALMACÉN.




Autor: Alumno del curso de Montaje y Reparación de Sistemas Microinformáticos IFCT0309
             Juan Manuel Verdeal García.

Objetivo:  Mostrar mediante un dígito el número de artículos que tenemos en nuestro almacén, para ello vamos a emplear nueve interruptores que simulan cada uno de ellos una célula de posición y con los cuales daremos entrada a o salida a nuestros productos. Además emplearemos dos leds que nos indicarán si nos encontramos o no en stock mínimo. De 0 a 3 estará encendido el rojo y con valores superiores el led verde.

Componentes a usar en este tutorial:

§  1 x Arduino UNO.
§  1 x Diodo LED Red.
§  1 x Diodo LED Green.
§  1 x Resistencia de 75 ohmios.
§  11 x Resistencias de 220 ohmios.
§  9 x Slideswitch.
§  1 x Display 7 segmentos.
§  Circuito integrado 74HC595.
§  Cables.

En la imagen de la derecha podemos identificar los LEDs, interruptores, resistencias, circuito integrado y digito.

Para conectar nuestro Arduino UNO a la BreadBoard sacaremos un cable (cable rojo) del PIN 5V hasta nuestra fila positiva de la protoboard (+) y un cable (cable azul) desde el PIN GND hasta nuestra fila (-) de la protoboard. Para el circuito integrado necesitaremos usar tres salidas digitales. El resto de salidas, son empleadas para los interruptores y LEDs, cada uno de los cuales con su correspondiente resistencia de 220 ohmios.  Con el display vamos  a usar una resistencia de 75 ohmios, suficiente para tener una intensidad de luminosidad adecuada de los segmentos.


Segmentos de nuestro Display:

     En la siguiente imagen vemos como se asignan las letras a nuestro Display


Ahora vayamos con el código:

/* ASIGNACION DE SALIDAS DIGITALES Y DECLARACIÓN DE VARIABLES */

int latchPin = 12;
int clockPin = 11;
int dataPin = 13;  
int maximo = 1;    
int minimo = 0;    

int articulo1 = 0;
int articulo2 = 0;
int articulo3 = 0;
int articulo4 = 0;
int articulo5 = 0;
int articulo6 = 0;
int articulo7 = 0;
int articulo8 = 0;
int articulo9 = 0;

int almacen = 0;

int plaza1 = 0;
int plaza2 = 0;
int plaza3 = 0;
int plaza4 = 0;
int plaza5 = 0;
int plaza6 = 0;
int plaza7 = 0;
int plaza8 = 0;
int plaza9 = 0;

/* EN ESTA SECCION CONTINUAMOS CON LA ASIGNACIÓN DE LAS SALIDAS DIGITALES.   Serán de entrada o "INPUT" y salida o "OUTPUT"*/

void setup() {
  
  pinMode(10, INPUT);
  pinMode(9, INPUT);
  pinMode(8, INPUT);
  pinMode(7, INPUT);
  pinMode(6, INPUT);
  pinMode(5, INPUT);
  pinMode(4, INPUT);
  pinMode(3, INPUT);
  pinMode(2, INPUT);
  
  pinMode(maximo, OUTPUT);
  pinMode(minimo, OUTPUT);
  
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

void loop()  
{     
  
/* ASIGNAMOS LAS SALIDAS DE NUESTRO CIRCUITO INTEGRADO A NUEVE VARIABLES */
  
  articulo1 = digitalRead(10);
  articulo2 = digitalRead(9);
  articulo3 = digitalRead(8);
  articulo4 = digitalRead(7);
  articulo5 = digitalRead(6);
  articulo6 = digitalRead(5);
  articulo7 = digitalRead(4);
  articulo8 = digitalRead(3);
  articulo9 = digitalRead(2);
  
/* Para todos los casos que se pueden dar vamos a utilizar la instrucción "If" y "Else if". De tal forma que cuando pulsemos alguno de nuestros interruptores se pueden dar dos casos   o posiciones "HIGH" O "LOW". Para el primero de los casos, vamos a hacer que le de entrada al artículo en nuestro almacén y para el segundo de los casos o posición de los interruptores, le damos salida. Mediante Las variables "plaza1, plaza2, ..." le decimos al programa si el artículo ha entrado o salido. La otra variable "almacén" la usamos como acumulador de artículos   que tenemos.*/
  
  if (articulo1 == HIGH and plaza1 < 1) {
    plaza1++;
    almacen++;
  }

  else if (articulo1 == LOW and plaza1 > 0) {
    plaza1--;
    almacen--;
  }
    
  if (articulo2 == HIGH and plaza2 < 1) {
    plaza2++;
    almacen++;
  }

  else if (articulo2 == LOW and plaza2 > 0) {
    plaza2--;
    almacen--;
  }
  
  if (articulo3 == HIGH and plaza3 < 1) {
    plaza3++;
    almacen++;
  }

  else if (articulo3 == LOW and plaza3 > 0) {
    plaza3--;
    almacen--;
  }
  
  if (articulo4 == HIGH and plaza4 < 1) {
    plaza4++;
    almacen++;
  }

  else if (articulo4 == LOW and plaza4 > 0) {
    plaza4--;
    almacen--;
  }
  
  if (articulo5 == HIGH and plaza5 < 1) {
    plaza5++;
    almacen++;
  }

  else if (articulo5 == LOW and plaza5 > 0) {
    plaza5--;
    almacen--;
  }
  
  if (articulo6 == HIGH and plaza6 < 1) {
    plaza6++;
    almacen++;
  }

  else if (articulo6 == LOW and plaza6 > 0) {
    plaza6--;
    almacen--;
  }
  
  if (articulo7 == HIGH and plaza7 < 1) {
    plaza7++;
    almacen++;
  }

  else if (articulo7 == LOW and plaza7 > 0) {
    plaza7--;
    almacen--;
  }
  
  if (articulo8 == HIGH and plaza8 < 1) {
    plaza8++;
    almacen++;
  }

  else if (articulo8 == LOW and plaza8 > 0) {
    plaza8--;
    almacen--;
  }
  
  if (articulo9 == HIGH and plaza9 < 1) {
    plaza9++;
    almacen++;
  }

  else if (articulo9 == LOW and plaza9 > 0) {
    plaza9--;
    almacen--;
  }

/* Ahora para encender nuestros leds empleamos la instrucción "switch ... case()", de tal forma que permanezca encendido el led rojo cuando el número de articulos esté entre los valores 0 y 3. Para valores superiores encenderemos el led verde. Dentro de la misma instrucción llamamos a las distintas subrutinas, creadas estas para encender o apagar los distintos segmentos de nuestro digito, según el número a mostrar*/
  
    switch (almacen) {

    case 0:
      cero();  
      digitalWrite(maximo, LOW);
      digitalWrite(minimo, HIGH);  
      
      break;

    case 1:
      uno();
      digitalWrite(maximo, LOW);
      digitalWrite(minimo, HIGH);  
      
      break;

    case 2:
      dos();
      digitalWrite(maximo, LOW);        
      digitalWrite(minimo, HIGH);  
      
      break;

    case 3:
      tres();
      digitalWrite(maximo, LOW);
      digitalWrite(minimo, HIGH);  
      
      break;

    case 4:
      cuatro();
      digitalWrite(maximo, HIGH);
      digitalWrite(minimo, LOW);  
      
      break;

    case 5:
      cinco();
      digitalWrite(maximo, HIGH);
      digitalWrite(minimo, LOW);        
      break;

    case 6:
      seis();
      digitalWrite(maximo, HIGH);  
      digitalWrite(minimo, LOW);        
      break;

    case 7:
      siete();
      digitalWrite(maximo, HIGH);  
      digitalWrite(minimo, LOW);  
      
      break;

    case 8:
      ocho();
      digitalWrite(maximo, HIGH);   
      digitalWrite(minimo, LOW);  
      
      break;

    case 9:      
      nueve();
      digitalWrite(maximo, HIGH);
      digitalWrite(minimo, LOW);        
      break;
  }

  delay(200);
}

/* A partir de aquí desarrollamos diez subrutinas, una para cada   número. Para ello vamos a pasar a binario distintos números,   63, 6, 79, etc. Con el dato obtenido, conseguiremos encender los   distintos segmentos de nuestro dígito, siendo 1 encendido y 0   apagado*/

  void cero(){
    // Decimal 63      Binary output  01111111     Displays 0
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 63);  
    digitalWrite(latchPin, HIGH);
  }
  
  void uno(){
    // Decimal 6      Binary output  00000110     Displays 1
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 6);  
    digitalWrite(latchPin, HIGH);
  }
  
  void dos(){
    // Decimal 91      Binary output  01011011     Displays 2
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 91);  
    digitalWrite(latchPin, HIGH);
  }
  


  
  void tres(){
    // Decimal 79      Binary output  01001111     Displays 3  
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 79);  
    digitalWrite(latchPin, HIGH);
  }
  
  void cuatro(){
    // Decimal 102      Binary output  01100110     Displays 4  
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 102);  
    digitalWrite(latchPin, HIGH);
  }
  
  void cinco(){
    // Decimal 109      Binary output  01101101     Displays 5  
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 109);  
    digitalWrite(latchPin, HIGH);
  }

  void seis(){
    // Decimal  125      Binary output  01111101     Displays 6  
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 125);  
    digitalWrite(latchPin, HIGH);
  }
  
  void siete(){
    // Decimal  7      Binary output  00000111     Displays 7     
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 7);  
    digitalWrite(latchPin, HIGH);
   }
  
  void ocho(){
    // Decimal 127      Binary  output  01111111     Displays 8    
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 127);  
    digitalWrite(latchPin, HIGH);
  }

  void nueve(){
    // Decimal 111      Binary output  01101111     Displays 9      
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, 111);  
    digitalWrite(latchPin, HIGH);
  }





Aquí mostramos un video explicativo con su posterior funcionamiento:




No hay comentarios: