C#

GnatMQ : un broker MQTT per il .Net Framework

Cattura

Con una settimana di ritardo rispetto l’uscita prevista, ho finalmente rilasciato in versione Beta un broker MQTT completamente sviluppato in C# e che può essere eseguito con il .Net Framework ed il .Net Compact Framework 3.9 (su sistemi con Windows Embedded Compact 2013) … il suo nome è GnatMQ !

Al suo interno pulsa il cuore della libreria M2Mqtt con la quale condivide il “core” del protocollo MQTT, per quanto riguarda la parte di connessione al client e la gestione dei messaggi.

Ovviamente, è completamente open source e disponibile su CodePlex ma è attualmente in versione Beta (aspetto numerose segnalazioni da parte vostra !).

Come riportato nella pagina di documentazione supporta le seguenti funzionalità :

  • Tutti i livelli di QoS del protocollo MQTT;
  • Flag Clean Session alla connessione di un client;
  • Flag di Retained Message;
  • Will Message con relativo QoS e topic;
  • Autorizzazione con username e password;
  • Sottoscrizione ai topic con wildcards;
  • Publish e subscribe mediante una “inflight queue”;

Tra le funzionalità non ancora supportate abbiamo :

  • Configurazione del broker da un file di configurazione;
  • Sicurezza basata su SSL/TLS;
  • Configurazione bridge (broker to broker);
  • Salvataggio permanente (es. database) delle sessioni, retained message e will message;

Il mio obiettivo è di supportare lo sviluppo di questo broker così come per la libreria M2Mqtt nella speranza che possa essere utilizzato e migliorato grazie alle vostre segnalazioni !

Per poterne seguire l’evoluzione è possibile utilizzare anche la relativa pagina Facebook ed account Twitter.

C# : tip per la risoluzione del “ambiguous reference”

Oggi mi si è riproposto un problema che da tempo non mi si presentava ed ho deciso di scrivere un “tip” per la risoluzione. Il problema in oggetto è l’errore di compilazione “ambiguous reference”.

Purtroppo, nel mio progetto uPLibrary su CodePlex ho una classe Utility nel nemespaceuPLibrary.Utilities ma ne esiste un’omonima nel namespace Microsoft.SPOT.Hardware del .Net Micro Framework. Ovviamente, questo comporta un errore di “ambiguous reference” al momento della compilazione.

2275.Immagine_thumb_58E4FDA2

La soluzione a questo problema prevede l’uso degli alias per i namespace o per le classi, per cui abbiamo due possibilità :

  • using uPUtility = uPLibrary.Utilities.Utility ossia dichiarare un alias per la classee quindi utilizzare uPUtility nel codice;
  • using uPUtilities = uPLibrary.Utilities ossia dichiarare un alias per il namespacee quindi utilizzare uPUtilities .Utility nel codice;

Un mio nuovo piccolo progetto su CodePlex : M2Mqtt

2783.m2mqttpng_58BFBD2D

Ho appena pubblicato su CodePlex un mio piccolo nuovo progetto : M2Mqtt.

Si tratta di un client MQTT (Message Queue Telemetry Transport) che può essere utilizzato su tutte le piattaforme .Net, ovviamente con un occhio particolare al .Net Micro Framework.

Per chi non lo sapesse MQTT è un protocollo per la comunicazione M2M (Machine to Machine) nell’ambito dell’Internet Of Things e per il quale ultimamente è stato avviato un processo di standardizzazione con OASIS. Basti pensare che grazie alla suo notevole “leggerezza”, è stato scelto come protocollo per lo scambio di messaggi attraverso ilFacebook Messanger.

Per maggiori informazioni vi rimando al sito ufficiale MQTT ma non mancherò di pubblicare al più presto una serie di articoli dedicati a questo protocollo ed all’utilizzo della libreria che ho appena rilasciato.

Mi raccomando….stay tuned !!

ioProgrammo : realizziamo un sistema di allarme temperatura con il Netduino Plus

8666.4-177g_468EB7EF

Anche questo mese nella rivista “ioProgrammo” (n. 177, Agosto 2012) c’è un mio articolo sul .Net Micro Framework e la sua applicazione con Netudino Plus.

Sfruttando la funzionalità Ethernet della scheda, viene realizzato un sistema di allarme temperatura configurabile via RESTful APIs che invia una mail quando la soglia impostata viene superata.

Anche questa volta…mi raccomando…non perdetevelo !

ioProgrammo : il mio articolo sul .Net Micro Framework

1884.4-176g_2CE5F352

Questo mese, nella nota rivista di programmazione “ioProgrammo” (n. 176, Luglio 2012), c’è un mio articolo sul .Net Micro Framework.

Si parte dalle basi, dall’architettura e dal modello di programmazione sino ad arrivare a realizzare, attraverso l’utilizzo del Netduino, un allarme fatto in casa che sfrutta un sensore di prossimità.

Mi raccomando non perdetevelo e correte in edicola ad acquistarlo !

WP7 : HttpWebRequest e la cache interna

Forse non tutti sanno che la classe HttpWebRequest utilizza una propria cache interna per tutte le richieste che via via vengono eseguite durante il suo utilizzo.

Accade che, eseguendo una richiesta sempre al medesimo URL, l’oggetto HttpWebRequest istanziato non esegue effettivamente la richiesta (l’ho rilevato mediante Wireshark) ma bensì ritorna immediatamente il contenuto della richiesta fatta in precedenza allo stesso URL. Questo comportamento è, appunto, dovuto alla cache interna di cui la classe è dotata.

Su Windows Phone 7, non esiste la possibilità di modificare l’utilizzo della cache attraverso le cache policies come accade nel .Net Framework ma è necessario sopperire a questa mancanza attraverso un workaround.

string requestUrl = String.Format(url + "&{0}", DateTime.Now.Ticks);
HttpWebRequest request = HttpWebRequest.CreateHttp(requestUrl);
request.BeginGetResponse(new AsyncCallback(HandleResponse), request);

Attraverso il codice precedente, si evince che il workaround consiste nell’aggiungere un parametro casuale nella query string dell’URL desiderato, in modo da avere di volta in volta un URL risultante diverso e forzare la richiesta. In questo caso, la casualità è determinata dai ticks del sistema ma potrebbe essere utilizzata anche legata alla generazione di un Guid. Tipicamente, questo parametro sarà ignorato dal web server ma servirà dal lato del device per “simulare” la richiesta ad un URL differente.

Sicuramente la soluzione non appare molto elegante ma a quanto pare è l’unica possibile…nell’attesa di piacevoli smentite !

Codice Nativo vs Gestito : performance

Affrontando un problema lavorativo riguardo le perfomance grafiche su un target device con processore ARM e Windows CE 6.0 R3 e facendo delle ricerche di approfondimento in rete, mi sono imbattuto in un interessantissimo articolo di Chris Tacke dell’OpenNETCF Communty intitolato “Native vs. Managed Code : GDI Performance”.

L’articolo, attraverso un’applicazione di test, dimostra quanto il codice nativo non possa essere considerato in assoluto molto più veloce del codice gestito ma soltanto per una percentuale relativa che però può talvolta variare da piattaforma a piattaforma. In particolare, il test viene eseguito utilizzando le GDI di Windows.

Un ulteriore interessante risultato è che l’utilizzo di metodi del .Net Compact Framework che fungono da wrapper di corrispondenti metodi nativi (vedi ad esempio Graphics.FillRectangleche è wrapper dell’API FillRect) riducono le performance rispetto all’invocazione diretta delle API di sistema attraverso le P/Invoke. E’ ovvio che il wrapper al suo interno eseguirà sempre una P/Invoke ma aggiunge un carico di lavoro in più, probabilmente legato a dei check che vengono eseguiti prima della chiamata nativa (vedi anche il marshalling dei parametri).

Swap di due variabili senza la variabile di appoggio ? Si può !

Una delle prime funzioni (escludendo il solito Main() che produce il famosissimo “Hello World”) che si scrive quando ci si avvicina al mondo della programmazione, è quella che ci permette lo swap (scambio) di valori tra due variabili. Tipicamente si è portati a scrivere del codice di questo tipo …

private void Swap(ref int a, ref int b)
{
    if (a != b)
    {
        int tmp;

        tmp = a;
        a = b;
        b = tmp;
    }
}

… ossia siamo portati ad utilizzare una terza variabile (tmp) di appoggio.

Ebbene, tale variabile si può assolutamente evitare, riscrivendo la funzione nel modo seguente …

private void Swap(ref int a, ref int b)
{
    if (a != b)
    {
        a ^= b;
        b ^= a;
        a ^= b;
    }
}

… ed utilizzando solo ed esclusivamente le proprietà dell’operatore logico XOR (commutativa, associativa identità).