Archivi categoria: Arduino

Aggiornare firmware USBasp con Arduino

Mi è capitato alcune volte di aver problemi con il mio USBasp, mi è capitato di leggere questo errore nel monitor: “avrdude: warning: cannot set sck period. please check for usbasp firmware update”.

Sul sito di Fischl (http://www.fischl.de/usbasp/) ho potuto trovare tutti i file necessari per l’upgrade del dispositivo, tra cui il firmware più recente usbasp.2011-05-28.tar.gz

Ma come programmare un programmatore!?

Due sono le strade:

  1.  L’uso di un secondo programmatore (un altro USBasp ad esempio)
  2.  Un Arduino

Non avendo un secondo USBasp, il modo più semplice era quello di usare un arduino come programmatore.

Ebbene, Arduino può essere utilizzato come programmatore… lo sapevate? 🙂

Gli step da eseguire per aggiornare il firmware dell’USBasp tramite Arduino sono i seguenti:

1. Aprite la vostra ide Arduino, e flashate il vostro arduino con lo sketch ArduinoISP (File>Esempi>ArduinoISP).

2. Mettete in corto lo Jumper JP2 (in qualche versione meno recente è lo jumper R8) del vostro USBasp, in modo tale da abilitare la modalità di autoprogrammazione.usbaspver2

3. Collegate il vostro arduino al pettine dell’USBasp come segue:

Arduino – USBasp
5V ———– 2
GND ——– 10
13 ———— 7 (SCK)
12  ———-  9 (MISO)
11 ———-   1 (MOSI)
10 ———    5 (RESET)

ISP_pines_ArduinoISP_lusbasp_and_arduino

4. Scaricate ed installate AVRDUDESS (http://blog.zakkemble.co.uk/avrdudess-a-gui-for-avrdude/)

5. Cliccate sull’eseguibile e settate il tutto in questo modo:

  • Programmer > Arduino
  • MCU > Atmega8 (assumendo che il vostro USBasp abbia un atmega8)
  • Port > COM3 (dipende a quale porta del vostro pc è collegato arduino)
  • Baud Rate > 19200
  • Files > Flash > Selezionate il vostro firmware .hex da flashare

Dovrebbe essere più o meno così:

Cattura

6. Premete “START!” e incrociate le dita…

Due parole su quale firmware caricare sul vostro USBasp

Sul sito di Thomas Fischl (http://www.fischl.de/usbasp/) l’ultima versione disponibile del firmware è la usbasp.2011-05-28.tar.gz

Pare (praticamente certo), però, che l’ultima versione sia leggermente buggata e che le versioni più vecchiotte non supportano in pieno MCU con memoria flash >64k, dunque non avremo la possibilità di aggiornare i nostri Arduino con Atmega2560.

Ho trovato in giro per la rete questa versione corretta che pare funzioni a dovere: http://openrcforums.com/forum/viewtopic.php?f=10&t=1363#p29615

-Si ringrazia Romolo per la versione riveduta e corretta del firmware-

 

Seminario programmazione embedded #2

 

Il giorno 01/03/2013 si è tenuto, presso l’Università degli studi di Napoli “Parthenope”, il secondo seminario sulla programmazione embedded.

In particolare si è parlato di Arduino e di un paio di progetti fatti al volo.

Durante l’hangout ha partecipato il prof. Raffaele Montella da Chicago.

Allego codici sorgente utilizzati durante il seminario.

E ricordo, che il codice da utilizzare per cosm.com è possibile trovarlo registrandosi al sito.

Sensore temperatura LM35

void setup()
{
  //seriale aperta a 9600 baud
  Serial.begin(9600);
}

void loop()
{ 
  int analogPin=0; //pin analogico 0
  float sensor =0;  

  //leggiamo e convertiamo la temperatura dal pin 0 di arduino
  sensor = analogRead(analogPin);
  sensor = (5.0 * sensor * 100.0)/1024.0;
  //teoria: http://learn.adafruit.com/tmp36-temperature-sensor

  //stampa sulla seriale
  Serial.print("Temperatura: ");
  Serial.println(sensor);

  delay(1000);
}

LM35 + LCD

/*
 Demonstration sketch for Adafruit i2c/SPI LCD backpack
 using MCP23008 I2C expander
 ( http://www.ladyada.net/products/i2cspilcdbackpack/index.html )

 This sketch prints "Hello World!" to the LCD
 and shows the time.
 
  The circuit:
 * 5V to Arduino 5V pin
 * GND to Arduino GND pin
 * CLK to Analog #5
 * DAT to Analog #4
*/

// include the library code: http://learn.adafruit.com/i2c-spi-lcd-backpack/downloads
#include "Wire.h"
#include "LiquidCrystal.h"

// Connect via i2c, default address #0 (A0-A2 not jumpered)
LiquidCrystal lcd(0);

void setup() {
  // set up the LCD's number of rows and columns: 
  lcd.begin(16, 2);
  //seriale aperta a 9600 baud
  Serial.begin(9600);
}

void loop() {
  int analogPin=0; //pin analogico 0
  float sensor =0;  

  //leggiamo e convertiamo la temperatura dal pin 0 di arduino
  sensor = analogRead(analogPin);
  sensor = (5.0 * sensor * 100.0)/1024.0;
  //teoria: http://learn.adafruit.com/tmp36-temperature-sensor

  //stampa sulla seriale
  Serial.print("Temperatura: ");
  Serial.println(sensor);

  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  lcd.print(sensor);

  delay(1000);
}

Open AirQuality System

Open AirQuality System è un sistema di monitoraggio per la qualità dell’aria che sfrutta tecnologie open hardware.

Tale progetto è stato ideato da Andrea Esposito e realizzato con l’aiuto di Fabio Giansante.

Presentato durante lo scorso Hackaton (in occasione del DevFest Campania tenutosi nella nostra università 08-07/12/2012), ha guadagnato il secondo posto.

Questo articolo, scritto a due mani, spiegherà brevemente come si compone il sistema nelle sue parti essenziali.

>>Intervista<<

 

Andrea Esposito:


Supponendo di avere alcuni tipi di sensori di gas commerciali (ad esempio: http://www.futurlec.com/Gas_Sensors.shtml), abbiamo emulato una centralina fissa che rivelava parametri chimici del tipo: co, co2, o3, NH3, NOx, CNG, h2 etc etc

Il sistema si basa sulla scheda open hardware Arduino che, configurata come data collector, raccoglie le variazioni chimiche, percepite dai sensori, trasformandole in valori numerici.

Con semplici chiamate HTTP, il modulo ethernet presente sull’arduino, riesce ad inoltrare tutti i dati ogni x secondi.

Il webservice, facendo il parsing della query string, ha il compito di raccogliere le richieste e memorizzarle su un proprio database.

Grazie a delle API scritte ad hoc, è possibile rendere fruibile all’esterno qualsiasi informazione presente nel database.

Nel nostro caso, l’app Android era in grado di selezionare un area geografica (quartiere/città) ed ottenere informazioni, in tempo reale, relativi a quell’area.

Esempio: selezionando dall’app la città di Frittole (quasi 1500) posso ottenere tutte le informazioni della qualità dell’aria relativa alla centralina installata a Frittole.

Inoltre, se il sistema fosse migliorato, ipotizzando di avere molti campioni su una popolazione di centinai di centraline sparse un pò ovunque, l’apparato potrebbe saper indicare se sul sito X c’è un anomalia in termini ambientali.

Esempio: Se a Piovarolo, nell’ultimo periodo, ho ottenuto una crescita di gas metano, probabilmente ci potrebbe esser qualche discarica abusiva di rifiuti nelle vicinanze.

Tale “popolazione di centraline” potrebbe essere installata su automobili o mezzi pubbici e, legando opportunamente le informazioni raccolte a coordinate GPS, si potrebbe estendere il monitoraggio su aree geografiche più ampie.
Legando alcuni progetti pubblicati su Sebeto (“Tutorial: data logging con Arduino”+”Tuco: Targhetta elettronica a porta con Arduino”) ho potuto prototipare un codice che mi ha permesso di emulare dati fittizzi (in modo random) e inviarli tramite comandi GET.

Nel nostro caso ho usato un oggetto String che mi ha portato via parecchia RAM (portandomi in alcuni casi ad un miserabile overflow) ma che mi ha semplificato la scrittura del codice:

String buffer="";
buffer="GET /getvalueair.json?Quartiere=Arzano&CAQ1="+(char)tempc1;
buffer+="&S02="+(char)sensore2;
buffer+="&O3="+(char)sensore3;
buffer+="&PM10="+(char)sensore4;
buffer+="&NO2="+(char)sensore5;
buffer+="&CO="+(char)sensore6;
buffer+=" HTTP/1.1";   
Serial.println(buffer); //stampa su seriale
client.println(buffer); //invio comando GET

Tale codice può essere alleggerito preferendo di gran lunga questo (da debuggare):

//    client.print("GET /getvalueair.json?Quartiere=Arzano&CAQ1=");
//    client.print(tempc1);
//    client.print("&SO2=");
//    client.print(sensore2);
//    client.print("&O3=");
//    client.print(sensore3);       //Nota: questa era l'idea originale PRIMA dell'utilizzo dell'oggetto String ma...
//    client.print("&PM10=");       //...bug 3: controllare le NewLine!!!
//    client.print(sensore4);
//    client.print("&NO2=");
//    client.print(sensore5);
//    client.print("&CO=");
//    client.print(sensore6);
//    client.println(" HTTP/1.1");

Andrea Esposito

blackstufflabs.com

 

 

 

Fabio Giansante:


FRAPI è un RESTful API Framework che permette agli sviluppatori di creare in modo semplice e rapido RESTful APIs facili da consultare e altamente performanti. FRAPI si divide in due parti specifiche: l’interfaccia di amministrazione e l’API pubblica.

admin-frapi-4

Questo particolare framework permette, con le apposite funzioni dei vari linguaggi di programmazione di cui si fa utilizzo, di leggere ed elaborare dati presenti su un server.

L’interrogazione tramite metodo GET o POST può restituire vari formati di file, uno dei più utilizzati è il file JSON.
1

Come si può notare, in questo caso, l’interrogazione restituisce una serie di dati in un unico record, ma, ovviamente, c’è anche la possibilità di avere una serie di record, ovvero un’array.

Il processo di comunicazione quindi parte dal “richiedente” (app,software, ecc..); il server, che nella maggior parte dei casi preleverà i dati da un database, restituisce una risposta.

Nel caso della nostra applicazione, possiamo evidenziare due passaggi fondamentali :

1) La centralina acquista i vari dati della qualità dell’aria e li invia al server in rete, che provvederà a memorizzarli in una database.

2) L’app ”interroga” l’apposita API che restituirà i dati tramite un file json da leggere ed elaborare.

Uno dei principali vantaggi di una tale infrastruttura è che non c’è tantissimo codice da scrivere.

Tralasciando la parte relativa alla grafica (layout, immagini, bottoni ecc), per elaborare il file JSON, bastano davvero poche righe di codice :

2

La parte fondamentale è nelle prime tre righe, dove :

– la variabile “url” è l’indirizzo tramite il quale si ricava il file JSON

– la funzione “readJSON” prende in input l’url e esegue una sorta di “scansione” del file JSON

– “JSONObject jso” istanzia un oggetto di tipo JSON da poter elaborare

– per effettuare l’elaborazione, bisogna conoscere i vari nomi dei campi che compongono il record, in questo caso vediamo che con la funzione “jso.getString(“Quartiere”)” si estrapola un campo di tipo string identificato col nome “Quartiere”.

L’applicazione android Open AirQuality System potenzialmente potrebbe diventare un utilissimo servizio pubblico a disposizione dei cittadini. La prospettiva di funzionamento è molto semplice e la descriviamo tramite un esempio :

Il sign. Mario Rossi vive nei pressi del Centro Direzionale; ha deciso che è giunto il momento di fare un po’ di footing, ma il suo medico curante gli ha vivamente consigliato di praticarlo quando il livello di CO2 (anidride carbonica) nell’aria è davvero minimo. Bene, il sign. Rossi allora attiva l’app. che localizza la sua posizione tramite gps e mostra in tempo reale i vari parametri della qualità dell’aria nella zona localizzata, in modo tale da poter decidere se è opportuno o meno scendere.

1

C’è inoltre la possibilità di poter scegliere, mediante una select, tra i vari quartieri “sotto-analisi”, in modo tale che se a Capodimonte o altrove i valori sono ottimali, il sign. Rossi può decidere dove è più opportuno svolgere la sua attività fisica.

Fabio Giansante

0124/0028

fabio.giansante@studenti.uniparthenope.it

Arduino: Lettore universale di API

Con questo articolo vorrei mostrarvi i rudimenti per visualizzare su display i risultati di qualsiasi API-REST.

In particolare la visualizzazione delle API Weather di Salvatore Serafino.

Il codice è quasi identico  a quello per la bacheca elettronica “tuco”, per questo motivo credo che modificando opportunamente il firmware possiamo dire che è “universale”.

Il problema del buffer:

Risposte GET molto grandi (molti caratteri) implicano l’uso di buffer molto grandi che manderebbero in overflow il microcontroller senza visualizzare nulla (se ci va bene!).

In questo caso la risposta è memorizzata in un buffer poco più grande di 305 char.

305 char sono 305byte in memoria  (cira 0.3kb).

Sarebbe stato un lavoro più pulito se avessi utilizzato librerie che gestiscono file json; per arduino ho trovato questa: https://github.com/interactive-matter/aJson

Le domande da porci ogni volta sono:

Vale davvero la pena immergere nel proprio binario un’altra libreria a scapito della memoria flash?

Quanta ram avrebbe utilizzato?

La RAM dell’atmega328 (arduino uno/duemilanove) è da 2kb (due cappa, non otto giga!), utilizzata non solo per il buffer…

Seppur il codice viene ottimizzato dal compilatore avr-gcc è buona norma non affaticare il controller che lavoro a soli 16MHz (mega non giga! “single core”!).

Infatti è raro trovare codici che fanno uso di allocazione dinamica, strutture dati complesse ed oggetti avanzati: la StandardTemplateLibrary è ridotta all’osso.

La memoria flash è di soli 32Kb, ed è consigliabile non includere troppe librerie.

Questo codice porta via circa 19kb di flash memory.

Per arginare questi problemi bisogna demandare il carico di lavoro al server.

L’ideale sarebbe: tante GET ben parametrizzate che restituiscono piccole informazione per piccoli buffer.

Ecco perché le api dovrebbero essere ben parametrizzare per restituire poca roba!

Dopo questa piccola premessa analizziamo tutte le fasi della produzione:

HW:

L’hardware che ho usato è sempre lo stesso: router, ethernet shield, arduino duemilanove e un lcd 16×2 seriale.

Questa volta ho utilizzato un lcd più piccolino ma con meno ingombro di cavetterie: solo 4 fili!

Per la precisione vengono utilizzati due cavi (data e clock) per il bus seriale i2c e due cavi per l’alimentazione (+5v e gnd).

Non è il massimo per la lettura ma per la prototipazione rapida è un must.

Documentazione e wiring: http://learn.adafruit.com/i2c-spi-lcd-backpack

Librerie extra:

Per pilotare il convertitore seriale-i2c ho utilizzato la libreria LiquidCrystal ottimizzata da Adafruit: https://github.com/adafruit/LiquidCrystal

Inizializzazione:

viene fatta nella void function setup() e consiste nell’invocazione dei seguenti metodi:

lcd.begin(16, 2); //inizializzazione del display 16x2
Serial.begin(9600);//inizializzazione della porta seriale a 9600baud
Ethernet.begin(mac);//inizializzazione della scheda Ethernet con il proprio mac

La struttura del loop():

myConnect() connessione al server
esecuzione del comando GET
parse() lettura e memorizzazione della risposta in un buffer
disconnect() disconnessione dal server
stampa() parsing del buffer
stampa del buffer su lcd

 

 

 

 

Demando tutti i dettagli implementativi nei commenti del codice.

Codice:

Api-Photo-courtesy-mammedomani.it_

Video:

 

Tuco: Targhetta elettronica a porta con Arduino

Tuco 1.0 è una targhetta elettronica a porta: “intelligente”, open source e open hardware.

E’ stata concepita per essere installata (teoricamente) sulle porte degli studi della nostra università.

Lo scopo della targhetta è visualizzare in tempo reale informazioni del tipo: numero dello studio, docente/i, orari di ricevimento, contatti mail e/o telefonici etc etc… ma soprattutto avvisi presi in tempo reale da uno dei canali di comunicazione dell’università.

E’ stata realizzata sfruttando l’hardware del famoso progetto 100% Italiano chiamato “Arduino“.

Questo prototipo in particolare usa: Arduino Duemilanove, Ethernet Shield, un router (modificato) WiFi Fonera 2100 e un display grafico (G-LCD) parallelo KS0107

Quindi da oggi, le targhette stampate sulle porte della nostra università, potrebbero trasformarsi da queste:

32004523964655204561918

A qualcosa di molto simile a questa:

dscn1128h

Come è stato realizzato questo progetto?

Parte hardware:

Dopo aver configurato le impostazioni del firmware DD-WRT (open) correttamente, il nostro router Fonera deve collegarsi alla propria rete WiFi in modalità repeater WiFi (una valida alternativa della Fonera è il TL-WR702N)

Il router andrà collegato all’ethernet shield con un normale cavo RJ45

Il wiring fatto tra GLCD e Arduino si può trovare sulla documentazione ufficiale della librearia grafica GLCD per Arduino: http://www.arduino.cc/playground/Code/GLCDks0108

Avendo l’accortezza, però, di cambiare i pin:

GLCD – ARDUINO

9    -> D2
10 -> D3

e

16 -> A1
15 -> A2
Per poi ottenere questo:
fdsfsdfsd

Parte software:

Dopo aver scaricato e configurato la propria Arduino IDE, bisogna scaricare ed installare nel path giusto la libreria grafica GLCD.

All’interno della libreria grafica GLCD vanno modificato alcuni file in questo modo:

In:    glcd/glcd_Config.h

Bisogna: commentare #include “config/ks0108_Panel.h” e togliere il commento da //#include “config/ks0108_Manual_Config.h”

In: glcd/config/ks0108_Manual_Config.h

Bisgona: modificare la linea

#define glcdData2Pin        10
#define glcdData3Pin        11

in

#define glcdData2Pin        2
#define glcdData3Pin        3

Save & exit.

Questa modifica è necessaria in quanto sia l’etherne shield che il glcd hanno in comune i pin 10 e 11, dunque per evitare incompatibilità tra i due hardware, la libreria va modificata come sopra

Il firmware:

Il firmware, da me scritto, è presente nella mia cartella personale su: cliccami

Circa i punti salienti del firmware, posso aggiungere che la funzione principale loop (un loop infinito) è strutturata quanto segue:

void loop() { 
  logo();
  cornice();
  numero();
  mail();
  myConnect();
  parse();
  disconnect();
}

In particolare:

Logo

è una funzione che restituisce due immagini bitmap, opportunamente realizzate con un tool (in java e open) all’interno della libreria grafica glcd.

In particolare restituisce il logo della nostra università diviso in due metà.

Cornice

Grazie all’uso dell’oggetto gText ho strutturato il display in tre parti:

immaginerv

Questo mi permette di avere le informazioni divise per aree grafiche tematiche:

Nella superiore visualizzo nome e cognome del/dei docenti e numero dello studio.

Al centro tutte le informazioni DINAMICHE

Nella parte inferiore l’orario di ricevimento

numero e mail

Sono due funzioni che stampano sul gText.centrale rispettivamente: numero stanza e l’indirizzo email.

myConnect

E’ la funzione che mi permette di instaurare un collegamento in modalità client, tra la mia arduino ed il server sebeto.

In particolare myConnect cerca di instaurare il collegamento, ma se dopo tre tentativi non riesce a stabilire una connessione, avviene un hardreset grazie alla macro definita nell’header del firmware.

Una volta stabilita la connessione, effettuo il comando GET verso l’api news (settata in modo tale da  restituire un solo avviso)

parse

E’ la funzione che realizza il parsing del primo avviso restituito dall’api news, in particolare cerca la sottostringa content e memorizza il contenuto dei primi 300caratteri in un buffer.

Il buffer viene stampato char by char con un ritardo di 50ms tra un char e l’altro.

disconnect

realizza la disconnessione dell’arduino dal server.

Note finali:

  • Non avendo un sistema di avvisi centralizzato e comune, in questo prototipo, è stato utilizzato l’api news a scopo dimostrativo.
  • Se avessimo un sistema di avvisi centralizzato si potrebbe modificare il firmware in questo modo:
  1. una query join tra il numero di porta a cui è stato assegnato l’arduino e il DB dei docenti
  2. la query potrebbe restituire molte informazioni, ad esempio: nome, cognome, email, telefono etc etc
  3. il primo/i avviso di ogni docente di quello studio
  4. print delle informazioni scelte su glcd
  • Il limite degli avvisi in questo prototipo, è stato fissato a 300 per ragioni di memoria, leggibilità e perchè fa più figo pensare gli avvisi come dei tweet
  • Essendo open source, ogni idea e modifica è facilmente realizzabile
  • Nel video il display sembra rovinato o sbiadito: è un effetto dovuto ai filtri video di YouTube.
  • Eventuali combinazioni hardware possono essere:
  1. Router -> Ethernet Shield -> Arduino -> Glcd (è il mio prototipo)
  2. Router -> Arduino Ethernet -> Glcd
  3. Arduino WiFi Shield -> Arduino -> GLCD
  4. Arduino + WiFi (su singola pcb) -> Glcd (la combinazione migliore per spazio)

Alcune foto:

dscn1122t dscn1126yt dscn1127h

Tuco 1.0 firmware

Inviare dati da Arduino ad una pagina web ASP.Net 4 / C#

Uno dei modi più semplice per inviare dati sul web è sicuramente usare le query string.

La query string è quella parte dell’url che contiente dati da passare in input ad un programma.

Una volta scritta il nostro sketch in arduino è estremamente semplice inviare i dati ad una webpage da noi scritta.

Avremo bisogno di un modulo aggiuntivo alla nostra board: l’ethernet shield.

Questo shield ha tutto il necessario per trasformare arduino in un client o in un piccolo webservice.

Le librerie ufficiali sfruttano in modo quasi ottimale le potenzialità del suo chipset.

ethshield

Con l’ausilio di richieste HTTP 1.1, quali la GET, riusciamo agilmente nel nostro obiettivo.

Arduino sketch:

#include &lt;SPI.h&gt;
#include &lt;Ethernet.h&gt;
byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; //assegnamo un mac addres alla nostra arduino
byte ip[] = {
192,168,2,20 }; //assegnamo un ip
byte server[] = {
46,16,168,17 }; //l’ip del web service
Client client(server, 80);
//istanziamo un client che lavora sull’ip del web service sulla porta 80
void setup() {
    Ethernet.begin(mac, ip);
    //istanziamo l’ethernet shield con mac ed ip
    Serial.begin(9600);
}
void loop()
{
    delay(1000);
    Serial.println(“connecting…”);
    client.connect(); //ci colleghiamo con i parametri di cui sopra
    if (client.connected()) {
        Serial.println(“connected”);
        //la nostra GET:
        client.println(“GET http://www.QUALCOSA.com/acquire.aspx?username=USERFROMARDUINO&password=PASSFROMARDUINO&
                        datastream=DATASTREAMFROMARDUINO&value=VALUEFROMARDUINO HTTP/1.1″);
        client.println ( “Host: http://www.QUALCOSA.com” ) ;
        client.println(); //chiudere sempre con uno spazio vuoto
    }
    else {
        Serial.println(“connection failed”);
    }
    if (client.available()) {
        //stampiamo tutti i caratteri in risposta dal web service
        do {
            char c = client.read();
            Serial.print(c);
        }
        while (client.available());
    }
    if (!client.connected()) { //stoppiamo il nostro client
        Serial.println();
        Serial.println(“disconnecting.”);
        client.stop();
    }
}

Il nostro frontend acquire.aspx:

<%@ Page Language=”C#” AutoEventWireup=true” CodeFile=”acquire.aspx.cs”
Inherits=”acquire” %>
    <!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>
    <html xmlns=”http://www.w3.org/1999/xhtml”>
        <head runat=server”>
            <title></title>
        </head>
        <body>
            <form id=”form1″ runat=server”>
                <div>
                    <asp:TextBox ID=”TextBox1″ runat=server”></asp:TextBox>
                    <asp:TextBox ID=”TextBox2″ runat=server”></asp:TextBox>
                    <asp:TextBox ID=”TextBox3″ runat=server”></asp:TextBox>
                    <asp:TextBox ID=”TextBox4″ runat=server”></asp:TextBox>
                </div>
            </form>
        </body> 
    </html>

Il backend in C# con il parsing della query string:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
public partial class acquire : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        TextBox1.Text = Request.QueryString["username"];
        TextBox2.Text = Request.QueryString["password"];
        TextBox3.Text = Request.QueryString["datastream"];
        TextBox4.Text = Request.QueryString["value"];
    }
}