Arduino Project 11: Bola de cristal

Necesitaremos los siguientes materiales:

• 1 sensor de movimiento
• 1 potenciómetro
• 1 resistencia de 220Ω
• 1 resistencia de 10 kΩ
• 1 panel LCD

Todo esto lo conectaremos en nuestro bredboard junto a nuestro Arduino (o similar) y cables de la siguiente manera:

Cargaremos el siguiente código en nuestra placa:

// incluimos las librerias
#include <LiquidCrystal.h>

// iniciamos las librerias con los números de los pines de la interfaz
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

/*
aquí declaramos los pines que serán para cada uno de nuestros elementos
*/
const int switchPin = 6;

int switchState = 0;

int prevSwitchState = 0;

int reply;

void setup() {

  // inicia el numero de filas y columnas del LCD
  lcd.begin(16, 2);

  pinMode(switchPin,INPUT);

  // imprime unn mensaje en el LCD
  lcd.print("Ask the");

  // pone el cursor en la linea 1 columna 0
  lcd.setCursor(0, 1);

  //imprime en la segunda línea
  lcd.print("Crystal Ball!");

}

void loop() {
  //revisa el estado del switch
  switchState = digitalRead(switchPin);

  //compara el estado del switch con el anterior
  if (switchState != prevSwitchState) {

    /*
si el estado cambia de HIGH a LOW es porque la bola se ha movido
*/
    if (switchState == LOW) {
      // elige de forma aleatoria una respuesta
      reply = random(8);
      // limpia la pantalla tras dar una respuesta
      lcd.clear();
   
      lcd.setCursor(0, 0);
     //imprime el siguiente texto
      lcd.print("the ball says:");
      //pone el cursor en la segunda linea
      lcd.setCursor(0, 1);

      //elige la respuesta
      switch(reply){
      case 0:
        lcd.print("Yes");
        break;

      case 1:
        lcd.print("Most likely");
        break;

      case 2:
        lcd.print("Certainly");
        break;

      case 3:
        lcd.print("Outlook good");
        break;

      case 4:
        lcd.print("Unsure");
        break;

      case 5:
        lcd.print("Ask again");
        break;

      case 6:
        lcd.print("Doubtful");
        break;

      case 7:
        lcd.print("No");
        break;
      }
    }
  }
  //guarda el ultimo estado del switch
  prevSwitchState = switchState;
}

Tras simular en circuits.io, obtenemos el siguiente resultado:





El funcionamiento en físico junto a su construcción se muestran, como siempre, en el siguiente video:

Arduino Project 10: Zoótropo

Necesitaremos los siguientes materiales:

• 2 resistencias de 10 k‎Ω
• 1 potenciómetro
• 2 botones
• 1 batería de 9 V
• 1 motor
• 1 chip H-bridge (puente en H)

El objetivo es crear una imágen en movimiento mediante el rápido movimiento de imágenes en torno a un eje.

Usaremos un puente en H para poder mover el motor en ambos sentidos, su funcionamiento elemental se detalla en la imagen.

Se usará el siguiente código:

//el puente en H controla el encendido y apagado

const int controlPin1 = 2;

const int controlPin2 = 3;

const int enablePin = 9;

//botones

const int directionSwitchStatePin = 4;

const int onOffSwitchStatePin = 5;

//potenciómetro

const int potPin = A0;

int onOffSwitchState = 0;

int previousOnOffSwitchState = 0;

int directionSwitchState = 0;

int previousDirectionSwitchState = 0;

int motorEnabled = 0;

int motorSpeed = 0;

int motorDirection = 1;

void setup(){

//declarar entradas y salidas

  pinMode(directionSwitchStatePin, INPUT);

  pinMode(onOffSwitchStatePin, INPUT);

  pinMode(controlPin1, OUTPUT);

  pinMode(controlPin2, OUTPUT);

  pinMode(enablePin, OUTPUT);

  //apaga el motor inicialmente
  digitalWrite(enablePin, LOW);

}

void loop(){

  onOffSwitchState = digitalRead(onOffSwitchStatePin);

  delay(1);

  directionSwitchState = digitalRead(directionSwitchStatePin);

  motorSpeed = analogRead(potPin)/4;

  

  if(onOffSwitchState != previousOnOffSwitchState){

    if(onOffSwitchState == HIGH){

      motorEnabled = !motorEnabled;
//las exclamaciones invierten el estado de la variable

    }//end of nested(if)

  }//end of outer (if)

  

  if(directionSwitchState != previousDirectionSwitchState){

    if(directionSwitchState ==HIGH){

      motorDirection = !motorDirection; //cambia la dirección del motor

    } //end of nested if()

  } //end of outer (if)

  

  if(motorDirection == 1){

//con esto se hace la configuración del puente en H

    digitalWrite(controlPin1, HIGH);

    digitalWrite(controlPin2, LOW);

  }

  else{

    digitalWrite(controlPin1, LOW);

    digitalWrite(controlPin2, HIGH);

  }

  

  if (motorEnabled == 1){

    //determina la velocidad

    analogWrite(enablePin, motorSpeed);

  }

  else{

    analogWrite(enablePin, 0);

  }

  

  previousDirectionSwitchState = directionSwitchState;

  previousOnOffSwitchState = onOffSwitchState;

} 

  

La simulación con circuits.io da el siguiente resultado:

Y como siempre, su construcción y funcionamiento se ven así:

Arduino Project 9: Molinillo motorizado

Para esta práctica harán falta los siguientes elementos:

• 1 transistor N-MOSFET
• 1 diodo
• 1 batería de 9 V
• 1 botón
• 1 resistencia de 10 kΩ

Esta practica consiste en controlar con nuestro Arduino un motor que funciona a 9 V, es decir, con un circuito electrónico de 5 V, controlar uno eléctrico de mayos voltaje. Para ello emplearemos un transistor, que deja pasar la corriente (este tipo así lo hace) cuando recibe una señal por la entrada G (gate). La corriente fluirá desde S (source) hasta D (drain). 

El transistor tiene el siguiente esquema, adjunto con una foto con conexiones y diagrama eléctrico.

Usaremos el siguiente código, esta vez comentado de forma más escueta ya que avanzamos en dificultad, por lo que las partes fáciles no recibirán tanta atención a partir de ahora.

//nombrar primeros las constantes que definirán los pines

const int switchPin = 2;

const int motorPin = 9;

//y la constante que tendrá el valor del botón

int switchState = 0;

void setup() {

  // iniciar los pines según convenga

  pinMode(motorPin, OUTPUT);

  pinMode(switchPin, INPUT);

}

void loop() {

//da a la constante seitchState el valor leido por el pin switchPin

  switchState = digitalRead(switchPin);

  

/*

si la variable switchState está en estado HIGH (activado), manda una señal en HIGH por el pin motorPin

*/

  if (switchState == HIGH) {

    digitalWrite(motorPin, HIGH);

  }

//si no, lo mantiene apagado

  else {

    digitalWrite(motorPin, LOW);

  }

}

El código nos da el siguiente resultado al simular:

Y su posterior construcción en físico y su funcionamiento se ven a continuación:

Arduino Project 8: Reloj de arena digital

Para esta práctica necesitaremos:

• 6 LEDS
• 6 resistencias de 220Ω
• 1 resistencia de 10 kΩ
• 1 sensor de movimiento

El objetivo es hacer un circuito que funcione de forma similar a un reloj de arena, que cambie de forma comprensible y regular en el tiempo y que, al agitarlo, se reinicie (esto se conseguirá con el sensor de movimiento).

Las conexiones a realizar son las siguientes:

Para hacer que funcione, tendremos que cargar en nuestra placa Arduino (o similar, aquí somos partidarios de marcas blancas ;) ) el siguiente código:

//nombra la constante para el pin del sensor
const int switchPin = 8;

unsigned long previousTime = 0; 

//guarda el último momento en que un led fue encendido

int switchState = 0;

//variable para el estado actual del sensor

int prevSwitchState = 0;

//guarda el anterior estado del sensor

int led = 2;

//variable referida a los leds

//3000 = 3000 milisegundos
long interval = 3000;

//este será el intervalo entre un led que se enciende y el siguiente

void setup() {

 for(int x = 2;x<8;x++){
   pinMode(x, OUTPUT);

//declara lo que serán las salidas de los leds, con un contador

 }

 //declara el pin del sensor como entrada
 pinMode(switchPin, INPUT);

}

void loop(){ 

 //guarda el tiempo desde el cual la placa comenzó el programa
 unsigned long currentTime = millis(); 

 /*

compara el tiempo con el que hubo la última vez que un led se encendió

y si es mayor que el intervalo definido, enciende el siguiente

*/

 if(currentTime - previousTime > interval) {

   //guarda la última vez que cambiaste un led
   previousTime = currentTime; 

   //enciende el led
   digitalWrite(led, HIGH);
   led++; 
   
   if(led == 7){

   }
 }

 //lee el valor del sensor
 switchState = digitalRead(switchPin); 

 //si el sensor cambia, apaga todos los sensores
 if(switchState != prevSwitchState){

   for(int x = 2;x<8;x++){    
     digitalWrite(x, LOW);

   }  
   
   //resetea la variable de los leds a la original
   led = 2;
   
   //resetea el contador de tiempos
   previousTime = currentTime;
 }
 //guarda el último estado en que estuvo el led
 prevSwitchState = switchState;

}

Este es el resultado de simular en circuits.io:

Y su posterior construcción en físico da el siguiente resultado:

Arduino Project 7: Teclado instrumental

Para esta práctica necesitaremos:

• 1 Buzzer
• 4 botones
• 2 resistencias de 10 kΩ
• 1 resistencia de 220 Ω
• 1 resistencia de 1 MΩ

En esta práctica, construiremos y programaremos un instrumento similar a un piano, es decir, un circuito que generará diferentes frecuencias según que botones (teclas) pulsemos.

Al final de la práctica, se propone hacer una carcasa para que el cableado no quede visible y se asemeje más a un piano.

Las conexiones que realizaremos serán las que se muestran en la imagen:

El código que usaremos será el siguiente:

int buttons[6];

//crea una lista con 6 elementos

buttons[0] == 2;

//le da a primer elemento el valor 2

int notes[] = {262,294,330,349};

//relaciona cada valor de la lista anterior con uno de esta

void setup(){

  Serial.begin(9600);

}

void loop(){

  int keyVal = analogRead(A0); 

//lee un valor entre 0 y 1024 dependiendo de qué botón está pulsado

  Serial.println(keyVal);

  

  if(keyVal ==1023){

    tone(8, notes[0]);

  }

  else if(keyVal >= 990 && keyVal <=1010){

    tone(8, notes[1]);

  }

  else if(keyVal <= 505 && keyVal <= 515){

    tone(8, notes[2]);

  }

  else if(keyVal >= 5 && keyVal <=10){

    tone(8, notes[3]);

  }

  else{

    noTone(8);

  }

}

/*

con estas últimas líneas de código, haremos que suene una nota según qué botón pulsemos, es decir, según qué valor de la lista este activo

*/

Con este código, y las anteriores conexiones, la simulación en crcuits.io nos da el siguiente resultado:

Y su construcción y funcionamiento en formato físico es el siguiente:

Arduino Project 6: Theremín de luz

Para esta práctica necesitaremos los siguientes materiales, que son pocos en esta ocasión:

• 1 Fotorresistencia
• 1 Buzzer
• 1 Resistencia de 10 kΩ

En esta práctica, haremos un aparato similar a un theremín, que es un instrumento musical electrónico el cual es manipulado sin contacto físico, pues funciona por ondas de radio (adjuto foto). Para ello realizaremos las siguientes conexiones:

El código usado es el siguiente:

//variable del sensor de luz

int sensorValue;

// variable para calibrado inferior

int sensorLow = 1023;

// variable para calibrado superior

int sensorHigh = 0;

// pin del LED

const int ledPin = 13;

void setup() {

  // declara el pin del LED como salida y lo enciende

  pinMode(ledPin, OUTPUT);

  digitalWrite(ledPin, HIGH);

  //calibra durante los primeros 5 segundos de programa

  while (millis() < 4000) {

    // guarda el valor máximo del sensor

    sensorValue = analogRead(A0);

    if (sensorValue > sensorHigh) {

      sensorHigh = sensorValue;

    }

    //guarda el valor mínimo del sensor

    if (sensorValue < sensorLow) {

      sensorLow = sensorValue;

    }

  }

  // apaga el led para señalar que ha acabado el calibrado

  digitalWrite(ledPin, LOW);

}

void loop() {

  //lee la señal analógica del A0 y la guarda como valor

  sensorValue = analogRead(A0);

  //mapea los los valores del sensor en un rango de frecuencias

  int pitch = map(sensorValue, sensorLow, sensorHigh, 50, 4000);

  //ejecuta el tono durante 20 ms en el pin 8

  tone(8, pitch, 20);

  delay(10);

}

La simulación en circuits.io es la siguiente:

Y este el resultado en formato físico:

Arduino Project 5: Señal de Humor

Para esta práctica necesitaremos:

• 1 Potenciómetro
• 1 Servo con brazo
• 2 Condensadores electrolíticos de 100 micro Faradios

En esta práctica se pretende hacer un brazo que controlado por un potenciómetro señale en que estado de animo estás (esto se consigue simplemente añadiendo un círculo de papel con inscripciones de estados de ánimo en él).

Usaremos los condensadores para mantener estable las señales, lo que hará que el motor que se mueva de forma más suave y no a trompicones. El uso de condensadores es escalable.
CUIDADO: ¡si los conectas al revés pueden explotar ya que están polarizados!

El esquema de conexión es el siguiente:

Y usaremos el siguiente código para controlar el servo con un potenciómetro.

#include <Servo.h>   //incluimos las librerías de control del servo

int const potPin = A0; //pin analógico A

int potVal; //guarda el valor pot

int angle = 0; //guarda la posición del servo

void setup() {

  myServo.attach(9); //declara en que pin está conectado el servo

  Serial.begin(9600);

}

void loop() {

  potVal = analogRead(potPin);

  Serial.print("potVal: ");

  Serial.print(potVal);

  

  angle = map(potVal, 0, 1023, 0, 179);
/*
el valor angle es el valor pot reescalado de 0-179 grados
*/

  Serial.print("angle: ");

  Serial.println(angle);

  myServo.write(angle);

  delay(15);

}

Aquí está subida la simulación en circuits.io con el código de arriba:

Y por último, un vídeo de su funcionamiento en formato físico:

Arduino Project 4: Lámpara mezclando colores

Comenzando por la lista de materiales, para esta práctica necesitaremos:

• 1 LED RGB
• 3 resistencias de 220
• 3 resistencias de 10 k
• 3 fotorresistencias

Con el LED RGB, mezclaremos los 3 colores primarios, rojo, azul y verde, para obtener tantos colores como queramos. Esto se hará con diferentes voltajes en cada patilla del RGB para obtener mezclar los colores a nuestro gusto. Aquí una imagen del LED RGB y tanto sus conexiones individuales como las de la práctica montada:  

• R: rojo
• B: azul
• G: verde
• -: tierra

Las fotorresistencias ofrecerán diferentes valores de resistencia según la cantidad de luz que les llegue.

El código usado será el siguiente, comentado por mí:

const int greenLEDPin = 9 ;  //crea la variable para el pin de salida del led verde

const int redLEDPin = 11;    //crea la variable para el pin de salida del led rojo

const int blueLEDPin = 10;  //crea la variable para el pin de salida del led azul

const int redSensorPin = A0;     //crea la variable para la entrada del led rojo

const int greenSensorPin = A1;  //crea la variable para la entrada del led verde

const int blueSensorPin = A2;   //crea la variable para la entrada del led azul

int redValue = 0;     //crea la variable para el valor del voltaje del led rojo

int greenValue = 0; //crea la variable para el valor del voltaje del led verde

int blueValue = 0;  //crea la variable para el valor del voltaje del led azul

int redSensorValue = 0;      //crea la variable para el valor del sensor para el led rojo

int greenSensorValue = 0;  //crea la variable para el valor del sensor para el led verde

int blueSensorValue = 0;   //crea la variable para el valor del sensor para el led azul

void setup(){ //aquí, como siempre, el setup declarado que pines son salidas

  Serial.begin(9600);

  

  pinMode(greenLEDPin, OUTPUT);

  pinMode(redLEDPin, OUTPUT);

  pinMode(blueLEDPin, OUTPUT);

}

void loop(){
/*
con este código, se revisa repetidamente el estado del voltaje que entra por las entradas analógicas en cada pin con el analogRead, después escribe los voltajes según convenga a fin de que salga por las salidas correspondientes a los pines del RGB
*/

  redSensorValue = analogRead(redSensorPin);

  delay(5);

  greenSensorValue = analogRead(greenSensorPin);

  delay(5);

  blueSensorValue = analogRead(blueSensorPin);

  

  Serial.print("Raw SensorValues \t Red: ");

  Serial.print(redSensorValue);

  Serial.print("\t Green: ");

  Serial.print(greenSensorValue);

  Serial.print("\t Blue: ");

  Serial.print(blueSensorValue);

  redValue = redSensorValue/4;

  blueValue = blueSensorValue/4;

  greenValue = greenSensorValue/4;

  

  Serial.print("Mapped SensorValues \t Red: ");

  Serial.print(redValue);

  Serial.print("\t Blue: ");

  Serial.print(blueValue);

  Serial.print("\t Green: ");

  Serial.print(greenValue);

  

  analogWrite(redLEDPin, redValue); //aquí cambia el color del led

  analogWrite(greenLEDPin, greenValue);

  analogWrite(blueLEDPin, blueValue);

}

La simulación en circuits.io es la siguiente:

Y la construcción en formato físico con su funcionamiento es esta:

Arduino Project 3: Love-o-Meter

En esta práctica, construiremos un termómetro rudimentario, para lo que necesitaremos los siguientes materiales:

• 3 led, usaré el color rojo
• 1 sensor de temperatura TMP-36
• resistencias de 220 Ω para cada led

El sensor TMP-36 podemos encontrarlo por 2 € en casi cualquier tienda de electrónica, y nos aporta la ventaja de que el voltaje de salida es directamente proporcional a la temperatura que mide.

El esquema de conexión es el que aparece en la imágen.

Las conexiones son las siguientes:

                                       

De nuevo, esta práctica está enfocada a aprender algo de programación, con la diferencia de que usaremos sensores y, por ende, a tratar señales analógicas.

Usaremos el siguiente código, otra vez comentado por mí para aclarar que hace cada una de sus partes:

const int sensorPin = A0; //establece cual será el pin análogico de entrada de datos (para el sensor)

const float baselineTemp = 20.0; //determina la temperatura base entorno a la cual programaremos

void setup(){

  Serial.begin(9600); //inicia el monitor serial, que podemos abrir arriba a la derecha en la consola de                                    //programación

  for (int pinNumber = 2; pinNumber < 5; pinNumber++){

       pinMode(pinNumber, OUTPUT);

       digitalWrite(pinNumber, LOW);

       }

       }

       

       void loop(){

         int sensorVal = analogRead(sensorPin); //

         Serial.print("Sensor Value:: ");

         Serial.print (sensorVal);

         

         //convierte la señal ADC leída en voltaje

         float voltage = (sensorVal/1024.0)*5.0;

         Serial.print(", Volts: ");

         Serial.print(voltage);

         Serial.print(", degress C: ");

                      //convierte el voltaje en temperatura, en grados centígrados

                      float temperature = (voltage - .5)*100;

                      Serial.println(temperature); //con el siguiente if, haremos que se enciendan los leds                                                                            // que queremos según la temperatura

                      if(temperature < baselineTemp){

                        digitalWrite(2, LOW);

                        digitalWrite(3, LOW);

                        digitalWrite(4, LOW);

                      }

         else if(temperature >= baselineTemp+2 && temperature < baselineTemp+4){

                        digitalWrite(2, HIGH);

                        digitalWrite(3, LOW);

                        digitalWrite(4, LOW);

                      }

                      else if(temperature >= baselineTemp+4 && temperature < baselineTemp+6){

                        digitalWrite(2, HIGH);

                        digitalWrite(3, HIGH);

                        digitalWrite(4, LOW);

                      }

                      else if(temperature >= baselineTemp+6){

                        digitalWrite(2, HIGH);

                        digitalWrite(3, HIGH);

                        digitalWrite(4, HIGH);

                      }

                      delay(1);

                      }

Este código, dará el siguiente resultado en la simulación:

Y su construcción en formato físico nos dará este otro resultado:

Arduino Project 2: Interfaz de nave espacial

Para esta práctica, necesitaremos:

• Resistencias de 220 y 10 kΩ
• 1 botón
• 2 leds rojos y 1 led verde
• Placa arduino y breadboard

Nada más comenzar, nos dan el siguiente esquema de conexión (la resistencia de 10 kΩ esta con el botón para evitar ruido y así obtener una señal clara de este; el resto son las de 220 Ω).

Toda la práctica gira en torno al análisis del código que nos dan, el cual he comentado en cada línea, que es el siguiente:

//se crea la variable que usaremos para saber si el botón esta activo

int switchState = 0;

//setup

// la rutina del setup empieza al resetear y se lee solo una vez

void setup() {

  // inicia los pines digitales como salidas (OUTPUT) o entradas (INPUT)

  pinMode(3, OUTPUT);

  pinMode(4, OUTPUT);

  pinMode(5, OUTPUT);

  pinMode(2, INPUT);

}

// la rutina loop se lee continuamente

void loop() {

  switchState = digitalRead(2);   //HIGH o LOW según el botón este encendido o apagado

  if (switchState == LOW) { //la función if funciona si se cumple su condición (en este caso que la                                                     //entrada del botón este activa, es decir, el botón pulsado)

    //con el boton no accionado

    digitalWrite(3, HIGH);  //enciende el led verde

    digitalWrite(4, LOW);   //apaga el led rojo

    digitalWrite(5, LOW);   //apaga el led rojo

  }

  else { //la función else funciona si no se cumple la condición de un if

    //con el botón accionado

    digitalWrite(3, LOW); //apaga el led verde

    digitalWrite(4, LOW); //apaga el led rojo uno

    digitalWrite(5, HIGH); //enciende el led rojo dos

    delay (250);  //espera un cuarto de segundo (250 milisegundos)

    //cambia el led rojo encendido

    digitalWrite(4, HIGH); //enciende el led rojo uno

    digitalWrite(5, LOW); //apaga el led rojo dos

    delay (250); //espera un cuarto de segundo

  }

    

} //vuelve a empezar la función loop

Adjunto una simulación antes de pasar a compartir la práctica en formato físico:

Y he aquí el resultado en formato físico:

Se recomienda el uso de una pequeña carcasa para tapar el cableado, pero no es necesario tenerla, funcionará igual.

Esta práctica es corta y sencilla, ideal para introducirnos a cómo programar Arduino.

Arduino Project 0: Introducción

Antes de nada, debo comentar que las practicas están en inglés, pero gracias a mi manejo de la lengua, propio de todo experto en Arduino, haré la mejor traducción que pueda.

Bien, en este primer proyecto, se nos introduce al mundo de Arduino, y se nos presentan y explican los elementos que todo proyecto tiene:

Sensores: captan una variable del mundo físico, adaptándola y transformándola en una diferencia de potencial determinada, que podrá ser usada en el circuito.

Actuadores: tienen una respuesta física en función de la señal eléctrica que les llegue.

Microcontroladores: son los que captan la señal de los sensores, la analizan y envían una respuesta a los actuadores en función de lo que esté programado.


Esta primera práctica nos enseña además a ensamblar nuestro kit de Arduino y una introducción general al uso de cada una de las partes de la placa: pines, leds indicadores...

Posteriormente se dan indicaciones de como usar el simulador que proporciona circuits.io y como obtener el programa Arduino IDE, con el que podras desarrollar tu propio código y subirlo a tu Arduino.

Luego, pone un ejemplo de circuito, que hará parpadear un led, con una conexión sencilla y algo de código:

int led = 13; //crea la variable que designará el pin digital 13

// la rutina setup se ejecuta una vez

void setup() {

  //inicia el pin como salida

  pinMode(led, OUTPUT);

}

// la rutina loop se ejecuta repetidamente

void loop() {

  digitalWrite(led, HIGH);   //enciende el LED (HIGH es el nivel de voltaje, 5 V)

  delay(1000);               //espera 1000 milisegundos (1 segundo)

  digitalWrite(led, LOW);    //apaga el LED cambiando el voltaje a 0 V

  delay(1000);               //espera otro segundo

}

Primero, se efectúa la siguiente simulación en la página de Circuits.io, con ese código. Se ve aquí también el diagrama de conexión:




A continuación, un vídeo de su funcionamiento en formato físico (usará el mismo código ya que usa los mismos componentes) y una foto de montaje:

Al iniciar el programa el led comienza a parpadear, encendiéndose y apagándose en intervalos de 1 s.

Para acabar, introduce los conceptos de intensidad, voltaje y resistencia, así como los diagramas y representaciones de varios componentes comunes.

Dentro de poco estará la siguiente práctica.