Sistemas digitales y sus misterios

Hola, hacía ya mucho tiempo que no escribía nada y a sido debido a que, en clase hemos estado aprendiendo mis compañeros y yo digitales.

Y diréis,¿que es eso?, lo que hemos estado viendo en este trimestre, con respecto a digitales, a sido como hacer el cambio de unidades en decimal a binario, octal, hexagesimal y otras muchas bases, a cada cual más difícil de realizar. También, a medida que aprendíamos estos cambios de base, hemos aprendido, mediante el álgebra de Boole, a representar las distintas funciones lógicas y sacar sus minterms y maxterms, en mi opinión algo que me ha costado mucho de aprender. Si os interesa cómo se realiza y queréis aprender más acerca de ello, os dejo el enlace a la página de donde lo hemos aprendido.


Para terminar con el temario de este último trimestre, aprendimos a simplificar una función lógica a través de las tablas de Karnaugh, las cuales hacen que simplificar las funciones sean más fáciles desde mi punto de vista, a pesar de que cuesta bastante cogerle el truco a como simplificarlo.

Este es un ejemplo de una tabla de Karnaugh, la cual contiene cuatro variable Y,Z,X,T.

Esto a sido todo por el momento, ya que esto es lo ultimo que vamos a tener de temario durante este curso, pero aún nos queda una de las noticias más importantes del curso entero, que vendrá en la siguiente entrada que escriba. 

Un saludo, Alejandro.

Examen de Arduino

¡Buenas a todos! Posiblemente a algunos esta entrada os recuerde a otra subida unos días atrás. El caso es que, por motivos desconocidos, su contenido se borró, y como iba a ser evaluada aquí estoy, subiéndola de nuevo.
Lo que os traigo hoy es un par de alarmas caseras hechas con Arduino. Como ya dijimos, las aplicaciones de este pequeño kit para iniciarse en la programación son infinitas, y aquí tenéis un ejemplo práctico: en un momento podéis montaros vuestra propia alarma.

Alarma 1

const int pinButton = 3;
const int pinFoto = A5;
const int ledVerde = 11;
const int ledRojo = 10;
int buttonState = 0;
unsigned long time;
int foto = 0;

void setup (){
Serial.begin(9600);
pinMode(pinButton, INPUT);
pinMode(ledVerde, OUTPUT);
pinMode(ledRojo, OUTPUT);
}
void (* resetFunc) (void)=0;
void loop (){
  time = millis ();
  foto = analogRead(pinFoto);
  Serial.println(foto);
  buttonState = digitalRead(pinButton);
 
 while (time>2100) {
 
   if (foto<500 && buttonState == LOW ) {
      digitalWrite(ledVerde, HIGH);
      delay(3000);
      resetFunc();
      delay(5000);
   }
    if (foto<500 && buttonState == HIGH ) {
   Serial.print("Call: 092");
   digitalWrite(ledRojo,HIGH);
   delay(3000);
   resetFunc();
  }
  }
 }

Alarma 2

const int pinButton1 = 3;
const int pinButton2 = 4;
const int pinButton3 = 5;
const int ledVerde = 11;
const int ledRojo = 10;

int buttonState1 = 0;
int buttonState2 = 0;
int buttonState3 = 0;

void setup (){
Serial.begin(9600);
pinMode(pinButton1, INPUT);
pinMode(pinButton2, INPUT);
pinMode(pinButton3, INPUT);
pinMode(ledVerde, OUTPUT);
pinMode(ledRojo, OUTPUT);
}
void (* resetFunc) (void)=0;
void loop (){
buttonState1 = digitalRead(pinButton1);
buttonState2 = digitalRead(pinButton2);
buttonState3 = digitalRead(pinButton3);
if (buttonState1 == HIGH && buttonState2 == HIGH && buttonState3 == HIGH) {
  digitalWrite(ledRojo,HIGH);
  delay(1000);
  Serial.print("Call: 092");
}
if (buttonState1 == HIGH && buttonState2 == HIGH && buttonState3 == LOW) {
  digitalWrite(ledRojo,HIGH);
  delay(1000);
  Serial.print("Call: 092");
}
if (buttonState1 == HIGH && buttonState2 == LOW && buttonState3 == LOW) {
  digitalWrite(ledRojo,HIGH);
  delay(1000);
  Serial.print("Call: 092");
}
if (buttonState1 == LOW && buttonState2 == LOW && buttonState3 == LOW) {
  delay(5000);
  digitalWrite(ledRojo,HIGH);
  delay(1000);
  Serial.print("Call: 092");
}
if (buttonState1 == HIGH && buttonState2 == LOW && buttonState3 == HIGH) {
  digitalWrite(ledVerde,HIGH);
  delay(1000);
}
}

La neumática y sus misterios

En esta entrada de hoy lo que voy a enseñaros es lo que hemos estado haciendo durante este tiempo en tecnología industrial.
Desde que dejamos el bloque de arduino, con la ultima entrada que fue la del examen, hemos estado aprendiendo diversas cosas del apartado de neumática. Diréis, ¿que es eso?, bien en lo que consiste es en la transmisión de la energía mediante el aire comprimido, a través de una serie de mecanismos (válvulas, auxiliares, cilindros...) y una serie de circuitos.

A continuación os voy a poner un esquema de lo que sería un circuito de neumática del que hemos tenido que realizar una serie de actividades en clase.

En este esquema podemos encontrar dos válvulas que serían la 1.2 y 1.4 las cuales llegarían a la válvula auxiliar 1.6, la que proporcionaría el aire al cilindro para que el vástago saliera.

Esta es una de los esquemas mas simples que se pueden encontrar, la cosa se puede complicar mucho mas, como en el examen final que hemos tenido que hacer de esto, que madre mía que circuito mas complejo. 

Bueno de momento esto sería más o menos la parte teórica de esta parte de la asignatura aunque sigue quedando la parte practica, la cual empezaré a practicar la semana que viene y con suerte podré haber aprendido lo suficiente para subir otra entrada explicando lo que hemos hecho. 

Espero que os haya servido esta entrada para descubrir un poquito sobre esta parte de tecnología.

Un saludo. Alex

Comenzamos con neumática

Hola a todos de nuevo. Antes de nada, queremos deciros que, dado que terminamos el trimestre en breve, durante las vacaciones no subiremos contenido relacionado con las clases, pero seguramente sí con otros asuntos de la materia.
Dicho esto, os presentamos nuestro último tema a trabajar en clase:  neumática.
Esto que veis aquí es un circuito neumático, una serie de mecanismos que emplean aire a presión para realizar una tarea.  Acabamos de comenzar a ver los componentes, así que cuando terminemos la temporada de exámenes seguramente empecemos en laboratorio a jugar con ello. ¡Hasta entonces!

Prácticas de Arduino

¿Qué he llegado a hacer con Arduino?

Durante todo este tiempo que llevamos con la placa de Arduino hemos estado empezando a programar y aprendiendo pero ha llegado el gran momento, ¡EL EXAMEN!

Bien, pues aquí os tengo que contar lo que he presentado para este examen y para ello voy a poneros a continuación un vídeo con el trabajo realizado, el código con el que lo he hecho posible y una breve explicación de como funciona y los componentes que lleva aunque viene explicado un poco en el propio vídeo.

Bueno pues mi trabajo/examen consiste en de dos partes, una secundaria que sería un regulador de intensidad para un led que e colocado junto al potenciometro (como los reguladores de intensidad de las bombillas de una casa) y de la parte principal y mas difícil de hacer y es un despertador solar, si si, como lo oyes. Aquí tenéis el vídeo de como esta montado y una pequeña explicación de como funciona.

Seguido os dejo el código que he utilizado para realizar este trabajo:

int ledPin = 3;   // Pin para el led que hace de luz regulable
int lightPin = 0; // Pin para la fotoresistencia.
int buzzerPin=9;  // Pin al que se conecta el Buzzer.

void setup() {
Serial.begin(9600);  
pinMode(buzzerPin,OUTPUT);
pinMode(potenciometro,OUTPUT);

}
void loop(){
int valor_pot = analogRead(A5);
int valor_luz = int((float(valor_pot) * 255.0) / 1023.0);
analogWrite(ledPin, valor_luz);      
delay(30);                        
Serial.println(analogRead(lightPin));
analogWrite(buzzerPin, analogRead(lightPin)/4),
delay(100);

}

El funcionamiento del despertador solar es el siguiente:
Al recibir el LDR luz (solar o artificial) lo que produce  que el LDR se active y mande una señal al Buzzer que está conectado a la Arduino y al LDR, y cuando este le manda la señal el Buzzer empieza a sonar.
Al Buzzer se le puede meter cualquier tipo de melodía, aunque yo prefiero una mas tradicional como es un simple pitido.

Espero que os haya gustado u os haya fascinado lo que he podido realizar y nos vemos en un breve tiempo ya con neumática.

Curso Arduino: ¡Manos a la obra!

Bueeeenos días, Vietnam. Soy Álvaro, y hoy voy a subir una breve entrada enseñándoos a programar vuestros primeros programas de Arduino. Para ello tan necesitaréis:

-Placa de vuestra elección (cada modelo tiene funcionalidades específicas)
-Un ordenador a mano
-Un cable USB de impresora
-Software oficial de Arduino para comenzar a hacer vuestros códigos, el cual os podéis bajar de aquí
-Un kit de iniciación de Arduino, en el que se incluyan los elementos básicos (cables, leds, botones, etc)


¿Lo tenéis todo? Pues al lío. En el curso de hoy cargaremos nuestro primer código y veremos su funcionamiento, para en los siguientes dedicarnos a comprender el funcionamiento tanto de C++ como de los distintos componentes que nos hemos comprad, profundizando cada vez más.
Lo primero que haremos es bajarnos el software del link que os hemos puesto un par de líneas encima. Una vez que lo tengáis descargado e instalado, lo ejecutamos y conectamos nuestro Arduino al ordenador. Aseguraos de conectarlo al puerto USB más rápido que tengáis para facilitar la compilación más tarde.


Tras conectarlo, aseguraos de que el programa ha reconocido la placa adecuadamente. Para ello, id a Herramientas > Puerto, y seleccionad COM3 si no está ya por defecto. En caso de tener un modelo distinto al Arduino UNO, después acceded A Herramientas > Placa y seleccionad el vuestro.

Ahora es cuando comenzamos con nada más y nada menos que nuestro primer código. Ya aprenderemos a hacer los nuestros propios, pero para habituarnos a el funcionamiento del lenguaje, vamos a cargar uno ya hecho. ¿Cómo? Muy fácil: vamos a Archivo > Ejemplos > Basics > Blink, y ya tenemos el más sencillo de los códigos que podemos hacer. Este consiste en encender un led un segundo y apagarlo otro. No os apabulléis por ese monton de paréntesis y números: con el tiempo aprenderemos a manejar esto cual programador de Skype... Bueno, de Skype no, que eso va peor con cada actualización... BUENO, QUE LO CONTROLAREMOS DE LUJO. Hoy por hoy vamos a limitarnos a darle al botón de COMPILAR, esa flecha junto al tick de confirmación, y... ¿Le ocurre algo a vuestra placa? Exacto, esa pequeño led que lleva incorporado está parpadeando al ritmo que le manda el código que acabáis de cargar...
Poco vistoso, ¿no? Pues si queréis darle un poco más de caña, que para algo nos hemos comprado el kit de iniciación, vamos a mirar la imagen de aquí abajo:

Ahora, conectaremos nuestros cables de la placa a nuestra breadboard como se indica en el esquema. Aseguraos de que la resistencia que usáis es de 330K Ohmnios, y que esta va conectada a la pata corta del led que uséis (el color da igual). ¿Lo tenemos? Pues no hace falta que volváis a cargar el código: observad el led, que ahora parpadea con el ritmo que el código le indica.
Empezad a trastear con los delays, los pines, añadidle más leds... Lo que queráis, vamos: así es como mejor se aprende a programar.
¡Esperemos que os haya gustado este primer curso de Arduino! ¿Tenéis alguna sugerencia? Dejadnos un comentario diciéndonos qué mejorar para el próximo número. ¡Nos vemos!