Pessoal boa noite! Qual tecnologia me permitiria controlar dois motores de passo com base em dados do GPS? Eu quero montar um "star tracker" (desculpem se o termo está errado). Na verdade é para deixar um dispositivo sempre apontado para o sol! Teria de funcionar com dados de algum aplicativo do tipo Google Sky, para saber onde o sol vai nascer todo dia e segui-lo até o por-do-sol durante as estações do ano usaria giroscópios, acelerômetro e gps? Se alguém puder me dar uma dica: arduino, raspberry?

Exibições: 1091

Responder esta

Respostas a este tópico

Bom dia , acho que o nome mais adequado é  SUN Tracker. ( Perseguidor do Sol). 

O Sol também é uma estrela (STAR).

Essa escola italiana de Mecatrônica desenvolveu projeto muito interessantes. Descobri no Youtube. 

Veja o SUN TRACKER deles. Muito legal (as fotos foram copiadas do video) 

Procure entrar em contato com a escola, para ver se consegue mais detalhes do projeto.

http://www.itsmeccatronico.it/

Eu usaria motores de passo iguais a esse. São pequenos, consumem pouca energia e travam o movimento, quando estão desligados. O motor que eles usaram é gigante. Não precisa de tanto. 

Esse é o video com os projeto da escola :

José muito obrigado pela ajuda! Sensacional!

Oi DS, bom dia.

Brincando um pouco, você quer na realidade um "sun tracker". 

A inclinação do sol é determinada pela localização geográfica de onde você está (Latitude)

(90 graus, polo norte, -90 graus polo sul),

O sol,( na realidade a terra) tem 2 inclinações máximas em relação ao sol.

O solstício de Inverno e solstício de verão,  Tomando por base o equador, ( 0 graus), no  solstício de verão,

a terra está inclinada a 23,5 graus, e no solstício de inverno, a -23,5 graus.

Estes verão e inverno que me referi, são do hemisfério norte.

Qdo está perpendicular ao equador nos temos os equinócios (De primavera  e de outono).

http://www.infoescola.com/geografia/solsticio-e-equinocio/   este link ajuda um pouco a entender.

Com estas informações, e sabendo que a terra leva 365 dias, 6 horas e alguns segundos para dar uma volta 

em redor do sol, e que este ciclo de inclinação é sincronizado com esta volta, podemos calcular a posição 

da terra em relação ao sol, os horários do nascer e por do sol e ainda a duração e inclinação da da luz solar sobre nós.

Há alguns meses desenvolvi para um amigo,(não do LdG), umsistema para usar placas fotovoltaicas, mantendo-as

sempre perpendicular ao sol a cada segundo e escrevi um algorítimo para este cálculo.

Depois escrevi um code para o arduino usar 2 motores de passo controlando o movimento e acompanhado 

o movimento do sol. Este calculo envolve a latitude, o horário, e o dia do ano.

No final do dia solar, os motores reposicionam as placas para o inicio do próximo dia e ficam a espera do amanhecer.

Caso falte energia durante o dia, ao retornar a energia, as placas são reposicionadas no incio, e em seguida

avançam até a posição que deveriam estar no exato momento que a energia foi restabelecida.

É importante o uso de RTC de boa precisão. Eu usei um DS3231.

Como aprendizado, recomendo você desenvolver o restante do code, mas caso não tenha

conhecimentos ou desenvoltura em C posso disponibilizar o code completo.

Rui

Obs. Não gosto de postar code na área de texto, mas como era bem pequeno e ajuda a entender o funcionamento

resolvi postar.

//-----------------------------------------------------------------------------
void CalculosGeo ()
{
d = tan(23.45*sin(((float)360/365*(284+MeuDia)*Rad))*Rad);   // Calcula declinacao da terra
d = -(d * TgF);                                                                     // Declinacao da terra = declinação * tang das                                                                                                 coord
Nht = ((float)2/15)*(acos(d))/PI*180;                                      // Calcula horas total de sol por dias (float)
Nh = Nht;                                                                           // Horas de sol por dia (long)
Nm = (Nht-Nh)*60;                                                              // Minutos de sol por dia (long)
Ns = (Nht-Nh)*3600-Nm*60;                                                 // Segundos de sol por dia (long)
// Serial.print("Tempo de sol: ");                                            // Serial imprime "Tempo de sol: "
// Imprime();                                                                        // Serial imprime o tempo total de sol do dia
TTotal = (Nh*3600+ Nm*60+ Ns);                                          // Metade do tempo total de seg de sol por dia
Inicio = 43200 - (TTotal/2);                                                    // Meio dia menos metade do tempo de sol
Fim = 43200 + (TTotal/2);                                                     // Meio dia mais metade do tempo de sol
Move = 648000/float(TTotal);                                                 // Segs de graus de deslocamento por seg de hora
}

Olá Rui, cara muito obrigado! Sensacional as tuas informações! Era exatamente isso! Eu sou Médico Veterinário mas estudei eletrônica antes. Estou para defender minha dissertação de mestrado, mas faço parte de um laboratório de física e me pediram um trabalho sobre utilizar aqueles sensores de luminosidade LDR para fazer o dispositivo (na hora já pensei que não seria o ideal). Então como eu gosto muito de astronomia e vinha lendo bastante sobre telescópios, tinha lido sobre alguns modelos e projetos de foto que usam algo parecido. Entãoo eu falei a idéia para o pessoal e fiquei de pesquisar! Me envia um e-mail em denissato@usp.br que gostaria de conversar mais contigo! Falaremos sobre trabalho e valores! Abração e parabéns!

Olá Rui sam, tudo bem? Meu caro, eu montei o sistema aqui mas baseado no LDR. Estou com um pouco de dificuldade para entender a matemática do projeto. Será que você poderia me ajudar? Pelo que entendi o algoritmo faz uma verificação das médias da resistência dos LDR's e compara com o valor de tolerância. Acredito que seja uma comparação com a tensão de 5V. Seria isso mesmo? Segue o algorítmo que eu utilizei no projeto:

#include <Servo.h> // include Servo library

// 180 graus movimento horizontal máximo
Servo horizontal; // horizontal servo
int servoh = 180; // 90; // posição servo horizontal

int servohLimitHigh = 180;
int servohLimitLow = 65;

// 65 degrees MAX
Servo vertical; // vertical servo
int servov = 45; // 90; // posição servo vertical

int servovLimitHigh = 80;
int servovLimitLow = 15;


// LDR pin connections
// name = analogpin;
int ldrlt = 0; //LDR top left - BOTTOM LEFT <--- BDG
int ldrrt = 1; //LDR top rigt - BOTTOM RIGHT
int ldrld = 2; //LDR down left - TOP LEFT
int ldrrd = 3; //ldr down rigt - TOP RIGHT

void setup()
{
Serial.begin(9600);
// servo connections
// name.attacht(pin);
horizontal.attach(9);
vertical.attach(10);
horizontal.write(180);
vertical.write(45);
delay(3000);
}
//definindo variáveis
void loop()
{
int lt = analogRead(ldrlt); // LDR superior esquerda
int rt = analogRead(ldrrt); // LDR superior direita
int ld = analogRead(ldrld); // LDR inferior esquerda
int rd = analogRead(ldrrd); // LDR inferior direita

// int dtime = analogRead(4)/20; // valores de referência
// int tol = analogRead(5)/4;
int dtime = 10;
int tol = 50;

int avt = (lt + rt) / 2; // media ldr superiores
int avd = (ld + rd) / 2; // media ldr inferiores
int avl = (lt + ld) / 2; // media ldr esquerda
int avr = (rt + rd) / 2; // media ldr direita
int dvert = avt - avd; // diferença entre medias superiores e inferiores
int dhoriz = avl - avr;// diferença entre medias esquerda e direita


Serial.print(avt);
Serial.print(" ");
Serial.print(avd);
Serial.print(" ");
Serial.print(avl);
Serial.print(" ");
Serial.print(avr);
Serial.print(" ");
Serial.print(dtime);
Serial.print(" ");
Serial.print(tol);
Serial.println(" ");


if (-1*tol > dvert || dvert > tol) // se valor de tolerância for maior ou menor que media dvert mov vertical
{
if (avt > avd)
{
servov = ++servov;
if (servov > servovLimitHigh)
{
servov = servovLimitHigh;
}
}
else if (avt < avd)
{
servov= --servov;
if (servov < servovLimitLow)
{
servov = servovLimitLow;
}
}
vertical.write(servov);
}

if (-1*tol > dhoriz || dhoriz > tol) // se valor de tolerância for maior ou menor que media dhoriz mov horizontal
{
if (avl > avr)
{
servoh = --servoh;
if (servoh < servohLimitLow)
{
servoh = servohLimitLow;
}
}
else if (avl < avr)
{
servoh = ++servoh;
if (servoh > servohLimitHigh)
{
servoh = servohLimitHigh;
}
}
else if (avl = avr)
{

}
horizontal.write(servoh);
}
delay(dtime);

}

Os LDR's foram ligados às portas analógicas de um arduino UNO conforme o modelo descrito aqui:

http://www.instructables.com/id/Simple-Dual-Axis-Solar-Tracker/

Segue algumas fotos do nosso experimento.

Eu montei um sun tracker aqui usando 4 LDR dispostos sobre uma placa solar.

Vou tentar explicar como funciona a lógica desse projetinho que construí:

* eu coloquei 2 LDR na parte superior da placa solar (LDR1 e LDR2, dispostos um do lado do outro); no meio dos 2, eu coloquei um anteparo, um "paredinha", de forma que quando o sol iluminasse os 2 LDRs (LDR1 e LDR2) perpendicularmente, esses 2 LDR produziamleituras iguais. Se o sol iluminasse de forma "inclinada" esses LDR 1 e 2, o anteparo projetava uma sombra sobre um dos LDRs, que por conseguinte produzia leituras diferentes entre eles. Dessa forma, programaticamente, eu aciono o servo motor para inclicar a placa solar nesse eixo dos LDR1 e LDR2 para que as leituras fiquem iguais, ou seja, a placa ficará apontada para o sol nesse eixo

* Já outros 2 LDR (LDR3 e LDR4) eu fiz usando  a mesma idéia, porém coloquei na parte esquerda da placa solar, dispostos um acima do outro. No meio dos 2, eu coloquei tambem um anteparo, um "paredinha", de forma que quando o sol iluminasse os 2 LDRs (LDR3 e LDR4) perpendicularmente, esses 2 LDR produziam leituras iguais. Se o sol iluminasse de forma "inclinada" esses LDR 3 e 4, o anteparo projetava uma sombra sobre um dos LDRs, que por conseguinte produzia leituras diferentes entre eles. Dessa forma, programaticamente, eu aciono o servo motor para inclicar a placa solar nesse eixo dos LDR3 e LDR4 para que as leituras fiquem iguais, ou seja, a placa ficará apontada para o sol nesse eixo.

Precisei então de 2 servos, um para controlar a inclinação da placa solar para que os LDR 1 e LDR2 produzissem leituras iguais, e o outro servo para controlar a inclinação da placa solar para que os LDR 3 e LDR4 produzissem leituras iguais.

Poxa que legal cara, mas funcionou legal? e quando está nublado o tempo? Tipo se tiver de manhã nublado e à tarde abrir o tempo, ele consegue movimentar na direção do sol? Obrigado pela explicação!

a verdade é que se está nublado, tanto faz se está apontando pro local certo ou não, afinal de contas sem iluminação suficiente a placa irá gerar pouca energia. Mas mesmo que haja uma iluminação fraca, se houver sombra sendo projetada pelos anteparos, os servos corrigirão o posicionamento para que os LDRs gerem leituras parecidas a cada par.

Em respeito  a haver manhã nublada e tarde ensolarada, eu não previ esse aspecto. Talvez sua dúvida esteja sobre a ocorrência de leituras iguais entre os pares de LDR quando a placa estiver apontada para um local oposto de onde está o sol (leste/oeste). Mas não penso que seja difícil programar o apontamento para que fique mais ou menos próximo da provável localização do sol. O RTC ajudará nisso, vide a idéia que o sr. Rui deu

Entendi mestre! Muito obrigado pelas informações imhugo! Parabéns pela ideia!

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço