Guardar los ajustes de la tarjeta microSD


Una cosa muy importante en cualquier aplicación hoy en día es necesario es el entorno.No se trabaja con soluciones fijas sin guardar cualquier tipo de configuración. Sea una configuración simple de un IP o un mensaje personalizado, un archivo de configuración es siempre necesario.

Al principio,  programando utilizando microcontroladores PIC que era un nivel de tarea “muy difícil” porque era para asignar una parte de la memoria de código a las variables de la tienda y el tiempo utilizado como códigos de control y tipo de variable dobles en los procesadores de punto fijo que costabanhoras de programación de desmontar con seguridad un valor doble y hacer el paseo más tarde (El nombre de esta técnica es EWR – EEPROM Lectura y escritura). Esto sigue siendo un buen método, ya que no requiere de una memoria externa como los tradicionales chips de SPI 25LCxxxx donde xxxx es la cantidad de memoria en mísero de kb (máximo 2Mb)!

Si el interés es tan grabar sólo unas pocas variables esta es una gran idea, incluso si la Chirs Walker no simpatizar porque placas Netduino Netduino Mini y cuestan la mitad del precio de la Netduino Plus, es decir, su aplicación queda a mitad de precio!. Este tema , en el foro Netduino muestra una discusión sobre el tema  para reducir el costo y todo.
Para el Netduino además, tenemos una tarjeta microSD de 4 GB de espacio para grabar todo lo que quiera y nada mejor que escribir un archivo sólo para configuración de la tarjeta, por lo que el acceso a la información es práctico y también para modificar las entradas sólo cambiando el archivo en la tarjeta microSD sin necesidad de recompilar el código.

Lo que los lectores deben estar preguntando en este momento es porque no se ha implemntado  en NeonMika.Webserver y se  escribe  aqui  acerca de los archivos de configuración:la lógica está en el paso de guardar la información de configuración de la tarjeta de la tarjeta  para lo  que el autor desarrolló una clase independiente para manejar ese tipo de cosas.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
using System;
using System.Text;
using System.Collections;
using System.Net.Sockets;
using System.Net;
using System.Diagnostics;
using System.IO;
using Microsoft.SPOT;
namespace SDCardClass
{
    /// <summary>
    /// Configuration File Class
    ///
    /// Developed to: Netduino Plus REV.B Borad
    /// .NETMF 4.2 RC5
    ///
    /// By Victor M. Batista
    /// email: [email protected]
    ///
    /// Date: 13-Ago-2012
    /// </summary>
    class Configuration
    {
        //TODO: Insert List to create a file with configuration sections
        private Hashtable _Configuration = new Hashtable();
        private string _FileName;
        public enum ConfigMode{Append,DoNothing};
        /// <summary>
        /// Open a configuration file if it exist and provide
        /// information for request's.
        /// </summary>
        /// name="filename">Optinal file name
        public Configuration(string filename = "ndpcfg.ini")
        {
            //Nome global
            _FileName = filename;
            //Clear configuration file;
            _Configuration.Clear();
            //Read configuration file
            if (File.Exists("\\SD\\" + _FileName))
            {
                FileStream CfgFileStream;
                StreamReader CfgStreamReader;
                try
                {
                    CfgFileStream = new FileStream("\\SD\\" + _FileName,
                                                               FileMode.Open,
                                                               FileAccess.ReadWrite,
                                                               FileShare.None);
                    CfgStreamReader = new StreamReader(CfgFileStream);
                    string val = CfgStreamReader.ReadLine();
                    if (val != null)
                    {
                        do
                        {
                            if (val[0] != ';') // If is not a comment line
                            {
                                string[] SplitVals = val.Split('=');
                                if (SplitVals.Length == 2)
                                {
                                    _Configuration.Add(SplitVals[0], SplitVals[1]);
                                }
                            }
                                val = CfgStreamReader.ReadLine();
                        } while (val != null);
                    }
                    CfgStreamReader.Close();
                    CfgFileStream.Close();
                }catch {}
            }
            
        }
        /// <summary>
        /// Apend new configuration in configuration file
        /// </summary>
        /// name="key">Key as a configuration variable
        /// name="value">Key value as string
        /// name="SetIfExist">Set a this value to the key
        /// if this current key already exist in context
        public void AppendConfig(string key, string value, bool SetIfExist = false)
        {
            if (!_Configuration.Contains(key))
            {
                _Configuration.Add((object)key, (object)value);
            }
            else if(SetIfExist)
            {
                _Configuration[key] = value;
            }
        }
        /// <summary>
        /// Set new configuration in configuration file
        /// </summary>
        /// name="key">Key as a configuration variable
        /// name="value">Key value as string
        public void SetConfig(string key, string value, bool CreateIfNotExist = false)
        {
            if (_Configuration.Contains(key))
            {
                _Configuration[key] = value;
                
            }
            else if (CreateIfNotExist)
            {
                _Configuration.Add((object)key, (object)value);
            }
        }
        /// <summary>
        /// Get a value of key. If current kay did not exist in the context
        /// you can put a default value to set or simples ignore and recive
        /// a empty string as defult
        /// </summary>
        /// name="key">Key that you need the value
        /// name="mode">Handling method if key don't exit in the file
        /// name="val">Default value that to place in key if it don't exist.
        /// If *mode* is DoNothig this value was ignored
        /// <returns></returns>
        public string GetConfigurationOf(string key, ConfigMode mode =
            ConfigMode.DoNothing, string val = "" ){
            //Verifay if this key exit
            if(_Configuration.Contains(key))
            {
                //If key exist return value.
                return _Configuration[key].ToString();
            }else{
                //else make the handling
                if (mode != ConfigMode.DoNothing)
                {
                    //append new entry in configuration file.
                    AppendConfig(key, val);
                    return val;
                }
                else
                {
                    return "";
                }
            }
        }
        /// <summary>
        /// Function to force to write in the microSD card the current
        /// configuration.
        /// </summary>
        public void ForceToWrite()
        {
            try
            {
                FileStream CfgFileStream = new FileStream("\\SD\\" + _FileName,
                                                            FileMode.OpenOrCreate,
                                                            FileAccess.ReadWrite,
                                                            FileShare.ReadWrite);
                StreamWriter CfgStreamWriter = new StreamWriter(CfgFileStream);
                CfgStreamWriter.WriteLine(";Netduino Plus Configuration File");
                foreach (DictionaryEntry Entry in _Configuration)
                {
CfgStreamWriter.WriteLine(Entry.Key.ToString() + "=" +
                                                Entry.Value.ToString());
                }
                CfgStreamWriter.Close();
                CfgFileStream.Close();
            }
            catch { }
        }
        /// <summary>
        /// Desconstructor to write de file in card when the class is
        /// disposed
        /// </summary>
        ~Configuration()
        {
            ForceToWrite();
        }
    }
}

 

La clase es muy simple llamado configuraition y sirve para manejar leer y escribir eventos en la tarjeta microSD que facilita porque no es necesario acceder directamente al archivo, basta con crear la clase y obtener los valores de configuración deseados.

El formato elegido para el archivo es INI . Para aquellos que no conocen el formato del archivo INI es un estándar para la preparación de archivos dedicado para cargar la configuración de programas y dispositivos. Archivos INI son archivos mediante un texto simple con una estructura muy básica que ha  generalizado en Microsoft y en todo el ecosistema Windows. Por supuesto que es muy flojo (un archivo oculto) en Windows ha sido sustituido por el registro de Windows, pero el formato es valido.

Cuando el nombre se debe a la extensión de nombre de archivo que se utiliza comúnmente, “.INI”, que viene de “arranque”. Como “INI” es una extensión de “Windows” muchos desarrolladores  han comenzado a jugar creando varias extensiones como como “CFG”, “conf” o “.TXT”.

El formato INI encapsula el mensaje a través de nuevas líneas en las que una propiedad (o parámetro) es único y es una línea de cualquier archivo. En esta propiedad tiene un nombre y unvalor, delimitado por un signo de igual (=). El nombre aparece a la izquierda del signo igual.

propiedad = valor
propiedad2 = valor2

El punto y coma (";") indica el comienzo de una línea se trata como comentario comentario Cualquier cosa entre el punto y coma y el final de la línea se ignora.

El código que maneja un archivo escrito de esa manera en la tarjeta microSD permitiendo la creación de comentarios y la manipulación de atributos a través de una tabla. Los métodos principales son el constructor, el AppendConfig (), GetConfigurationOf () y el ForceToWrite ().

El constructor de la clase tiene un valor por defecto es el nombre predeterminado ndpcfg.ini que significa archivo de configuración Netduino Plus que se puede cambiar la ubicación o el nombre de la creación de una clase con un nombre de archivo diferente. Si usted desea poner en una subcarpeta recordar la sintaxis: “nomedoarquivo.extensão Carpeta1 \\ \\ Carpeta2”.

El método GetConfigurationOf (clave) es petición de una propiedad que figuran en el expediente, lo natural es que existe la propiedad y que cuestionan el valor como cadena, se devuelve en caso contrario devuelve una cadena sin caracteres (“”). Pero se puede asignar un valor por defecto si no se va a grabar al terminar el control de clases.

El otro método consiste en asignar una nueva clave puede utilizar el AppendConfig () funciones o SetConfig (), esto debido a que el archivo INI tiene una sintaxis que no permite propiedades con el mismo nombre por lo que puede tratar de crear y ya existe en el contexto sólo cambiar el valor o la viceversa con SetConfig ()

Por último, está el método ForceToWrite () que sirve para forzar la escritura de toda la configuración en la tarjeta microSD incluso antes de la clase ha terminado. Esto reduce la cantidad de veces que se accede a la tarjeta, no es la mejor manera de hacer esto, pero esta clase seguirá evolucionando.

Para probar la clase descargar el proyecto aquí .

 

Config = new Configuration ();
 config.GetConfigurationOf ("IP",
     Configuration.ConfigMode.Append, "192.200.6.254");
            
 // Contar el número de código de ejecuciones
 Int32 exec = Convert.ToInt32 (
     config.GetConfigurationOf ("ExecutionsCount" 
     Configuration.ConfigMode.Append, "1"));
 exec ++;
 config.SetConfig (exec.ToString "ExecutionsCount" ());
            
 // Registro de valores
 config.AppendConfig ("máscara", "255.255.0.0");
 config.SetConfig ("puerta de entrada", "192.200.1.1");

 // Escritura Obligar
 config.ForceToWrite ();

Para ilustrar el funcionamiento el autor creo una variable en el archivo de configuración que se incrementa cada vez que se ejecuta el código, un clásico ejemplo del archivo de configuración de la aplicación.

Abra su mente a nuevas ideas, en el archivo de configuración puede contener valores tales como mensajes de LCD para diferentes tipos de cultura, las opciones preferidas por los manipuladores de usuarios de la solución y más.

 

Fuente aqui

Cómo solucionar el problema de que algunas unidades usb no son reconocidas en windows 8


Reparar problemas de dispositivo de hardware y drivers en Windows  de  unidades    usb   que no son reconocidas  correctamente  en nuestro equipo con Windows 8  a veces  puede ser una labor ardua sobre todo cuando vemos que esa unidad es operativa   en otro equipo.

En windows  7  ante  este problema  con el regedit    podíamos ir a  la siguiente ruta   \Hkey current  users \Software\ Microsoft\Windows\ Current user\Policies\  de modo que si había  más de una entrada  debíamos eliminar una , con lo que el problema se solucionaba.

En window 8.1 , como la solución anterior no es  efizcaz,  disponemos de la herramienta Fixit  gratuita desde el sitio web de soporte de Microsoft .  Esta utilidad diagnostica y repara automáticamente problemas de hardware como dispositivos de sonido, USB que no funcionan o hardware que no se reconoce.

Soluciona:
  • Cuando instala un dispositivo de hardware, éste no se detecta.
  • Determina si el dispositivo de audio está conectado.
  • Windows Update no instala automáticamente las actualizaciones del controlador.
  • Verá alguno de los errores siguientes:
    • está deshabilitado o apagado en Windows.
    • <Nombre dispositivo> tiene un problema con el controlador y es necesario volver a instalarlo.
    • Windows detectó un problema con , no funciona correctamente.
    • No hay ningún controlador instalado para <Nombre dispositivo>.
Se ejecuta en…
  • Windows 7
  • Windows Server 2008
  • Windows Server 2008 R2
  • Windows Vista
  • Windows 8
  • Windows 8.1
  • Windows Server 2012 editions
  • Windows Server 2012 R2

 

 

Para ejecutarla , tan solo hay que ir  a la  pagina oficial de Microsoft  y seguir  estas sencillas instrucciones:

Pinchar el link  de la  pagina  de Microsoft   y aceptar la descarga del instalador (por supuesto  el sw  no lleva ningún tipo de malware ni publicidad dado el origen del propio software que es el propio fabbrciante)

En la  parte derecha superior   tendremos que pulsar  el botón verde “Ejecutar ahora”

 

fixiti

 

Ahora hay que aceptar la descarga , y permitir la ejecución de este  aplicación   DeviceWin8.meta.diagcab.

Si no se ejecuta  ésta , hacer doble click y permitir  la ejecución  de este ( pulsando en Si)

Ahora simplemente pulsaremos  en siguinte

prob

 

Tras unos minutos se supone quedara resulto el problema

 

probelma

 

 

Por cierto , esta utilidad es gratuita  y ! se puede ejecutar tantas veces se  necesite siempre  que tenga algún tipo de problema con alguna unidad  usb en Windows  8 !

NeonMika.Webserver (servidor web para Netduino) – Parte 3


En esta tercera   parte del NeonMika.Webserver  mostramos las opciones de configuración de todo lo que se ha dicho antes en relación con el servidor web y las opciones para la lectura y la escritura en la tarjeta microSD. También se evaluarán las opciones que existen  sobre solicitudes XML al servidor a través de un programa muy simple de prueba

Petición de Login

En el post   anterior    sobre el NeonMika.Webserver  pudimos comprobar  que una vez que el cliente esta  conectado a la placa de  Netduino+  la conexión nunca se cierra; y, además, cualquier cliente puede acceder a ella sin necesidad de una nueva solicitud de inicio de sesión.

Por supuesto que esto está mal, los clientes no se pueden conectar de forma indiscriminada y una especie de tiempo de espera debería existir en la solicitud del cliente de forma automática que se pudiera quitar debido a la inactividad

Para entender mejor este proceso el autor hizo un pequeño diagrama de cómo funciona la nueva solicitud de inicio de sesión:

 

Una vez que usted ha solicitado una página de código comprueba si el cliente HTML (la IP donde partió la solicitud)  si  ya está en la lista interna de los clientes de un inicio de sesión satisfactorio, si no envía  a la página de inicio de sesión y almacena la página solicitada en la memoria para enviarla más tarde .

En la página de inicio de sesión del usuario debe introducir el nombre de usuario y contraseña a través de un formulario que será enviado por el método POST que contiene por lo menos estos dos objetos: ” nombre de usuario “y” contraseña “. Una vez conectado correctamente este cliente está incluido en la lista de clientes con un tiempo de vida de la conexión y luego abre la página solicitada, si esta página es nulo o vacío se carga “index.html ”

Los usuarios pueden navegar en todas las páginas disponibles en el servidor y también puede tener acceso a otros tipos de respuesta como XMLResponse y JSONRespose

Un acceso de este tipo se lleva a cabo el curso de la vida de la conexión del cliente se regenera al valor pre-definido en la configuración.  La duración de la conexión se decrementa automáticamente una función periódica independiente.

Al llegar a cero cliente se elimina de la lista y se requiere una nueva conexión:así, el servidor web ya tiene una  sesión segura de  conexión a través de la configuración HTML

HTML a través de la configuración de conexión

La configuración IP es una unión de la segunda parte de esta serie de artículos sobre el NeonMika.Webserver relacionado  sobre la configuración escrito en la tarjeta microSD. Vamos a ver ua nueva función de la construcción del servidor donde se requiren datos que se obtienen a partir de un archivo grabado en la tarjeta microSD.
Desafortunádamente, si el código es universal, es decir, se necesitauna página html unida a una función de código. También utilizando el método POST la petición de inicio de sesión se añadió como una solicitud XML (aunque la respuesta no es XML bastante). Así, las peticciones de la página “http: // ipnetduino / config” son enviados a la función “SetNewConfig” en Server.cs.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public Server(OutputPort ledPort, int portNumber = 80)
{
    Configuration config = new Configuration(Settings.CONFIG_FILE);
                       
    var interf = NetworkInterface.GetAllNetworkInterfaces()[0];
    if (config.GetConfigurationOf("dhcp", Configuration.ConfigMode.Append, "false") == "true")
    {
        interf.EnableDhcp();
        interf.RenewDhcpLease();
    }
    else
    {
        //New to fix
        string ipAddress = config.GetConfigurationOf("ip", Configuration.ConfigMode.Append, "10.20.19.200");
        string subnetMask = config.GetConfigurationOf("mask", Configuration.ConfigMode.Append, "255.255.0.0");
        string gatewayAddress = config.GetConfigurationOf("gateway", Configuration.ConfigMode.Append, "10.20.19.1");
            
        interf.EnableStaticIP(ipAddress, subnetMask, gatewayAddress);
    }
            
    //New to set login webpage
    string loginName = config.GetConfigurationOf("loginName", Configuration.ConfigMode.Append, "admin");
    string loginPassword = config.GetConfigurationOf("loginPassword", Configuration.ConfigMode.Append, "admin");
    if (!((loginName == null) && (loginPassword == null)))
    {
        _UserName = loginName;
        _Password = loginPassword;
    }
    ClientsLogedTimeOut = new Timer(new TimerCallback(ClientsLogedEvent), null, 60000, 60000);
           
    this._PortNumber = portNumber;
    _OnboardLed = ledPort;
    ResponseListInitialize();
    _ListeningSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    _ListeningSocket.Bind(new IPEndPoint(IPAddress.Any, portNumber));
    _ListeningSocket.Listen(4);
    var webserverThread = new Thread(WaitingForRequest);
    webserverThread.Start();
    //To force file write in the card
    config.ForceToWrite();
    //limpa a memória
    Debug.GC(true);
}

 

 

La “función SetNewConfig “es una función que se puede llamar por dos métodos: POST y GET. Cuando nos dijeron que el método GET es una solicitud de la página HTML mediante el envío de la página HTML existente en la tarjeta SD: “http://ipnetduino/config.html&#8221;. Está página “config.html” se puede configurar mediante el establecimiento REQUEST_CONFIG_URL enSettings.cs . Una vez que se carga la página puede enviar el formulario a través de un post con la nueva información de configuración. Cuando el cliente envía una solicitud POST se envía cualquier tipo de información mediante la manipulación del archivo de configuración y ajuste de la configuración.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
private void SetNewConfig(RequestReceivedEventArgs e, Hashtable results)
{
    if (e.Request.Method == "POST")
    {
        //Esta enviando as informações de configuração
        Configuration config = new Configuration(Settings.CONFIG_FILE);
        foreach( DictionaryEntry ent in e.Request.PostArguments)
        {
            config.SetConfig(ent.Key.ToString(), ent.Value.ToString(),true);
        }
        //Envia a página de configuração
        e.Request.URL = Settings.REQUEST_CONFIG_OK_URL;
        Response response = null;
        response = (Response)_Responses["FileResponse"];
        if (response != null)
        {
            if (response.ConditionsCheckAndDataFill(e))
            {
                response.SendResponse(e);
            }
        }  
        //Force to Write
        config.ForceToWrite();
        //Apaga tudo!
        Debug.GC(true);
        //Desliga a placa
        PowerState.RebootDevice(false);
    }
    else
    {
        //envia a página de configuração
        e.Request.URL = Settings.REQUEST_CONFIG_URL;
        Response response = null;
        response = (Response)_Responses["FileResponse"];
        if (response != null)
        {       
            if (response.ConditionsCheckAndDataFill(e))
            {
                if (!response.SendResponse(e))
                {
                }
                ////Debug("Sending response failed");
                Thread ledThread = new Thread(new ThreadStart(delegate()
                {
                    for (int i = 0; i < 3; i++)
                    {
                        _OnboardLed.Write(true); Thread.Sleep(5);
                        _OnboardLed.Write(false); Thread.Sleep(20);
                    }
                }));
                        
                ledThread.Start();
            }
        }  
    }
}

Si al  final, una página ha entrado no son aceptados los ajustes y se envía de nuevo y la placa reanuda el código para que las opciones de conexión  tengan efecto.

//Force to Write
config.ForceToWrite();

//Apaga tudo!
Debug.GC(true);

//Desliga a placa
PowerState.RebootDevice(false);

Tenga en cuenta que la página no se envía cuando se hace un preset con los valores de configuración actuales y  no se implementan, pero es necesario para hacer una buena solución robusta. Por otra parte, cuando se recibe el método POST los campos de formulario se escriben en el archivo sin tipo de información de validación para el envío o si el atributo tiene sentido para que el ajuste sea correcto.La validación de este paso es necesario.

Otra simplificación es el hecho es que no todos los atributos puedan ser configurados, el nombre de usuario y la contraseña no son, por definición, en esta forma, pero se puede aumentar simplemente el formulario e incluir  dos campos con la etiqueta: nombre de usuario y contraseña, y todo se resolverá .> recordar que, dado que no existe una validación ejar estos espacios en blanco permite que el usuario sea “” ( cadena vacía) y la contraseña de la misma cosa “” (vacío).

Esto hace que sea posible  mostrar lo lejos se pueda  llegar  con  Netduino Plus.. NET Micro Framework permite que el sistema operativo embebido  soperte   cosas tan potentes  sin un costo alto nivel de memoria externa. Estoy seguro de poner un servidor web con u PIC24 o un MSP430 no sea una tarea fácil y universal como se hizo aquí.

Peticiones XML

Una de las características implementadas por Marcus VV en el servidor NeonMika.server   son elsoporte de  las peticiones de XML. Se está enviando un GET para escribir / leer algo en hardware / software en Netduino; lo cual es muy útil si se desea enviar un comando a través de la automatización de servidores como de apertura y cierre de un relé o comprobar el estado de iluminación (por ejemplo).

Las   respuestas XML son en realidad delegación de un tratamiento de un GET (el principio porque han probado los ajustes que usted puede enviar un POST) enviado por un cliente. Al igual que en elcódigo modificado adjunto  se pide un login y una contraseña, también se requiere esta información de acceso para acceder a los métodos XML.

Sobre Server.cs , este tiene una función llamada ResponseListInitialize (), que se inicia todas las delegaciones requisición y métodos de cada delegación serán funciones dedicadas para el propósito indicado.

Véase el ejemplo de ” switchDigitalPin “cuando se envía la solicitud:” http://ipnetduino/switchDigitalPin “esta solicitud es interpretada por la función SwitchDigitalPin Es necesario “atributo pin “y” Estado“que son recibidas por el método GET, por lo que la solicitud de se hace de la siguiente manera:

 

 

El retorno de esta función es un archivo XML como se puede ver en esta solicitud:

Además  en neomika.server      las siguientes funciones de acceso a hardware también están disponibles:

  • echo > Valor [ipnetduino] / echo? = [az]
  • switchDigitalPin > [ipnetduino] / switchDigitalPin? pin = [0-13]
  • setDigitalPin > pin [ipnetduino] / setDigitalPin = [0-13] y Estado = [true | false]?
  • PWM pin> [ipnetduino] / PWM = [5 | 6 | 9 | 10]? y periodo = [int] y duración = [int]
  • xmlResponselist > [ipnetduino] / xmlResponselist
  • getAnalogPinValue > [ipnetduino] / getAnalogPinValue? = pin [0-5]
  • getDigitalPinState 
    > [ipnetduino] / getDigitalPinState? pin = [0-13]
  • multipleXML
    > [ipnetduino] / multixml

Lo que viene a la mente en este momento es importante la necesidad de utilizar el navegador para que el acceso a estas “funciones” están disponibles para acceder a la tarjeta.Para demostrar que no es necesario código muy complejo   el autor   hizo  iniciar su sesión en el servidor Netduino Plus y hacer los pins ajustes y leer las entradas analógicas en un programa de manera práctica.

La idea de que el software es exclusivamente para mostrar la viabilidad de NeoMika.Webserver y soporte XML. El   inicio del programa se puede ajustar el valor de IP a IP que su tablero es Netduino Plus y realizar una prueba de ping .

Antes de acceder a la tarjeta es necesario darse cuenta de inicio de sesión,, por lo que al hacer clic en el botón Iniciar sesión se le enviará a la página de inicio de sesión correctamente una vez realizado el  acceso a la tarjeta de programa.

En el interfaz    aparece en un lado la imagen de la Netduino y los campos alrededor de su acceso. Al hacer clic en la actualización de los valores de los pines analógicos se actualizan y cambian el valor porcentual de la década de PWM cambian la placa y botones manejan los pines IO. Todo esto se lleva a cabo mediante el uso de XML con el siguiente interesantisimo código  , que nos demuestra la potencia de esta plataforma.

Function getAnvalue(pin As Integer) As String
        Dim webClient As New System.Net.WebClient
        Dim result As String = webClient.DownloadString("http://" + boardIP.Text.ToString() + "/getAnalogPinValue?pin=" + pin.ToString())
        EventsLog.Text += result.ToString() + vbNewLine
        Dim AdStrVal As String() = result.Split(">")
        Dim AdStrVal2 As String() = AdStrVal(3).Split("<")
        Dim advalue As Integer = CType(AdStrVal2(0), Integer)
        Return (3.3 * advalue / 1024).ToString()
    End Function

Consideraciones finales

Para concluir esta serie de artículos sobre la obra de Marcus NeoMika.Webserver y VV.destacaríamos  la practicidad con la que todo esto se llevó a cabo y que las nuevas aplicaciones se puede cerrar en el medio de código sin muchos cambios. Esto es importante porque muestra qué tan rápido se puede desarrollar algo nuevo y es ideal para aplicaciones de pequeñas empresas.

Recursos

Versión actualizada del servidor web se puede descargar aquí .

La  manipulación de software de XML se puede descargar aquí .

Fuente aqui