sábado, 10 de octubre de 2015

Decodificadores en Logisim

Circuitos Con Decodificadores En Logisim
 Decodificador de 3 a 8 con el 74138
El decodificador 74138 es un dispositivo estándar de amplio uso ya sea como elemento electrónico que se consigue en una tienda electrónica o como dispositivo que se puede sintetizar en una FPGA.

La librería empleada en Logisim para la realización del circuito que se observa en el vídeo se puede descargar del siguiente enlace
 En la tabla se observa que las salidas son activas bajas y que para que opere las entras de activación deben conectarse adecuadamente sino las salidas siempre serán uno. 
Tabla de la verdad del 74138
 
Explicación del funcionamiento 

Generación de funciones lógicas con decodificadores

Los decodificadores son también generadores de minterminos por lo tanto con ellos es posible realizar circuitos lógicos combinatorios a partir de tablas de la verdad o ecuaciones boolenas.
El siguiente vídeo explica el principio de operación del decodificador como generador de minterminos para la realización de un circuito que indique si un numero de 3 bits es impar.
 
 
Generación de funciones lógicas


En el vídeo se empleo una compuerta OR con entradas negadas (negativa OR), empleando el teorema de DeMorgan se puede realizar el equivalente lógico correspondiente empleando una compuerta NAND.
En la tabla se observa que /(B.A) = /B + /A que es la equivalencia que se aplica para emplear una compuerta NAND en lugar de una negativa OR 

Tabla con equivalencias lógicas

 
Generación de funciones lógicas parte 2
 

miércoles, 7 de octubre de 2015

Logisim para la simulacion de circuitos logicos

Circuitos Lógicos Digitales Con Logisim
 Logisim es un herramienta que permite la realización y simulación de circuitos lógicos digitales, permite la realización de circuitos básicos hasta circuitos complejos como procesadores.

Conexiones En Logisim
Logisim permite la conexión de varios datos binarios en un solo hilo (bus de datos) . El siguiente vídeo muestra los principios básicos de conexión.


lunes, 7 de septiembre de 2015

Robot Raton Version 1

Construcción Del Robot Ratón V1

Este tipo de robot es muy popular y fácil de construir, la presente es una guía de como hacer uno con componentes fáciles de conseguir.
El robot tipo ratón esta propuesta para que el constructor pueda hacer sus propias variantes e innovaciones y también para que explores con otros materiales, este robot es un reto al ingenio para aquellos que se inician en el mundo de la robótica.
Robot tipo ratón V1

Esta primera versión de este robot tendrá un sistema mecánico para detectar y eludir obstáculos.
En las siguientes versiones se le añadirá mas inteligencia al robot de manera que pueda ser programado con un microcontrolador.

Componentes robot ratón V1

Componentes:

  • Motores
  • Interruptores pulsadores
  • Cables
  • Batería preferiblemente recargable
  • Palo de plástico o madera
  • Clips o alambre

Montaje de los motores

Motores en los extremos del robot
Los motores se pegaran con silicona en los extremos laterales del robot, también se les soldaran dos cables
Vista frontal de los motores en el robot
En este caso se empleo una batería de teléfono para el cuerpo del robot, los motores están pegado con una inclinación de aproximadamente 45 grados.

Configuración de los interruptores

Pulsador de lengüeta de 3 terminales
El terminal C es común a los otros dos terminales NO y NC, ambos están conectados en este terminal.
Si el pulsador no es presionado el terminal NO esta como un interruptor abierto con respecto al punto común, es decir entre los terminales C y NO no hay continuidad a no ser que se presione el interruptor, por esto se dice que el interruptor esta normalmente abierto entre estos dos terminales.
Si el pulsador es presionado el terminal NC esta como un interruptor cerrado  con respecto al punto común, es decir entre los terminales C y NC hay continuidad a no ser que se presione el interruptor, por esto se dice que el interruptor esta normalmente cerrado entre estos dos terminales.
Las conexiones para el robot se harán entre el punto común C y el terminal normalmente cerrado NC.

 
Cables en el punto común y normalmente cerrado

Este tipo de conexión servirá para apagar el motor en caso de que el interruptor sea presionado y abra el circuito.

Referencias y material complementario

 Robot ratón del profe Garcia
Mouse robot

domingo, 6 de septiembre de 2015

Medir la rotación de los motores Lego en Bricx

Rotación De Los Motores Lego NXT

Manejo de los motores y el codificador óptico

Para la odómetria de la plataforma móvil es necesario que el conteo del codificador óptico de rotación pueda ser controlado. Cuando se emplea la función onFwd y OnRev el conteo de la rotacion del motor es reiniciado constantemente y no se puede hacer los calculos necesarios para determinar la posición de la plataforma.

Funciones onFwdex() y onRevex() 

Estas funciones son similares a onFwd() y OnRev() pero con la opción de seleccionar por medio de 5 constantes el modo de controlar el codificador optico (tacometro) de la plataforma móvil, estas opciones son:

Ejemplo 

onFwdex(OUT_AC,100,RESET_NONE);

Los motores del Lego Mindstorm NXT tienen un codificador óptico para determinar cuanto y en que dirección a girado el motor. 
Los sensores tienen una resolución de un grado, es decir esto es lo mínimo que se puede medir.


Función MotorRotationCount

 Vídeo de ejemplo

Retorna el valor en grados de la posición relativa del motor. Hay que indicar el puerto en que esta conectado el motor. El valor que se retorna no vuelve a ser cero después de completar 360 grados, después de un giro el valor siguiente seria 361 grados y así sucesivamente.
Los puertos de conexión para los motores son OUT_A OUT_B OUT_C
El tipo de valor que retorna es long por lo que el valor en grados almacenado puede ser bastante grande.


Ejemplo básico:

long ValorGrados; //variable tipo long donde se guardara el valor en grados
ValorGrados = MotorRotationCount(OUT_A);//Almacena el valor del motor A

Ejemplo de aplicación:

void GirarRobotI(long GRADOS, int POTENCIA){
 long GradosActual;
 long GradosGirados=0;//Inicializar en cero
 GradosActual= MotorRotationCount(OUT_A);
 while(GradosGirados<=GRADOS){
    OnRev(OUT_B, POTENCIA);
    OnFwd(OUT_A, POTENCIA);
    GradosGirados=MotorRotationCount(OUT_A)-GradosActual;
     NumOut(0,0,GradosGirados);
 }
   Off(OUT_AB);
   TextOut(0, LCD_LINE3,"TerminoI");
}
//Funcion para girar el robot a la derecha (en realidad los grados son del motor)
void GirarRobotD(long GRADOS, int POTENCIA){
 long GradosActual;
 long GradosGirados=0;//Inicializar en cero
 GradosActual= MotorRotationCount(OUT_B);
 while(GradosGirados<=GRADOS){
    OnFwd(OUT_B, POTENCIA);
    OnRev(OUT_A, POTENCIA);
    GradosGirados= MotorRotationCount(OUT_B)-GradosActual;
    NumOut(0,0,GradosGirados);
 }
   Off(OUT_AB);
   TextOut(0, LCD_LINE3,"TerminoD");
}

task main(){
     while (true){
     GirarRobotD(180,70);
     Wait(1000);
     GirarRobotI(180,70);
     Wait(1000);
     }
}


lunes, 18 de mayo de 2015

Video Juego de Ping Pong en Processing

Como Hacer Un Video Juego Básico Con Processing

En la presente publicación trata de aplicar varios de los conceptos que se aprenden en los cursos básicos de programación mediante un video juego tipo Ping Pong.

Ejemplo 1
Como desplazar una bola en pantalla y hacer que esta rebote.

Codigo Empleado En Ejemplo 1
int BolaX = 0;
int BolaY = 10;
int IncX = 1;
int IncY = 1;
int AnchoPantalla = 100;
int AltoPantalla = 100;
void setup() {
  size(AnchoPantalla, AltoPantalla);
  frameRate(10);
}
void draw() {
  background(255);
  ellipse(BolaX, BolaY, 10, 10);
  BolaX=BolaX+IncX;
  BolaY=BolaY+IncY;
  println("Posicion Bola X = "+BolaX);
  println("Posicion Bola Y = "+BolaY);
  if (BolaX<=0 || BolaX>=AnchoPantalla) {
    IncX=IncX*(-1);
  }
  if (BolaY<=0 || BolaY>=AltoPantalla) {
    IncY=IncY*(-1);
  }
}  

lunes, 11 de mayo de 2015

Comunicacion serial con Processing y Arduino


Lectura De Datos Seriales Desde Processing

Elaboración básica de un programa en Processing para leer datos enviados desde un microcontrolador, en este ejemplo Arduino.
En este ejemplo solo se hace lectura de datos tipo entero desde Processing.



Instrucciones Empleadas Para La Comunicación
import processing.serial.* : Importa la librería para la comunicación, esta librería ya esta incluida en processing.

Serial MiPuerto: Instancia o declara un objeto que se empleara para el manejo del puerto serial.

Serial.list() : Da un listado de los puertos seriales disponibles en el computador, sirve para determinar en que posición del listado esta el puerto que se empleara en la comunicación

new Serial(this, ListaPuertos[0], 9600): Inicializa el objeto puerto serial, en este ejemplo el puerto que esta en la posición 0 del listado a una velocidad de comunicación de 9600 baudios.

MiPuerto.read() : Instrucción para la lectura de datos enviados por el puerto serial, la lectura se hace del buffer o pila que almacena los datos enviados. El buffer o pila puede almacenar muchos datos que son leídos uno a uno.

MiPuerto.clear() : Limpia el buffer o pila que almacena los datos seriales recibidos, es útil para una lectura inmediata del dato enviado por el microcontrolado a costa de la perdida de datos.

Más informacion se puede consultar en:

Código en Processing

import processing.serial.*;
String ListaPuertos[];
Serial MiPuerto;
int DatoLeido;
float VoltajeLeido;
void setup() {
  println(Serial.list());
  ListaPuertos=Serial.list();
  println(ListaPuertos[0]);
  MiPuerto=new Serial(this, ListaPuertos[0], 9600);
  println(MiPuerto);
}
void draw() {
  DatoLeido=MiPuerto.read();
  println("Dato = "+DatoLeido);
  VoltajeLeido=(float(DatoLeido))*0.019607843;
  println("Voltaje = "+VoltajeLeido);
  MiPuerto.clear();
}
 

Envío de una cadena de caracteres desde Arduino

Processing tiene la clase String que permite hacer manejo de cadena de caracteres lo que facilita el envío y recepción de estas por medio del puerto serial.
En el siguiente ejemplo el envío de la cadena se hace desde la tarjeta Arduino y la recepción se hace en Processing.
La cadena ser recibe desde processing con la instrucción

CadenaRecibida = MiPuerto.readStringUntil('\n');
 
El metodo readStringUntil indica que se hace la lectura hasta que encontrar un salto de linea que se indica con  '\n'  en Arduino se emplea la instrucción
 
Serial.println("Hola Mundo");
 
Para enviar una cadena de caracteres con salto de linea

Código de Arduino

void setup(){
  Serial.begin(9600);
}
void loop(){
  Serial.println("Hola Mundo");
  delay(100);
} 

Código de Processing

import processing.serial.*;
String ListaPuertos[];

String CadenaRecibida;
Serial MiPuerto;
int DatoLeido;
void setup() {
  println(Serial.list());
  ListaPuertos=Serial.list();
  println(ListaPuertos[0]);
  MiPuerto=new Serial(this, ListaPuertos[0], 9600);
  println(MiPuerto);
}

void draw(){
  if ( myPort.available() > 0){
    CadenaRecibida = MiPuerto.readStringUntil('\n');
  } 
  println(CadenaRecibida);
}

Envío de un dato desde Processing a Arduino

En este caso se emplea la instrucción MiPuerto.write() para enviar una dato de byte que puede ser un valor entero o carácter.
En este ejemplo se envía el carácter '1' o su equivalente entero en ASCII que es 49 para encender un led de la tarjeta Arduino.

Código de Arduino

char Dato; 
void setup() {
   pinMode(13, OUTPUT);
   Serial.begin(9600);
 }
void loop() {
   if (Serial.available()){
     Dato = Serial.read();
   }
   if (val == '1') { 
     digitalWrite(ledPin, HIGH);
   } else {
     digitalWrite(ledPin, LOW);
   }
   delay(10);
}  
 

Código de Processing

import processing.serial.*;
String ListaPuertos[];

String CadenaRecibida;
Serial MiPuerto;
void setup() {
  println(Serial.list());
  ListaPuertos=Serial.list();
  println(ListaPuertos[0]);
  MiPuerto=new Serial(this, ListaPuertos[0], 9600);
  println(MiPuerto);
}

void draw() {
  if (mousePressed == true){                          
    myPort.write('1');
  }else {                           
    myPort.write('0');
  }   
}
 

Envío y recepción Processing a Arduino

En este caso se hace tanto envío como recepción de datos entre las dos plataformas.
Se hace el uso de la función establecerComunicacion para garantizar que se ha establecido la comunicación entre las dos plataformas. 

Código de Arduino

char Dato;
boolean EstableComunicacion; 
void setup() {
   pinMode(13, OUTPUT);
   Serial.begin(9600);
   establecerComunicacion();
   EstadoLed=false; 
   EstableComunicacion =false;
 }

void loop()
{
  if (Serial.available() > 0) { 
    Dato = Serial.read();
    if(val == '1'){
       ledState = !ledState; //Cambia de estado
       digitalWrite(13, ledState); 
    }
    delay(100);
  } else {
    Serial.println("Listo para recibir");
    delay(50);
   }
}
void establecerComunicacion() {
  while (Serial.available() <= 0) {
    Serial.println("A");//Envia el caracter A procurando establecer comunicacion 
    delay(300);
  }
} 

Código de Processing

import processing.serial.*;
String ListaPuertos[];

String CadenaRecibida;
Serial MiPuerto;

boolean EstableComunicacion = false; 
void setup() {
  println(Serial.list());
  ListaPuertos=Serial.list();
  println(ListaPuertos[0]);
  MiPuerto=new Serial(this, ListaPuertos[0], 9600);
  println(MiPuerto);

 MiPuerto.bufferUntil('\n');//Envia el evento hasta detectar un fin de linea
}
void draw() {
 //Nada de momento
}
void serialEvent( Serial myPort) {
  CadenaRecibida = myPort.readStringUntil('\n');
  if (CadenaRecibida != null) {//Verifica que la cadena no este vacia
    CadenaRecibida = trim(CadenaRecibida);//Elimina espacios y saltos de linea de cadena
    println(CadenaRecibida);//Muestra en la consola la cadena recibida
    if (EstableComunicacion == false) {//Si no se ha establecido por primera vez la comunicacion
      if (CadenaRecibida.equals("A")) {//Si la cadena recibida es la letra A
        MiPuerto.clear();//Limpia buffer
        EstableComunicacion = true;//Indica que se estableció comunicacion
        MiPuerto.write("A");//Envia el caracter A la la tarjeta Arduino
        println("Se estableció comunicacion");//Muestra en la consola que ya hay comunicacion
      }
    } else {//Ya hay comunicacion con la tarjeta
      println(CadenaRecibida);//Muestra en consola la cadena recibida
      if (mousePressed == true) {//Si el raton es presionado                           
        MiPuerto.write('1');//Envia el caracter 1        
        println("1");//Muestra en consola que se envio el 1
      }
      MiPuerto.write("A");//Envia el caracter A procurando establecer comunicacion
    }
  }
}

domingo, 1 de marzo de 2015

PICDEM Con Pinguino

COMO EMPLEAR LA TARJETA PINGUINO CON PICDEM

Una de la inquietudes con la tarjeta pinguino es su posibilidad de emplearla para aplicaciones compiladas en otros leguajes (CCS, PIC18, COWBASIC). Explorando la Web me encontre con una modificación realizada en la pagina de microembebidos
En la pagina lo que se expone es la implementacion de un Bootloader que descargado en la tarjeta pinguino permite descargar los archivos .hex de las aplicaciones realizadas con otros compiladores diferentes a Pinguino.

ENLACES Y DESCARGAS 
 La instalación no se ha probado en windows 8 , pero quizas necesite la instalacion en modo de controladores no firmados. En windows 8.1 el proceso es un poco diferente, aqui hay uno enlaces con la explicacion

viernes, 20 de febrero de 2015

Sistemas Combinatorios Con Boole Deusto


EJEMPLO DE SISTEMA COMBINATORIOS CON BOOLE DEUSTO

Boole Deusto

Es un entorno para el analisis y diseño de sistemas digitales combinatorios y secuenciales.
Es desarrollado por  Javier García Zubía, Jesús Sanz Martinez, Borja Sotomayor Basilio.
No es necesario registrarse en ninguna web, pero sí es recomendable enviar un correo electrónico a zubia@eside.deusto.es para poder recibir gratuitamente las nuevas versiones del BOOLE-DEUSTO. Basta con enviar el nombre, la universidad o centro de enseñanza, facultad, asignatura y curso en que se usa y número de alumnos que lo usan.

Enlaces de descarga y guias

Videos Tutoriales


jueves, 19 de febrero de 2015

Ascii Art y animaciones en Pseint

ASCII ART

Es una tecnica de computación grafica para realizar graficos empleando los caracteres alfanumericos definidos por el codigo Ascii.
Pseint por tener un terminal de visualizacion solo en texto, puede emplear esta tecnica para mostrar graficos.
Aqui de pueden ver algunos ejemplos:

EDITORES Y GENERADORES DE GRAFICOS ASCII

Los editores y generadores son utiles para realizar estos graficos, algunos de ellos son

 ASCII ART EN PSEINT

En Pseint se debe tener en cuenta que la consola de visualizacion es de 80 de ancho por 25 de alto, asi que los graficos deben ser maximo de este tamaño
Para el curso de programacion la propouesta es la siguiente:

  • Realizar una secuencia de escenas que narren una historia o cuento.
  • La historia debe por lo menos tener amenos 10 escenas diferentes
  • La primer escena debe contar con el nombre del estudiante, código, grupo y titulo del cuento o historia.
  • Por lo menos dos de las escenas debe tener animaciones.
  • En caso de ser extensa la historia, se puede presentar por partes en diferentes pseudocódigos de Pseint.

 Tutoriales y videos pueden encontrase aqui: