Geekly articles weekly

Experimentos basados ​​en el kit de laboratorio digital

En el primer artículo sobre el kit de capacitación del Laboratorio Digital NR05 , describimos los principios de construcción, la composición del kit y la placa de expansión.



Ahora echemos un vistazo a la ayuda de capacitación incluida en el kit y analicemos dos experiencias simples con el uso de una tarjeta de expansión que lo ayudará a comprender cómo están conectados los dispositivos externos y cómo usar los botones incorporados, y dar ejemplos de bocetos.

Como ya hemos dicho, la placa contiene grupos de conectores para conectar varios módulos externos: sensores, actuadores y dispositivos que utilizan algunos buses de intercambio de información estándar.

Como un actuador, se proporciona un lugar en la placa para instalar un indicador LCD de dos líneas de caracteres de cristal líquido con luz de fondo. En dicho indicador, se puede mostrar suficiente información con fines educativos y cuando se utiliza el kit como un dispositivo terminado. El manual de capacitación describe cómo mostrar información simbólica en la pantalla, cómo hacer que la pantalla muestre letras rusas e inglesas al mismo tiempo. El indicador se utiliza en casi todos los proyectos descritos en el folleto.

Considere el actuador más simple: un LED. El conjunto incluye un LED brillante tricolor (RGB - Rojo, Verde, Azul). De los tres colores de dicho LED, al cambiar la intensidad de cada uno de ellos, debido a las características del ojo humano, se puede obtener cualquier color. Este método de obtención de color se denomina mezcla de color aditiva y se usa, por ejemplo, en televisores y monitores. Mezclando tres colores en proporciones iguales, obtenemos un color blanco.



Conectamos el LED al conector XP15 en la tarjeta de expansión, que además se marca "RGB_LED" con cuatro cables o un adaptador. Utilizamos un LED con un cátodo común ("menos" común), por lo que la salida de LED más larga está conectada al terminal GND ("Tierra"), y las salidas de LED restantes están conectadas al ROJO / D5 (rojo), AZUL / D6 (azul), VERDE / D9 (verde).



D5, D6 y D9 son los pines digitales Arduino en los que puede obtener la modulación de ancho de pulso (PWM) para controlar el brillo del LED. El manual de capacitación proporciona el mínimo necesario de la teoría PWM y la forma de implementar esta modulación en Arduino.



Aquí está el código para el programa (boceto) que controla el brillo del brillo del LED RGB:

Spoiler
//    RGB 
//-----------------------------------------------------------------------
//   
int redPin = 5;
int greenPin = 9;
int bluePin = 6;
//-----------------------------------------------------------------------
/*     1      Arduino
    */
void setup() 
{

}

//-----------------------------------------------------------------------
/*       setup         .*/

void loop() {
   /*    256 .    value      1.*/
   for(int value = 0 ; value <= 255; value ++) { 
    //      0
    analogWrite(redPin, 255-value);
    //  
    analogWrite(greenPin, value);
    //   
    analogWrite(bluePin, 0);
    //    30 
    delay(30);
  }

  /*    256 .    value      1.*/
  for(int value = 0 ; value <= 255; value ++) { 
    //  
    analogWrite(redPin, 0);
    //      0
    analogWrite(greenPin, 255-value);
    //  
    analogWrite(bluePin, value);
    //    30 
    delay(30);
  }

  /*    256 .    value      1.*/
  for(int value = 0 ; value <= 255; value ++) { 
    //  
    analogWrite(redPin, value);
    //  
    analogWrite(greenPin, 0);
    //      0
    analogWrite(bluePin, 255-value);
    //    30 
    delay(30);
  }

 //  loop    
}



Cuando el programa se está ejecutando, el LED cambia suavemente el color emitido de rojo a verde, luego de verde a azul y luego de azul a rojo.
Complementamos nuestro programa de tal manera que la pantalla LCD muestra los valores correspondientes al brillo de cada color en cada momento desde el mínimo (0) hasta el máximo (255). El código modificado se da debajo del spoiler.

Spoiler
//    RGB 
//-----------------------------------------------------------------------
//   
int redPin = 5;
int greenPin = 9;
int bluePin = 6;
//    
int pwmRed;
int pwmGreen;
int pwmBlue;
//-----------------------------------------------------------------------
//   LiquidCrystalRus
#include <LiquidCrystalRus.h>
//  ,   LiquidCrystalRus
#include <LiquidCrystalExt.h>
#include <LineDriver.h>

//-----------------------------------------------------------------------
/*  ,      RS,EN,DB4,DB5,DB6,DB7 */
LiquidCrystalRus lcd(A1, A2, A3, 2, 4, 7);

//     1      Arduino
void setup() 
{
  //  LCD - 16 , 2 
  lcd.begin(16, 2);
  //      ()      
  lcd.print(" RED GREEN BLUE");
  
}

//-----------------------------------------------------------------------
//       setup         .

void loop() {
   /*    256 .    value      1.*/
   for(int value = 0 ; value <= 255; value ++) { 
    pwmGreen = value;
    pwmRed = 255 - value;
    //      0
    analogWrite(redPin, pwmRed);
    //  
    analogWrite(greenPin, pwmGreen);
    //   
    analogWrite(bluePin, 0);
    //    30 
    delay(30);
    Display();
  }

  /*    256 .    value      1.*/
  for(int value = 0 ; value <= 255; value ++) { 
    pwmBlue = value;
    pwmGreen = 255 - value;
    //  
    analogWrite(redPin, 0);
    //      0
    analogWrite(greenPin, pwmGreen);
    //  
    analogWrite(bluePin, pwmBlue);
    //    30 
    delay(30);
    Display();
  }

  /*    256 .    value      1.*/
  for(int value = 0 ; value <= 255; value ++) { 
    pwmRed = value;
    pwmBlue = 255 - value;
    //  
    analogWrite(redPin, pwmRed);
    //  
    analogWrite(greenPin, 0);
    //      0
    analogWrite(bluePin, pwmBlue);
    //    30 
    delay(30);
    Display();
  }

 //  loop    
}

//      ,  
void Display(){
 lcd.setCursor(0,1);
 lcd.print("                ");
 lcd.setCursor(1,1);
 lcd.print(pwmRed);
 lcd.setCursor(6,1);
 lcd.print(pwmGreen);
 lcd.setCursor(11,1);
 lcd.print(pwmBlue);
}



Ahora veamos un ejemplo del uso de botones integrados en el tablero.



En el caso general, cada botón está conectado a una salida digital Arduino separada y el programa sondea secuencialmente estas salidas para determinar qué botón se presiona. Para guardar las conclusiones de Arduino, que debe usarse para determinar la presión del botón en la placa de expansión del kit del Laboratorio Digital, se utiliza un teclado "analógico", conectado a una sola entrada analógica de Arduino. Este método se usa a menudo en electrodomésticos. El programa mide el voltaje de salida en la salida del divisor de voltaje, que depende del botón que se presione. En el manual de capacitación, se considera la teoría de dicho divisor y el método de su aplicación en el teclado. La desventaja de este método es que los botones se pueden presionar solo uno a la vez, secuencialmente.

Descargue el programa apropiado en Arduino:

Spoiler
//           
//-----------------------------------------------------------------------
//     LiquidCrystal
#include <LiquidCrystal.h>

//      
#define NUM_KEYS 5
//      ( )
int  adcKeyVal[NUM_KEYS] = {30, 150, 360, 535, 760};
//-----------------------------------------------------------------------
//  ,      RS,EN,DB4,DB5,DB6,DB7
LiquidCrystal lcd(A1, A2, A3, 2, 4, 7);

//-----------------------------------------------------------------------
//     1      Arduino
void setup() 
{
  //  LCD   -16   2 
  lcd.begin(16, 2);
  //      ()      

  //     Keyboard
  lcd.print("Keyboard");  
 
  //    2000 = 2 
  delay(2000); 
}

//-----------------------------------------------------------------------
//       setup         .

void loop() {
  //     key
  int key;
  
  //       ,      get_key
  key = get_key();
 
  //      
  lcd.clear();
  //      ()     
 
  //     . -      
  lcd.print(key); 
  
  //    100 = 0,1 
  delay(100);
 //  loop    
}

//-----------------------------------------------------------------------
//          
//     ,    
//     ,    
int get_key()
	{
	  int input = analogRead(A6);
	  int k;
	  for(k = 0; k < NUM_KEYS; k++) 
	    if(input < adcKeyVal[k]) 
	      return k + 1;     
	  return 0;
	}



Para mostrar información sobre qué botón se presiona, se utiliza un indicador LCD. Si presiona los botones, el número del botón presionado se mostrará en el indicador.

La función get_key devuelve un número entero correspondiente al número del botón presionado, que puede usarse en el programa principal. Los valores de calibración, con los cuales se compara el voltaje de la salida del divisor, se determinan experimentalmente usando este programa:

#include <LiquidCrystal.h>
LiquidCrystal lcd(A1, A2, A3, 2, 4, 7);
void setup() 
{
  lcd.begin(16, 2);
  lcd.print("Press keys");  
  delay(2000); 
}
void loop() {
  
  int input = analogRead(A6);
  lcd.clear();
  lcd.print(input); 
  delay(100);
}


Intente cargarlo en Arduino y vea qué valores se muestran y compárelos con los de calibración. Intentemos ahora usar los ejemplos anteriores para crear un programa que implemente el control LED mediante botones. Configuremos la siguiente funcionalidad:

• cuando presiona el botón 1 (extremo izquierdo), se enciende una luz roja, en el botón 2 - verde, 3 - azul. Cuando se presiona nuevamente el botón, la luz correspondiente se apaga. El indicador muestra qué colores están activados.
• cuando se presiona el botón 4, los colores de encendido y apagado cambian de lugar
• cuando se presiona el botón 5, todos los colores se apagan.

Aquí está una de las posibles opciones para tal boceto:

Spoiler
//       RGB-
//-----------------------------------------------------------------------
//     LiquidCrystal
#include <LiquidCrystal.h>

//      
#define NUM_KEYS 5
//      ( )
int  adcKeyVal[NUM_KEYS] = {30, 150, 360, 535, 760};
#define redLED 5
#define greenLED 9
#define blueLED 6
//-----------------------------------------------------------------------
//  ,      RS,EN,DB4,DB5,DB6,DB7
LiquidCrystal lcd(A1, A2, A3, 2, 4, 7);
int redLEDstate = 0;
int greenLEDstate = 0;
int blueLEDstate = 0;
int flag = 0;

//-----------------------------------------------------------------------
//     1      Arduino
void setup() 
{
  pinMode(redLED, OUTPUT);
  pinMode(greenLED, OUTPUT);
  pinMode(blueLED, OUTPUT);
  //  LCD   -16   2 
  lcd.begin(16, 2);
  //      ()      

  //     
  lcd.print("Try Keys + LEDs");  
 
  //    1000 = 1 
  delay(1000); 
  //    
  lcd.clear();
}

//-----------------------------------------------------------------------
//       setup         .

void loop() {
  //     key
  int key;
  //       ,      get_key
  key = get_key();
  //   ,      
  // C   flag     ,      
     if(key == 1 && flag == 0) {                                              
        digitalWrite(redLED, !digitalRead(redLED));
        flag = 1;
      }
     if(key == 2 && flag == 0) {  //   : if(key == 2 && !flag)                                            
        digitalWrite(greenLED, !digitalRead(greenLED));
        flag = 1;
      }
    if(key == 3 && !flag)  {                                              
        digitalWrite(blueLED, !digitalRead(blueLED));
        flag = 1;
      }
    if(key == 4 && !flag)  {                                              
        digitalWrite(redLED, !digitalRead(redLED));
        digitalWrite(greenLED, !digitalRead(greenLED));
        digitalWrite(blueLED, !digitalRead(blueLED));
        flag = 1;
      }
    if(key == 5 && !flag){                                              
        digitalWrite(redLED, LOW);
        digitalWrite(greenLED, LOW);
        digitalWrite(blueLED, LOW);
        flag = 1;
      }
    //      ,    
    if(!key && flag) //  if(key == 0 && flag == 1)
      {
        flag = 0;
      }        
   //        ,   
   if (digitalRead(redLED)) { //  if (digitalRead(redLED) == 1)
         lcd.setCursor(0,0);
         lcd.print("Red");
        }
        else {
         lcd.setCursor(0,0);
         lcd.print("   ");
        }
   if (digitalRead(greenLED)) {
         lcd.setCursor(5,0);
         lcd.print("Green");
        }
        else {
         lcd.setCursor(5,0);
         lcd.print("     ");
        }
    if (digitalRead(blueLED)) { 
         lcd.setCursor(11,0);
         lcd.print("Blue");
        }
        else {
         lcd.setCursor(11,0);
         lcd.print("    ");
        }

 //  loop    
}

//-----------------------------------------------------------------------
//          
//     ,    
//     ,    
int get_key()
	{
	  int input = analogRead(A6);
	  int k;
	  for(k = 0; k < NUM_KEYS; k++) 
	    if(input < adcKeyVal[k]) 
	      return k + 1;     
	  return 0;
	}



En conclusión, presentamos un video corto que demuestra los experimentos descritos.



Como puede ver, las capacidades del kit de expansión Digital Lab le permiten aprender de manera conveniente, gráfica y rápida cómo trabajar con Arduino y los módulos complementarios.

En el próximo artículo, consideraremos la interacción de Arduino con un teléfono inteligente Android con tecnología Bluetooth y una tarjeta de expansión. Programaremos el teléfono inteligente utilizando el proyecto MIT App Inventor , desarrollado y respaldado por el Instituto de Tecnología de Massachusetts.

Source: https://habr.com/ru/post/es390345/

More articles:


All Articles