• Welcome to LusoRobótica - Robótica em Português.
 

Telescopio

Started by c3dr1c, 03 de May de 2014, 22:58

Previous topic - Next topic

0 Members and 1 Guest are viewing this topic.

senso

#60
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. :P

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.
Avr fanboy

Njay

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

StarRider

Quote from: c3dr1c on 25 de June de 2014, 22:14
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  ;D ...

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

#63
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...
"O único modo de descobrir os limites do possivel é aventurarmo-nos um pouco para além deles em direcção ao impossivel."

Uma das Três Leis de Arthur C. Clarke

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...
"O único modo de descobrir os limites do possivel é aventurarmo-nos um pouco para além deles em direcção ao impossivel."

Uma das Três Leis de Arthur C. Clarke

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.
Avr fanboy

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).
"O único modo de descobrir os limites do possivel é aventurarmo-nos um pouco para além deles em direcção ao impossivel."

Uma das Três Leis de Arthur C. Clarke

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.
Avr fanboy

c3dr1c

#68
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.
"O único modo de descobrir os limites do possivel é aventurarmo-nos um pouco para além deles em direcção ao impossivel."

Uma das Três Leis de Arthur C. Clarke

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  :P


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...







"O único modo de descobrir os limites do possivel é aventurarmo-nos um pouco para além deles em direcção ao impossivel."

Uma das Três Leis de Arthur C. Clarke

c3dr1c

#70
Boas.

Bem já passei à acção :P  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.

// 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 :P, 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
"O único modo de descobrir os limites do possivel é aventurarmo-nos um pouco para além deles em direcção ao impossivel."

Uma das Três Leis de Arthur C. Clarke

c3dr1c

#71
Boas.

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


Agora não sei interpretar os valores do giroscópio :P 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º ;D

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 é :P


"O único modo de descobrir os limites do possivel é aventurarmo-nos um pouco para além deles em direcção ao impossivel."

Uma das Três Leis de Arthur C. Clarke

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? :P

É 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.
"O único modo de descobrir os limites do possivel é aventurarmo-nos um pouco para além deles em direcção ao impossivel."

Uma das Três Leis de Arthur C. Clarke