You are on page 1of 52

COMUNICACIN SERIAL

Ing. Daniel Gonzlez Das

8744@utcv.edu.mx
Crdoba,
Veracruz.

Mecatrnica
Lebni Zaabdi Lpez Melchor

Univer
sidad
Tecnol
ogca
del
Centro
de
Veracr
uz
04/201

ndice
Universidad Tecnologca del Centro de Veracruz.................................................0
............................................................................................................................ 0
Introduccin........................................................................................................ 2
Seccin 1- puertos de comunicacin...................................................................3
RS-232............................................................................................................. 3
RS485.............................................................................................................. 4
Puertos USB (Universal Serial Bus):.................................................................4
Protocolos TCP/IP.............................................................................................. 5
Conclusin....................................................................................................... 6
Seccin 2- serial port component........................................................................7
Serial port en C#............................................................................................. 7
Jerarqua de herencia....................................................................................... 7
Sintaxis.......................................................................................................... 7
Constructores.................................................................................................. 7
Crear un Serial port (ejemplo)......................................................................8
Conclusin..................................................................................................... 10
Serial 3- Serial port y Arduino...........................................................................11
C# y Arduino utilizando el serial port............................................................11
Protocolo de comunicaciones.....................................................................11
Ejemplo de comunicacin con Arduino.......................................................12
Conclusin..................................................................................................... 16
Bibliografa........................................................................................................ 16
Anexos.............................................................................................................. 16

Introduccin
Las computadoras han evolucionado suficiente desde que se concibi la primera, y con ellas han
desarrollado los dispositivos de almacenamiento. Debido al adelanto tecnolgico se crearon puertos que
utilizan para recoger y remitir datos de la computadora a perifricos que estn conectados a ella, estos se
llaman puertos de comunicacin y en este momento se conoce una gran gama de ellos.
En el presente trabajo se estudiarn los consecutivos dispositivos: puertos PS/2, RCA, PARALELO,
SERIAL, USB, VGA y otros.

Seccin 1- puertos de comunicacin


Los puertos de comunicacin son herramientas que permiten manejar e intercambiar datos entre un
computador (generalmente estn integrados en las tarjetas madres) y sus diferentes perifricos, o entre
dos computadores. Entre los diferentes puertos de comunicacin tenemos:
Estos puertos son en esencia puertos paralelos que se utilizan para conectar pequeos perifricos a la
PC. Su nombre viene dado por las computadoras de modelo PS/2 de IBM, donde fueron utilizados por
primera vez.

RS-232
Es una norma o estndar mundial que rige los parmetros de uno de los modos de comunicacin serial.
Por medio de este protocolo se estandarizan las velocidades de transferencia de datos, la forma de
control que utiliza dicha transferencia, los niveles de voltajes utilizados, el tipo de cable permitido, las
distancias entre equipos, los conectores, etc.
Adems de las lneas de transmisin (Tx) y recepcin (Rx), las comunicaciones seriales poseen otras
lneas de control de flujo (Hands-hake), donde su uso es opcional dependiendo del dispositivo a conectar.
La siguiente tabla muestra el conector de 9 pines serie que se encuentra en la mayora de las PC de hoy
en da.

RS485
La diferencia principal entre RS422 y RS485 es el nmero de seales usadas en el cable de trasmisin.
RS422 usa 4 seales y su tierra, RS485 usa solo 2 seales y su tierra. RS485 requiere de un protocolo
"half dplex" para operar, dado que las mismas lneas son usadas tanto para trasmisin como recepcin.
Todos los dispositivos RS485 poseen drivers "tristate" que permiten a las UTR desconectarse de la lnea
una vez que trasmitieron su informacin. Normalmente, para este fin se usa un circuito temporizador
automtico habilitado por el flanco ascendente de la seal de trasmisin. El temporizador habilita el
circuito trasmisor durante el tiempo que dura el mensaje y lo deshabilita al terminar ste.
Entre las aplicaciones tpicas de la norma RS485, se encuentran los sistemas de control de acceso, los
sistemas distribuidos de control industrial y los sistemas de seguridad casera. En todos estos casos,
varias UTR reportan su informacin hacia una computadora central o bien reciben comandos de la

misma.

Puertos USB (Universal Serial Bus):


Permite instalar perifricos sin tener que abrir la mquina para instalarle hardware, sin necesidad de
reiniciar la computadora ni de volver a configurar el sistema, es decir, que basta con conectar dicho
perifrico en la parte posterior del computador

El USB trabaja como interfaz para la transmisin de datos y distribucin de energa que ha sido
introducido en el mercado de PCs y perifricos para mejorar las lentas interfaces serie y paralelo. Los
perifricos para puertos USB son reconocidos automticamente por el computador y se configuran casi
automticamente lo cual evita dolores de cabeza al instalar un nuevo dispositivo en el PC
Los puertos USB son capaces de transmitir datos a 12 Mbps
Existe un solo tipo de cable USB (A-B) con conectores distintos en cada extremo, de manera que es
imposible conectarlo errneamente

Protocolos TCP/IP
El conjunto de protocolos TCP/IP tiene correspondencia con el modelo de comunicaciones de red
definido por ISO (International Organization for Standardization), este modelo se denomina modelo de
referencia de interconexin de sistemas abiertos (OSI). El modelo OSI describe un sistema ideal de redes
que permite establecer una comunicacin entre procesos de capas distintas y fciles de identificar. En el
host, las capas prestan servicios a capas superiores y reciben servicios de capas inferiores muestra las

siete capas del modelo de referencia OSI y su correspondencia general con las capas del conjunto de
protocolos TCP/IP, se enumeran los protocolos ms comunes del conjunto de protocolos TCP/IP y los
servicios que proporcionan.
Modelo de referencia OSI y las capas de TCP/IP correspondientes. Protocolos ms comunes de TCP/IP.
Protocolo Servicio Protocolo Internet (IP) Proporciona servicios para la entrega de paquetes entre nodos.
Protocolo de control de mensajes de Internet (ICMP). Regula la transmisin de mensajes de error y
control entre los hosts y los routers. Protocolo
de resolucin de direcciones (ARP). Asigna
direcciones
Internet a
direcciones
fsicas.
Protocolo de
resolucin de
direcciones por
rplica
(RARP).
Asigna
direcciones
fsicas a
direcciones Internet. Protocolo de control de
transmisin (TCP). Proporciona servicios de envo de flujos fiables entre los clientes. Protocolo de
datagrama de usuario (UDP). Proporciona servicio de entrega de datagramas no fiable entre clientes.
Protocolo de transferencia de archivos (FTP). Proporciona servicios de nivel de aplicacin para la
transferencia de archivos. TELNET Proporciona un mtodo de emulacin de terminal. Protocolo de
informacin de encaminamiento (RIP) Permite el intercambio de informacin de rutas de vectores de
distancia entre routers. Protocolo abrir la va ms corta primero (OPSF) Permite el intercambio de
informacin de rutas de estado del enlace entre routers. Protocolo Gateway Externo (EGP) Permite el
intercambio de informacin de rutas entre routers externos.

Conclusin
Podemos concluir que las diferentes entradas de comunicacin fueron evolucionando hasta crear redes
mundiales, aunque algunos se siguen utilizando, la velocidad de transmisin de las ms recientes
generaciones, ha dejado obsoletos a algunos puertos.

Seccin 2- serial port component


Serial Port Component es un componente COM, que provee un simple manejo de la interfase del
scripting para comunicaciones no sincronizadas a travs de un puerto en serie. Serial Port Component
puede controlar mdems, mdems ISDN, aparatos en serie USB , as como otros dispositivos y mquinas
que poseen una interfase serial.

Serial port en C#
Utilice esta clase para controlar un recurso de archivo de puerto serie. Esta clase proporciona sincrnica
y controlada por eventos E/S, acceso a los Estados de conexin e interrupcin y acceso a propiedades
del controlador serie. Adems, la funcionalidad de esta clase se puede ajustar en interno Stream objeto
accesible a travs del BaseStream propiedad y se pasa a las clases que contengan o utilicen secuencias.
El SerialPort clase admite las codificaciones siguientes: ASCIIEncoding, UTF8Encoding,
UnicodeEncoding, UTF32Encoding, y cualquier codificacin definida en mscorlib.dll donde la pgina de
cdigos es menor que 50000 o sea 54936.Puede utilizar codificaciones alternativas, pero debe utilizar el
ReadByte o Write (mtodo) y realizar la codificacin por s mismo.
Utiliza el GetPortNames mtodo para recuperar los puertos vlidos para el equipo actual.
Si un SerialPort objeto se bloquea durante una operacin de lectura, no anular el subproceso. En su
lugar, cierre la base de transmitir o desechar la SerialPort objeto.
Jerarqua de herencia
System.Object
System.MarshalByRefObject
System.ComponentModel.Component
System.IO.Ports.SerialPort

Sintaxis
C#C++F#VB
public class SerialPort : Component

Constructores
Nombre
Descripcin
System_CAPS_pubmethod

SerialPort()

Inicializa una nueva instancia de la clase SerialPort.


System_CAPS_pubmethod

SerialPort(IContainer)

Inicializa una nueva instancia de la clase SerialPort utilizando el objeto IContainer especificado.
System_CAPS_pubmethod

SerialPort(String)

Inicializa una instancia nueva de la clase SerialPort utilizando el nombre de puerto especificado.
System_CAPS_pubmethod

SerialPort(String, Int32)

Inicializa una instancia nueva de la clase SerialPort utilizando el nombre de puerto y la velocidad en
baudios especificados.
System_CAPS_pubmethod

SerialPort(String, Int32, Parity)

Inicializa una instancia nueva de la clase SerialPort utilizando el nombre del puerto, la velocidad en
baudios y el bit de paridad especificados.
System_CAPS_pubmethod

SerialPort(String, Int32, Parity, Int32)

Inicializa una instancia nueva de la clase SerialPort utilizando el nombre del puerto, la velocidad en
baudios, el bit de paridad y los bits de datos especificados.
System_CAPS_pubmethod

SerialPort(String, Int32, Parity, Int32, StopBits)

Inicializa una instancia nueva de la clase SerialPort utilizando el nombre del puerto, la velocidad en
baudios, el bit de paridad, los bits de datos y el bit de parada especificados.
Crear un Serial port (ejemplo)
En el pasado, para comunicarse con un puerto serie utilizando .Net 1.1, haba que utilizar la API de
Windows, o utilizar un control de terceros. Con .Net 2.0, Microsoft ha aadido este apoyo con la inclusin
de la clase SerialPort como parte del espacio de nombres System.IO.Ports. Implementacin de la clase
SerialPort es muy sencilla. Para crear una instancia de la clase SerialPort, simplemente se pasan las
opciones SERIALPORT al constructor de la clase:
// Todas las opciones para un dispositivo serie
// ---- Se pueden enviar a travs del constructor de la clase SerialPort
// ---- NombrePuerto = "COM1", la velocidad en baudios = 19200, Paridad = Ninguna,

// ---- Bits de datos = 8, los bits de parada = Uno, apretn de manos = Ninguno
SerialPort _serialPort = nueva SerialPort ( "COM1" , 19200, Parity.None, 8, StopBits.One);
_serialPort.Handshake = Handshake.None;

Para recibir datos, necesitaremos crear un manejador de sucesos para el


"SerialDataReceivedEventHandler":
// "Sp_DataReceived" es un mtodo personalizado que he creado
_serialPort.DataReceived + = nueva SerialDataReceivedEventHandler (sp_DataReceived);
Tambin puede configurar otras opciones, como la ReadTimeout y WriteTimeout:
// Milisegundos _serialPort.ReadTimeout = 500;
_serialPort.WriteTimeout = 500;
Una vez que est listo para usar el puerto serie, tendr que abrirlo:
// Abre el puerto serie
_serialPort.Open ();
Ahora estamos listos para recibir datos. Sin embargo, para escribir estos datos en el cuadro de texto en
un formulario, necesitamos crear un delegado. .Net No permite la accin entre subprocesos, por lo que
tenemos que utilizar un delegado. El delegado se utiliza para escribir en el hilo de interfaz de usuario
desde un subproceso no interfaz de usuario.
// Delegado se utiliza para escribir en un control de interfaz de usuario desde un subproceso no UI
privada delegado vaco SetTextDeleg ( cadena de texto);
Ahora vamos a crear el mtodo "sp_DataReceived" que se ejecutar cuando se reciben datos a travs
del puerto serie:
void sp_DataReceived ( objeto emisor, SerialDataReceivedEventArgs e)
{
Thread.Sleep (500);
string de datos = _serialPort.ReadLine ();
// Invoca el delegado en el hilo de interfaz de usuario, y enva los datos que se recibieron en el mtodo
invocado.
// ---- El mtodo "si_DataReceived" se ejecutar en el subproceso de interfaz de usuario que permite
poblar el cuadro de texto.
este .BeginInvoke ( nueva SetTextDeleg (si_DataReceived), nuevo objeto [] {data});
}
Ahora vamos a crear nuestro mtodo "si_DataReceived":
privada vaco si_DataReceived ( cadena de datos) {TextBox1.Text = data.Trim (); }
Ahora podemos recibir datos de un dispositivo de puerto serie y mostrarlo en un formulario. Algunos
dispositivos enviarn datos sin que se le solicite. Sin embargo, algunos dispositivos necesitan ser enviar
ciertos comandos, y que responder con los datos que las llamadas de comandos para. Para estos

dispositivos, que va a escribir los datos al puerto serie, y utilizando un cdigo anterior para obtener los
datos que sern enviados de vuelta. En mi ejemplo, se va a comunicar con una escala. Por esta escala
particular, el envo de la orden "SI \ r \ n" obligar a devolver el peso de lo que est en la escala. Este
comando es especfico para esta escala. Usted tendr que leer la documentacin de su dispositivo serial
para encontrar los comandos que va a recibir. Para escribir en el puerto serie, he creado un botn "Inicio"
en el formulario. He aadido cdigo para Click_Event es:
privada vaco btnStart_Click ( objeto emisor, EventArgs e)
{
// Se asegura de puerto serie est abierta antes de intentar escribir
tratar
{
si (! (_ serialPort.IsOpen))
_serialPort.Open ();
_serialPort.Write ( "SI \ r \ n" );
}
captura (Exception ex)
{
MessageBox.Show ( "Error al abrir / escribir en el puerto en serie ::" + ex.Message, "Error!" );
}
}

Conclusin
Podemos concluir que el serial port es aquel que controla los eventos que salen y que entran en cualquier
tipo de codificacin, y este se utiliza en conjunto con otros mtodos, este tambin es el que realiza la
comunicacin entre distintos puertos.

Serial 3- Serial port y Arduino


Se utiliza para la comunicacin entre la placa Arduino y un ordenador u otros dispositivos. Todas las
placas Arduino tienen al menos un puerto serie (tambin conocido como un UART o USART): Serial . Se
comunica en los pines digitales 0 (RX) y 1 (TX), as como con el ordenador a travs de USB. Por lo tanto,
si utiliza estas funciones, no se puede tambin utilizar pasadores 0 y 1 para la entrada o salida digital.
Puede utilizar monitor serie incorporado en el entorno Arduino para comunicarse con una placa Arduino.
Haga clic en el botn de monitor de serie en la barra de herramientas y seleccione la misma velocidad de
transmisin utilizada en la llamada para comenzar ().

C# y Arduino utilizando el serial port


Esta clase C # combinado con el boceto Arduino le permite conectar un Arduino al puerto USB de un PC
y luego tener su puerto COM detectados por la aplicacin de C #. Una vez que el puerto COM se conoce
la aplicacin de C # a continuacin, puede enviar / recibir mensajes desde el Arduino.
Las bsquedas de aplicaciones C # todos los puertos de comunicacin y enva una consulta utilizando un
protocolo simple (explicado ms adelante). Una vez que el Arduino recibida la solicitud, responde. La
aplicacin de C # que seala el puerto COM que caus el Arduino para responder y guarda el nombre del
puerto COM. La aplicacin de C # a continuacin, puede utilizar este puerto COM en las comunicaciones
posteriores.

Protocolo de comunicaciones
Este utiliza un mensaje de 5 byte
Byte 0 es el marcador de inicio de mando. Esto es siempre decimal 16 convertido a byte
(Convert.ToByte (16);)
Byte 1 es el tipo de comando: 127 = Enviar datos a los pines
128 = Identificar
Byte 2 es el pin para recibir datos
Byte 3 es la Valus para el pasador
Byte 4 se utiliz como un marcador de "fin de mensaje", pero es redundante
As que enviar 100 al pin 3 es: 16,127,3,100,4
Y pedir al Arduino para devolver el mensaje es identificar: 16,128,0,0,4
Usted puede agregar fcilmente al protocolo. En uno proyecta que uso de comandos 129 para solicitar
los datos desde el Arduino.

Ejemplo de comunicacin con Arduino


/*
* Monitor de puerto serie
*
*
*/

// Salida de instalacin
int ledPin_3 = 3;
// bytes mensaje de establecimiento
inputByte_0 de bytes;
inputByte_1 de bytes;
inputByte_2 de bytes;
inputByte_3 de bytes;
inputByte_4 de bytes;
//Preparar
void setup () {
pinMode (ledPin_3, OUTPUT);
Serial.begin (9600);
digitalWrite (ledPin_3, HIGH); //
delay (250); //
digitalWrite (ledPin_3, LOW); //
delay (250); //
}
//Bucle principal
void loop () {
// Leer Buffer
if (Serial.available () == 5)
{
// Bfer de lectura
inputByte_0 = Serial.read ();
delay (100);
inputByte_1 = Serial.read ();
delay (100);

inputByte_2 = Serial.read ();


delay (100);
inputByte_3 = Serial.read ();
delay (100);
inputByte_4 = Serial.read ();
}
// Cheque para el inicio de mensaje
if (== inputByte_0 16)
{
// Detectar el tipo de comando
interruptor (inputByte_1)
{
case 127:
// Establecer PIN y el valor
interruptor (inputByte_2)
{
Case 4:
if (inputByte_3 == 255)
{
digitalWrite (ledPin_3, HIGH);
rest;
}
more
{
digitalWrite (ledPin_3, LOW);
rest;
}
rest;
}
rest;
case 128:
//Di hola
Serial.print ( "HOLA DE ARDUINO");
rest;
}
// Borrar Mensaje bytes
inputByte_0 = 0;
inputByte_1 = 0;
inputByte_2 = 0;
inputByte_3 = 0;
inputByte_4 = 0;
// Que el PC sabe que estamos listos para ms datos
Serial.print ( "- LISTO PARA RECIBIR");
}
}
DO#
using System;

using System.Threading;
using System.IO.Ports;
using System.IO;
public class ArduinoControllerMain {
SerialPort currentPort;
bool portFound;
private void SetComPort ()
{
while
{
string [] = puertos SerialPort.GetPortNames ();
foreach (abertura para cuerda en los puertos)
{
currentPort = new SerialPort (puerto, 9600);
if ( DetectArduino ())
{
portFound = true;
rest;
}
more
{
portFound = false ";
}
}
}
catch (Exception e)
{
}
}
private bool DetectArduino ()
{
while
{
// Los ajustes de abajo son para el apretn de manos Hola
byte [] buffer = nuevo byte [5];
buffer [0] = Convert.ToByte (16);
buffer [1] = Convert.ToByte (128);
buffer [2] = Convert.ToByte (0);
buffer [3] = Convert.ToByte (0);
buffer [4] = Convert.ToByte (4);
int intReturnASCII = 0;
Char charReturnValue = (Char) intReturnASCII;
currentPort.Open ();
currentPort.Write (buffer, 0, 5);
Thread.Sleep (1000);

int count = currentPort.BytesToRead ;


returnMessage cadena = "";
while (contador> 0)
{
intReturnASCII = currentPort.ReadByte ();
returnMessage = returnMessage + Convert.ToChar (intReturnASCII);
contar--;
}
COMport .name = returnMessage;
currentPort.Close ();
(if returnMessage.Contains ( "HOLA DE ARDUINO"))
{
return true;
}
more
{
false retorno;
}
}
catch (Exception e)
{
false retorno;
}
}
}

Conclusin
Con la siguiente informacin, podemos concluir que para enviar y recibir datos del Arduino es necesario
que este primero reciba una solicitud de conexin al COM para que C# lo identifique he inicie la
transmisin.

Bibliografa
I.
II.
III.
IV.
V.
VI.
VII.
VIII.

https://curlacavunah.files.wordpress.com/2010/09/4-perifc3a9ricos-los-puertos-decomunicacic3b3n.pdf
http://rdedatos.tripod.com/rs232.htm
http://www.puntoflotante.net/RS485.htm
http://sebastian-suescun.blogspot.com/2013/02/puertos-de-comunicacion-pc.html
http://esdocs.com/doc/1376017/sistema-de-adquisici%C3%B3n-de-datos-port%C3%A1til-parala-generaci...
http://es.activexperts.com/serial-port-component/
https://msdn.microsoft.com/es-es/library/system.io.ports.serialport(v=vs.110).aspx
https://www.arduino.cc/en/Reference/Serial

Anexos
Imagen de panel principal

Panel de lectura de sensores

Sketch Arduino

#include <Servo.h>
Servo servo1;
Servo servo2;
int led1 = 13;
int led2 = 12;
int led3 = 8;
int r = 11;
int a = 5;
int v = 6;
int valtr;

void setup() {
Serial.begin(9600);
Serial.flush();
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);

servo1.attach(10);
servo2.attach(9);

void loop() {
int sensorValue = analogRead(A0);
Serial.println(sensorValue);
if (Serial.available())
{

switch (Serial.read())
{
case '0':
digitalWrite(led1, HIGH);
break;
case '1':
digitalWrite(led1, LOW);
break;
case '2':
digitalWrite(led2, HIGH);
break;
case '3':
digitalWrite(led2, LOW);
break;
case '4':
digitalWrite(led3, HIGH);
break;
case '5':
digitalWrite(led3, LOW);
break;
case '6':
analogWrite(r, 0);

break;
case '7':

analogWrite(r, 26);
break;
case '8':

analogWrite(r, 51);
break;
case '9':

analogWrite(r, 77);

break;
case 'A':

analogWrite(r, 102);

break;
case 'a':

analogWrite(r, 128);

break;
case 'B':

analogWrite(r, 153);

break;
case 'b':

analogWrite(r, 179);

break;

case 'C':

analogWrite(r, 204);

break;
case 'c':

analogWrite(r, 230);

break;
case 'D':

analogWrite(r, 255);

break;
case 'd':

analogWrite(a, 0);

break;
case 'E':

analogWrite(a, 26);

break;
case 'e':

analogWrite(a, 51);

break;
case 'F':

analogWrite(a, 77);

break;
case 'f':

analogWrite(a, 102);

break;
case 'G':

analogWrite(a, 128);

break;
case 'g':

analogWrite(a, 153);

break;
case 'H':

analogWrite(a, 179);

break;
case 'h':

analogWrite(a, 204);

break;
case 'I':

analogWrite(a, 230);

break;
case 'i':

analogWrite(a, 255);

break;
case 'J':

analogWrite(v, 0);

break;
case 'j':

analogWrite(v, 26);

break;
case 'K':

analogWrite(v, 51);

break;
case 'k':

analogWrite(v, 77);

break;
case 'L':

analogWrite(v, 102);

break;
case 'l':

analogWrite(v, 128);

break;
case 'M':

analogWrite(v, 153);

break;
case 'm':

analogWrite(v, 179);

break;
case 'N':

analogWrite(v, 204);

break;
case 'n':

analogWrite(v, 230);

break;
case '_':

analogWrite(v, 255);

break;
case '~':

servo1.write(0);

break;
case 'O':

servo1.write(10);

break;
case 'o':

servo1.write(20);

break;
case 'P':

servo1.write(30);

break;
case 'p':

servo1.write(40);

break;
case 'Q':

servo1.write(50);

break;
case 'q':

servo1.write(60);

break;
case 'R':

servo1.write(70);

break;
case 'r':

servo1.write(80);

break;
case 'S':

servo1.write(90);

break;
case 's':

servo1.write(100);

break;
case 'T':

servo1.write(110);

break;
case 't':

servo1.write(120);

break;
case 'U':

servo1.write(130);

break;
case 'u':

servo1.write(140);

break;
case 'V':

servo1.write(150);

break;
case 'v':

servo1.write(160);

break;
case 'W':

servo1.write(170);

break;
case 'w':

servo1.write(180);

break;
case 'X':

servo2.write(0);

break;
case 'x':

servo2.write(10);

break;
case 'Y':

servo2.write(20);

break;
case 'y':

servo2.write(30);

break;
case 'Z':

servo2.write(40);

break;
case 'z':

servo2.write(50);

break;
case '#':

servo2.write(60);

break;
case '$':

servo2.write(70);

break;
case '%':

servo2.write(80);

break;
case '=':

servo2.write(90);

break;
case '*':

servo2.write(100);

break;
case '-':

servo2.write(110);

break;
case '+':

servo2.write(120);

break;
case '.':

servo2.write(130);

break;
case ',':

servo2.write(140);

break;
case ')':

servo2.write(150);

break;
case '`':

servo2.write(160);

break;
case'@':

servo2.write(170);

break;
case '?':

servo2.write(180);

break;
}

Codigo en Panel:
using
using
using
using
using
using
using
using
using
using
using

System;
System.Collections.Generic;
System.ComponentModel;
System.Data;
System.Drawing;
System.Linq;
System.Text;
System.Threading.Tasks;
System.Windows.Forms;
System.IO.Ports;
System.Threading;

namespace WindowsFormsApplication4
{
public partial class Form1 : Form
{
//int ejeX1 = 0;
//int ejeX2 = 0;
//int ejeX3 = 0;
public Form1()
{
InitializeComponent();

//timer2.Start();
//groupBox4.Visible = false;
//chart1.Series["Series1"].ChartType = SeriesChartType.Line;
//chart1.Series["Series2"].ChartType = SeriesChartType.Line;
//chart1.Series["Series3"].ChartType = SeriesChartType.Line;
serialPort1.BaudRate = 9600;
serialPort1.Parity = Parity.None;
serialPort1.StopBits = StopBits.One;
serialPort1.DataBits = 8;
serialPort1.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
serialPort1.Open();
}
static string indata;
string env;
string recibir;
private void Form1_Load(object sender, EventArgs e)
{
}
private void textBox2_TextChanged(object sender, EventArgs e)
{
}
private void checkBox1_CheckedChanged(object sender, EventArgs e)
{
pictureBox1.Image = WindowsFormsApplication4.Properties.Resources.Verde;
}
private void pictureBox1_Click(object sender, EventArgs e)
{
}
private void label1_Click(object sender, EventArgs e)
{
}
private void groupBox3_Enter(object sender, EventArgs e)
{
}
private void groupBox2_Enter(object sender, EventArgs e)
{
}
private void label5_Click(object sender, EventArgs e)
{
}
private void label42_Click(object sender, EventArgs e)
{
}
private void label39_Click(object sender, EventArgs e)
{
}

private void man_Click(object sender, EventArgs e)


{
timer1.Stop();
timer3.Stop();
timer4.Stop();
LL.Enabled = true;
AL.Enabled = true;
AL1.Enabled = true;
AL2.Enabled = true;
AL3.Enabled = true;
EL1.Enabled = true;
EL2.Enabled = true;
EL3.Enabled = true;
LP.Enabled = true;
AP.Enabled = true;
GB.Enabled = true;
LB.Enabled = true;
RB.Enabled = true;
PC.Enabled = true;

}
private void sen_Click(object sender, EventArgs e)
{
serialPort1.Close();
//groupBox4.Visible = true;
Sensores objventana = new Sensores();
this.Hide();
if (objventana.ShowDialog() == DialogResult.OK)
{

this.Show();

timer1.Stop();
timer3.Stop();
LL.Enabled = true;
AL.Enabled = true;
AL1.Enabled = true;
AL2.Enabled = true;
AL3.Enabled = true;
EL1.Enabled = true;
EL2.Enabled = true;
EL3.Enabled = true;
LP.Enabled = true;
AP.Enabled = true;
GB.Enabled = true;
LB.Enabled = true;
RB.Enabled = true;
PC.Enabled = true;
}
private void byt_Click(object sender, EventArgs e)
{
backgroundWorker1.RunWorkerAsync();
byt.Enabled = false;
}
private void checkBox2_CheckedChanged(object sender, EventArgs e)
{

pictureBox1.Image = WindowsFormsApplication4.Properties.Resources.Rojo;
}
private void checkBox4_CheckedChanged(object sender, EventArgs e)
{
}
private void checkBox3_CheckedChanged(object sender, EventArgs e)
{
}
private void checkBox6_CheckedChanged(object sender, EventArgs e)
{
}
private void checkBox5_CheckedChanged(object sender, EventArgs e)
{
}
int tim;
private void timer1_Tick(object sender, EventArgs e)
{
tim++;
if (tim == 1)
{
EL1.Checked = true;

}
if (tim == 2)
{

EL2.Checked = true;
}
if (tim == 3)
{
EL3.Checked = true;
}
if (tim == 4)
{
AL1.Checked = true;

}
if (tim == 5)
{
AL2.Checked = true;

}
if (tim == 6)
{
AL3.Checked = true;

tim = 0;
}
serialPort1.WriteLine(env);
Thread.Sleep(5);
recibir += indata + Environment.NewLine;
}
private void EL1_CheckedChanged(object sender, EventArgs e)
{
pictureBox1.Image = WindowsFormsApplication4.Properties.Resources.Verde;
env = "0";
}
private void AL1_CheckedChanged(object sender, EventArgs e)
{
pictureBox1.Image = WindowsFormsApplication4.Properties.Resources.Rojo;
env = "1";
}
private void EL2_CheckedChanged(object sender, EventArgs e)
{
pictureBox2.Image = WindowsFormsApplication4.Properties.Resources.Verde;
env = "2";
}
private void AL2_CheckedChanged(object sender, EventArgs e)
{
pictureBox2.Image = WindowsFormsApplication4.Properties.Resources.Rojo;
env = "3";
}
private void EL3_CheckedChanged(object sender, EventArgs e)
{
pictureBox3.Image = WindowsFormsApplication4.Properties.Resources.Verde;
env = "4";
}
private void AL3_CheckedChanged(object sender, EventArgs e)
{
pictureBox3.Image = WindowsFormsApplication4.Properties.Resources.Rojo;
env = "5";
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
for (int i = 1; i <= 1000; i++)
{
backgroundWorker1.ReportProgress(i);
System.Threading.Thread.Sleep(500);
if (backgroundWorker1.CancellationPending)
{
e.Cancel = true;
return;

}
}
e.Result = "byte transferidos";

private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)


{
progressBar1.Value = e.ProgressPercentage;
porc.Text = progressBar1.Value.ToString() + "%";
if (porc.Text == "100%") {
porc.Text = "Completado";
backgroundWorker1.CancelAsync();
byt.Enabled = true;

private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)


{
if (e.Error != null)
{
MessageBox.Show("Error");
}
else
if (e.Cancelled)
{
MessageBox.Show("Se transfirieron todos los datos");
}
else
{
MessageBox.Show(e.Result.ToString());
}
}
private void porc_Click(object sender, EventArgs e)
{
}
private void timer2_Tick(object sender, EventArgs e)
{
}
int au;
int ab;

private void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)


{
SerialPort sp = (SerialPort)sender;
indata = sp.ReadExisting();
}
int t4;
private void trackBar5_Scroll(object sender, EventArgs e)
{
t4 = trackBar5.Value;
if (t4 == 0)
{
B = "X";
}
if (t4 == 1)
{
B = "x";

}
if (t4 == 2)
{
B = "Y";
}
if (t4 == 3)
{
B = "y";
}
if (t4 == 4)
{
B = "Z";
}
if (t4 == 5)
{
B = "z";
}
if (t4 == 6)
{
B = "#";
}
if (t4 == 7)
{
B = "$";
}
if (t4 == 8)
{
B = "%";
}
if (t4 == 9)
{
B = "=";
}
if (t4 == 10)
{
B = "*";
}
if (t4 == 11)
{
B = "-";
}
if (t4 == 12)
{
B = "+";
}
if (t4 == 13)
{
B = ".";
}
if (t4 == 14)
{
B = ",";
}
if (t4 == 15)
{

B = ")";
}
if (t4 == 16)
{
B = "`";
}
if (t4 == 17)
{
B = "@";

}
if (t4 == 18)
{
B = "?";
}

private void trackBar1_Scroll(object sender, EventArgs e)


{
t3 = trackBar1.Value;
if (t3 == 0)
{
A = "~";
}
if (t3 == 1)
{
A = "O";
}
if (t3 == 2)
{
A = "o";
}
if (t3 == 3)
{
A = "P";
}
if (t3 == 4)
{
A = "p";
}
if (t3 == 5)
{
A = "Q";
}
if (t3 == 6)
{
A = "q";
}
if (t3 == 7)
{
A = "R";
}
if (t3 == 8)
{
A = "r";
}

if (t3 == 9)
{
A = "S";
}
if (t3 == 10)
{
A = "s";
}
if (t3 == 11)
{
A = "T";
}
if (t3 == 12)
{
A = "t";
}
if (t3 == 13)
{
A = "U";
}
if (t3 == 14)
{
A = "u";
}
if (t3 == 15)
{
A = "V";
}
if (t3 == 16)
{
A = "v";
}
if (t3 == 17)
{
A = "W";
}
if (t3 == 18)
{
A = "w";
}

}
int t;
int t1;
int t2;
string X;
string Y;
string Z;
string A;
string B;
private void trackBar2_Scroll(object sender, EventArgs e)
{
t = trackBar2.Value;
if (t == 0)
{
X = "6";

}
if (t == 1)
{
X = "7";
}
if (t == 2)
{
X = "8";
}
if (t == 3)
{
X = "9";
}
if (t == 4)
{
X = "A";
}
if (t == 5)
{
X = "a";
}
if (t == 6)
{
X = "B";
}
if (t == 7)
{
X = "b";
}
if (t == 8)
{
X = "C";
}
if (t == 9)
{
X = "c";
}
if (t == 10)
{
X = "D";
}
}
private void trackBar3_Scroll(object sender, EventArgs e)
{
t1 = trackBar3.Value;
if (t1 == 0)
{
Y = "d";
}
if (t1 == 1)
{
Y = "E";
}
if (t1 == 2)
{
Y = "e";

}
if (t1 == 3)
{
Y = "F";
}
if (t1 == 4)
{
Y = "f";
}
if (t1 == 5)
{
Y = "G";
}
if (t1 == 6)
{
Y = "g";
}
if (t1 == 7)
{
Y = "H";
}
if (t1 == 8)
{
Y = "h";
}
if (t1 == 9)
{
Y = "I";
}
if (t1 == 10)
{
Y = "i";
}

private void trackBar4_Scroll(object sender, EventArgs e)


{
t2 = trackBar4.Value;
if (t2 == 0)
{
Z = "J";
}
if (t2 == 1)
{
Z = "j";
}
if (t2 == 2)
{
Z = "K";
}
if (t2 == 3)
{
Z = "k";
}
if (t2 == 4)

Z = "L";

}
if (t2 == 5)
{
Z = "l";
}
if (t2 == 6)
{
Z = "M";
}
if (t2 == 7)
{
Z = "m";
}
if (t2 == 8)
{
Z = "N";
}
if (t2 == 9)
{
Z = "n";
}
if (t2 == 10)
{
Z = "_";
}
}
private void AL_Click(object sender, EventArgs e)
{
serialPort1.WriteLine(env);
Thread.Sleep(5);
recibir += indata + Environment.NewLine;
}
private void LL_Click(object sender, EventArgs e)
{
AL3.Checked = false;
AL2.Checked = false;
AL1.Checked = false;
EL1.Checked = false;
EL2.Checked = false;
EL3.Checked = false;

}
private void LP_Click(object sender, EventArgs e)
{
trackBar2.Value = 0;
trackBar3.Value = 0;
trackBar4.Value = 0;
}
private void AP_Click(object sender, EventArgs e)
{

serialPort1.WriteLine(X);
Thread.Sleep(5);
recibir += indata + Environment.NewLine;
serialPort1.WriteLine(Z);
Thread.Sleep(5);
recibir += indata + Environment.NewLine;
serialPort1.WriteLine(Y);
Thread.Sleep(5);
recibir += indata + Environment.NewLine;

}
int t3;
private void LB_Click(object sender, EventArgs e)
{
serialPort1.WriteLine(A);
Thread.Sleep(5);
recibir += indata + Environment.NewLine;
}
private void GB_Click(object sender, EventArgs e)
{

serialPort1.WriteLine(B);
Thread.Sleep(5);
recibir += indata + Environment.NewLine;

private void RB_Click(object sender, EventArgs e)


{
trackBar5.Value = 0;
trackBar1.Value = 0;
serialPort1.WriteLine("1");
Thread.Sleep(5);
recibir += indata + Environment.NewLine;
}
private void aut_Click(object sender, EventArgs e)
{
timer1.Start();
timer3.Start();
timer4.Start();
LL.Enabled = false;
AL.Enabled = false;
AL1.Enabled = false;
AL2.Enabled = false;
AL3.Enabled = false;
EL1.Enabled = false;
EL2.Enabled = false;
EL3.Enabled = false;
LP.Enabled = false;
AP.Enabled = false;
GB.Enabled = false;
LB.Enabled = false;
RB.Enabled = false;
PC.Enabled = false;

}
private void timer4_Tick(object sender, EventArgs e)

{
}
private void timer3_Tick(object sender, EventArgs e)
{
au++;
t2 = au;
t = au;
t1 = au;
if (t == 0)
{
X = "6";
}
if (t == 1)
{
X = "7";
}
if (t == 2)
{
X = "8";
}
if (t == 3)
{
X = "9";
}
if (t == 4)
{
X = "A";
}
if (t == 5)
{
X = "a";
}
if (t == 6)
{
X = "B";
}
if (t == 7)
{
X = "b";
}
if (t == 8)
{
X = "C";
}
if (t == 9)
{
X = "c";
}
if (t == 10)
{
X = "D";
}
if (t1 == 0)
{

Y = "d";
}
if (t1 == 1)
{
Y = "E";
}
if (t1 == 2)
{
Y = "e";
}
if (t1 == 3)
{
Y = "F";
}
if (t1 == 4)
{
Y = "f";
}
if (t1 == 5)
{
Y = "G";
}
if (t1 == 6)
{
Y = "g";
}
if (t1 == 7)
{
Y = "H";
}
if (t1 == 8)
{
Y = "h";
}
if (t1 == 9)
{
Y = "I";
}
if (t1 == 10)
{
Y = "i";
}
if (t2 == 0)
{
Z = "J";
}
if (t2 == 1)
{
Z = "j";
}
if (t2 == 2)
{
Z = "K";
}
if (t2 == 3)

Z = "k";

}
if (t2 == 4)
{
Z = "L";
}
if (t2 == 5)
{
Z = "l";
}
if (t2 == 6)
{
Z = "M";
}
if (t2 == 7)
{
Z = "m";
}
if (t2 == 8)
{
Z = "N";
}
if (t2 == 9)
{
Z = "n";
}
if (t2 == 10)
{
Z = "_";
}
trackBar2.Value = au;
trackBar3.Value = au;
trackBar4.Value = au;
serialPort1.WriteLine(X);
Thread.Sleep(5);
recibir += indata + Environment.NewLine;
serialPort1.WriteLine(Z);
Thread.Sleep(5);
recibir += indata + Environment.NewLine;
serialPort1.WriteLine(Y);
Thread.Sleep(5);
recibir += indata + Environment.NewLine;
if (au == 10) {
au = -1;
}
ab++;
trackBar1.Value = ab;
trackBar5.Value = ab;
if (ab == 18)
{
ab = -1;
}
t3 = ab;
if (t3 == 0)
{

A = "~";
}
if (t3 == 1)
{
A = "O";
}
if (t3 == 2)
{
A = "o";
}
if (t3 == 3)
{
A = "P";
}
if (t3 == 4)
{
A = "p";
}
if (t3 == 5)
{
A = "Q";
}
if (t3 == 6)
{
A = "q";
}
if (t3 == 7)
{
A = "R";
}
if (t3 == 8)
{
A = "r";
}
if (t3 == 9)
{
A = "S";
}
if (t3 == 10)
{
A = "s";
}
if (t3 == 11)
{
A = "T";
}
if (t3 == 12)
{
A = "t";
}
if (t3 == 13)
{
A = "U";
}

if (t3 == 14)
{
A = "u";
}
if (t3 == 15)
{
A = "V";
}
if (t3 == 16)
{
A = "v";
}
if (t3 == 17)
{
A = "W";
}
if (t3 == 18)
{
A = "w";
}
t4 = ab;
if (t4 == 0)
{
B = "X";
}
if (t4 == 1)
{
B = "x";
}
if (t4 == 2)
{
B = "Y";
}
if (t4 == 3)
{
B = "y";
}
if (t4 == 4)
{
B = "Z";
}
if (t4 == 5)
{
B = "z";
}
if (t4 == 6)
{
B = "#";
}
if (t4 == 7)
{
B = "$";
}
if (t4 == 8)
{

B = "%";
}
if (t4 == 9)
{
B = "=";
}
if (t4 == 10)
{
B = "*";
}
if (t4 == 11)
{
B = "-";
}
if (t4 == 12)
{
B = "+";
}
if (t4 == 13)
{
B = ".";
}
if (t4 == 14)
{
B = ",";
}
if (t4 == 15)
{
B = ")";
}
if (t4 == 16)
{
B = "`";
}
if (t4 == 17)
{
B = "@";
}
if (t4 == 18)
{
B = "?";
}
serialPort1.WriteLine(A);
Thread.Sleep(5);
recibir += indata + Environment.NewLine;
serialPort1.WriteLine(B);
Thread.Sleep(5);
recibir += indata + Environment.NewLine;

}
private void timer4_Tick_1(object sender, EventArgs e)
{

}
}

Cdigo en grafica de sensores:


using
using
using
using
using
using
using
using
using
using
using
using

System;
System.Collections.Generic;
System.ComponentModel;
System.Data;
System.Drawing;
System.Linq;
System.Text;
System.Threading.Tasks;
System.Windows.Forms;
System.Windows.Forms.DataVisualization.Charting;
System.IO.Ports;
System.Threading;

namespace WindowsFormsApplication4
{
public partial class Sensores : Form
{
float ejeX1 = 0, ejey1;
public Sensores()
{
InitializeComponent();
serialPort2.BaudRate = 9600;
serialPort2.Parity = Parity.None;
serialPort2.StopBits = StopBits.One;
serialPort2.DataBits = 8;
serialPort2.Open();
timer1.Start();
timer2.Start();
chart1.Series["Series1"].ChartType = SeriesChartType.Line;

private void Sensores_Load(object sender, EventArgs e)


{

}
string recibir;
private void timer3_Tick(object sender, EventArgs e)
{
}
private void serialPort2_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
recibir = serialPort2.ReadLine();
ejey1 = float.Parse(recibir);
}
private void timer1_Tick(object sender, EventArgs e)
{

ejeX1++;
chart1.Series[0].Points.AddXY(ejeX1, ejey1);
dataGridView1.Rows.Add(recibir);
}
private void button1_Click(object sender, EventArgs e)
{
this.DialogResult = DialogResult.OK;
this.Close();

}
private void chart1_Click(object sender, EventArgs e)
{

}
private void timer2_Tick(object sender, EventArgs e)
{
recibir = "";
}