• Augmented Life…

Telescopio dobsoniano 16″ JB
by admin

Dopo averci pensato e ripensato, dopo un bel po’ di rimuginamenti e occhiate tristi al portafoglio (e occhiate ancor più tristi dal portafoglio a me) ho fatto il grande passo! mi son comprato un bel Jach Blak 16″ UC !! Per i non addetti trattasi di un telescopio dobsoniano da 16″ (40cm) costruito da Jach Blak, al secolo Massimo Zancan link abile astrocostruttore vicentino

La strumentazione che lo accompagna è la seguente.

  • Oculari Pentax XW 5 – 10 – 20 mm, Nagler 3.5mm, Antares MER30
  • Torretta binoculare Baader Maxbright
  • Push To sky commander XP4
  • SkySafari 3 su iPad
  • Telrad, Red Dot, Cercatore 60mm, laser
  • Collimatori Catseye e Howie Glatter
Photo

febbraio 4th

15:42
astronomia

Un PushTo economico con Arduino e ASCOM
by admin

Gironzolando per la rete mi sono imbattuto in questo sito dove si descrive la costruzione di un sistema push to basato su arduino… i componenti necessari sono:

– scheda arduino
– encoders
– pc windows con cartes du ciel e piattaforma ascom 6
– drivers ascom appositi

avendo già i primi tre mi sono dovuto scaricare e installare i drivers ascom scritti da David Ek presenti in questa pagina (c’è anche una guida passo passo alla configurazione di cartes du ciel che può tornare utile più avanti)

Il passo successivo è stato quello di realizzare il collegamento tra arduino e i due encoders, cosa molto semplice come si capisce dal disegno

Poi sono passato al caricamento del codice sulla scheda, sul sito mfastro c’è già il sorgente pronto purtroppo il codice è un po’ datato quindi ho dovuto fare una piccola modifica per renderlo compatibile con la versione attuale di arduino

/*
Arduino based Digital Setting Circle

Michael Fulbright 2010-06-06

Feel free to modify and share - please let me know if you make any changes so I can keep my version up to date

2010-06-06: Initial relase - supports 2X encoding

*/

// constants won't change. They're used here to
// set pin numbers:

const int AZ_enc_A = 6; // digital pin 6 = PD6
const int AZ_enc_B = 7; // digital pin 7 = PD7

const int ALT_enc_A = 9; // digital pin 9 = PB1
const int ALT_enc_B = 10; // digital pin 10 = PB2

const int RES = 4000; // resolution of encoders

byte beenAligned = 0;

long ALT_pos = RES/2; // initial position of encoders is
long AZ_pos = RES/2; // half their resolution

void setup() {

// initialize the encoder inputs
pinMode(ALT_enc_A, INPUT);
pinMode(ALT_enc_B, INPUT);
pinMode(AZ_enc_A, INPUT);
pinMode(AZ_enc_B, INPUT);

Serial.begin(9600);

// Pin change interrupt control register - enables interrupt vectors
// Bit 2 = enable PC vector 2 (PCINT23..16)
// Bit 1 = enable PC vector 1 (PCINT14..8)
// Bit 0 = enable PC vector 0 (PCINT7..0)
PCICR |= (1 << PCIE2); PCICR |= (1 << PCIE0); // Pin change mask registers decide which pins are enabled as triggers PCMSK2 |= (1 << PCINT23); // arduino pin 7 = PD7 = az encoder A PCMSK0 |= (1 << PCINT1); // arduino pin 9 = PB1 = alt encoder A // enable interrupts interrupts(); } void loop(){ // see if command sent and reply if appropriate // byte inchar; while (!Serial.available()) { delay(50); } inchar = Serial.read(); // throw away rest of command - we don't need it Serial.flush(); if (inchar == 'Q') { printEncoderValue(AZ_pos); Serial.print("\t"); printEncoderValue(ALT_pos); Serial.print("\r"); } else if (inchar == 'R' || inchar == 'Z' || inchar == 'I' || inchar == 'z') { // ignore command - just return proper code if (inchar == 'R' || inchar == 'I') Serial.print("R"); else if (inchar == 'Z') Serial.print("*"); else if (inchar == 'z') Serial.print("r"); } else if (inchar == 'r') { // print out resolution - hardcoded to 4000 tics/rev Serial.print("04000\t04000\r"); } else if (inchar == 'V') { //version Serial.print("V1.0.0\r"); } else if (inchar == 'T') { // test mode - output resolutions and error count Serial.print("04000,04000,00000\r"); } else if (inchar == 'q') { // error count Serial.print("00000\r"); } else if (inchar == 'P') { // encoder power up Serial.print("P"); } else if (inchar == 'p') { // // dave eks error command Serial.print("00"); } else if (inchar == 'h') { // report resolution in Dave Eks format Serial.write(0xA0); Serial.write(0x0F); Serial.write(0xA0); Serial.write(0x0F); } else if (inchar == 'y') { // report encoders in Dave Eks format printHexEncoderValue(ALT_pos); printHexEncoderValue(AZ_pos); } else if (inchar == 'a') { if (beenAligned) Serial.print("Y"); else Serial.print("N"); } else if (inchar == 'A') { beenAligned = 1; } #ifdef DEBUG Serial.print(digitalRead(AZ_enc_A)); Serial.print(" "); Serial.print(digitalRead(AZ_enc_B)); Serial.print(" "); Serial.print(digitalRead(ALT_enc_A)); Serial.print(" "); wi Serial.print(digitalRead(ALT_enc_B)); Serial.print("\r"); //return; Serial.print(AZ_pos); Serial.print(" "); Serial.print(ALT_pos); Serial.print("\r"); delay(500); #endif } // print encoder value with leading zeros void printEncoderValue(long val) { unsigned long aval; if (val < 0) Serial.print("-"); else Serial.print("+"); aval = abs(val); if (aval < 10) Serial.print("0000"); else if (aval < 100) Serial.print("000"); else if (aval < 1000) Serial.print("00"); else if (aval < 10000) Serial.print("0"); Serial.print(aval); } void printHexEncoderValue(long val) { byte low, high; high = val / 256; low = val - high*256; Serial.write(low); Serial.write(high); return; } // we have to write our own interrupt vector handler.. ISR(PCINT2_vect){ if (digitalRead(AZ_enc_A) == digitalRead(AZ_enc_B)) { AZ_pos++; if (AZ_pos >= RES)
AZ_pos = 0;
}
else
{
AZ_pos--;

if (AZ_pos < 0) AZ_pos = RES - 1; } } ISR(PCINT0_vect){ if (digitalRead(ALT_enc_A) == digitalRead(ALT_enc_B)) { ALT_pos++; if (ALT_pos >= RES)
ALT_pos = 0;
}
else
{
ALT_pos--;

if (ALT_pos < 0) ALT_pos = RES - 1; } }

una volta caricato il codice si può verificare il suo funzionamento aprendo il serial monitor, muovendo a mano gli encoders e premendo il tasto Q si dovrebbe vedere variare i valori sullo schermo
Appurato che tutto funziona si tratta di configurare cartes du ciel (ma dovrebbe funzionare con qualsiasi software ascom-compatibile) quindi:

  1. 1) si va su "telescopio" -> "impostazione" e si seleziona ASCOM
  2. 2) "telescopio" -> "pannello di controllo" -> "configura" e si apre la finestra di configurazione dei drivers
  3. 3) in "Interface type" si seleziona "Dave Ek's DSC" e si compilano gli altri campi come Mount, Ticks/Rev, Serial Port e site info con i relativi valori

    alcuni sono obbligatori e alcuni sono opzionali, quelli obbligatori sono:
    - Mount, nella sezione "telescope info"
    - tutta la sezione "encoder info"

    la sezione "site info" è opzionale ma consigliata

    Il valore della porta seriale (COM) dovrebbe aggiornarsi da solo, se non lo fa è sufficiente andare (dopo aver collegato arduino) nel pannello di controllo -> sistema -> hardware -> Gestione periferiche -> porte (COM e LPT) e vedere a quale è associata la scheda arduino, solitamente è una COM maggiore di 3

  4. 4) a questo punto si connette il telescopio clikkando su "connetti"
  5. 5) ora si deve fare l'allineamento a due stelle clikkando su sync e seguendo la guida che si apre
  6. 6) fatto tutto quanto sopra si è pronti a cercare gli oggetti, click destro sull'oggetto desiderato -> "telescopio" -> "muovi alla posizione del cursore"
  7. 7) si aprirà adesso una finestra con due valori az e alt, dovremo muovere il telescopio a mano fino ad azzerare i due numeri... fatto questo saremo sopra l'oggetto ricercato...

La procedura l'ho verificata personalmente e funziona, o quanto meno funziona indoor dato che non l'ho ancora provata sul cielo... 😛

Photo

febbraio 1st

12:08
arduino

astronomia

Quale oculare per vedere giove grande quanto una mucca?
by admin

Prendo spunto da una discussione in altra sede per rispondere alla classica domanda del neofita che si chiede quale oculare usare per vedere un certo oggetto celeste, solitamente un pianeta, grande quanto un altro oggetto di riferimento, solitamente la luna piena oppure una moneta.

Il problema è molto semplice e richiede due dati fondamentali, il diametro angolare del pianeta e il diametro angolare dell’oggetto di riferimento

Utilizziamo come esempio giove e come oggetto la classica moneta da due euro (la sopra citata mucca crea qualche difficoltà, quindi meglio all’inizio usare un oggetto semplice), con un programma apposito (ad esempio winjupos o cartes du ciel) sappiamo che giove in questo periodo sottende un diametro angolare di circa 44″ mentre una moneta da due euro ha un diametro di circa 26mm… come possiamo adesso mettere in relazione queste due misure?
Qui ci serve un pizzico di trigonometria che ci dice diametro angolare = arctan(diametro oggetto / distanza oggetto) dove arctan è l’arcotangente…

Prendiamo quindi la nostra moneta e poniamola per comodità ad 1 metro di distanza (1000mm), la relazione sopra scritta diventa

diametro angolare = arctan(26/1000) = 1,489° e siccome 1° = 60′ = 3600″ abbiamo che 1,489° = 5360,4″

quindi una moneta da due euro ad un metro di distanza ha un diametro angolare di circa 5360,4 secondi d’arco
Ora dividiamo questa misura per quella di giove ed otteniamo di quanto vogliamo ingrandire il pianeta per vederlo grande quanto la moneta

5360,4 / 44 = 121,83

Questi sono gli ingrandimenti che ci servono! Da qui è sufficiente dividere la focale del telescopio per questo valore per ottenere la focale del oculare desiderata, ad esempio con un 130/900 dovremo utilizzare un oculare da 900/121,83= 7,4mm

Photo

novembre 27th

8:40
astronomia

[ARDUINO] Muovere uno stepper e regolarne la velocità
by admin

Con questo sketch possiamo cambiare il verso di rotazione di uno stepper e controllarne la velocità, lo sketch sfrutta la libreria stepper.h e utilizza il motor shield rev. 3 di arduino
Componenti:

  • 1 Arduino UNO
  • 1 Motor Shield Arduino Rev. 3
  • 1 Stepper bipolare 4 fili
  • 1 potenziometro
  • 2 pulsanti
  • 2 resistenze da 220

Utilizziamo i due pulsanti per la direzione di rotazione ed il potenziometro per regolare la velocità, questa non sarà altro che il ritardo tra uno step e l’altro…

Clicca sull’immagine per vedere lo schema a dimensione reale… purtroppo con Fritzing non trovo l’immagine del motor shield quindi c’è il solo arduino

Questo il codice:

#include <Stepper.h>

const int pwmA = 3;
const int pwmB = 11;
const int brakeA = 9;
const int brakeB = 8;
const int dirA = 12;
const int dirB = 13;
const int buttonA = 2;
const int buttonB = 4;
const int potPin = 0; // Pin analogico del potenziometro

const int STEPS = 100; //numero di passi per rivoluzione -> 360/gradi

// inizializziamo la classe myStepper
Stepper myStepper(STEPS, dirA, dirB);

void setup() {
  pinMode(pwmA, OUTPUT);
  digitalWrite(pwmA, HIGH);
  pinMode(pwmB, OUTPUT);
  digitalWrite(pwmB, HIGH);
  
  pinMode(brakeA, OUTPUT);
  digitalWrite(brakeA, LOW);
  pinMode(brakeB, OUTPUT);
  digitalWrite(brakeB, LOW);

  pinMode(buttonA, INPUT);
  pinMode(buttonB, INPUT);
  pinMode(potPin, INPUT);

  Serial.begin(9600); // se vogliamo mostrare a terminale la velocità
}

void loop() {
  int passi = 1;
  int val = analogRead(potPin);
  int delayTime = map(val,0,2048,0,100);
  Serial.println(delayTime);
  
  if(digitalRead(buttonA) == HIGH){
    orario(passi, delayTime);
  }
  
  if(digitalRead(buttonB) == HIGH){
    antiorario(passi, delayTime);
  }
}

void orario(int passi, int delayTime){
  myStepper.step(passi);
  delay(delayTime);
}

void antiorario(int passi, int delayTime){
  myStepper.step(-passi);
  delay(delayTime);
}

UPDATE: aggiungo un VIDEO con un esempio dell’utilizzo del progetto sopra riportato, tramite uno stepper e una cinghia controlliamo il focheggiatore di un telescopio…

Photo

novembre 4th

10:42
arduino

[ARDUINO] pilotare un led tramite una fotoresistenza
by admin

Con il seguente sketch (semplice modifica dello sketch di Mauro Alfieri) pilotiamo l’accensione di un led leggendo il valore restituito da una fotoresistenza, se inferiore ad un valore prefissato il led si accende, se superiore rimane spento…
codice

/*
 * Autore: Mauro Alfieri
 * Web: mauroalfieri.it
 * Tw:  @mauroalfieri
 *
 * modifica accensione LED
 * by eacocon
 */
 
int analogInPin = A0; // pin al quale è collegata la fotoresistenza
int sensorValue = 0;
int ledPin = 12; // pin al quale è collegato il led
int limitValue = 300; // valore per l'accensione del led
 
void setup() {
  Serial.begin(9600);
  pinMode( analogInPin, INPUT);
  pinMode(ledPin, OUTPUT);
}
 
void loop() {
  sensorValue = analogRead(analogInPin);           
  Serial.print("sensor = " );
  Serial.println(sensorValue);     
  if(sensorValue < limitValue){
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
  delay(500);
}

Photo

luglio 4th

15:46
arduino