Telescopio

[senso]

Não, mas a Rangel(representante da fedex de cá) faz-te o favor de desalfandegar tudo e mais alguma coisa pela módica quantida de 80 ou 90€ mais o valor da alfandega em si, são uns fofos.

E atenção que a caixa não é mesmo 100:1, mais abaixo diz que na realidade é de 99.05:1
O que torna o rácio algo mais engraçado digamos.

[Njay]

Dos EUA por "CTT" é USPS ou "registered air mail".

[StarRider]

Encontrei este site com motores de passo e caixas de redução a preços acessiveis:

http://www.omc-stepperonline.com/gear-1001-planetary-gearbox-for-nema-17-geared-stepper-motor-p-46.html

Mas parece que vai dos estados unidos. Pode vir pela fedex, isso evitará alfandegas e possiveis taxas?

Boas,

Por coincidência, estou para mandar vir uns motores desse fornecedor  ...

Por isso, podemos dividir (em partes proporcionais) os custos do envio, vou mandar vir por TNT e trato eu
mesmo de desalfandegar em Lisboa uma vez que tenho por experiência que a TNT é a transportadora que
tem uns custos mais baixos nesse capitulo, da ultima vez que usar a TNT paguei 18 euros pela "carta de porte"
e tratei eu do resto da burocracia. É claro que existe ainda o custo do transporte a adicionar a estes 18 euros.

Diz qualquer coisa.

Abraços,
PA

[c3dr1c]

Isso era o ideal StarRider. Por mim é na boa. Eu apenas queria dois motores Nema 17 100:1, estamos a falar de cerca de 50€. Ja agora o que achas dos motores e da redução? Achas que têm força suficiente?


Ja agora, afinal vem da China... Talvez tenhamos sorte com a alfandega...

[c3dr1c]

O que acham de um raspberry pi para controlar o telescopio?

Como se trata de um mini computador peço que a comunicação do software de controlo com os motores e a webcam "será mais" em tempo real do que com um arduino. Alem disso permitiria-me ter o stellarium a correr nele (acho eu).

Sei que à partida é mais fiável e tem mais resolução que o arduino...

[senso]

O que é que chamas de mais resolução?
Tens uint64_t no atmega, agora se é a melhor coisa para controlar isso, não faço ideia, mas isso é muito basicamente dois motores de passo que vão receber comandos do género goto via serial.

[c3dr1c]

Tava a pensar e ter três opções de funcionamento.

Um opção mais portátil que apenas com um lcd me indica as coordenadas para onde o telescópio está a apontar (usando apenas encoders).

Outra opção em que com um orbita pre-calculada, sao indicados os pontos para onde o telescopio tem de se deslocar (usando motores, enconders e uma webcam para recolha de imagens).

A terceira opção, ao receber as imagens de um planeta através de uma webcam, reconhecer a sua deslocação e segui-lo (usando motores, enconders e uma webcam para recolha de imagens).

[senso]

Só com encoders o telescópio nunca saberá para onde está virado, precisas de atirar um GPS, magnetómetro(ou um IMU completo) e mais umas coisas para cima dele.

[c3dr1c]

Mas posso apontar o telescopio para um ponto de referencia e atribuir-lhe a posição corrente. Claro que vai apresentar erros, mas mais pa frente penso nessa questão dos sensores...

Edit: Ja li que não é possivel correr o stellarium no raspPi. Se calhar volto po arduino + labview.

[c3dr1c]

Boas.

Tenho andado indeciso e precisava da vossa ajuda em relação ao microcontrolador a utilizar.


Portanto, a ideia na pratica é poder levar o telescopio para uma sitio e através de um LCD poder saber as coordenadas para onde estou apontar. Poderia também programar as coordenadas actuais de uma nebulosa em função do tempo e fazer um sistema GoTo.

Esta seria a primeira etapa do projecto e a mais prática em termos de uso, bem como a que consome menos energia.


Por outro lado e agora virado para a astrofotografia, quero colocar uns motores no telescópio para poder fazer umas longas exposições e/ou monitorizar a órbita de um astro. Como tal preciso também de uma webcam. Em termos práticos tenho duas opções. Ou utilizo uma webcam e guardo as fotos num cartão de memorias através do microcontrolador e depois descarrego-as em casa para não ter de andar com o portátil atrás. Ou ando com o portátil atrás e ligo a webcam directamente ao portátil, tendo a opção de criar e usar programas interactivos de monitorização, contudo nada pratico e com um grande consumo energético.


Para estes cenários tenho duas opções: um atmega ou um raspberry pi.

- O atmega não sei se será fácil de programar para obter imagens da webcam e guarda-las;
- Consome menos energia;
- Posso utilizar o labview com a experiência que tenho e criar programas.

- Quanto ao raspberry pi deve ser fácil de interagir com a webcam e guardar as imagens;
- Consome mais energia
- Também devo poder criar programas em outro tipo de software que não conheço, mas utilizando um LCD touchscreen talvez dispensava o uso do portátil. Não sei qual a complexidade de criar um programa numa linguagem compatível com o raspberry pi, o labview é uma maravilha 


Contudo também tenho de ter em conta que só os motores necessitam de muita energia e se tenho energia é de aproveitar utilizar o portátil.

Tou todo baralhado...

[c3dr1c]

Boas.

Bem já passei à acção   Comprei um Atmega 2560 e um IMU (MPU-9150).

Datasheet:http://www.google.pt/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0CB4QFjAA&url=http%3A%2F%2Fwww.invensense.com%2Fmems%2Fgyro%2Fdocuments%2FPS-MPU-9150A-00v4_3.pdf&ei=J2PRU5P_MOPT7AaWxYCYCg&usg=AFQjCNGesRlMHQ9trZ8uI-dyay-0ENDB9Q&sig2=6EYW-s99VEpcAsG_-Wlong&bvm=bv.71667212,d.ZGU&cad=rja




Como nunca mexi num IMU tive analisar as leituras e estas têm algum ruído. Provavelmente deve dar para melhorar, digo eu.

Os seguintes plots é com o IMU pousado numa mesa (supostamente em repouso):
O arduino está a recolher dados de 100 em 100ms, são só apenas uns minutos de recolha. Os resultados estão centrados em 0.





E agora dando uns pequenos toques na mesa:





A tabela é a mexer o imu em todas as direcções e mais algumas, com os valores reais:



O giroscópio e o acelerometro são de 16bits. O compasso é de 13bits.
Este ruído não deve afectar muito as medições mas como não tenho experiência, não faço a mínima. De qualquer maneira vou calcular medias dos valores.


Bem, já consegui meter o arduino a recolher valores ao Atmega, mas a verdade é que fui preguiçoso e fui à procura de código.

Código: [Seleccione]

// MPU-9150 Accelerometer + Gyro + Compass + Temperature
// -----------------------------
//
// By arduino.cc user "frtrobotik" (Tobias Hübner)
//
//
// July 2013
//      first version
//
// Open Source / Public Domain
//
// Using Arduino 1.0.1
// It will not work with an older version,
// since Wire.endTransmission() uses a parameter
// to hold or release the I2C bus.
//
// Documentation:
// - The InvenSense documents:
//   - "MPU-9150 Product Specification Revision 4.0",
//     PS-MPU-9150A.pdf
//   - "MPU-9150 Register Map and Descriptions Revision 4.0",
//     RM-MPU-9150A-00.pdf
//   - "MPU-9150 9-Axis Evaluation Board User Guide"
//     AN-MPU-9150EVB-00.pdf
//
// The accuracy is 16-bits.
//
// Some parts are copied by the MPU-6050 Playground page.
// playground.arduino.cc/Main/MPU-6050
// There are more Registervalues. Here are only the most
// nessecary ones to get started with this sensor.

#include <Wire.h>

// Register names according to the datasheet.
// According to the InvenSense document
// "MPU-9150 Register Map and Descriptions Revision 4.0",

#define MPU9150_SELF_TEST_X        0x0D   // R/W
#define MPU9150_SELF_TEST_Y        0x0E   // R/W
#define MPU9150_SELF_TEST_X        0x0F   // R/W
#define MPU9150_SELF_TEST_A        0x10   // R/W
#define MPU9150_SMPLRT_DIV         0x19   // R/W
#define MPU9150_CONFIG             0x1A   // R/W
#define MPU9150_GYRO_CONFIG        0x1B   // R/W
#define MPU9150_ACCEL_CONFIG       0x1C   // R/W
#define MPU9150_FF_THR             0x1D   // R/W
#define MPU9150_FF_DUR             0x1E   // R/W
#define MPU9150_MOT_THR            0x1F   // R/W
#define MPU9150_MOT_DUR            0x20   // R/W
#define MPU9150_ZRMOT_THR          0x21   // R/W
#define MPU9150_ZRMOT_DUR          0x22   // R/W
#define MPU9150_FIFO_EN            0x23   // R/W
#define MPU9150_I2C_MST_CTRL       0x24   // R/W
#define MPU9150_I2C_SLV0_ADDR      0x25   // R/W
#define MPU9150_I2C_SLV0_REG       0x26   // R/W
#define MPU9150_I2C_SLV0_CTRL      0x27   // R/W
#define MPU9150_I2C_SLV1_ADDR      0x28   // R/W
#define MPU9150_I2C_SLV1_REG       0x29   // R/W
#define MPU9150_I2C_SLV1_CTRL      0x2A   // R/W
#define MPU9150_I2C_SLV2_ADDR      0x2B   // R/W
#define MPU9150_I2C_SLV2_REG       0x2C   // R/W
#define MPU9150_I2C_SLV2_CTRL      0x2D   // R/W
#define MPU9150_I2C_SLV3_ADDR      0x2E   // R/W
#define MPU9150_I2C_SLV3_REG       0x2F   // R/W
#define MPU9150_I2C_SLV3_CTRL      0x30   // R/W
#define MPU9150_I2C_SLV4_ADDR      0x31   // R/W
#define MPU9150_I2C_SLV4_REG       0x32   // R/W
#define MPU9150_I2C_SLV4_DO        0x33   // R/W
#define MPU9150_I2C_SLV4_CTRL      0x34   // R/W
#define MPU9150_I2C_SLV4_DI        0x35   // R 
#define MPU9150_I2C_MST_STATUS     0x36   // R
#define MPU9150_INT_PIN_CFG        0x37   // R/W
#define MPU9150_INT_ENABLE         0x38   // R/W
#define MPU9150_INT_STATUS         0x3A   // R 
#define MPU9150_ACCEL_XOUT_H       0x3B   // R 
#define MPU9150_ACCEL_XOUT_L       0x3C   // R 
#define MPU9150_ACCEL_YOUT_H       0x3D   // R 
#define MPU9150_ACCEL_YOUT_L       0x3E   // R 
#define MPU9150_ACCEL_ZOUT_H       0x3F   // R 
#define MPU9150_ACCEL_ZOUT_L       0x40   // R 
#define MPU9150_TEMP_OUT_H         0x41   // R 
#define MPU9150_TEMP_OUT_L         0x42   // R 
#define MPU9150_GYRO_XOUT_H        0x43   // R 
#define MPU9150_GYRO_XOUT_L        0x44   // R 
#define MPU9150_GYRO_YOUT_H        0x45   // R 
#define MPU9150_GYRO_YOUT_L        0x46   // R 
#define MPU9150_GYRO_ZOUT_H        0x47   // R 
#define MPU9150_GYRO_ZOUT_L        0x48   // R 
#define MPU9150_EXT_SENS_DATA_00   0x49   // R 
#define MPU9150_EXT_SENS_DATA_01   0x4A   // R 
#define MPU9150_EXT_SENS_DATA_02   0x4B   // R 
#define MPU9150_EXT_SENS_DATA_03   0x4C   // R 
#define MPU9150_EXT_SENS_DATA_04   0x4D   // R 
#define MPU9150_EXT_SENS_DATA_05   0x4E   // R 
#define MPU9150_EXT_SENS_DATA_06   0x4F   // R 
#define MPU9150_EXT_SENS_DATA_07   0x50   // R 
#define MPU9150_EXT_SENS_DATA_08   0x51   // R 
#define MPU9150_EXT_SENS_DATA_09   0x52   // R 
#define MPU9150_EXT_SENS_DATA_10   0x53   // R 
#define MPU9150_EXT_SENS_DATA_11   0x54   // R 
#define MPU9150_EXT_SENS_DATA_12   0x55   // R 
#define MPU9150_EXT_SENS_DATA_13   0x56   // R 
#define MPU9150_EXT_SENS_DATA_14   0x57   // R 
#define MPU9150_EXT_SENS_DATA_15   0x58   // R 
#define MPU9150_EXT_SENS_DATA_16   0x59   // R 
#define MPU9150_EXT_SENS_DATA_17   0x5A   // R 
#define MPU9150_EXT_SENS_DATA_18   0x5B   // R 
#define MPU9150_EXT_SENS_DATA_19   0x5C   // R 
#define MPU9150_EXT_SENS_DATA_20   0x5D   // R 
#define MPU9150_EXT_SENS_DATA_21   0x5E   // R 
#define MPU9150_EXT_SENS_DATA_22   0x5F   // R 
#define MPU9150_EXT_SENS_DATA_23   0x60   // R 
#define MPU9150_MOT_DETECT_STATUS  0x61   // R 
#define MPU9150_I2C_SLV0_DO        0x63   // R/W
#define MPU9150_I2C_SLV1_DO        0x64   // R/W
#define MPU9150_I2C_SLV2_DO        0x65   // R/W
#define MPU9150_I2C_SLV3_DO        0x66   // R/W
#define MPU9150_I2C_MST_DELAY_CTRL 0x67   // R/W
#define MPU9150_SIGNAL_PATH_RESET  0x68   // R/W
#define MPU9150_MOT_DETECT_CTRL    0x69   // R/W
#define MPU9150_USER_CTRL          0x6A   // R/W
#define MPU9150_PWR_MGMT_1         0x6B   // R/W
#define MPU9150_PWR_MGMT_2         0x6C   // R/W
#define MPU9150_FIFO_COUNTH        0x72   // R/W
#define MPU9150_FIFO_COUNTL        0x73   // R/W
#define MPU9150_FIFO_R_W           0x74   // R/W
#define MPU9150_WHO_AM_I           0x75   // R

//MPU9150 Compass
#define MPU9150_CMPS_XOUT_L        0x4A   // R
#define MPU9150_CMPS_XOUT_H        0x4B   // R
#define MPU9150_CMPS_YOUT_L        0x4C   // R
#define MPU9150_CMPS_YOUT_H        0x4D   // R
#define MPU9150_CMPS_ZOUT_L        0x4E   // R
#define MPU9150_CMPS_ZOUT_H        0x4F   // R


// I2C address 0x69 could be 0x68 depends on your wiring.
int MPU9150_I2C_ADDRESS = 0x69;


//Variables where our values can be stored
int cmps[3];
int accl[3];
int gyro[3];
int temp;

void setup()
{     
  // Initialize the Serial Bus for printing data.
  Serial.begin(9600);

  // Initialize the 'Wire' class for the I2C-bus.
  Wire.begin();

  // Clear the 'sleep' bit to start the sensor.
  MPU9150_writeSensor(MPU9150_PWR_MGMT_1, 0);

  MPU9150_setupCompass();
}


void loop()
{
  // Print all sensor values which the sensor provides
  // Formated all values as x, y, and z in order for
  // Compass, Gyro, Acceleration. The First value is
  // the temperature.

  double dT = ( (double) MPU9150_readSensor(MPU9150_TEMP_OUT_L,MPU9150_TEMP_OUT_H) + 12412.0) / 340.0;
  Serial.print(dT);
  Serial.print("  ");
  Serial.print(MPU9150_readSensor(MPU9150_CMPS_XOUT_L,MPU9150_CMPS_XOUT_H));
  Serial.print("  ");
  Serial.print(MPU9150_readSensor(MPU9150_CMPS_YOUT_L,MPU9150_CMPS_YOUT_H));
  Serial.print("  ");
  Serial.print(MPU9150_readSensor(MPU9150_CMPS_ZOUT_L,MPU9150_CMPS_ZOUT_H));
  Serial.print("  ");
  Serial.print(MPU9150_readSensor(MPU9150_GYRO_XOUT_L,MPU9150_GYRO_XOUT_H));
  Serial.print("  ");
  Serial.print(MPU9150_readSensor(MPU9150_GYRO_YOUT_L,MPU9150_GYRO_YOUT_H));
  Serial.print("  ");
  Serial.print(MPU9150_readSensor(MPU9150_GYRO_ZOUT_L,MPU9150_GYRO_ZOUT_H));
  Serial.print("  ");
  Serial.print(MPU9150_readSensor(MPU9150_ACCEL_XOUT_L,MPU9150_ACCEL_XOUT_H));
  Serial.print("  ");
  Serial.print(MPU9150_readSensor(MPU9150_ACCEL_YOUT_L,MPU9150_ACCEL_YOUT_H));
  Serial.print("  ");
  Serial.print(MPU9150_readSensor(MPU9150_ACCEL_ZOUT_L,MPU9150_ACCEL_ZOUT_H));
  Serial.println();
  delay(100);
}

//http://pansenti.wordpress.com/2013/03/26/pansentis-invensense-mpu-9150-software-for-arduino-is-now-on-github/
//Thank you to pansenti for setup code.
//I will documented this one later.
void MPU9150_setupCompass(){
  MPU9150_I2C_ADDRESS = 0x0C;      //change Adress to Compass

  MPU9150_writeSensor(0x0A, 0x00); //PowerDownMode
  MPU9150_writeSensor(0x0A, 0x0F); //SelfTest
  MPU9150_writeSensor(0x0A, 0x00); //PowerDownMode

  MPU9150_I2C_ADDRESS = 0x69;      //change Adress to MPU

  MPU9150_writeSensor(0x24, 0x40); //Wait for Data at Slave0
  MPU9150_writeSensor(0x25, 0x8C); //Set i2c address at slave0 at 0x0C
  MPU9150_writeSensor(0x26, 0x02); //Set where reading at slave 0 starts
  MPU9150_writeSensor(0x27, 0x88); //set offset at start reading and enable
  MPU9150_writeSensor(0x28, 0x0C); //set i2c address at slv1 at 0x0C
  MPU9150_writeSensor(0x29, 0x0A); //Set where reading at slave 1 starts
  MPU9150_writeSensor(0x2A, 0x81); //Enable at set length to 1
  MPU9150_writeSensor(0x64, 0x01); //overvride register
  MPU9150_writeSensor(0x67, 0x03); //set delay rate
  MPU9150_writeSensor(0x01, 0x80);

  MPU9150_writeSensor(0x34, 0x04); //set i2c slv4 delay
  MPU9150_writeSensor(0x64, 0x00); //override register
  MPU9150_writeSensor(0x6A, 0x00); //clear usr setting
  MPU9150_writeSensor(0x64, 0x01); //override register
  MPU9150_writeSensor(0x6A, 0x20); //enable master i2c mode
  MPU9150_writeSensor(0x34, 0x13); //disable slv4
}

////////////////////////////////////////////////////////////
///////// I2C functions to get easier all values ///////////
////////////////////////////////////////////////////////////

int MPU9150_readSensor(int addrL, int addrH){
  Wire.beginTransmission(MPU9150_I2C_ADDRESS);
  Wire.write(addrL);
  Wire.endTransmission(false);

  Wire.requestFrom(MPU9150_I2C_ADDRESS, 1, true);
  byte L = Wire.read();

  Wire.beginTransmission(MPU9150_I2C_ADDRESS);
  Wire.write(addrH);
  Wire.endTransmission(false);

  Wire.requestFrom(MPU9150_I2C_ADDRESS, 1, true);
  byte H = Wire.read();

  return (int16_t)((H<<8)+L);
}

int MPU9150_readSensor(int addr){
  Wire.beginTransmission(MPU9150_I2C_ADDRESS);
  Wire.write(addr);
  Wire.endTransmission(false);

  Wire.requestFrom(MPU9150_I2C_ADDRESS, 1, true);
  return Wire.read();
}

int MPU9150_writeSensor(int addr,int data){
  Wire.beginTransmission(MPU9150_I2C_ADDRESS);
  Wire.write(addr);
  Wire.write(data);
  Wire.endTransmission(true);

  return 1;
}
Queria fazer um código de raiz (vá mais ou menos de raiz) em labview mas estou com algumas dificuldades e não percebo se é problema do código ou outro problema qualquer.

Comecei primeiro por tentar ler um register qualquer do IMU, mas não consigo.
Quando tento escrever, o labview não me dá erros, mas quando tento ler dá-me logo um erro.
Mas só me dá erro quando altero o numero de bytes a ler. Se estiver 0 ta tudo bem , se coloco 1 dá erro.

Estou a colocar o adress em decimal, mas já tentei em binário, só não tentei em hex.

Será que tenho escrever alguma coisa primeiro para depois ele me dar uma resposta?





Cumps

[c3dr1c]

Boas.

Ja consegui resolver alguns problemas. Meço temperaturas sem problemas.


Agora não sei interpretar os valores do giroscópio Precisava de uma ajudinha.
O meu raciocínio foi o seguinte:

- Portanto se estou a usar uma escala de +/- 250º/s e recebo valores no labview entre +/-32768, então:

32768/250=131 (tenho de dividir os valores por 131 para adaptar à escala usada).

- Posteriormente terei de adaptar os valores à escala temporal do programa, portanto se recolho valores de 100 em 100ms tenho de multiplicar a velocidade angular por 0.1

- Para saber a posição actual terei de ir somando as velocidades angulares recolhidas.


Isto está longe da perfeição mas não estou a ver outra forma. Se dou uma volta em torno do eixo X (o eixo que estou a testar no labview) nunca obtenho os 360º perfeitos, há sempre um desvio de cerca de 30º

Outro problema é que em repouso a velocidade angular não está em 0, provavelmente por causa do ruído, à um offset pequenito. Para isso filtrei os valores (> -200  &  < 200)=0

Isto deve ser uma cena muito simples, mas nao estou a ver o que é

[Njay]

Não tou por dentro do que é exactamente o sistema e os detalhes, mas em geral, adicionar "deslocamentos" para obter o valor absoluto não funciona bem. Cada medição tem um erro e a cada adição o erro total cresce "ad eternum".

[StarRider]

Boas,

Ainda não consegui perceber qual a utilidade do IMU no meio disso tudo .... qual é o objectivo do uso de
um IMU ??

Abraços,
PA

[c3dr1c]

Acumular o erro não é nada bom, é verdade. Mas nao faço a minima como fazer isto.

Quanto ao IMU, saber a inclinação do terreno e o norte magnético?

É verdade que vou ter enconders, que são mais fiáveis.
Podia borrifar-me para o IMU e calibrar manualmente, apontando para duas estrelas. Se calhar até era melhor.

Mas agora vou ate ao fim com o IMU para ver as suas possibilidades/potencialidades.