Jumping Jack Flash weblog

AMD Athlon II X2 240 si surriscalda

Posted in hardware by jumpjack on 4 settembre 2014

Ho un vecchio PC dotato di processore AMD Athlon II X2 240; da qualche mese va soggetto a surriscaldamento, per cui devo tenere il cabinet aperto e un ventilatore da tavola acceso per evitare che, superata una certa soglia critica che credo sia 70 °C, il PC si spenga (a volte mi scordo il ventilatore e si spegne tutto senza preavviso!)

Mi è stato detto che potrebbe essere sporco il dissipatore, così ho provato a dargli un’occhiata…

DSC01059

 

 

DSC01061

DSC01062

Un vero schifo, non c’è che dire. Il fatto che il PC sia da 3 anni in un soggiorno con angolo cottura ha prodotto questo schifoso strato di polvere e grasso che, chiaramente, ostacola il flusso d’aria e impedisce il raffreddamento.

Quindi adesso devo vedere se riesco a smontare la ventola dal dissipatore senza far danni.

E poi devo trovare un modo per pulire questo disastro, chissà se va bene la pompa per il materassino usando un ugello piccolo..

 

Aggiornamento:

Ho smontato l’alimentatore, passo necessario per riuscire ad arrivare comodamente alla ventolina. Incidentalmente, do un’occhiata alla ventola dell’alimentatore…

DSC01063

Vabbè, approfitto è do una pulita pure a questo: potendolo rimuovere dal cabinet, posso anche dargli una soffiata, ma prima tolgo il grosso con un pennello pulito.

Passiamo poi a smontare la ventola della CPU:

DSC01064 DSC01065

Quattro anni di permanenza in un soggiorno con angolo cottura lasciano il segno!

E veniamo al dissipatore:

DSC01066

Una cosa davvero indegna! Non è difficile capire perchè il processore si surriscaldasse!!

La mappazza di polvere+grasso è così compatta che, piuttosto che col pennello, posso rimuoverla con un cacciavite, anche perchè penso che col pennello finirei per infilarla ben bene nelle alette o per spargerla per tutto il cabinet!

DSC01067

I residui rimanenti li rimuovo invece col pennello:

DSC01070

Il risultato finale è ottimo:

 

 

DSC01065

Prima

DSC01072

Dopo

 DSC01066 DSC01071

Anche termicamente il risultato è ottimo: adesso la CPU non supera nemmeno i 45 gradi, anche col ventilatore spento (prima stava stabilmente a 60 col ventilatore acceso e il cabinet aperto).

Non ho rimosso il dissipatore dalla CPU perchè è un procedimento molto delicato e si rischia di danneggiare la CPU stessa, ma per fortuna gli ottimi risultati raggiunti rendono del tutto superflua una pulitura più approfondita.

Si ringraziano gli utenti di HWUpgrade per avermi fatto risparmiare 400 euro per comprare un PC nuovo! 🙂

 

Le avventure di Mennekes – episodio 7: la spina piccola

Posted in auto elettriche, batterie, elettricita, hardware, scooter elettrici by jumpjack on 16 giugno 2014

 

 

Ed eccoci a un nuovo episodio: ci eravamo lasciati col proposito di cercare una spina più piccola, perchè la SME che ho trovato va bene per le misure standard della presa Mennekes, ma non per le colonnine ENEL, protette da shutter:

mennekes-SME

 
(more…)

Batterie al litio in vendita in Europa

Posted in batterie, hardware, scooter elettrici by jumpjack on 24 novembre 2013

Ho finalmente trovato diversi siti europei che vendono celle al litio LiFePO4: in Polonia (.PL), Repubblica Ceca (.CZ), Germania (.DE),…

Per il momento mi sto soffermando su www.lipopower.de , perchè oltre alle batterie sembra avere un sacco di altra roba interessante: connettori intercelle,supporti per celle Headway e per celle A123, ma soprattutto questo interessante BMS da 16-24 celle: potrei usarlo infatti per fare esperimenti sia per una batteria provvisoria da 20 celle / 60Vper lo Zem Star 45, nel tentativo di farlo resistere fino a Maggio 2014, quando scadrà l’assicurazione, sia per l’Oxygen Lepton, che va a 48V e quindi richiede una batteria da 16 celle.

Penso che opterò per una prima batteriola di prova da 10-15 Ah, visto che per lo Zem non mi serve di più, e che è sufficiente per fare esperimenti con il Lepton, che assorbe 60-100A, mentre le celle sono da 10C, quindi 100-150A (anche se immagino che a 10C non durino molti cicli).

Esistono molti tagli di celle Headway:

  1. LiNANO ® 6 Ah 3.2V 20C Headway 38105SP (SL-FHW-38105P) – 21,20€, 65,1 Wh/kg, 19,20Wh, 143,5 Wh/L
  2. LiNANO® 8 Ah 3,2V 25C Headway 38120HP (SL-FHW-38120HP) – 21,85€, 76 Wh/kg, 25.6 Wh, 167 Wh/L
  3. LiNANO ® 8 Ah 3.2V 20C Headway 38120SP (SL-FHW-38120Pfuori produzione) – 18,50€, 76 Wh/kg, 25.6Wh, 167 Wh/L
  4. LiNANO® 9 Ah 3,2V 10C Headway 38120SE (SL-FHW-38120SE) – 16,50€, 86 Wh/kg, 28,8 Wh, 212 Wh/L
  5. LiNANO® 10 Ah 3,2V 10C Headway 38120SE (SL-FHW-38120SE) – 19,90€, 95,52 Wh/kg, 32 Wh, 209 Wh/L
  6. LiNANO® 11 Ah 3,2V 10C Headway 40120SE (SL-FHW-40120SE) – 23,75€, 97 Wh/kg, 38,4 Wh, 255 Wh/L
  7. LiNANO ® 12Ah 3.2V 10C Headway 38140SE (SL-FHW-38140SE) – 23,95€, 97 Wh/kg, 38,4 Wh, 220 Wh/L
  8. LiNANO ® 15 Ah 3.2V 10C Headway 40152SE (SL-FHW-40152SE) – 29,95€, 100 Wh/kg, 48 Wh

Sono disponibili anche in kit da 4 celle / 12V:

  1. LiNANO ® 8 Ah 12V HP25C (kit 4x) – 107,50€, 1,44 kg, 104 Wh
  2. LiNANO ® 8 Ah 12V SP20C (kit 4x) – 99,95€, 1,44 kg, 104 Wh
  3. LiNANO ® 9 Ah 12V 10C (kit 4x) – 79,95€, 1,44 kg, 115,2Wh
  4. LiNANO ® 12 Ah 12V 10C (kit 4x 38140SE) – 109,95€, 153,6 Wh,
  5. LiNANO® 14 Ah 12V 10C (kit 4x 38140SE ) – 109,95€ (errore?)
  6. LiNANO® 15 Ah 12V 10C (kit 4x 40152SE) – 133,75€

Invece, volendosi costruire la batteria da soli da zero:

  1. Supporto  per 20 celle da 38mm (SL-FHW-38120P, SL-FHW-38120S, SL-FHW-38140SE) – 7,50€ l’uno, ne servono 2
  2. Supporto da 38 mm per 3 celle – 0,85 euro l’uno, ne servono 2 ogni 3 celle, quindi 12 per 16 celle (13,6 €) e 14 per 20 celle (11,9 €)
  3. Supporto da 40 mm per 3 celle – 0,85 euro l’uno, ne servono 2 ogni 3 celle, quindi 12 per 16 celle (13,6 €) e 14 per 20 celle (11,9 €)
  1. Connettore in ferro per celle 38mm – 0,55€ – ne servono 34 per 16 celle (18,7€) e 42 per 20 celle (23,10€)
  2. Connettore in ferro per celle 40 mm –  0,55€ – ne servono 34 per 16 celle (18,7€) e 42 per 20 celle (23,10€)
  3. Connettore in rame per celle 38 mm – 0,90€ – ne servono 34 per 16 celle (30,6€) e 42 per 20 celle (37,80€)

BMS:

  1. BMS 16-24 celle con bilanciatore incorporato – 109,95€
  2. bilanciatore esterno per cella singola, corrente di bilanciamento  da 1400 mA – 4,75 euro – ne servirebbero 16 (76€) o 20 (95€); il vantaggio è che se ne brucio uno, non devo spendere altri 100 euro ma solo 5. Dovrei comprarne almeno 22, quindi diciamo 104,5€.

Varie:

  1. Connettore a 9 fili per bilanciatore – 2,75€ – ne servono 2 per 16 celle (5,50€) e 3 per 20 celle (8,25€)
  2. Guaina termorestringente – 12,05€/metro – non indispensabile, ma in genere si usa per ricoprire le batterie; ne potrebbero servire 2 metri – 24,10€
  3. Cavo rosso da 8 mm^2 – 5,95€/metro, ne basta 1 – 5,95€ (ottimo cavo con guaina in silicone morbido ultraflessibile e interno in fili di rame finissimi intrecciati)
  4. Cavo nero da 8 mm^2 – 5,95€  (ottimo cavo con guaina in silicone morbido ultraflessibile e interno in fili di rame finissimi intrecciati)
  5. Connettore Anderson da 50A – 6,95€ – ne esistono 3 tipi: rosso, blu e grigio, incompatibli tra loro; il mio Zem li monta grigi – ne prendo 4 –  27,8€

I prezzi complessivi risultanti (senza connettori Anderson):

  1. 48V/15Ah: 504,00 €, 7 kg
  2. 48V/40Ah: 1.486,00 €, 19 kg
  3. 60V/15Ah: 630,00 €, 9kg
  4. 60V/40Ah: 1.831,00 €, 24 kg

Spedizione: 35,00 euro

Ecco “Displog”, il DISPlay che LOGga!

Posted in arduino, hardware by jumpjack on 8 aprile 2013

Una volta domato il bastardo Ardulog, crearci nuove applicazioni è solo questione di fantasia!

Ecco quindi nascere DISPLOG, il primo display con logger incorporato, o logger con display incorporato, fate vobis:

DISPLOG - DISPLAY + LOGGER on SD card

DISPLOG – DISPLAY + LOGGER on SD card

La faccenda è molto semplice: il display grafico/alfanumerico 3110/5110 (aka Philips PCD8544) può essere pilotato tramite 5 soli pin (addirittura 4 in casi particolari), e su Ardulog ci sono 4 pin analogici disponibili (A1, A3, A4 e A5), più RX e TX (D0 e D1); quindi si tratta solo di giocherellare un po’ con le impostazioni di un banale sorgente di esempio sul playground, fare 5 saldature, ed ecco ottenuto un display che supporta le micro SD card!

Tutto quello che cè da fare è modificare le prime linee di codice in questo modo:

#define PIN_SCE   0
#define PIN_RESET 1
#define PIN_DC    A3
#define PIN_SDIN  A4
#define PIN_SCLK  A5

Manca un PIN libero per accendere la retroilluminazione, ma Hobbytronics ha previdentemente predisposto due piazzole libere vicino ai due LED, quindi si può facilmente utilizzare il pin 5 o 13 per comandare la retroilluminazione.

Il pin analogico A1 rimane disponibile per collegare un qualunque sensore analogico.

PowerDuino Standalone, ecco i sorgenti

Posted in hardware, Programmazione by jumpjack on 7 aprile 2013

AGGIORNAMENTO 29 marzo 2014 – Arduino Day 2014

Presentato in fiera progetto dimostrativo basato su sensori di luce.

power1

 

Il progetto dimostrativo utilizza due fotoresistenze e un sensore con accelerometro e bussola.

Le fotoresistenze mostrano come si possa programmare Arduino per rilevare la luce o il buio e per controllare apparecchi a 330V (lampadine);

PowerDuino è una dimostrazione di utilizzo del rilevamento di luce : ad ogni lampeggio del led di un contatore di energia, arduino incrementa un contatore, riuscendo così a calcolare la potenza istantanea e l’energia consumata.

Il sensore con bussola+accelerometro serve a illustrare la facilità con cui è possibile interfacciare sensori ad Arduino: bastano due fili per i sensori dotati di protocollo I2C; altri due fili servono per la massa e l’alimentazione. Opportune librerie permettono di pilotare i sensori con facilità.

Il sensore in uso nel progetto dimostrativo è un LSM303D, utilizzato con questa libreria.

 

Sketch dimostrativo:

 

#include <Wire.h>
#include <LSM303.h>
LSM303 compass;
char report[80];
int ControlPin=13;
int RelayOne=7;
int RelayTwo=8;
int SensorOne=A1; // Light sensor one (SHORT RESISTOR - DARKNESS)
int SensorTwo=A2; // Light sensor two (LONG RESISTOR - LIGHT)
int GND_One=11; // For light sensor one (SHORT RESISTOR - DARKNESS)
int GND_Two=12; // for light sensor two (LONG RESISTOR - LIGHT)
int GND_Three=6; // For I2c Sensor
int DARKNESS_THRESHOLD = 200; // if above, it's dark, turn on the light
int LIGHT_THRESHOLD = 450; // if below, light is detected, turn on the lamp!
void setup()
{
 Serial.begin(9600);
 Serial.println("Init wire...");
 delay(1000);
 Wire.begin();
 delay(1000);
 Serial.println("Init compass...");
 compass.init();
 delay(1000);
 Serial.println("Enable compass...");
 compass.enableDefault();
 delay(1000);
 Serial.println("Init vars...");
 pinMode(ControlPin,OUTPUT); //Led
 pinMode(RelayOne,OUTPUT); //Xboard relay 2
 pinMode(RelayTwo,OUTPUT); //Xboard relay 2
 pinMode(GND_One,OUTPUT);
 digitalWrite(GND_One,LOW);
 pinMode(GND_Two,OUTPUT);
 digitalWrite(GND_Two,LOW);
 pinMode(GND_Three,OUTPUT);
 digitalWrite(GND_Three,LOW);
 pinMode(SensorOne,INPUT);
 pinMode(SensorTwo,INPUT);
 digitalWrite(ControlPin,HIGH);
 digitalWrite(SensorOne,HIGH);
 digitalWrite(SensorTwo,LOW);
 delay(1000);
 digitalWrite(ControlPin,LOW);
 Serial.println("Program started!");
}
void loop()
{
 compass.read();
snprintf(report, sizeof(report), "A: %6d %6d %6d M: %6d %6d %6d",
 compass.a.x, compass.a.y, compass.a.z,
 compass.m.x, compass.m.y, compass.m.z);
 Serial.print("ResistenzE; ");
 Serial.print(analogRead(SensorOne));
 Serial.print(",");
 Serial.print(analogRead(SensorTwo));
 Serial.print(",");
 Serial.println(report);
 
 
// GRAVITY //////////////// 
if (compass.a.z<0) {
 digitalWrite(RelayOne,HIGH);
}
if (compass.a.z>0) {
 digitalWrite(RelayOne,LOW);
}
// COMPASS ////////////////
if (compass.m.x<0) {
 digitalWrite(RelayTwo,HIGH);
}
if (compass.m.x>0) {
 digitalWrite(RelayTwo,LOW);
}

// DARKNESS /////////////////
if (analogRead(SensorOne)>DARKNESS_THRESHOLD) {
 digitalWrite(RelayOne,HIGH);
}
if (analogRead(SensorOne)<=DARKNESS_THRESHOLD) {
 digitalWrite(RelayOne,LOW);
}
// LIGHT ///////////////////
if (analogRead(SensorTwo)<LIGHT_THRESHOLD) {
 digitalWrite(RelayTwo,HIGH);
}
if (analogRead(SensorTwo)>=LIGHT_THRESHOLD) {
 digitalWrite(RelayTwo,LOW);
}
 delay(100);
}

power2

power3

 

Powerduino può essere usato per disegnare la curva di carico di lavatrice e lavastoviglie, scoprire quando e per quanto tempo assorbono 2000W, e quindi scoprire di quanto va sfalsata l’acdensione dei due elettrodomestici in modo che possano lavorare insieme senza far saltare il contatore.
image

image

============================

Dopo la presentazione all’Arduino Day 2013, ecco i sorgenti del PowerDuino Standalone:

DOWNLOAD PowerDuino 0.3.2

E’ sufficiente caricarlo(*)  su un normale Ardulog (meglio evitare l’Openlog, a meno di essere in grado di effettuare microsaldature a mano…), e immediatamente l’Ardulog si trasformerà da logger seriale a logger standalone, ossia in grado di registrare autonomamente dati dal pin analogico A1, senza bisogno di una Arduino esterna di supporto.

Al momento il listato è ancora un po’ primitivo, non è assolutamente ottimizzato, al contrario di quello originale Openlog 3.0  superottimizzato a basso livello in modo da ridurre al minimo i consumi del processore (quello distribuito con Ardulog è invece molto più rudimentale).

In futuro avrei in mente di realizzare un listato generico che, anzichè registrare specificamente la potenza misurata da un energy monitor esterno, semplicemente registri i dati grezzi letti dai 4 pin analogici e due digitali presenti su Ardulog: in questo modo, Hobbytronics, autore dell’Ardulog,  potrebbe vendere il prodotto in versione “standalone” oltre che “serial”, e tale versione sarebbe adatta per qualunque applicazione: basterebbe demandare al file excel in cui si copiano i dati il compito di elaborarli in modo opportuno. Il file conterrebbe infatti semplicemente una riga per ogni lettura, effettuata ogni TOT millisecondi, e in ogni riga ci sarebbero i valori dei pin.

Bisogna però decidere in che modo impostare l’intervallo dall’esterno senza dover riprogrammare l’Ardulog; potrei ad esempio usare i due pin digitali per impostare 4 livelli diversi di precisione (2 bit= 4 valori), oppure i due digitali più A1, che sta fisicamente separato dagli altri, in modo da poter impostare 8 valori (2^3=8), semplicemente a seconda di quali pin sono a massa e quali a +Vcc.

Spero di riuscire a farmi un’idea più chiara in tempo per la prossima “uscita pubblica” di PowerDuino, che probabilmente sarà in occasione della “Geek Sunday” in programma a Roma per il prossimo 5 maggio.

 

(*) Per caricare uno “sketch” (=listato=programma) su Ardulog, bisogna collegarlo al PC tramite circuito adattatore FTDI (RS232/TTL), oppure tramite una Arduino Uno priva del microchip, collegando i pin RX-RX, TX-TX, Vcc-3.3V, GND-GND, RST-RESET, e impostando Arduino Uno sull’IDE.

Energy Logger fai-da-te, da quadro o a batteria.

Posted in hardware, Programmazione by jumpjack on 31 marzo 2013

Dopo un anno di prove, ricerche, esperimenti e sbattimenti, ho finalmente il piacere di annunciarvi che il primo logger “professionale” di energia a basso costo è ufficialmente una realtà!

Prevedo di mettere in commercio due versioni:

– autonoma, per interni; autonomia infinita, in quanto preleva la tensione direttamente dalla corrente di casa; è contenuto in un normale modulo DIN (dimensioni: 1+1.5, da montare nel quadro elettrico), al quale bisogna semplicemente collegare 4 fili: due che vengono dal contatore ENEL, due che vanno alle utenze di casa. Dotato di cicalino interno di allarme per sovraccarico.  Contiene una SD card estraibile che memorizza i dati. Al momento registra solo i Wh tramite energy monitor esterno interfacciato otticamente, ma prevedo, in caso di interesse, un aggiornamento per misurazione anche di V e CosFI.
Il costo complessivo risulterebbe di 65 euro + spedizione.

– a batteria, autonomia di circa una settimana con una batteria da 9V, o… infinita con un pannello solare da 1W (il consumo è di max 10 mA, tensione ammessa tra 3,3 e 12V); basta collocarlo vicino al contatore ENEL, incollare il sensore sul LED del contatore, ed è tutto. A registrazione ultimata, si stacca la batteria, si preleva la SD Card e si leggono i dati sul PC, eventualmente facendo grafici con Excel.
Questa versione costerebbe (se risultasse esserci mercato…) 30 euro + spedizione.

Con una SD card da 2 GB potrebbe registrare teoricamente dati per 2000 giorni.

Il vantaggio maggiore su qualunque altro modello in commercio è la programmabilità: chi ha competenze su Arduino potrà espandere/migliorare a piacimento il logger. Ma soprattutto, potrà costruirselo da sè a prezzo di costo scaricandosi schemi e sorgenti che pubblicherò tra una settimana.
Lo svantaggio è il dover “tagliare i fili” dell’impianto per collegarlo, ma è necessario per avere l’accuratezza necessaria; in ogni caso posso facilmente realizzare una più “classica” versione con pinza.

Presenterò i prototipi sabato 6 aprile ad Arduino Day 2013, nel pomeriggio.
Nel frattempo accetto consigli, suggerimenti e richieste.

Controllare display 5110 mediante scheda Pinguino PIC32 MICRO

Posted in hardware by jumpjack on 16 marzo 2013

Nuovo, piccolo passo verso il completamento del logger di energia per scooter e pannelli fotovoltaici: finalmente il listato dimostrativo per Arduino di utilizzo del display 5110 funziona!
Adesso posso aggiungere finalmente al mio logger la visualizzazione in tempo reale dei dati registrati, in modo da poterlo tarare facilmente.

// LCD_5110_test for Pinguino PIC32 MICRO.
// Sample program to drive 5110 LCD display (Philips PCD8544 based).
// Display works at 3,3V, so no need for voltage regulators on Pinguino PIC32 Micro.
// Directly copied from Arduino site: http://playground.arduino.cc/Code/PCD8544
// Added shift_out procedure (copied from Arduino IDE source).
//
// Jumpjack march 2013

#define PIN_SCE 13 // CON2-03
#define PIN_RESET 12 // CON2-04
#define PIN_DC 11 // CON2-05
#define PIN_SDIN 10 // CON2-06
#define PIN_SCLK 9 // CON2-07
#define PIN_LED 8 // CON2-08 (Backlight, optional)

#define LCD_C LOW
#define LCD_D HIGH

#define LCD_X 84
#define LCD_Y 48

#define LSBFIRST 0
#define MSBFIRST 1

static const byte ASCII[][5] =
{
{0x00, 0x00, 0x00, 0x00, 0x00} // 20
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ←
,{0x78, 0x46, 0x41, 0x46, 0x78} // 7f →
};

void LcdCharacter(char character)
{
int index=0;
LcdWrite(LCD_D, 0x00);
for ( index = 0; index < 5; index++)
{
LcdWrite(LCD_D, ASCII[character - 0x20][index]);
}
LcdWrite(LCD_D, 0x00);
}

void LcdClear(void)
{
int index=0;
for ( index = 0; index < LCD_X * LCD_Y / 8; index++)
{
LcdWrite(LCD_D, 0x00);
}
}

void LcdInitialise(void)
{
pinMode(PIN_SCE, OUTPUT);
pinMode(PIN_RESET, OUTPUT);
pinMode(PIN_DC, OUTPUT);
pinMode(PIN_SDIN, OUTPUT);
pinMode(PIN_SCLK, OUTPUT);
pinMode(8,OUTPUT); //backlight
digitalWrite(PIN_RESET, LOW);
digitalWrite(PIN_RESET, HIGH);
LcdWrite(LCD_C, 0x21 ); // LCD Extended Commands.
LcdWrite(LCD_C, 0xB1 ); // Set LCD Vop (Contrast).
LcdWrite(LCD_C, 0x04 ); // Set Temp coefficent. //0x04
LcdWrite(LCD_C, 0x14 ); // LCD bias mode 1:48. //0x13
LcdWrite(LCD_C, 0x0C ); // LCD in normal mode.
LcdWrite(LCD_C, 0x20 );
LcdWrite(LCD_C, 0x0C );
}

void LcdString(char *characters)
{
while (*characters)
{
LcdCharacter(*characters++);
}
}

void LcdWrite(byte dc, byte data)
{
digitalWrite(PIN_DC, dc);
digitalWrite(PIN_SCE, LOW);
shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data);
digitalWrite(PIN_SCE, HIGH);
}

void setup(void)
{
LcdInitialise();
LcdClear();
LcdString("Hello World!");
delay(1000);
digitalWrite(8,LOW);
}

void loop(void)
{
toggle(PIN_LED);
delay(1000);
}

void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val)
{
uint8_t i;

for (i = 0; i < 8; i++) {
if (bitOrder == LSBFIRST)
digitalWrite(dataPin, !!(val & (1 << i)));
else
digitalWrite(dataPin, !!(val & (1 << (7 - i))));

digitalWrite(clockPin, HIGH);
digitalWrite(clockPin, LOW);
}
}

Sempre parlando di logger, ho scoperto che esistono semplici contatori di kWh per la corrente di casa, da installare nel quadro elettrico, che fanno lampeggiare un led ogni tot kWh (come il contatore ufficiale ENEL), e che costano 20 euro invece che 200 come quelli che conoscevo io…
Questo significa che costruire un logger Arduino/Pinguino per la corrente dicasa diventa un po’ più semplice, perchè non serve più un sensore di corrente, ma basta una fotoresistenza, più un partitore 1:100 per la tensione (comunque necessario solo per misure molto precise della potenza e/o per misurare anche il cosFi).
Appena mi danno l’indirizzo lo compro e inizio a fare le prove.

PinguiLogger – registrazione corrente e tensione con board Pinguino

Posted in hardware, Programmazione by jumpjack on 12 febbraio 2013

Sta per vedere la luce il mio PinguiLogger 🙂 , un aggeggino che permette di registrare correnti fino a 70 A e tensioni fino a 60V su scheda SD, per analizzare cosa combina il mio scooter elettrico.

Al momento il listato C è già pronto e funzionante su scheda Arduino, anche se si limita a registrare i dati senza elaborarli, quindi registra solo valori compresi tra 0 e 1023 da due sensori di corrente e da due partitori di tensione 1:21, creando un file .CSV; poi bisogna importare il file in Excel e fare i dovuti calcoli.

I campi registrati nel file sono:

  • tempo (millisecondi)
  • riferimento 1
  • corrente 1
  • tensione 1
  • riferimento 2
  • corrente 2
  • tensione 2

Il “riferimento” è il pin di riferimento dei sensori di corrente, il cui valore dovrebbe servire, se ho ben capito, a indicare a quale valore del pin di output corrisponde una corrente nulla (perchè immagino che il “punto 0″ dipenda dalla tensione effettiva di alimentazione”, ma devo ancora studiare bene la faccenda…

(more…)

Turn your phone into an universal remote control

Posted in hardware, Infrarossi, Sviluppo, Symbian by jumpjack on 10 giugno 2008

This short tutorial shows how to turn almost any cellphone into an universal IR remote control.

CHECK GoogleCode page for downloads and updates

Old post (with detailed instructions about how to build hardware)

How I did it (and credits)

Why it should work also on non-stereo cellphones (but it does not?!?) (see also excel file)

Useful links (explanations of remote control protocols)

Other uses for old phones
Available patents (not mine):
Infrared generator from audio signal source
IR receiver using IR transmitting diode

 

Ready-made transmitter: irDroid

http://www.irdroid.com/purchase/

Requirements:

– a cellphone with stereo audio output (audio left , audio right , ground) or symmetrical audio output (audio+, audio-)

– 2 IR leds

– a wired headset compatible with the phone

– a PC with audio card

– an audio recording software on PC

– an audio editing software for PC or an audio sinthesyzer software for PC

This project does not depend on O.S. used: you just need ANY computer capable of recording audio and create audio files from scratch. Linux, Windows, MacOSX or whatelse makes NO difference.

Please look at this post to know how to:
– build an IR receiver for the PC
– sample a remote control
– (create a WAV file using Audacity program) (not strictly needed: this article describe an alternate method).

Once you sampled all needed buttons of your remote, it’s just a matter of building a proper WAV file for each one of them. If you don’t want to use Audacity to do it manually, you can use SOX program: it creates pieces of “raw” audio file, which joined together build up the final WAV file.

Here you find example scripts (for DOS/Windows environment) which build a WAV file based on binary description of the remote signal. You have to setup the unizeri.bat file to have it matching the sampled signal. Then call create.bat specifying as parameter the “creator file” (unizeri-raw, or unizeri-tv,… ), the final WAV file (testbutton) and the number of additional times you want the command is repeated (at least ONE occurrence will be alway created):

create unizeri-raw testbutton 4

(no extensions required for filenames) (NOTE: script must be run inside SOX folder).

This will result in a tesbutton.wav file which, played on a phone (or on PC, or on any audio capable device), equipped with audio-to-IR converter, to control your device.

The audio-to-IR converter:

It is just a couple of LEDs connected in oppopsite ways to “audio output left” and “audio output right” (for normal phones) or to “audio+” and “ground” (for phones with symetrical audio output like nokia 6680). In symetricl ouptu, Left- and Right- must be connected together (see below).

Audio-to-IR converter:

Connections for nokia 6680:

(10 Ohm resistor not strictly needed)

—————————————————-

Study about physics/optical phoenomena involved in this project:

Excel file – how to play a 38000 Hz “sound” through a 20000Hz-capable audio device

Big image summarizing Excel data

————————-

Forums about Ledrem:

Italian:

Nokioteca

PLC Forum

PC Tuner

HW upgrade

Planetmobile

English:

IP-mart.com

Hackint0sh

What can you do with an old cellphone?

Posted in GPS, hardware, Infrarossi, intuizioni, Symbian by jumpjack on 7 giugno 2008

An old nokia series 60 phone (like nokia 6600 or 6680) costs around 50$. But it has:

– bluetooth support

– infrared support

– fotocamera

– internet access

– SMS support

– USB support

– Python support (pys60)

– java j2me  support

Mix all these things together, and you could obtain:

1) 3d foto/video (*)

2) touchscreen (wiimote-like)

3) remote video surveillance

4) Add an IR led to your recipe, and you obtain an SMS-controlled remote-control. (GoogleCode page)

5) Add a bluetooth GPS receiver and you have a GPS antitheft. (GoogleCode page)

6) Home intrusion detection system.

7) Simple guitar tuner.

…any more ideas?

It’s just a matter of writing proper software!

(*) To make 3d photo of moving subjects, or 3d video, you need two separate but synchronized cameras. Bluetooth conection should allow such a synchronization, in such a way that when you shoot a photo on one phone, at the same time it’s shot on the other phone.