Emulatori MAC Old World

Per ricorda un po' i vecchi tempi un po' di giochi con l'emulatore per computer Apple della serie 68000 e PowerPC.
Per motivi legali per poter far funzionare l'emulatore (visto che deve essere utilizzato il file ROM) si deve possedere il calcolatore originale ma vista la mia collezione di Apple che parte dal 512K e finisce ad un MacMini G4 non credo che ci siano problemi

L'emulatore piu' completo da usare e' Basilisk che, su Debian, si installa semplicemente con il comando

apt-get install basilisk2

a questo punto si devono inserire i file ROM (che si scaricano in modo piu' o meno legale da Internet o, avendo l'hardware funzionante, possono essere estratti direttamente). Basilisk gestisce ROM fino ai modelli Quadra

Successivamente si deve avere a disposizione il sistema operativo. Fino a qualche tempo fa Apple metteva a disposizione in download gratuito i System da 6 fino a 7.5.5. (attualmente la pagina non funziona piu' ma qualche anno fa mi ero salvato le immagini dei dischetti)...sempre su Internet si trovano le immagini dei System 8 e 9 ma, essendo tuttora coperti da licenza, si deve aver comprato la licenza per poterli usare

A questo punto si e' pronti. Lanciando il comando BasiliskII (attenzione alla maiuscola iniziale) compare la GUI di configurazione

Per il monitor si puo' scegliere fino a 1024x768 ma i primi monitor di Mac erano 512x342.
Per la memoria e' necessario settare almeno 12 Mb per System 8
Per la Rom si deve settare quella disponibile sotto Memory/Misc
Nei Volumes si deve creare un disco vuoto (diciamo di 20 Mb perche' i primi Mac avevano queso taglio di disco fisso) e l'immagine del System
Pronti per lo Start

Una volta avviato compare prima l'Happy Mac, seguito dalla richiesta di formattazione del disco fisso..si puo' procedere. Terminata questa fase si conclude quindi con l'installazione del System

Terminata l'installazione si puo' fare lo shutdown ed eliminare il Volume dell'immagine del System in modo da effettuare il boot dal disco fisso

Attenzione: non sono riuscito a far partire l'emulatore con il display a colori ma e' un mio difetto dato che il software permette di farlo (la GUI sotto Windows presente questa opzione che non e' presente nella versione nei repository Debian)

Come emulatore esiste anche Mini VMac che pero' non e' disponibile nei repository Debian e che e' indirizzato all'emulazione dei modelli piu' vecchi del tipo 68000 (niente PPC) in particolare di un Mac Plus 4 Mb . Si puo' scaricare direttamente il file eseguibile da questo link.

Per funzionare il programma ha bisogno di una Rom che deve essere denominata come vMac.ROM e che deve risiedere nella stessa directory dell'eseguibile.

Una volta avviato il programma si presenta la schermata con l'Happy Mac e poi l'icona del Floppy con il punto interrogativo. Si deve quindi con il drag&drop trascinare sulla finestra dell'emulatore il file immagine del System e quello del disco fisso vuoto (si trovano delle immagini di vario taglio nel file blank.zip) 

Montare condivisioni Windows su Linux

Come al solito arrivo in ritardo.
Fino a qualche tempo fa montavo le condivisioni Windows mediante smbmount ed oggi che ne avevo bisogno non trovavo piu' il comando nella mia Debian Box

Con un po' di disappunto ho scoperto che il comando e' stato deprecato ed attualmente si deve procedere con

apt-get install cifs-utils

si crea poi la directory dove effettuare il mount
mkdir /mnt/cifs

e poi si usa cifs (le istruzioni sono riprese dal sistema che ho usato per copiare le Rom su ChameleonPi)

mount -t cifs //192.168.0.2/roms /mnt/cifs -o username=xz,password=spectrum

Errore OpenGl (FreeGlut) in Virtualbox

UPDATE 2

------------------------------------------------------------

Dopo un po' di prove ho isolato il problema

Il programma che disegna il cubo e che funzionava in CentOS e non in Debian ha smesso di funzionare nel momento in cui ho installato le Guest Additions alla macchina CentOS.

Per cui il difetto non e' nelle librerie OpenGL ma nell'implementazione OpenGL fatta da Virtualbox nelle Guest Additions

--------------------------------------------------------------

UPDATE

------------------------------------------------------------

ho riprovato dopo un po' di tempo e mi sono reso conto che l'errore di segmentazione su VirtualBox delle OpenGL non e' totalmente a carico di software di virtualizzazione

Infatti questo codice

//////////////////////////////////////////////////////////////

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

void init(void) 
{
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel (GL_FLAT);
}

void display(void)
{
   glClear (GL_COLOR_BUFFER_BIT);
   glColor3f (1.0, 1.0, 1.0);
   glLoadIdentity ();             /* clear the matrix */
           /* viewing transformation  */
   gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
   glScalef (1.0, 2.0, 1.0);      /* modeling transformation */ 
   glutWireCube (1.0);
   glFlush ();
}

void reshape (int w, int h)
{
   glViewport (0, 0, (GLsizei) w, (GLsizei) h); 
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
   glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
   glMatrixMode (GL_MODELVIEW);
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
   glutInitWindowSize (500, 500); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape);
   glutMainLoop();
   return 0;
}

//////////////////////////////////////////////////////////////

compilato con 

gcc cubo.cpp -lglut -lGLU

Su Debian Testing in Virtuabox crasha brutalmente

Invece su CentOS , installando le librerie come segue

yum install freeglut freeglut-devel libX11-devel mesa-libGLU-devel

il programma funziona correttamente

c'e' da dire che CentOS usa generalmente librerie e programmi piu' vecchi rispetto a Debian Testing per cui il problema potrebbe essere proprio da ricercare nelle librerie OpenGL ed il non aggiornamento di Virtualbox

------------------------------------------------------------

Tentando di compilare il sorgente sottostante (un esempio di OpenGl) in una Debian Box in VirtualBox e' comparso il seguente messaggio


OpenGL Warning: XGetVisualInfo returned 0 visuals for 0x8807240
OpenGL Warning: Retry with 0x8002 returned 0 visuals

Errore di segmentazione

----------------------------------------
#include "GL/freeglut.h"
#include "GL/gl.h"

/* display function - code from:
     http://fly.cc.fer.hr/~unreal/theredbook/chapter01.html
This is the actual usage of the OpenGL library. 
The following code is the same for any platform */
void renderFunction()
{
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(1.0, 1.0, 1.0);
    glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
    glBegin(GL_POLYGON);
        glVertex2f(-0.5, -0.5);
        glVertex2f(-0.5, 0.5);
        glVertex2f(0.5, 0.5);
        glVertex2f(0.5, -0.5);
    glEnd();
    glFlush();
}

/* Main method - main entry point of application
the freeglut library does the window creation work for us, 
regardless of the platform. */
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE);
    glutInitWindowSize(500,500);
    glutInitWindowPosition(100,100);
    glutCreateWindow("OpenGL - First window demo");
    glutDisplayFunc(renderFunction);
    glutMainLoop();    
    return 0;
}
----------------------------------------

Il problema e' relativo alla software di virtualizzazione (Virtualbox) che, nonostante sia spuntato l'utilizzo dell'accelerazione 3D, non gestisce in modo corretto OpenGL e quindi genera un errore che su una macchina reale sarebbe assente

Big Array in C++

Mentre cercavo di creare un array un po' grandino (6000x6000..dati derivanti da Shuttle Radar Topography Mission) mi sono accorto di una cosa un po' strana.
Il file origine e' composto da un header di 5 righe e poi 6000 righe con 6000 elementi di dati di elevazione

La compilazione del programma sottostante avviene corretamente ma quando viene messo in esecuzione

Errore di segmentazione

L'errore viene creato quando viene creata la matrice bidimensionale
-------------------------
int main()
{

int t;
stringstream textstr;
string s="";
int riga,colonna;
int srtm[6000][6000];

ifstream infile( "E010_N40.asc" );

// salta l'header
for (t = 0; t <= 5; t++)
{
getline(infile, s);
}

riga = 0;
colonna = 0;

while (infile)
  {
    string s;
    if (!getline( infile, s )) break;
    istringstream ss(s);
    colonna = 0;
    while (ss)
    {
      string s;
      if (!getline( ss, s, ' ' )) break;
      cout << riga << ":" << colonna << ":" << atoi(s.c_str()) << endl;
      
      srtm[riga][colonna] = atoi(s.c_str());
      colonna++;
      }
     riga++;
  }
return 0;
} 

-------------------------

La soluzione, molto semplice, e' sostituire il tipo dati matrice con un vector

-------------------------
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <stdlib.h> 
#include <vector>    


using namespace std;

int main()
{

int t;
stringstream textstr;
string s="";
int riga,colonna;
vector<int> srtm;

ifstream infile( "E010_N40.asc" );

// salta l'header
for (t = 0; t <= 5; t++)
{
getline(infile, s);
}

while (infile)
  {
    string s;
    if (!getline( infile, s )) break;
    istringstream ss(s);
    colonna = 0;
    while (ss)
    {
      string s;
      if (!getline( ss, s, ' ' )) break;
      cout << riga << ":" << colonna << ":" << atoi(s.c_str()) << endl;
      
      srtm.push_back(atoi(s.c_str()));
     
      }
     
  }
return 0;
} 

Creazione di post automatici su Facebook con RFID su Android (7)

Qui viene descritto come pubblicare su Facebook in modo automatico mediante un telefono abilitato con Rfid. In pratica si tratta dell'unione di diversi post precedenti ed in particolare questo e questo


A differenza di Java, per creare una connessione Http in Android si devono prima settare i permessi nel file Manifest.xml (come al solito le modifiche rispetto ai post precedenti sono in giallo)


Manifest.xml
---------------------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.test4"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="7"
        android:targetSdkVersion="16" />

    <uses-permission android:name="android.permission.NFC"/>
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission  android:name="android.permission.ACCESS_NETWORK_STATE" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.example.test4.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>


        <activity android:label="@string/event_verify" android:name="verifytagscanact">
            <intent-filter>
                <action android:name="android.nfc.action.TECH_DISCOVERED"/>
            </intent-filter>
            <meta-data android:name="android.nfc.action.TECH_DISCOVERED" android:resource="@xml/filter_nfc"/>
        </activity>

    </application>

</manifest>

---------------------------------------------------

Nella main le modifiche sono minime e piuttosto simili a Java per l'oggetto HttpConnection. Molto peculiari sono le prime righe dopo OnCreate perche' sono relative ad una gestione specifica di Android (come si puo' leggere meglio spiegato in questo post)

MainActivity.java

---------------------------------------------------

package com.example.test4;

import android.os.Bundle;

import android.app.Activity;

import android.os.StrictMode;

import android.util.Log;

import android.view.Menu;

import android.nfc.Tag;

import android.nfc.NfcAdapter;

import android.nfc.tech.MifareClassic;

import android.app.PendingIntent;

import android.content.Intent;

import android.content.IntentFilter;

import android.content.IntentFilter.MalformedMimeTypeException;

import android.widget.Toast;

import java.math.BigInteger;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.net.HttpURLConnection;

import java.net.MalformedURLException;

import java.net.URL;

public class MainActivity extends Activity {

    NfcAdapter adapter;

    PendingIntent pendingIntent;

    IntentFilter writeTagFilters[];

    String[][] techListsArray;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        StrictMode.ThreadPolicy policy = new StrictMode.

        ThreadPolicy.Builder().permitAll().build();

        StrictMode.setThreadPolicy(policy);

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        adapter = NfcAdapter.getDefaultAdapter(this);

        pendingIntent = PendingIntent.getActivity(this, 0, new Intent(this, getClass()).addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP), 0);

        IntentFilter tagDetected = new IntentFilter(NfcAdapter.ACTION_TECH_DISCOVERED);

        try {

            tagDetected.addDataType("*/*");

        }

        catch (MalformedMimeTypeException e) {

            throw new RuntimeException("fail", e);

        }

        tagDetected.addCategory(Intent.CATEGORY_DEFAULT);

        writeTagFilters = new IntentFilter[] { tagDetected };

        techListsArray = new String[][] { new String[] { MifareClassic.class.getName() } };

    }

    static String bin2hex(byte[] data) {

        return String.format("%0" + (data.length * 2) + "X", new BigInteger(1,data));

    }

    @Override

    protected void onNewIntent(Intent intent){

        //Toast.makeText(getApplicationContext(), "Trovato Tag", Toast.LENGTH_SHORT).show();

        Tag tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);

        byte[] tagId = intent.getByteArrayExtra(NfcAdapter.EXTRA_ID);

        // trasmissione dati al server

      try {
            URL url = new URL("http://m.msn.unifi.it/luca/examples/rfid_server3.php?rfid="+bin2hex(tag.getId())+"&msg=cellulare");
            HttpURLConnection connection;
            connection = (HttpURLConnection) url.openConnection();

            readStream(connection.getInputStream());
            Toast.makeText(getApplicationContext(), bin2hex(tag.getId()), Toast.LENGTH_SHORT).show();
            } catch (Exception e) {
            e.printStackTrace();
              }

    

    }


 private void readStream(InputStream in) {
            BufferedReader reader = null;
            try {
                reader = new BufferedReader(new InputStreamReader(in));
                String line = "";
                while ((line = reader.readLine()) != null) {
                    System.out.println(line);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

        }

    public void onPause() {

        super.onPause();

        adapter.disableForegroundDispatch(this);

    }

    public void onResume() {

        super.onResume();

        adapter.enableForegroundDispatch(this, pendingIntent, writeTagFilters, techListsArray);

    }

    @Override

    public boolean onCreateOptionsMenu(Menu menu) {

        // Inflate the menu; this adds items to the action bar if it is present.

        getMenuInflater().inflate(R.menu.main, menu);

        return true;

    }

    

}

---------------------------------------------------
deve essere infine modificato il file /res/values/strings.xml


il file sul server e' identico a quello usato in precedenza

Accoppiamento WiFly con lettore Rfid

Per lo shield WiFly e' stata effettuata la patch descritta qui


Per la connessione del lettore Rfid si usano i seguenti pin

VCC : 3.3V
GND :

MOSI: Pin 11 / ICSP-4
MISO: Pin 12 / ICSP-1
SCK: Pin 13 / ISCP-3
SS: Pin 10
RST: Pin 9

da notare che vista la presenza dello shield il PIN 3.3V risulta coperto per cui e' stato necessario mettere una patch piegando il piedino in modo da poter appoggiare lo shield. In realta' si potrebbe rubare la corrente saldando un contatto direttamente sullo shield

Lo sketch inizializza il lettore Rfid e la WiFly. Successivamente nel loop attende che venga passato il tag Rfid, lo legge ed invia il codice allo script in Php sul server

---------------------------------------------------
#include <WiFlyHQ.h>
#include <SPI.h>
#include <RFID.h>
#include <SoftwareSerial.h>


//WiFi
SoftwareSerial wifiSerial(2,3);
WiFly wifly;
const char mySSID[] = "TIM_PN51T_C0D1";
const char myPassword[] = "50276337";
const char site[] = "m.msn.unifi.it";

//RFid
#define SS_PIN 10
#define RST_PIN 9
RFID rfid(SS_PIN, RST_PIN); 
int serNum0;
int serNum1;
int serNum2;
int serNum3;
int serNum4;

void terminal();

void setup()
{
    char buf[32];
    
    SPI.begin(); 
    rfid.init();

    Serial.begin(9600);
    pinMode(pushButton, INPUT);

    Serial.println("Starting");
    Serial.print("Free memory: ");
    Serial.println(wifly.getFreeMemory(),DEC);

    wifiSerial.begin(9600);
    if (!wifly.begin(&wifiSerial, &Serial)) {
        Serial.println("Failed to start wifly");
terminal();
    }

    /* Join wifi network if not already associated */
    if (!wifly.isAssociated()) {
/* Setup the WiFly to connect to a wifi network */
Serial.println("Joining network");
wifly.setSSID(mySSID);
wifly.setPassphrase(myPassword);
wifly.enableDHCP();

if (wifly.join()) {
   Serial.println("Joined wifi network");
} else {
   Serial.println("Failed to join wifi network");
   terminal();
}
    } else {
        Serial.println("Already joined network");
    }

    //terminal();

    Serial.print("MAC: ");
    Serial.println(wifly.getMAC(buf, sizeof(buf)));
    Serial.print("IP: ");
    Serial.println(wifly.getIP(buf, sizeof(buf)));
    Serial.print("Netmask: ");
    Serial.println(wifly.getNetmask(buf, sizeof(buf)));
    Serial.print("Gateway: ");
    Serial.println(wifly.getGateway(buf, sizeof(buf)));

    wifly.setDeviceID("Wifly-WebClient");
    Serial.print("DeviceID: ");
    Serial.println(wifly.getDeviceID(buf, sizeof(buf)));


}

void loop()
{
    if (wifly.available() > 0) {
char ch = wifly.read();
Serial.write(ch);
if (ch == '\n') {
   /* add a carriage return */ 
   Serial.write('\r');
}
    }

    if (Serial.available() > 0) {
wifly.write(Serial.read());
    }


 if (rfid.isCard()) {
        if (rfid.readCardSerial()) {
              if (wifly.isConnected()) {
                  Serial.println("Old connection active. Closing");
                  wifly.close();
                  }

              if (wifly.open(site, 80)) {
                  Serial.print("Connected to ");
                  Serial.println(site);
                  } else {
                  Serial.println("Failed to connect");
                }
                serNum0 = rfid.serNum[0];
                serNum1 = rfid.serNum[1];
                serNum2 = rfid.serNum[2];
                serNum3 = rfid.serNum[3];
                serNum4 = rfid.serNum[4];
                String Id = String(rfid.serNum[0],HEX)+String(rfid.serNum[1],HEX)+String(rfid.serNum[2],HEX)+String(rfid.serNum[3],HEX)+ String(rfid.serNum[4],HEX);
                Serial.println(Id);
                String params = "{}";
                String paramsLength = String(params.length());
                /* Send the request */
                
                wifly.println("POST /luca/examples/rfid_server2.php?rfid="+Id+"&msg=definitivo HTTP/1.1"); // paste your number here
                wifly.println("Host: m.msn.unifi.it:80");
                wifly.print("Content-Length: ");
                wifly.println(paramsLength);
                wifly.println("User-Agent: lifegraph/0.0.1");
                wifly.println();
                wifly.println(params);
             } 
        
    rfid.halt();
    }
}

/* Connect the WiFly serial to the serial monitor. */
void terminal()
{
    while (1) {
if (wifly.available() > 0) {
   Serial.write(wifly.read());
}


if (Serial.available() > 0) {
   wifly.write(Serial.read());
}
    }
}

-----------------------------------------------------------




Script Php

-----------------------------------------------------------
require_once '../src/facebook.php';
//Luca
if ($_GET["rfid"] == "f479abb492")
    {
    $accessToken = "CAAJkNq2LttoBAJywtmNSbVHqFPubOjYmQ2yyUG4kpibD75BHid9J7xsvif8osSOc4ewgK4aYerrLZBsZCQM5wykRTYVLDkCJXlXYl3gi8WFRQ8U4p4y4ZAXYsdamz6RVdRJZAe4vZA80mWBayuG0qc4IAj2TMDmQXKiv1OrKp8CwKjD6xxxxxxxxxxxxxxxxx";
    print "Luca<br>";
    }
//Gabriele
if ($_GET["rfid"] == "0800364CD7")
    {
    $accessToken = "CAAJkNq2LttoBACxBnb2QjtvbedXaRNwWDAniJsIE59ZBZBjDgsT1FtTmBIVxZAmS4MbbEXY8Y9kduFxfBmQhEgflGxdvXjRG1CAMHICGlHGaCXfP81VlLRySw2m8lzatt074jHsDKYlQjwZAHI725LLSMsAjjDDty3GDOrso0361xLCDzxxxxxxxxxxxxxxxxxxxxxxxxxx";
    print "Gabriele";
    }

$appid = '6731359560xxxxxx';
$appsecret = 'dde6cfb07dbb769c7efe94xxxxxxxxx';
$msg = $_GET["msg"];
$title = 'Dove sono ??';
$uri = 'http://debiaonoldcomputers.blogspot.com/';
$desc = 'Sono ad Arcetri';
$pic = 'http://www.dst.unifi.it/themes/Boozook/images/testa.gif';
$action_name = 'Link';
$action_link = 'http://www.geo.unifi.it/';

$facebook = new Facebook(array(
 'appId' => $appid,
 'secret' => $appsecret,
 'cookie' => false,
 ));

 $user = $facebook->getUser();


$attachment = array(
'access_token' => $accessToken,
'message' => $msg,
'name' => $title,
'link' => $uri,
'description' => $desc,
'picture'=>$pic,
'actions' => json_encode(array('name' => $action_name,'link' => $action_link))
);
$status = $facebook->api("/me/feed", "post", $attachment);
print "Ok";
?> 

Trasmissione radio digitale a 433 MHz con Arduino

Con pochi euro si possono trovare coppie di trasmettitore e ricevitore radio a 433 MHz per far dialogare due schede Arduino nell'arco di qualche decina di metri
Attenzione : vengono venduti componenti, molto simili nell'aspetto, che lavorano a 315 MHz. Il codice e' identico per le due versioni di frequenza, l'importante e' non mischiare un trasmettitore a 433 MHz ed un ricevitore a 315 MHz

La libreria di riferimento per questo tipo di componenti e' VirtualWire

Le connessioni sono molto semplice perche' sono sufficienti tre fili
Vcc (da 5 a 12 V)
GND
Dati

(il ricevitore ha 4 pin ma i due pin centrali normalmente portano entrambi il segnale dati)
Al momento dell'acquisto conviene comprare componenti provvisti di antenna (nella foto si vede che l'antenna del trasmettitore e' stata aggiunta in un secondo momento mentre il ricevitore ha una antenna spiralata)
Di default il pin di trasmissione e' settato sul D12 mentre il pin di ricezione di default e' sul pin D11 (questi possono essere modificato tramite vw_set_tx_pin(nr_pin) e vw_set_rx_pin(nr_pin);

Nella foto un esempio di trasmissione tra due Arduino Nano

In rosso trasmettitore, in verde ricevitore

Attenzione: i componenti vengono venduti senza antenna. E' necessario aggiungere una antenna di 17 cm per i sensori a 433 MHz e 21 cm per i sensori a 315 MHz

Prove effettuate in campo hanno mostrato che il segnale si segue in spazio aperto fino a oltre 150 m con alimentazione a 5 V e baud rate di 200 bit/s

Trasmettitore
--------------------------------------------------------------
#include <VirtualWire.h>

void setup()
{
    Serial.begin(9600);  // Debugging only
    Serial.println("setup");

    // Initialise the IO and ISR
    vw_set_ptt_inverted(true); // Required for DR3100
    vw_setup(2000); // Bits per sec
}

void loop()
{
    const char *msg = "hello";

    digitalWrite(13, true); // Flash a light to show transmitting
    vw_send((uint8_t *)msg, strlen(msg));
    vw_wait_tx(); // Wait until the whole message is gone
    digitalWrite(13, false);
    delay(200);
}
--------------------------------------------------------------

Ricevitore
--------------------------------------------------------------
#include <VirtualWire.h>

void setup()
{
    Serial.begin(9600); // Debugging only
    Serial.println("setup");

    // Initialise the IO and ISR
    vw_set_ptt_inverted(true); // Required for DR3100
    vw_setup(2000); // Bits per sec

    vw_rx_start();       // Start the receiver PLL running
}

void loop()
{
    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;

    if (vw_get_message(buf, &buflen)) // Non-blocking
    {
int i;

        digitalWrite(13, true); // Flash a light to show received good message
// Message with a good checksum received, dump it.
Serial.print("Got: ");

for (i = 0; i < buflen; i++)
{
   Serial.print(buf[i], HEX);
   Serial.print(" ");
}
Serial.println("");
        digitalWrite(13, false);
    }
}
--------------------------------------------------------------