Progra, Mecatronica y mas

INDICE DE ENTRADAS

2020-07-21T09:48:00.000-07:00

IntelliJ 14 KeyGen

2016-09-30T13:18:00.004-07:00

I don't like to post KeyGen in this blog or any sort or crack but the code for the keygen is pure Java and it's very educative.

<<No me agrada publicar KeyGen's o cracks de ningún tipo, pero ya que el código es Java simple y es sumamente educativo, lo haré aquí.

So, the KeyGen for IntelliJ 14 Ultimate is:
El KeyGen para IntelliJ 14 Ultimate es:

Archivo keygen.java:

import java.math.BigInteger;
import java.util.Date;
import java.util.Random;
import java.util.zip.CRC32;

public class keygen
{
/**
* @param s
* @param i
* @param bytes
* @return
*/
public static short getCRC(String s, int i, byte bytes[])
{
CRC32 crc32 = new CRC32();
if (s != null)
{
for (int j = 0; j < s.length(); j++)
{
char c = s.charAt(j);
crc32.update(c);
}
}
crc32.update(i);
crc32.update(i >> 8);
crc32.update(i >> 16);
crc32.update(i >> 24);
for (int k = 0; k < bytes.length - 2; k++)
{
byte byte0 = bytes[k];
crc32.update(byte0);
}
return (short) (int) crc32.getValue();
}

/**
* @param biginteger
* @return String
*/
public static String encodeGroups(BigInteger biginteger)
{
BigInteger beginner1 = BigInteger.valueOf(0x39aa400L);
StringBuilder sb = new StringBuilder();
for (int i = 0; biginteger.compareTo(BigInteger.ZERO) != 0; i++)
{
int j = biginteger.mod(beginner1).intValue();
String s1 = encodeGroup(j);
if (i > 0)
{
sb.append("-");
}
sb.append(s1);
biginteger = biginteger.divide(beginner1);
}
return sb.toString();
}

/**
* @param i
* @return
*/
public static String encodeGroup(int i)
{
StringBuilder sb = new StringBuilder();
for (int j = 0; j < 5; j++)
{
int k = i % 36;
char c;
if (k < 10)
{
c = (char) (48 + k);
}
else
{
c = (char) ((65 + k) - 10);
}
sb.append(c);
i /= 36;
}
return sb.toString();
}

/**
* @param name
* @param days
* @param id
* @param prtype
* @return
*/
public static String MakeKey(String name, int days, int id)
{
id %= 100000;
byte bkey[] = new byte[12];
bkey[0] = (byte) 1; // Product type: IntelliJ IDEA is 1
bkey[1] = 14; // version
Date d = new Date();
long ld = (d.getTime() >> 16);
bkey[2] = (byte) (ld & 255);
bkey[3] = (byte) ((ld >> 8) & 255);
bkey[4] = (byte) ((ld >> 16) & 255);
bkey[5] = (byte) ((ld >> 24) & 255);
days &= 0xffff;
bkey[6] = (byte) (days & 255);
bkey[7] = (byte) ((days >> 8) & 255);
bkey[8] = 105;
bkey[9] = -59;
bkey[10] = 0;
bkey[11] = 0;
int w = getCRC(name, id % 100000, bkey);
bkey[10] = (byte) (w & 255);
bkey[11] = (byte) ((w >> 8) & 255);
BigInteger pow = new BigInteger("89126272330128007543578052027888001981", 10);
BigInteger mod = new BigInteger("86f71688cdd2612ca117d1f54bdae029", 16);
BigInteger k0 = new BigInteger(bkey);
BigInteger k1 = k0.modPow(pow, mod);
String s0 = Integer.toString(id);
String sz = "0";
while (s0.length() != 5)
{
s0 = sz.concat(s0);
}
s0 = s0.concat("-");
String s1 = encodeGroups(k1);
s0 = s0.concat(s1);
return s0;
}

public static void main(String[] args)
{
if (args.length == 0)
{
System.err.printf("*** Usage: %s name%n", keygen.class.getCanonicalName());
System.exit(1);
}
Random r = new Random();
System.out.println(MakeKey(args[0], 0, r.nextInt(100000)));
}
}

If you want to get your Key for IntelliJ14 Ultimate do the following:
>>Si deseas obtener tu clave para IntelliJ 14 Ultimate haz lo siguiente:

Instructions:

Create a folder in your desktop (or somewhere)
Create a text file inside that folder with the name: keygen.java
Copy and paste the code above in the text file, save and exit
Open a terminal and go to that folder
Compile the file:

$ javac keygen.java

Execute the progam using the username you want:

$ java keygen yourusername

Enjoy.

Instrucciones:

Crea un folder en tu escritorio (o donde sea)
Crea un simple archivo de texto dentro de ese folder y llámalo: keygen.java
Copia y pega el código Java de arriba en el archivo, guardalo y cierra
Abre una terminal y navega hasta dicho folder
Compila el programa java:

$ javac keygen.java

Ejecuta el programa usando el nombre de usuario que deseas:

$ java keygen yourusername

Disfruta.

Example:

>> Ejemplo:

Dell xps m1330 - No enciende y la luz el cargador se apaga

2015-04-27T07:01:00.005-07:00

Troubleshooting Dell xps m1330.

No Power, Charger light turns off.

Para esta ocasión les traigo el problema de un amigo, su Dell xps m1330, la cual coloco a continuación ya no encendia, se apago un día mientras estaba trabajando y ya no quiso encender.

Dell xps m1330 - Después de reparada

La falla se debió a que un capacitor interno entro en corto circuito causando que el circuito de alimentación que va a la batería quedara sin voltaje y a vez toda la tarjeta madre.

El dichoso capacitor era el C10 que esta en la parte superior de la tarjeta madre justo a un lado del conector a la batería y por debajo de la parte superior del teclado.

PROBLEMA

Si tu laptop DELL sufre de los siguiente síntomas lo mas seguro es que esta sea la causa:

No enciende. (Nada, ni una luz)
Al momento de conectar el cargador este se apaga (a primera vista pareciera que el cargador es el problema).

La información acerca del problema fue encontrada en los siguientes sitios:

SOLUCIÓN

Desoldar dicho capacitor (C10), el cual no sirve para nada, así es, su única función es echar a perder la laptop completa. Una vez desoldado pueden conectar la laptop de nuevo y verán como enciende como nueva.

NOTA: Es posible que sirva para algo pero al no tener el esquemático de la tarjeta madre es difícil saber, lo mas seguro es que solo sea para estabilizar voltaje.

IMÁGENES
Aquí unas imágenes que espero les sirvan de guía.

Dell xps m1330 desarmada. El cuadro rojo muestra la ubicación del capacitor C10

Ubicación exacta del capacitor C10.

Capacitor C10 removido. Ahora ya todo debe funcionar bien.

Cálculo del Sueldo Bruto e ISR a partir del Sueldo Neto - México

2015-04-17T19:58:00.000-07:00

Si eres contador o la persona encargada de Nóminas esto sin duda te interesa.

Cuantas veces has querido obtener el sueldo bruto e ISR del salario si solo tienes el sueldo neto a pagar a tus trabajadores?.

Sonará extraño pero así es, si tu empresa es de esas que paga por proyectos, normalmente la empresa promete X cantidad de dinero como remuneración por los servicios, digamos $15,000MXN, pero un momento, eso es lo que le prometiste al contratista del proyecto que le vas a pagar, y como demonios calculas el ISR a declarar ante hacienda?

Esta calculadora por el momento solo permite hacer el cálculo basado en un sueldo mensual.

Utiliza esta aplicación WEB que coloco aquí mismo, fue desarrollada como proyecto final para de mis materias en la UANL, FIME. México. Si experimenta problemas usando Iinternet Ecxplorer por favor pruebe en Chrome.

--------------------------------------------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------------------------------------------
Las tablas usadas como fuente de datos fueron:

Tarifa mensual del ISR (DOF 5 de enero de 2015)

Límite inferior	Límite superior	Cuota fija	Por ciento para aplicarse sobre el excedente del límite inferior
$	$	$	%
0.01	496.07	0.00	1.92
496.08	4,210.41	9.52	6.40
4,210.42	7,399.42	247.24	10.88
7,399.43	8,601.50	594.21	16.00
8,601.51	10,298.35	786.54	17.92
10,298.36	20,770.29	1,090.61	21.36
20,770.30	32,736.83	3,327.42	23.52
32,736.84	62,500.00	6,141.95	30.00
62,500.01	83,333.33	15,070.90	32.00
83,333.34	250,000.00	21,737.57	34.00
250,000.01	En adelante	78,404.23	35.00

Tabla del subsidio para el empleo

Monto de ingresos que sirven de base para calcular el impuesto
Para Ingresos de	Hasta Ingresos de	Cantidad de subsidio para el empleo mensual
$	$	$
0.01	1,768.96	407.02
1,768.97	2,653.38	406.83
2,653.39	3,472.84	406.62
3,472.85	3,537.87	392.77
3,537.88	4,446.15	382.46
4,446.16	4,717.18	354.23
4,717.19	5,335.42	324.87
5,335.43	6,224.67	294.63
6,224.68	7,113.90	253.54
7,113.91	7,382.33	217.61
7,382.34	En adelante	0.00

Fuente: http://contadormx.com/2015/01/05/tablas-isr-2015-y-subsidio-mensual-calculo-de-nomina-sueldos-y-salarios-2015/

Afilicación del Seguro Social

2014-03-04T08:20:00.000-08:00

Bueno, si eres Mexicano/a y necesitas afiliarte al IMSS (darte de Alta por primera vez, obtener tu Numero de Seguro Social NSS) por diversos motivos, ya sea que vas a comenzar a trabajar o que por alguna razón simplemente ocupas el mendigo número he aquí la solución más rápida de tenerlo y todo es a través de internet.

Si ya cuentas con tu número pero no lo recuerdas puedes usar los mismos pasos mencionados abajo, simplemente no tendrás que escribir todos tus datos.

Documentos requeridos:

CURP
Dirección de correo electrónico (email)
Tu domicilio completo

Pasos:

Ingresa a la siguiente página: IMSS
Escribe tus datos (CURP, email)
Localiza tu domicilio actual
Aceptar.

El sistema te arrojará tu NSS (Número de Seguro Social), lo puedes guardar como PDF para imprimirlo y aparte te lo envía a tu email.

Ahora es muy fácil, creo que ya he recuperado un poco de esperanza en mi país.

Biomecánica de Rodilla

2014-01-27T07:25:00.005-08:00

La siguiente investigación tiene por fin dar a conocer un poco acerca de la biomecánica. En especial acerca de lo que una parte del cuerpo muy importante, La rodilla:

https://proyect-general-es.googlecode.com/svn/branches/Main/Investigacion_Biomecanica_Rodilla.pdf

Checa la wiki:

https://code.google.com/p/proyect-general-es/wiki/Biomecanica_de_Rodilla

"Dicho trabajo de investigación fue realizado por mí y todo el material dentro del mismo pertenece a diversos autores de diferentes libros y páginas web señalados en el mismo, si deseas usar alguna información por favor incluye un link a esta entrada y marca en tu bibliografía a los autores que hicieron posible mi investigación. Gracias"

Basic ECG con Arduino y C#

2014-01-03T13:03:00.001-08:00

Introduction

El proyecto completo puede ser descargado por SVN usando: https://proyect-general-es.googlecode.com/svn/branches/Main/ECG_Basic/

Esta página de la wiki está diseñada con el propósito de dar a conocer una manera sencilla y práctica de hacer un ECG muy pero muy básico que sirva como una pequeña introducción al mundo de las señales mioeléctricas.

Dos presentaciones en PPTX fueron desarrolladas, estas contienen mucha información útil:

(El circuito final mostrado en dichas presentaciones está desactualizado, favor de leer esta página completa o la Tesis para comprender a detalle el proyecto)

Todo el trabajo realizado durante el semestre se reduce a la pequeña Tesis a continuación, esta contiene todo lo presentado en esta página y más: Tesis

Así queda al final

Posición de los electrodos

Objetivo

El objetivo de este proyecto bien podría ser el diseño y la creación de un aparato capaz de poder registrar las variaciones eléctricas del corazón por medio de métodos no invasivos, es decir, hacer un electrocardiógrafo fiable, portátil y que pueda ser vendido en el creciente mercado de la medicina. Por desgracia en la universidad el equipo necesario para desarrollar este tipo de investigaciones es muy limitado y la disposición del mismo no es para tiempos flexibles (solo podemos usar el equipo en horarios establecidos y eso que estamos hablando de un simple osciloscopio y una computadora), el presupuesto que destina la universidad para proyectos de este estilo es nulo, es decir no existe (cabe mencionar que el alumno mismo costea todo el proyecto). Con todas estas limitantes no se puede esperar a que el alumno logre un proyecto exitoso al 100% ni mucho menos una investigación a conciencia, M´exico no está preparado aun para nada de esto.

Para ver el proyecto completo accede a mi wiki: https://code.google.com/p/proyect-general-es/wiki/ECG_Basic

Glucómetro. Detector de glucosa sanguínea por medio de Infrarrojos con Arduino y C#

2014-01-03T09:55:00.002-08:00

Si deseas descargar el proyecto completo usa: https://proyect-general-es.googlecode.com/svn/branches/Main/Glucometro/

Se pretende crear un dispositivo medidor de glucosa (al que llamaremos Glucómetro) que sea capaz de comunicarse con una PC, con un dispositivo Android o que pueda ser usado de manera independiente.

La conexión a la PC se piensa manejar por medio de USB as´ı como con Android. Para que nuestro Glucómetro sea capaz de funcionar de manera independiente sin una PC o dispositivos Android conectados es necesario que posea una interfaz, dicha interfaz se ha propuesto crearla por medio de componentes que se tengan ya a la mano, es decir push-buttons.

El sistema completo constará de dos placas, una Shield para el Arduino y una placa que llamaremos "Placa IR" donde irán montados los LED's IR y el Transistor IR (esta última placa irá montada junto con la parte "mecánica" es decir, el soporte para las laminillas con la muestar de sangre)

Para ver el proyecto completo consultalo en mi wiki:

https://code.google.com/p/proyect-general-es/wiki/Sensor_Glucosa

This BLOG is deprecated. Actualización de mi blog.

2013-12-31T09:01:00.003-08:00

A partir de Enero 2014 dejaré de usar este blog para mis proyectos y ahora utilizaré mi wiki de googlecode, esto principalmente a que la oportunidad de poder subir todo mi código por SVN, incluído el archivo .wiki.

Seguiré publicando nuevas entradas aquí para que los seguidores no pierdan el hilo:

https://code.google.com/p/proyect-general-es/

Evitar Cache del Navegador con Javascript

2013-05-30T07:37:00.002-07:00

Antes que nada una breve explicación del problema:

El navegador guarda en "caché" una copia de la página web, esto para evitar hacer un "request" al servidor cada vez que se visita, esto es bueno en la mayoría de las circunstancias ya que agiliza el cargar la página WEB (por supuesto que ni siquiera pregunta al servidor por tanto no que se ejecute una llamada HTTP en este sea GET sea POST...), pero si estas desarrollando esto llega a ser un dolor de cabeza.

Mi problema (si deseas leerlo):

Estoy trabajando por el momento con un modulo FlyPort, el cual crea un WebServer por medio de AdHoc, y a través de llamadas GET y POST controlo acciones en el Microcontrolador PIC embebido. El problema está en que si el BENDITO navegador guarda la pagina WEB en caché y la despliega en lugar de ejecutar un GET nunca lograré invocar ningún evento en el Micro. Lo cual me convierte en HULK =( cada vez que pasa.

Este problema se me ha presentado y una solución que he implementado y que me ha funcionado al 100% para "evitar" que el navegador despliegue repetidamente la pagina en caché, es de agregar un parametro al azar que haga que cada URL siempre sea diferente y unica y así "forzar" al navegador a siempre hacer una llamada el server.

Por ejemplo:

Deseas ejecutar la URL simsynchro.html?cmd=5 pero al momento de ejecutarla no ves cambios, esto porque el navegador ha guardado en caché la respuesta del server a esta URL. Agregando un parámetro al azar solucionas todo, por tanto:

var url = "simsynchro.html?cmd=5";

var date = new Date();

var dummyDateParam = "&dummy=" + (date.getMonth() + 1) + "/" + date.getDate() + "/" + date.getFullYear() + "_" + date.getTime();

url += dummyDateParam;

window.location = url;

Deberías crear una función que te agregue de manera automática el parámetro y listo.

TAGS:

Avoid Browser Caché
El navegador guarda caché
Refrescar Javascript
Navegador no ejecuta script
Javascript no se ejecuta
Evitar que el navegador guarde caché
FlyPort AJAX
AJAX no funciona
AJAX no se ejecuta
FlyPort not executing GET

Control de Motores (AC y DC) por medio de la Computadora

2013-05-16T00:44:00.000-07:00

Control de Motor Monofásico, On/Off por medio de una Computadora Personal.
Control de 2 Motores DC, On/Off y sentido de giro por medio de una Computadora Personal

Introducción

En el presente proyecto tuvo como finalidad de dejar al laboratorio un dispositivo capaz de permitir el controlar varios motores eléctricos por medio de la computadora, se construyo un driver con micro-controlador se hizo uso de comunicación USB-Serial, se desarrollo una Interfaz Hombre-Maquina echa en C#, se uso un motor de AC y dos de DC.

Control de Motor AC
En la clase se estudia cómo se controlan diferentes tipos de motores, en el salón se dispone de un motor monofásico, a este no se nos fue posible controlar el sentido de giro ya que los 2 embobinados, el de arranque y el trabajo, están unidos en los cables de sus “neutros” por lo que no se puede invertir las terminales, como no se pudo controlar la dirección, se agregaron dos motores de corriente directa para demostrar que el sentido de giro puede ser cambiado en un motor.
Cabe mencionar que el trabajo anterior, tenía un tablero para cambiar el sentido de giro del motor monofásico; pero se hacía un corto circuito y esto ocasionaba que el motor empezara a fallar y producir humo, puesto que esa operación forzada pudiera dañar al motor, se cambió el circuito que traía puesto que los dispositivos no trabajaban como debían así como los interruptores de cambio de giro.

Desarrollo

Figura 1.- Diagrama de Subsistemas de la función controlar un motor.

Matariales:

1) Motor de Corriente Alterna:

Para saber cómo funciona el motor se hicieron diferentes pruebas, al motor encontrando la siguiente información:

• Motor, 3-3358-4 333584 del secador de Maytag

• Modelo S58NXEET-2895

• Potencia, 1/4B

• Voltaje 115 AC

• RPM 1725

• 60 Hz.

• 6 Amperes.

• CL B 40 °C

Figura 2.- Etiqueta de datos del fabricante del motor monofásico.

Figura 3.- Fotografía del motor monofásico del laboratorio.

Como se aprecia en las fotografías se tienen 3 cables de diferentes colores, los cuales se identificaron como:
• Amarillo -> Fase del embobinado de trabajo
• Azul -> Neutro del embobinado de trabajo
• Negro -> Fase del embobinado de arranque

Figura 4.- En la imagen de arriba se muestra como se cree que es el arreglo de las terminales de las bobinas del motor de AC.

El trabajo anterior tenía dos interruptores de palanca, uno de encendido y otro de dirección, los cuales al hacer girar el motor a favor de las manecillas del reloj no había problema, pero al momento de hacerles girar en contra se ponía al cable azul sin conectar, el amarillo se llevaba a la fase y el negro al neutro; si se seguía con esta operación se quemaría el motor puesto que sacaba humo después de un rato.

Figura 5.- Diagrama de conexiones cuando se forzaba a girar en sentido contrario al motor de AC.

Se podía hacer girar el motor desconectando el bobinado de arranque, desconectando el cable negro, dejando alimentados los demás con CA; pero se requería girar el eje manualmente hacia el lado deseado.

Para poder invertir su sentido de giro hay que invertir solo las terminales del bobinado de trabajo sin invertir las de arranque pero con lo anteriormente expuesto no se podía controlar el motor de AC.

Para poder controlarlo, por medio de la computadora; solo se requiere decirle al micro-controlador que encienda al motor, como este solo trabaja a 5V requerirá de otro dispositivo que lo encienda para ello se hizo uso de un relevador activado por el micro-controlador, que al cerrarse alimentara al motor con 127 AC ~.

Figura 6.- Arriba parte del esquemático donde se muestra al micro-controlador activando y desactivando al relevador, en el circuito se puso en paralelo e invertido un diodo con respecto a la bobina del relevador para evitar que las contracorriente dañen al dispositivo.

2) Control de motor DC:

Como no se pudo hacer el cambio de giro del motor AC, se anexaron dos motores de DC para demostrar el sentido de cambio todo controlado por la computadora. Para esto se hizo uso de un puente H, en circuito integrado sin diodos de rodada estos se tuvieron que poner externos.

Figura 7.- Arriba se muestra la sección del esquemático para el control de 2 motores de DC, se hizo uso del circuito integrado L293. Las señales de sentido de giro son mandadas desde el micro-controlador.

3) Micro-controlador:

Se eligió para este trabajo el uso del micro-controlador PIC16F877P para mandar los pulsos de señal, así como recibir las instrucciones de la computadora por medio de puerto serial.

Figura 8.- Esquemático del micro-controlador usado.

Figura 9.- Arriba se muestran las conexiones al PIC para primero hacer el parpadeo de un led que nos asegurara que el PIC trabaja bien y segundo unas terminales para poder reprogramar al PIC In Circuit Program

Figura 10.- En la imagen de arriba se muestran las conexiones de la comunicación serial echa por medio de un MAX233.

Figura 11.- Esta parte del esquemático muestra que la alimentación de todos los dispositivos a 5 V será interrumpida por un interruptor de palanca, para hacer el encendido y apagado.

Figura 12.- En la imagen de arriba se muestran las entradas que tendrá el PIC para ser controlado por un tablero y así tener una botonera para controlar los motores cuando no se disponga de una computadora, en el dibujo no se aprecia pero todas las 8 conexiones tienen un diodo que va a un 9° pin del micro este es para hacer que lea el estado del teclado.

Interfaz Hombre-Maquina

Se desarrollo una interfaz de manera que simulara los tipos de tableros que se manejan físicamente para control de maquinas rotativas o en lineas de producción, algunas de las características de la interfaz se basaron en las recomendaciones del los estándares de la <<referencia 1>>. La interfaz es gráfica y hace uso de imágenes para su manejo, el usuario puede interactuar con ella para el control de los motores, también presenta bloqueos de seguridad (los botones de inhabilitan) dependiendo de las operaciones. En el vídeo del final se pueden apreciar las funciones de todo el proyecto.

En la imagen de arriba, se muestra el primer prototipo de la interfaz para el usuario final.

En la imagen de arriba, se muestra la interfaz aprobada para su uso.

Vídeo del Proyecto:

Conclusiones:

Interfaz H-M. Vemos que el resultado final es mas amigable que el prototipo presentado, los botones son mas fáciles de diferenciar, la consola de comunicación se coloco por debajo del área del trabajo, ya que en sí no es necesaria para el operador, es importante para los desarrolladores de la interfaz para saber si ocurre algún error con la comunicación serial; también esta la parte que comienza la comunicación serial, que sera usada por operarios y desarrolladores.

Referencias:

1.- NFPA 79: Electrical Standard for Industrial Machinery, 2002 Edition
2.- http://esp.ebay.com/viewItem?item=110766848335&v=gbh
3.- http://html.rincondelvago.com/motores-de-induccion-monofasicos-asincronos.html

Anexo A (Programas Utilizados):

Microsoft Visual Studio 2010
PIC C Compiler (PCWHD Compiler, CCS inc.)
Eagle PCB Software
Solid Works 2010

HCS08 - Motorola Freescale - Contador 0 a 99 en 2 Display 7 Segmentos

2013-04-04T01:08:00.001-07:00

Para ayudar a varios compatriotas en mi Universidad me he dispuesto a crear esta entrada.. bla bla bla

A lo bueno.

NOTA: Se seguirá usando para programar el microcontrolador el debugger ICSP tan usado en anteriores entradas (BDM).

Descripción del Proyecto.

Crear una cuenta de 0 a 99, la cual se incrementará en una unidad cada segundo, esta cuenta será en sistema decimal y los resultados de la misma serán mostrados en dos display de 7 segmentos, uno por digito.

Se usaran dos transistores 2N3906 como conmutadores para activar cada uno de los display de 7 conectando el común de estos al transistor los cuales por medio de un pulso en su Base activaran o desactivaran el display a conveniencia.

Se usan también dos Buffers de corriente CD4050 para que la corriente demandada por cada display se cargue sobre estos y no sobre los microcontroladores y que este ultimo solo tenga la acción de mandar pulsos lógicos de voltaje.

Contador digital

Un contador digital es básicamente un circuito electrónico que muestra un cambio cada cierto periodo de tiempo establecido, este periodo de tiempo es común que sea ajustable.

Estos cambios se pueden manifestar de diferentes maneras de acuerdo a lo que se desee lograr, como por ejemplo, mostrar una cuenta de números en cualquier tipo interfaz visual, o activar cierto relé que a su vez crear más cambios.

También son usados como una manera sencilla de realizar acciones cada cierto tiempo.

En nuestro caso, nuestro contador mostrara una cuenta de números decimales del 0 al 99 mostrado en dos display de 7 segmentos, esta cuenta se incrementara en intervalos de una unidad cada segundo que pase.

Display de 7 segmentos

Los Display de 7 segmentos son básicamente un arreglo de leds ordenados de tal forma que encendiendo unos cuantos de estos puedes formar números y algunas letras, en otros símbolos.

Hay dos distintos, ya sea cátodo común o ánodo común, esto debido a que los leds dentro de los mismo tienen todos interconectados a un mismo punto el cátodo o el ánodo.

Por tanto conectando este punto común a una fuente de voltaje (para el caso del ánodo común) se puede encender cada led interno mandando un estado lógico bajo o a tierra (para el caso del cátodo común) y mandándole un pulso lógico alto.

Transistor PNP 2N3906

El transistor es un dispositivo semiconductor que cumple varias funciones, entre ellas están las de amplificador, oscilador, conmutador o rectificador. En este caso lo usaremos de conmutador para crear la acción de barrido en los display de 7 segmentos.

Esquematicos

Descarga: pdf

CODIGO

;*******************************************************************
;* This stationery serves as the framework for a user application. *
;* For a more comprehensive program that demonstrates the more     *
;* advanced functionality of this processor, please see the        *
;* demonstration applications, located in the examples             *
;* subdirectory of the "Freescale CodeWarrior for HC08" program    *
;* directory.                                                      *
;*******************************************************************

; Include derivative-specific definitions
            INCLUDE 'derivative.inc'
;
; export symbols
;
            XDEF _Startup
            ABSENTRY _Startup

;
; variable/data section
;
            ORG    RAMStart         ; Insert your data definition here
ExampleVar: DS.B   1
contador:    equ  $90
unidades:   equ   $92
unidadesA:  equ   $93          
decenas:    equ   $94
decenasA:   equ   $95
tope:       equ   $96

;
; code section
;
            ORG    ROMStart

_Startup:
            LDHX   #RAMEnd+1        ; initialize the stack pointer
            TXS
            CLI                     ; enable interrupts

PROG_PORTS:  
            MOV   #$FF,PTBDD         ;puerto B salida
            MOV   #$FF,PTCDD         ;declaramos puerto C como salida            
            MOV   #$64,RTCMOD        ;declaramos timer a un segundo, con tope el 100=$64
            MOV   #%1111,RTCSC
            
            MOV   #$00,contador       ;iniciamos el contador con cero
            MOV   #$00,unidades       ;inicializamos unidades y decenas
            MOV   #$00,decenas
            
                        ;cargamos el valor de ajuste a disp 7 segm en las memorias
            MOV   #111111,$80      ;ajuste del 0
            MOV   #000110,$81      ;ajuste del 1
            MOV   #%01011011,$82
            MOV   #%01001111,$83
            MOV   #%01100110,$84
            MOV   #%01101101,$85
            MOV   #%01111101,$86
            MOV   #000111,$87
            MOV   #%01111111,$88
            MOV   #%01100111,$89      ;ajuste del 9
            
main:
            feed_watchdog
            BSR   checa_cuenta        ;vamos a la subrutina que lleva la cuenta en unidades y decenas
            BSR   ajusta_unidades             ;subrutina que ajusta el valor de unidades y decenas para desplegarlo en el disp 7 segm
            BSR   ajusta_decenas
            LDA   unidadesA           ;cargamos unidades y decenas ajustadas y las mostramos en el display
            STA   PTBD
            MOV   #%10,PTCD
            BSR   retardo
            LDA   decenasA
            STA   PTBD
            MOV   #%01,PTCD
            BSR   retardo
            LDA   contador            ;checamos si se paso del 99
            CBEQA #$64,hacercero 
            BRA   main
;subrutina que regresa a cero todo
;-------------------
hacercero:
            MOV   #$00,unidades
            MOV   #$00,unidadesA
            MOV   #$00,decenas
            MOV   #$00,decenasA
            MOV   #$00,contador
            BRA   main


            
;--------------------------------
            
;--------------Rutina checa cuenta
checa_cuenta:
                LDA   RTCCNT
                CMP   contador
                BNE   incrementa_cuenta             ;si no es el mismo numero, es decir, ya cambio (ya paso el tiempo programado)
                RTS                                 ;si es el mismo, regresamos
                
incrementa_cuenta:
                LDA   RTCCNT                        ;como no son iguales, los hacemos iguales
                STA   contador
                INC   unidades                      ;si las unidades completa una decena
                LDA   unidades                      ;regresamos a cero unidades y decenas +1
                CMP   #$A
                BEQ   una_decena_mas
                RTS                
una_decena_mas:
                MOV   #$00,unidades
                INC   decenas
                RTS
;--------------termian rutina checa cuenta            
;---------------------*******Subrutina de retardo                
retardo:       
            LDHX  #$0000
RET1:        
            feed_watchdog
            AIX   #$01
            CPHX  #$FF            ;Se incrementa este valor para hacer un retardo mas largo
            BNE   RET1
            RTS
;-----------------------****Termian el retardo

;.---------------------------Subrutinas de ajuste            
ajusta_unidades:
                LDHX    #$80                    ;apuntamos a la memoria $80, que es donde empiezan los valores de ajuste
                MOV     #$80,tope               ;colocamos $80 en la memoria que servira de tope
                LDA     unidades
                ADD     tope                    ;cargamos las unidades y las sumamos a tope obteniendo asi ($80+unidades) la direccion del numero para ajustar
                STA     tope                
ciclo_unidades:                             
                feed_watchdog                   ;recorremos desde la memoria $80 hasta que llegemos a la memoria tope($80+unidades)
                CPX     tope  
                BEQ     salir_unidades
                INCX
                BRA     ciclo_unidades               
salir_unidades:                                
                LDA   ,X
                STA   unidadesA                 ;el valor de la memoria tope la guardamos en unidadesA el cual sera el valor ajustado de la unidad
                RTS
                
ajusta_decenas:
                LDHX    #$80                    ;misma explicacion que para unidades pero con decenas
                MOV     #$80,tope
                LDA     decenas
                ADD     tope
                STA     tope                
ciclo_decenas:
                feed_watchdog
                CPX     tope  
                BEQ     salir_decenas
                INCX
                BRA     ciclo_decenas               
salir_decenas:                                
                LDA   ,X
                STA   decenasA        
                RTS            
;--------------Terminan las subrutinas de ajuste            
            

;**************************************************************
;* spurious - Spurious Interrupt Service Routine.             *
;*             (unwanted interrupt)                           *
;**************************************************************
spurious:                           ; placed here so that security value
            NOP                     ; does not change all the time.
            RTI

;**************************************************************
;*                 Interrupt Vectors                          *
;**************************************************************
            ORG   $FFFA

            DC.W  spurious          ;
            DC.W  spurious          ; SWI
            DC.W  _Startup          ; Reset

Descarga .asm: aqui

Descarga el proyecto para CodeWarrior: aqui

REVISION

Este codigo que coloco fue desarrollado hace mucho tiempo por mí, así que por el momento no recuerdo del todo sí es 100% funcional o si falta ajustar algo (tengo varias versiones del mismo proyecto y coloqué aquí la mas reciente).

Pido a cualquier persona que se atreva a probarlo a comentar su funcionalidad.

tchao

Drag and Drop Canvas

2013-03-24T06:49:00.000-07:00

Antes que nada, el código no es mío, solo quiero aportarlo a mi blog por se simple y bello, el link a la web del autor se encuentra en Referencias.

<!doctype html>
<html>
<head>
<meta charset="UTF-8" />
<title>Canvas Drag and Drop Test</title>
 
 <script type="text/javascript">

 var canvas;
 var ctx;
 var x = 75;
 var y = 50;
 var WIDTH = 400;
 var HEIGHT = 300;
 var dragok = false;
 
 function rect(x,y,w,h) {
  ctx.beginPath();
  ctx.rect(x,y,w,h);
  ctx.closePath();
  ctx.fill();
 }
 
 function clear() {
  ctx.clearRect(0, 0, WIDTH, HEIGHT);
 }
 
 function init() {
  canvas = document.getElementById("canvas");
  ctx = canvas.getContext("2d");
  return setInterval(draw, 10);
 }
 
 function draw() {
  clear();
  ctx.fillStyle = "#FAF7F8";
  rect(0,0,WIDTH,HEIGHT);
  ctx.fillStyle = "#444444";
  rect(x - 15, y - 15, 30, 30);
 }
 
 function myMove(e){
  if (dragok){
   x = e.pageX - canvas.offsetLeft;
   y = e.pageY - canvas.offsetTop;
  }
 }
 
 function myDown(e){
  if (e.pageX < x + 15 + canvas.offsetLeft && e.pageX > x - 15 +
  canvas.offsetLeft && e.pageY < y + 15 + canvas.offsetTop &&
  e.pageY > y -15 + canvas.offsetTop){
   x = e.pageX - canvas.offsetLeft;
   y = e.pageY - canvas.offsetTop;
   dragok = true;
   canvas.onmousemove = myMove;
  }
 }
 
 function myUp(){
  dragok = false;
  canvas.onmousemove = null;
 }
 
 function here()
 {
  init();
  canvas.onmousedown = myDown;
  canvas.onmouseup = myUp;
 }
 </script>

</head>
 <body onLoad="here();">

 <canvas id="canvas" width="400" height="300">
  This text is displayed if your browser does not support HTML5 Canvas.
 </canvas>

 </body>
</html>

Así se vería si copias y pegas el codigo en un archivo html:

Referencias

http://html5.litten.com/how-to-drag-and-drop-on-an-html5-canvas/

2.- Arduino Mega ADK y Android Tutorial. "Control Multiple de salidas"

2013-02-18T15:36:00.000-08:00

Bueno, como parte del mismo proyecto que tuve que realizar, ahora se controlara la placa creada en esta entrada:

http://hzsquare.blogspot.fr/2012/11/corrimiento-de-bit-controlado-por-pc-c.html

El propósito a alcanzar es controlar la placa por medio de una interfaz hecha completamente para Android por medio de USB usando un Arduino Mega ADK.

Imagen de muestra:

Imagen de la plaza hecha

Esquematico de la placa, en lugar de la PC ahora tendremos un dispositivo Android, los pines tambien cambian
solo hay que ver el .ino del Arduino para saber

Un video de muestra:

Proyecto para Eclipse (ADT): aqui

Codigo de Arduino: aqui

NOTA: Recordar que para poder compilar el codigo de Android se necesitan ciertas librerias especiales, checa aqui para obtenerlas.

SitePlaye y Arduino. Hola Mundo por Puerto Serie

2012-12-15T15:07:00.000-08:00

Bueno, antes que nada, hola a todos!.... Bah, pura palabrería, vamos directo a lo que entraste a esta página...

SitePlayer, si si, es el Wervidor Web mas pequeño del mundo, si bla bla... más info aqui.

Bueno, un modulo de estos no nos sirve de mucho si no poseemos algo que procese datos de mejor manera, así que comunicaremos el SitePlayer con un Arduino y al Arduino con nuestra PC, ambos por medio del Puerto UART Serial.

NOTA: Carga el SitePlayer con la pagina de ejemplo que viene en el software de desarrollo (SiteLinker)

Material:

Arduino (El que sea que posea dos puertos Serie Ejemplo: Mega, Due)

Para este caso yo estoy usando un chipKit Max32, que en pocas palabras es lo mismo que un Mega pero con mayor velocidad de reloj =D.

SitePlayer completo.
Router (o LAN a la que conectarse, o en su defecto un cable CrossOver para conectar el SitePlayer directo al PC)

Esquemático:

Esquemático en Vivo

En pdf

Esquemático con mas rollo.

En pdf

Código de Arduino:

void setup()
{
  Serial.begin(115200);
  Serial1.begin(9600);  
}

void loop()
{
  if(Serial1.available())
  {
     Serial.write(Serial1.read()); 
  }
}

Imágenes de Muestra:

Mostrando la Pagina del SitePlayer y la IDE del arduino (Modificada para chipKit MPIDE, no te asustes es lo mismo que Arduino IDE)

Mostrando la Pagina del SitePlayer y el Serial Monitor después de enviar un "Hola Mundo"

Estos son mis cacharros

Bien, eso fue todo. A seguir desarrollando!!!

1.- Arduino Mega ADK y Android Tutorial "Como Comenzar"

2012-12-09T01:33:00.001-08:00

Hello World Arduino Mega ADK y Android

Esta entrada está desactualizada, para ver la información más reciente favor de ver mi nueva wiki: https://code.google.com/p/proyect-general-es/wiki/ArduinoADK_Android

Enciende y apaga un led (led pin 13) de tu Arduino Mega ADK por medio de un dispositivo Android.

Que rollo!!,, compraste un Arduino Mega ADK pensando que sería fácil programar algo, que en media hora estarías controlando ya la placa por medio de tu celular o de tu tablet?

Ooo decepción!!

Si eres nuevo en Android y en Arduino a la vez, esto si que es una jalada, pero bueno para eso está hecho este tutorial.
La página de Google ADK es bonita y explicativa? O claro que lo és (para una persona que llevo mínimo unos 5 años trabajando en este rollo), pero si queremos comenzar no nos sirve, bueno, al menos hasta que nos motivemos viendo que hicimos algo bien, ya de allí despegamos solos.

Material:

Un Arduino Mega ADK
Un dispositivo Android (tu celular!!!!)
Los cables para conectar =P

Vista preliminar

Y así se supone debe quedar todo

Sip, así mero

Software Necesario

IDE de Arduino (mínimo la 1.0.2) la cual incluye ya las librerias necesarias (Max3421e.h y Usb.h). link
Obtener las librerías del ADK (Google Tuto) o si bien no deseas descargar todo el repositorio con repo, aquí te coloco lo único necesario para este tutorial y más: android_accessories_descarga. Debo aclarar que ese código viene directo del repositorio de google y no ha sido modificado.
Eclipse. Si ya tienes Eclipse instala bien el plugin para programar Android o si eres novato en esto recomiendo que descargues mejor el ADT Bundle (Version de Eclipse ya lista), o si ya eres master en esto saltatelo LOL!!!.

Debes tener las APIS de Google tal y como indica aqui.

APIS de Google instaladas

Comienza lo divertido.

Librearías para Arduino.
Del repositorio que descargaste de Google copia las librerías necesarias al directorio de librearías de Arduino IDE:

Copia los directorios:
*android-accesories/adk1/board/AndroidAccesory
*android-accesories/adk1/board/USB_Host_Shield
a
.../arduino-1.0.2/libraries/

Nuevo proyecto y APIS necesarias

Crea un nuevo Android Application Project y ponle de nombre ArduinoBlinkLED, haz clic en Next, Next, Finish hasta terminar.

Nuevo Proyecto Android

Deberías tener mínimo:

Un layout principal llamado activity_main.xml
Un archivo de actividad java principal llamado MainActivity.java dentro del paquete com.example.arduinoblinkled
Un archivo manifest llamado AndroidManifest.xml

Que bonito Código!!! Manos a la obra

Así es como se verá tu Package Explorer en Eclipse:

0
Agrega las APIS de Google al proyecto.

Clic derecho a la carpeta del proyecto, propiedades
Resource/Android y selecciona Google APIs como Project Buil Target

1
Cambia el código de nuestro activity_main.xml por este:

Archivo: layout/activity_main.xml:

<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout android:layout_width="fill_parent"

android:id="@+id/relativeLayout1"

android:layout_height="fill_parent"

android:layout_weight="0.72" xmlns:android="http://schemas.android.com/apk/res/android">

<ToggleButton

android:text="ToggleButton"

android:id="@+id/toggleButtonLED"

android:layout_width="500px"

android:layout_height="200px"

android:layout_centerVertical="true"

android:layout_centerHorizontal="true"

android:textSize="50px"

android:onClick="blinkLED"></ToggleButton>

</RelativeLayout>

Crea una carpeta dentro de "res" llamada xml y dentro de ella crea un nuevo archivo llamado accessory_filter.xml, coloca el siguiente codigo en el archivo:

Archivo: xml/accessory_filter.xml:

<?xml version="1.0" encoding="utf-8"?>

<usb-accessory manufacturer="Manufacturer" model="Model" version="1.0" />

</resources>

Modifica el código de AndroidManifest.xml de tal manera que te quede algo parecido a esto:

Archivo: AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

package="com.example.arduinoblinkled"

android:versionCode="1"

android:versionName="1.0" >

<uses-sdk

android:minSdkVersion="13"

android:targetSdkVersion="16" />

<application

android:allowBackup="true"

android:icon="@drawable/ic_launcher"

android:label="@string/app_name"

android:theme="@style/AppTheme" >

<activity

android:name="com.example.arduinoblinkled.MainActivity"

android:label="@string/app_name" >

<intent-filter>

</intent-filter>

<intent-filter>

</intent-filter>

android:resource="@xml/accessory_filter" />

</activity>

<uses-library android:name="com.android.future.usb.accessory"></uses-library>

</application>

</manifest>

En este ultimo paso se declara que se usaran las librearías USB accessory y también se pide permiso de que cuando conectes el dispositivo al aparato android nuestra aplicación comience por default. Recuerda usar el minSdkVersion adecuado a tus librerías, para estar seguro puedes verificar las referencias de google.

Referencias de google:

http://developer.android.com/guide/topics/connectivity/usb/accessory.html

4
Cambia el codigo del archivo MainActivity.java por este:

Archivo: com.example.arduinoblikled/MainActivity.java

package com.example.arduinoblinkled;

import java.io.FileDescriptor;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import android.app.Activity;

import android.app.PendingIntent;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.os.Bundle;

import android.os.ParcelFileDescriptor;

import android.util.Log;

import android.view.View;

import android.widget.ToggleButton;

import com.android.future.usb.UsbAccessory;

import com.android.future.usb.UsbManager;

public class MainActivity extends Activity {

// TAG is used to debug in Android logcat console

private static final String TAG = "ArduinoAccessory";

private static final String ACTION_USB_PERMISSION = "com.google.android.DemoKit.action.USB_PERMISSION";

private UsbManager mUsbManager;

private PendingIntent mPermissionIntent;

private boolean mPermissionRequestPending;

private ToggleButton buttonLED;

UsbAccessory mAccessory;

ParcelFileDescriptor mFileDescriptor;

FileInputStream mInputStream;

FileOutputStream mOutputStream;

private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

String action = intent.getAction();

if (ACTION_USB_PERMISSION.equals(action)) {

synchronized (this) {

UsbAccessory accessory = UsbManager.getAccessory(intent);

if (intent.getBooleanExtra(

UsbManager.EXTRA_PERMISSION_GRANTED, false)) {

openAccessory(accessory);

} else {

Log.d(TAG, "permission denied for accessory "

+ accessory);

}

mPermissionRequestPending = false;

}

} else if (UsbManager.ACTION_USB_ACCESSORY_DETACHED.equals(action)) {

UsbAccessory accessory = UsbManager.getAccessory(intent);

if (accessory != null && accessory.equals(mAccessory)) {

closeAccessory();

}

};

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

mUsbManager = UsbManager.getInstance(this);

mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(ACTION_USB_PERMISSION), 0);

IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);

filter.addAction(UsbManager.ACTION_USB_ACCESSORY_DETACHED);

registerReceiver(mUsbReceiver, filter);

if (~~getLastNonConfigurationInstance~~() != null) {

mAccessory = (UsbAccessory) ~~getLastNonConfigurationInstance~~();

openAccessory(mAccessory);

}

setContentView(R.layout.activity_main);

buttonLED = (ToggleButton) findViewById(R.id.toggleButtonLED);

}

@Override

public Object onRetainNonConfigurationInstance() {

if (mAccessory != null) {

return mAccessory;

} else {

return super.~~onRetainNonConfigurationInstance~~();

}

@Override

public void onResume() {

super.onResume();

if (mInputStream != null && mOutputStream != null) {

return;

}

UsbAccessory[] accessories = mUsbManager.getAccessoryList();

UsbAccessory accessory = (accessories == null ? null : accessories[0]);

if (accessory != null) {

if (mUsbManager.hasPermission(accessory)) {

openAccessory(accessory);

} else {

synchronized (mUsbReceiver) {

if (!mPermissionRequestPending) {

mUsbManager.requestPermission(accessory,mPermissionIntent);

mPermissionRequestPending = true;

}

} else {

Log.d(TAG, "mAccessory is null");

}

@Override

public void onPause() {

super.onPause();

closeAccessory();

}

@Override

public void onDestroy() {

unregisterReceiver(mUsbReceiver);

super.onDestroy();

}

private void openAccessory(UsbAccessory accessory) {

mFileDescriptor = mUsbManager.openAccessory(accessory);

if (mFileDescriptor != null) {

mAccessory = accessory;

FileDescriptor fd = mFileDescriptor.getFileDescriptor();

mInputStream = new FileInputStream(fd);

mOutputStream = new FileOutputStream(fd);

Log.d(TAG, "accessory opened");

} else {

Log.d(TAG, "accessory open fail");

}

private void closeAccessory() {

try {

if (mFileDescriptor != null) {

mFileDescriptor.close();

}

} catch (IOException e) {

} finally {

mFileDescriptor = null;

mAccessory = null;

}

public void blinkLED(View v){

byte[] buffer = new byte[1];

if(buttonLED.isChecked())

buffer[0]=(byte)0; // button says on, light is off

else

buffer[0]=(byte)1; // button says off, light is on

if (mOutputStream != null) {

try {

mOutputStream.write(buffer);

} catch (IOException e) {

Log.e(TAG, "write failed", e);

}

4
Carga el siguiente sketch a tu Arduino Mega ADK:

sketch:
____________________________________________________________

#include <Max3421e.h>
#include <Usb.h>
#include <AndroidAccessory.h>
#define  LED_PIN  13
AndroidAccessory acc("Manufacturer",
  "Model",
  "Description",
  "1.0",
  "http://example.com",
                "0000000012345678");
void setup()
{
  // set communiation speed
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);
  acc.powerOn();
}
 
void loop()
{
  byte msg[0];
  if (acc.isConnected()) {
    int len = acc.read(msg, sizeof(msg), 1); // read data into msg variable
    if (len > 0) {
      if (msg[0] == 1) // compare received data
        digitalWrite(LED_PIN,HIGH); // turn on light
      else
        digitalWrite(LED_PIN,LOW); // turn off light
    }
  } 
  else
    digitalWrite(LED_PIN , LOW); // turn off light
}

____________________________________________________________

5

Carga la aplicación android a tu dispositivo androi (dígase celular, tableta...)
Conecta el Arduino a tu PC y abre un SerialMonitor
Conecta el dispositivo Android al Arduino
Listo!!!!!!!!!!!

Video de muestra

Descargas:
Proyecto de eclipse aqui.
Sketch arduino aqui.

Error Comun:

error: WProgram.h: No such file or directory

Si la IDE de Arduino te tira ese error es porque a partir de la versión 1.0.1 WProgram.h que contiene declaraciones para la API de Arduino fue cambiada por Arduino.h.

Parece que Arduino se le olvido mencionarle a Google que había cambiado su API, bueno este error se soluciona fácil basta con cambiar en todos los archivos que contengan ese error WProgram.h por Arduino.h y ya.

En nuestro caso solo debería ser en el archivo de librería AndroidAccessory.h como muestra el compilador.

Fuentes:
Especial agradecimiento a esta Web, todo el código presentado en esta entrada es de su propiedad, yo sólo me estoy encargando de colocar tips en español.

http://allaboutee.com/2011/12/31/arduino-adk-board-blink-an-led-with-your-phone-code-and-explanation/

Aquí encontré la solución del error:
https://github.com/adafruit/DHT-sensor-library/issues/1

TAGS:

Arduino Mega ADK Tutorial
Android ADK Tutorial
Arduino y Android
Arduino ADK Tuto
Arduino Hellow World
How to Begin Tutorial
WProgram.h error

Compilar Assembler x86 en Linux 64bits

2012-11-11T10:45:00.001-08:00

Bueno, acá en la universidad en la que estoy de intercambio estamos intentando aprender ensamblador para procesadores 8086, así es, lo básico de lo básico.

Bueno, el primer pedo!!! Así es, el pedoo,, es que en las máquinas de la universidad, los trastos de la prehistoria corren Windows XP x86, joder. Y yo tengo sólo sistemas operativos x64.

Bien, al rendirme de usar Tasm y Tlink en Windows 7 x64 decidí por usar mi siempre fiel Ubuntu x64.

Y los problemas como siempre, de compilación y de linkeo.

Pero basta de eso, aquí te pongo los pasos para que ejecutes un Hellow World en Linux x64.

Primero, el codigo de nuestro Hellow World:

section .text

    global _start   ;must be declared for linker (ld)

_start:     ;tell linker entry point

  mov edx,len ;message length
 mov ecx,msg ;message to write
 mov ebx,1 ;file descriptor (stdout)
 mov eax,4 ;system call number (sys_write)
 int 0x80 ;call kernel

  mov eax,1 ;system call number (sys_exit)
 int 0x80 ;call kernel

section .data

msg db 'Hello, world!',0xa ;our dear string
len equ $ - msg   ;length of our dear string

Descarga aqui.

Descargamos YASM de aqui o de su web oficial e instalamos el .deb

O para el NASM:

sudo apt-get install nasm

Ahora, podemos usar dos compiladores. NASM y YASM. El segundo es una ampliación del primero, y es el que recomiendo.

Compilamos:

yasm -f elf hello.asm

Linkeamos:

ld -m elf_i386 -s -o hello hello.o

Ejecutamos:

./hello

Recuerda, si usas NASM en lugar de YASM solo tienes que compilar así, el linkeo es igual:

nasm -f elf hello.asm

TAGS:

TLINK
TASM
YASM
NASM
Assembler 8086

Corrimiento de bit controlado por PC (C#) usando chipKit/Arduino y sn74ls164

2012-11-10T14:38:00.000-08:00

Esta es una continuación de la última entrada:
http://hzsquare.blogspot.fr/2012/10/control-de-parpadeo-de-led-con.html

Ahora por medio de ese parpadeo controlaremos el corrimiento de bits para hacer una bonita obra de arte.

Material:

2 x sn74ls164 ----> "Corredor de bits" Realmente es un Shift Registers, algo así como un covertidor Serie - Paralelo, pero el uso que le daremos es otro.
3 x 8L01-05-111 ------> Relay Reed Switch. Estos amigos nos ayudarán como interruptores, así podremos controlar con nuestro chipKit/Arduino voltajes mayores a los 5V usuales.
chipKit o Arduino
19 Leds
3 Resistencias 330 ohms

Descargas:

Se realizará en dos partes, primero el corrimiento de bits, y después haremos un corrimiento doble colocando dos sn74ls164 en cascada y añadiendo los relay reed switch. Para ambos casos ni la programación de la Interfaz ni el sketch del chipKit/Arduino cambian.

___________________Simple corrimiento de bits_____________________________
Aquí coloco el esquemático de las conexiones:

Esquemático pdf
El video de muestra, para que sepas que hacer:

______________Corrimiento de bits en cascada y salidas digitales______________

Aquí coloco el esquemático de las conexiones:

Esquemático pdf

Una imagen de muestra:

De la Proto

De la aplicación en C#

El video de muestra, para que sepas que hacer:

Tags:

MPIDE
chipKit
chipKit MAX32
Arduino
C#
Control de LED
Control de Parpadeo
Parpadeo sin retardo
blink without delay
Corrimiento de bits
sn74ls164

5.- Programa en C de CCS. Lee Puerto despliega valor en Display 7 segmentos

2012-10-19T14:07:00.004-07:00

Bien, para esta práctica, se usará el compilador de PIC C de CCS, debido a que el MPASM me resulto muy engorroso, oo decepcion, así es. Lo que no pude hacer en dos días en MPLABX lo hice en 5 minutos en PIC C.

Si tienes la IDE de programación de CCS la puedes conseguir aquí

Aclaro que sólo con fines didácticos si en realidad deseas desarrollar con esto, recomiendo que la compres.

He aquí también el Manual de referencia de CCS:
* CCS Reference Manual
Puedes descargarlo de la pagina oficial de CCS también.

Como funciona un Display de 7 Segmentos:

Cabe aclarar que un displays de 7 segmentos no es otra cosa que leds arreglados de una forma bonita de tal suerte que al encender los leds correspondientes a la vez se dibuje un símbolo, número o letra.

Existen muchos tipos de displays, entre los de 7 segmentos también existen variaciones, por 7 segmentos nos referimos a 7 leds (quizá 8 si contamos los que poseen punto decimal en algunas versiones). Podemos encontrar generalmente dos tipos muy comunes, clasificándolos de acuerdo a su manera de uso, los de Anodo Comun y los de Cátodo común.

Una imagen vale mucho más:

Y aquí está la imagen que vale mucho más.

Podemos observar los leds, por tanto, observamos que los de Cátodo Común debemos conectar su pin común a tierra y mandando un voltaje necesario (un uno lógico) a su pin correspondiente haremos que se encienda el led, si encendemos los ciertos leds al mismo tiempo podremos formar números etc etc bla bla bla bla...

Lo contrario para ánodo común.

Preparando el terreno:

Primero hacemos una prueba sencilla, tomaremos el codigo de la práctica anterior y lo usaremos aquí, pero en lugar de tener simples leds, tendremos los displays de 7 segmentos, de acuerdo a la entrada que le demos al pic por medio del dipswitch serán las barras de los displays que se encenderan:

Esquemático Prueba:

Esquemático para la prueba. El display que esta en la parte inferior izquierda solo es de prueba
para que se observe como conectar un cátodo común

Codigo en Assembler (mpasm):

1 ;Hazael Fernando Mojica García

2 ;Villeurbanne, Francia

3 ;18/10/2012

4 ;GPL

6 #include <p16f887.inc>

8 ;Definicion de variables

12 ;Comienzo del programa

13 org 00h ;Vector de Reset

16 Start

18 clrw ;Limpiamos el registro del acumulador W

19 bsf STATUS,RP0

20 clrf TRISB ;Declaramos como salida el Puerto B colocando en 0 todos sus pines

21 movlw 0xFF ;Colocamos 11111111b en W

22 movwf TRISD ;Declaramos como entrada el Puerto D colocando el 1 todos sus pines

23 bcf STATUS,RP0

25 Main

26 movfw PORTD

27 movwf PORTB

28 goto Main

29 end

Código en C:

#include <16f887.h>
#fuses NOWDT                                                //Deshabilita Watchdog
//#fuses INTRC                                                //Cristal Interno RC
#fuses NOMCLR                                               //No Master Clear
#use delay(clock=4000000)                                   //Clock interno de 4MHZ


void main()
{
   int numeroDecimal[10];
   

   set_tris_d(0xFF);          //Puerto D como entrada, colocando 1 en cada Pin
   set_tris_b(0x00);          //Puerto B como salida, colocando 0 en cada pin
   set_tris_c(0x00);          //Puerto C como salida
   
   output_c(0xFF);
   
   while(1)
   {
      output_b(input_d());
      //output_b(0b11111110);
      delay_ms(100);
   }
}

Podemos observar en el codigo de arriba que lo unico que hacemos es tomar el valor de puerto D y ponerlo en el puerto B.

Por medio de esto, podemos saber que barra del display se enciende y por tanto saber así que pines del pic es necesario colocar en 1 para formar cierto número.

Proyecto de prueba en PIC C de CCS y esquematico Proteus: aqui

*****____________________________________________________*********

PROYECTO COMPLETO

Y bueno ahora viene el bueno, he aquí el proyecto completo:

En este lo que se hace a grandes rasgos, es tomar el valor del puerto D, del mismo, se separa ese numero en unidades, decenas y centenas, después se despliega en cada unos de los displays correspondientes cada valor colocando el valor en el puerto B y encendiendo el transistor correspondiente para llevar a tierra el común del display respectivo.

En este sencillo programa desplegaremos en 3 displays de 7 segmentos el numero correspondiente en decimal al introducido en binario al Puerto D por medio del dip switch. Para esto, usaremos algo conocido como barrido, es decir, debido a que solo tenemos un puerto (Puerto B) para manejar los 3 dislpays encenderemos cada uno a la vez con el numero correspondiente a tal velocidad que parecera que todos estan encendidos.

Para este propósito, contamos con un transistor que usamos como interruptor Cuando hay un cero lógico en la base del transistor no hay paso entre catodo y anodo (circuito abierto) Cuando hay un uno lógico en la base del transistor es cuando existe coducción entre catodo y anodo (circuito cerrado) Llevando el común de los displays de 7 segmento a tierra, cerrando el circuito y haciendo que enciendan

Esquemático:

Esquematico Final

Código C:

Hay viene lo bueno ¬¬

/*
   Hazael Fernando Mojica García
   Villeurbanne, France, 19/10/2012
   GPL
*/

#include <16f887.h>
#fuses NOWDT                                                //Deshabilita Watchdog
//#fuses INTRC                                                //Cristal Interno RC
#fuses NOMCLR                                               //No Master Clear
#use delay(clock=4000000)                                   //Clock interno de 4MHZ

/*
   En este sencillo programa desplegaremos en 3 displays de 7 segmentos
   el numero correspondiente en decimal al introducido en binario al Puerto D
   por medio del dip switch.
   Para esto, usaremos algo conocido como barrido, es decir, debido a que solo tenemos
   un puerto (Puerto B) para manejar los 3 dislpays encenderemos cada uno a la vez con el
   numero correspondiente a tal velocidad que parecera que todos estan encendidos.
   Para este propósito, contamos con un transistor que usamos como interruptor
   Cuando hay un cero lógico en la base del transistor no hay paso entre catodo y anodo (circuito abierto)
   Cuando hay un uno lógico en la base del transistor es cuando existe coducción entre catodo y anodo (circuito cerrado)
   Llevando el común de los displays de 7 segmento a tierra, cerrando el circuito y haciendo que enciendan
*/

void main()
{
   int numeroDecimal[10];
   int c_unidades = 0b00000001;        //Cuando toque unidades encendemos solo RC0
   int c_decenas  = 0b00000010;        //Cuando toque decenas encendemos solo RC1
   int c_centenas = 0b00000100;        //Cuando toque centenas encendemos solo RC2
   int numeroObtenido = 0;
   int unidades = 0;
   int decenas = 0;
   int centenas = 0;
   
   numeroDecimal[0] = 0b11111110;      //Representacion del 0 en nuestro display de 7 segmentos
   numeroDecimal[1] = 0b00110000;      //Representacion del 1 en nuestro display de 7 segmentos
   numeroDecimal[2] = 0b01101101;      //Representacion del 2 en nuestro display de 7 segmentos
   numeroDecimal[3] = 0b01111001;
   numeroDecimal[4] = 0b00110011;
   numeroDecimal[5] = 0b01011011;
   numeroDecimal[6] = 0b01011111;
   numeroDecimal[7] = 0b01110001;
   numeroDecimal[8] = 0b11111111;
   numeroDecimal[9] = 0b11111011;
   

   set_tris_d(0xFF);                   //Puerto D como entrada, colocando 1 en cada Pin
   set_tris_b(0x00);                   //Puerto B como salida, colocando 0 en cada pin
   set_tris_c(0x00);                   //Puerto C como salida
   
   output_c(0xFF);
   
   while(1)
   {
      //Tomaremos en cuenta que deseamos representar el numero 255, 0b11111111, 0xFF
      
      numeroObtenido = input_d();                                       //Leemos el numero que deseamos representar en los displays
      centenas = numeroObtenido / 100;                                  //255/100 = 2.55 = 2
      decenas = (numeroObtenido - (centenas * 100)) / 10;               //(255 - (2*100))/10 = 5.5 = 5
      unidades = numeroObtenido - (centenas * 100) - (decenas * 10);    //255 - (2*100) - (5*10) = 5
      
      //Desplegamos el numero en los displays
      //Unidades
      output_c(c_unidades);
      output_b(numeroDecimal[unidades]);
      output_b(0x00);
      //Decenas
      output_c(c_decenas);
      output_b(numeroDecimal[decenas]);
      output_b(0x00);
      //Centenas
      output_c(c_centenas);
      output_b(numeroDecimal[centenas]);
      output_b(0x00);
   }
}

Chan chan, se acabó

Descargas Proyecto Final completo:
Proyecto final en PIC C y esquematico .DSN proteus: aqui

Tags:

Leer puerto
PIC C CCS
Encender leds
Displays 7 segmentos
Pic
Assembler
MPASM
MPLABX
Pic C
CCS
XC8

4.- Programa en MPASM. Lee puerto D y despliega valor en puerto B

2012-10-19T13:43:00.001-07:00

Esta será otra práctica sencilla, vamos a leer un valor en binario por medio del puerto D y desplegaremos su valor en los leds del puerto B. Sería lo mismo que conectar el dip switch directo a los leds.

Esquemático:

Esquemático

Código en Assembler (mpasm):

1 ;Hazael Fernando Mojica García

2 ;Villeurbanne, Francia

3 ;18/10/2012

4 ;GPL

6 #include <p16f887.inc>

8 ;Definicion de variables

12 ;Comienzo del programa

13 org 00h ;Vector de Reset

16 Start

18 clrw ;Limpiamos el registro del acumulador W

19 bsf STATUS,RP0

20 clrf TRISB ;Declaramos como salida el Puerto B colocando en 0 todos sus pines

21 movlw 0xFF ;Colocamos 11111111b en W

22 movwf TRISD ;Declaramos como entrada el Puerto D colocando el 1 todos sus pines

23 bcf STATUS,RP0

25 Main

26 movfw PORTD

27 movwf PORTB

28 goto Main

29 end

Descargas:
Diagrama en proteus y Proyecto de MPLABX: aqui

Tags:

Leer puerto
Encender leds
Pic
Assembler
MPASM
MPLABX
Pic C
CCS
XC8

3.- Primer programa de prueba. Contador de 8bits

2012-10-19T13:29:00.002-07:00

Bien, comenzamos con un circuito sencillo.
Lo que trataremos de realizar en esta ocasión es un contador de 8 bits, es decir, un circuito que cuente de 0 a 255 (8 bits) en binario y muestre esa cuenta por medio de un arreglo de leds.

Tenemos que poder ver esa cuenta, y sabemos que un Microcontrolador tiene una velocidad de 4MHz para este caso, por tanto, necesitamos que incremente su cuenta cada cierto tiempo para poder apreciar que demonios esta contando, así que, ocupamos un retardo de tiempo también.

Comenzamos por el circuito:

Esquemático

El código en assembler para pic (mpasm):

1 ;Hazael Fernando Mojica García

2 ;Villeurbanne, Francia

3 ;18/10/2012

4 ;GPL

6 #include <p16f628.inc>

8 ;Definicion de variables

9 cblock 0x20 ;Inicio de la RAM disponible

10 COMPTE:1 ;Variable de un byte

11 VARDEL1:1 ;Variable de un byte

12 VARDEL2:1 ;Variable de un byte

13 endc

15 ;Comienza Programa

16 org 00h ;Vector de reset

17 goto Start

19 Start

21 clrw ;Limpia registro w (acumulador)

22 movwf PORTB ;Limpia registro PORTB

23 bsf STATUS,RP0 ;Set bit RP0 (5) del registro STATUS (Acceso a bank 1)

24 movwf TRISB ;Declaramos como salida el Puerto B colocando 0 en el

25 bcf STATUS,RP0 ;Clear bit RP0(5) del registro de STATUS (Acceso a bank 0)

27 ;El bit RP0 (bit 5), junto con RP1 (bit 6), son para activar/desactivar Lectura y Escritura

28 ;Recordar siempre colocar a 1 el bit PR0 de STATUS antes de modificar el modo (entrada/salida) de un puerto

29 ;Y después, al acabar, colocarlo de nuevo en 0

31 Init

32 clrf COMPTE ;Limpiamos la variable COMPTE

34 IncCompte

35 incf COMPTE,F ;Incrementamos COMPTE y guardamos resultado en COMPTE, igual sería: incf COMPTE,1. En C dería algo como COMPTE++ o COMPTE = COMPTE +1

36 movf COMPTE,W ;Copiamos el valor de la variable COMPTE al acumulador W

37 movwf PORTB ;Copiamos el valor del acumulador W al puerto B

38 call Delai ;Entramos a la función delai

39 goto IncCompte ;Regresamos a incrementar el contador, una vez que este se desborde, es decir, sobrepase el byte, regresará a 0

41 ;La función, si es que podemos llamarla función debido a que esto es assembler, de Delai, es crear un retardo de tiempo de unos cauntos milisengudos

42 ;lo suficiente para ver cambiar los leds

43 ;Si observamos bien la estructura de Delai, veremos que es algo así como un bucle for anidado dentro de otro.

44 Delai

45 movlw 0xFF ;Copiamos una literal o constante al acumulador W, en este caso 0xFF

46 movwf VARDEL2 ;Copiamos el registro del acumulador W a VARDEL2

48 D0

49 movwf VARDEL1

51 D1

52 decfsz VARDEL1,F

53 goto D1

54 decfsz VARDEL2,F

55 goto D0

56 return

58 end ;Fin del programa

Ver mejor: aqui

Descargas:
Proyecto completo (.DSN de proteus y proyecto de MPLABX): aqui

Tags:

Contador de 8 bits
Contador de un byte
Pic
Assembler
MPASM
MPLABX
Pic C
CCS
XC8

2.- Como crear un nuevo Proyecto en MPLABX y simular en Proteus

2012-10-18T03:44:00.001-07:00

Bien, esto es un poco trivial, pero bueno, para no dejar tantas cosas al azar, vamos a ver como podemos crear un nuevo proyecto en MPLABX. Por ahora me encuentro en Windows, por tanto, los screenshots que coloque serán de windows, pero cabe decir que lo mismo aplica para Linux y Mac, son los mismos pasos.

Abrimos MPLABX
Menu File/ New Project
En el cuadro de diálogo de New Project seleccionar:

Standalone Project, Next
Seleccionamos el Pic que vamos a usar, Next (para la mayoría de los proyectos de este tutorial usaremos el PIC16f887)
Seleccionamos al herramienta para programar nuestro PIC, Next (para las dimensiones de este tutorial sólo será suficiente con el simulador pero si posees un PICkit, puedes usarlo)
Seleccionamos nuestro compilador, Next (usaremos mpasm, que es el ensamblador para PIC que provee Microchip, después usaremos XC8, pero por ahora todo será en ensamblador)
Ponle nombre a tu proyecto, Finish (el proyecto debe quedar grabado por default en el directorio de proyectos de MPLABX, si no modificaste algo)

Tenemos creado el proyecto ahora agregamos un nuevo archivo fuente

Clic derecho en la carpeta Source Files / New / Assembly File
Colocamos el nombre de nuestro archivo y seleccionamos su extensión (.asm), Finish

Programamos algo
Compilamos ("Build Project"hacemos clic en la imagen del martillo o en Menú Run / Build Project)
Cargamos el .hex en Proteus

Nuestro archivo .hex debe estar en (Carpeta de proyectos de MPLABX)/Nombre_de_mi_Proyecto.X/dist/default/production
En Windows sería algo como: C:\Users\Usuario\MPLABXProjects\MiProyecto.X\dist\default\production
En Proteus doble clic en nuestro PIC y seleccionamos el archivo .hex que hemos creado
Run

Cuadro de diálogo New Project

3.1

3.2

3.3

3.4

3.5

3.6

Agregar nuevo archivo fuente

4.1

4.2

Programamos algo

Compilamos (Build)

Cargamos a Proteus

7.3

Tags:

Tutotiral MPLABX
Crear proyecto MPLABX
Pic
Assembler
MPASM
MPLABX
Pic C
CCS
XC8

Control de Parpadeo de LED con chipKit/Arduino y C#

2012-10-14T04:22:00.000-07:00

Para este caso estamos usando una tarjeta chipKit MAX32 y la IDE de programación derivada de la de Arduini MPIDE.

Control del parpadeo del LED que está en paralelo con el pin 13 de nuestro Arduino o nuestro chipKit por medio de una aplicación hecha en C# .Net Framework 4.5.

Solo necesitamos:

Visual Studio 2010
Un chipKit cualsea o Arduino cualsea (que tenga en paralelo un Led en el pin 13, si no, tendran que conectar al mismo un led con una resistencia)
MPIDE o Arduino IDE

DESCARGA: aqui

Dentro del comprimido .rar vienen dos directorios, uno contiene la solución (.sln) para Visual Studio 2010, en el otro viene el sketch para MPIDE o Arduino IDE en .pde.

Carga el sketch a tu Arduino o chipKit
Abre la solución y correla (Run)
Presiona Commencer
Presiona el boton de reset del Arduino o chipKit
Controla por medio de la trackBar o insertando el Intervalo de parpadeo en la TextBox + Enter

Una disculpa que varias cosas estén en Francés, igual lo modifican a su gusto.

Imagenes:

Se observa el programa corriendo en modo Debug con VS2010

Solo ocupamos nuestra tarjeta chipKit o Arduino

Video de muestra:

Tags:

MPIDE
chipKit
chipKit MAX32
Arduino
C#
Control de LED
Control de Parpadeo
Parpadeo sin retardo
blink without delay

mpide (chipKit) en Ubuntu o kubuntu 64bits

2012-10-11T13:57:00.002-07:00

A veces los sistemas de 64bits en Linux tienden ser una lata, una batlla constante en compatibilidad con los programas para 32bits.

En este caso, queremos ejecutar mpide, la ide modificada de Arduino para las tarjetas de desarrollo chipKit en Kubuntu o Ubuntu de 64bits.

La parte mala de todo esto es que no es tan facil como solo ejecutar.

Antes que nada quiero agradecer a esta entrada en este blog que me ayudo mucho:
http://colinharrington.net/blog/2011/08/running-mpide-chipkits-arduino-ide-remake-64bit-ubuntu/

Bien, primero, debemos tener instalada la IDE de Arduino, esto para facilitarnos la vida ya que cuando se instala la IDE de Arduino, se instalan todos los paquetes correspondietes, así que aplicamos el famoso:

sudo apt-get install arduino

después siguen los paquetes que hacen magia de 32bits en sistemas de 64bits:

Abrimos el Gestor de paquetes. Muon Package Manager en Kubuntu o Synaptic Package Manager en Ubuntu
Buscamos e instalamos:

libelf1

(library to read and write ELF files)

libreadline6 y libreadline6(i386)

GNU readline and history libraries, run-time libraries

Y a programar chipkit usando codigo Arduino.

Saludos!!!!!!!

Tags:

Arduino
chipKit
Ubuntu 64bits
Ubuntu x64
Kubuntu x64
Problema Ubuntu 64 chipKit

Graficar entrada analogica (potenciometro) usando Arduino y C#

2012-10-06T05:33:00.001-07:00

Bien, el pequeño proyecto que les traigo el día de hoy es de graficar la entrada analógica de nuestro Arduino, es decir, el Convertidor Analógico Digital.

Este proyecto lo presenté hace varios meses como una práctica de laboratorio en mi querídisima (ROFL) facultad de mi Universidad, FIME UANL.

Vamos a graficarlo en la PC usando una aplicación creada por mi mismo en C#.

Bien, puedo resumir todo esto en unas cuantas etapas:

Armamos un circuito sencillo donde tengamos conectad a forma de divisor de voltaje nuestro potenciómetro, tu sabes man, una terminal de un extremo a voltaje, la otra a tierra y la terminal de enmedio a una de las entradas analogicas del Arduino.

Esto sencillamente para al momento de variar la resistencia en el potenciometro, en la terminal de en medio varía el voltaje.
NOTA: si tenemos un potenciometro logaritmico (los "normales jaja", los mas baratos) nuestra salida sera una función logaritmica (aah en serio!!) de la variación de la resistencia, si requieres un poco de más "precisión" usa uno lineal.

Nuestro Arduino estará conectado a la PC por el USB
Por medio de comunicación Serial mandaremos el resultado de la conversión Analógica - Digital cada vez que se requiera refrescar la gráfica
La aplicación en la PC hecha en C# recibe los datos por Serial y refresca la gráfica.

Circuito

Esquematico del circuito (NOTA: La terminal superior del potenciometro tambien esta conectada a 5V así como a AREF)

Imágenes del Circuito

Usando un Arduino Mega

1.- Usando un Arduino UNO

2.- Usando un Arduino UNO

Sketch de Arduino:

void setup()
{
  Serial.begin(115200);
  analogReference(EXTERNAL);

  Inicializa();
}

void loop()
{
  Get_Instruccion();
}



int Get_Instruccion()
{
  if(Serial.available())
  {
      switch(Serial.read())
      {
         case 'r'://Leer entrada analogica y mandar dato
           Analog_Read();
         break; 
         
         case 's': //En espera a nueva inicializacion
           Salir();
         break;
      }
  }
}

void Salir()
{
  Inicializa(); //Loop en inicializa esperando nueva inicializacion
}

void Analog_Read()
{
    int resultado = 0;
    resultado = analogRead(0); //Leemos el pin analogico 0 en 10bits
    Serial.write(resultado / 4); //Mandamos el resultado en 8bits por Serial
}



//Inicializamos la comunicacion serial
//Debe mandar una secuencia de caracteres tal que cumplan con el criterio "square"
void Inicializa()
{
  int caracter[6];
  int i = 0;
  caracter[0] = 's';
  caracter[1] = 'q';
  caracter[2] = 'u';
  caracter[3] = 'a';
  caracter[4] = 'r';
  caracter[5] = 'e';
  
  while(1)
  {//Mientras no se inicialize no sale del ciclo
     if(Serial.available())
    {
        if(Serial.read() == caracter[i])
        {
          if(i == 5)
          {//Si es la ultima iteracion
            Serial.write('a');//escribimos caracter de confirmacion
            break; //Salimos del while
          }
          i++;
        }
      } 
  }
  //Termina While
}

Explicaré un poco el código para el Arduino:

Al inicio se encuentra la función Inicializa(), esta se encarga de inicializar al Arduino, por así decirlo, lo que hace es esperar a recibir cierta cadena de caracteres por Serial, si esa cadena de caracteres es la correcta entonces se pondrá en marcha el programa principal confirmando esto por mandando un carácter de confirmación por Serial

La función principal Get_Instruccion() ejecuta cierta operación de acuerdo a lo recibido por Serial, si recibe "r" quiere decir que nuestra aplicación en C# esta requiriendo una lectura delo convertidor analógico digital, si recibe "s" es que se debe salir al al bucle de Inicialización.

Parte del Codigo para C#:

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.IO.Ports;

namespace Practica2_LabDSM

{

public partial class Form_Main : Form

{

Arduino arduino = null;

int[] muestreo;

public Form_Main()

{

InitializeComponent();

muestreo = new int[50];

}

private void groupBox_PuertoSerial_Enter(object sender, EventArgs e)

{

}

private void Form_Main_Load(object sender, EventArgs e)

{

serial_combo(this.comboBox_Puertos);

for (int i = 0; i < 50; i++)

{

//this.chart_Datos.Series[0].Points.AddY(i);

muestreo[i] = 0;

}

private void button_Iniciar_Click(object sender, EventArgs e)

{

if (this.comboBox_Puertos.Items.Count > 0)

{

if (this.comboBox_Puertos.SelectedIndex > -1)

{//Si esta seleccionado algun puerto

arduino = new Arduino(this.comboBox_Puertos.Text, 115200);//Inicializamos arduino a 115200 bauds

arduino.Inicializa_Comunicacion();

this.button_Iniciar.Enabled = false;

this.button_Stop.Enabled = true;

timer.Enabled = true;

timer.Start();

}

//Metodo que primero limpia y despues llena la comboBox pasada como

//parametro con los puertos serie disponibles

private void serial_combo(ComboBox combo)

{

combo.Items.Clear();

string[] ports = SerialPort.GetPortNames();

foreach (string port in ports)

{

combo.Items.Add(port);

}

private void Form_Main_FormClosed(object sender, FormClosedEventArgs e)

{

try

{

arduino.CierraPuerto();

}

catch

{

;

}

private void timer1_Tick(object sender, EventArgs e)

{

Get_Lectura();

}

private void button_Stop_Click(object sender, EventArgs e)

{

try

{

arduino.Stop();

arduino.CierraPuerto();

arduino = null;

this.button_Stop.Enabled = false;

this.button_Iniciar.Enabled = true;

this.timer.Stop();

this.timer.Enabled = false;

}

catch

{

arduino = null;

}

private void Get_Lectura()

{

int punto = 0;

if (arduino != null)

{

punto = arduino.GetLectura();

this.textBox_caracter.Text = Convert.ToChar(punto).ToString();

ActualizaGrafica(punto);

}

private void ActualizaGrafica(int punto)

{

RecorreArray(punto);

this.chart_Datos.Series[0].Points.Clear();

for (int i = 0; i < 50; i++)

{

this.chart_Datos.Series[0].Points.AddY(muestreo[i]);

}

private void RecorreArray(int punto)

{

int[] muestreoAux = new int[50];

for (int i = 0; i < 49; i++)

{

muestreoAux[i + 1] = muestreo[i];

}

muestreoAux[0] = punto;

muestreo = muestreoAux;

}

private void button_Refresh_Click(object sender, EventArgs e)

{

serial_combo(this.comboBox_Puertos);

}

Este código en sí no ayuda en mucho, sólo se ve bonito =). Es mejor si descargas la solución completa (Tip, está mas abajo)

Screenshot de la Interfaz en C# de la aplicación.

Básicamente lo que trata de hacer esta aplicación es por medio de un Timer, cada cierto tiempo una lectura analógica digital al arduino vía Serial, esta lectura la coloca en un array de hasta 50 muestras la cuál usa para construir la gráfica.

***********************_________________________________________********************

DESCARGAS:

Solución de C# para Visual Studio 2010 y Sketch Arduino: aqui (compresión RAR)
Esquematico: pdf, png

Si cargas el sketch al Arduino y Corres la solución de VS2010 todo debe funcionar perfecto, pero te coloco unas instrucciones para que lo hagas bien y sin dudas:

Abre con Arduino el archivo prac2_2.ino

Carga el Sketch al Arduino

Abre la solcion de VS2010 (Practica2_LabDSM.sln)
Conecta el Arduino a la PC por USB
Corre la aplicación de C# (Run)
Una vez se esté ejecutando el programa selecciona el puerto serie que corresponde a tu arduino, si no aparece da click en Refrescar
Click en Iniciar

Esto mismo puede ser usado, para muchos propósitos, por ejemplo, si cambias el potenciómetro por un LM35 tendrás un graficador de Temperatura etc...

Usando un poco de imaginación y programación tendrás lo que necesitas!!

Tags:

Arduino
Arduino y C#
Graficar Arduino
Graficar Convertidor Analogico Digital
Analog Digital Converter Arduino with C#
Graficar potenciometro con Arduino en la PC