Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
//agregar
using System.Diagnostics;
using System.Runtime.InteropServices;
using MecaniqueUK;
// agregar
using System.IO;
using System.Net;
using System.Net.Sockets;
namespace Aplicacion_USB_HID
{
public partial class Form2 : Form
{
Int32 port = 13000;//iniia codigo del servidor
IPAddress localAddr = IPAddress.Parse("192.168.0.105");
Byte[] bytes = new Byte[256];
// String data = null;
//String perver;//variavle del dato que se enviara por el usb al ser
recivido por el servidor
static string datousb;
bool Binicio = false;//codigo servidor
static UInt32 controlador;
//Buffer carc;
int[] cadena = new int[32];
public Form2()
{
InitializeComponent();
}
public void inicio()
{
try
{
var server = new TcpListener(localAddr, port);
// Start listening for client requests.
server.Start();
EscuchandoCliente(server);
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
finally
{
// Stop listening for new clients.
// server.Stop();
}// fin de try
} //fin de inicio
public async void EscuchandoCliente(TcpListener server)
{
// Enter the listening loop.
while (true)
{
var cliente = await server.AcceptTcpClientAsync();
MENSAJE_USB.Items.Add("Conectado");
procesar(cliente);
}
} //fin de escuchar cliente
public static async void procesar(TcpClient cliente)
{
var stream = cliente.GetStream();
var buffer = new byte[256];
var amountRead = await stream.ReadAsync(buffer, 0, 256);
var message = Encoding.ASCII.GetString(buffer, 0, amountRead);
listBox1.Items.Add("client sent: " + message);
// String data = null;
//data = data.ToUpper();
byte[] msg = System.Text.Encoding.ASCII.GetBytes(message);
// Send back a response.
stream.Write(msg, 0, msg.Length);
listBox1.Items.Add(Encoding.ASCII.GetString(buffer, 0, amountRead));
datousb = Encoding.ASCII.GetString(buffer, 0, amountRead);
//escribirmicro(0);
string dato = datousb;
byte[] BufferOUT = new byte[EasyHID.BUFFER_OUT_SIZE];
// BufferOUT[4] = 'r';
//for (int i = 1; (i < dato.Length) && (i < 32); i++)
//{
BufferOUT[1] = (byte)Convert.ToChar(datousb);
EasyHID.Write(controlador, BufferOUT);
System.Threading.Thread.Sleep(50);
// BufferOUT[i] = (byte)dato[i - 1];
//}
//EasyHID.Write(controlador, BufferOUT);
//System.Threading.Thread.Sleep(50);
//perver = Encoding.ASCII.GetString(buffer, 0, amountRead);
} //fin del hilo
//fin de la form1
private void Boton_Conectar_pic_Click(object sender, EventArgs e)
{
try
{
//MessageBox.Show("Aki si entra :D");
EasyHID.Connect(Handle);
//MessageBox.Show("Aki si entra :D");
if (EasyHID.IsAvailable(EasyHID.VENDOR_ID, EasyHID.PRODUCT_ID) ==
true)
{
habilitar();
MENSAJE_USB.Items.Clear();
MENSAJE_USB.Items.Add("Dispositivo USB Conectado!");
CONECTAR_PIC.Text = "DISPOSITIVO CONECTADO";
CONECTAR_PIC.BackColor = Color.LightSeaGreen;
CONECTAR_PIC.ForeColor = Color.Black;
// EasyHID.SetReadNotify(handle, true);
//controlador = handle;
MENSAJE_USB.Items.Add("Puede usar el Dispositivo.");
}
else
{
MENSAJE_USB.Items.Clear();
MENSAJE_USB.Items.Add("Dispositivo no encontrado,");
MENSAJE_USB.Items.Add("controlador conectado...");
CONECTAR_PIC.Text = "CONTROLADOR CONECTADO";
CONECTAR_PIC.BackColor = Color.GreenYellow;
CONECTAR_PIC.ForeColor = Color.Black;
}
}
catch { MENSAJE_USB.Items.Add("imposible conectar" + e); }
}//fin del boton
private void habilitar()
{
/*
OUT_DIGITAL_1.Enabled = true;
OUT_DIGITAL_2.Enabled = true;
OUT_DIGITAL_3.Enabled = true;
OUT_DIGITAL_4.Enabled = true;
OUT_DIGITAL_5.Enabled = true;
OUT_DIGITAL_6.Enabled = true;
OUT_DIGITAL_7.Enabled = true;
OUT_DIGITAL_8.Enabled = true;
*/
//MENSAJE_USB.Enabled = true;
}
private void deshabilitar()
{
/*
OUT_DIGITAL_1.Enabled = false;
OUT_DIGITAL_2.Enabled = false;
OUT_DIGITAL_3.Enabled = false;
OUT_DIGITAL_4.Enabled = false;
OUT_DIGITAL_5.Enabled = false;
OUT_DIGITAL_6.Enabled = false;
OUT_DIGITAL_7.Enabled = false;
OUT_DIGITAL_8.Enabled = false;
*/
//MENSAJE_USB.Enabled = false;
}
private void MENSAJE_USB_TextChanged(object sender, EventArgs e)
{
}
protected override void WndProc(ref Message message)
{
if (message.Msg == EasyHID.WM_HID_EVENT)
{
switch (message.WParam.ToInt32())
{
case EasyHID.NOTIFY_PLUGGED:
Dispositivo_Conectado((UInt32)message.LParam.ToInt32());
break;
case EasyHID.NOTIFY_UNPLUGGED:
Dispositivo_desconectado((UInt32)message.LParam.ToInt32());
break;
case EasyHID.NOTIFY_READ:
Leer_pic((UInt32)message.LParam.ToInt32());
break;
}
}
base.WndProc(ref message);
if (Binicio == false)
{
inicio();
Binicio = true;
}
base.WndProc(ref message);
}
private void Dispositivo_Conectado(UInt32 handle)
{
if (EasyHID.GetVendorID(handle) == EasyHID.VENDOR_ID &&
EasyHID.GetProductID(handle) == EasyHID.PRODUCT_ID)
{
EasyHID.SetReadNotify(handle, true);
controlador = handle;
MENSAJE_USB.Items.Add("Puede usar el Dispositivo.");
}
}
private void Leer_pic(UInt32 In_handle)
{
byte [] BufferINP = new byte [EasyHID.BUFFER_IN_SIZE];
if ((EasyHID.Read(In_handle, out BufferINP)) == true)
{
string cadena="";
char car;
for (int x = 1; x < BufferINP.Length; x++)
{
car = Convert.ToChar(BufferINP[x]);
cadena = cadena + car;
}
// From string to byte RAUL RAUL RAUL RAUL !!!!!!!!
// byte[] buffer = BufferINP;
// From byte array to string
// (BufferINP, 0, BufferINP.Length);
// s = Encoding.ASCII.GetString(BufferINP, 0, BufferINP.Length);
// s = en GetString(BufferINP, 0, BufferINP.Length);
// System.Threading.Thread.Sleep(1);
// s =
Convert.ToString(Convert.ToChar(BufferINP,0,BufferINP.Length));
// s= D
MENSAJE_USB.Items.Add(cadena.ToString());
}
}
private void Dispositivo_desconectado(UInt32 handle)
{
if (EasyHID.GetVendorID(handle) == EasyHID.VENDOR_ID &&
EasyHID.GetProductID(handle) == EasyHID.PRODUCT_ID)
{
MENSAJE_USB.Items.Clear();
MENSAJE_USB.Items.Add("Dispositivo USB, desconectado.");
CONECTAR_PIC.BackColor = Color.Red;
CONECTAR_PIC.ForeColor = Color.White;
CONECTAR_PIC.Text = "CONECTAR DISPOSITIVO";
deshabilitar();
EasyHID.Disconnect();
}
}
private void Leer_Mensaje_Pic_Click(object sender, EventArgs e)
{
string dato = datousb;
byte [] BufferOUT = new byte [EasyHID.BUFFER_OUT_SIZE];
// BufferOUT[4] = 'r';
for(int i=1;(i<dato.Length) &&(i<32);i++){
BufferOUT[i] = (byte)dato[i-1];
//ufferOUT[i]= Convert.ToByte(Convert.ToChar(dato[i]));
}
//BufferOUT.All= Co.("raul");
//BufferOUT[]= conv ("hola");
//BufferOUT[1] = (string)"hola"; // 65--> A
EasyHID.Write(controlador, BufferOUT);
System.Threading.Thread.Sleep(50);
//BufferOUT[1] = (byte)'o'; // 65--> A
//EasyHID.Write(controlador, BufferOUT);
//System.Threading.Thread.Sleep(50);
//BufferOUT[1] = (byte)'l'; // 65--> A
//EasyHID.Write(controlador, BufferOUT);
//System.Threading.Thread.Sleep(50);
//BufferOUT[1] = (byte)'a'; // 65--> A
//EasyHID.Write(controlador, BufferOUT);
//System.Threading.Thread.Sleep(50);
//BufferOUT[1] = (byte)' '; // 65--> A
//EasyHID.Write(controlador, BufferOUT);
//System.Threading.Thread.Sleep(50);
//BufferOUT[1] = (byte)'R'; // 65--> A
//EasyHID.Write(controlador, BufferOUT);
//System.Threading.Thread.Sleep(50);
//BufferOUT[1] = (byte)'a'; // 65--> A
//EasyHID.Write(controlador, BufferOUT);
//System.Threading.Thread.Sleep(50);
//BufferOUT[1] = (byte)'a'; // 65--> A
//EasyHID.Write(controlador, BufferOUT);
//System.Threading.Thread.Sleep(50);
//BufferOUT[1] = (byte)'u'; // 65--> A
//EasyHID.Write(controlador, BufferOUT);
//System.Threading.Thread.Sleep(50);
//BufferOUT[1] = (byte)'l'; // 65--> A
//EasyHID.Write(controlador, BufferOUT);
} //fin de la funcion
private void USB_HID_FormClosed(object sender, FormClosedEventArgs e)
{
EasyHID.Disconnect();
}
} //fin de la forma
//**********************************************************************************
*******************************************
class EasyHID
{
// HID specific...
public const UInt32 VENDOR_ID = 0x1234; //1234 HEX
public const UInt32 PRODUCT_ID = 0x0001; //0001 HEX
public const int BUFFER_IN_SIZE = 32;
public const int BUFFER_OUT_SIZE = 32;
// HID events...
private const int WM_APP = 0x8000;
public const int WM_HID_EVENT = WM_APP + 200;
public const int NOTIFY_PLUGGED = 0x0001;
public const int NOTIFY_UNPLUGGED = 0x0002;
public const int NOTIFY_CHANGED = 0x0003;
public const int NOTIFY_READ = 0x0004;
// HID interface...
[DllImport("mcHID.dll")]
public static extern bool Connect(IntPtr pHostWin);
[DllImport("mcHID.dll")]
public static extern bool Disconnect();
[DllImport("mcHID.dll")]
public static extern UInt32 GetItem(UInt32 pIndex);
[DllImport("mcHID.dll")]
public static extern UInt32 GetItemCount();
[DllImport("mcHID.dll")]
public static extern bool Read(UInt32 pHandle, IntPtr pData);
[DllImport("mcHID.dll")]
private static extern bool Write(UInt32 pHandle, IntPtr pData);
[DllImport("mcHID.dll")]
private static extern bool ReadEx(UInt32 pVendorId, UInt32 pProductId,
IntPtr pData);
[DllImport("mcHID.dll")]
private static extern bool WriteEx(UInt32 pVendorId, UInt32 pProductId,
IntPtr pData);
[DllImport("mcHID.dll")]
public static extern UInt32 GetHandle(UInt32 pVendorID, UInt32 pProductId);
[DllImport("mcHID.dll")]
public static extern UInt32 GetVendorID(UInt32 pHandle);
[DllImport("mcHID.dll")]
public static extern UInt32 GetProductID(UInt32 pHandle);
[DllImport("mcHID.dll")]
public static extern UInt32 GetVersionID(UInt32 pHandle);
[DllImport("mcHID.dll")]
public static extern UInt32 GetInputReportLength(UInt32 pHandle);
[DllImport("mcHID.dll")]
public static extern UInt32 GetOutputReportLength(UInt32 pHandle);
[DllImport("mcHID.dll")]
public static extern void SetReadNotify(UInt32 pHandle, bool pValue);
[DllImport("mcHID.dll")]
public static extern bool IsReadNotifyEnabled(UInt32 pHandle);
[DllImport("mcHID.dll")]
public static extern bool IsAvailable(UInt32 pVendorId, UInt32 pProductId);
// Managed version of the read/write functions.
public static bool Read(UInt32 pHandle, out byte[] pData)
{
IntPtr unmanagedBuffer = Marshal.AllocHGlobal(BUFFER_IN_SIZE);
bool result = Read(pHandle, unmanagedBuffer);
try { pData = new byte[BUFFER_IN_SIZE]; Marshal.Copy(unmanagedBuffer,
pData, 0, BUFFER_IN_SIZE); }
finally { Marshal.FreeHGlobal(unmanagedBuffer); }
return result;
}
public static bool Write(UInt32 pHandle, byte[] pData)
{
IntPtr unmanagedBuffer = Marshal.AllocHGlobal(BUFFER_OUT_SIZE);
bool result;
try { Marshal.Copy(pData, 0, unmanagedBuffer, BUFFER_OUT_SIZE); result =
Write(pHandle, unmanagedBuffer); }
finally { Marshal.FreeHGlobal(unmanagedBuffer); }
return result;
}
} //fin clase
} //fin del spacename