Color Flat Box

Con l’impiego di una camera CCD a colori (OSC) SBIG ST2000XCMI mi sono imbattuto in un problema imprevisto: i flat a colori. Abituato alle camere in bianco e nero non mi ero mai posto il problema delle dominanti cromatiche dei flat, invece con la nuova camera OSC ho notato che la flat box emetteva una luce azzurrognola con conseguente correzione delle immagini poco efficiente.

Il mio amico Luciano Telesca spesso diceva “Se non puoi alzare il ponte, abbassa il fiume!”. In questo caso il problema è che essendo la camera una OSC non posso variare la lunghezza delle pose per i singoli colori (come si fa con le camere monocromatiche e i filtri RGB); quindi, non potendo modificare il comportamento della camera, ho pensato di modificare la sorgente: la flat box.

La teoria

Avevo pensato di utilizzare dei LED RGB in modo da poter regolare l’emissione di ogni componente impiegando i PWM di Arduino, purtroppo però il primo esperimento mi ha (erroneamente) fatto desistere: i LED RGB infatti non sono altri che 3 LED, uno rosso, uno verde e uno blu, inseriti nello spazio di un LED singolo; peccato che quando si accendono tutti e 3 le componenti il risultato non sia un LED del colore risultante ma 3 cerchietti dei colori primari che si intersecano formando un’immagine simile a questa:

La luce di un LED RGB

Deluso dall’inaspettato risultato avevo quasi messo da parte il progetto come fallimentare; fortunatamente una chiacchierata con il mio amico Ivaldo Cervini mi ha fatto continuare: infatti secondo Ivaldo (a ragione) la luce del LED si va poi a mischiare nella flatbox con il risultato che questa cambia colore in modo uniforme.

L’elettronica

Sebbene il pilotaggio del PWM su Arduino sia piuttosto semplice, non è possibile collegare i LED direttamente all’Arduino in quanto l’assorbimento totale risulterebbe troppo elevato, per questo motivo ho impiegato una variante di un circuito con una modifica: utilizzo come NPN dei TIP110.

schema del circuito

Il firmware

Lo sketch da caricare su Arduino (io ho usato un NANO ma vanno benissimo anche l’UNO o il Leonardo) è piuttosto semplice:

/**************************************************************************/
/*!
 Firmware Color Flat Box
 Version: 1.0
 Scope: Variable intensity for color flat box
 Author: Simone Martina
 
 Usage:
 * Connect to the board at 9600bps
 * To set a new color, send three numbers seperated by ","
 * Values must be included by 0 and 255
 * Every values bigger than 255 will be set at 255
 i.e.: 123,99,234
 
 Changelog:
 2017/09/20 - v0.1 First release
 2017/09/21 - v1.0 added serial settings and EEPROM previous values storing

*/
/**************************************************************************/

#include <EEPROM.h>

/**************************************************************************/

// led brightness variables
int vG;
int vB;
int vR;

// led pins definition
const int G=6;
const int B=5;
const int R=3;

void setup() {
 Serial.begin(9600);
 Serial.println("ColorFlatBox 1.0");
 
 // Read previous values from EEPROM
 vR=EEPROM.read(R);
 vG=EEPROM.read(G);
 vB=EEPROM.read(B);
 
 // Print previous values on serial connections
 Serial.print("Previous values: R=");
 Serial.print(vR);
 Serial.print(" G=");
 Serial.print(vG);
 Serial.print(" B=");
 Serial.println(vB);

// LED pins initialization
 pinMode(G,OUTPUT);
 pinMode(B,OUTPUT);
 pinMode(R,OUTPUT);

}

void loop() {
 // if there's any serial available, read it:
 while (Serial.available() > 0) {

// look for the next valid integer in the incoming serial stream:
 int red = Serial.parseInt();
 // do it again:
 int green = Serial.parseInt();
 // do it again:
 int blue = Serial.parseInt();

// look for the newline. That's the end of your sentence:
 if (Serial.read() == '\n') {
 // if common-anode LED, just use "255 - constrain(color, 0, 255);"
 // if common-cathode LED, just use "constrain(color, 0, 255);"
 red = constrain(red, 0, 255);
 green = constrain(green, 0, 255);
 blue = constrain(blue, 0, 255);
 
 // set values for intensity and store it
 vR = red;
 EEPROM.write(R, red);
 vG = green;
 EEPROM.write(G, green);
 vB = blue;
 EEPROM.write(B, blue);

// print RGB intensity values as hexadecimal:
 Serial.print(red);
 Serial.print(",");
 Serial.print(green);
 Serial.print(",");
 Serial.println(blue);
 delay(50);
 }
 }
 // fade the red, green, and blue legs of the LED:
 analogWrite(R, vR);
 analogWrite(B, vG);
 analogWrite(G, vB);
}

Come si usa?

Fin qui tutto semplice ma… come si usa?

Una volta flashato l’Arduino con lo sketch i LED verranno settati, di default, a 128,128,128: collegandosi alla seriale di Arduino (impostando una velocità di 9600 baud con un a capo NL) la Color Flat Box restituirà i valori precedentemente impostati.
Per settare un nuovo colore è sufficiente indicare quanto i 3 LED debbano essere luminosi con tre valori tra 0 e 255) separati da virgole e senza spazi. I.e.: 80,128,130

Impostazione di un nuovo colore

La Color Flat Box restituirà i valori appena impostati e, naturalmente, il colore della flat box cambierà di conseguenza.

La taratura

Inizialmente avevo sperato di poter effettuare una taratura analoga al bilanciamento del bianco tramite stella G2V, ossia: impostare la flat box con 3 valori standard (128,128,128), riprendere uno scatto con la CCD, estrarre i canali BGGR e misurarne i valori. In funzione dei valori, operare una proporzione in modo da equiparare il risultato.

Purtroppo, ho scoperto sul campo che, anche accendendo un solo colore alla volta (i.e.: verde 0,128,0), la camera non riprende valori nulli negli altri due colori (nell’esempio: rosso e blu). Per questo sono partito dal metodo precedente (ossia la proporzione semplice) e poi ho modificato i valori per approssimazione fino ad avere i 3 frame estratti dalla matrice di bayer con un’intensità il più possibile simile. Il risultato è un flat con una sola campana composta dalla sovrapposizione delle 3 campane RGB.

Sperando che questa soluzione possa essere utile ad altri autocostruttori, ricordo che il firmware e tutto il materiale del sito è sottoposto a licenza CC non commerciale.

Quest’opera è distribuita con Licenza Creative Commons Attribuzione – Non commerciale – Condividi allo stesso modo 4.0 Internazionale.

Simone.