In questa pagina RubinoLab.com presenta diverse foto di un prototipo e prove sperimentali di un caricabatterie senza fili per E-bike da 300 W, realizzato per attività di ricerca.
Per questo progetto, sono stati scritti diversi documenti scientifici sviluppando un modello matematico e conducendo analisi delle prestazioni per determinare la funzione di trasferimento della tensione, la massima capacità di trasferimento di potenza, l’efficienza i per diversi gap d’aria (1 -3 cm) con vari disallineamenti (0,5-1,5 cm)
La frequenza di risonanza di questo circuito per la ricarica wireless delle batterie è di 40kHz.
Per ottenere la massima efficienza e il massimo trasferimento di potenza, occorre lavorare alla frequenza di risonanza.
Per valutare la correttezza dei parametri di tutto il circuito è stata realizzata una interfaccia LabView dove è stato possibile caratterizzare il circuito risonante variando la frequenza tra 30-50 kHz.
Di seguito il secondo prototipo del caricabatteria per Ebike. È il primario del caricabatterie e rispetto al primo prototipo funziona ad una frequenza più alta. Per la parte magnetica è stata utilizzata una bobina di Wurth Elektronik.
Il circuito durante un test connesso ai vari strumenti di misura e alla seriale di un pc per la variazione della frequenza.
In questa sezione vedremo come realizzare un “monitor CAN BUS di tipo universale isolato galvanicamente” utilizzando la piattaforma Arduino con lo shield CAN-ISO (RubinoLab) e l’interfaccia grafica CANHacker.
Un dispositivo professionale “completo” utilizzabile per tutti i protocolli CAN-BUS, da quello per settore automobilistico a quello industriale.
Un dispositivo CAN che consente di scrivere/leggere su Canbus per eseguire operazioni di diagnostica, analisi sul traffico di rete, identificazione problemi di rete, ecc. Ad esempio:
Nel settore automotive: può essere utilizzato per leggere i codici di errore delle auto, moto, ecc. che utilizzano OBD-II oppure eseguire operazioni di “Canbus Reverse Engineering” monitorando lo scambio di dati CAN tra unità lato motore, o inviare comandi per resettare codici di errore, eseguire test a banco di singoli sottosistemi, ecc
Nella industria: con il monitoraggio della rete è possibile aiutare i gestori di una rete CAN a identificare se una rete funziona normalmente o è congestionata. Inoltre, possono essere identificati i colli di bottiglia all’interno di una rete per migliorare le prestazioni aggiornando l’infrastruttura.
Identificazione dei problemi: Come accennato in precedenza, oltre a leggere/scrivere su CAN è possibile identificare tutti i problemi relativi alla rete. Dalle informazioni acquisite via CAN è possibile identificare i pacchetti errati e/o identificare il nodo che non ha risposto alle richieste. Ciò facilita l’identificazione dei dispositivi difettosi all’interno della rete e offre la possibilità di intraprendere azioni correttive rapide.
Lo sketch “Arduino canbus monitor”, implementa il protocollo CAN ASCII/SLCAN compatibile con CAN232/CANUSB di Lawicel. Esso può essere usato per monitorare una gran parte di protocolli CAN. Note: Per velocità CAN che eccedono i 500kbps con una alta densità di dati sulla porta seriale di Arduino, la porta seriale può diventare un collo di bottiglia.
L’interfaccia grafica “CANHacker tool” di (Lawicel) si interfaccia a “Arduino canbus monitor”. Essa implementa una comunicazione CAN con:
invia & riceve Can Frames
supporta lo standard (11 bit) & esteso (29 bit) frames
supporta remote frames (RTR)
supporta filter ID (mask + code)
supporta can baudrates da 10Kbps fino a 1Mbps
supporta MCP2515 @ 16 MHZ
Ora vedremo passo passo come installare il software “Arduino canbus monitor” e “CANHacker tool”.
Installazione
Ora possiamo usare il nostro “sniffer” o “monitor canbus”.
Connettere il dispositivo CAN (Arduino+CAN-ISO shield) al PC. Aspetta che Windows assegni un numero di porta seriale COM. Verifica il numero di porta seriale assegnata da Windows in “Gestione dispositivi”.
Avvia il software CANHacker, e in “Setting” scegliere:
CAN Device: la porta COM assegnata a Arduino da windows
COM Baudrate: 115200 bits/s
CAN Baudrate: velocità della porta CAN
Fare clic sul pulsante “OK”, quindi su “Connect”. Divertiti! Monitora il tuo Can bus, salva i valori, invia messaggi, fai quello che può fare il tuo software di analisi/visualizzazione.
EXAMPLE 01
In questo test effettueremo un test di comunicazione Canbus tra due schede “Arduino UNO” con lo shield “CAN-ISO”.
Ora è possibile avviare i seguenti terminali dopo averli configurati: CANHacker: configura la porta COM, la velocità CAN (per la board con Arduino canbus monitor); CANINO: configura la porta COM, la velocità CAN (per la board con Canino);
Nella figura, per esempio, possiamo vedere l’invio della stringa @00A0102030405060708 dal “terminale seriale di Windows” via CAN all’interfaccia grafica “CANHacker”.
Conclusioni
Con questa soluzione avremo un completo tool, galvanicamente isolato per molteplici usi, a basso costo.
Contattateci per farci conoscere le vostre opinioni, o proporci una vostra idea/progetto. Per scriverci: info(at)rubinolab dot com
I-PRIMES: Intelligent Power Regulation using Innovative Modules for Energy Supervision
JTI-CS – Joint Technology Initiatives – Clean Sky from 2012-06-01 to 2014-12-31
I-PRIMES è un progetto Europeo FP7-JTI del programma di ricerca Clean Sky, nel settore Aeronautico.
I partecipanti al progetto:
Università degli studi della Campania “Luigi Vanvitelli”;
Aeromechs: di cui i fratelli Rubino Guido e Luigi sono stati i responsabili della progettazione, realizzazione e test hardware e dei codici firmware delle SSPC (Solid State Power Controller) progettate.
Tutte le parti del progetto sono state sviluppate e realizzate presso il laboratorio dei fratelli Rubino, ora RubinoLab.
Fase di test del dispositivo I-PRIMES.
Descrizione
L’obiettivo principale è stato lo sviluppo di un dispositivo hardware/software in grado di implementare un sistema innovativo di gestione dell’energia (I-LPM) per una rete elettrica aeronautica.
I-PRIMES è un sistema avanzato “intelligente” per carichi elettrici, che ottimizza il consumo e uniforma le richieste di energia nei periodi transitori di potenza o al sopraggiungere di un guasto elettrico.
Il sistema utilizza una struttura modulare.
Ogni cella è composta da un dispositivo programmabile, uno stadio di interfacciamento e una innovativa parte di potenza che implementa una tecnica di filtraggio sulla linea dc a 270Vdc di dimenzioni contenute.
Il modulo “master” è stato in grado di implementare le I-LPM e comunicare ai moduli “slave” tramite CAN-BUS 2.0B la strategia di gestione dell’energia. Alcuni moduli “slave” sono a “potenza fissa”, altri a “potenza variabile” per la riduzione del consumo.
Caratteristiche:
Tensione nominale: 270V (DC)
Potenza massima per singolo dispositivo: 15kW
Modalità operative: ON / OFF – buck converter
Filtro di linea DC bus 270V @15kW
CAN-BUS 2.0
TEST: RIG SAFRAN (Tolouse-Paris).
Inviti e presentazioni del progetto I-PRIMES
CIRA “Centro Italiano Ricerche Aerospaziali” di Capua (12 Giugno 2014). Presentazione del dispositivo I-PRIMES nel meeting “Clean Sky GRA Annual Review”. Durante il meeting, sono stati esposti in una sala conferenza le funzionalità del dispositivo I-PRIMES con una demo in tempo reale ai responsabili del progetto Clean Sky e dirigenti di aziende del settore aeronautico.
Stand “Clean Sky” al 49th Farnborough International Airshow (18 lug 2014 – 20 lug 2014). Selezionati per esporre e dimostrare le funzionalità del dispositivo I-PRIMES.
UPGRADE
Un aggiornamento del progetto I-PRIMES con estensione hardware/software è un EPC (Electrical Power Center) che è stato progettato e realizzato per test in volo “PERMIT TO FLIGHT LEVEL“.
EPOCAL: Electrical POwer Center for Aeronautical Loads
JTI-CS – Joint Technology Initiatives – Clean Sky
dal 2013-03-01 al 2015-07-31
EPOCAL è un progetto Europeo FP7-JTI del programma di ricerca Clean Sky, nel settore Aeronautico.
I partecipanti al progetto:
Università degli studi della Campania “Luigi Vanvitelli”;
Aeromechs: di cui i fratelli Rubino Guido e Luigi sono stati i responsabili della progettazione, realizzazione e test hardware e dei codici firmware delle SSPC (Solid State Power Controller) progettate ad hoc. Inoltre si sono occupati di tutte le comunicazioni interne (CAN-BUS 2.0b) e l’interfacciamento a dispositivi esterni di terze parti.
Tutte le parti del progetto sono state sviluppate e realizzate presso il laboratorio dei fratelli Rubino, ora RubinoLab.
Descrizione
L’obiettivo principale di questo progetto è stato lo sviluppo di un Electrical Power Center (EPC) cioè di un distributore di potenza per il “flight test” su AIRBUS ATR-72, da integrare con una consolle di controllo dedicata (CC), per valutare le strategie avanzate di gestione dell’energia (E -EM).
I principali punti chiave sviluppati sono stati:
Un EPC equipaggiato con Solid State Power Controllers (SSPC) progettato ad hoc che integra le protezioni hardware e software della sua funzionalità e regola la potenza dei carichi in base alla strategia di gestione dell’energia.
Le tecnologie più recenti sono state implementate nel distributore di energia, riferendosi alle più moderne tecniche, al fine di garantire la conformità con gli standard aeronautici.
Il progetto è stato realizzato procedendo secondo un tipico flusso di lavoro basato sull’analisi dei requisiti, sulle specifiche, sulla fase progettuale, sull’implementazione fisica, sulla fase di test, sull’analisi dei risultati rispetto alle simulazioni e alla convalida finale delle apparecchiature.
L’EPC è uno dei componenti fondamentali per il corretto funzionamento di tutte le parti elettriche ed elettroniche di un aereo, per questo motivo prima dell’installazione per il “test in volo” su AIRBUS ATR-72 (tenutosi a Tolosa nel mese di marzo 2016) sono stati richiesti severi test preliminari per la qualificazione fino a 10000mt, presso un laboratorio esterno qualificato per specifiche aeronautiche (più di 35 test).
I test di qualificazione di tutte le parti per il volo, sono stati condotti presso la azienda Celab (Latina) che ha certificato l’affidabilità del dispositivo secondo i più rigidi standard aeronautici.
Di seguito alcune foto dell’interno del dispositivo “Epocal”
Foto dell’equipaggiamento “Epocal” installato all’interno di un ATR-72.
Il dispositivo nell’ambito del progetto Clean Sky, nel mese di marzo 2016 si è classificato tra i primi
10 migliori lavori per tecnologia su oltre 300 progetti valutati. In futuro sarà riprodotto per la installazione di serie su nuovi velivoli.
Il protocollo implementato utilizza una comunicazione standard ASCII. Ciò rende il sistema compatibile con qualsiasi programma (Python, LabVIEW, MATLAB etc), semplice da adattare al proprio progetto.
Il primo passo da fare è installare la libreria MCP_CAN (se non l’avete già installata), nell’editor Arduino. Qui trovate il link della libreria:
Create un progetto con il codice esempio qui riportato o in alternativa scaricate il progetto allegato e scompattatelo nella vostra cartella di lavoro.
//revisione 2 del 30/03/2018, con Arduino 1.8.5
/*
CAN BUS + ARDUINO --> CANINO interface :)
USB <--> CAN BUS interface
Author: Luigi Rubino
Adesso accetta 3 byte di indirizzo
STRING EXAMPLE:
@00A0102030405060708\n
*/
#include "mcp_can.h"
#include <SPI.h>
#define CAN0_INT 2 // Set INT to pin 2
MCP_CAN CAN0(10); // Set CS to pin 10
// the cs pin of the version after v1.1 is default to D9
// v0.9b and v1.0 is default D10
// Can_Bus_shield-ISO-v1 is default D10
//const int SPI_CS_PIN = 10;
//MCP_CAN CAN(SPI_CS_PIN); // Set CS pin
unsigned char buf[8];
unsigned char canId;
long unsigned int rxId;
#define LEN_STRING 10
unsigned char ReceivedString[LEN_STRING]; //stringa ricezione carattere da USB
int inByte = 0; // incoming serial byte
//global var
int digValue, sign=1;
char rxpos, rxpos2; //per il parser seriale
int address; //comando da eseguire
int DT;
void setup() {
// start serial port at 115200 bps:
Serial.begin(115200); //provare velocità 115200
while (!Serial) {
; // wait for serial port to connect. Needed for native USB port only
}
// Initialize MCP2515 running at 16MHz with a baudrate of 500kb/s and the masks and filters disabled.
if(CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_16MHZ) == CAN_OK)
Serial.println("MCP2515 Initialized Successfully!");
else
Serial.println("Error Initializing MCP2515...");
CAN0.setMode(MCP_NORMAL); // Set operation mode to normal so the MCP2515 sends acks to received data.
pinMode(CAN0_INT, INPUT); // Configuring pin for /INT input
Serial.println("CANINO READY...");
}
void loop() {
unsigned char len = 0;
// if we get a valid byte, read analog ins:
if (Serial.available() > 0) {
// get incoming byte:
inByte = Serial.read();
//Serial.write(inByte);
// delay 10ms to let the ADC recover:
//delay(10);
/* Get the character received from the USART */
if (inByte=='@')
{
rxpos = 1;
digValue = 0;
}
else
{
// Serial.print("-->");
// Serial.print((int) rxpos);
// Serial.println();
switch(rxpos)
{
case 1:
address = hex2int(inByte);
rxpos += 1;
break;
case 2:
address <<=4;
address += hex2int(inByte);
rxpos += 1;
break;
case 3:
address <<=4;
address += hex2int(inByte);
rxpos += 1;
rxpos2 = 0;
break;
case 4: //byte 1
DT = hex2int(inByte);
rxpos += 1;
break;
case 5:
DT <<=4;
DT += hex2int(inByte);
ReceivedString[rxpos2] = DT;
rxpos += 1;
rxpos2 += 1;
break;
case 6: //byte 2
DT = hex2int(inByte);
rxpos += 1;
break;
case 7:
DT <<=4;
DT += hex2int(inByte);
ReceivedString[rxpos2] = DT;
rxpos += 1;
rxpos2 += 1;
break;
case 8: //byte 3
DT = hex2int(inByte);
rxpos += 1;
break;
case 9:
DT <<=4;
DT += hex2int(inByte);
ReceivedString[rxpos2] = DT;
rxpos += 1;
rxpos2 += 1;
break;
case 10: //byte 4
DT = hex2int(inByte);
rxpos += 1;
break;
case 11:
DT <<=4;
DT += hex2int(inByte);
ReceivedString[rxpos2] = DT;
rxpos += 1;
rxpos2 += 1;
break;
case 12: //byte 5
DT = hex2int(inByte);
rxpos += 1;
break;
case 13:
DT <<=4;
DT += hex2int(inByte);
ReceivedString[rxpos2] = DT;
rxpos += 1;
rxpos2 += 1;
break;
case 14: //byte 6
DT = hex2int(inByte);
rxpos += 1;
break;
case 15:
DT <<=4;
DT += hex2int(inByte);
ReceivedString[rxpos2] = DT;
rxpos += 1;
rxpos2 += 1;
break;
case 16: //byte 7
DT = hex2int(inByte);
rxpos += 1;
break;
case 17:
DT <<=4;
DT += hex2int(inByte);
ReceivedString[rxpos2] = DT;
rxpos += 1;
rxpos2 += 1;
break;
case 18: //byte 8
DT = hex2int(inByte);
rxpos += 1;
break;
case 19:
DT <<=4;
DT += hex2int(inByte);
ReceivedString[rxpos2] = DT;
rxpos += 1;
rxpos2 += 1;
break;
case 20: //eseguo il comando
CAN0.sendMsgBuf(address, 0, 8, ReceivedString);
//byte sndStat = CAN0.sendMsgBuf(0x100, 0, 8, data);
//delay(100); // send data per 100ms
rxpos = 0;
//da rinuovere
// Serial.print(address, HEX);
// for (int kk=0;kk<=7; kk++)
// {
// Serial.print(" ");
// Serial.print(ReceivedString[kk], HEX);
//
// }
// Serial.println();
break;
default:
rxpos = 0;
break;
}
} //fine gestione acquisizione
} //fine gestione seriale
// --------------------------------------------------
//gestione CAN BUS
if(!digitalRead(CAN0_INT)) // If CAN0_INT pin is low, read receive buffer
{
CAN0.readMsgBuf(&rxId, &len, buf); // Read data: len = data length, buf = data byte(s)
canId = (unsigned char) rxId;
// canId = CAN0.getCanId(); // indirizzo risposta
// Serial.println("-----------------------------");
// Serial.print("Get data from ID: ");
Serial.print("@");
Serial.print(canId, HEX);
for(int i = 0; i<len; i++) // print the data
{
if (buf[i]<=15) { Serial.print('0');}
Serial.print(buf[i], HEX);
}
Serial.println();
}
}
void establishContact() {
while (Serial.available() <= 0) {
Serial.print('A'); // send a capital A
delay(300);
}
}
int hex2int (char c)
{
if (c >= '0' && c <= '9')
{
return (int) (c-'0');
}
else
{
return (int) ((c - 'A')+10);
}
}
CANINO library
Adesso siamo pronti per iniziare!
Test del codice (Trasmissione)
Una tipica connessione CAN-Bus nel campo dell’automazione industriale è quella mostrata in figura, dove c’è un master e vari multi slave. Nel master/slave ogni dispositivo o processo (chiamato master) controlla uno o più dispositivi o processi (chiamati slaves). Una volta che la connessione master/slave si è stabilita, la direzione del controllo è sempre dal master allo slave(s).
Per il test del codice è necessario creare una micro-rete CAN-BUS, ad esempio utilizzando due interfacce CAN-BUS Arduino. Per l’esempio qui riportato abbiamo utilizzato una interfacca CAN-BUS Arduino connessa a una interfaccia commerciale.
NB. L’interfaccia è configurata per una velocità di comunicazione CAN di 500kbps. Cambiate questo valore nel codice per una velocità diversa. Gli indirizzi sono configurati ad 11bit.
Aprite il terminale seriale dall’editor Arduino e configuratela per una velocità di 115200 baud, nessun controllo di flusso.
Digitate la seguente stringa: @00A0102030405060708 e premete invio.
La stringa è composta di tre parti:
@ (Attention) avverte l’interfaccia che una nuova stringa sta arrivando e che deve riallinearsi per un nuovo invio
00A indirizzo di destinazione
01 02 03 04 05 06 07 08 sono gli 8 byte da inviare in formato esadecimale. Ricordiamo che un byte esadecimale è compreso tra 00 e FF.
Se tutte le operazioni sono state effettuate correttamente, l’altra interfaccia riceverà all’indirizzo 0A i byte come nella sequenza mostrata.
Test del codice (Ricezione)
Per il test del codice in ricezione, si effettua l’operazione inversa.
In ricezione avremo una stringa ASCII formattata in modo analogo alla trasmissione, come di seguito riportato:
Esempio (Canino+LabView)
Un video YouTube dove CAN-ISO dialoga con una centralina industriale con CAN BUS, utilizzando il codice “CANINO” e interfaccia grafica “LabView”:
Conclusioni
Adesso che il codice è testato e siamo in grado di trasmettere/ricevere un pacchetto generico, opportunamente formattato, il prossimo step è utilizzare l’interfaccia con un programma. Nei prossimi tutorial vedremo come utilizzare l’interfaccia con Python, LabVIEW, MATLAB, bash shell ed altri.
Contattateci per farci conoscere le vostre opinioni, o proporci una vostra idea/progetto. Per scriverci: info(at)rubinolab dot com