En anteriores “post”, os hablaba de la madurez de net Microframework 4.2, una de las características más noticiables “al menos para mí “, fue la incorporación de Visual Basic como lenguaje de programación de pequeños micros. Sin duda una asignatura pendiente considerando que históricamente el “Basic” ha sido uno de los lenguajes más usados por gran número de entusiastas… recordemos el intérprete del Intel MSC51 o el reciente “Basic Stamp”.
Durante años, muchos de los que vivimos “aquellas épocas” demandábamos la incorporación de un lenguaje moderno como “Visual Basic” y echábamos de menos poder programar los nuevos silicios “todo en uno” dentro de un entorno .net con todos los beneficios que ello comporta… uso del mismo IDE, generación IL, compilación JIT, debug on line, y un largo etc.
Posteriormente y como fruto de trabajos realizados en Microsoft Research, la versión 4.1 del MicroFramework hizo las delicias de los programadores en C# incorporando a Visual Studio la posibilidad de instalar “.net Gadgeteer” conteniendo un rico conjunto de módulos enchúfables, ello permite crear fácilmente proyectos MicroFramework orientados a la realización rápida de prototipos electrónicos utilizando sencillos “Gadgets” listos para arrastrar y soltar dentro de un entorno asistido llamado “Gadgeteer”.
Entonces cual es la noticia?
Pues simplemente que para alegría de los “VB”, ya podemos jugar con las versiones preliminares del “firmware” para placas como “Fez Hydra” y “Fez Cerberus” y .net Gadgetter. Es emocionante estar jugando con los “Gadgets” en Visual Basic!.
No tardéis en apuntaros a la "onda" Gadgeteer.
Os espero en mfDevices! y sus Foros!
Saludos,
PepLluis,
|
|
Ayer 23 de Abril, celebramos el día del Libro y la Rosa, Entre libros i cumpleaños de aquellos primeros sistemas “todo en uno” que hicieron las delicias de los entusiastas de microprocesadores y microsistemas: Hoy me complace compartir con todos mis lectores un momento muy especial; os presentamos el inicio de la primera comunidad de Habla hispana entorno a dispositivos Microframework y toda la cacharrería electrónica asociada en forma de ‘gadgeteer’.
Sin duda una ocasión única de retomar la pasión por la programación de pequeños dispositivos y la construcción de creativas aplicaciones estrechamente relacionadas con electrónica.
Mucho ha llovido desde los ‘sinclairs’ y los ‘commodores’, con sus 8 bits, 1k y los 4Mhz. Os invito a participar activamente en esta nueva comunidad de los procesadores ARM, con sus 32bits, velocidades de vértigo y casi sin limite de memoria.
Si sientes nostalgia de esos tiempos, te parecerá increíble poder programar y depurar directamente desde Visual Studio tan solo pulsado F5 y por supuesto utilizando nuestro lenguaje favorito…. Visual Basic o C#.
No olvidéis visitar mfDevices si queréis estar al día.
Se el primero en estrenar los foros : Foro mfDevices
o date una vuelta por el Blog :
Blog mfDevices
Como veis, este año vamos a Escribir un LIBRO!.
Os espero,
PepLluis,
|
Siguiendo una conversación muy interesante sobre Micro Framework y las dudas que surgen a la hora de implementar o desplegar aplicaciones, me complace compartir ciertas puntualizaciones sobre su arquitectura con el fin de clarificar e identificar cada uno de sus componentes.
Generalmente una de las principales confusiones es distinguir donde se encuentra ubicada cada una de sus capas. En ese sentido situaremos a nuestras aplicaciones y Visual Studio en el lado de ‘Código administrado’ y el resto representado a la parte de ‘Código Nativo’ que residirá en el chip. Deberemos diferenciar los cargadores o ‘TinyBooters’ del propio MicroFramework.
La implementación del ‘Codigo Nativo’ deberá realizarse en dos fases diferentes, en la primera transferiremos los cargadores y en la segunda el firmware de la electrónica.
Veamos su Arquitectura.
Para una mayor comprensión acerquémonos con un poco más detalle:
Finamente la síntesis de toda esta arquitectura se materializa e implementa a través de tres binarios, uno de ellos conocido como el TinyBooter, representa al cargador (es especifico para cada procesador) y dialoga con MFDeploy que será la herramienta del SDK encargada de ubicar los compilados (o sea el MicroFramework) en el chip, estos binarios obtenidos de 'msbuild' y los compiladores C son suministrados por el fabricante de la placa electrónica. Aunque no olvidéis que se puede personalizar para adecuarlo a otras necesidades especificas. Aunque en este caso se requiere disponer de los compiladores nativos en C para el procesador en cuestión.
Existe un Kit con el código fuente de base para. NET Micro Framework que puede usarse para crear/personalizar el firmware especifico de cada procesador.
Resumiendo:
TinyBooter es el gestor de arranque que permite a MFDeploy 'flashear' en tiempo de ejecución el firmware y/o aplicaciones de producción. El firmware está compuesto en la mayoría de los casos por dos archivos, uno de configuración y otro correspondiendo al binario en si mismo.
TinyBooterDecompressor es un archivo autoextraíble que se carga por el gestor de arranque (TinyBooter) en la memoria RAM y luego ejecuta el gestor real de arranque.
La aplicación descargada desde Visual Studio es código MSIL comprimido para mf net y luego es interpretado en tiempo de ejecución por el propio .net MicroFramework runtime.
Para cualquier cosa no dudéis en seguir esta conversación.
Saludos,
PepLluis,
(**) Las figuras anteriores pertenecen a las ‘Brochures’ y presentaciones técnicas del equipo de MicroFramework y por lo tanto son propiedad de MicroSoft.
No te pierdas este EIAV (Evento Internacional de Altos Vuelos) :-)
Si te consideras geek y estás cerca de Andorra el próximo sábado 21 de Abril, no hagas planes. En AndorraDotNet hemos organizado el primer Geek-â-palooza, en colaboración con la AVIA (Agrupació Virtual d'Informàtics d'Andorra). Un evento de la mano de Microsoft y otras asociaciones del país para traerte las últimas novedades en IT y desarrollo: Desde la presentación en sociedad de Windows 8 cliente y servidor, Windows Intune, Microsoft Office 365, y dos sesiones de desarrollo de aplicaciones para Windows 8.
Nos vemos en Andorra!
PepLluis,
--> Ademas :
Pep Lluís Bano impartirá un pequeño taller sobre .NET MicroFramework en el exterior de la sala de actos de forma paralela a las sesiones. Muchas gracias Pep!
Que es NET MicroFramework? Es el entorno integrado de desarrollo de aplicaciones para pequeños dispositivos con recursos limitados. Ofrece una completa e innovadora plataforma de desarrollo y entorno de ejecución que aportan la productividad de las herramientas informáticas modernas para este tipo de dispositivos, esto significa que ahora se pueden crear aplicaciones que se ejecutan en una variedad de pequeños dispositivos electrónicos con el mismo modelo de programación y herramientas a las que estamos acostumbrados en Visual Studio.
Para los actuales desarrolladores de sistemas integrados, esto significa que ahora pueden aprovechar los beneficios de productividad que se han logrado en las aplicaciones de escritorio y reducir el tiempo de comercialización de sus productos. .NET Micro Framework es una experiencia totalmente integrada a Visual Studio e incorpora un sistema de desarrollo fiable y productivo en sistemas ‘embebidos’.
Muchos desarrolladores continúan si utilizar los “pragmas” que aprovechan y explotan el rendimiento de nuestros equipos con procesadores de varios núcleos.
Dejando de pensar en ‘single’ con tan solo un ‘AsParallel’ nuestros bucles pueden lucir mucho mas agiles.
Da un vistazo al siguiente código, te animo a experimentar y perder el miedo a usarlo… et tiempo… si lo cronometras… nos dará la razón.
En este ejemplo podras cronometrar el tiempo empleado en ejecutar tres 'pings' en blucle clasico y el siguiente con AsParallel... veras la diferencia!
' Sacar partido a la ejecucion paralela, cuando disponemos de mas de un nucleo
'
Sub Main()
Console.WriteLine("Number of processors : " + Environment.ProcessorCount.ToString)
Dim ips = {"192.168.1.1", "192.168.1.3", "192.168.1.5"}
Dim start As DateTime = Now
' test de ejecucion para for each clasico
Dim pings = From ip In ips
Select New Ping().Send(ip)
For Each ping In pings
Console.WriteLine("{0} : {1}", ping.Status, ping.Address)
Next
Console.WriteLine(Now.Subtract(start))
' test de ejecucion para for each AsParallel
Dim start2 As DateTime = Now
Dim pings2 = From ip In ips.AsParallel()
Select New Ping().Send(ip)
For Each ping In pings2
Console.WriteLine("{0} : {1}", ping.Status, ping.Address)
Next
Console.WriteLine(Now.Subtract(start2))
Console.ReadLine()
End Sub
Saludos,
PepLluis,
Eso si, después de conversar con un amable lector, ADVERTIROS… que como todo debe hacerse un buen uso con criterio y conocimiento de causa, aplicándolo en funciones donde se justifique : Pero sin dejar de transmitiros que también es contraproducente dejar de usar las ventajas de utilizar grandes facilidades por el miedo que nos produce experimentar con ellas… así que Ánimos… AsParallel! (Gracias HB)
Descubre oportunidades para poner en práctica tus conocimientos
a la vez que contribuyes a una buena causa.
Con pocas palabras y con buenas intenciones : http://tucodigovaacambiarelmundo.org/
Saludos,
PepLluis,
Otro tip... de una pregunta en los foros :-)
Imports System.Linq
Public Class Form1
Private Sub Form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
Dim RegKey = "Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts"
Dim Fuentes = From aif In My.Computer.Registry.LocalMachine.OpenSubKey(RegKey).GetValueNames
Select My.Computer.Registry.LocalMachine.OpenSubKey(RegKey).GetValue(aif)
Me.ComboBox1.Items.AddRange(Fuentes.ToArray)
Me.ComboBox1.SelectedIndex = 1
End Sub
End Class
Saludos,
PepLluis,
No te pierdas la oportunidad de conocer un excelente punto de entrada a EntityFramework.
Mucho habia oido hablar de Entity, pero confieso que no he tenido una vision realista del mismo hasta completar la lectura de esta excelente guia.
Sobre todo Code First ayudara a simplificar la rampa de aprendizaje y como punto de entrada a dominar ciertos contextos de datos de forma racional en escenarios típicamente complejos para algunos desarrolladores.
Os dejo el enlace de Julia : http://www.oreillynet.com/pub/au/3141
Otro Link al Libro : http://shop.oreilly.com/product/0636920022220.do?sortby=publicationDate
Saludos,
PepLluis,
Mario me pregunta :
<Espero me puedas ayudar necesito escribir una cadena en un cuadro de texto en valores hexadecimales y enviarlos por un puerto serial y capturar la respuesta y convertirla en hexadecimal ejemplo: enviar 7E000408014E4464 (son valores hexadecimales) capturar la respuesta (también es una cadena)y convertirla a hexadecimal mostrándola en un texbox ya convertida. estoy utilizando C# con sharpdevelop.>
Respuesta : (C# Visual Studio) :-)
using System;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
System.IO.Ports.SerialPort port = new System.IO.Ports.SerialPort();
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
string toSend = "454647484950";
for (int ndx = 0; ndx <= toSend.Length-1; ndx+=2)
{
byte asc = Convert.ToByte(toSend.Substring(ndx, 2), 16);
char sendChar = Convert.ToChar(asc);
port.Write(sendChar.ToString());
}
//
// No olvideis que 'E' es '69' en decimal y '45' en Hex
byte[] Recibidos = { 69,70,71,72,73};
string hexInString = "";
foreach (int val in Recibidos)
{
hexInString+=String.Format("{0:x2}",val);
}
}
}
}
Saludos,
PepLluis,
Hasta el dia 22, Microsoft nos ofrece la oportunidad de participar en la terminologia para la version Española de Windows 8, para revisar y hacer comentarios sobre los mismos.
Podreis participar simplemente haciendo 'login' con vuestro LiveId... os lo recomiendo. Pero no espereis mucho solo quedan 9 dias :-)
http://www.microsoft.com/Language/mtcf/mtcf_home.aspx?langid=2239&cult=es-ES&WT.mc_id=dpx
Espero lo considereis interesante.
PepLluis,
Una de las características atractivas de las aplicaciones para Windows Phone, es la posibilidad de incorporar almacenamiento local en SQL CE. Mucho se discute y es sabido que existen diversas técnicas, pero como siempre muchos de vosotros preguntáis por la “Chuleta” paso a paso o pequeño laboratorio guía para iniciarnos en su uso.
La idea principal es utilizar “SQL Metal” para construir nuestro “Data Context”, nuestra clase se acceso a datos se creara a partir de nuestra BD. En tono de humor será nuestro “Entity Framework” trabajando en invertido J
Aquí tenéis el laboratorio de introducción paso, paso… espero que os sea asequible i de utilidad.
Crear la Base de datos.
Desde el explorador de servidores de Visual Studio, agregaremos una conexión :
Seleccionaremos SQL CE
Pondremos nombre a nuestra base de datos
Seleccionar “Crear”
Crear La tabla:
Con esto finalizaremos la creación de nuestra BD “WinPhoneData” y la tabla “LocalizationData”.
El siguiente paso consistirá en crearnos la clase con el contexto de datos para nuestra aplicación.
En primer lugar deberemos invocar el “CMD” o “Power Shell”, dependiendo de vuestros gustos. Los siguientes pasos serán muy sencillos, pues requerirán simplemente dos mandatos:
Es importante observar la Invocación a SQL Metal, pasándole las ubicaciones de la “sdf” anteriormente creada y el lenguaje destino para la generación de nuestra clase de acceso a datos.
1) Añadir a nuestro Path la referencia a “\Program Files\Microsoft SDKs\Windows\v7.0A\bin”
2) sqlmetal d:\WinPhoneData.sdf /language:vb /namespace:WinPhoneData /pluralize /code:d:WinPhoneData.vb
Una vez ejecutados dichos comandos, tendremos nuestra “WinPhoneData.vb” lista para ser utilizada en nuestro Windows Phone Project.
Por lo tanto nuestros próximos pasos serán muy fáciles, Desde nuestra instancia de Visual Studio, crearemos un nuevo proyecto “Windows Phone”.
Evidentemente seleccionaremos el SO 7.1.
Para que todo ruede a la perfección no deberemos olvidar las referencias a System.Data.Linq
Desde las propiedades del proyecto, seleccionaremos la de añadir un elemento existente:
Agregando la clase generada anteriormente.
La clase generada por Sqlmetal, no es 100% compatible, pues implementa ‘IDBConnection’ deberemos editar “WinPhoneData.vb” y eliminar los sub’s “New’s” sobrecargados, para conexiones ‘Idb’.
Public Sub New(ByVal connection As System.Data.IDbConnection)
MyBase.New(connection, mappingSource)
OnCreated()
End Sub
Public Sub New(ByVal connection As System.Data.IDbConnection,
ByVal mappingSource As System.Data.Linq.Mapping.MappingSource)
MyBase.New(connection, mappingSource)
OnCreated()
End Sub
Una vez completado este punto, podremos compilar la aplicación. Sin ningún tipo de problemas. Luego es tarea de cada cual adaptar los requerimientos navegando a través de sus propiedades y métodos… por ejemplo:
Partial Public Class MainPage
Inherits PhoneApplicationPage
' Constructor
Private Dbas As WinPhoneData.WinPhoneData
Public Sub New()
InitializeComponent()
InitializeData()
End Sub
Sub InitializeData()
Me.Dbas = New WinPhoneData.WinPhoneData("Data Source=isostore:\GeoLocData.sdf")
If Not Dbas.DatabaseExists Then
Dbas.CreateDatabase()
End If
' Simular una nueva entrada a la tabla de localizacion
Dim c1 = New WinPhoneData.LocalizationData With {.Date = DateTime.Now, .Latitude = 10, .Longitude = 15, .Speed = 11}
Dim ls As New List(Of WinPhoneData.LocalizationData) From {c1}
Dbas.LocalizationDatas.InsertAllOnSubmit(ls)
Dbas.SubmitChanges()
End Sub
End Class
Espero que pequeño paso a paso os ayude a completar vuestra primera aplicación para Windows Phone y almacén SQL Ce en local. Si la descripción anterior no es suficiente, no dudéis en solicitármelo y puedo adjuntaros el documento en cuestión a titulo de Guía Rápida.
Saludos,
PepLluis,
Some people ask me to have any soft start guide using microframework serial port. Well, as you know in desktop apps is the typical “Hello World”, the translation into serial port apps are “Echo for response”.
This code shows how to open the serial port to read incoming bytes and resend it as an echo. Is the first brick to check that the UART is all right! After this lab, you are ready to build your own DCE/DTE protocol and play serial commands between both sides.
Imports System.IO.Ports
Imports System.Text
Imports Microsoft.SPOT
Imports Microsoft.SPOT.Hardware
Module EchoResponse
Private WithEvents SerialComm As SerialPort =
New SerialPort("COM1", 9600, Parity.None, 8, StopBits.One)
Private DataReceived As String = ""
Private PortActivity As New OutputPort(CType(55, Cpu.Pin), False)
Sub Main()
SerialComm.Open()
' include your functions here
Thread.Sleep(Timeout.Infinite)
End Sub
Private Sub SerialIn() Handles SerialComm.DataReceived
PortActivity.Write(True)
Dim Length As Integer = SerialComm.BytesToRead
Dim Frame(Length) As Byte
SerialComm.Read(Frame, 0, Length)
SerialComm.Write(Frame, 0, Length)
DataReceived = ""
PortActivity.Write(False)
End Sub
End Module
Enjoy!! PepLluis,
Muchos de los lectores de este blog muestran interés por ejemplos entorno a Windows forms y SQL Express, no hay duda y soy consciente de que este articulo no forma parte de esos “avances que están por venir” ni representa a ninguna novedad tecnológica actual; obviamente lejos de herramientas tan actuales como LightSwitch, sin embargo me complace compartirlo con vosotros pues creo que puede ser un buen soporte para ayudar en la comprensión de ciertos usos y técnicas sobre todo para los que empiezan.
Como digo, este es uno de esos artículos intemporales en varios aspectos, pues describe metodologías “retro” utilizando los clásicos SQL y Forms… si embargo no quiero que perdáis de vista que los “usos” y “técnicas” utilizadas pueden traspasar esa barrera atemporal y utilizarse en cualquier escenario actual… incluso en las nuevas aplicaciones “Metro Style” J
Al diseñar algunos ejemplos, disfruto partiendo de una plantilla de “Consola”, pues debido a la naturaleza y el propósito del mismo, esta concesión me permite “Salirme fuera de pistas” de lo que sería una aplicación comercial, pero a su vez me permite disfrutar de la libertad de construir algo desde los cimientos.
Como su nombre indica el objetivo del siguiente laboratorio es interactuar con la conocida base de datos para pruebas “NorthWnd”, utilizaremos la estructura de cualquiera de sus tablas para “Autogenerar” nuestro form de entrada (con todos sus textboxes) que nos permita añadir un nuevo registro a la tabla a través de un “Enlazador”. A modo de flecos para darle un poco mas de interés, he creído divertido incluir una pequeña funcionalidad que nos permita recorrer la tabla buscando todos los registros según la coincidencia del país introducido el textbox de búsqueda (con LINQ), y un par de botones para recorrer el enlazador, avanzando o retrocediendo a partir de la posición actual en el datagridview.
No creo que sea necesario un detalle mas exhaustivo, prefiero pasar al código, aunque antes quedo a vuestra disposición para continuar y desarrollar esta conversación según consideréis de interés.
Que disfrutéis J
PepLluis,
Imports System.Drawing
Imports System.Windows.Forms
Imports System.Data
Imports System.Data.SqlClient
'
'
' Establecer un punto de entrada. Esto es una aplicacion VB
'
Module MiAplicacion
Sub Main()
Dim Ventana As New frmDinamico
Ventana.Show()
Application.Run()
End Sub
End Module
Public Class frmDinamico
Inherits Form
'Punto de Inicializacion de nuestra ventana
'Definicion de Variables de contexto
Private MiConexion As New SqlConnection(
"Data Source=.\SQLEXPRESS;" +
"AttachDbFilename=D:\Bd_App\NORTHWND.MDF;" +
"Integrated Security=True;Connect Timeout=30;User Instance=True")
' Adaptador, Enlazador y juego de datos para la tabla clientes
Private MiAdaptador As New SqlDataAdapter("Select * from Customers", MiConexion)
Private MiEnlazador As New BindingSource
Private MiDataSet As New DataSet
''' <summary>
''' Al lanzar la ejecucion de la app
''' </summary>
''' <remarks></remarks>
Sub New()
Try
Inicializacion()
Catch fallo As Exception
Messagebox.Show(fallo.Message, "Error Grave... no puedo continuar")
End
End Try
End Sub
''' <summary>
''' Inicializar/Construir los objetos de la aplicacions
''' </summary>
''' <remarks></remarks>
Sub Inicializacion()
Me.Text = "Auto Entry Data Form"
' Crear y Enlazar datos
Dim MiCommandBuild As New SqlCommandBuilder(MiAdaptador)
MiConexion.Open()
MiAdaptador.Fill(MiDataSet)
MiENlazador.DataSource = MiDataSet.Tables(0)
Dim MiDataGridView As New DataGridView
MiDataGridView.DataSource = MiENlazador
MiDataGridView.Anchor = AnchorStyles.Left Or AnchorStyles.Right Or AnchorStyles.Top
MiDataGridView.Dock = DockStyle.Top
'
' Añadir los controles al Form
Me.Controls.Add(MiDataGridView)
Me.Controls.AddRange({
New TextBox With {.Name = "Buscar", .Text = "", .Dock = DockStyle.Bottom},
New Button With {.Name = "Añadir", .Text = .Name, .Dock = DockStyle.Bottom},
New Button With {.Name = "Avanza", .Text = .Name, .Dock = DockStyle.Bottom},
New Button With {.Name = "Retrocede", .Text = .Name, .Dock = DockStyle.Bottom}
})
' Apuntar los handlers a sus funciones
AddHandler Me.Controls("Añadir").Click, AddressOf Nuevo
AddHandler Me.Controls("Avanza").Click, AddressOf Avanzar
AddHandler Me.Controls("Retrocede").Click, AddressOf Retroceder
AddHandler Me.Controls("Buscar").TextChanged, AddressOf Seleccionar
Me.Controls("Buscar").Focus()
End Sub
''' <summary>
''' Al final la ejecucion de la app
''' </summary>
''' <remarks></remarks>
Sub Fin() Handles Me.FormClosed
Application.ExitThread()
End
End Sub
''' <summary>
''' Query para seleccionar solo los registros coincidentes
''' con la cadena de texto introducida en el TextBox 'Buscar'
''' </summary>
''' <remarks></remarks>
Sub Seleccionar()
MiENlazador.DataSource =
(
From S In MiDataSet.Tables(0)
Where S.Item("Country").Contains(Me.Controls("Buscar").Text)
Select Nombre = S.Item("CompanyName"),
Ciudad = S.Item("City")
).ToList
End Sub
''' <summary>
''' Enlazador : MoveNext
''' </summary>
''' <remarks></remarks>
Sub Avanzar()
MiEnlazador.MoveNext()
End Sub
''' <summary>
''' Enlazador : MovePrevious
''' </summary>
''' <remarks></remarks>
Sub Retroceder()
MiEnlazador.MovePrevious()
End Sub
''' <summary>
''' Crear un nuevo form conteniendo un TextBox y una etiqueta
''' con su descripcion para cada columna de la tabla
''' </summary>
''' <remarks></remarks>
Sub Nuevo()
Dim AutoForm As New Form
AutoForm.Name = "Nuevo"
AutoForm.Text = "Data Entry Form"
Dim Pos_x As Integer = 5
Dim Pos_y As Integer = 10
Dim Etiqueta As Label
Dim Entrada As TextBox
For Each col As DataColumn In MiDataSet.Tables(0).Columns
Etiqueta = New Label
Etiqueta.Location = New Point(Pos_x, Pos_Y)
Etiqueta.Text = Col.ColumnName
Pos_X += Etiqueta.Width
Entrada = New TextBox
Entrada.tag = Etiqueta.Text
Entrada.Location = New Point(Pos_X, Pos_Y)
AutoForm.Controls.AddRange(New Control() {Etiqueta, Entrada})
Pos_x = 5
Pos_Y += Etiqueta.Height + 5
Next
AutoForm.height = Pos_y + 75
AutoForm.Show()
End Sub
End Class
Respondiendo a la pregunta de David : "Al leer del puerto serie leo su contenido pero me lo muestra como ASCii, existe alguna forma para visualizar su contenido en HEX o Decimal?"
Function AsciiToHex(TramaRecibida As String, ConvertToHex As Boolean) As String
'
' Conversion de un string a una cadena de Hexadecimales / decimales
For Each c As Char In TramaRecibida
If ConvertToHex Then
AsciiToHex += "0x" + Hex(Asc(c)) + " "
Else
AsciiToHex += Asc(c).ToString + " "
End If
Next
Return AsciiToHex
End Function
Para invocar la funcion :
Dim RespuestaEnHex As String = AsciiToHex("abcABCD_CualquierTextoRecibido", True)
Dim RespuestaEnDEC As String = AsciiToHex("abcABCD_CualquierTextoRecibido", False)
Espero te sea util.
Saludos,
PepLluis,
Si bien es cierto que han pasado 25 años desde los primeros micro controladores “todo en uno” de Intel MCS51 que incluían un interprete “Basic” como “Firmware” y hacían nuestras delicias permitiéndonos encender y apagar “lucecitas” con instrucciones muy simples y sin tener que ahondar en profundos conocimientos... nadie discute que paulativamente aquella tecnología dejo de apasionarnos al ritmo que aparecieron nuevos procesadores y electronicas con mucho mas atractivo; de hecho incluso nos avergonzaba tener que numerar las líneas, pero también es cierto que después de aquellos primeros pinitos quedamos fuera de juego inmersos en complejos y potentes sistemas de 16/32b que embebían todo el chip set en un solo encapsulado… ya sabéis el resto de 32 a 64 y la necesidad de acumular un montón de conocimiento previo sobre el medio para poder terminar encendiendo y apagando nuestra querida “lucecita” :-) con la diferencia de haber tenido que escribir un monton de codigo mas ... complejidad obliga!
Quizás buscando la moraleja se resumiría desde hace algunos años en la nostalgia de NO tener a mano aquellos viejos cacharros que nos permitían activar una salida de pulso con modulación simplemente con : 10 PWM 100,100,1000 , no quiero aburriros explicando como las nuevas plataformas y procesadores se alejaron cada vez mas del “Basic listo para funcionar” y se aproximaron al preámbulo técnico entre compiladores librerías, inicializaciones y descarga de binarios en la ‘flash’ para poder terminar haciendo lo mismo en un procesador super complejo. De ahi la gran aficion a chips como el PICAXE o Basic STAMP... En resumen sin darnos cuenta nos alejábamos definitivamente del concepto “Basic”.
La suerte y la buena noticia para todos los que sentimos pasión por estos artilugios que nos abstraen a esa mágica mezcla entre electrónica y lenguajes, es que a punto de pronunciar el tipico : “El Basic a Muerto” Viva el BASIC!!, vuelve a aparecer a escena la implementacion de "Visual Basic" para projectos del MicroFramework 4.2, que como sabeis solo estaba disponible para C# hasta la fecha.
Que os parecería cacharrear utilizando visual studio y expresiones como las que siguen :
While (True)
Encender(Led_Azul)
Esperar(1)
Apagar(Led_Azul)
Esperar(1)
If "Expresion" = "Cierta" Then
Encender(Alarma_1)
Else
Apagar(Alarma_1)
End If
End While
Uno de los avances mas importantes en este sentido, es la posibilidad de desarrollar y depurar aplicaciones con o sin electrónica, pues podemos crearnos nuestros propios dispositivos emuladores y en el mejor de los casos si disponemos del dispositivo físico podemos depurar directamente sobre la electrónica a traves del puerto serie o USB.
La proposición es fácil, bienvenidos al mundo de los apasionantes sistemas embebidos “on chip”, después de largos años de desarrollo .NET MicroFramework alcanza una madurez envidiable en su versión 4.2, convirtiéndose en un excelente ‘open source’ y como ya he dicho antes, incorporando por fin la posibilidad crear nuestros nuevos proyectos recuperando Visual Basic.
Me permito postearos esta sencilla introducción, como preámbulo a todo un apartado que nos puede dar mucho de que hablar, pues ciertamente muchos lectores de este blog siempre han mostrado especial interés en controlar dispositivos de una forma amigable. Esperando vuestros comentarios para ir dando formato a los futuros artículos.
Aquí tenéis el código completo para un hardware genérico. Creo que es muy interesante motivaros en la forma que podemos adaptar la redacción de nuestras funciones de una forma altamente inteligible.
Imports Microsoft.SPOT
Imports Microsoft.SPOT.Hardware
Public Module Principal
Sub Main()
While (True)
Encender(Led_Azul)
Esperar(1)
Apagar(Led_Azul)
Esperar(1)
If "Expresion" = "Cierta" Then
Encender(Alarma_1)
Else
Apagar(Alarma_1)
End If
End While
End Sub
End Module
' Definicion de funciones
Module Funciones
'
Sub Encender(pin As OutputPort)
pin.Write(True)
End Sub
Sub Apagar(pin As OutputPort)
pin.Write(False)
End Sub
Sub Esperar(segundos As Integer)
Thread.Sleep(segundos * 1000)
End Sub
End Module
' Constructores y definicion de nombres
Module GPIOs
Public Led_Azul As OutputPort = New OutputPort(CType(55, Cpu.Pin), False)
Public Alarma_1 As OutputPort = New OutputPort(CType(18, Cpu.Pin), False)
End Module
Que lo disfrutéis!
PepLluis,
Feliz Navidad y Prospero año nuevo!
Merry Christmas to you and your family as well
The best whishes to make this 2012, the Year of bread and cheese dinners!
Pep Lluis,
Catalonian Claus.
Sin la intención de profundizar excesivamente y relativo a una pregunta relativa al control de la ejecución de varias instancias de una misma aplicación. Se me ocurre responder : Con el uso MUTEX!
Creo que vale la pena que ‘echéis’ un vistazo al código… reamente infalible!
bool SingleInstance;
Mutex mutex = new Mutex(false, "MiCodigoMutex", out SingleInstance);
if (!SingleInstance)
{
MessageBox.Show(null, "No se puede ejecutar mas de una instancia",
"Programa en ejecucion", MessageBoxButtons.OK, MessageBoxIcon.Stop);
this.Close();
}
Saludos navideños,
PepLluis,
Atendiendo el comentario de Jose Fco en el que indica :
<< He podido leer diversos ejemplos de como utilizar e implementar las funciones básicas de acceso al puerto serie principalmente en aplicaciones WinForms, seria posible obtener una esqueleto base en WPF tal como tienes para los anteriores.>>
El siguiente ejemplo, se entiende como ejercicio para realizar la transmisión y recepción de una trama utilizando un temporizador de un segundo en un proyecto WPF, para cerrar el circuito deberás insertar un conector en el puerto serie con un puente entre los pines 2 y 3. Recordad que el uso de ReadLine suspende la ejecucion del thread hasta recibir la sequencia definida en 'SerialPort.NewLine'.
Partial Public Class Window1
Delegate Sub Actualizar()
Private WithEvents Puerto1 As New System.IO.Ports.SerialPort
Private temporizador As New System.Timers.Timer
Private Recibidos As String = ""
Sub New()
' Llamada necesaria para el Diseñador de Windows Forms.
InitializeComponent()
Puerto1 = My.Computer.Ports.OpenSerialPort("COM1", 9600)
AddHandler Puerto1.DataReceived, AddressOf Recepcion
temporizador.Interval = 1000
temporizador.Enabled = True
AddHandler temporizador.Elapsed, AddressOf Peticion
End Sub
Private Sub Recepcion()
Recibidos = Puerto1.ReadLine
Me.Dispatcher.Invoke(New Actualizar(AddressOf Datos))
End Sub
Sub Peticion()
Puerto1.WriteLine("Saludos!")
End Sub
Sub Datos()
Me.Label1.Content = Recibidos
End Sub
End Class
Espero que cumpla con tus espectativas.
Saludos,
PepLluis,
Es complicado poder atender todas las solicitudes recibidas en este blog, a menudo intento responder a vuestras inquietudes a pesar de que tambien siempre intento convenceros de que utilizemos los Foros de MSDN puesto que es el sitio adecuado para poder compartir vuestras preguntas para que todos los expertos puedan aportar su opinion.
Para preguntas sobre el puerto serie os recomiendo visitar : http://social.msdn.microsoft.com/Forums/es-ES/devcommes/threads
Una vez aclarado :-)
Bolivar pregunta : a luis tenia una consulta , como puedo convertir cualquier numero entero introducido en un textbox para despues convertirlo a hexadecimal y luego enviarlo por RS232
Repuesta:
Private MiPuertoSerie As New IO.Ports.SerialPort
Sub EnviarHex(Numero As String)
Numero = Hex(Val(Numero)).ToString
MiPuertoSerie.Write(Numero)
End Sub
Respondiendo una pregunta de los foros, me complace compartir con vosotros el siguiente ejercicio; no sin antes puntualizar que se trata de la puesta en escena de un ejemplo que utilizaría un modulo como “clase estática” donde depositar objetos compartidos dentro de nuestro espacio de aplicación.
Para evitar interpretaciones, este es uno de esos ejemplos que no debe considerarse “modelo” pues su escenario es poco menos que atípico, aclarar que en situaciones similares lo adecuado seria diseñar una clase completa con toda la funcionalidad y acceso, para posteriormente incluirla como propiedad en un modulo. La dificultad se encuentra en la cantidad de código que deberíamos desplegar para realizar una explicación que finalmente terminaría siendo compleja de seguir y entender.
Dicho esto, el siguiente es solo un punto de entrada para las personas que intentan iniciarse en el tema y se encuentran en situaciones como la que expone “Caudiz” en los foros… necesita poder acceder al puerto serie desde dos forms diferentes.
Primero definiríamos el modulo que contendrá toda la lógica de acceso al puerto serie y podría ser algo similar a lo que sigue :
Imports System.IO.Ports
Module SerialComm
Private SerialPort1 As New SerialPort
Private LastFrameRead As String
Public Event DataAvailable()
Sub New()
SerialPort1.PortName = "COMx"
SerialPort1.Open()
AddHandler SerialPort1.DataReceived, AddressOf ReceiveData
End Sub
Private Sub ReceiveData()
LastFrameRead += SerialPort1.ReadExisting.ToString()
RaiseEvent DataAvailable()
End Sub
Public Function ReadData() As String
Return LastFrameRead
End Function
Public Sub WriteData(Frame)
SerialPort1.Write(Frame)
End Sub
Public Sub ClearData()
LastFrameRead = ""
End Sub
End Module
Finalmente incluiríamos el siguiente código para acceder a dicha funcionalidad en este caso desde el ‘Form1’ aunque evidentemente podemos incluirlo desde cualquier otro punto del espacio de nuestra aplicación.
Public Class Form1
Sub Form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
AddHandler SerialComm.DataAvailable, AddressOf ReadData
Form2.Show()
End Sub
Sub ReadData()
Me.Label1.Text = SerialComm.ReadData
End Sub
Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles Button1.Click
SerialComm.WriteData("Hola :-) from 1")
End Sub
End Class
Public Class Form2
Private Sub Form2_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
AddHandler SerialComm.DataAvailable, AddressOf ReadData
End Sub
Sub ReadData()
Me.Label1.Text = SerialComm.ReadData
End Sub
Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles Button1.Click
SerialComm.WriteData("Hola :-) from 2")
End Sub
End Class
Espero vuestros comentarios y que a partir de esta idea, podáis construir de forma robusta la implementación de vuestra solucion.
Saludos,
PepLluis,
More Posts
Next page »