in

dotNet Umbria

Il primo User Group in Umbria sul mondo .Net

Articoli

Articoli vari degli iscritti a DotNetUmbria

June 2008 - Posts

  • Primi passi con il .NET Microframework

    Come accennavo in un mio precedente commento ad un post di Andrea, qualche tempo fa alcuni miei colleghi ed io ci siamo dilettati con alcuni primordiali esperimenti di “programmazione embedded” (le virgolette sono d’obbligo visto il livello davvero elementare dei nostri esperimenti); all’inizio è duro anche solamente scegliere cosa provare: il campo di applicazioni è vasto ma richiede competenze un po’ ad ampio spettro, comunque che vanno al di là delle sole conoscenze relative alla progettazione/realizzazione del software.

    Abbiamo acquistato un kit di sviluppo Tahoe, ovvero una scheda equipaggiata con CPU Meridian, dotata di un display LCD, porta seriale, usb e una ridda di pin con passo un decimo di pollice per accedere facilmente alle porte I/O messe a disposizione dalla CPU stessa.  Ecco la nostra scheda (noterete che è ancora marcata ‘Embedded Fusion’…)

    Il Tahoe Development Kit

    Il passo successivo per noi è stato quello di informarci sui rudimenti dei protocolli di comunicazione I2C e SPI, supportati dal Meridian, e di procurarci i primi integrati da far interagire con la nostra scheda…

    abbiamo pensato ai classici sensori di temperatura e ne abbiamo scelti alcuni che implementano il bus I2C e altri che invece dialogano via SPI e, per farci veramente del male, ce li siamo procurati in versione microscopica (con package SMD tra i più piccoli, al limite della saldabilità a mano!)… per poterli ‘cablare’ in una breadboard di dimensioni umane abbiamo comprato (o in un caso realizzato in casa, con tanto di bromografo e bagni in percloruro ferrico!) piccole Printed Board che ospitano l’integrato e offrono piazzole forate per poter saldare i classici cavetti di collegamento… ed eccovi il risultato nella sua forma migliore!

    La breadboard 

    Cosa stiamo osservando? Alla scheda sono collegati: due sensori di temperatura TMP100 (I2C) e un sensore di temperatura TMP123 (SPI) di Texas Instruments, ma non solo! Abbiamo fatto piccoli esperimenti anche con un RTC DS1678 (I2C) della Maxim e, dulcis in fundo (ma ancora tutto è in stato embrionale), un ADC ADS1000 (I2C) ancora di Texas Instruments.

    Al di là del layout confusionario e dei singoli componenti usati quello che abbiamo messo in opera è una semplice comunicaizone con dispositivi esterni con i due protocolli citati; il risultato? Eccovi un termometro con ben tre sensori (e altre cose di contorno)! La temperatura rilevata dai primi due (identici) è quella delle prime due righe, poi abbiamo il clock; alla quarta riga la temperatura rilevata dal sensore SPI (che ha sensibilità maggiore) e in ultima riga un dato analogico (una tensione in particolare) convertito dall’ADC

    Il display quando tutto è in funzione

    Applicazioni pratiche? Chiaramente un termostato programmabile con rilevazione della temperatura in più punti, eccetera eccetera…

    Ma da un punto di vista prettamente informatico, cosa abbiamo realizzato? Per ogni dispositivo una classe driver che eredita da una opportuna classe fornita dal SDK di Embedded Fusion (una per ogni protocollo che abbiamo usato, intendo), a formare un semplice diagramma di questo tipo:

    ClassDiagram1

    La routine principale del nostro software ‘prototipale’? A intervalli regolari chiediamo al processore di fare un giro di ‘transazioni’ di scrittura/lettura con i dispositivi esterni che abbiamo inizializzato e scriviamo i risultati sul display:

    float temp_1 = Hardware.TMP100_1.Temperature;
    float temp_2 = Hardware.TMP100_2.Temperature;
     
    DateTime timestamp = Hardware.DS1678.TimeStamp;
     
    float temp_spi=Hardware.TMP123.Temperature;
     
    float data = Hardware.ADS1000.Data;
     
    Dispatcher.Invoke(new TimeSpan(1000),
        new TimerCallback(delegate(object state) {
            _txt_1.TextContent = string.Concat("#1 : ",string.Concat(temp_1.ToString(), " °C"));
            _txt_2.TextContent = string.Concat("#2 : ", string.Concat(temp_2.ToString(), " °C"));
            _txt_3.TextContent = timestamp.ToString();
            _txt_4.TextContent = string.Concat("SPI : ", string.Concat(temp_spi.ToString(), " °C"));
            _txt_5.TextContent = string.Concat("Data : ", string.Concat(data.ToString(), ""));
        }),
        null);

    Che ne dite? Approfondiamo? Avete idee o suggerimenti? A presto, allora!

  • Progetto NHooligans - Parte 1 - Concetti, entità e interfacce del sistema di simulazione

    In considerazione della straordinaria risposta al mio post nella sezione "futuri appuntamenti" (intendo straordinariamente scarsa), provo ad addentrarmi un po' più nel concreto del sistema di simulazione che costituirà l'ambiente all'interno del quale interagiranno i vari agenti (denominati "hooligan") comandati dai programmi "contendenti".

    Facendo riferimento alla terminologia utilizzata nel framework NSteer, intorno al quale verrà sviluppato il sistema di simulazione, si individuano i seguenti "attori", ciascuno con le proprie peculiarità (o, in altri termini, ciascuno caratterizzato dall'implementazione di una o più delle interfacce definite dal framework:

    Un oggetto di tipo "agente" (Agent, in NSteer), descrive un'entità che vive all'interno del "mondo" (World, in NSteer). Un agente ha un "corpo" (Body, in NSteer), un sistema di "visione" (Vision, in NSteer) e un "comportamento" (Behavior, in NSteer).

    Il "corpo" di un agente definisce le proprietà cinematiche dell'agente (posizione, velocità e accelerazione).

    Un sistema di "visione" definisce la regione in cui un agente può "vedere" gli altri agenti o gli ostacoli presenti, tipicamente, nelle sue vicinanze.

    Il "comportamento" di un agente determina, ad ogni passo della simulazione, la forza (in senso vettoriale) cui sarà sottoposto il suo "corpo".

    Gli agenti sono confinati all'interno del "mondo".

    Il "simulatore" (Simulator, in NSteer) determina, ad ogni passo della simulazione, la situazione cinematica (posizione, velocità e accelerazione) di tutti gli agenti presenti nel sistema.

    Il sistema di simulazione implementato in NSteer definisce quattro servizi per gestire gli agenti, il mondo, gli ostacoli e la "prossimità" di un agente nei confronti degli altri rispettivamente mediante i servizi AgentService, WorldService, ObstacleService e NeighborhoodService.

    Per quanto concerne la visualizzazione della simulazione NSteer definisce il concetto di Sprite, un oggetto 2D caratterizzato da attributi quali colori, visibilità, forma, ecc. e il concetto di "Scena" (Scene, in NSteer), che astrae gli aspetti legati al rendering della simulazione.

    Prima che vi sloghiate la mandibola per gli sbadigli, vi incollo un'immagine relativa ad uno step della simulazione realizzata all'interno del demo che accompagna il framework NSteer.

    Nello screenshot è possibile individuare una decina di agenti (i punti contornati dal cerchietto rosa, che rappresenta lo spazio occupato dall'agente) ciascuno dei quali ha un proprio "orientamento" ed un proprio "cono visivo" (rappresentato dai 3 segmenti terminati da pallini che escono dal centro dell'agente). I comportamenti di ciascun agente sono descritti dall'etichetta che compare accanto a ciascun cerchietto rosa. I comportamenti definiti all'interno del framework NSteer sono già parecchi, ma è possibile definirne di nuovi o scrivendoli da zero o utilizzando uno dei comportamenti "contenitore" già definiti in NSteer. I 3 cerchi viola rappresentano degli ostacoli circolari. Nell'immagine gli agenti al centro della finestra hanno attivato il comportamento "Seek" (ossia insegui) nei confronti del pallino verde in alto (comandato dal movimento del cursore del mouse nell'applicazione di esempio). Gli altri hanno attivato invece un comportamento composito caratterizzato dalla somma del comportamento "Confine" (ossia confina, argina) e del comportamento "Avoid" (ossia evita), rispettivamente per rimanere all'interno della regione permessa (rappresentata dal riquadro interno) e per evitare l'ostacolo che hanno accanto.

    Anche se nello step di simulazione immortalato da questo screenshot non è evidente (perché in questo screenshot altri comportamenti avevano priorità), gli agenti tendono a rimanere uniti ma a non sovrapporsi grazie ad un altro comportamento: il FlockBehavior (dove flock significa "stormo").Questo comportamento ha una valenza "storica" particolare perché è proprio dalla scomposizione delle regole che guidano il comportamento di uno stormo di uccelli che Reynolds ha tratto lo spunto per il proprio lavoro. Per rendervi conto meglio di quello che Reynolds ha inventato (o forse dovrei dire "scoperto") vi consiglio di dare un'occhiata ai demo allegati, ed in particolare (premento Tab si passa da un demo al successivo) al demo "Boids".

    Nel prossimo post inizieremo a dare un'occhiata a qualche snippet di codice, per poi fare chiarezza sui "lotti" di progetto disponibili per l'assegnazione a chi vorrà partecipare attivamente allo sviluppo di NHooligans.

  • Tutorial WPF & LINQ - Lezione 2 - Accesso al database tramite LINQ

    Eccoci qui con la seconda lezione!
    In questa lezione vedremo come creare in automatico delle classi di accesso al database sfruttando le potenzialità di LINQ to SQL quindi vedremo come creare una listview che prelevi i dati dalla nostra tabellina e li mostri a video. Tutto questo senza scrivere una sola riga di codice !!

    4. Creazione di Classi LINQ to SQL

    In Visual Studio, Microsoft mette a disposizione un tipo di file (dbml) che ci consente di creare le classi in modo visuale senza complicarci troppo la vita. Quindi cliccate con il pulsante destro sul progetto nella finestra di esplorazione progetti e seguite il percorso "Add -> New Item ... " e vi apparirà una finestra come questa:Inserimento di LINQ to SQL
    dove selezionate "LINQ to SQL Classes" quindi date un nome al vostro file considerando che tutti i riferimenti poi sfrutteranno questo nome. Io ho messo "MyLinqToSQL.dbml".

    Questa operazione aggiunge tutte le dipendenze necessarie per lavorare con LINQ to SQL se controllate sulle risorse infatti dovreste avere tra gli Assembly:

    System.Data.LINQ
    System.Xml.LINQ

    Ora trascinate la vostra tabella "TIPI" dal "Server Explorer" all'area di lavoro (dovreste infatti avere il file MyLinqToSQL.dbml aperto in modalità Design). Se avete fatto tutto bene vi apparirà la vostra tabella nell'area di lavoro. Questa tabella è la rappresentazione grafica della classe "Tipi" creata in automatico da VS.
    Ora salvate il file e chiudetelo visto che per il momento non ci serve più. L'area di lavoro torna al design della finestra Window1 del progetto.

    5. Creazione della LISTVIEW

    Per inserire controlli in una form WPF il mio consiglio è di utilizzare Expression Blend. Aprite Expression Blend (senza chiudere il progetto VS) e caricate il progetto TestWPFLinqToSql. Vi comparirà la vostra window1. Cercate il controllo ListView nella toolbar a sinistra (probabilmente dovrete aprire l'Asset Library cliccando sul pulsante ">>" quindi cercate ListView e fateci Click, verrà aggiunto alla toolbar) quindi fate doppio click su di esso e vedrete che vi si posizionerà in alto a sinistra. impostate i margini a 0,0,0,40 così da lasciare lo spazio per i futuri bottoni.

    A questo punto andate nel pannello delle proprietà (sempre di expression studio) e se non vi da problemi di refresh potete scorrerlo fino a trovare "miscellaneous" che è una sezione compattata.
    Cliccate su di essa e, sempre se non avete problemi di refresh, potete scorrerla fino a trovare "View" che è anch'essa una sezione compattata, sempre cliccandoci sopra la aprite e scorrete fino a trovare la voce "columns" che invece è una collezione per cui avrete un pulsantino con "..." scritto sopra.
    Cliccateci e se tutto va bene dovrebbe comparirvi il "Collection Editor" delle colonne.
    Create 1 colonna (l'altra già c'è) poi selezionate la prima e impostate la Proprietà "Header" in "Codice"
    Selezionate la seconda e impostate la proprietà "Header" a "Descrizione".
    Ora chiudete premendo OK.
    Visto che probabilmente avrete problemi di refresh anche qui, vi consiglio di chiudere la finestra di design della Window1 e riaprirla dal pannello "Project".
    otterrete una cosa simile a questa:

    6. Associare i dati alla ListView

    Ora comincia il bello.
    Premete F5 e magicamente il programma si avvierà, correggete errori se ce ne sono ma credo che non ve ne siano.
    Ora chiudete l'applicazione appena eseguita e selezionate il controllo ListView facendo doppioclick su esso dal pannello "Object and TimeLine" in modo tale che vi si evidenzi in giallo.
    A questo punto cliccate con il pulsante destro sul controllo nel form e scegliete la voce "BindItemSourceToData" dal menu contestuale.
    Premete sul pulsante "+ CLR" che trovate nella finestra che si è appena aperta e cliccate su "MyLinqToSQLDataContext" che dovreste avere nella lista (io avevo chiamato il file delle classi linq così: MyLinqToSQL.dmbl per cui il mio datacontext si chiama MyLinqToSQLDataContext)
    Premete su "OK" e il datacontext verrà aggiunto alle connessioni "Data Sources", cliccateci sopra e vi apparirà nella colonna di destra, l'elenco degli oggetti che implementano l'interfaccia IObservableCollection (e qui non sono proprio sicuro, quindi la butto là così come mi viene e prendetela con beneficio di inventario) tra cui la classe "Tipis (Array):(Table Tipi)"
    Selezionatela e premete Finish.
    Sembra che non sia cambiato niente ma in realtà abbiamo appena detto che il compilatore XAML deve creare un'istanza di Tipis perché la ListView la deve usare come DataSource ed abbiamo detto alla ListView di usare quell'istanza come DataSource per i suoi DataItem.
    passate dalla visualizzazione Design a quella XML, il Codice XAML ora è il seguente:

    <Window
        xmlns="
    http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="
    http://schemas.microsoft.com/winfx/2006/xaml"
        x:Class="Window1"
        Title="Window1" Height="300" Width="300" xmlns:d="
    http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d" xmlns:TestWPFLinqToSql="clr-namespace:TestWPFLinqToSql">
     <Window.Resources>
      <ObjectDataProvider x:Key="MyLinqToSQLDataContextDS" d:IsDataSource="True" ObjectType="{x:Type TestWPFLinqToSql:MyLinqToSQLDataContext}"/>
     </Window.Resources>
        <Grid>
         <ListView IsSynchronizedWithCurrentItem="True" Margin="0,0,0,40" ItemsSource="{Binding Path=Tipis, Mode=Default, Source={StaticResource MyLinqToSQLDataContextDS}}">
          <ListView.View>
           <GridView>
            <GridViewColumn Header="Codice"/>
            <GridViewColumn Header="Descrizione"/>
           </GridView>
          </ListView.View>
         </ListView>
        </Grid>
    </Window>

    Ora bisogna dire alle colonne quale valore prendere:
    Qui il mio consiglio è di farlo a mano:

            <GridViewColumn Header="Codice" DisplayMemberBinding="{Binding Path=TipoCodice}"/>
            <GridViewColumn Header="Descrizione" DisplayMemberBinding="{Binding Path=TipoDescrizione}"/>

    Purtroppo Expression Blend non ha intellisense e quello di VS si spegne proprio nel Binding per cui dovete sapere come si chiamano le colonne della tabella, le mie si chiamano TipoCodice e TipoDescrizione.
    ora compilate ed eseguite premendo F5. se avete messo dei valori di prova nella tabella dovreste vederli nella listview.
    Tutto questo ancora una volta senza scrivere nessuna riga di codice se non per effettuare il Binding alle colonne. spero che questa limitazione venga al piu presto sorpassata (io sto utilizzando VS2008 SP1 e Blend 2.5 March CTP).

    Con questo abbiamo chiuso la Lezione 2, arrivederci alla prossima lezione dove vedremo come permettere la modifica dei valori direttamente da listview.
    Vi lascio in allegato lo screenshot di quello che è venuto fuori.
  • Tutorial WPF & LINQ - Lezione 1 - Preparazione dell'ambiente di lavoro

     

    Come promesso eccomi qua per creare un mini-tutorial sulla creazione di una piccola applicazione WPF che legga e scriva dati in una tabella di un database SQL sfruttando LINQ.

    1. Creazione del database in SQL EXPRESS 

    Per prima cosa occorre creare un database, io utilizzo SQL Management Studio Express per gestire i database.
    posto la query per la creazione del database così come me la propone SQL Management Studio Express:

    USE [master]
    GO
    /****** Oggetto:  Database [MySampleDB]    Data script: 05/22/2008 13:36:33 ******/
    CREATE DATABASE [MySampleDB] ON  PRIMARY
    ( NAME = N'MySampleDB', FILENAME = N'c:\Programmi\Microsoft SQL Server\MSSQL.1\MSSQL\DATA\MySampleDB.mdf' , SIZE = 2240KB , MAXSIZE = UNLIMITED, FILEGROWTH = 1024KB )
     LOG ON
    ( NAME = N'MySampleDB_log', FILENAME = N'c:\Programmi\Microsoft SQL Server\MSSQL.1\MSSQL\DATA\MySampleDB_log.LDF' , SIZE = 560KB , MAXSIZE = 2048GB , FILEGROWTH = 10%)
    GO
    EXEC dbo.sp_dbcmptlevel @dbname=N'MySampleDB', @new_cmptlevel=90
    GO
    IF (1 = FULLTEXTSERVICEPROPERTY('IsFullTextInstalled'))
    begin
    EXEC [MySampleDB].[dbo].[sp_fulltext_database] @action = 'enable'
    end
    GO
    ALTER DATABASE [MySampleDB] SET ANSI_NULL_DEFAULT OFF
    GO
    ALTER DATABASE [MySampleDB] SET ANSI_NULLS OFF
    GO
    ALTER DATABASE [MySampleDB] SET ANSI_PADDING OFF
    GO
    ALTER DATABASE [MySampleDB] SET ANSI_WARNINGS OFF
    GO
    ALTER DATABASE [MySampleDB] SET ARITHABORT OFF
    GO
    ALTER DATABASE [MySampleDB] SET AUTO_CLOSE ON
    GO
    ALTER DATABASE [MySampleDB] SET AUTO_CREATE_STATISTICS ON
    GO
    ALTER DATABASE [MySampleDB] SET AUTO_SHRINK OFF
    GO
    ALTER DATABASE [MySampleDB] SET AUTO_UPDATE_STATISTICS ON
    GO
    ALTER DATABASE [MySampleDB] SET CURSOR_CLOSE_ON_COMMIT OFF
    GO
    ALTER DATABASE [MySampleDB] SET CURSOR_DEFAULT  GLOBAL
    GO
    ALTER DATABASE [MySampleDB] SET CONCAT_NULL_YIELDS_NULL OFF
    GO
    ALTER DATABASE [MySampleDB] SET NUMERIC_ROUNDABORT OFF
    GO
    ALTER DATABASE [MySampleDB] SET QUOTED_IDENTIFIER OFF
    GO
    ALTER DATABASE [MySampleDB] SET RECURSIVE_TRIGGERS OFF
    GO
    ALTER DATABASE [MySampleDB] SET  ENABLE_BROKER
    GO
    ALTER DATABASE [MySampleDB] SET AUTO_UPDATE_STATISTICS_ASYNC OFF
    GO
    ALTER DATABASE [MySampleDB] SET DATE_CORRELATION_OPTIMIZATION OFF
    GO
    ALTER DATABASE [MySampleDB] SET TRUSTWORTHY OFF
    GO
    ALTER DATABASE [MySampleDB] SET ALLOW_SNAPSHOT_ISOLATION OFF
    GO
    ALTER DATABASE [MySampleDB] SET PARAMETERIZATION SIMPLE
    GO
    ALTER DATABASE [MySampleDB] SET  READ_WRITE
    GO
    ALTER DATABASE [MySampleDB] SET RECOVERY SIMPLE
    GO
    ALTER DATABASE [MySampleDB] SET  MULTI_USER
    GO
    ALTER DATABASE [MySampleDB] SET PAGE_VERIFY CHECKSUM 
    GO
    ALTER DATABASE [MySampleDB] SET DB_CHAINING OFF

    una volta creato il database è necessario creare la tabella:
    anche qui posto il codice così come me lo propone SQLMSE:

    USE [MySampleDB]
    GO
    /****** Oggetto:  Table [dbo].[Tipi]    Data script: 05/22/2008 13:40:07 ******/
    SET ANSI_NULLS ON
    GO
    SET QUOTED_IDENTIFIER ON
    GO
    CREATE TABLE [dbo].[Tipi](
     [TipoCodice] [bigint] NOT NULL,
     [TipoDescrizione] [nvarchar](100) NULL,
     CONSTRAINT [PK_Tipi] PRIMARY KEY CLUSTERED
    (
     [TipoCodice] ASC
    )WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
    ) ON [PRIMARY]

    La nostra tabella sarà quindi una tabellina di 2 soli campi: TipoCodice e TipoDescrizione. la tabella si chiama Tipi

    2. Creazione del un progetto con VISUAL STUDIO 2008

    Apriamo ora Visual Studio 2008 e creiamo un nuovo progetto di tipo "WPF Application" e lo chiamiamo "TestWPFLinqToSql"

    3. Creazione di una connessione dati in Visual Studio 2008

    Dalla finestra "Server Explorer" premete il pulsante "Connect To Database" (quello con il cilindretto giallo ed il + verde) vi comparirà la finestra "Add Connection" dove andrete a selezionare il server (es. NOMEPC/SQLEXPRESS) dove avete creato il database e quindi impostate, se necessario, le credenziali e selezionate il database MySampleDB quindi date ok e vi comparirà nella finestra "Server Explorer" il vostro collegamento al database.

    Ora abbiamo preparato tutto il necessario per poter lavorare. Salvate tutto il progetto e proseguite con la Lezione 2

  • Come scrivere un articolo

    Ecco a voi alcune nozioni tecniche, per chi volesse cimentarsi nella scrittura di un articolo per il nostro portale.

    La seziona articoli è un blog e il suo url è http://dotnetumbria.org/blogs/articoli

    Una volta aperta la pagina del blog, e dopo avere fatto login, in alto a destra trovate il link "Control Panel".

    All'interno del Link è presente il comando "Write a Blog Post", che apre l'editor che vi permette la scrittura direttamente dal WEB del vostro nuovo articolo; ovviamente potete inserire allegati all'articolo e Tag di  ricerca.

    Se scrivete molti articoli nello stesso giorno potete decidere di pubblicarli un po' alla volta cambiando la data di pubblicazione nel Tab "Publication Settings".

    Essendo il nostro un portale tecnico, abbiamo inserito un piccolo plugin che ci permette di formattare il codice in modo agevole.

    Tutto il codice che volete formattare va inserito all'interno dei tag [code language=""] [/code], dove language è il linguaggio di programmazione che state utilizzando. Il plugin si occuperà di colorare le keywords e i riferimenti sintattici in modo coerente con il linguaggio scelto. I linguaggi supportati sono i più disparati e vanno dall'XML semplice al VB.Net passando per C# ed altri. Unico consiglio, se state scrivendo XAML utilizzate XML come linguaggio, e in linea generale utilizzate il tag XML per tutto quello che può essere riferito a tale standard.

    Se preferite utlizzare uno strumento Offline, un'ottima scelta secondo me è Windows Live Writer.

    L'url per la configurazione del blog è sempre la stessa e il login è il vostro account.

    Buon lavoro a tutti.

dotNet Umbria 2007-2008
Powered by Community Server (Commercial Edition), by Telligent Systems