Raspberry e Arduino in collaborazione

Salve a tutti.
Questo è il mio primo post quindi spero di non trasgredire al regolamento.
Ho cercato un pò nel forum ma non sono riuscito a trovare nulla che faccia al caso mio.
Vi espongo il mio dubbio/richiesta.
Sono venuto da poco in possesso di un raspberry pi b plus.
Una mia amica mi ha detto che invece suo padre a lei ha comprato un arduino.
Ci sono sempre piaciuti i circuiti elettronici, la programmazione e la robotica.
La mia domanda era: "è possibile interfacciando un arduino con la raspberry pi b plus creare il "cervello" di un robot?"
Noi per comandare il robot vorremmo usare un altro pc nella stessa rete mentre per la connessione tra raspberry e arduino volevamo usare il protocollo I2C.
Abbiamo come cavia da modificare il robosapiens v1.
Il nostro intento era di fargli fare i normali movimenti : direzionali e movimenti delle braccia; fargli trasmettere in streaming il video ripreso dalla webcam e fargli accendere un led per l'illuminazione e un puntatore laser.
Avevo letto che è possibile usare la rasp come master e l'arduino come slave.
Potreste darmi una delucidazione su questo progetto?
Secondo voi è fattibile?
Potreste spiegarlo in modo semplice in modo che anche io possa capirlo ? :smiley:
Grazie mille per un eventuale risposta è per il vostro aiuto

Ti invitiamo a presentarti (dicci quali conoscenze hai di elettronica e di programmazione) qui: Presentazioni
e a leggere il regolamento: Regolamento

Connessione Arduino-Raspy la fai molto semplicemente collegandoli via seriale. Tramite "tuoi" comandi crei un protocollo, ovvero una serie di comandi tramite frasi testuali tra i due.
Esempio "L1ON#" accendi il led numero 1, # per indicare fine comando

Sindrome di Gundam in arrivo... :smiley:

Soprattutto è interessante la possibilità di connettere il tuo raspberry all'arduino della tua amica ;D

ho scritto un driver per linux, e quindi fruibile anche su raspberry, che mappa arduino sul computer come se fossero i pin gpio.
Ha un bug tra il passaggio dai pin alle modalità spi/i2c che sto cercando di risolvere.
Non è legato a nessuna board, cosi si può attaccare dalla UNO alla TEENSY anche se il firmware per il momento è solo per la uno.....
Eccoti un output del mio terminale:

odroid@odroid:~/Croject/remotegpio$ sudo insmod remotegpio.ko
[sudo] password for odroid: 
odroid@odroid:~/Croject/remotegpio$ cd /sys/class/rgpio/
odroid@odroid:/sys/class/rgpio$ echo "connect /dev/ttySAC0" > board
bash: echo: errore in scrittura: Argomento non valido
odroid@odroid:/sys/class/rgpio$ echo "connect to=/dev/ttySAC0" > board
odroid@odroid:/sys/class/rgpio$ ls
a0.0  a2.0  a4.0  avr328p.0  d10.0  d12.0  d2.0  d4.0  d6.0  d8.0  eeprom.0
a1.0  a3.0  a5.0  board      d11.0  d13.0  d3.0  d5.0  d7.0  d9.0
odroid@odroid:/sys/class/rgpio$ cd avr328p.0
odroid@odroid:/sys/class/rgpio/avr328p.0$ ls
lock  mode  option  power  ram  subsystem  timesleep  uevent  version
odroid@odroid:/sys/class/rgpio/avr328p.0$ cat ram
1403
odroid@odroid:/sys/class/rgpio/avr328p.0$ cat option
cmdblink = false
sleepblink = true
autosleep = true
odroid@odroid:/sys/class/rgpio/avr328p.0$ cd ..
odroid@odroid:/sys/class/rgpio$ cd d13.0
odroid@odroid:/sys/class/rgpio/d13.0$ ls
mode  power  subsystem  uevent  value
odroid@odroid:/sys/class/rgpio/d13.0$ echo "1" > value
bash: echo: errore in scrittura: Il descrittore del file è danneggiato
odroid@odroid:/sys/class/rgpio/d13.0$ echo "output" > mode
odroid@odroid:/sys/class/rgpio/d13.0$ echo "1" > value
odroid@odroid:/sys/class/rgpio/d13.0$ echo "0" > value
odroid@odroid:/sys/class/rgpio/d13.0$

Non so quando lo renderò disponibile perchè il tempo a disposizione ultimamente è ridotto all'osso.....

vbextreme:
ho scritto un driver per linux, e quindi fruibile anche su raspberry, che mappa arduino sul computer come se fossero i pin gpio.

Non posso giudicare il tuo lavoro senza vederlo, magari è un capolavoro e non lo sappiamo :slight_smile: , però per il semplice controllo remoto delle varie periferiche di Arduino esiste Firmata, disponibile per vari linguaggi, p.e. per Python o node js, il che rende molto semplice azionare un gpio di Arduino da pc, non importa se Windows o Linux.
Ci sono anche le librerie bridge, nate per la Yun, che con un pochino di lavoro per il porting è possibile utilizzare su un sistema Linux generico, rendono molto semplice la comunicazione tra i due mondi con una particolare attenzione alla parte web.

@astro conosco firmata, arduio è un vero driver!
Vantaggi?
potresti usare qualsiasi codice scritto per raspberry sul tuo pc di casa cambiando solo il nome dei pin.
Il driver può essere chiamato da TUTTI i linguaggi che conosci, compresi quelli di script.
ma in realtà offre una cosa molto particolare, l'estensione del driver direttamente da arduino!
ad esempio se su arduino vuoi collegare un display lcd con firmata come lo usi? e se ci vuoi collegare il lindar?
Bene su arduio dichiari una funzione che gestisce le proprietà del driver remoto e con poche semplici chiamate te lo ritrovi sul computer fruibile da qualsiasi linguaggio.
Ora metti il caso semplice di un servo, scrivi il codice su arduino 20 righe al massimo e sul pc ti appare
/sys/class/rgpio/servo.0
al massimo si possono creare 8 driver x board, limitati solo ad 8 per mantenere una buona dose di ram che come hai potuto vedere è poco più di un kb sulla uno.
Si possono collegare sino a 1024 board diverse ein futuro ci sarà il riconoscimento automatico.

Non sopravvalutarmi è bello ma non penso diessere in grado di creare dei capolavori.
Data di rilascio? bho, a parte il piccolo bug devo scrivere tutta la documentazione! ci vorrà un bel pò ma probabile che a breve lo metto su git.

Le librerie della yun non le conosco,sempre librerie, no driver!

stavo dimenticando, il driver può essere richiamato anche da una pagina scritta in php, sai che significa vero?

vbextreme:
@astro conosco firmata, arduio è un vero driver!

Ok è un driver, però quale mezzo di comunicazione usi tra Linux e Arduino ?

astrobeed:
Ok è un driver, però quale mezzo di comunicazione usi tra Linux e Arduino ?

Ha parlato di SPI/I2C.

Multibus?

Il driver è stato strutturato per utilizzare qualsiasi mezzo di comunicazione, quindi seriale, ethernet etc, per il momento ho implementato le funzioni solo per la seriale perchè voglio prima essere sicuro che tutto funzioni bene, ma essendo predisposto anche per altri tipi di comunicazione basterà aggiungere 6/7 funzioni ed il gioco è fatto.
Firmata gestisce il sincronismo sulla scheda?
ovvero due programmi possono contemporaneamente scrivere sulla spi e sulla eprom? in che modo li gestisce?
Firmata è e rimane un ottimo prodotto ma limita molto le potenzialità di arduino sopratutto per chi è agli inizi.

Il discorso è semplice, arduino permette di fare troppe cose e esportarle tutte è impossibile, allora ho deciso di creare i “remote driver” in questo modo il driver è arduino!
guarda un pò questo codice:

#include "firmios.h"

Firmios firmios;

void setup()
{
    //firmios.setting(9600, OPZ_CMD_BLINK | OPZ_SLEEP_BLINK | OPZ_SLEEP_AUTO, 60000);
    firmios.setting(9600, OPZ_SLEEP_BLINK | OPZ_SLEEP_AUTO, 60000);
    firmios.registerDrv(servo_onevent,3);
}

void loop()
{
    firmios.run();
    /*your code here*/
}

#include <Servo.h>
#include <string.h>

Servo servo;

#define ATTRIBUTE_ATTACH 0
#define ATTRIBUTE_DETACH 1
#define ATTRIBUTE_ANGLE  2

const char *att_name[] = {"attach","detach","angle"};

byte servo_onevent(const HDRV hd, const HATT ha, byte event, char* buf, byte count, byte* bex, void* vex)
{
    byte* val = (byte*) vex;
  
    switch (event)
    {
        case EVENT_DRV_GETNAME:
            strcpy(buf,"servo");
        break;
        
        case EVENT_DRV_EXPORT:
        break;

        case EVENT_DRV_UNEXPORT:
            servo.detach();
        break;
        
        case EVENT_ATT_GETNAME:
            strcpy(buf,att_name[ha]);
        break;

        case EVENT_ATT_EXPORT:
            *bex = ( ATTRIBUTE_DETACH == ha ) ? 0 : 1;
        break;
        
        case EVENT_ATT_READ:
        return 1;
        
        case EVENT_ATT_WRITE:
            switch ( ha )
            {
                case ATTRIBUTE_ATTACH:
                    servo.attach(*val);
                break;
                
                case ATTRIBUTE_DETACH:
                    servo.detach();
                break;
                
                case ATTRIBUTE_ANGLE:
                    servo.write(*val);
                break;
            }
        break;
    }
    
    return 0; 
}

ecco ora se scrivi

odroid@odroid:/sys/class/rgpio$ cd avr328p.0
odroid@odroid:/sys/class/rgpio/avr328p.0$ echo "export servo" > drv
odroid@odroid:/sys/class/rgpio/avr328p.0$ cd ..
odroid@odroid:/sys/class/rgpio$ ls
a0.0  a2.0  a4.0  avr328p.0  d10.0  d12.0  d2.0  d4.0  d6.0  d8.0  eeprom.0
a1.0  a3.0  a5.0  board      d11.0  d13.0  d3.0  d5.0  d7.0  d9.0 servo.0
odroid@odroid:/sys/class/rgpio$ cd servo.0
odroid@odroid:/sys/class/rgpio/servo.0$ ls
attach detach  power  subsystem  uevent  angle
odroid@odroid:/sys/class/rgpio/servo.0$ echo "5" > attach
odroid@odroid:/sys/class/rgpio/servo.0$ echo "90" > angle
odroid@odroid:/sys/class/rgpio/servo.0$ echo "" > detach

puoi controllare il servo senza nemmeno scrivere una riga di codice sul computer!
bello no?
Presente il controller per la psx? bene scrivi il codice su arduino ed hai il driver su linux! due comandi bash e puoi giocare con il joystic e hai scritto al massimo 30/40 righe d codice su arduino e 5/6 righe di bash su linux!
E coi display? potresti sempre avere la temperatura del tuo pc su un display alphanumerico il tutto senza diventare matto con niente.
Con firmata invece ne esci pazzo! come fai con il controller della psx? devi scrivere un servizio/demone che rimanga attivo e devi riscrivere tutto il programma sul pc, hai da fare un enorme lavoro.
Lo so bene perchè inizialmente usavo firmata poi ho scritto una mia libreria chiamata IOS (la trovi sul mio repository) e da IOS è partito il driver ArduIO creato appositamente per semplificare il piu possibile la gestione del dispositivo remoto.

In piu ArduIO o meglio remoteGPIO non è legato alla board e pertanto puoi collegarci qualsiasi scheda tu voglia, anche una Raspberry anche via tcp/ip, ovvero potresti avere un server web x86 che dialoga in remoto con una raspberry,una arduino o cò che ti pare e gli può far accendere o spegnere i vari gpio e far eseguire i “remote driver” in qualsiasi linguaggio…

replicare le funzionalità di ArduIO con una classica libreria è impossibile!

ho letto adesso l’altra risposta, si volendo possono comunicare anche tramite spi o i2c ma quello che intendevo prima è che Arduino ha l’spi e l’i2c che possono essere usate direttamente dal driver.

braFo braFo! :smiley:

Io non ci ho capito niente :slight_smile:

Vorrei segnalare che esiste Randa una scheda di sviluppo per Raspberry Pi B+.

E' in pratica una UNO privata della sezione di alimentazione e della USB, ma con in più un RTC che fa da tramite tra il mondo di Arduino e Raspberry.

cyberhs:
Vorrei segnalare che esiste Randa

Ma si può cazzare ? :grin:

Astro non essere volgare! :slight_smile:

cyberhs:
Astro non essere volgare! :slight_smile:

Dillo ai marinai, loro le rande le cazzano sempre :smiley:

Ah, ecco perché si dice "promesse da marinaio": sono abituati a dire cazzate!

Che i nostri governanti siano dei marinai?

astrobeed:
Dillo ai marinai, loro le rande le cazzano sempre :smiley:

Anche le gomene e le cime, se per quello...

cyberhs:
Ah, ecco perché si dice "promesse da marinaio": sono abituati a dire cazzate!

Errato... i marinai, siccome cazzano le rande... sono dei cazzari... indi fan promesse da marinai :grin: