Pacote computacional para simulação de atitude de...

1

Instituto Nacional de Pesquisas Espaciais INPE

Divisão de Mecânica Espacial e Controle

Manual do

Pacote computacional para simulação de atitude de

satélites

Valdemir Carrara

3

Índice 1 – Introdução

1.1 – Versão 2 – Estrutura e uso do pacote de simulação

2.1 – Matrizes 2.2 – Constantes

3 - Funções do simulador de atitude

3.1 - Torques externos de controle ou perturbação não modelada 3.2 - Torques externos em bobinas 3.3 - Torques externos de propulsores 3.4 - Torques internos em rodas de reação 3.5 - Torques internos em amortecedores de nutação 3.6 - Propriedades do satélite 3.7 - Parâmetros do integrador de atitude 3.8 – Parâmetros da atitude 3.9 – Propagador de atitude 3.10 – Cálculo de efemérides

4 - Rotinas para conversão de coordenadas de atitude

4.1 – Matrizes de rotação 4.2 - Funções para conversão de coordenadas de atitude

5 – Efemérides orbitais

5.1 – Transformações de data e hora 5.2 – Conversão de efemérides 5.3 – Posição do Sol 5.4 – Campo magnético terrestre 5.5 – SGP8

6 – Simulação de equipamentos

6.1 – Funções de variáveis aleatórias 6.2 – Magnetômetro 6.3 – Sensor solar analógico 6.4 – Sensor de estrela 6.5 – Sensor GPS 6.6 – Unidade inercial 6.7 – Bobinas magnéticas 6.8 – Propulsores 6.9 – Rodas de reação 6.10 – Mecanismo de rotação do painel solar – BAPTA

7 – Operações em tempo-real

7.1 – Exemplos de uso Referências bibliográficas Apêndice A – Especificações dos equipamentos da PMM

4

Apêndice B – Plano de testes e exemplos de uso

Apêndice C – Relação de funções

5

1 – Introdução

Este documento apresenta um pacote de funções de simulação computacional de atitude desenvolvido para suporte à plataforma multimissão (PMM) da MECB. Fazem parte do conjunto de programas destinados à qualificação do sistema de controle de atitude e órbita (AOC) do satélite dois pacotes principais: o software destinado à simulação da atitude e o programa de controle embarcado. A Figura 1.1 destaca detalhes do relacionamento e interface entre os diversos módulos que compõem o pacote. Há dois requisitos extras para o desenvolvimento destes programas. O primeiro deles é que o programa embarcado deverá ser desenvolvido em linguagem C padrão (Ansi C), uma vez que o computador de bordo deverá contar com este compilador. Este requisito não impõe restrição sobre a linguagem a ser utilizada no programa de simulação, mas uma vez que a linguagem C será necessária no programa embarcado, então é natural que se utilize a mesma linguagem no simulador. O segundo é que os programas serão implantados no laboratório de simulação, que deverá contar com sistema operacional Linux e compilador GCC. Decidiu-se, portanto, desenvolver este pacote em linguagem C, e os exemplos e as interfaces de funções descritas neste documento seguirão este padrão. Cumpre salientar que não há restrições sobre o uso exclusivo de C Ansi no simulador, mas sim no programa embarcado. De fato, alguns poucos recursos não exclusivos de C Ansi foram utilizados, visando principalmente facilitar a programação, como ficará mais claro a seguir.

Existem diversos compiladores C comerciais, entre os quais pode-se mencionar o Visual C++ da Microsoft e o Borland C++. Além de suporte a C++ – ou seja, além de permitir a criação de classes e objetos – estes compiladores possuem diversos recursos de programação em ambiente de rede, interfaces com o sistema operacional e módulos para programação em Windows. Como a maior parte dos computadores que serão utilizados no desenvolvimento contam com sistema operacional Windows, o simulador deverá ser desenvolvido visando a possibilidade de compilação em qualquer compilador C, com poucas ou nenhuma adaptação. A migração do pacote para o ambiente de simulação em GCC-Linux não deverá apresentar grandes problemas, pois a linguagem é padronizada.

Simulação da atitude e órbita

Simulação de sensores

Programa embarcado do controlador

Simulação dos atuadores

sinais de controle

atitude

torques simulados

leitura dos sensores

Simulador

Fig. 1.1 – Interfaces entre os módulos que constituem o programa de simulação e o programa

embarcado do controlador. Mesmo tendo sido desenvolvido com o propósito de suporte à PMM, o pacote apresentado aqui não é específico, mas sim genérico. Isto significa que pode ser configurado livremente para simular qualquer satélite que possua características semelhantes, inclusive satélites estabilizados por rotação, e até mesmo estabilizado por gradiente de gravidade.

6

1.1 - Versão

O simulador de atitude encontra-se na versão 1.0.2. O controle de versões e as modificações efetuadas nas últimas versões encontram-se no Apêndice D. A versão corrente do pacote pode ser verificada em tempo de execução pela avaliação da variável do tipo inteiro ATT_PRO_VERSION (ver Seção 2.2), a qual vale 102 na presente versão.

7

2 – Estrutura e uso do pacote de simulação

O pacote de funções destinado a prover recursos para a simulação de atitude de satélites é composto de 7 módulos:

1) Propagador de atitude (Cap. 3) 2) Conversão de coordenadas (Cap. 4) 3) Funções de controle 4) Efemérides orbitais (Cap. 5) 5) Simulação de equipamentos (sensores, atuadores, BAPTA) (Cap. 6) 6) Perturbações ambientais 7) Operações em tempo-real (Cap. 7)

Os capítulos seguintes descrevem cada um destes pacotes, bem como as rotinas que o

integram, suas variáveis e demais informações úteis. Adicionalmente foi implementado um conjunto de estruturas destinadas a efetuar operações envolvendo matrizes e vetores, com o objetivo de facilitar a programação e depuração dos programas, e um arquivo de cabeçalho com constantes comumente utilizadas em mecânica espacial. Estes pacotes são descritos a seguir. Embora os pacotes tenham sido separados em arquivos diversos, para fins de utilização isto cria dificuldades, já que o número de bibliotecas e arquivos de cabeçalhos diferentes é grande. Assim, para facilitar a utilização do pacote, eles foram agrupados na biblioteca attit_pro.lib, compilada em Microsoft C++, que deverá ser acrescentada ao programa principal durante o processo de amarração (“link”). De forma análoga os arquivos de cabeçalhos foram igualmente agrupados em att_pro.h. Quando compilado em Microsoft C, o programa principal a ser construído deve obrigatoriamente ser declarado como C++ (extensão cpp), em virtude da adoção, pelo pacote, de sobreposição de operadores, que é um recurso exclusivo C++. No lcc-win, deve-se habilitar o uso de extensão de linguagem pelo compilador. Os códigos fontes ds funções construídas (cerca de 200) foram agrupadas em diversos arquivos, para facilitar a depuração e os testes. Estes arquivos são combinados numa única biblioteca, embora os fontes e cabeçalhos continuem separados. Os arquivos individuais serão mencionados ao longo deste manual, porém deve-se, sempre que possível, inserir no projeto os arquivos completos attit_pro.lib, e att_pro.h. Este último é um cabeçalho que insere outros cabeçalhos, que, obviamente, devem estar presentes no ambiente de compilação do projeto: att_pro.h:

#include "matrices.h" #include "consta.h" #include "orbit.h" #include "sgp8.h" #include "attdyn.h" #include "attaux.h" #include "sensors.h" #include "realtime.h" #include "defvar.h"

8

A presente implementação permite a execução do programa de simulação tanto em tempo real quanto em tempo não real. Em ambos os casos, esta versão permite apenas a execução num único computador. 2.1 - Matrizes

Considerando que a simulação e o controle de atitude são equacionados em termos de matrizes e vetores, criou-se um conjunto de estruturas que facilitam a codificação dos programas. No contexto utilizado aqui as matrizes são todas de dimensão 3, ou seja, são matrizes quadradas 3 x 3. Os vetores são igualmente tridimensionais, ou hexa-dimensionais enquanto que quatérnions são quadridimensionais. As estruturas criadas foram: matrix3, vector3, vector6 e quaternion. Utilizou-se o conceito de vetrizes, que combina as propriedades de matrizes com a de vetores. Um vetor é uma estrutura composta por 3 valores reais (precisão dupla, ou double), na forma:

( )3 3 3 3._1 ._ 2 ._ 3v v v v=

O vetor de 6 posições é composto por dois vetores tridimensionais:

6 6 6 66

6 6 6 6

._1 ._1._1 ._1._ 2 ._1._ 3

._ 2 ._ 2._1 ._ 2._ 2 ._ 2._ 3

v v v vv

v v v v

= =

,

Uma matriz a é formada por 3 vetores linha, a._1, a._2 e a._3, e portanto tem a forma:

._1 ._1._1 ._1._ 2 ._1._3

._ 2 ._ 2._1 ._ 2._ 2 ._ 2._ 3

._ 3 ._ 3._1 ._ 3._ 2 ._ 3._3

a a a a

a a a a a

a a a a

= =

,

Finalmente, o quatérnion tem a forma:

._1

._ 2

._3

._ 4

q

qq

q

q

=

.

Nota-se que a matriz poderia ser definida como sendo um vetor de 9 componentes. A

diferença serve para lembrar que o existem produtos de matrizes por vetores, mas não existem produtos de vetores de 6 dimensões por outro de 3 dimensões, por exemplo. Em outras palavras, no produto de uma matriz a por um vetor linha b, deve-se sempre lembrar que, de fato, está a se fazer um produto na forma a bT, onde o sobrescrito “T” indica a transposição do vetor. O código para esta multiplicação é simplesmente a*b, sem a necessidade de transpor o vetor.

Uma variável matrix3 é composta por 3 vetores linha (denominados _1, _2 e _3) e estes por 3 elementos cada, de tal forma que os nove elementos da matriz podem ser endereçados na seqüência ._1._1, ._1._2, ._1._3, ._2._1, ._2._2, ._2._3, ._3._1, ._3._2,

9

._3._3. O vetor tridimensional é composto por 3 elementos: ._1, ._2, ._3; o vetor de seis componentes é composto pelos elementos: ._1._1, ._1._2, ._1._3, ._2._1, ._2._2, ._2._3 e, finalmente, o quatérnion é composto por 4 elementos: ._1, ._2, ._3, ._4. Os elementos destas estruturas são todos do tipo double. Para criar variáveis com estas estruturas, usa-se:

#include “matrices.h” …

matrix3 mat_rot, mat_rot1, mat_rot2; vector3 vec_pos; vector6 state_vector; quaternion q;

...

Os elementos individuais de cada variável podem ser acessados por meio do ponto

seguido do nome do elemento, como, por exemplo, mat_rot._21, vec_pos._3 ou q._1. A atribuição de valor para cada um deles pode ser facilmente feita por meio de listas como

mat_rot = 0.2, 0, -1, 0.6, 1, -2, 2, 1.5, 3; vec_pos = 1543.3, 764.0, -2414.8;

ou então pelo acesso a cada elemento por meio de seus índices: vec_pos._1 = mat_rot._1._3; vec_pos._2 = mat_rot._2._3; vec_pos._3 = mat_rot._3._3; q._4 = 1;

Foram implementadas (sobrepostas) neste pacote as principais operações matemáticas

entre matrizes e vetores, para permitir a representação simbólica destas operações. Assim, um produto de duas matrizes é indicado por:

mat_rot = mat_rot1 * mat_rot2;

Qualquer composição envolvendo operações de adição, subtração e multiplicação é

igualmente válida:

mat_rot = (mat_rot1 + mat_rot2) * mat_rot3;

As seguintes operações são válidas, e verificadas durante a compilação, isto é, caso

seja detectado uma operação não definida previamente, o compilador emite um alerta:

• Produto entre duas matrizes: (matrix3) = (matrix3) * (matrix3) • Produto de um escalar por uma matriz: (matrix3) = (double) * (matrix3) • Produto de um inteiro por uma matriz: (matrix3) = (int) * (matrix3) • Produto de uma matriz por um escalar: (matrix3) = (matrix3) * (double) • Produto de uma matriz por um inteiro: (matrix3) = (matrix3) * (int) • Divisão de uma matriz por um escalar: (matrix3) = (matrix3) / (double) • Divisão de uma matriz por um inteiro: (matrix3) = (matrix3) / (int) • Soma de matrizes: (matrix3) = (matrix3) + (matrix3) • Diferença entre matrizes: (matrix3) = (matrix3) - (matrix3) • Produto escalar entre vetores: (double) = (vector3) * (vector3) • Produto de uma matriz por um vetor: (vector3) = (matrix3) * (vector3) • Soma de vetores: (vector3) = (vector3) + (vector3)

10

• Diferença entre vetores: (vector3) = (vector3) - (vector3) • Produto vetorial: (vector3) = (vector3) ^ (vector3) • Produto de um escalar por um vetor: (vector3) = (double) * (vector3) • Produto de um inteiro por um vetor: (vector3) = (int) * (vector3) • Produto de um vetor por um escalar: (vector3) = (vector3) * (double) • Produto de um vetor por um inteiro: (vector3) = (vector3) * (int) • Divisão de um vetor por um escalar: (vector3) = (vector3) / (double) • Divisão de um vetor por um inteiro: (vector3) = (vector3) / (int) • Produto de uma matriz por um vector6: (vector6) = (matrix3) * (vector6) • Soma de vetores duplos: (vector6) = (vector6) + (vector6) • Diferença entre vetores duplos: (vector6) = (vector6) - (vector6) • Produto de um escalar por um vetor6: (vector6) = (double) * (vector6) • Produto de um inteiro por um vetor duplo: (vector6) = (int) * (vector6) • Produto de um vetor6 por um escalar: (vector6) = (vector6) * (double) • Produto de um vetor duplo por um inteiro: (vector6) = (vector6) * (int) • Divisão de um vetor duplo por um escalar: (vector6) = (vector6) / (double) • Divisão de um vetor duplo por um inteiro: (vector6) = (vector6) / (int) • Produto entre escalar e quatérnion (quaternion) = (double) * (quaternion) • Produto entre inteiro e quatérnion (quaternion) = (int) * (quaternion) • Produto entre quatérnion e escalar (quaternion) = (quaternion) * (double) • Produto entre quatérnion e inteiro (quaternion) = (quaternion) * (int) • Divisão entre quatérnion e escalar (quaternion) = (quaternion) / (double) • Divisão entre quatérnion e inteiro (quaternion) = (quaternion) / (int) • Produto entre quatérnions (quaternion) = (quaternion) * (quaternion)

O produto escalar entre vetores é indicado pelo sinal usual do produto “*”, enquanto

que o produto vetorial é indicado pelo circunflexo “^”. Veja que o resultado pode diferir em virtude da ordem com que as operações são realizadas, como no caso:

(matrix3) = (matrix3) * ((vector3) * (vector3)) (double) = (matrix3) * (vector3) * (vector3)

Em virtude da sobreposição de operações e dos símbolos de operações, não se pode

garantir a ordem com que elas são realizadas numa linha. Notou-se que pelo menos no produto vetorial a ordem de precedência do produto não é obedecida, isto é, num cálculo como este: dwdt = a_ang ^ w_vel - wheel_torque;

a subtração tem precedência sobre o produto! Portanto, adverte-se manter um controle sobre a ordem das operações, para evitar maiores problemas na depuração, e sinalizar por meio de parêntesis a ordem correta:

dwdt = (a_ang ^ w_vel) - wheel_torque;

O produto de uma matriz por um vetor de 6 componentes é realizado multiplicando-se

a matriz pelos dois vetores que compõem o vetor6.

O produto de quatérnions, por sua vez, permite efetuar a rotação de uma atitude dado o quatérnion que relaciona ambas. Maiores detalhes podem ser encontrados no Apêndice D de

11

Wertz (Wertz, 1978). A estrutura quatérnion admite que os três primeiros valores (q._1, q._2 e q._3) constituem o vetor nas direções i, j e k, respectivamente, enquanto que a quarta componente (q._4) armazena o valor escalar: 1 2 3 4q q i q j q k q= + + +

As definições e protótipos para estas variáveis encontram-se no cabeçalho

matrices.h. Um programa que utilize estas estruturas deverá ser unido (link) ao arquivo matrices.lib, que contém os operadores definidos em matrices.c. As matrizes são criadas pela estrutura matrix3, os vetores pela estrutura vector3 e os quatérnions pela estrutura quaternion. O seguinte programa foi utilizado para testar as operações entre matrizes e vetores:

#include <stdio.h> #include "matrices.h" void main ()

double a = 2; matrix3 mat1 = 9, 8, 7, 6, 5, 4, 3, 2, 1;

matrix3 mat2 = -1, 4, 2, -5, -3, 0, 3, 2, 4; matrix3 mat3 = 5, -2, 4, -1, -3, 0, 2, 9, 1;

vector3 vec1 = 1, 2, 3, vec2 = -4, -3, 2, vec3;

// mat3 = 2 * mat1 * mat3 * mat2 ;// produto de matrizes // mat3 = mat1 * mat3 * 2 * mat2 ;// produto de escalar por matriz // mat3 = mat1 * mat3 * mat2 * 2 ;// produto de matriz por escalar // mat3 = mat1 + mat3 + mat2 ; // soma de matrizes // mat3 = mat1 + mat3 - mat2 ; // soma e subtração de matrizes // mat3 = (mat1 + mat3) * mat2 ; // soma e produto

// mat3 = vec1 * vec2 * mat2 ; // produto escalar // mat3 = mat2 * (vec1 * vec2) ; // produto escalar // a = mat2 * vec1 * vec2; // produto de matriz por vetor // vec3 = vec1 + vec2; // soma de vetores // vec3 = vec1 - vec2; // diferença de vetores // vec3 = vec1 ^ vec2; // produto vetorial // vec3 = vec2 ^ vec1; // produto vetorial // vec3 = a * vec1; // produto de escalar por vetor // vec3 = vec1 * a; // produto de escalar por vetor

printf(" Matriz \n");

printf(" %10.4f %10.4f %10.4f \n", mat3._11,mat3._12,mat3._13); printf(" %10.4f %10.4f %10.4f \n", mat3._21,mat3._22,mat3._23); printf(" %10.4f %10.4f %10.4f \n", mat3._31,mat3._32,mat3._33); printf(" Vetor \n");

printf(" %10.4f %10.4f %10.4f \n", vec3._1, vec3._2, vec3._3); printf(" Escalar \n");

printf(" %10.4f \n", a);

return;

Adicionalmente, foram acrescentadas funções que visam oferecer outros recursos na

manipulação de matrizes. Entre elas encontram-se funções para inverter ou transpor uma matriz, normalizar um vetor ou um quatérnion, funções de atribuição de valores, etc. Estas funções são descritas a seguir:

12

• matrix3 transpose (matrix3 mat);

A função transpose retorna com a transposta de uma matriz dada. A transposta é útil

na inversão de matrizes ortogonais unitárias (matrizes de rotação). Parâmetros de entrada: mat

matriz a ser transposta, passada por referência. Parâmetros de saída: transpose

matriz transposta de mat. Exemplo: matrix3 mat1 = 9, 8, 7, 6, 5, 4, 3, 2 ,1, mat2; mat2 = transpose(mat1); R:

mat1 = 9, 6, 3, 8, 5, 2, 7, 4, 1

• matrix3 inverse (matrix3 matin);

Esta função é utilizada para inverter a matriz matin.

Parâmetros de entrada: matin

matriz a ser invertida, passada por referência. Parâmetros de saída: inverse

inversa da matriz matin,. Exemplo:

Entradas: matrix3 mat1 = 1, 2, 3, -1, 5, 1, 2, 4, 5.99; mat2 = inverse (mat1); mat3 = mat1 * mat2; Saídas: mat2 = -370.7143, -0.2857, 185.7143, -114.1429, 0.1429, 57.1429, 200., 0, -100. mat3 = 1, 0, 0, 0, 1, 0, 0, 0, 1 • matrix3 identity (double escal);

A função identity retorna com uma matriz identidade multiplicada pelo escalar

escal. Parâmetros de entrada: escal

escalar que irá multiplicar a matriz identidade, passado por valor. Parâmetros de saída: identity

matriz identidade multiplicada por escal.

13

Exemplo: mat1 = identity (2.5); R:

mat1 = 2.5, 0, 0, 0, 2.5, 0, 0, 0, 2.5

• matrix3 skew_simetric (vector3 win);

A função skew_simetric retorna com a matriz do produto vetorial, isto é, tal que

skew_simetric * v apresenta o mesmo resultado de win ^ v, onde v é um vetor qualquer e ^ denota o produto vetorial. Em algumas situações é preferível ter a matriz do produto vetorial a efetuar este produto por meio do operador “^”. Parâmetros de entrada: win

primeiro vetor do produto vetorial, passado por referência. Parâmetros de saída:

skew_simetric

matriz do produto vetorial. Exemplo: vector3 vec1[3] = -3, 2, 5; mat1 = skew_simetric (vec1); R:

mat1 = 0, -5, 2, 5, 0, 3, -2, -3, 0

• vector3 unity_vector (vector3 vecin);

A função unity_vector normaliza o vetor vecin. Se o vetor de entrada possuir

módulo nulo, então o vetor de retorno será também nulo. Parâmetros de entrada: vecin

vetor a ser normalizado, passado por referência. Parâmetros de saída: univec

vetor normalizado (módulo unitário). Exemplo: vector3 vec1 = -3, 2, 5; vec2 = unity_vector (vec1);

R: vec2 = -0.4867, 0.3244, 0.8111

• double modulus (vector3 vecin);

A função modulus obtém a magnitude do vetor vecin. Parâmetros de entrada: vecin

vetor de entrada, passado por referência.

14

Parâmetros de saída: modulus

magnitude do vetor vecin. Exemplo: vector3 vec1 = -3, 2, 5; double dmod; dmod = univec (vec1);

R: dmod = 6.1644

• quaternion unity_quaternion (quaternion quat);

A função unity_quaternion normaliza o quatérnion quat, que passa a ter módulo

unitário. Normalmente, a magnitude de um quatérnion possui módulo unitário. Porém, erros de integração fazem com que esta magnitude desvie lentamente da unidade. Esta função, portanto, restaura a magnitude original. Parâmetros de entrada: quat

quatérnion a ser normalizado, passado por referência Parâmetros de saída: unity_quaternion

quatérnion normalizado Exemplo: quaternion quat1 = .2, .6, .4, .5; quat2 = unity_quaternion (quat1);

R: quat2 = 0.2222, 0.6667, 0.4444, 0.5556

• quaternion conjugate (quaternion quat)

Esta função retorna com o conjugado do quatérnion quat. Maiores detalhes sobre o conjugado do quatérnion e suas propriedades podem ser encontradas em Wertz (1978). O quatérnion conjugado possui o sinal invertido nas primeiras 3 coordenadas enquanto que a quarta coordenada permanece inalterada. Parâmetros de entrada: quat

quatérnion, passado por referência. Parâmetros de saída: conjugate

quatérnion conjugado (corresponde ao inverso do quatérnion). Exemplo: quaternion quat1 = .2, .6, .4, .5; quat2 = conjugate (quat1);

R: quat2 = -0.2, -0.6, -0.4, 0.5

15

• vector3 vec3_def (double vx, double vy, double vz);

A função vec3_def permite atribuir valores a um vetor, sem a necessidade de especificar cada uma das componentes. Esta função pode ser utilizada, por exemplo, em argumentos de funções que requeiram um parâmetro do tipo vector3. Parâmetros de entrada: vx, vy, vz

componentes do vetor, nas direções x, y e z, respectivamente, passados por valor.

Parâmetros de saída: vec3_def

vetor com componentes vx, vy, vz Exemplo: quat2 = exyzquat (vec3_def(1.2, -0.15, 0.57));

R: quat2 = 0.5229, -0.2177, 0.1908, 0.8017

• vector6 vec6_def (double vx, double vy, double vz, double wx, double wy,

double wz);

A função vec6_def permite atribuir valores a um vetor duplo, de 6 componentes, sem

a necessidade de especificar cada um deles. Esta função pode ser utilizada, por exemplo, em argumentos de funções que requeiram um parâmetro do tipo vector6. Parâmetros de entrada: vx, vy, vz

componentes do primeiro vetor do vetor duplo, nas direções x, y e z, respectivamente, passados por valor.

wx, wy, wz

componentes do segundo vetor do vetor duplo, nas direções x, y e z, respectivamente, passados por valor.

Parâmetros de saída: vec6_def

vetor com componentes vx, vy, vz, wx, wy, wz Exemplo: vector6 vec6;

vec6 = kepel_statvec (vec6_def(7128150, 0.01, 0.12, 0, 0, 0.6)); R: vec6 = 5788824., 4028899., 485802., -4292., 6153., 742.

• quaternion quat_def (double q1, double q2, double q3, double q4);

A função quat_def permite atribuir valores a um quaternion, sem a necessidade de

especificar cada uma de suas componentes. Esta função pode ser utilizada, por exemplo, em argumentos de funções que requeiram um parâmetro do tipo quaternion. Parâmetros de entrada: q1, q2, q3, q4

16

componentes do quaternion (vetor nas 3 primeiras componentes e escalar na quarta componente), passados por valor.

Parâmetros de saída: quat_def

quaternion com componentes q1, q2, q3, q4. Exemplo: int ista;

ista = set_attitude (quat_def(0., 0., 0., 1)); R: vec6 = 5788824., 4028899., 485802., -4292., 6153., 742.

• matrix3 mat3_def (double a11, double a12, double a13, double a21, double

a22, double a23, double a31, double a32, double a33);

A função mat3_def permite atribuir valores a uma quaternion, sem a necessidade de

especificar cada uma de suas componentes. Esta função pode ser utilizada, por exemplo, em argumentos de funções que requeiram um parâmetro do tipo matrix3. Parâmetros de entrada: a11, a12, a13, a21, a22, a23, a31, a32, a33

componentes da matriz, passados por valor. Parâmetros de saída: mat3_def

matriz com componentes a11, a12, a13, a21, a22, a23, a31, a32, a33.

Exemplo: matrix3 omeg;

omeg = mat3_def(0., -3., 2., 3., 0., -1., -2., 1., 0.); R: omeg = 0., -3., 2., 3., 0., -1., -2., 1., 0.

2.2 - Constantes

É comum em problemas de dinâmica orbital e de atitude o uso de constantes, como por exemplo o raio da Terra, em diversos locais do programa de simulação. Para evitar a repetição de definições e uniformizar seus valores, elas foram agrupadas no arquivo consta.h (tipo header), que deve ser incluído sempre que estas constantes forem necessárias à execução do programa. As seguintes bibliotecas fazem uso deste arquivo de cabeçalho: attdyn.c, orbit.c, sgp8.c e sensors.c. Uma vez que a linguagem C separa os caracteres maiúsculos dos minúsculos (case sensitive), adotou-se, por convenção, que as constantes devem possuir todos os seus caracteres em letras maiúsculas, para que fosse possível identificar facilmente as variáveis que provêm deste cabeçalho. A tabela 2.1 fornece uma relação das constantes presentes neste arquivo e sua nomenclatura. Todas as variáveis são do tipo estáticas (static) e de precisão dupla (double)

17

Tabela 2.1 Constantes do arquivo consta.h

Tipo Símbolo Variável Valor Unid.

π PI 3.1415926535897932 -

2 π PI_T2 6.2831853071795865 -

π / 2 PI_D2 1.5707963267948966 -

π / 180o RADIANS 0.017453292519943296 rad/o

Constantes matema-ticas

180o / π DEGREES 57.29577951308232088 o/rad Ano trópico Yt TROPIC_YEAR 365.24219879 dias Ano sideral Ys = Yt + 1 SIDEREAL_YEAR 366.24219879 dias Segundos do dia Sd SEC_PER_DAY 86400 s

Constantes de tempo

Ds = Sd Yt / Ys SIDEREAL_DAY 86164.0905382136453 s Raio da Terra Rt EARTH_RADIUS 6378139 m f = 1 / 298.257 EARTH_FLATNESS 0.003352813177896914 -

µt EARTH_GRAVITY 3.9860064e+14 m3/s2 Constantes da Terra

2 11

d tS Y

πθ = +

ɺ EARTH_RATE 7.292115854681949e-5 rad/s

-62 484.165410 5J = J_2 1.0826268362e-3 -

-63 -0.9583810 7J = J_3 -2.5356351415e-6 -

-64 -0.5411210 3J = J_4 -1.62336e-6 -

-65 -0.0686210 11J = J_5 -2.2758679311e-7 -

Coeficien-tes zonais do modelo GEM10

-65 0.15070 10 13J = J_6 5.4335657721e-7 -

Raio do Sol Rs SUN_RADIUS 0.6953e+09 m

Unid. Astronômica Au ASTRONOMICAL_UNIT 149.60e+09 m Constantes do Sol

µs SUN_GRAVITY 1.32712438e+20 m3/s2 Raio da Lua Rm MOON_RADIUS 0.1738e+07 m Constantes

da Lua µm MOON_GRAVITY 4.902794e+12 m3/s2

Adicionalmente, foram criadas diversas variáveis com finalidade de facilitar a programação e configuração do simulador. Elas foram agrupadas no arquivo de cabeçalhos defvar.h, mas encontram-se igualmente disponíveis no cabeçalho att_pro.h. Elas constituem, basicamente, variáveis para a configuração do integrador numérico, além de algumas constantes úteis como vetores nas direções dos eixos cartesianos e matriz identidade:

const int TRUE = 1; const int FALSE = 0; const int INTEG_FIX = 0; const int INTEG_VARIABLE = 1; const int INTEG_RKF_4 = 2; const int INTEG_RKF_24 = 3; const int INTEG_RKF_78 = 4; const int ATT_PRO_VERSION = 102; vector3 NULL_VECTOR = 0, 0, 0; vector3 X_VECTOR = 1, 0, 0; vector3 Y_VECTOR = 0, 1, 0; vector3 Z_VECTOR = 0, 0, 1; matrix3 ID_MATRIX = 1, 0, 0, 0, 1, 0, 0, 0, 1;

18

Os vetores X_VECTOR, Y_VECTOR e Z_VECTOR definem as direções cartesianas x, y e z, e

o vetor NULL_VECTOR define um vetor nulo. A matriz ID_MATRIX define uma matriz identidade. A variável ATT_PRO_VERSION fornece a versão atual do pacote de simulação.

Os vetores unitários nas direções cartesianas permitem obter os componentes escalares de qualquer vetor sem a necessidade de se invocar diretamente o vetor. Por exemplo, seja o vetor w = 0.1, 0.2, 0.3. Estas componentes podem ser encontradas, em qualquer ponto do programa, por meio de w._1, w._2 e w._3. Por outro lado, pode-se igualmente obter estes valores por meio dos produtos escalares w*X_VECTOR, w*Y_VECTOR e w*Z_VECTOR.

19

3 - Funções do simulador de atitude O simulador de atitude foi implementado na linguagem C, e os protótipos das funções estão definidos no arquivo de cabeçalho attdyn.h. O arquivo de biblioteca a ser unido ao programa executável denomina-se attdyn.lib. As funções estão agrupadas segundo sua aplicação na simulação. Tem-se, assim, funções destinadas ao fornecimento de torques de controle (ou mesmo de perturbações) de origem externa; funções para fornecimento de torques de controle internas por meio de rodas de reação ou volantes de inércia; funções para fornecimento da geometria e dinâmica de apêndices articulados ou giratórios, funções para a definição de propriedades do satélite, e funções destinadas à configuração do propagador de atitude. A dinâmica dos apêndices articulados ou giratórios foi implementada de forma a não depender do tempo. Portanto ela não altera, ao contrário das rodas e volantes de inércia, o número de graus de liberdade (variáveis de estado) da planta. Em outras palavras, pressupõe-se que o torque aplicado na interface entre o apêndice e o corpo do satélite seja nulo, o que evita a necessidade de se integrar separadamente o movimento do satélite e do apêndice. Isto não acarreta perda de generalidade, uma vez que, se houver um torque nesta interface, pode-se supor que este apêndice seja um volante de inércia, o que irá permitir a integração separada. Contudo, neste caso, é necessário que este apêndice possua simetria de inércia radial (como um volante), e que sua massa e inércia sejam adicionadas ao corpo principal do satélite. Somente o momento angular relativo entre eles será integrado. Um satélite do tipo dual-spin no qual a velocidade angular da parte rotativa não sofre acelerações (ou torques), pode ser modelado como um apêndice articulado. Igualmente, painéis solares giratórios podem ser considerados apêndices articulados, já que sua velocidade de rotação é constante (torque líquido nulo). Isto não significa, em absoluto, que a conservação da quantidade de movimento angular seria violada na ausência de torques externos. Acelerações e desacelerações na velocidade angular dos painéis são compensadas por uma reação contrária no corpo principal do satélite, sem ser necessária a descrição do torque nesta interface. A vantagem desta modelagem é permitir que os apêndices possam ser modelados com assimetria de massa. De fato, a implementação da dinâmica leva em conta as alterações na inércia do conjunto, bem como na alteração do centro de massa do satélite devido ao movimento do apêndice. Antes de descrever as funções do simulador, convém mencionar os ciclos de tempo utilizados pelo integrador de atitude. Os torques utilizados pelo integrador podem possuir dinâmica de curto período (torques de reação das rodas, efeitos da geometria dos painéis na dinâmica, etc.), de médio período (atuação dos propulsores, atuação das bobinas) ou ainda de longo período (perturbações ambientais). É relativamente difícil classificar os torques efetivamente modelados como pertencentes a uma ou outra categoria, uma vez que não foi definido exatamente o que é um efeito de curto ou longo período. Um torque pode ser classificado como médio período e apresentar oscilações aleatórias de curto período, por exemplo. Por outro lado, os requisitos de operação em tempo real exigem que o cálculo destes efeitos seja otimizado com relação ao tempo de processamento. Para não descumprir este requisito, uma vez estes cálculos podem exigir processamento elevado, conclui-se que os torques devem ser atualizados no maior intervalo de tempo possível. Isto significa que este intervalo deve ser, ao mesmo tempo, pequeno o suficiente para garantir continuidade da resposta no tempo, e grande o suficiente para reduzir o esforço de processamento. Internamente um integrador numérico de passo fixo possui igualmente ciclos de tempo: há o passo de integração, o ciclo de integração e o período de integração, mostrados na Figura 3.1. O passo de integração é o menor intervalo de tempo no qual as equações da dinâmica serão avaliadas. O ciclo de integração é o intervalo no qual deseja-se conhecer o

20

estado da dinâmica, uma vez que a integração nos passos é realizada sem controle externo. Cada ciclo de integração corresponde a vários passos de integração. Finalmente, o período de integração é o intervalo de tempo que se deseja simular. Tipicamente, passos de integração de atitude situam-se entre milésimos e décimos de segundo. Ciclos de integração são compatíveis com ciclos de controle e situam-se entre décimos de segundo e poucos segundos. Períodos de integração em geral duram de alguns minutos a algumas horas. Estes intervalos não devem ser confundidos com o tempo de processamento, que é a duração de execução do programa. No caso de simuladores em tempo real, é necessário garantir que o tempo de processamento seja inferior ao período de integração.

Dinâmica de atitude

Período de integração

Ciclo de integração

Passo de integração

Fig. 3.1 – Intervalos de tempos presentes no integrador numérico de atitude.

Parece óbvio, portanto, que a atualização das informações de torque sejam baseadas elas também nestes ciclos, de forma a otimizar o tempo disponível para o processamento. Implementou-se, assim, formas distintas de atualizar estas informações, que seguem a dinâmica temporal. Efeitos de curto período são atualizados durante os passos de integração por meio de funções de retorno (callback function). Genericamente passa-se o nome da função (callback) que calcula a derivada temporal deste efeito como argumento de uma função, e o integrador faz atualizações desta variável com base na derivada. Efeitos de médio período são atualizados durante os ciclos de integração, por meio de funções de atribuição ou definição. Trata-se de funções que recebem valores como parâmetros e registram estes valores, que permanecem constantes durante todo o ciclo de integração, até que sejam novamente atualizados pelo programa. Efeitos de longo período são atualizados durante períodos de integração, que envolvem vários ciclos. O período de atualização deve ser informado ao simulador por meio de uma função, e o simulador promoverá o cálculo do torque somente ao fim de cada período. Cada torque calculado, seja automaticamente ou fornecido pelo programador, segue apenas um destes ciclos. Torques de controle, por exemplo, podem ser atualizados somente a cada ciclo de integração, mas não podem ser calculados nos passos de integração. Um programa típico escrito em C e que utilize as funções descritas aqui possui a seguinte forma geral:

// inclusão dos cabeçalhos #include "att_pro.h"

void main () // programa principal

21

// declaração de variáveis ... // chamadas às funções de configuração do satélite e integrador ... // malha de integração

while (t < t_end) // comando dos torques de controle

... // armazenar o estado atual ... // propagar a atitude

sat_propagation(); // fim return;

A utilização de funções de configuração permitem que, ao se iniciar a propagação da atitude (função sat_propagation), todas as variáveis necessárias à integração já estejam definidas, e, portanto, não é necessário passar argumentos para a integração. Além disso, implementou-se também funções de retorno dos valores atribuídos, de tal forma que, em qualquer ponto do programa, pode-se ter acesso às informações utilizadas nas definições ou os principais resultados calculados pelo integrador. As funções implementadas para a configuração do satélite e do propagador de atitude são descritas a seguir, agrupadas por aspectos funcionais:

• Torque externo de controle ou perturbação não modelada • Torques externos em bobinas • Torques externos em propulsores • Torques internos em rodas de reação • Torques internos em amortecedores de nutação • Propriedades do satélite • Parâmetros do integrador de atitude • Parâmetros da atitude • Propagador de atitude • Cálculo de efemérides

3.1 - Torques externos de controle ou perturbação não modelada

As funções descritas nesta seção permitem definir qual será o torque de controle (ou de perturbação) a ser utilizado no próximo ciclo de integração. Constam de funções para habilitar ou desabilitar o processamento dos torques externos de controle, e para definir o valor deste torque. Desabilitar o processamento do torque durante a integração é equivalente a anular o torque de controle.

• int set_control_torque_flag ()

Esta função habilita a integração do torque externo de controle pela dinâmica de

atitude, por meio da variável (int) control_torque_flag. Esta função define esta variável como sendo igual a 1. O valor do torque de controle é definido pela função set_control_torque. O torque de controle pode ser obtido por meio da função get_control_torque. Torques externos são aqueles que alteram o momento angular do

22

satélite, como torques das bobinas e de propulsores. Esta variável é iniciada com valor 0 (falso). Parâmetros de entrada:

não há Parâmetros de saída:

set_control_torque_flag valor de retorno: 0

Exemplo: int ista; ista = set_control_torque_flag(); • int reset_control_torque_flag ()

Esta função desabilita o uso de torque de controle pela dinâmica de atitude, por meio da variável (int) control_torque_flag. Esta função define esta variável como sendo igual a 0. Parâmetros de entrada:


reset_control_torque_flag Valor de retorno: 0

Exemplo: int ista; ista = set_control_torque_flag(); ista = reset_control_torque_flag(); • int get_control_torque_flag ()

Esta função retorna com o valor atual da variável control_torque_flag. Esta função não possui argumentos. Parâmetros de entrada:


get_control_torque_flag valor de retorno: control_torque_flag

Exemplo: int ista; ista = set_control_torque_flag(); ista = get_control_torque_flag(); R: ista = 1 • int set_control_torque (vector3 torq)

23

Esta função define o torque externo de controle (Nm) a ser usado pela dinâmica de atitude, desde que a variável control_torque_flag esteja habilitada. As componentes do torque nas direções x, y e z do sistema de coordenadas fixado ao corpo principal do satélite são fornecidas nas componentes torq._1, torq._2 e torq._3, respectivamente. Esta variável é iniciada como um vetor nulo. Parâmetros de entrada: torq torque externo aplicado ao satélite, em Nm. Parâmetros de saída:

set_control_torque 0 se control_torque_flag estiver habilitado, -1 caso contrário, e neste caso o valor do torque não é atualizado. Valor de retorno: control_torque_flag

Exemplo: int ista; vector3 vec1; ista = set_control_torque_flag();

vec1._1 = 0.001; vec1._2 = -0.001; vec1._1 = 0.15;

ista = set_control_torque (vec1);

• vector3 get_control_torque ()

Esta função retorna com o valor atual do torque externo de controle (Nm) usado na dinâmica de atitude. As componentes do torque nas direções x, y e z do sistema de coordenadas fixado ao corpo principal do satélite são fornecidas nas componentes ._1, ._2 ._3, respectivamente. Parâmetros de entrada: não há Parâmetros de saída: get_control_torque

vetor contendo o valor atual do torque externo, ou um vetor nulo caso a variável control_torque_flag esteja desabilitada.

Exemplo: int ista; vector3 vec1; ista = set_control_torque_flag();

vec1._1 = 0.001; vec1._2 = -0.001; vec1._1 = 0.15; ista = set_control_torque (vec1); vec1 = get_control_torque(); R: vec1 = 0.001, -0.001; 0.15

24

3.2 - Torques externos em bobinas

O cálculo do torque de controle efetuado por bobinas difere dos torques externos mencionados anteriormente, em virtude de vários aspectos. O principal deles é o fato de que o torque gerado pelas bobinas é perpendicular tanto ao momento magnético da bobina (alinhada com o eixo de simetria) quanto ao campo magnético terrestre. Isto significa que o campo magnético muda de direção quando for expresso no referencial do satélite, mesmo que inercialmente o campo permaneça praticamente fixo. Por sua vez isto implica que o torque gerado pelas bobinas deve ser integrado usando o próprio passo de integração, ou seja, o valor do torque deve ser atualizado durante cada passo de integração. A implementação realizada aqui permite a possibilidade de configurar até 8 bobinas na simulação. É necessário, portanto, fornecer as direções dos eixos destas bobinas e seus momentos magnéticos individuais. As funções set_torque_coil_flag e reset_torque_coil_flag permitem configurar o integrador para processar ou não os torques oriundos das bobinas. • int set_torque_coil_flag ();

Esta função habilita o processamento do torque externo gerado por bobinas magnéticas (torque coils), por meio da variável torque_coil_flag. Esta função atribui o valor 1 a esta variável. Pode-se obter a qualquer instante o valor corrente do torque das bobinas por meio da função get_torque_coil_torque. O valor default da variável torque_coil_flag é nulo, isto é, o torque das bobinas inicia-se desabilitado. Adicionalmente esta função cria 3 bobinas, alinhadas aos eixos x, y e z do satélite, com momentos magnéticos de 1 Am2 cada uma. Estas bobinas podem ser posteriormente alteradas pelas funções descritas nesta seção. Parâmetros de entrada: não há Parâmetros de saída:

set_torque_coil_flag valor de retorno nulo.

Exemplo: int ista; ista = set_torque_coil_flag(); • int reset_torque_coil_flag ()

Esta função desabilita o processamento de torque das bobinas pela dinâmica de atitude, e configura o satélite com nenhuma bobina. Esta função atribui o valor 0 para a variável torque_coil_flag. Parâmetros de entrada: não há Parâmetros de saída:

reset_torque_coil_flag valor de retorno nulo.

Exemplo:

25

int ista; ista = set_torque_coil_flag(); ista = reset_torque_coil_flag();

• int get_torque_coil_flag ()

Esta função permite obter o valor atual da variável torque_coil_flag. Esta função não possui argumentos. Parâmetros de entrada: não há Parâmetros de saída:

get_torque_coil_flag valor de retorno: torque_coil_flag

Exemplo: int ista; ista = set_torque_coil_flag(); ista = get_torque_coil_flag(); R: ista = 1

• int set_number_coils (int ncoils);

A função set_number_coils define o número de bobinas presentes no satélite

capazes de gerar torques magnéticos. Esta função deve ser utilizada em conjunto com a função set_coil_magnetic_moment. A variável ncoils é iniciada com valor nulo. Parâmetros de entrada:

ncoils número de bobinas presentes no satélite, passado por valor.

Parâmetros de saída:

set_number_coils valor de retorno: 0 se bem sucedida, ou –1 caso o número de bobinas ultrapasse o valor máximo permitido de 8. Neste caso o valor de ncoils é rejeitado.

Exemplo: int ista; ista = set_torque_coil_flag(); ista = set_number_coils(3);

• int get_number_coils ();

Esta função retorna com o número de bobinas anteriormente especificadas para o

satélite.

Parâmetros de entrada: não há Parâmetros de saída:

get_number_coils

26

número de bobinas presentes. Exemplo: int ista; ista = set_torque_coil_flag(); ista = set_number_coils(3); ista = get_number_coils(); R: ista = 3

• int set_coil_magnetic_moment (int ind_coil, vector3 vec_coil);

A função set_coil_magnetic_moment estabelece a direção, o sentido e o momento

magnético da bobina de número ind_coil. As bobinas são numeradas de 1 até ncoils. O sentido é positivo na direção positiva do momento magnético. O módulo do vetor vec_coils fornece o momento magnético da bobina em Am2, e o versor correspondente (módulo unitário) fornece a direção do eixo da bobina. Parâmetros de entrada:

ind_coil variável contendo o índice de uma dada bobina (de 1 até ncoils), passado por valor.

vec_coil vetor que fornece a direção do eixo e o momento magnético da bobina de número ind_coil, passado por referência.

Parâmetros de saída: set_coil_magnetic_moment

0 se bem sucedida, –1 caso o índice ind_coil esteja fora da faixa permitida (de 1 a ncoils), ou –2 caso o vetor fornecido seja nulo. Nestes casos o vetor é rejeitado.

Exemplo: int ista; vector3 vec1; ista = set_torque_coil_flag(); ista = set_number_coils(3); vec1._1 = 10; vec1._2 = 0; vec1._3 = 0; istat = set_coil_magnetic_moment (1, vec2); vec1._1 = 0; vec1._2 = 10; vec1._3 = 0; istat = set_coil_magnetic_moment (2, vec2); vec1._1 = 0; vec1._2 = 0; vec1._3 = 10; istat = set_coil_magnetic_moment (3, vec2);

• vector3 get_coil_vector (int ind_coil);

A função get_coil_vector obtém o versor da direção positiva do eixo do momento

magnético da bobina de número ind_coil. O versor direção possui sempre módulo unitário.

27

Parâmetros de entrada: ind_coil

variável contendo o índice de uma dada bobina (de 1 até ncoils), passado por valor.

Parâmetros de saída: get_coil_vector

vetor contendo a direção do eixo magnético da bobina de número ind_coil, se bem sucedida, ou um vetor nulo caso este esteja fora da faixa permitida.

Exemplo: int ista; vector3 vec1; ista = set_torque_coil_flag(); ista = set_number_coils(3); vec1._1 = 10 vec1._2 = 0; vec1._3 = 0; istat = set_coil_magnetic_moment (1, vec2); vec1._1 = 0; vec1._2 = 10 vec1._3 = 0; istat = set_coil_magnetic_moment (2, vec2); vec1._1 = 0; vec1._2 = 0; vec1._3 = 10 istat = set_coil_magnetic_moment (3, vec2); vec2 = get_coil_vector(2); R: vec2 = 0, 10, 0

• double get_coil_magnetic_moment (int ind_coil);

A função get_coil_magnetic_moment obtém o momento magnético da bobina de

número ind_coil. O momento magnético neste caso é um escalar, igual ao módulo do vetor vec_coil. Parâmetros de entrada:



get_coil_magnetic_moment

variável de precisão dupla (double) contendo o momento magnético da bobina am Am2, se bem sucedida, ou −1 caso o índice ind_coil esteja fora da faixa permitida.

Exemplo: int ista; vector3 vec1; double coil; ista = set_torque_coil_flag(); ista = set_number_coils(3); vec1._1 = 10; vec1._2 = 0; vec1._3 = 0;

28

istat = set_coil_magnetic_moment (1, vec2); vec1._1 = 0; vec1._2 = 10; vec1._3 = 0; istat = set_coil_magnetic_moment (2, vec2); vec1._1 = 0; vec1._2 = 0; vec1._3 = 10; istat = set_coil_magnetic_moment (3, vec2); coil = get_coil_magnetic_moment(2); R: coil = 10.

• int set_torque_coil_switch_state (int ind_coil, double switch_state);

A função set_torque_coil_switch_state estabelece a polaridade de uma dada

bobina no instante em que a função é invocada. A polaridade, ou estado da bobina, será utilizada nos próximos passos de integração da atitude, até que seja novamente alterada, e desde que a variável torque_coil_flag esteja habilitada. Nota-se que a polaridade só pode ser alterada nos ciclos de integração, isto é, sob a ação do controle. A polaridade deve estar obrigatoriamente compreendida entre –1 e 1. Embora a polaridade possa assumir qualquer valor dentro deste intervalo (significando que a corrente elétrica, e, portanto, o momento e o torque magnético gerado pela bobina é uma fração do máximo permitido), em geral os valores utilizados em sistemas de controle são –1, 0 e 1. O valor 1 significa que o momento magnético gerado é no mesmo sentido da direção do eixo da bobina, –1 é na direção contrária e 0 significa que a bobina encontra-se desligada. O torque gerado pelas bobinas pode ser recuperado a qualquer instante por meio da função get_torque_coil_torque. Parâmetros de entrada:


switch_state estado de ativação (ou de desativação) da bobina de índice ind_coil, passado por valor.

Parâmetros de saída: set_torque_coil_switch_state

0 se bem sucedida, –1 caso torque_coil_flag estiver desabilitado, –2 se ind_coil estiver fora da faixa permitida (de 1 a ncoils), e –3 se a polaridade estiver fora da faixa permitida (–1 a 1). Nestes dois últimos casos o valor do estado da bobina não é utilizado.

Exemplo: int ista; vector3 vec1; ista = set_torque_coil_flag(); ista = set_number_coils(1); vec1._1 = 10; vec1._2 = 0; vec1._3 = 0; istat = set_coil_magnetic_moment (1, vec2); istat = set_torque_coil_switch_state (1, -1);

29

• double get_torque_coil_switch_state (int ind_coil); Esta função retorna com o valor atual do estado de ativação da bobina de número ind_coil, desde que a variável torque_coil_flag esteja habilitada. Parâmetros de entrada: não há Parâmetros de saída: get_torque_coil_switch_state

variável contendo o valor atual da polaridade da bobina de número ind_coil, ou o valor –1 se torque_coil_flag estiver desabilitado, ou ainda –2 caso ind_coil esteja fora da faixa permitida.

Exemplo: int ista; vector3 vec1; double coil; ista = set_torque_coil_flag(); ista = set_number_coils(1); vec1._1 = 10; vec1._2 = 0; vec1._3 = 0; istat = set_coil_magnetic_moment (1, vec2); istat = set_torque_coil_switch_state (1, 0.5); coil = get_torque_coil_switch_state(1); R: coil = 0.5;

• vector3 get_torque_coil_torque ();

Esta função retorna com o valor atual do torque total (Nm) aplicado pelas bobinas, nas direções x, y e z do sistema de coordenadas fixo ao corpo principal do satélite, nas componentes ._1, ._2 ._3, respectivamente, do vetor de retorno. Esta função é utilizada internamente pelo integrador numérico para obter o torque gerado pelas bobinas. O cálculo do torque usa os momentos magnéticos das bobinas, fornecidos pela função set_coil_magnetic_moment, junto com a direção do campo magnético terrestre fornecida pela função set_inertial_geomag_strength (ver Seção 3.10). Parâmetros de entrada: não há Parâmetros de saída: get_torque_coil_torque

vetor contendo o valor atual do torque das bobinas nas direções x, y e z, ou um vetor nulo caso a variável torque_coil_flag esteja desabilitada.

Exemplo: vector3 torq; torq = get_torque_coil_torque();

30

3.3 - Torques externos de propulsores

Propulsores (ou motores foguete, ou motores de jato de gás) são equipamentos que visam gerar impulsos lineares (forças) e conjugados (torques). A força ou o torque gerado pelos propulsores é aproximadamente constante e não controlado, isto é, não se consegue dosar a intensidade da força ou do torque. Porém consegue-se, até certo limite, controlar o tempo de acionamento dos motores, e assim gerar impulsos (produto da força ou torque pelo tempo de acionamento) controlados. O limite é imposto pelo tempo de abertura e fechamento da válvula, de tal forma que, abaixo de um certo intervalo de tempo entre a abertura e o fechamento, a válvula deixa de responder ao comando. Este intervalo mínimo de tempo gera o MIB (“minimum impulse bit” ou impulso mínimo). Em geral o tempo de acionamento de um MIB é menor do que o ciclo de controle, o que significa que deve haver uma eletrônica especial ou uma interface do programa de controle embarcado capaz de comandar a abertura e o fechamento da válvula do propulsor de forma independente do ciclo de controle. Nos propulsores reais o impulso gerado não é proporcional ao tempo de acionamento se o intervalo de tempo entre a abertura e o fechamento for pequeno, ou seja, da ordem da duração do MIB. Porém, para intervalos relativamente longos o impulso é praticamente proporcional ao tempo de acionamento.

Como o controle da abertura e fechamento da válvula é executado por eletrônica

digital, então os intervalos de acionamento são discretos no tempo. Este controle pode ser executado pelo processador central do controle de atitude por meio de uma interface, desde que esta possa contar com intervalos de tempo menores do que o do ciclo de controle. Pode, também, ser executado por eletrônica dedicada, que conte com seu próprio oscilador (“clock”). Uma vez que tentativas de acionamento dos propulsores em intervalos inferiores ao requerido pelo MIB podem comprometer tanto a durabilidade da válvula quanto do leito catalítico (no caso de propulsores à hidrazina), então a eletrônica ou a interface de acionamento deve ignorar comandos que violam a condição de MIB. Isto significa, também, que esta eletrônica dedicada ou a interface deve conhecer o instante de fechamento da válvula antes de comandar a abertura. De fato, procedimentos de segurança que não permitem comandar a abertura sem que o instante de fechamento seja definido são freqüentemente empregados em satélites: se o sistema de comando falhar ou travar durante o intervalo de acionamento, ainda assim garante-se que os propulsores serão desligados no instante correto.

A implementação efetuada para simular o empuxo de propulsores faz aproximações

tanto no impulso quanto na discretização do tempo. A modelagem necessária para a simulação da atitude deve possuir característica de generalidade, e como as não-linearidades do impulso em pequenos intervalos de tempo dependem de detalhes construtivos do propulsor, então, para manter-se a generalidade, adotou-se uma formulação baseada em impulsos proporcionais ao tempo de acionamento, ficando a cargo do programador a verificação do atendimento da condição de MIB, bem como as não-linearidades envolvidas.

O empuxo gerado pela simulação é portanto discreto no tempo, assumindo o valor

máximo se o comando estiver acionado ou um empuxo nulo caso contrário. O instante de acionamento é sempre o instante corrente, ou seja, no início ou fim de um ciclo de integração. O instante associado ao fechamento da válvula é passado para a simulação juntamente com o comando de acionamento, o que permite dosar o impulso em valores inferiores ao do ciclo de integração. Este instante é fornecido por meio de tempo de acionamento time_prop em segundos, e assim o propulsor permanece ligado entre os instantes time e time +

time_prop, e desligado a partir daí. Conseqüentemente, se time_prop for maior do que o

31

ciclo de integração (ver função set_step_time, na Seção 3.7), então o acionamento continua durante todo ou parte do ciclo seguinte. Acionamentos com duração negativa são ignorados.

A discretização dos instantes de acionamento é também efetuada no simulador, uma

vez que se desconhecem quais serão os intervalos de tempo adotados pela eletrônica dedicada ou pela interface. Por outro lado, embora o integrador numérico trabalhe com intervalos discretos de tempo, ainda assim o real valor deste intervalo pode ser desconhecido, porque depende da ordem do integrador utilizado e do fato de se utilizar passo fixo ou variável. Até mesmo nos integradores de passo fixo o passo não é constante. Isto significa que o valor total do impulso irá diferir daquele comandado, pois o propulsor somente é desligado após exceder o tempo de disparo. Caso deseje-se conhecer o real valor do impulso, a função get_thruster_duty_cycle retorna com o intervalo de tempo do último impulso utilizado na integração.

A implementação permite configurar até 16 propulsores no satélite, por meio da

posição, empuxo e direção de cada um. O torque é calculado automaticamente em função da posição do centro de massa, que varia no caso de haver apêndices articulados no satélite. A posição dos propulsores deve ser fornecida com relação ao sistema geométrico do satélite, xoyozo, fixado no centro de massa do corpo principal (ver Seção 3.6). As funções set_thruster_flag e reset_thruster_flag permitem configurar o

integrador para processar ou não os torques oriundos dos propulsores. • int set_thruster_flag ();

Esta função habilita o processamento do torque externo gerado pelos propulsores (thrusters), por meio da variável thruster_flag. Esta função atribui o valor 1 a esta variável. Pode-se obter a qualquer instante o valor corrente do torque dos propulsores por meio da função get_thruster_torque. O valor default da variável thruster_flag é nulo, isto é, o torque dos propulsores inicia-se desabilitado. Parâmetros de entrada: não há Parâmetros de saída:

set_thruster_flag valor de retorno: 0 Exemplo: int ista;

ista = set_thruster_flag();

• int reset_thruster_flag ()

Esta função desabilita o processamento de torque dos propulsores pela dinâmica de atitude. Esta função atribui o valor 0 para a variável thruster_flag. Parâmetros de entrada: não há Parâmetros de saída:

32

reset_thruster_flag

valor de retorno: 0 Exemplo: int ista;

ista = set_thruster_flag(); ista = reset_thruster_flag();

• int get_thruster_flag ()

Esta função permite obter o valor atual da variável thruster_flag. Esta função não possui argumentos. Parâmetros de entrada: não há Parâmetros de saída:

get_thruster_flag retorna com o valor corrente da variável thruster_flag

Exemplo:

int ista; ista = set_thruster_flag(); ista = get_thruster_flag(); R: ista = 1

• int set_number_thrusters (int nthrusters);

A função set_number_thrusters define o número de propulsores presentes no

satélite capazes de gerar forças e torques. Esta função deve ser utilizada em conjunto com a função set_thrusters. A variável nthrusters é iniciada com valor nulo. Parâmetros de entrada:

nthrusters número de propulsores presentes no satélite, passado por valor.


set_number_thrusters valor de retorno: 0 se bem sucedida, ou –1 caso o número de propulsores ultrapasse o valor máximo permitido de 16. Neste caso o valor de nthrusters é rejeitado.

Exemplo:

int ista; ista = set_thruster_flag(); ista = set_number_thrusters(2);

• int get_number_thrusters ();

Esta função retorna com o número de propulsores anteriormente especificados para o

satélite.

33


get_number_thrusters

retorna com o número de propulsores presentes (variável nthrusters). Exemplo:

int ista; ista = set_thruster_flag(); ista = set_number_thrusters(2); ista = get_number_thrusters (); R: ista = 2

• int set_thrusters (int ind_thrtr, vector3 thrtr_pos, vector3

thrtr_thrust);

A função set_thrusters estabelece a posição, a direção, o sentido e o empuxo do

propulsor de número ind_thrtr. Os propulsores são numerados de 1 até nthrusters. A posição do propulsor thrtr_pos descreve o centro de aplicação das forças de pressão geradas durante o acionamento, com relação ao sistema geométrico xoyozo do satélite, fixado no centro de massa do corpo principal (ver Seção 3.6). A direção, o sentido e o empuxo são fornecidos pelo vetor thrtr_thrust. O módulo deste vetor fornece o empuxo em Newtons, e o versor correspondente (módulo unitário) fornece a direção e o sentido da força exercida no satélite pelo propulsor, em coordenadas do sistema geométrico do satélite (corpo principal). O torque é calculado por meio do produto vetorial do empuxo pela posição do propulsor com relação ao centro de massa instantâneo.

Parâmetros de entrada:

ind_thrtr variável contendo o índice de um dado propulsor (de 1 até nthrusters), passado por valor.

thrtr_pos vetor que fornece a posição do centro de aplicação do empuxo do propulsor de número ind_thrtr, passado por referência.

thrtr_thrust vetor que fornece a direção e o valor do empuxo em Newtons do propulsor de número ind_thrtr, com relação ao sistema geométrico do satélite, passado por referência.


set_thrusters retorna com valor 0 se bem sucedida ou –1 caso o índice ind_ thrtr esteja fora da faixa permitida (de 1 a nthrusters). Neste caso o vetor é rejeitado.

Exemplo:

int ista; vector3 vec1, vec2; ista = set_thruster_flag(); ista = set_number_thrusters(2); vec1._1 = 0.4; // Posição vec1._2 = 0.8;

34

vec1._3 = 0.; vec2._1 = -2*0.; // Empuxo vec2._2 = -2*1.; vec2._3 = -2*0; ista = set_thrusters (1, vec1, vec2); vec1._1 = -0.4; // Posição vec1._2 = 0.8; vec1._3 = 0.; ista = set_thrusters (2, vec1, vec2);

• vector3 get_thruster_position (int ind_thrtr);

A função get_thruster_position obtém o versor posição do centro de aplicação do

empuxo do propulsor de número ind_thrtr no sistema geométrico do satélite. Parâmetros de entrada:

ind_thrtr variável contendo o índice do propulsor (de 1 até nthrusters), passado por valor.


get_thruster_position

vetor contendo a posição do centro de empuxo, se bem sucedida, ou um vetor nulo caso ind_thrtr esteja fora da faixa permitida.

Exemplo:

int ista; vector3 vec1, vec2; ista = set_thruster_flag(); ista = set_number_thrusters(2); vec1._1 = 0.4; // Posição vec1._2 = 0.8; vec1._3 = 0.; vec2._1 = -2*0.; // Empuxo vec2._2 = -2*1.; vec2._3 = -2*0; ista = set_thrusters (1, vec1, vec2); vec1._1 = -0.4; // Posição vec1._2 = 0.8; vec1._3 = 0.; ista = set_thrusters (2, vec1, vec2); vec1 = get_thruster_position(1); R: vec1._1 = 0.4, 0.8, 0.

• vector3 get_thruster_vector (int ind_thrtr);

A função get_thruster_vector obtém o versor da direção do empuxo do propulsor

de número ind_thrtr no sistema geométrico do satélite. Este versor possui módulo unitário. Parâmetros de entrada:



35

get_thruster_vector

vetor contendo a direção do empuxo do propulsor (força exercida pelo propulsor), se bem sucedida, ou um vetor nulo caso ind_thrtr esteja fora da faixa permitida.

Exemplo:

int ista; vector3 vec1, vec2; ista = set_thruster_flag(); ista = set_number_thrusters(2); vec1._1 = 0.4; // Posição vec1._2 = 0.8; vec1._3 = 0.; vec2._1 = -2*0.; // Empuxo vec2._2 = -2*1.; vec2._3 = -2*0; ista = set_thrusters (1, vec1, vec2); vec1._1 = -0.4; // Posição vec1._2 = 0.8; vec1._3 = 0.; ista = set_thrusters (2, vec1, vec2); vec1 = get_thruster_vector(1); R: vec1._1 = 0., -1., 0.

• double get_thruster_thrust (int ind_thrtr);

A função get_thruster_vector obtém o empuxo máximo (N) do propulsor de

número ind_thrtr. Este empuxo é obtido pelo módulo de thrtr_thru (ver função set_thrusters). Parâmetros de entrada:



get_thruster_thrust

variável contendo o empuxo do propulsor em Newtons, se bem sucedida, ou –1 caso ind_thrtr esteja fora da faixa permitida.

Exemplo:

int ista; double scale; vector3 vec1, vec2; ista = set_thruster_flag(); ista = set_number_thrusters(2); vec1._1 = 0.4; // Posição vec1._2 = 0.8; vec1._3 = 0.; vec2._1 = -2*0.; // Empuxo vec2._2 = -2*1.; vec2._3 = -2*0; ista = set_thrusters (1, vec1, vec2); vec1._1 = -0.4; // Posição vec1._2 = 0.8; vec1._3 = 0.;

36

ista = set_thrusters (2, vec1, vec2); scale = get_thruster_thrust(1); R: scale = 2

• int set_thruster_duty_cycle (int ind_thrtr, double time_prop);

A função set_thruster_duty_cycle estabelece o tempo de duração de um pulso do

propulsor dado pelo número ind_thrtr. Se a duração do acionamento time_prop for maior do que o intervalo de tempo de um ciclo de integração (dtime na função set_step_time), então o acionamento continua no ciclo seguinte. A real duração do acionamento irá diferir de time_prop porque depende do passo interno de propagação e poderá ser obtida no ciclo posterior ao término do acionamento pela função get_thruster_duty_cycle. Se um propulsor for acionado durante um ciclo em andamento, o valor anterior da duração de acionamento será descartado. Parâmetros de entrada:


time_prop duração do acionamento em segundos, durante o qual será considerado o torque gerado pelo propulsor, passado por valor.


set_thruster_duty_cycle 0 se bem sucedida, –1 se thruster_flag estiver desabilitado, –2 caso o índice ind_thrtr esteja fora da faixa permitida (de 1 a nthrusters), ou –3 se time_prop for negativo. Nestes casos o valor passado é rejeitado.

Exemplo:

int ista; vector3 vec1, vec2; ista = set_thruster_flag(); ista = set_number_thrusters(1); vec1._1 = 0.4; // Posição vec1._2 = 0.8; vec1._3 = 0.; vec2._1 = -2*0.; // Empuxo vec2._2 = -2*1.; vec2._3 = -2*0; ista = set_thrusters (1, vec1, vec2); ista = set_thrusters (1, vec1, vec2); ista = set_thruster_duty_cycle(1, 1.);

• double get_thruster_duty_cycle (int ind_thrtr);

A função get_thruster_duty_cycle obtém a duração real do acionamento do propulsor de número ind_thrtr que foi utilizada na integração. A duração real do acionamento só pode ser obtida no ciclo posterior ao término do acionamento, caso contrário o valor corresponderá à duração utilizada até o instante corrente. A duração efetiva do acionamento será sempre maior ou igual à duração especificada. Parâmetros de entrada:

37



get_thruster_duty_cycle intervalo real do tempo de acionamento do propulsor utilizado na integração, se bem sucedida, –1 se thruster_flag estiver desabilitado, ou –2 caso o índice ind_thrtr esteja fora da faixa permitida (de 1 a nthrusters).

Exemplo:

int ista; double scale; vector3 vec1, vec2; ista = set_thruster_flag(); ista = set_number_thrusters(1); vec1._1 = 0.4; // Posição vec1._2 = 0.8; vec1._3 = 0.; vec2._1 = -2*0.; // Empuxo vec2._2 = -2*1.; vec2._3 = -2*0; ista = set_thrusters (1, vec1, vec2); ista = set_thrusters (1, vec1, vec2); ista = set_thruster_duty_cycle(1, 1.); scale = get_thruster_duty_cycle(1); R: scale = 1.

• vector3 get_thruster_torque ();

A função get_thruster_torque retorna com o torque (Nm) dos propulsores no

instante corrente, relativo ao centro de massa atual do satélite, nas direções x, y e z do sistema de coordenadas fixo ao corpo principal do satélite, nas componentes ._1, ._2 ._3, respectivamente, do vetor de retorno. Se frac_prop for menor do que a unidade, então o valor do torque será nulo ao término do ciclo de integração. Parâmetros de entrada:


get_thruster_torque

vetor contendo o valor atual do torque dos propulsores nas direções x, y e z, ou um vetor nulo caso a variável torque_coil_flag esteja desabilitada.

Exemplo:

int ista; double scale; vector3 vec1, vec2; ista = set_thruster_flag(); ista = set_number_thrusters(1); vec1._1 = 0.4; // Posição vec1._2 = 0.8; vec1._3 = 0.; vec2._1 = -2*0.; // Empuxo

38

vec2._2 = -2*1.; vec2._3 = -2*0; ista = set_thrusters (1, vec1, vec2); ista = set_thrusters (1, vec1, vec2); ista = set_thruster_duty_cycle(1, 1.); ista = get_thruster_torque(1);

3.4 - Torques internos em rodas de reação

O fornecimento do torque de controle por meio de rodas de reação é diferente dos torques de controle mencionados na seção anterior, em virtude da possibilidade de se instalar várias rodas (tipicamente de 1 a 4) em satélites. Torna-se necessário, portanto, fornecer as direções dos eixos de rotação das diversas rodas presentes, além do torque em cada uma delas. Limitou-se, por motivos de requisitos de programação, a um máximo de 8 rodas no satélite. As funções, set_wheel_torque_flag e reset_wheel_torque_flag, permitem configurar o integrador para processar ou não os torques provindos das rodas. Diferentemente dos torques de controle, não se recomenda modificar este valor uma vez iniciada a integração da atitude, pois o número de variáveis a serem integradas depende do número de rodas. O integrador pode gerar resultados não esperados caso as rodas sejam repentinamente retiradas da integração. • int set_wheel_torque_flag ()

Esta função habilita o processamento do torque interno de controle com rodas de reação ou volantes de inércia pela dinâmica de atitude, por meio da variável wheel_torque_flag. Esta função atribui o valor 1 a esta variável. O valor do torque de controle é definido pela função set_wheel_torque. Pode-se obter a qualquer instante o valor corrente do torque de controle por meio da função get_wheel_torque. Torques internos são aqueles que não alteram o momento angular do satélite, e necessitam a integração do momento angular das rodas. O valor default da variável wheel_torque_flag é nulo, isto é, o torque de controle das rodas inicia-se desabilitado. Adicionalmente esta função cria 3 rodas de reação, alinhadas aos eixos x, y e z do satélite, com momento de inércia de 1 kg m2 cada uma, e todas elas com velocidade angular inicial nula. Estas rodas podem ser posteriormente alteradas pelas funções descritas nesta seção. Parâmetros de entrada:


set_wheel_torque_flag

valor de retorno: 0 Exemplo:

set_wheel_torque_flag();

• int reset_wheel_torque_flag ();

Esta função desabilita o processamento de torque de controle com rodas pela dinâmica de atitude, e configura o satélite com nenhuma roda. Esta função atribui o valor 0 para a variável wheel_torque_flag.

39

Parâmetros de entrada: não há


reset_wheel_torque_flag


int ista; ista = reset_wheel_torque_flag ();

• int get_wheel_torque_flag ();

Esta função permite obter o valor atual da variável wheel_torque_flag. Esta função não possui argumentos. Parâmetros de entrada:


get_wheel_torque_flag


int ista; ista = set_wheel_torque_flag (); ista = get_wheel_torque_flag (); R: ista = 1

• int set_number_wheels (int nwheels);

A função set_number_wheels define o número de rodas presentes no satélite capazes

de gerar torques internos. Esta função deve ser utilizada em conjunto com as funções set_wheel_vector e set_wheel_torque. A variável nwheels é iniciada com valor nulo. Parâmetros de entrada:

nwheels número de rodas presentes no satélite, passado por valor.


set_number_wheels

valor de retorno: 0 se bem sucedida, ou –1 caso o número de rodas ultrapasse o valor máximo permitido de 8. Neste caso o valor de nwheels é rejeitado.

Exemplo:

int ista; ista = set_wheel_torque_flag (); ista = set_number_wheels (3);

• int get_number_wheels ();

40

Esta função retorna com o número de rodas de reação anteriormente especificadas para o satélite. Parâmetros de entrada:


get_number_wheels número de rodas presentes.

Exemplo:

int ista; ista = set_wheel_torque_flag (); ista = set_number_wheels (3); ista = get_number_wheels (3); R: ista = 3

• int set_wheel_vector (int ind_wheel, vector3 vec_wheel);

A função set_wheel_vector estabelece a inércia (direção do eixo de torque ou de

rotação e o momento de inércia) da roda de número ind_wheel. As rodas devem ser enumeradas, com este índice variando de 1 até nwheels. A direção é positiva no sentido positivo do torque. O módulo do vetor vec_wheel fornece o momento de inércia da roda na direção do eixo de rotação (em kg m2), e o versor correspondente (módulo unitário) fornece a direção do eixo de rotação. Parâmetros de entrada:

ind_wheel variável contendo o índice de uma dada roda (de 1 até nwheels), passado por valor.

vec_wheel vetor que fornece a direção do eixo de rotação e o momento de inércia da roda de número ind_wheel, passado por referência.


set_wheel_vector

0 se bem sucedida, –1 caso o índice ind_wheel esteja fora da faixa permitida (de 1 a nwheels), ou –2 caso o vetor fornecido seja nulo. Nestes casos o vetor é rejeitado.

Exemplo:

int ista; vector3 dir_w = 0.02, 0., 0.; ista = set_wheel_torque_flag (); ista = set_number_wheels (3); ista = set_wheel_vector (1, dir_w);

• vector3 get_wheel_vector (int ind_wheel);

A função get_wheel_vector obtém o versor direção do eixo de torque da roda de

número ind_wheel. O versor direção possui sempre módulo unitário.

41

Parâmetros de entrada: ind_wheel

variável contendo o índice de uma dada roda (de 1 até nwheels), passado por valor.


get_wheel_vector

vetor contendo a direção do eixo de rotação da roda de número ind_wheel, se bem sucedida, ou um vetor nulo caso o índice ind_wheel esteja fora da faixa permitida.

Exemplo:

int ista; vector3 vec_wheel, dir_w = 0.02, 0., 0.; ista = set_wheel_torque_flag (); ista = set_number_wheels (3); ista = set_wheel_vector (1, dir_w); vec_wheel = get_wheel_vector (1); R: vec_wheel = 1, 0, 0

• double get_wheel_inertia (int ind_wheel);

A função get_wheel_inertia obtém o momento de inércia do rotor da roda de

número ind_wheel. O momento de inércia da roda é calculado com base no módulo do vetor direção do eixo de rotação fornecido pela função set_wheel_vector. Parâmetros de entrada:



get_wheel_inertia

variável de precisão dupla (double) contendo o momento de inércia da roda com relação ao eixo de rotação, se bem sucedida, ou um valor nulo caso o índice ind_wheel esteja fora da faixa permitida.

Exemplo:

int ista; vector3 dir_w = 0.02, 0., 0.; double wheel_m; ista = set_wheel_torque_flag (); ista = set_number_wheels (3); ista = set_wheel_vector (1, dir_w); wheel_m = get_wheel_inertia (1); R: wheel_m = 0.02

• int set_wheel_torque (int ind_wheel, double torw);

A função set_wheel_torque estabelece o torque (Nm) aplicado na roda de reação de

número ind_wheel. Este torque será utilizado nos próximos ciclos de integração da atitude, até que seja novamente alterado, e desde que a variável wheel_torque_flag

42

(set_wheel_torque_flag) esteja habilitada. Esta função usa as direções dos eixos das rodas, fornecida pela função set_wheel_vector, junto com o torque torw em cada uma das rodas presentes, para compor o torque nos eixos cartesianos x, y e z. O torque pode ser recuperado a qualquer instante por meio das funções get_wheel_torque_xyz ou get_wheel_torque. Parâmetros de entrada:


torw torque aplicado na roda de índice ind_wheel, passado por valor.


set_wheel_torque

0 se bem sucedida, -1 caso wheel_torque_flag estiver desabilitado, -2 se ind_wheel estiver fora da faixa permitida (de 1 a nwheels). Nestes dois últimos casos o valor do torque não é utilizado.

Exemplo:

int ista; vector3 dir_w = 0.02, 0., 0.; double wheel_m; ista = set_wheel_torque_flag (); ista = set_number_wheels (3); ista = set_wheel_vector (1, dir_w); ista = set_wheel_torque (1, 0.0001);

• double get_wheel_torque (int ind_wheel);

Esta função retorna com o valor atual do torque (Nm) aplicado na roda de reação de número ind_wheel, desde que a variável wheel_torque_flag esteja habilitada. Parâmetros de entrada:


Parâmetros de saída: get_wheel_torque

variável contendo o valor atual do torque na roda de número ind_wheel, ou o valor –1 se wheel_torque_flag estiver desabilitado, ou ainda –2 caso ind_wheel esteja fora da faixa permitida.

Exemplo:

int ista; vector3 dir_w = 0.02, 0., 0.; double wheel_t; ista = set_wheel_torque_flag (); ista = set_number_wheels (3); ista = set_wheel_vector (1, dir_w); ista = set_wheel_torque (1, 0.0001); wheel_t = get_wheel_torque (1); R:

43

wheel_t = 0.0001

• vector3 get_wheel_torque_xyz ();

Esta função retorna com o valor atual do torque (Nm) aplicado pelas rodas de reação, nas direções x, y e z do sistema de coordenadas fixado ao corpo principal do satélite, nas componentes ._1, ._2 ._3, respectivamente, do vetor de retorno. Parâmetros de entrada:

não há Parâmetros de saída: get_wheel_torque_xyz

vetor contendo o valor atual do torque nas rodas nas direções x, y e z, ou um vetor nulo caso a variável wheel_torque_flag esteja desabilitada.

Exemplo:

int ista; vector3 dir_w = 0.02, 0., 0.; vector3 wheel_t; ista = set_wheel_torque_flag (); ista = set_number_wheels (3); ista = set_wheel_vector (1, dir_w); ista = set_wheel_torque (1, 0.0001); wheel_t = get_wheel_torque_xyz (); R: wheel_t = 0.0001, 0, 0

• int set_wheel_momentum (int ind_wheel, double hw);

A função set_wheel_momentum estabelece o momento angular (Nms) inicial (ou seja,

no início da propagação da atitude) da roda de reação de número ind_wheel. Não se deve alterar o valor do momento angular uma vez iniciada a propagação, porque poderia levar o integrador numérico a erros. O momento angular atual pode ser recuperado em qualquer instante por meio das funções get_wheel_momentum ou get_wheel_speed. Parâmetros de entrada:


hw

momento angular inicial da roda de índice ind_wheel, passado por valor. Parâmetros de saída:

set_wheel_momentum

0 se bem sucedida, -1 caso wheel_torque_flag estiver desabilitado, -2 se ind_wheel estiver fora da faixa permitida (de 1 a nwheels). Nestes dois últimos casos o valor do momento angular não é utilizado.

Exemplo:

int ista; vector3 dir_w = 0.02, 0., 0.; vector3 wheel_t;

44

ista = set_wheel_torque_flag (); ista = set_number_wheels (3); ista = set_wheel_vector (1, dir_w); ista = set_wheel_momentum (1, 3.0);

• double get_wheel_momentum (int ind_wheel);

Esta função retorna com o valor atual do momento angular (Nms) da roda de reação de número ind_wheel, em relação ao corpo do satélite, e desde que a variável wheel_torque_flag esteja habilitada. Parâmetros de entrada:


Parâmetros de saída: get_wheel_momentum

variável contendo o valor atual do momento angular da roda de número ind_wheel, ou o valor –1 se wheel_torque_flag estiver desabilitado, ou ainda –2 caso ind_wheel esteja fora da faixa permitida.

Exemplo:

int ista; vector3 dir_w = 0.02, 0., 0.; double wheel_m; ista = set_wheel_torque_flag (); ista = set_number_wheels (3); ista = set_wheel_vector (1, dir_w); ista = set_wheel_momentum (1, 3.0); wheel_m = get_wheel_momentum (1); R: wheel_m = 3

• vector3 get_wheel_momentum_xyz ();

Esta função retorna com o valor atual do momento angular (Nms) armazenado nas rodas, no sistema de coordenadas do corpo do satélite, e desde que a variável wheel_torque_flag esteja habilitada. Parâmetros de entrada:

não há Parâmetros de saída: get_wheel_momentum_xyz

variável contendo o valor atual do momento angular de todas as rodas, no sistema do satélite, ou um vetor nulo se wheel_torque_flag estiver desabilitado.

Exemplo:

int ista; vector3 h_w, dir_w = 0.02, 0., 0.; ista = set_wheel_torque_flag (); ista = set_number_wheels (3);

45

ista = set_wheel_vector (1, dir_w); ista = set_wheel_momentum (1, 3.0); h_w = get_wheel_momentum_xyz (); R: h_w = 3, 0, 0

• double get_wheel_speed (int ind_wheel);

Esta função retorna com o valor atual da velocidade angular (rd/s) da roda de reação de número ind_wheel, desde que a variável wheel_torque_flag esteja habilitada. A velocidade angular é calculada pela relação entre o momento angular e o momento de inércia da roda. Parâmetros de entrada:


Parâmetros de saída: get_wheel_speed

variável contendo o valor atual da velocidade angular da roda de número ind_wheel, ou o valor –1 se wheel_torque_flag estiver desabilitado, ou ainda –2 caso ind_wheel esteja fora da faixa permitida.

Exemplo:

int ista; vector3 dir_w = 0.02, 0., 0.; double wheel_s; ista = set_wheel_torque_flag (); ista = set_number_wheels (3); ista = set_wheel_vector (1, dir_w); ista = set_wheel_momentum (1, 3.0); wheel_s = get_wheel_speed (1); R: wheel_s = 150

3.5 - Torques internos em amortecedores de nutação

Amortecedores de nutação passivos são elementos fixados ao satélite que dissipam energia cinética rotacional associada a velocidades angulares em eixos perpendiculares ao eixo de maior inércia. Embora existam amortecedores de nutação magnéticos, cujo princípio de funcionamento é a dissipação de energia por meio de histerese magnética, os mais comuns são aqueles compostos por uma pequena massa vinculada ao satélite por meio de um elemento flexível. Tem-se, assim, sistemas massa-mola, massa imersa em um fluido, e um fluido que preenche parcialmente um tubo, entre outros. Em todos eles, há um elemento de massa (contrapeso) cuja posição varia com relação ao satélite em função da magnitude das velocidades angulares transversais. Isto significa que a dinâmica apresenta agora graus de liberdade adicionais, que dependem do tipo de amortecedor utilizado. Considerando a impossibilidade de implementar diversos modelos de amortecedores, adotou-se aqui uma generalização do efeito do amortecedor. Supõe-se, a princípio, que o deslocamento do contrapeso seja incapaz de introduzir modificações na matriz de inércia e no centro de massa do satélite. Admite-se, ainda, que o amortecedor ou amortecedores sejam orientados, isto é, consigam dissipar energia apenas quando o movimento angular se dá numa dada direção. Este

46

é o caso do amortecedor do tipo massa imersa em um fluído, porém os demais conseguem dissipar a energia também em outra direção. Amortecedores direcionais não são restringentes, pois a nutação faz com que a velocidade angular transversal mude de direção, e portanto sempre haverá uma componente desta velocidade na direção de dissipação do amortecedor. Caso o satélite apresente um amortecedor capaz de dissipar energia em duas direções, então bastará selecionar na dinâmica de atitude dois amortecedores direcionais. Não se deve esquecer que a massa e a inércia do elemento móvel do amortecedor deverão ser incorporadas ao satélite.

Posto desta forma, o modelo de um amortecedor será tão somente um elemento que

produz um torque no satélite em função da velocidade angular transversal. 3.6 - Propriedades do satélite Estas funções permitem definir características do satélite tais como massa e momentos de inércia. Cumpre salientar que o satélite pode ser tratado como um único corpo rígido ou como composto por vários apêndices articulados – cada um deles é um corpo rígido. As funções descritas aqui permitem configurar um satélite com até 8 apêndices rígidos e articulados ao corpo principal do satélite. Não permite, contudo uma cadeia de articulações na qual um apêndice articula-se a outro.

Para compor o movimento do apêndice, é necessário estabelecer uma correspondência

entre o sistema de coordenadas do corpo principal do satélite e o sistema de coordenadas do apêndice. Este movimento depende da posição e da orientação da junta de articulação, bem como da localização do centro de massa de cada apêndice e também dos momentos de inércia individuais. Utiliza-se nesta descrição a notação de Denavit-Hartemberg, derivada de manipuladores robóticos. Para cada apêndice são necessários 10 parâmetros (denominados de parâmetros de Denavit-Hartemberg) sendo 5 métricos e 5 angulares, além da variável angular que varia com o tempo.

Para obter os parâmetros de Denavit-Hartenberg para o apêndice k, considera-se os sistemas de eixos mostrados na Figura 3.2. O sistema xoyozo é o sistema geométrico de coordenadas, fixado no corpo principal do satélite, cuja origem passa pelo seu centro de massa (não inclui a massa dos apêndices). O sistema xkykzk é fixado no centro de massa do apêndice k. O sistema xjyjzj é fixado num determinado ponto da junta que gira o apêndice k. O sistema xnynzn é tal que seu eixo zn coincide com o eixo zk. Inicialmente determina-se a reta mutuamente perpendicular aos eixos zo e zj, e entre os eixos zj e zk. Se um destes eixos for paralelo ao outro, então adota-se qualquer reta mutuamente perpendicular. A distância entre os eixos zs é conhecida como comprimento do elo e vale a0 e a1, respectivamente. Os eixos x

j e xn são obtidos como prolongamentos dos comprimentos dos elos, no sentido do eixo zo para zj, e de zj para zk. As distâncias d0, d1 e d2 constituem os deslocamentos das juntas, e são positivas se medidas na direção positiva do eixo z correspondente. Projetando-se a direção de xj no plano formado por xo e yo, obtém-se o ângulo de rotação da junta θ0, medido entre xo e a projeção de xj. O mesmo raciocínio permite que sejam obtidos os ângulos θ1 e θ2. Estes ângulos são positivos se orientados segundo a regra da mão direita no sentido positivo do eixo z correspondente. Nota-se que θ1 irá fornecer o ângulo de rotação da junta na situação inicial, na qual o ângulo θ(t) = θ(0) = 0. Finalmente, os ângulos de torção ti são medidos entre as projeções dos eixos z anteriores nos planos yz dos sistemas posteriores e são positivos se, ao passar do eixo anterior ao posterior, seguirem a regra da mão direita no sentido positivo do eixo x. Assim, t0 mede o ângulo entre z

o e zj, e t1 mede o ângulo entre zj e zk. Veja-se que o

47

ângulo t0 é negativo na Figura 2. Tem-se, ao todo, dez elementos escalares para cada junta: θ0, d0, a0, t0, θ1, d1, a1, t1, θ2 e d2, que permitem que sejam obtidos os parâmetros necessários na dinâmica de atitude.

zo zj

zk

yj

xk

xj

yk

θ1+θ(t)

d1

a1

d0

t1

a0

θ0

t0

xo

yo θ2

d2

xn

zn yn

Fig 3.2 – Sistemas de coordenadas do corpo principal, da junta e do apêndice k.

• int set_sat_inertia (matrix3 sat_inert);

Esta função permite definir a matriz de inércia de um satélite sem apêndices (kg m2), ou a matriz de inércia do corpo principal. A matriz de inércia é dada por: | sat_inert._1._1 sat_inert._1._2 sat_inert._1._3 | sat_inert = | sat_inert._2._1 sat_inert._2._2 sat_inert._2._3 | | sat_inert._3._1 sat_inert._3._2 sat_inert._3._3 |

A variável sat_inert é uma estrutura do tipo matrix3, passada por referência. Esta função calcula internamente a inversa da matriz de inércia, para ser usada pela dinâmica de atitude. Se o satélite possuir apêndices articulados (ver seção sobre apêndices articulados), então a matriz de inércia deve referir-se apenas ao corpo principal do satélite. Parâmetros de entrada:

sat_inert Parâmetros de saída:

set_sat_inertia valor de retorno: 0 .

Exemplo: matrix3 iner; int istat; iner._1._1 = 10; iner._1._2 = 0; iner._1._3 = 0; iner._2._1 = 0; iner._2._2 = 15;

48

iner._2._3 = 0; iner._3._1 = 0; iner._3._2 = 0; iner._3._3 = 20; istat = set_sat_inertia (iner);

• matrix3 get_sat_inertia ();

Esta função retorna com a matriz de inércia do satélite (ou do corpo principal),

originalmente definida pela função set_sat_inertia. No caso do satélite possuir apêndices articulados, esta função retorna com o a matriz de inércia do corpo principal. Parâmetros de entrada:


get_sat_inertia

matriz de inércia do satélite, ou do corpo principal do satélite Exemplo:

matrix3 iner, test; int istat; iner._1._1 = 10; iner._1._2 = 0; iner._1._3 = 0; iner._2._1 = 0; iner._2._2 = 15; iner._2._3 = 0; iner._3._1 = 0; iner._3._2 = 0; iner._3._3 = 20; istat = set_sat_inertia (iner); test = get_sat_inertia (); R: test = 10, 0, 0, 0, 15, 0, 0, 0, 20

• int set_sat_mass (double mass);

A função set_sat_mass define a massa do corpo principal do satélite. Esta massa será utilizada somente quando o satélite possuir apêndices articulados (painéis solares). Parâmetros de entrada:

mass

variável contendo a massa em kg do corpo principal do satélite, passada por valor.


set_sat_mass valor de retorno: 0 .

Exemplo: istat = set_sat_mass (220);

• double get_sat_mass ();

49

A função get_sat_mass retorna com a massa do corpo principal do satélite previamente definida pela função set_sat_mass, no caso de não haver apêndices articulados, ou então a massa total no caso de haver apêndices. Parâmetros de entrada:


get_sat_mass

massa do corpo principal do satélite em kg. Exemplo: int istat; double auxi; istat = set_sat_mass (220); auxi = get_sat_mass (); R: auxi = 220

• int set_number_bodies (int n_body);

A função set_number_bodies permite configurar o número de apêndices articulados presentes no satélite. O número máximo de apêndices está limitado a 8 na presente versão. Parâmetros de entrada:

n_body

variável contendo o número de apêndices articulados do satélite, passado por valor.


set_number_bodies valor de retorno: 0 .

Exemplo: int istat; istat = set_number_bodies(1);

• int get_number_bodies ();

A função get_number_bodies recupera o número o número de apêndices articulados presentes no satélite, definido por meio da função set_number_bodies. Parâmetros de entrada:


n_body

variável contendo o número de apêndices articulados do satélite, passado por valor.

Exemplo: int istat; istat = set_number_bodies(1);

50

istat = get_number_bodies(); R: istat = 1

• int set_body_k (int k, double b_mass, matrix3 b_iner, double dh0[4],

double dh1[4], double dh2[4]);

A função set_body_k define a configuração do apêndice k com relação ao corpo principal do satélite. Os apêndices são numerados de 1 a n_body. Parâmetros de entrada: k

variável contendo o índice do apêndice (de 1 até n_body), passado por valor. b_mass

variável contendo a massa articulada do apêndice (isto é, a massa de todos os componentes que se movem solidários ao apêndice), passada por valor.

b_iner

matriz contendo a matriz de inércia do apêndice, incluindo todos os componentes que se movem solidários a ele, passada por referência. Esta matriz é fornecida com relação ao sistema k geométrico do apêndice, fixado ao seu centro de massa.

dh0

vetor de 4 posições contendo as variáveis de Denavit-Hartenberg entre o sistema geométrico do corpo principal, fixado ao centro de massa do corpo principal, e o sistema de coordenadas da junta j. Estas variáveis são: θ0 (dh0[0]): ângulo de rotação da junta inicial, em graus. d0 (dh0[1]): deslocamento da junta, em metros. a0 (dh0[2]): comprimento do elo, em metros. t0 (dh0[3]): ângulo de torção da junta, em graus.

dh1

vetor de 4 posições contendo as variáveis de Denavit-Hartenberg entre o sistema de coordenadas da junta j e o sistema de coordenadas n. As variáveis seguem a mesma estrutura de dh0.

dh2

vetor de 2 posições contendo as variáveis de Denavit-Hartenberg entre o sistema de coordenadas n e o sistema de coordenadas do apêndice k. Neste caso são necessárias apenas duas variáveis: θ2 (dh2[0]): ângulo de rotação entre os sistemas, em graus. d2 (dh2[1]): deslocamento entre as origens em metros.


set_body_k 0, se bem sucedida, ou –1 caso o índice do apêndice esteja fora da faixa permitida (1 a n_body).

Exemplo: int istat; matrix3 b_iner; double dh0[4], dh1[4], dh2[4]; b_iner._1._1 = 2.25; b_iner._1._2 = 0; b_iner._1._3 = 0; b_iner._2._1 = 0;

51

b_iner._2._2 = 0.65; b_iner._2._3 = 0; b_iner._3._1 = 0; b_iner._3._2 = 0; b_iner._3._3 = 1.15;

dh0[0] = 0.; dh0[1] = 0.6; dh0[2] = 0.1; dh0[3] = -90; dh1[0] = 0.; dh1[1] = 2.1; dh1[2] = 0.; dh1[3] = 90; dh2[0] = 0.; dh2[1] = 0.05; istat = set_number_bodies(1);

istat = set_body_k (1, 8.5, b_iner, dh0, dh1, dh2);

• int set_body_accel (int k, double ack);

Esta função estabelece a aceleração de cada apêndice, ou seja, a segunda derivada temporal do ângulo do apêndice com relação ao corpo principal do satélite. A aceleração é admitida como constante durante um ciclo de integração (passo externo), e integrada analiticamente. Parâmetros de entrada:

k

índice do apêndice, limitado entre a faixa 0 a n_body, passado por valor. ack

variável contendo a aceleração (rd/s2) do apêndice k, passado por valor. Parâmetros de saída:

set_body_accel valor de retorno: 0, se bem sucedida ou –1 caso o índice k esteja fora da faixa permitida.

Exemplo: int istat;

ack = 0.01; istat = set_body_accel(1, ack);

• int set_body_pos (int k, double b_angl, double b_vel);

A função set_body_pos configura o ângulo e a velocidade angular inicial de cada apêndice, para ser posteriormente propagada pelo integrador numérico. Parâmetros de entrada:

k

índice do apêndice, limitado entre a faixa 0 a n_body, passado por valor. b_angl

ângulo de posição inicial do apêndice k (radianos), passado por valor. b_vel

velocidade angular (rd/s) inicial do apêndice k, passada por valor. Parâmetros de saída:

52

set_body_pos 0, se bem sucedida, ou –1 caso o índice do apêndice esteja fora da faixa permitida (1 a n_body).

Exemplo: int istat; matrix3 b_iner; double dh0[4], dh1[4], dh2[4]; b_iner._1._1 = 2.25; b_iner._1._2 = 0; b_iner._1._3 = 0; b_iner._2._1 = 0; b_iner._2._2 = 0.65; b_iner._2._3 = 0; b_iner._3._1 = 0; b_iner._3._2 = 0; b_iner._3._3 = 1.15;


istat = set_body_k (1, 8.5, b_iner, dh0, dh1, dh2); istat = set_body_pos (1, PI_D2, 0);

• matrix3 get_body_rmatrix (int k);

Esta função permite recuperar a matriz de rotação atual que relaciona o sistema do corpo principal com o sistema do apêndice. Um vetor no sistema do apêndice pode ser expresso no sistema do corpo principal multiplicando-se a matriz de rotação por este vetor. Esta função leva em conta o ângulo de rotação atual do apêndice, isto é, o ângulo provindo da integração da aceleração. Parâmetros de entrada:

k

índice do apêndice, limitado entre a faixa 0 a n_body, passado por valor. Parâmetros de saída:

get_body_rmatrix

matriz de rotação que leva um vetor expresso no sistema do apêndice ao sistema do corpo principal, ou uma matriz nula se k estiver fora da faixa permitida.

Exemplo: int istat; matrix3 b_iner, test; double dh0[4], dh1[4], dh2[4]; b_iner._1._1 = 2.25; b_iner._1._2 = 0; b_iner._1._3 = 0;

53

b_iner._2._1 = 0; b_iner._2._2 = 0.65; b_iner._2._3 = 0; b_iner._3._1 = 0; b_iner._3._2 = 0; b_iner._3._3 = 1.15;


istat = set_body_k (1, 8.5, b_iner, dh0, dh1, dh2); istat = set_body_pos (1, PI_D2, 0); test = get_body_rmatrix (1); R: test = 0, 0, 1, 0, 1, 0, -1, 0, 0

• vector3 get_body_ovect (int k);

Esta função obtém o vetor posição da origem do sistema do apêndice k expresso no sistema do corpo principal. Esta função leva em conta o ângulo de rotação atual do apêndice, isto é, o ângulo provindo da integração da aceleração. Parâmetros de entrada:

k


get_body_ovect

vetor posição da origem do sistema k em relação ao sistema do corpo principal, ou um vetor nulo caso k esteja fora da faixa permitida.

Exemplo: int istat; matrix3 b_iner, test; double dh0[4], dh1[4], dh2[4]; b_iner._1._1 = 2.25; b_iner._1._2 = 0; b_iner._1._3 = 0; b_iner._2._1 = 0; b_iner._2._2 = 0.65; b_iner._2._3 = 0; b_iner._3._1 = 0; b_iner._3._2 = 0; b_iner._3._3 = 1.15;

dh0[0] = 0.; dh0[1] = 0.6; dh0[2] = 0.1; dh0[3] = -90; dh1[0] = 0.; dh1[1] = 2.1; dh1[2] = 0.;

54

dh1[3] = 90; dh2[0] = 0.; dh2[1] = 0.05; istat = set_number_bodies(1);

istat = set_body_k (1, 8.5, b_iner, dh0, dh1, dh2); istat = set_body_pos (1, PI_D2, 0); vec1 = get_body_ovect (1); R: vec1 = 0.15, 2.1, 0.6

• double get_body_pos (int k);

A função get_body_pos retorna com o ângulo atual do apêndice k. Parâmetros de entrada:

k


get_body_pos

ângulo atual (rd) do apêndice k, ou –1 caso k esteja fora da faixa permitida. Exemplo: int istat; matrix3 b_iner, test; double auxi, dh0[4], dh1[4], dh2[4]; b_iner._1._1 = 2.25; b_iner._1._2 = 0; b_iner._1._3 = 0; b_iner._2._1 = 0; b_iner._2._2 = 0.65; b_iner._2._3 = 0; b_iner._3._1 = 0; b_iner._3._2 = 0; b_iner._3._3 = 1.15;


istat = set_body_k (1, 8.5, b_iner, dh0, dh1, dh2); istat = set_body_pos (1, PI_D2, 0); auxi = get_body_pos (1); R: auxi = 1.5707963267949 (PI_D2)

• double get_body_vel (int k);

A função get_body_vel retorna com a velocidade atual do apêndice k. Parâmetros de entrada:

55

k


get_body_vel

velocidade angular atual (rd/s) do apêndice k, ou –1 caso k esteja fora da faixa permitida.

Exemplo: int istat; matrix3 b_iner, test; double auxi, dh0[4], dh1[4], dh2[4]; b_iner._1._1 = 2.25; b_iner._1._2 = 0; b_iner._1._3 = 0; b_iner._2._1 = 0; b_iner._2._2 = 0.65; b_iner._2._3 = 0; b_iner._3._1 = 0; b_iner._3._2 = 0; b_iner._3._3 = 1.15;


istat = set_body_k (1, 8.5, b_iner, dh0, dh1, dh2); istat = set_body_pos (1, PI_D2, 0.1234); auxi = get_body_vel (1); R: auxi = 0.1234

• vector3 get_sat_center_mass (void);

A função get_sat_center_mass retorna com a posição do centro de massa do satélite relativo ao sistema geométrico do satélite cuja origem coincide com o centro de massa do corpo principal. Neste sistema, o centro de massa de um satélite composto unicamente pelo corpo principal consiste em um vetor nulo. Parâmetros de entrada:


get_sat_center_mass

posição do centro de massa do satélite, em metros, ou um vetor nulo se o satélite for composto unicamente pelo corpo principal.

Exemplo:

int istat; matrix3 b_iner, test;

56

double dh0[4], dh1[4], dh2[4]; b_iner._1._1 = 2.25; b_iner._1._2 = 0; b_iner._1._3 = 0; b_iner._2._1 = 0; b_iner._2._2 = 0.65; b_iner._2._3 = 0; b_iner._3._1 = 0; b_iner._3._2 = 0; b_iner._3._3 = 1.15;

dh0[0] = 0.; dh0[1] = 0.6; dh0[2] = 0.1; dh0[3] = -90; dh1[0] = 0.; dh1[1] = 2.1; dh1[2] = 0.; dh1[3] = 90; dh2[0] = 0.; dh2[1] = 0.05; istat = set_sat_mass (220);

istat = set_number_bodies(1); istat = set_body_k (1, 8.5, b_iner, dh0, dh1, dh2); istat = set_body_pos (1, PI_D2, 0); vec1 = get_sat_center_mass (); R: vec1 = 0.0055799, 0.0781182, 0.0223195

3.7 - Parâmetros do integrador de atitude As funções do propagador de atitude servem para definir e configurar o integrador numérico de atitude. Entre as propriedades que são ajustáveis cita-se a escolha do integrador e método de integração, precisão numérica do integrador, o passo, o ciclo e o período de integração, além de outros parâmetros como a duração do ciclo de integração e instantes de tempo corrente.

• int select_integ_method (int inttyp, int intmet);

Esta função seleciona qual o integrador a ser utilizado, e também seleciona se a

integração numérica será efetuada em passo fixo ou variável. Parâmetros de entrada: intmet

variável com a seleção do integrador, passada por valor. Os valores possíveis para esta variável são: • INTEG_RKF_4 ou 0: seleciona o integrador de passo fixo Runge-Kutta 4.

Neste caso os valores do erro absoluto e relativo (ver função set_integ_precision) serão ignorados.

• INTEG_RKF_24 ou 1: seleciona o integrador Runge-Kutta 2/4 de passo fixo ou variável. A seleção de passo fixo é feita com o parâmetro intmet igual a INTEG_FIX. A seleção de passo variável é feita com o parâmetro intmet igual a INTEG_VARIABLE, e os valores dos erros podem ser ajustados com set_integ_precision.

• INTEG_RKF_78 ou 2 (default): seleciona o integrador de passo fixo ou variável Runge-Kutta 7/8. A seleção de passo fixo é feita com o parâmetro

57

intmet igual a INTEG_FIX. A seleção de passo variável é feita com o parâmetro intmet igual a INTEG_VARIABLE, e os valores dos erros podem ser ajustados com set_integ_precision.

intmet variável com o método de integração, passada por valor. Os valores possíveis para esta variável são: • INTEG_FIX ou 0: seleciona passo fixo de integração. Neste caso os valores

dos erros absoluto e relativo de integração serão ignorados. • INTEG_VARIABLE ou 1: seleciona passo variável de integração. Neste caso

os valores do erro absoluto e relativo são especificados pela função set_integ_precision. Os valores default destes erros são iguais a 1. 10-6, tanto para as velocidades angulares quanto para os quatérnions. Os demais parâmetros da integração, como ângulos de rotação dos painéis e momento angular das rodas não são afetados pela escolha do erro..


select_integ_method valor de retorno: 0.

Exemplo:

select_integ_method (INTEG_RKF_78, INTEG_VARIABLE);

• int set_integ_precision (double rel_err, double abs_err)

Esta função estabelece os valores do erro relativo (rel_err) e do erro absoluto

(abs_err) a serem utilizados pelo integrador numérico de atitude. Os valores iniciais destas variáveis são: rel_err = 1.0e-6, e abs_err = 1.0e-6. Parâmetros de entrada: rel_err

variável com o erro relativo do integrador, passada por valor abs_err

variável com o erro absoluto do integrador, passada por valor Parâmetros de saída:

set_integ_precision Valor de retorno: 0.

Exemplo:

set_integ_precision (1.e-6, 1.e-8);

• double get_integ_rel_err ()

Esta função devolve o erro relativo correntemente empregado no integrador de atitude.


Não há Parâmetros de saída:

get_integ_rel_err erro relativo corrente do integrador.

58

Exemplo: double relerr; set_integ_precision (1.e-6, 1.e-8); relerr = get_integ_rel_err; R: relerr = 1.e-06

• double get_integ_abs_err ()

Esta função devolve o erro absoluto correntemente empregado no integrador de

atitude. Parâmetros de entrada:


abs_err erro absoluto corrente do integrador.

Exemplo:

double abserr; set_integ_precision (1.e-6, 1.e-8); relerr = get_integ_abs_err; R: abserr = 1.e-08

• int set_current_time (double time)

A função set_current_time estabelece o valor atual da contagem do tempo (s). É

usado para iniciar a contagem do tempo de propagação. A propagação da atitude altera o valor desta variável em incrementos dados por dtime (ver set_step_time). Esta variável é iniciada com valor nulo. Parâmetros de entrada: time

tempo atual em segundos, passado por valor. Parâmetros de saída:

set_current_time Valor de retorno: 0.

Exemplo:

set_current_time (10.);

• double get_current_time ()

A função get_current_time retorna com o valor corrente da contagem do tempo

(variável time) em segundos. É usado para definir funções que dependem do tempo, como o controle da atitude, a rotação dos apêndices, etc. A propagação da atitude altera o valor da variável time em incrementos dados por dtime (ver set_step_time). Parâmetros de entrada:

Não há

59


time instante corrente ou atual da propagação.

Exemplo:

double time; time = get_current_time ();

• int set_step_time (double dtime)

A função set_step_time estabelece o valor do intervalo de tempo em segundos no

qual a atitude será propagada. Em outras palavras, a função sat_propagation efetua uma propagação da atitude entre o instante corrente (time) e o instante time + dtime. Este intervalo em geral é conhecido como ciclo de integração ou intervalo de amostragem ou ainda ciclo de controle, porque assume-se, em geral, que o sinal do controle é constante durante todo este intervalo (não pode ser alterado em frações menores do que dtime). Esta variável é iniciada com valor 1 s. Parâmetros de entrada: dtime

intervalo de tempo do controle em segundos, passada por valor. Parâmetros de saída:

set_step_time

Valor de retorno: 0. Exemplo:

int istat; istat = set_step_time (0.001);

• double get_step_time ()

A função get_step_time retorna com o valor do ciclo de integração (ou intervalo de

controle) em segundos. Parâmetros de entrada:


get_step_time intervalo de tempo do controle em segundos (passo de integração).

Exemplo:

int istat; double t_step; istat = set_step_time (0.001); t_step = get_step_time (); R: t_step = 0.001;

• int set_int_step_time (double ditime)

60

A função set_int_step_time estabelece o valor de discretização do tempo no integrador numérico, conhecido também como passo de integração. Quando utilizado com integradores de passo variável, o valor do passo no integrador pode variar, embora o valor da variável permaneça o mesmo. Esta variável é iniciada com valor 0.1 s. Parâmetros de entrada: ditime

passo de integração numérica em segundos, passado por valor. Parâmetros de saída:

set_int_step_time

valor de retorno: 0. Exemplo:

int istat; double t_istep; istat = set_int_step_time (0.001);

• double get_int_step_time ()

A função get_int_step_time retorna com o valor do passo de integração corrente

em segundos. Parâmetros de entrada:


get_int_step_time passo de integração numérica em segundos (passo interno).

Exemplo:

int istat; double t_istep; istat = set_int_step_time (0.001); t_istep = get_int_step_time(); R: t_istep = 0.001

3.8 – Parâmetros da atitude

Estas funções permitem definir as condições iniciais de propagação e recuperar, em

qualquer ponto do programa, o estado atual do satélite no ciclo de integração (isto é, nos instantes de tempo proporcionais ao ciclo de integração). Este estado inclui o quatérnion da atitude e as velocidades angulares. O quatérion de atitude pode ser transformado em outra forma qualquer (ângulos de Euler, rotação de Euler, matriz de atitude) por meio das funções relacionadas na Seção 4.2.

• int set_attitude (quaternion quater);

A função set_attitude define os valores do quatérnion de atitude (condições

iniciais) para serem utilizados pelo integrador. Esta variável é iniciada com o quatérnion = 0., 0., 0., 1..

61

Parâmetros de entrada: quater

vetor de 4 posições contendo o quatérnion de atitude, passado por referência. Parâmetros de saída:

set_attitude


quaternion quarter; vector3 ezxz; int istat; ezxz._1 = 80*RADIANS; ezxz._2 = -20*RADIANS; ezxz._3 = -150*RADIANS; quater = ezxzquat (ezxz); istat = set_attitude (quater);

• quaternion get_attitude ();

A função get_attitude obtém os valores do quatérnion de atitude no instante

corrente. Parâmetros de entrada:


get_attitude

quatérnion da atitude no instante corrente. Exemplo:

quaternion quarter; quater = get_attitude ();

• int set_ang_velocity (vector3 w);

A função set_ang_velocity define a velocidade angular do satélite (condições

iniciais) a ser utilizada pelo integrador. Esta variável é iniciada como um vetor nulo. Parâmetros de entrada: w

vetor contendo a velocidade angular (rad/s), passado por referência. Parâmetros de saída:

set_ang_velocity

valor de retorno: 0.

Exemplo: vector3 w;

w._1 = 0.5; w._2 = 0; w._3 = 0.5; istat = set_ang_velocity (w);

62

• vector3 get_ang_velocity ();

A função get_ang_velocity recupera a velocidade angular do satélite no instante

corrente. Parâmetros de entrada:

não há Parâmetros de saída: get_ang_velocity

vetor contendo a velocidade angular (rad/s) no instante corrente. Exemplo:

vector3 w; w = get_ang_velocity ();

• vector3 get_sat_ang_momentum ();

A função get_sat_ang_momentum recupera o momento angular total do satélite no

instante corrente, referido ao sistema inercial, isto é, igual ao produto da matriz transposta da atitude pelo momento angular total referido ao sistema do corpo principal do satélite. O momento angular total é composto pelos momentos angulares do corpo principal, das rodas de reação e dos painéis. Na ausência de torques externos o momento angular total no sistema inercial é constante em módulo e direção. Parâmetros de entrada:

não há Parâmetros de saída: get_sat_ang_momentum

vetor contendo o momento angular total (Nms) no instante corrente. Exemplo:

vector3 ang_mom; ang_mom = get_sat_ang_momentum ();

3.9 – Propagador de atitude

O propagador de atitude é composto por uma única função, cujo objetivo é integrar

numericamente a atitude durante um ciclo de integração.

• int sat_propagation ()

A função sat_propagation efetua uma propagação da atitude entre o instante

corrente (time, função get_current_time)e o instante time + dtime (dtime, função set_step_time), utilizando um passo de integração dado por ditime ≤ dtime (ditime, função set_int_step_time). Esta função deve estar inserida dentro de uma malha (do, for, ou while), para permitir a integração pelo tempo necessário. Embora esta função não retorne com os valores da atitude, esta pode ser recuperada por meio das funções get_attitude, get_ang_velocity, e get_current_time. Caso seja necessário, pode-se transformar o

63

quatérnion de atitude em ângulos de Euler (ver Capítulo 4). A propagação de atitude é realizada com o integrador numérico Runge-Kutta (RKF78) como “default”, embora outros integradores estejam disponíveis (ver função select_integ_method). Este integrador pode gerar erros durante a integração, que são interpretados pela função sat_propagation. Esta função imprime um aviso no dispositivo padrão de saída (em geral o monitor de vídeo) com o valor do erro detectado. O código abaixo fornece a interpretação do erro provindo do integrador por meio da variável status. switch (status)

case RKF78_SUCCESS: break;

case INTERNAL_ERRORS: printf(" algo saiu errado na função de derivadas \n"); break;

case RKF78_DECREASE_STEP: dtint = dtint/2; printf(" redução do passo de integração \n"); break;

case RKF78_INCREASE_ERROR: abserr *=10 ; // multiply the error by 10; relerr *=10 ; // multiply the error by 10; printf(" aumento dos erros de integração \n"); break;

case RKF78_INCREASE_STEP: dtint = dtint*2; printf(" aumento do passo de integração \n"); break;

case RKF78_NOMEMORY_AVAIL: printf(" excedeu o limite de memória na integração\n"); break;

default: printf(" algo saiu errado durante a integração \n"); break;


não há Parâmetros de saída: sat_propagation valor de retorno: 0. Exemplo: double t, t_end; quaternion quarter; vector3 w; t_end = 200.; t = get_current_time (); while (t < t_end) quater = get_attitude (); w = get_ang_velocity ();

// ***************** propagação da atitude sat_propagation (); t = get_current_time ();

64

3.10 – Cálculo de efemérides Para simular leituras de sensores e a atuação de bobinas magnéticas é necessário

calcular-se certas efemérides. Uma vez que a maior parte destas efemérides dependem da posição orbital do satélite, foram então implementados no simulador dois propagadores analíticos de órbita. Embora a precisão obtida na propagação analítica seja inferior à da propagação numérica, ela é suficiente para as necessidades do simulador de atitude, além de ser computacionalmente mais rápida. O primeiro deles leva em conta apenas os harmônicos zonais da Terra até a ordem 4 (Brower e Clemence, 1961, ver Capítulo 5, Seção 5.2). Diversas funções foram acrescentadas para permitir a conversão de coordenadas orbitais neste propagador. O segundo propagador é o modelo SGP8, da NASA, também baseado no modelo de Brower, e apresentado na Seção 5.5. Este modelo analítico é mais completo do que o primeiro pois converte os elementos médios da propagação em elementos osculadores. Uma vez que a simulação do sensor GPS é afetada pelo elemento osculador da órbita, percebe-se que este modelo é mais adequado em simulações que envolvam o GPS. Contudo, qualquer um deles pode ser utilizado na simulação.

Deve ser mencionado, porém, que a propagação de órbita e o cálculo de efemérides

podem ser dispensados numa simulação de atitude de pequena duração, tal que a variação do campo magnético ou da posição do Sol e até mesmo da Terra com relação ao satélite possam ser ignoradas neste intervalo. Neste caso as efemérides da posição do Sol, do satélite ou o campo geomagnético podem ser previamente estabelecidos e mantidos constantes durante a execução da simulação. Caso seja necessário propagar uma órbita analiticamente configura-se a propagação por meio das funções:

• set_orbit_propagation_flag,

• set_orbit_propagation_model,

• set_ephemeris_date,

• set_keplerian_elements,

• set_two_line_elements.

As duas últimas funções possuem a mesma finalidade: definir os elementos orbitais. A

primeira delas, set_keplerian_elements, é mais apropriada para a propagação em elementos médios, enquanto que a outra é mais utilizada no modelo SGP8. Esta última aceita os elementos orbitais definidos pela estrutura nasa_el descrita na Seção 5.5. Nota-se, porém, que qualquer uma das duas funções pode ser utilizada com qualquer modelo de órbita. Resultados imprevisíveis podem ocorrer, contudo, se a seleção do modelo for alterada durante a propagação. Se os elementos keplerianos forem utilizados no modelo SGP8, alguns dos coeficientes da estrutura serão considerados nulos (mean_motion_dot, mean_motion_dot_dot e bstar - ver Seção 5.5). Isto tem pouco impacto numa propagação de curto período, inferior a alguns dias. Além disso deve-se informar o tempo das efemérides por meio da função set_ephemeris_date. Por outro lado, caso se utilize os elementos “2-line” no modelo de propagação em elementos médios, então aqueles elementos citados acima são ignorados, e não é necessário estabelecer o tempo das efemérides, já que este estará presente na estrutura nasa_el (mod_julian_date e day_fraction).

Cumpre salientar que a propagação da órbita atualiza automaticamente, a cada ciclo de

integração, a posição orbital do satélite, a direção do Sol e a direção do campo geomagnético, todos eles referidos ao sistema inercial. Este cálculo é referido ao instante atual de propagação acrescido do tempo das efemérides, ou seja, o tempo das efemérides coincide com o instante

65

time = 0 de propagação da atitude. Esta atualização tem um custo de processamento que será compensado quando os modelos dos sensores necessitarem destas informações. As funções set set_ephemeris_date, set_keplerian_elements e set_two_line_elements atualizam as efemérides da órbita, do campo geomagnético, do Sol e da Terra (tempo sideral) sempre que forem acionadas.

Por outro lado, caso a propagação de órbita não seja necessária pode-se definir um ou

mais dos valores que seriam calculados pela propagação automática. Caso, por exemplo, seja necessário simular a ação de bobinas magnéticas ou então um magnetômetro de bordo, o valor do campo magnético terrestre pode ser estabelecido com a função set_inertial_geomag_strength. Em resumo, as funções que permitem configurar as efemérides por meio de definições são:

• reset_orbit_propagation_flag,

• set_inertial_sat_pos,

• set_greenwich_sidereal_time,

• set_inertial_sun_vector,

• set_inertial_geomag_strength.

A função reset_orbit_propagation_flag desabilita a propagação analítica e

automática de órbita. Neste caso o vetor de estado do satélite, a direção do Sol e do campo geomagnético assumem valores “default”, a menos que sejam definidos por meio das funções descritas a seguir. A função set_inertial_sat_pos define a posição do satélite no sistema de eixos inerciais no instante corrente de execução. A velocidade é assumida como sendo nula. As demais funções seguintes estabelecem o tempo sideral de Greenwich, o vetor posição do Sol e do campo geomagnético.

As funções de retorno do valor diferem das funções usuais de definição, uma vez que

na grande maioria das situações deseja-se definir um parâmetro no sistema de referência geocêntrico inercial, ao passo que durante a simulação deseja-se conhecer este valor no sistema de referência do corpo do satélite. Logo, as funções do tipo set são também do tipo inertial, ao passo que as funções do tipo get referem-se tanto a inertial quanto a body. O conjunto destas funções é dado por:

• get_orbit_propagation_flag,

• get_orbit_propagation_model,

• get_current_date,

• get_greenwich_sidereal_time,

• get_inertial_state_vector,

• get_terrestrial_sat_pos,

• get_body_earth_vector,

• get_inertial_sun_vector,

• get_body_sun_versor,

• get_inertial_geomag_strength,

• get_body_geomag_vector,

A posição do satélite pode ser recuperada pela função get_body_earth_vector que

fornece a direção do centro da Terra no sistema do corpo do satélite (para simular um sensor de Terra, por exemplo). Este vetor é igual ao negativo do vetor posição do satélite no sistema de referência do corpo do satélite. Nota-se que estas funções não dependem do modelo de

66

propagação adotado, isto é, elas funcionam com qualquer um dos modelos. Segue a descrição das funções.

• int set_orbit_propagation_flag ();

A função set_orbit_propagation_flag habilita a propagação analítica de órbita

junto com a propagação de atitude. A propagação de órbita atualiza a posição do satélite, do Sol e do campo geomagnético a cada ciclo de integração. Ao ser executada, esta função atribui o valor 1 à variável orbit_propag_flag. A propagação de órbita é iniciada desabilitada. Parâmetros de entrada:

não há Parâmetros de saída: set_orbit_propagation_flag valor de retorno: 0. Exemplo: int istat;

istat = set_orbit_propagation_flag ();

• int reset_orbit_propagation_flag ();

Esta função desabilita a propagação analítica de órbita, ou seja, atribui o valor 0 à

variável orbit_propag_flag. Após o processo de desabilitar os parâmetros orbitais são mantidos com seus últimos valores. Parâmetros de entrada:


reset_orbit_propagation_flag valor de retorno: 0. Exemplo:

int istat; istat = reset_orbit_propagation_flag ();

• int get_orbit_propagation_flag ();

Esta função desprovida de argumentos permite obter o valor atual da variável orbit_propag_flag. Parâmetros de entrada:


get_orbit_propagation_flag

valor de retorno: variável orbit_propag_flag

67

Exemplo: int istat; istat = get_orbit_propagation_flag ();

• int set_orbit_propagation_model (int orb_model);

A função set_orbit_propagation_model seleciona o modelo orbital para a

propagação de órbita e cálculo das efemérides que dependem da posição orbital. Parâmetros de entrada: orb_model

seleção do modelo orbital: 0 (default) corresponde à propagação em elementos médios, enquanto que o valor 1 indica uma propagação pelo modelo SGP8, em elementos osculadores, passado por valor. Caso orb_model não corresponda a um valor válido, então o valor default é selecionado.

Parâmetros de saída: set_orbit_propagation_model valor de retorno: 0. Exemplo:

int istat; istat = set_orbit_propagation_flag (); istat = set_orbit_propagation_model (1);

• int get_orbit_propagation_model ();

Esta função retorna com o código do modelo orbital (variável orbit_prop_model): 0 indica modelo em elementos médios e 1 indica modelo em elementos osculadores. Parâmetros de entrada:

não há Parâmetros de saída: get_orbit_propagation_model

valor de retorno: modelo orbital selecionado (variável orbit_prop_model). Exemplo:

int istat; istat = set_orbit_propagation_flag (); istat = set_orbit_propagation_model (1); istat = get_orbit_propagation_model (); R: istat = 1

• int set_ephemeris_date (int day, int month, int year, int hour, int

minut, double secon);

A função set_ephemeris_date estabelece o instante inicial (data e horário) de

propagação de órbita e cálculo das efemérides. O valor default para o tempo das efemérides (instante atual) é 16/07/2005, às 0h:0:0. Esta função pode ser sobreposta pela função set_two_line_elements, já que o instante inicial das efemérides está também presente na estrutura nasa_el.

68

Parâmetros de entrada: day

dia (calendário gregoriano), passado por valor. month

mês (calendário gregoriano), passado por valor. year

ano (calendário gregoriano), passado por valor. hour

hora (UTC) do dia, passada por valor. minut

minutos inteiros decorridos dentro da hora, passado por valor. secon

segundos (e fração de segundos) decorridos dentro do minuto, passado por valor.

Parâmetros de saída: set_ephemeris_date valor de retorno: 0. Exemplo:

int istat; istat = set_orbit_propagation_flag (); istat = set_ephemeris_date (19, 4, 2007, 14, 48, 51.2);

• vector6 get_current_date ();

A função get_current_date retorna com a data (calendário gregoriano) e horário

(UTC) referidos ao instante de propagação time (ver get_current_time). Este instante corresponde ao tempo das efemérides (set_ephemeris_date) acrescido de time. Nota-se portanto que o instante das efemérides corresponde ao instante no qual time é nulo, e não ao instante no qual se inicia a propagação. Parâmetros de entrada:


get_current_date vetor de 6 posições contendo a data (dia, mês e ano) e horário do dia (hora, minuto e segundos) corrente, respectivamente.

Exemplo:

vector6 datum; int istat; istat = set_ephemeris_date (19, 4, 2007, 14, 48, 51.2); datum = get_current_date (); R: datum = 19., 4., 2007., 14., 48., 51.2

• int set_greenwich_sidereal_time (double gst);

A função set_greenwich_sidereal_time especifica o valor do tempo sideral de

Greenwich a ser usado, se necessário, quando a propagação analítica de órbita estiver

69

desabilitada. Se a propagação de órbita estiver ativa este ângulo é calculado e propagado automaticamente. Parâmetros de entrada:

gst ângulo relativo ao tempo sideral de Greenwich, em radianos, passado por valor.

Parâmetros de saída: set_greenwich_sidereal_time valor de retorno: 0. Exemplo:

int istat; istat = set_greenwich_sidereal_time (0.57);

• int get_greenwich_sidereal_time ();

Esta função devolve o valor do tempo sideral de Greenwich no instante corrente, ou

um valor nulo caso a propagação analítica de órbita não esteja habilitada e este ângulo não tenha sido definido pela função set_greenwich_sidereal_time. Parâmetros de entrada:


get_greenwich_sidereal_time ângulo relativo ao tempo sideral de Greenwich, em radianos, no instante corrente.

Exemplo: int istat; double gst; istat = set_greenwich_sidereal_time (0.57); gst = get_greenwich_sidereal_time (); R: gst = 0.57

• int set_keplerian_elements (vector6 kepel);

A função set_keplerian_elements define os elementos orbitais do satélite no

instante das efemérides, para ser usado pela propagação analítica de órbita no modelo de elementos médios. O parâmetro de entrada é um vetor do tipo vector6 com os elementos orbitais, com valor default de 7000000, 0, 0, 0, 0, 0. Esta função pode ser sobreposta pela set_two_line_elements. Parâmetros de entrada:

kepel

vetor de 6 componentes contendo os elementos keplerianos na ordem: semi-eixo maior orbital em metros, excentricidade orbital, inclinação em radianos, ascensão reta do nodo ascendente em radianos, argumento do perigeu em radianos e anomalia média em radianos, passado por referência.

Parâmetros de saída: set_keplerian_elements

70


int istat; vector6 kepel; kepel._1._1 = EARTH_RADIUS + 600000; kepel._1._2 = 0.06; kepel._1._3 = 1.; kepel._2._1 = 0.; kepel._2._2 = 0.5; kepel._2._3 = 6.09; istat = set_orbit_propagation_flag (); istat = set_keplerian_elements (kepel);

• int set_two_line_elements (nasa_el tl_elem);

A função set_two_line_elements define os elementos orbitais do satélite e o

instante das efemérides, para ser usado pela propagação analítica de órbita no modelo SGP8. O parâmetro de entrada é uma estrutura do tipo nasa_el (ver Seção 5.5). Os valores default para estes elementos são 1.079465214193e-3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20285, 0. Estes valores são correspondentes a uma órbita com os elementos keplerianos e tempo de efemérides default. Esta função pode ser sobreposta pela set_keplerian_elements e pela set_ephemeris_date. Parâmetros de entrada:

tl_elem

estrutura contendo os valores orbitais na forma de “2-line elements”. Parâmetros de saída: set_two_line_elements valor de retorno: 0. Exemplo:

nasa_el nsel; FILE *ifile; ifile = fopen("nasa2l.dat", "r"); nsel = nasael (ifile, 2); fclose(ifile); istat = set_two_line_elements(nsel);

• int set_inertial_sat_pos (vector3 satpos);

A função set_inertial_sat_pos irá estabelecer a posição do satélite no sistema

inercial, se necessário, caso a propagação analítica de órbita esteja desabilitada. Se a propagação de órbita estiver ativa, então a posição do satélite é calculada a partir dos elementos keplerianos fornecidos. Parâmetros de entrada:

satpos vetor contendo a posição do satélite no sistema geocêntrico inercial, em metros, passado por referência.


71

set_inertial_sat_pos valor de retorno: 0. Exemplo:

int istat; vector6 stat_vec; stat_vec._1._1 = 6311864.5276531; stat_vec._1._2 = 982229.88054033; stat_vec._1._3 = 1527997.8954799; stat_vec._2._1 = -2320.5118569289; stat_vec._2._2 = 4145.3317588174; stat_vec._2._3 = 6460.4357590289; istat = set_orbit_propagation_flag (); istat = set_inertial_sat_pos (stat_vec);

• vector6 get_inertial_state_vector ();

Esta função permite recuperar o valor corrente do vetor de estado do satélite (referido

ao instante time), caso a propagação de órbita tenha sido habilitada. O vetor de estado é composto por 3 componentes da posição e 3 da velocidade, referidos ao sistema geocêntrico inercial. Se a propagação de órbita não tiver sido habilitada a função irá devolver o valor estabelecido por meio da set_inertial_sat_pos, com velocidade nula, ou então o vetor 7000000, 0, 0, 0, 0, 0 (default). Parâmetros de entrada:


get_inertial_state_vector

vetor de 6 componentes contendo o vetor de estado do satélite: a posição é armazenada no primeiro vetor (._1) em metros e a velocidade no vetor seguinte (._2) em metros por segundo.

Exemplo:

int istat; vector6 kepel, stat_vec; kepel._1._1 = EARTH_RADIUS + 600000; kepel._1._2 = 0.06; kepel._1._3 = 1.; kepel._2._1 = 0.; kepel._2._2 = 0.5; kepel._2._3 = 6.09; istat = set_orbit_propagation_flag (); istat = set_keplerian_elements (kepel); stat_vec = get_inertial_state_vector (); R: stat_vec = 6311864.5276531, 982229.88054033, 1527997.8954799,

-2320.5118569289, 4145.3317588174, 6460.4357590289

• vector3 get_terrestrial_sat_pos ();

Esta função retorna com o vetor posição do satélite em coordenadas geocêntricas

referidas a Greenwich no instante corrente, em metros, caso a propagação de órbita esteja habilitada. Se a propagação de órbita estiver desabilitada a função retorna com a posição

72

estabelecida por set_inertial_sat_pos, corrigida pelo tempo sideral, ou ainda o vetor 7000000, 0, 0 (default). Parâmetros de entrada:


get_terrestrial_sat_pos

vetor de 3 componentes contendo a posição atual do satélite em metros no sistema geocêntrico terrestre referido a Greenwich.

Exemplo:

int istat; vector6 kepel; vector3 stat_vec; kepel._1._1 = EARTH_RADIUS + 600000; kepel._1._2 = 0.06; kepel._1._3 = 1.; kepel._2._1 = 0.; kepel._2._2 = 0.5; kepel._2._3 = 6.09; istat = set_orbit_propagation_flag (); istat = set_ephemeris_date (1, 1, 2001, 10, 40, 0.0); istat = set_keplerian_elements (kepel); stat_vec = get_terrestrial_sat_pos (); R: stat_vec = -1941307.7433316, 6085699.1052263, 1527997.8954799

• vector3 get_body_earth_vector ();

Esta função retorna com a direção oposta do vetor posição do satélite no sistema do

corpo do satélite, isto é, o vetor posição do centro da Terra. Se a propagação de órbita não tiver sido habilitada a função irá devolver o valor estabelecido por meio da set_inertial_sat_pos, com velocidade nula, ou então o vetor −7000000, 0, 0 (default). Esta função pode ser utilizada no modelo de um sensor terrestre ou sensor de horizonte. Nota-se que esta função depende da atitude do satélite, já que o vetor posição da Terra é expresso neste sistema. Parâmetros de entrada:


get_body_earth_vector

vetor de 3 componentes contendo o vetor posição do centro da Terra no sistema do corpo do satélite.

Exemplo:

int istat; vector6 kepel; vector3 stat_vec; ezxz._1 = 80*RADIANS; ezxz._2 = -20*RADIANS; ezxz._3 = -150*RADIANS; quater = exyzquat (ezxz); istat = set_attitude (quater);

73

kepel._1._1 = EARTH_RADIUS + 600000; kepel._1._2 = 0.06; kepel._1._3 = 1.; kepel._2._1 = 0.; kepel._2._2 = 0.5; kepel._2._3 = 6.09; istat = set_orbit_propagation_flag (); istat = set_ephemeris_date (1, 1, 2001, 10, 40, 0.0); istat = set_keplerian_elements (kepel); stat_vec = get_body_earth_vector (); R: stat_vec = 5766330.7638285, -1394668.9944376, 2818424.1767949

• int set_inertial_geomag_strength (vector3 geomagnetic);

A função set_inertial_geomag_strength fixa o valor do campo magnético

terrestre em Tesla (T) no referencial inercial, na posição orbital onde se encontra o satélite, caso a propagação de órbita esteja desabilitada. Se a propagação de órbita estiver ativada, então o campo magnético terrestre é automaticamente atualizado a cada novo ciclo de integração. Parâmetros de entrada:

geomagnetic vetor contendo as direções do campo magnético terrestre em Tesla no sistema de eixos inerciais, passado por referência.

Parâmetros de saída: set_inertial_geomag_strength valor de retorno: 0. Exemplo:

int istat; vector3 vec; vec._1 = 5.3657166596688e-6; vec._2 = -1.5956799212427e-5; vec._3 = 3.3901300910335e-5; istat = set_inertial_geomag_strength (vec);

• vector3 get_inertial_geomag_strength ();

Esta função retorna com o valor atual do campo magnético terrestre no sistema de eixos inerciais. Se a propagação de órbita estiver ativada, então o campo magnético terrestre é atualizado a cada ciclo de integração. Parâmetros de entrada:

não há Parâmetros de saída: get_inertial_geomag_strength

variável contendo o valor corrente do campo magnético terrestre em Tesla. Exemplo:

int istat; vector6 kepel; vector3 stat_vec;

74

kepel._1._1 = EARTH_RADIUS + 600000; kepel._1._2 = 0.06; kepel._1._3 = 1.; kepel._2._1 = 0.; kepel._2._2 = 0.5; kepel._2._3 = 6.09; istat = set_orbit_propagation_flag (); istat = set_ephemeris_date (1, 1, 2001, 10, 40, 0.0); istat = set_keplerian_elements (kepel); stat_vec = get_inertial_geomag_strength (); R: stat_vec = 5.36571665967e-6, -1.5956799212e-5, 3.3901300910e-5

• vector3 get_body_geomag_vector ();

Esta função retorna com o valor atual do campo magnético terrestre no sistema de referência do corpo do satélite. Se a propagação de órbita estiver ativada, então o campo magnético terrestre é atualizado a cada ciclo de integração. Esta função pode ser utilizada na simulação de um magnetômetro. Parâmetros de entrada:

não há Parâmetros de saída: get_body_geomag_vector

variável contendo o valor corrente do campo magnético terrestre em Tesla, no sistema do corpo do satélite.

Exemplo:

int istat; vector6 kepel; vector3 stat_vec; ezxz._1 = 80*RADIANS; ezxz._2 = -20*RADIANS; ezxz._3 = -150*RADIANS; quater = exyzquat (ezxz); istat = set_attitude (quater); kepel._1._1 = EARTH_RADIUS + 600000; kepel._1._2 = 0.06; kepel._1._3 = 1.; kepel._2._1 = 0.; kepel._2._2 = 0.5; kepel._2._3 = 6.09; istat = set_orbit_propagation_flag (); istat = set_ephemeris_date (1, 1, 2001, 10, 40, 0.0); istat = set_keplerian_elements (kepel); stat_vec = get_body_geomag_vector (); R: stat_vec = -2.6072563627e-5, -2.02986113096e-5, 1.8463379014e-5

• int set_inertial_sun_vector (vector3 sunvec);

A função set_inertial_sun_vector irá estabelecer a posição do Sol no sistema

inercial, se necessário, caso a propagação de órbita automática esteja desabilitada. Se a propagação de órbita estiver ativada, então este posição é atualizada a cada ciclo de integração.

75


sunvec vetor contendo a direção do Sol no sistema geocêntrico inercial, em metros, passado por referência.


set_inertial_sun_vector


int istat; vector3 sun_vec; sun_vec._1 = 28297293201.009; sun_vec._2 = -132442719798.63; sun_vec._3 = -57419745137.502; stat_vec = set_inertial_sun_vector (sun_vec);

• vector3 get_inertial_sun_vector ();

A função get_inertial_sun_vector devolve a posição do Sol no sistema de referência inercial em metros. Esta função é afetada pelos valores utilizados na função set_ephemeris_date. Parâmetros de entrada:


get_inertial_sun_vector vetor contendo a direção do Sol no sistema geocêntrico inercial, em metros, passado por referência.

Exemplo: int istat; vector6 kepel; vector3 sun_vec; istat = set_ephemeris_date (1, 1, 2001, 10, 40, 0.0); sun_vec = get_inertial_sun_vector (); R: sun_vec = 28297293201.009, -132442719798.63, -57419745137.502

• vector3 get_body_sun_versor ();

Esta função retorna com a direção do Sol referida ao sistema do corpo do satélite

(vetor unitário). Este vetor pode ser utilizado na simulação de sensores solares. Nota-se que esta função não detecta a situação do satélite encontrar-se na sombra da Terra. Parâmetros de entrada:


get_body_sun_versor vetor unitário contendo a direção do Sol no sistema do corpo do satélite.

Exemplo:

76

int istat; vector6 kepel; vector3 stat_vec; ezxz._1 = 80*RADIANS; ezxz._2 = -20*RADIANS; ezxz._3 = -150*RADIANS; quater = exyzquat (ezxz); istat = set_attitude (quater); kepel._1._1 = EARTH_RADIUS + 600000; kepel._1._2 = 0.06; kepel._1._3 = 1.; kepel._2._1 = 0.; kepel._2._2 = 0.5; kepel._2._3 = 6.09; istat = set_orbit_propagation_flag (); istat = set_ephemeris_date (1, 1, 2001, 10, 40, 0.0); istat = set_keplerian_elements (kepel); stat_vec = get_body_sun_versor (); R: stat_vec = -0.12872279831739, 0.69872823199543, 0.70371109058042

77

4 - Rotinas para conversão de coordenadas de atitude Esta biblioteca é composta por funções destinadas a efetuar operações envolvendo matrizes de rotação e funções para transformar coordenadas que descrevem a atitude de satélites. Os protótipos das rotinas tabeladas nesta seção encontram-se no arquivo attaux.h e a biblioteca para junção (link) é attaux.lib.

Nos exemplos fornecidos utilizou-se um cabeçalho comum, que define as variáveis usadas:

matrix3 mat1 = 1, 2, 3, 4, 5, 6, 7, 8, 9; matrix3 mat2 = 8, 7, 6, 5, 4, 3, 2, 1, 0; matrix3 mat3; vector3 vec1 = -3, 2, 5; vector3 vec2 = 1, -3, 4; vector3 vec3; quaternion quat1 = .2, .6, .4, .5; quaternion quat2, quat3; quaternion euler1, euler2; double dmod; double angle;

4.1 – Matrizes de rotação Estas funções fornecem matrizes de rotação que operam nos eixos cartesianos.

• matrix3 rotmax (double angl);

A função rotmax retorna com a matriz de rotação de coordenadas que efetua uma

rotação de um ângulo angl em radianos em torno do eixo x. Parâmetros de entrada: angl

ângulo em radianos passado por valor. Parâmetros de saída: rotmax

matriz de rotação de coordenadas sobre o eixo x. Exemplo: matrix3 mat1;

mat1 = rotmax (30*RADIANS); R: mat1 = 1, 0, 0, 0, 0.8660, 0.5000, 0, -0.5000, 0.8660

• matrix3 rotmay (double angl);

A função rotmay retorna com a matriz de rotação de coordenadas que efetua uma

rotação de um ângulo angl em radianos em torno do eixo y. Parâmetros de entrada: angl

ângulo em radianos passado por valor.

78

Parâmetros de saída: rotmay

matriz de rotação de coordenadas sobre o eixo y. Exemplo: matrix3 mat1;

mat1 = rotmay (30*RADIANS); R: mat1 = 0.8660, 0, -0.5000, 0, 1, 0, 0.5000, 0, 0.8660

• matrix3 rotmaz (double angl);

A função rotmaz retorna com a matriz de rotação de coordenadas que efetua uma

rotação de um ângulo angl em radianos em torno do eixo z. Parâmetros de entrada: angl

ângulo em radianos passado por valor. Parâmetros de saída: rotmaz

matriz de rotação de coordenadas sobre o eixo z. Exemplo: matrix3 mat1;

mat1 = rotmaz (30*RADIANS); R: mat1 = 0.8660, 0.5000, 0, -0.5000, 0.8660, 0, 0, 0, 1

• matrix3 rmxtran (matrix3 rmat);

Esta função efetua a transposição da matriz rmat. Uma matriz de rotação é ortogonal, e pelas propriedades de matrizes ortogonais, a inversa é igual a sua transposta. Desta forma, se rmat for uma matriz de rotação sua inversa é obtida mais facilmente (sem a necessidade de cálculo) por meio da sua transposta. Parâmetros de entrada: rmat

matriz a ser transposta, passada por referência. Parâmetros de saída: rmxtran

matriz rmat transposta. Exemplo:

matrix3 = 1, 2, 3, 4, 5, 6, 7, 8, 9; mat2 = rmxtran (mat1);

R: mat2 = 1, 4, 7, 2, 5, 8, 3, 6, 9

79

4.2 - Funções para conversão de coordenadas de atitude A atitude do satélite pode ser definida por meio dos ângulos de Euler, que consistem em três rotações de coordenadas efetuadas sobre os eixos cartesianos, ou ainda pelo ângulo e pelo vetor de Euler que descreve o eixo de rotação, e também pelo quatérnion e pela própria matriz de atitude. Existem 12 combinações distintas para os ângulos de Euler, porém apenas 4 delas possuem particular interesse na atitude de satélites. São as rotações efetuadas sobre os eixos x-y-z, z-x-z, z-x-y e z-y-x. Estas combinações de rotações são também conhecidas como 1-2-3, 3-1-3, 3-1-2 e 3-2-1 (Wertz, 1978). Tem-se, assim, 7 formas distintas de representar a atitude, que resolvem praticamente qualquer tipo de problema envolvendo a visualização do resultado. Implementou-se quase todas as transformações de um tipo de representação para outra. Algumas, contudo, foram omitidas em virtude de não se mostrarem úteis na solução de problemas. Contudo, uma vez que foram implementadas funções para transformar qualquer representação na matriz de atitude, então pode-se, sempre, atingir uma representação qualquer a partir de outra qualquer passando, eventualmente, por esta representação. A Figura 4.1 mostra as representações distintas e as conversões possíveis de serem efetuadas pelas funções listadas nesta biblioteca. A função desejada pode ser facilmente identificada neste diagrama, por meio da notação utilizada. Por exemplo, para transformar o vetor de Euler numa representação por quatérnion, deve-se utilizar a função eulerquat. Os parâmetros são também facilmente memorizáveis, uma vez que quatérnions e o vetor de Euler usam a estrutura quaternion, enquanto que ângulos de Euler utilizam vetores tridimensionais vector3. A matriz de atitude, por sua vez, usa a estrutura matrix3. O vetor de Euler usa as 3 primeiras componentes para armazenar a direção de rotação (vetor do eixo de rotação) de módulo unitário, enquanto que a quarta componente armazena o ângulo de rotação em radianos (0 a π) . Os vetores dos ângulos de Euler armazenam os ângulos de rotação em radianos.

quaternions

Attitude matrix

Euler xyz

Euler zxz

rmx Euler axis & angle

euler

quat

exyz

ezxz

Euler zxy ezxy

Euler zyx ezyx

Fig. 4.1 – Representações distintas da atitude e as conversões implementadas.

• quaternion rmxeuler (matrix3 rmat);

Esta função calcula o vetor e o ângulo de uma rotação de Euler, dada a matriz de

rotação rmat. Parâmetros de entrada: rmat

80

matriz de rotação, passada por referência. Parâmetros de saída: rmxeuler

vetor que fornece o eixo de uma rotação de Euler, com módulo unitário, nas 3 primeiras posições e ângulo de rotação em torno do eixo, em radianos, na quarta posição.

Exemplo: mat2 = rotmaz(30*RADIANS)*rotmax(45*RADIANS)*rotmaz(40*RADIANS); euler1 = rmxeuler (mat2);

R: euler1 = 0.5832, 0.0510, 0.8107, 1.4248.

• matrix3 eulerrmx (quaternion euler);

A função eulerrmx obtém a matriz de atitude dados a direção do eixo de rotação e o ângulo de Euler da rotação em torno deste eixo por meio do vetor euler. A função normaliza a direção do eixo de rotação para garantir que o determinante da matriz de rotação seja unitário. Parâmetros de entrada: rmxeuler

vetor que fornece o eixo de uma rotação de Euler, com módulo unitário, nas 3 primeiras posições e ângulo de rotação em torno do eixo, em radianos, na quarta posição, passado por referência.

Parâmetros de saída: eulerrmx

matriz da atitude. Exemplo: mat1 = rotmaz(30*RADIANS)*rotmax(45*RADIANS)*rotmaz(40*RADIANS); euler1 = rmxeuler (mat1); mat2 = eulerrmx (euler1); vec1 = DEGREES*rmxezxz (mat2); R: mat1 = 0.4362, 0.8275, 0.3536, -0.7766, 0.1477, 0.6124, 0.4545,

-0.5417, 0.7071 euler1 = (0.5832, 0.0510, 0.8107, 1.4248 mat2 = 0.4362, 0.8275, 0.3536, -0.7766, 0.1477, 0.6124, 0.4545,

-0.5417, 0.7071 vec1 = 40, 45, 30

• vector3 rmxexyz (matrix3 rmat);

A função rmxexyz calcula os ângulos de Euler em radianos relativos a uma seqüência

de rotações nos eixos x, y e z, nesta ordem, a partir da matriz de atitude armazenada em rmat. Parâmetros de entrada: rmat

matriz de rotação, passada por referência. Parâmetros de saída:

81

rmxexyz

vetor que fornece os 3 ângulos (radianos) de uma rotação de coordenadas nos eixos x, y e z, passado por referência. Os ângulos estão limitados entre −π < θ1 ≤ π, −π/2 < θ2 ≤ π/2 e −π < θ3 ≤ π.

Exemplo: mat1 = rotmaz(30*RADIANS)*rotmay(45*RADIANS)*rotmax(40*RADIANS); vec1 = DEGREES * rmxexyz (mat1); R:

mat1 = 0.6124, 0.7766, -0.1477, -0.3536, 0.4362, 0.8275, 0.7071, -0.4545, 0.5417) vec1 = 40, 45, 30.

• matrix3 exyzrmx (vector3 euler);

A função exyzrmx obtém a matriz de atitude dados os ângulos de Euler da atitude

correspondentes a rotações de coordenadas efetuadas sobre os eixos x, y e z. Parâmetros de entrada: euler

vetor que fornece os 3 ângulos (radianos) de uma rotação de coordenadas nos eixos x, y e z, passado por referência.

Parâmetros de saída: exyzrmx

matriz de atitude. Exemplo: vec1._1 = 40*RADIANS; vec1._2 = 45*RADIANS; vec1._3 = 30*RADIANS; mat2 = exyzrmx (vec1);

R: mat2 = 0.6124, 0.7766, -0.1477, -0.3536, 0.4362, 0.8275, 0.7071, -0.4545, 0.5417)

• vector3 rmxezxz (matrix3 rmat);

A função rmxezxz calcula os ângulos de Euler em radianos relativos a uma seqüência

de rotações nos eixos z, x e z, a partir da matriz de atitude armazenada em rmat. Parâmetros de entrada: rmat

matriz de atitude, passada por referência. Parâmetros de saída: rmxezxz

vetor que fornece os 3 ângulos (radianos) de uma rotação de coordenadas nos eixos z, x e z, passado por referência. Os ângulos estão limitados entre −π < θ1 ≤ π, 0 < θ2 ≤ π e −π < θ3 ≤ π.

Exemplo: mat1 = rotmaz(30*RADIANS)*rotmax(45*RADIANS)*rotmaz(40*RADIANS); vec1 = DEGREES * rmxexyz (mat1);

82

R: mat1 = 0.4362, 0.8275, 0.3536, -0.7766, 0.1477, 0.6124, 0.4545, -0.5417, 0.7071) vec1 = 40, 45, 30.

• matrix3 ezxzrmx (vector3 euler);

A função ezxzrmx obtém a matriz de atitude dados os ângulos de Euler da atitude correspondentes a rotações de coordenadas efetuadas sobre os eixos z, x e z. Parâmetros de entrada: euler

vetor que fornece os 3 ângulos (radianos) de uma rotação de coordenadas nos eixos z, x e z, passado por referência.

Parâmetros de saída: ezxzrmx

matriz de atitude. Exemplo: vec1._1 = 40*RADIANS; vec1._2 = 45*RADIANS; vec1._3 = 30*RADIANS; mat2 = exyzrmx (vec1);

R: mat2 = 0.4362, 0.8275, 0.3536, -0.7766, 0.1477, 0.6124, 0.4545, -0.5417, 0.7071)

• vector3 rmxezxy (matrix3 rmat);

A função rmxezxy calcula os ângulos de Euler em radianos relativos a uma seqüência

de rotações nos eixos z, x e y, a partir da matriz de atitude armazenada em rmat. Parâmetros de entrada: rmat

matriz de atitude, passada por referência. Parâmetros de saída: rmxezxy

vetor que fornece os 3 ângulos (radianos) de uma rotação de coordenadas nos eixos z, x e y (3-1-2), passado por referência. Os ângulos estão limitados entre −π < θ1 ≤ π, −π/2 < θ2 ≤ π/2 e −π < θ3 ≤ π.

Exemplo: vector3 exzy, vec1;

ezxy._1 = 80*RADIANS; ezxy._2 = -20*RADIANS; ezxy._3 = -150*RADIANS; vec1 = rmxezxy(ezxyrmx(ezxy))*DEGREES; R:

vec1 = 80, -20, -150.

• matrix3 ezxyrmx (vector3 euler);

83

A função ezxyrmx obtém a matriz de atitude dados os ângulos de Euler da atitude correspondentes a rotações de coordenadas efetuadas sobre os eixos z, x e y. Parâmetros de entrada: euler

vetor que fornece os 3 ângulos (radianos) de uma rotação de coordenadas nos eixos z, x e y (3-1-2), passado por referência.

Parâmetros de saída: ezxyrmx

matriz de atitude. Exemplo: vector3 exzy, vec1;

ezxy._1 = 80*RADIANS; ezxy._2 = -20*RADIANS; ezxy._3 = -150*RADIANS; vec1 = rmxezxy(ezxyrmx(ezxy))*DEGREES; R:

vec1 = 80, -20, -150.

• vector3 rmxezyx (matrix3 rmat);

A função rmxezyx calcula os ângulos de Euler em radianos relativos a uma seqüência

de rotações nos eixos z, y e x, a partir da matriz de atitude armazenada em rmat. Parâmetros de entrada: rmat

matriz de atitude, passada por referência. Parâmetros de saída: rmxezyx

vetor que fornece os 3 ângulos (radianos) de uma rotação de coordenadas nos eixos z, y e x (3-2-1), passado por referência. Os ângulos estão limitados entre −π < θ1 ≤ π, −π/2 < θ2 ≤ π/2 e −π < θ3 ≤ π.

Exemplo: vector3 exzy, vec1;

ezyx._1 = 80*RADIANS; ezyx._2 = -20*RADIANS; ezyx._3 = -150*RADIANS; vec1 = rmxezyx(ezyxrmx(ezyx))*DEGREES; R:

vec1 = 80, -20, -150.

• matrix3 ezyxrmx (vector3 euler);

A função ezyxrmx obtém a matriz de atitude dados os ângulos de Euler da atitude correspondentes a rotações de coordenadas efetuadas sobre os eixos z, y e x. Parâmetros de entrada: euler

vetor que fornece os 3 ângulos (radianos) de uma rotação de coordenadas nos eixos z, y e x (3-2-1), passado por referência.

84

Parâmetros de saída: ezyxrmx

matriz de atitude. Exemplo: vector3 exzy, vec1;

ezyx._1 = 80*RADIANS; ezyx._2 = -20*RADIANS; ezyx._3 = -150*RADIANS; vec1 = rmxezyx(ezyxrmx(ezyx))*DEGREES; R:

vec1 = 80, -20, -150.

• quaternion rmxquat (matrix3 rmat);

A função rmxquat obtém os quatérnions da atitude dada a matriz de atitude rmat. Esta

função usa o algoritmo descrito por Klumpp (Klumpp, 1976), que evita as singularidades dos métodos usuais. Parâmetros de entrada: rmat

matriz de atitude, passada por referência. Parâmetros de saída: rmxquat

vetor que fornece o quatérnion da atitude. Exemplo: mat1 = rotmaz(40*RADIANS)*rotmax(45*RADIANS)*rotmaz(30*RADIANS); quat1 = rmxquat (mat1); R:

mat1 = 0.4362, 0.7766, 0.4545, -0.8275, 0.1477, 0.5417, 0.3536, -0.6124, 0.7071) quat1 = 0.3812, -0.0334, 0.5299, 0.7568

• matrix3 quatrmx (quaternion quater);

A função quatrmx calcula a matriz da atitude a partir do quatérnion da atitude quater.


vetor de quatérnion da atitude, passado por referência. Parâmetros de saída: quatrmx

matriz de atitude. Exemplo: quat1 =

rmxquat (rotmaz(40*RADIANS)*rotmax(45*RADIANS)*rotmaz(30*RADIANS)); mat2 = quatrmx (quat1); R:

quat1 = 0.3812, -0.0334, 0.5299, 0.7568 mat2 = 0.4362, 0.7766, 0.4545, -0.8275, 0.1477, 0.5417, 0.3536,

85

-0.6124, 0.7071)

• quaternion quateuler (quaternion quater);

Esta função calcula o eixo de rotação e o ângulo de Euler a partir do quatérnion da

atitude quater. Parâmetros de entrada: quater

vetor de quatérnion da atitude, passado por referência. Parâmetros de saída: quateuler

vetor que fornece o eixo de uma rotação de Euler, com módulo unitário, nas 3 primeiras posições e ângulo de rotação em torno do eixo, em radianos, na quarta posição.

Exemplo:

quat1 = rmxquat (rotmaz(40*RADIANS)*rotmax(45*RADIANS)*rotmaz(30*RADIANS)); euler1 = quateuler (quat1); R: quat1 = 0.3812, -0.0334, 0.5299, 0.7568 euler1 = 0.5832, -0.0510, 0.8107, 1.4248,

• quaternion eulerquat (quaternion euler);

A função eulerquat obtém o quatérnion da atitude, dados a direção do eixo de rotação e o ângulo de Euler da rotação em torno deste eixo. A função normaliza a direção do eixo de rotação para garantir que o determinante da matriz de rotação seja unitário. Parâmetros de entrada: euler

vetor que fornece o eixo de uma rotação de Euler, com módulo unitário, nas 3 primeiras posições e ângulo de rotação em torno do eixo, em radianos, na quarta posição, passado por referência.

Parâmetros de saída: eulerquat

vetor que fornece o quatérnion da atitude. Exemplo:

euler1 = rmxeuler (rotmaz(40*RADIANS)*rotmax(45*RADIANS)*rotmaz(30*RADIANS)); quat1 = eulerquat (euler1); R: euler1 = 0.5832, -0.0510, 0.8107, 1.4248, quat1 = 0.3812, -0.0334, 0.5299, 0.7568

• vector3 quatexyz (quaternion quater);

A função quatexyz obtém os ângulos de Euler referentes a rotações de coordenadas efetuadas nos eixos x, y e z, respectivamente, dada a atitude em quatérnions.

86


vetor de quatérnion da atitude, passado por referência. Parâmetros de saída: quatexyz

vetor que fornece os 3 ângulos (radianos) de uma rotação de coordenadas nos eixos x, y e z.

Exemplo:

vec1._1 = 30*RADIANS; vec1._2 = 45*RADIANS;

vec1._3 = 40*RADIANS; quat1 = exyzquat (vec1); vec2 = DEGREES * quatexyz (quat1); R: quat1 = 0.3511, 0.2656, 0.3983, 0.8047 vec2 = 30, 45, 40

• quaternion exyzquat (vector3 euler);

Esta função obtém os quatérnions da atitude a partir dos ângulos de Euler correspondentes a uma rotação de coordenadas nos eixos x, y e z. Parâmetros de entrada: euler

vetor que fornece os 3 ângulos (radianos) de uma rotação de coordenadas nos eixos x, y e z, passado por referência.

Parâmetros de saída: exyzquat

vetor de quatérnion da atitude. Exemplo:


vec1._3 = 40*RADIANS; quat1 = exyzquat (vec1); R: quat1 = 0.3511, 0.2656, 0.3983, 0.8047

• vector3 quatezxz (quaternion quater);

A função quatezxz obtém os ângulos de Euler referentes a rotações de coordenadas

efetuadas nos eixos z, x e z, respectivamente, dada a atitude em quatérnions. Parâmetros de entrada: quater

vetor de quatérnion da atitude, passado por referência. Parâmetros de saída: quatexyz

vetor que fornece os 3 ângulos (radianos) de uma rotação de coordenadas nos eixos z, x e z.

87

Exemplo:


vec1._3 = 40*RADIANS; quat1 = ezxzquat (vec1); vec2 = DEGREES * quatezxz (quat1); R: quat1 = 0.3812, -0.0334, 0.5299, 0.7568 vec2 = 30, 45, 40

• quaternion ezxzquat (vector3 euler);

Esta função obtém os quatérnions da atitude a partir dos ângulos de Euler

correspondentes a uma rotação de coordenadas nos eixos z, x e z. Parâmetros de entrada: euler

vetor que fornece os 3 ângulos (radianos) de uma rotação de coordenadas nos eixos z, x e z, passado por referência.

Parâmetros de saída: exyzquat

vetor de quatérnion da atitude. Exemplo:


vec1._3 = 40*RADIANS; quat1 = ezxzquat (vec1); R: quat1 = 0.3812, -0.0334, 0.5299, 0.7568

89

5 – Efemérides orbitais O movimento em atitude de um satélite é afetado pela sua posição do satélite em sua órbita e também pela própria geometria orbital. Embora os efeitos orbitais possam ser desprezados nas simulações de curta duração no tempo (menores do que 10 minutos), estes devem ser levados em conta sempre que a simulação estender-se por períodos mais longos. Ademais, uma vez que os sensores de atitude com freqüência dependem destas efemérides, é natural incorporá-las ao simulador. Este pacote está dividido em 4 partes:

• transformações de data e hora, • conversão de efemérides, • efemérides do Sol e • campo magnético terrestre.

Transformações de data e hora permitem configurar a data e horário de simulação da

qual depende das efemérides do Sol e campo magnético. As funções de conversão de efemérides permitem, por exemplo, transformar elementos keplerianos em vetor de estado e vice-versa. Há também funções que permitem gerar uma órbita analiticamente em elementos médios com o modelo de Brower (Brower e Clemence, 1961). A precisão obtida pelo propagador analítico é suficiente para os propósitos da simulação de atitude, principalmente considerando os pequenos intervalos de tempo necessários para a simulação (em geral menores do que poucos dias). Efemérides do Sol permitem obter a posição do Sol no sistema geocêntrico inercial, e o modelo do campo magnético terrestre calcula o campo num ponto qualquer da órbita. O intervalo de atualização destas efemérides pode ser ajustado para permitir alterações no tempo de execução do programa.

Os protótipos das rotinas de cálculo de efemérides encontram-se no arquivo orbit.h e

a biblioteca para junção (link) é orbit.lib. Um outro pacote de propagação analítica de órbita foi também gerado, em virtude da

necessidade de propagação em elementos osculadores (necessária para dar maior confiabilidade no modelo do sensor GPS). Para não sobrecarregar o processamento, decidiu-se utilizar o pacote SGP8, que emprega o modelo analítico de Brower com conversão para elementos osculadores. Os protótipos para este propagador encontram-se no cabeçalho sgp8.h, e a biblioteca encontra-se em sgp8.lib. Para utilizar este modelo deve-se selecionar o valor 1 como parâmetro da função set_orbit_propagation_model (Seção 3.10)

5.1 – Transformações de data e hora A unidade de tempo utilizada na simulação é dia Juliano modificado e fração do dia em segundos (ou tempo UTC em segundos). Foram então implementadas 4 funções para a transformação da data e hora em unidades de tempo. Estas funções foram adaptadas do pacote Orba (Kuga et alli, 1981) em Fortran, e consistem da transformação de data para dia Juliano modificado (ida e volta), e unidades de hora para tempo UTC (ida e volta). • int djm (int day, int month, int year);

90

A função djm transforma data (dia, mês e ano) em dia Juliano modificado, referido a 1950.0. Parâmetros de entrada: day

dia, passado por valor. month

mês, passado por valor. year

ano, passado por valor. Parâmetros de saída: djm

dia Juliano modificado referido a 1950.0. Exemplo: diju = djm(16, 7, 2005);

R: diju = 20285.

• vector3 djm_inv (int mjd);

Esta função obtém a data (dia, mês e ano) a partir do valor do dia Juliano modificado.

Parâmetros de entrada: mjd

dia Juliano modificado referido a 1950.0, passado por valor. Parâmetros de saída: djm_inv

data (dia, mês e ano) referente ao dia Juliano. Exemplo: date = djm_inv(20285);

R: date = 16., 7., 2005.

• double time_to_dayf (int hours, int minutes, double seconds);

A função time_to_dayf calcula a fração do dia em segundos a partir da hora UTC.

Parâmetros de entrada: hours

hora do dia (UTC) de 0 a 23, passado por valor. minutes

minutos decorridos dentro da hora (0 a 59) , passado por valor. seconds

segundos decorridos dentro do minuto (0. a 59.9999), passado por valor. Parâmetros de saída: time_to_dayf

fração do dia em segundos (UTC).

91

Exemplo: t = time_to_dayf(8, 25, 10.432);

R: t = 30310.432

• vector3 dayf_to_time (double dayf);

A função dayf_to_time calcula o horário do dia (horas, minutos e segundos) a partir

da hora UTC em segundos. Parâmetros de entrada: dayf

fração do dia em segundos, passado por valor. Parâmetros de saída: dayf_to_time

vetor contendo o horário do dia (horas, minutos e segundos). Exemplo: date = dayf_to_time (30310.432)

R: date = 8., 25., 10.432

5.2 – Conversão de efemérides

As funções para conversão de coordenadas e propagação analítica de órbita foram implementadas em Fortran por Kuga et alli (1981) no pacote Orba e convertidas para a linguagem C para uso do simulador. Os parâmetros de entrada e saída das sub-rotinas foram adaptados para ficarem compatíveis com as estruturas utilizadas aqui. Nem todas as sub-rotinas foram convertidas; apenas aquelas requeridas para o simulador. Gerou-se assim as funções delkep (variação dos elementos keplerianos pelo modelo de Brower), kepler (solução da equação de Kepler), kepel_statvec (conversão de elementos keplerianos para vetor de estado - KESTV), statvec_kepel (conversão de vetor de estado para elementos keplerianos - STKE), e gst (cálculo do tempo sideral de Greenwich). Seis outras funções foram acrescentadas, originalmente presentes no Orba: inertial_to_terrestrial (STGCP) e terrestrial_to_inertial (GCSTP) que transformam coordenadas retangulares no sistema geocêntrico inercial em coordenadas retangulares geocêntricas referidas a Greenwich e vice-versa; sph_geodetic_to_geocentric (GDGCP) e geocentric_to_sph_geodetic (GCGDP) para transformar coordenadas geocêntricas retangulares em geodéticas esféricas (e vice-versa); e spherical_to_rectangular (GSGCP) e rectangular_to_spherical (GCGSP) para transfomar coordenadas retangulares inerciais ou terrestres em coordenadas esféricas e vice-versa. • vector3 delkep (vector6 kep_el);

A função delkep calcula a variação temporal dos elementos keplerianos angulares

devido ao geopotencial terrestre (até J4) , isto é, a variação da ascenção reta do nodo ascendente, Ω, do argumento do perigeu ω, e da anomalia média, M. Estes valores são devolvidos por meio de um vetor do tipo vector3. Parâmetros de entrada:

92

kep_el


Parâmetros de saída: delkep

vetor que fornece a variação temporal (em radianos por segundo) da ascensão reta do nodo ascendente, do argumento do perigeu e da anomalia média.

Exemplo: kep_el._1._1 = 7276369.; kep_el._1._2 = 0.001; kep_el._1._3 = 25*RADIANS; kep_el._2._1 = 50*RADIANS; kep_el._2._2 = 30*RADIANS; kep_el._2._3 = 60*RADIANS; dkep = delkep (kep_el);

R: dkep = -1.15533e-06, 1.98057e-06, 1.01811e-03

• double kepler (double mean_anomaly, double eccentricity);

A função kepler obtém a solução da equação de Kepler, que relaciona a anomalia

excêntrica com a anomalia média e a excentricidade orbital. Parâmetros de entrada: mean_anomaly

variável com a anomalia média corrente da órbita, em radianos, passada por valor.

eccentricity

variável com a excentricidade orbital (compreendida entre 0 e 0.9), passada por valor.

Parâmetros de saída: kepler

anomalia excêntrica orbital em radianos. Exemplo: mean_an = 0.001; eccentr = 60*RADIANS; eccentric_anomaly = kepler (mean_an, eccentr);

R: eccentric_anomaly = 1.048064

• vector6 kepel_statvec (vector6 kepel);

A função kepel_statvec efetua a conversão de elementos keplerianos para vetor de

estado Parâmetros de entrada: kepel

93


Parâmetros de saída: kepel_statvec

vetor de 6 componentes contendo a posição do satélite nas 3 primeiras componentes, em metros, e a velocidade nas 3 componentes seguintes em metros por segundo.

Exemplo: kepel._1._1 = 7276369.; kepel._1._2 = 0.001; kepel._1._3 = 1; kepel._2._1 = 3; kepel._2._2 = 1.5; kepel._2._3 = 2; xv = kepel_statvec (kepel);

R: xv = 6939661.77,411139.64,-2159112.65, -2047.377,4071.701,-5827.863

• vector6 statvec_kepel (vector6 statv);

A função statvec_kepel efetua a conversão de vetor de estado orbital para elementos keplerianos. Parâmetros de entrada: statv

vetor de 6 componentes contendo a posição do satélite nas 3 primeiras componentes, em metros, e a velocidade nas 3 componentes seguintes em metros por segundo, passado por referência.

Parâmetros de saída: statvec_kepel

vetor de 6 componentes contendo os elementos keplerianos na ordem: semi-eixo maior orbital em metros, excentricidade orbital, inclinação em radianos, ascensão reta do nodo ascendente em radianos, argumento do perigeu em radianos e anomalia média em radianos.

Exemplo:

xv._1._1 = 6939661.77; xv._1._2 = 411139.64; xv._1._3 = -2159112.65; xv._2._1 = -2047.377; xv._2._2 = 4071.701; xv._2._3 = -5827.863;

kepel = statvec_kepel (xv); R: kepel = 7276369.00, 0.001, 1.000, 3.000, 1.500, 2.000

• double gst (int mjd, double tsec);

A função gst obtém o tempo sideral médio de Greenwich referido ao equador e

equinócio do J2000.

94

Parâmetros de entrada: mjd

dia Juliano modificado (referido a 1950.0), passado por valor. tsec

complemento do dia (UTC) em segundos, passado por valor. Parâmetros de saída: gst

tempo sideral de Greenwich em radianos, referido ao dia mjd e instante tsec. Exemplo: diju = djm(16, 7, 2005); time = 0.5; gstime = gst (diju, time);

R: gstime = 5.130125

• vector3 inertial_to_terrestrial (double tesig, vector3 xi)

A função inertial_to_terrestrial transforma coordenadas retangulares do satélite referidas ao sistema geocêntrico inercial em coordenadas geocêntricas retangulares referidas ao sistema terrestre de Greenwich. Parâmetros de entrada: tesig

tempo sideral de Greenwich (ver função gst), passado por valor. xi

vetor de estado do satélite no sistema inercial (somente posição), passado por referência.

Parâmetros de saída: inertial_to_terrestrial

vetor de estado do satélite referido ao sistema geocêntrico de Greenwich. Exemplo:

vector3 vec1, vec2; double tsig; vec1._1 = 8311888.856; vec1._2 = 4819136.336; vec1._3 = -5004550.214; tsig = 0.2732; vec2 = inertial_to_terrestrial (tsig, vec1); R: vec2 = 9303892.126, 2397741.162, -5004550.214

• vector3 terrestrial_to_inertial (double tesig, vector3 xt)

A função terrestrial_to_inertial obtém as coordenadas retangulares no sistema

geocêntrico inercial a partir das coordenadas retangulares geocêntricas referidas a Greenwich. Parâmetros de entrada: tesig

tempo sideral de Greenwich (ver função gst), passado por valor. xt

95

vetor de estado do satélite no sistema geocêntrico terrestre (somente posição), passado por referência.

Parâmetros de saída: terrestrial_to_inertial

vetor de estado do satélite referido ao sistema geocêntrico inercial. Exemplo:

vector3 vec1, vec2; double tsig; vec1._1 = 9303892.; vec1._2 = 2397741.162; vec1._3 = -5004550.214; tsig = 0.2732; vec2 = terrestrial_to_inertial (tsig, vec1); R: vec2 = 8311888.735, 4819136.301, -5004550.214

• vector3 geocentric_to_sph_geodetic (vector3 geoc)

A função geocentric_to_sph_geodetic transforma coordenadas retangulares do

satélite referidas ao sistema geocêntrico terrestre em coordenadas geodéticas, isto é: longitude, latitude geodética e altitude geodética (sobre o elipsóide terrestre de referência). Parâmetros de entrada: geoc

vetor de coordenadas de posição do satélite no sistema geocêntrico terrestre referido a Greenwich, passado por referência.

Parâmetros de saída: geocentric_to_sph_geodetic

vetor contendo as coordenadas geodéticas do satélite: longitude em radianos, latitude em radianos e altitude em metros, referidos a Greenwich.

Exemplo:

vec1._1 = 8311888.856; vec1._2 = 4819136.336; vec1._3 = -5004550.214;

vec2 = geocentric_to_sph_geodetic (vec1); R: vec2 = 1.4000, -0.8000, 630000.0000

• vector3 sph_geodetic_to_geocentric (vector3 spgd)

A função sph_geodetic_to_geocentric transforma coordenadas geodéticas, isto é,

longitude, latitude geodética e altitude geodética em coordenadas retangulares terrestres referidas a Greenwich. Parâmetros de entrada: spgd

vetor contendo as coordenadas geodéticas do satélite: longitude em radianos, latitude em radianos e altitude em metros, referidos a Greenwich, passado por referência.

96

Parâmetros de saída: sph_geodetic_to_geocentric

vetor posição do satélite no sistema geocêntrico terrestre referido a Greenwich, em metros.

Exemplo: vec2._1 = 1.4; // longitude (rad) vec2._2 = -.8; // latitude (rad) vec2._3 = 630000.; // altitude (km) vec1 = sph_geodetic_to_geocentric (vec2);

R: vec1 = 8311888.856, 4819136.336, -5004550.214

• vector3 spherical_to_rectangular (vector3 spher)

Esta função transforma coordenadas esféricas (inerciais, topocêntricas ou terrestres)

em coordenadas retangulares referidas ao mesmo sistema de eixos. Parâmetros de entrada: spher

vetor contendo as coordenadas esféricas do satélite: ascenção reta em radianos (ou o ângulo entre o eixo x e a projeção do vetor no plano xy), a declinação em radianos (ou o ângulo entre o vetor e sua projeção no plano xy) e a distância (ou módulo do vetor), passado por referência.

Parâmetros de saída: spherical_to_rectangular

vetor contendo as coordenadas retangulares, na mesma unidade do módulo do vetor.

Exemplo: vec2._1 = .9273; vec2._2 = .9273; vec2._3 = 8000000.; vec1 = spherical_to_rectangular (vec2);

R: vec1 = 2880000.0000, 3840000.0000, 6400000.0000

• vector3 rectangular_to_spherical (vector3 rectan);

Esta função transforma coordenadas retangulares em coordenadas esféricas (inerciais,

topocêntricas ou terrestres) referidas ao mesmo sistema de eixos. Parâmetros de entrada: rectan

vetor contendo as coordenadas retangulares, passado por referência. Parâmetros de saída: rectangular_to_spherical

vetor contendo as coordenadas esféricas do satélite: ascenção reta em radianos (ou o ângulo entre o eixo x e a projeção do vetor no plano xy), a declinação em radianos (ou o ângulo entre o vetor e sua projeção no plano xy) e a distância (ou módulo do vetor), na mesma unidade do vetor.

97

Exemplo: vec1._1 = 2880000.; vec1._2 = 3840000.; vec1._3 = 6400000.; vec2 = rectangular_to_spherical (vec1);

R: vec2 = 0.9273, 0.9273, 8000000.0000

5.3 – Posição do Sol A posição da Terra em sua órbita ao redor do Sol é freqüentemente requerida em simulações de atitude, uma vez que o Sol é geralmente a fonte primária de energia dos satélites. Alguns sensores e instrumentos espaciais requerem o conhecimento da direção do Sol no sistema de coordenadas do satélite para se orientarem adequadamente no espaço. A posição da Terra em relação ao Sol ou sua recíproca, isto é, a posição do Sol em relação à Terra pode ser computada por métodos analíticos de propagação, levando em conta apenas efeitos seculares ou de longo período como a precessão do eixo de rotação, por exemplo. Tais métodos, como aqueles empregados nesta modelagem, garantem uma precisão menor do que 1o nas posições angulares, suficientes para a simulação da atitude. Maiores detalhes sobre o modelo utilizado podem ser achados nas referências Kuga et al., 1981, Flandern e Pulkkinen, 1979, e The Astronomical Almanac, 1987. A versão implementada aqui foi uma transcrição para C da versão em Fortran relatada por Kuga, que por sua vez é baseada no equacionamento proposto pelo Astronomical Almanac. A Figura 5.1 mostra o típico “8” da posição do Sol relativo à Terra ao longo de um ano. No eixo vertical mostra-se a declinação do Sol (de –23.4o a 23.4o), enquanto que o eixo das abscissas tem-se a variação horária em minutos, ao longo do equador terrestre, isto é, a diferença entre a posição do Sol e seu movimento médio.

-20 -15 -10 -5 0 5 10 15H (min)

-30

-20

-10

0

10

20

30

∆

ε

Fig. 5.1 – Posição do Sol ao longo de um ano referido ao seu movimento médio.

Foram criadas as funções sun e sun_coord, descritas a seguir, que fornecem a posição

do Sol, e uma outra (earth_shadow) para detecção da sombra da Terra sobre o satélite. A diferença básica entre as funções de posição do Sol é que sun é uma subrotina que retorna com a posição do Sol em um dos seus argumentos, enquanto que sun_coord é uma função.

98

• int sun (double djm, double ts, double s[6]);

A função (subrotina) sun calcula a posição do Sol no sistema geocêntrico inercial

(J2000), em função da data e hora do dia (UTC). Parâmetros de entrada: djm

data Juliana modificada (referida a 1950.0) na qual se deseja o vetor posição do Sol, passada por valor.

ts

fração do dia em segundos, de 0 a 86400, passado por valor. Parâmetros de saída: s[6]

vetor de 6 posições com a posição do Sol no sistema geocêntrico retangular inercial (J2000), em metros, nas componentes 0 a 2, e no sistema geocêntrico polar inercial nas posições 3 a 5, respectivamente a ascenção reta em radianos, a declinação (ou latitude) solar em radianos e a distância do centro do Sol ao centro da Terra em metros.

Valor de retorno:

sun valor de retorno: 0

Exemplo: double djm, ts, s[6]; djm = 18628.; ts = 0.5; istat = sun(djm, ts, s);

R: s = 2.716e+10, -1.327e+11, -5.750e+10, 4.9143, -0.4016, 1.4710e+11.

• vector3 sun_coord (int output_sel, int djm, double ts)

A função sun_coord calcula a posição do Sol no sistema geocêntrico inercial (J2000),

em função da data e hora do dia (UTC). Parâmetros de entrada: output_sel

seletor de sistema de coordenadas dos resultados de retorno. Se for 0 (ou outro valor diferente de 1), o vetor de saída será fornecido no sistema geocêntrico retangular inercial, enquanto que se for 1 a posição do Sol é fornecida no sistema geocêntrico polar inercial. Neste caso as componentes são, respectivamente, a ascenção reta em radianos, a declinação (ou latitude) solar em radianos e a distância do centro do Sol ao centro da Terra em metros. Esta variável é passada por valor.

djm

data Juliana modificada (referida a 1950.0) na qual se deseja o vetor posição do Sol, passada por valor.

ts

fração do dia em segundos, de 0 a 86400, passado por valor. Parâmetros de saída:

99

sun_coord

vetor de 3 posições com a posição do Sol no sistema geocêntrico retangular inercial (J2000), em metros (se output_sel for igual a 0), ou no sistema geocêntrico polar inercial se output_sel for igual a 1.

Exemplo: double djm, ts; vector3 sunrec, sunpol; djm = 18628.; ts = 0.5; sunrec = sun_coord (0, djm, ts); sunpol = sun_coord (1, djm, ts);

R: sunrec = 2.716e+10, -1.327e+11, -5.750e+10 sunpol = (4.9143, -0.4016, 1.4710e+11

A função de sombra possui como argumentos a posição do satélite em coordenadas

geocêntricas inerciais retangulares e a posição do Sol no mesmo sistema. Esta função possui a seguinte sintaxe: • double earth_shadow (vector3 sat_pos, vector3 sun_pos)

A função earth_shadow verifica se uma dada posição está iluminada pelo Sol ou se

está na sombra da Terra. Parâmetros de entrada: sat_pos

vetor com a posição do satélite em coordenadas geocêntricas inerciais retangulares em metros, passado por referência.

sun_pos

vetor com a posição do Sol em coordenadas geocêntricas inerciais retangulares em metros, passado por referência (vide função sun_coord).

Parâmetros de saída: earth_shadow

variável que define se o satélite está no lado iluminado (earth_shadow = 1), ou então na sombra da Terra (earth_shadow = 0). Se o valor desta variável estiver entre 0 e 1 ela indica que a posição dada encontra-se na penumbra, e o valor representa a fração do Sol vista naquela posição (supondo um horizonte terrestre retilíneo). Se o vetor sun_pos for nulo, então a função retorna com o valor –1.

Exemplo: double earthshadow; vector3 sat_pos, sun_pos;

R: earthshadow =

100

0 90 180 270 360Angle (deg)

0.0

0.5

1.0

Shadow

5.4 – Campo magnético terrestre O campo magnético terrestre é modelado pelo IGRF10, definido por um grupo de trabalho do IAGA (International Association of Geomagnetism and Aeronomy). O modelo usa expansão em harmônicos esféricos do campo em coordenadas geocêntricas, dado por

max1

1 0

( , , , ) [ ( )cos ( )sin ] ( )nn n

m m m

n n n

n m

RV r t R g t m h t m P

r

+

= =

θ λ = λ + λ θ

∑ ∑

onde r, θ, λ são as coordenadas geocêntricas (r é a distância do centro da Terra, θ é a colatitude, ou seja, 90° – latitude, e λ é a longitude), R é o raio de referência da Terra (6371.2 km), e ( )m

ng t , ( )m

nh t são os coeficientes associados de Legendre de grau n e ordem m na

forma semi-normalizada de Schimidt, no instante t.

Os coeficientes da expansão dependem do tempo e são definidos a cada cinco anos ou menos, e interpolados linearmente nos intervalos. Para o cálculo de valores futuros (extrapolados) do campo são fornecidas as variações temporais dos coeficientes, e não os coeficientes propriamente ditos. O grau do polinômio é 10 para o intervalo compreendido entre 1900 a 1990, e de 13 para 1995 em diante. Os coeficientes para valores futuros do campo (variação temporal) possuem grau 8. A precisão obtida pelo modelo de grau 10 é de 1 nT na superfície terrestre e de 0.1 nT para o grau 13. Os coeficientes são ajustados a partir de dados provindos de observatórios magnéticos espalhados pelo globo, medições efetuadas por navios, aviões e satélites. Como o campo depende do tempo, os coeficientes passados podem sofrer novos ajustes em função da disponibilidade outras informações, bem como para compensar efeitos não lineares. Assim, eles podem ser definitivos (não sofrem mais ajustes) ou não-definitivos. São não-definitivos valores compreendidos entre 1900 e 1940, inclusive, e, devido à falta de dados colhidos naquelas décadas que garantissem uma cobertura global, provavelmente jamais serão definitivos. Valores no intervalo 1945 a 2000 são definitivos, e acima disto são não-definitivos no modelo IGRF10.

Implementou-se um modelo na linguagem C que foi convertido a partir do original em Fortran IGRF10.F, elaborado por Susan Macmillan [1], também presente em modelos da NASA [2]. Os coeficientes são armazenados no próprio código fonte (por meio de DATA), o que permite rápida execução, pois não é necessário ler um arquivo de dados, embora exija uma nova compilação sempre que houver novos dados disponíveis para o campo. Infelizmente, modelos em C já disponíveis não possuíam as características necessárias para o simulador de atitude, e portanto decidiu-se converter o citado IGRF10.F. As diferenças entre as duas implementações são menores do que 10-3 nT (3σ RMS), provavelmente devido a variações nas conversões de constantes da forma decimal para a binária entre as duas versões. As Figuras 5.2, 5.3 e 5.4 fornecem as componentes do campo geomagnético em função do

101

tempo, para o período entre 1960 e 2010. Percebe-se claramente nestas figuras a interpolação linear do campo a cada intervalo de 5 anos.

1960 1965 1970 1975 1980 1985 1990 1995 2000 2005 2010Year

28300

28400

28500

28600

28700x (north) (nT)

Fig. 5.2 – Componente norte do campo geomagnético, modelo IGRF10 versão C.

1960 1965 1970 1975 1980 1985 1990 1995 2000 2005 2010Year

700

800

900

1000

1100

y (east) (nT)

Fig. 5.3 – Componente leste do campo geomagnético, modelo IGRF10 versão C.

102

1960 1965 1970 1975 1980 1985 1990 1995 2000 2005 2010Year

-22300

-22200

-22100

-22000

-21900

-21800

-21700

-21600

-21500z (dow

n) (nT)

Fig. 5.4 – Componente vertical do campo geomagnético, modelo IGRF10 versão C. Além da função principal para o cálculo do campo geomagnético, implementou-se um

uma função adicional para permitir o uso de parâmetros comumente adotados em mecânica orbital. Assim, a função igrf10syn é praticamente igual à versão em Fortran, exceto pelos argumentos de entrada, que foram substancialmente reduzidos uma vez que não eram necessários aqui, e a função geomag_field faz a ligação entre a forma de passagem de argumentos e retorno de resultados adotada aqui com aquela adotada pela igrf10syn. Mais especificamente, o campo magnético retorna desta última por meio de um argumento (vetor de 3 componentes), enquanto geomag_field retorna um vetor do tipo vector3. As funções são descritas a seguir. • int igrf10syn (double date, double alt, double colat, double elong,

double field[3]);

A função (subrotina) igrf10syn calcula o campo magnético terrestre referido à data

date em anos e fração de anos (entre 1900 e 2014.9), na posição dada pelas coordenadas terrestres alt, colat e elong, descritas abaixo. Parâmetros de entrada: date

data na qual se deseja o vetor campo geomagnético em anos e fração de anos, compreendida no intervalo 1900 a 2014.9 (IGRF10), passado por valor.

colat

co-latitude do ponto no qual se deseja o vetor campo geomagnético, em radianos. A co-latitude é o ângulo geocêntrico entre a direção do eixo polar norte da Terra e a direção radial do ponto de cálculo. Varia entre 0 e π e é passado por valor.

elong

longitude do ponto de cálculo, positivo para leste e contado a partir do meridiano de Greenwich. Varia entre 0 e 2π (ou de –π a π) e é passado por valor.

Parâmetros de saída: field[3]

103

vetor de 3 posições que retorna com o valor do campo magnético em coordenadas locais, em nT, nas direções x (componente 0 do vetor), que corresponde à componente na direção horizontal norte do vetor magnético; y (componente 1 do vetor), correspondente à direção horizontal leste e z (componente 2 do vetor), que fornece a componente vertical, positiva para o centro da Terra.

Valor de retorno:

igrf10syn

0 se o cálculo foi bem sucedido, –1 caso a variável date esteja fora da faixa permitida (entre 1900 e 2014.9), ou 1 caso o valor de date esteja compreendido entre 2010 e 2014.9, o que significa que o campo resultante possui precisão reduzida devido à extrapolação dos coeficientes.

Exemplo: double date, alt, colat, elong, field[3]; date = 2008.0; alt = 500. + 6371.2; colat = 100.*RADIANS; elong = 120.*RADIANS; istat = igrf10syn(date, alt, colat, elong, field);

R: field = 28634.5968, 829.5033, -21599.8874.

• vector3 geomag_field (int output_sel, double date, vector3 geo_cor)

A função geomag_field fornece o campo magnético terrestre na posição geocêntrica

dada por geo_cor. Esta função retorna com o campo em unidades de Tesla, e em 3 sistemas de coordenadas distintos. Parâmetros de entrada: output_sel

seletor de sistema de eixos do campo magnético. Pode assumir os valores menor ou igual a 0 (sistema de coordenadas norte-leste-nadir, conforme o parâmetro de saída field da função igrf10syn), igual a 1 (coordenadas geocêntricas) e maior ou igual a 2 (coordenadas polares locais, respectivamente a componente horizontal do campo magnético em Tesla; declinação magnética, que corresponde ao ângulo entre a componente horizontal e a direção horizontal norte em radianos, positiva em direção leste; e a inclinação magnética, que é o ângulo entre o campo magnético e o plano horizontal, positivo para baixo). Passado por valor.

date

data na qual se deseja o vetor campo geomagnético em anos e fração de anos, compreendida no intervalo 1900 a 2014.9 (IGRF10), passado por valor.

geo_cor

coordenadas geocêntricas do ponto onde se deseja o vetor campo geomagnético, em metros, passado por referência.

Parâmetros de saída: geomag_field

vetor com as coordenadas do campo geo-magnético, ou um vetor nulo caso date esteja fora da faixa permitida.

104

Exemplo:

vector3 geofield, geocor; date = 2008.0;

alt = 500. + 6371.2; colat = 100.; elong = 120.; geocor._1 = alt*1000.*sin(colat*RADIANS)*cos(elong*RADIANS); geocor._2 = alt*1000.*sin(colat*RADIANS)*sin(elong*RADIANS); geocor._3 = alt*1000.*cos(colat*RADIANS); geofield = geomag_field (0, date, geocor);

R: geofield = 2.8634597e-005, 8.2950329e-007, -2.1599887e-005.

5.5 – SGP8 O pacote de funções SGP8 foi inicialmente desenvolvido e implementado em Fortran e consistia num propagador de órbita analítico adotado pela NASA. A principal característica deste propagador é que ele usa um modelo analítico de Brower (Brower e Clemence, 1961) com cálculo tanto dos elementos médios quanto dos elementos osculadores. O modelo foi adaptado por Hoots e Roehrich (1980). A órbita é então propagada em elementos médios, usando-se para isso os “2-line elements”, que são a forma usual de descrição dos elementos orbitais adotada pelo NORAD. Nesta descrição os elementos orbitais são organizados em duas linhas de dados, como neste exemplo: 1 15642u 85028b 98145.46280604 -.00000045 00000-0 10000-3 0 8676 2 15642 0.9415 94.0931 0002726 306.7030 253.8375 1.00303630 53828

As principais variáveis armazenadas nestas linhas de dados são a seguir indicadas

sobre o exemplo fornecido: <id1 > <id2 > <epoch > <xndt20 > <xndd60> <bstar > 1 15642u 85028b 98145.46280604 -.00000045 00000-0 10000-3 0 8676 <xincl > <xnodeo> <eo > <omegao> <xmo > <xno > <rev> 2 15642 0.9415 94.0931 0002726 306.7030 253.8375 1.00303630 53828

onde id1 e id2 são identificadores do satélite ou veículo orbital, epoch é o tempo das efemérides, no formato yyddd.dddddddd no qual yy representa o ano (entre 1957 e 2056), e ddd.dddddddd é o dia do ano (a partir de 1o de janeiro) e fração do dia. A seguir tem-se, respectivamente, a primeira e a segunda derivadas temporais do movimento médio, isto é nɺ (xndt20) e nɺɺ (xndd60), em ciclos pelo quadrado de dia e ciclos pelo cubo de dia, em formato exponencial e o último no formato exponencial e multiplicado por 105. O último elemento de interesse na primeira linha é B*, ou bstar, relacionado com o arrasto atmosférico e também no formato exponencial e multiplicado por 105. A segunda linha apresenta, após a identificação, a inclinação orbital xincl em graus, a ascenção reta do nodo ascendente orbital xnodeo também em graus, a excentricidade eo (ponto decimal assumido à esquerda) e o argumento do perigeu omegao em graus. Os dois parâmetros seguintes são a anomalia média xmo e o movimento médio xno em ciclos por dia. O último parâmetro é o número da órbita rev, com um dígito decimal assumido.

Na conversão do pacote em Fortran para a linguagem C, optou-se pela descrição dos elementos orbitais por meio de uma estrutura, definida pelo tipo nasa_el, com os seguintes componentes, todos do tipo duplo (double):

105

ne.mean_motion - movimento médio em radianos por segundo ne.eccentricity - excentricidade ne.inclination - inclinação em radianos ne.right_ascension - ascenção reta do nodo ascendente em radianos ne.perigee - argumento do perigeu em radianos ne.mean_anomaly - anomalia média em radianos ne.mean_motion_dot - derivada do movimento médio dividido por 2 em rad/s2 ne.mean_motion_dot_dot - segunda derivada dividida por 6 em rad/s3 ne.bstar - B* em unidades do inverso do raio da Terra ne.revolution_number - número da órbita referido ao tempo das efemérides ne.mod_julian_date - data Juliana modificada do tempo das efemérides ne.day_fraction - fração do dia em segundos do tempo das efemérides.

A conversão dos parâmetros de 2-line para os parâmetros da estrutura acima deve ser feita na forma:

ne.mean_motion = 2

86400

π xno

ne.eccentricity = 10-7 eo

ne.inclination = 180

π xincl

ne.right_ascension = 180

π xnodeo

ne.perigee = 180

π omegao

ne.mean_anomaly = 180

π xmo

ne.mean_motion_dot = 2

2

86400

π xndt20

ne.mean_motion_dot_dot = 3

2

86400

π10-5 xndd60

ne.bstar = 10-5 bstar ne.revolution_number = 10-1 rev

A data Juliana modificada e a fração do dia são calculadas com base no tempo das

efemérides epoch usando para isto a função djm (ver Capítulo 5).

Esta estrutura pode ser fornecida diretamente ao propagador de órbita, ou então se pode igualmente utilizar uma função para ler um arquivo no formato 2-line elements. Uma vez que o propagador necessita de uma grande quantidade de parâmetros derivados dos elementos apontados acima, é conveniente calculá-los previamente antes de ser acionada a propagação. A função sgp8 faz este cálculo e necessita ser chamada sempre que algum elemento orbital for modificado externamente ao propagador. Este pacote está contido no arquivo sgp8.lib, e utiliza o arquivo de cabeçalho sgp8.h que descreve os protótipos das funções e a definição da estrutura nasael. Foram implementadas funções para efetuar a leitura de um arquivo no formato “2-line”, para a inicialização da propagação pelo SGP8, para propagar a órbita em elementos médios e osculadores, para obter o semi-eixo maior da órbita

106

a partir dos elementos 2-line e para calcular o movimento médio a partir dos elementos keplerianos. Segue a descrição das funções implementadas neste pacote. • nasa_el nasael (void *ifile, int itype);

Esta função efetua a leitura de um arquivo indicado pelo apontador de arquivo ifile

contendo as duas linhas dos elementos orbitais. Após a leitura o arquivo poderá ser fechado com a função fclose. Parâmetros de entrada: ifile

apontador para o arquivo no formato 2-line elements, com os elementos orbitais. Este apontador é do tipo FILE e deve ser inicializado antes de ser enviado a nasael (isto é, deve-se preliminarmente abrir o arquivo com a função fopen). Não possui valor default e é passada por referência.

itype

variável que indica o tipo de dados a serem lidos. No caso de elementos no formato 2-line esta variável deve ser igual a 2, e atualmente é o único formato suportado.

Parâmetros de saída: nasael

estrutura contendo os elementos orbitais no formato 2-line. Caso o arquivo não seja encontrado ou caso o valor de itype seja diferente de 2 a função irá devolver uma estrutura contendo valores inválidos, porém sem alertar para isso.

Exemplo: FILE *ifile; ifile = fopen("nasa2l.dat", "r"); nsel = nasael (ifile, 2); fclose(ifile); R:

nsel.mean_motion: 7.2942858133423323e-05 nsel.eccentricity: 2.7260000000000001e-04 nsel.inclination: 1.6432274907526613e-02 nsel.right_ascension: 1.6422343984082766e+00 nsel.perigee: 5.3529771757441678e+00 nsel.mean_anomaly: 4.4303001400311066e+00 nsel.mean_motion_dot: -3.7876068836682496e-16 nsel.mean_motion_dot_dot: 0.0000000000000000e+00 nsel.bstar: 1.0000000000000000e-04 nsel.revolution_number: 5.3820000000000000e+03 nsel.mod_julian_date: 1.7676000000000000e+04 nsel.day_fraction: 3.9986441855924204e+04

• int sgp8 (nasa_el nasael);

Esta função inicializa os diversos coeficientes utilizados pelo propagador de órbita, e

deve ser chamada sempre que os elementos orbitais sofrerem modificações externas, como uma nova órbita, por exemplo. Parâmetros de entrada: nasael

107

estrutura contendo os elementos orbitais conforme descrição anterior. Parâmetros de saída:

sgp8 valor de retorno: 0.

Exemplo:

sgp8 (nasael);

• vector6 sgp8pr_mean (double tsince);

Esta função propaga analiticamente a órbita usando o propagador SGP8 do NORAD, e

retorna com o vetor de estado médio. Para utilizar esta função é necessário que os parâmetros orbitais tenham sido inicializados pela função sgp8. Parâmetros de entrada: tsince

intervalo de tempo de propagação, em segundos. Os elementos orbitais são calculados no instante tefm + tsince, onde tefm é o instante ou tempo das efemérides, fornecido na estrutura nasael.

Parâmetros de saída: sgp8pr_mean

vetor de 6 componentes contendo o vetor de estado médio (posição e velocidade) do satélite, em coordenadas inerciais geocêntricas, e em metros e metros por segundo.

Exemplo: FILE *ifile; ifile = fopen("nasa2l.dat", "r"); nsel = nasael (ifile, 2);

fclose(ifile) stat = sgp8 (nsel); xv = sgp8pr_mean (2000.); R:

xv = 22934679.24369220, -35372604.64895410, -334452.86197629, 2579.06288716, 1673.60545692, -44.23858330

• vector6 sgp8pr (double tsince);

Esta função propaga analiticamente a órbita usando o propagador SGP8 do NORAD, e

retorna com o vetor de estado osculador. Para utilizar esta função é necessário que os parâmetros orbitais tenham sido inicializados pela função sgp8. Parâmetros de entrada: tsince

intervalo de tempo de propagação em segundos. Os elementos orbitais são calculados no instante tefm + tsince, onde tefm é o instante ou tempo das efemérides, fornecido na estrutura nasael.

Parâmetros de saída: sgp8pr

108

vetor de 6 componentes contendo o vetor de estado osculador (posição e velocidade) do satélite, em coordenadas inerciais geocêntricas, e em metros e metros por segundo.

Exemplo: FILE *ifile; ifile = fopen("nasa2l.dat", "r"); nsel = nasael (ifile, 2);

fclose(ifile) stat = sgp8 (nsel); xv = sgp8pr (2000.); R:

xv = 22934038.73112890, -35371223.80886380, -334437.47057289, 2579.15087253, 1673.67177420, -44.24107369

• double mean_a (nasa_el nasael);

A função mean_a calcula o semi-eixo maior médio da órbita.

Parâmetros de entrada: nasael

estrutura contendo os elementos orbitais conforme descrição anterior. Parâmetros de saída: mean_a

semi-eixo maior médio referente aos elementos orbitais fornecidos, em metros. Exemplo: FILE *ifile; ifile = fopen("nasa2l.dat", "r"); nsel = nasael (ifile, 2);

fclose(ifile) stat = sgp8 (nsel); a = mean_a(nsel); R:

a = 42156858.339783564

• double mean_n (vector6 kepel);

A função mean_n calcula o movimento médio da órbita com base nos elementos

keplerianos. Parâmetros de entrada: kepel

vetor de 6 componentes contendo os elementos keplerianos da órbita. Os três últimos elementos angulares (ascenção reta do nodo, argumento do perigeu e anomalia média) não são utilizados.

Parâmetros de saída: mean_n

movimento médio orbital em radianos por segundo. Exemplo: FILE *ifile;

109

ifile = fopen("nasa2l.dat", "r"); nsel = nasael (ifile, 2);

fclose(ifile) stat = sgp8 (nsel); a = mean_a(nsel); xv._1._1 = a; xv._1._2 = nsel.eccentricity; xv._1._3 = nsel.inclination; xv._2._1 = nsel.right_ascension; xv._2._2 = nsel.perigee; xv._2._3 = nsel.mean_anomaly; n = mean_n (xv);

R: n = 7.2942858133423323e-05

111

6 – Simulação de equipamentos

Adotou-se certos procedimentos no processo de modelagem dos equipamentos para simulação de atitude. Em primeiro lugar, admite-se que a simulação em computador jamais será tão fiel quanto o sistema ou equipamento real. Isto implica que, por mais sofisticado ou complexo que sejam os modelos matemáticos, ainda assim permanece um erro com relação ao sistema real. Por outro lado, a simplificação em demasia pode tornar a simulação distante da realidade. O ponto de equilíbrio adotado será, portanto, aquele que permita uma certa confiabilidade da simulação ainda retendo o modelo num nível de complexidade adequado (sem comprometer, por exemplo, a execução da simulação em tempo-real). Infelizmente, critérios que permitam definir qual é o nível de complexidade adequado são difíceis de se estabelecer e de se medir. Um pouco de “sensibilidade”, ou de “bom senso”, neste caso, é inevitável. Outros procedimentos que orientam a modelagem devem garantir uma certa generalidade no modelo e a possibilidade de configuração para permitir, entre outros, a simulação de modos de falha e análise de pior caso.

Nesta primeira versão não se levou em conta os efeitos de amostragem caracterizados por eletrônica “sample and hold”. Isto significa que as medidas referem-se ao instante de tempo corrente, e atrasos eletrônicos são simplesmente descartados. O cabeçalho referente às funções apresentadas aqui está disponível em sensors.h.

Os modelos apresentados aqui seguem um padrão: utiliza-se uma função para efetuar a

configuração dos sensores (número, desvio padrão do ruído, direção de medida, etc.) e outra para efetuar a leitura. Obviamente, a função de configuração deve ser vista como integrante do ambiente de simulação, porém a leitura está associada ao controlador de atitude. Isto significa que estas funções devem ser executadas em processos independentes numa implementação futura que envolva tempo-real. Por processo independente entende-se dois programas executados numa mesma máquina (em tempo compartilhado), ou em máquinas diferentes comunicando-se entre si para troca de informações. Os sensores, ao contrário dos atuadores, podem ser posicionados em qualquer parte do satélite, até mesmo em apêndices articulados. De fato a PMM prevê a utilização de sensores solares analógicos fixados ao painel solar giratório. Para dotar o simulador de atitude de um caráter de generalidade, decidiu-se que tais sensores podem ser fixados quer no corpo principal ou em qualquer um dos apêndices, portanto solidário a este em seu movimento relativo ao corpo principal.

Os sensores (e também atuadores) estão sempre sujeitos a ruídos. Estes ruídos raramente constituem um ruído branco (gaussiano), mas tampouco se conhece sua real natureza e distribuição. Portanto a melhor alternativa é modelá-los por meio de um ruído branco. Porém, os recursos disponíveis na linguagem C para modelar ruído são em geral limitados e diferem de compilador para compilador. Um outro problema que tais recursos apresentam refere-se à impossibilidade de se criar diversas variáveis aleatórias independentes, como seria desejável para que se pudesse dispor de uma variável aleatória para cada medida simulada. A vantagem de tal recurso torna-se evidente quando se verifica que duas simulações idênticas no tocante às condições iniciais, podem resultar diferentes caso seja retirado ou inserido um sensor a mais, mesmo que o resultado desta leitura não influa na propagação nem no controle da atitude. Computacionalmente falando, trata-se de uma limitação nas funções capazes de gerar variáveis aleatórias, que não requerem argumento para gerar um novo valor. Este processo pode ser explicado por meio de duas situações distintas. Na primeira delas, duas variáveis s1 e s2 recebem valores aleatórios por meio da função rand, que por sua vez foi iniciada pela função srand (função gérmen ou semente):

112

... srand(3452); s1 = rand(); s2 = rand(); ... s1 = rand(); s2 = rand(); ...

gerando os valores, por exemplo, 0.392, 0.872, 0.466 e 0.592, e tendo o primeiro sensor recebido o primeiro e o terceiro valor. Caso seja removido da simulação o segundo sensor, então s1 receberia o primeiro e o segundo valor da função rand ou seja, 0.392 e 0.872. As simulações seriam, portanto, diferentes. Um exemplo de uma função capaz de gerar mais de uma variável aleatória seria:

... n1 = srand(3452); n2 = srand(5981) s1 = rand(n1); s2 = rand(n2); ... s1 = rand(n1); s2 = rand(n2); ...

Neste exemplo, n1 e n2 recebem valores que permitem selecionar duas (ou mais)

seqüências de valores aleatórios, e são depois utilizados na identificação da variável aleatória a ser gerada. Assim a remoção completa de s2 não altera a seqüência de valores aleatórios gerados para s1. É desnecessário dizer que a função rand da linguagem C não suporta este tipo de configuração.

Torna−se então imperioso a construção de uma interface para padronizar o acesso e o uso de variáveis aleatórias que permita, futuramente, a incorporação de novos recursos numa revisão ou num aperfeiçoamento das funções descritas aqui. Esta interface será descrita a seguir, e, logo em seguida, as implementações dos sensores e atuadores.

As funções descritas e modeladas aqui são portanto:

• geração de variáveis aleatórias • magnetômetro • sensor solar analógico • sensor de estrela • sensor GPS • unidade inercial (giros) • bobinas magnéticas • propulsores • rodas de reação • mecanismo de rotação do painel solar – BAPTA

113

6.1 – Funções de variáveis aleatórias Supondo então que sensores e atuadores sejam perturbados por ruídos brancos, implementou-se as funções gaussian_noise e s_gaussian_noise para gerar e iniciar a geração de variáveis aleatórias, respectivamente. Criou-se também a função vec_gaussian_noise para gerar um ruído na forma de um vetor. • double gaussian_noise(unsigned long id_noise);

A função gaussian_noise retorna com uma variável aleatória gaussiana de média

nula e desvio padrão unitário. A função foi adaptada para C a partir da função GAUSS (Fortran), e utiliza o gerador de números aleatórios rand()com distribuição uniforme entre 0 e RAND_MAX. Na presente implementação o argumento id_noise não é utilizado. Parâmetros de entrada: id_noise

identificador da variável aleatória. Várias variáveis aleatórias podem ser definidas e usadas simultaneamente. Este recurso não se encontra operacional nesta versão. Variável passada por valor.


gaussian_noise

variável aleatória de uma distribuição normal (gaussiana) de média nula e desvio padrão unitário.

Exemplo: unsigned long a;

double x; a = s_gaussian_noise (0);

x = gaussian_noise(a);

• double s_gaussian_noise(unsigned long seed);

A função s_gaussian_noise inicializa o gerador de números aleatórios com o

gérmen seed. Esta função utiliza a função de inicialização do gerador de variável aleatória da linguagem C, srand(seed). Na presente implementação, esta função retorna com um valor nulo. Parâmetros de entrada: seed

semente de inicialização do gerador aleatório. Variável passada por valor. Parâmetros de saída:

s_gaussian_noise

identificador da variável aleatória de uma distribuição normal (gaussiana) de média nula e desvio padrão unitário. Na presente implementação, esta função retorna com um valor nulo.


double x; a = s_gaussian_noise (0);

114

x = gaussian_noise(a);

• vector3 vec_gaussian_noise (unsigned long id_noise);

A função vec_gaussian_noise retorna com um vetor de variáveis aleatórias

gaussianas de média nula e desvio padrão unitário. Na presente implementação o argumento id_noise não é utilizado. Parâmetros de entrada: id_noise

identificador da variável aleatória. Várias variáveis aleatórias podem ser definidas e usadas simultaneamente. Este recurso não se encontra operacional nesta versão. Variável passada por valor.


vec_gaussian_noise

vetor de 3 componentes contendo valores de uma variável aleatória com distribuição normal (gaussiana) de média nula e desvio padrão unitário.


vector3 x; a = s_gaussian_noise (0);

x = vec_gaussian_noise(a);

6.2 – Magnetômetro Considerou-se o modelo de um magnetômetro de 3 eixos, no qual os efeitos predominantes são a matriz de correlação do ruído branco (desvio padrão) σmag, o viés (“bias”) Bmag, o ganho escalar ou fator de conversão Kmag, e as direções dos eixos de medida do magnetômetro emag junto com eventuais desalinhamentos destes eixos. São descartados no modelo efeitos de não-linearidade e outros. O modelo considerado é dado por: [ ( ) ]mag mag mag T mag mag magr K e B B= + + σ ω ,

onde ωmag é um vetor de variável aleatória gaussiana de média nula e variância unitária, e BT é a direção do campo magnético terrestre no sistema de referência do satélite. Nota-se que o viés neste modelo é referido ao sistema geométrico do satélite, enquanto que o ruído é referido ao sistema do próprio sensor. Embora fosse igualmente possível e provável que o viés seja característico do instrumento, sabe-se, contudo, que efeitos eletromagnéticos a bordo do satélite provocam vieses maiores do que aqueles internos ao sensor. Uma vez que seria possível fixar um magnetômetro num apêndice (de fato, alguns satélites são providos de mastro com magnetômetro na ponta), deve-se neste caso efetuar uma rotação de coordenadas entre ambos os sistemas (geométrico do satélite e do apêndice). A função get_body_rmatrix (Seção 3.6) fornece a matriz de rotação Rs,ap entre o apêndice e o satélite: ,s s ap apr R r= ,

115

onde rap é um vetor qualquer referido ao sistema fixado a um apêndice e rs representa as coordenadas deste vetor no sistema geométrico do corpo principal. Caso o magnetômetro seja fixado ao apêndice, então deve-se exprimir o campo magnético neste sistema, o que leva o modelo a ,[ ( ) ]T

mag mag mag s ap T mag mag magr K e R B B= + + σ ω ,

e. neste caso, as direções do eixos do magnetômetro emag referem-se ao sistema fixado ao apêndice. Duas funções foram implementadas para simular um magnetômetro: set_3axis_mag para configurar o sensor e read_3axis_mag para efetuar uma leitura. O campo magnético terrestre é calculado internamente ao invocar a função get_body_geomag_vector, (ver Seção 3.10). Não se deve esquecer de iniciar a geração de variáveis aleatórias com a função s_gaussian_noise. Segue a descrição das funções. • int set_3axis_mag (int ind_body, matrix3 axis_dir, matrix3 std_dev,

vector3 bias, double k_mag);

Esta função configura um magnetômetro de 3 eixos para ser utilizado na simulação.

Parâmetros de entrada: ind_body

índice do apêndice no qual é fixado o sensor. O corpo principal do satélite possui índice igual a zero. Maiores detalhes a respeito da configuração de apêndices podem ser vistos na seção 3.6. O valor default desta variável é nulo e deve ser passada por referência.

axis_dir

matriz emag contendo os vetores unitários das direções dos 3 eixos do magnetômetro, armazenados em linhas, referidos ao sistema geométrico do corpo do satélite. Seu valor default é uma matriz identidade. Variável passada por referência.

std_dev

matriz de correlação das medidas (desvio padrão σmag) em Tesla, com valor default igual a uma matriz diagonal com elementos da diagonal iguais a 10-7 (100 nT ou 1mG). Variável passada por referência.

bias

vetor contendo o viés do magnetômetro Bmag em seus 3 eixos, em Tesla, com valor default igual a um vetor nulo. Variável passada por referência.

k_mag

ganho do magnetômetro (ou fator de conversão Kmag), em unidades de leitura por Tesla. Seu valor default é unitário. Variável passada por valor.

Parâmetros de saída: set_3axis_mag


auxi = s_gaussian_noise (0.); axis_d = identity(1.); std_dev = identity(2.e-7); bias._1 = -2.e-7; bias._2 = 4.e-7;

116

bias._3 = -3.e-7; istat = set_3axis_mag (axis_d, std_dev, bias, 1.);

• vector3 read_3axis_mag ();

Esta função obtém a leitura de um magnetômetro de 3 eixos configurado pela função

set_3axis_mag. Para que esta função tenha sucesso é necessário iniciar anteriormente a geração de variáveis aleatórias. Parâmetros de entrada:

não há Parâmetros de saída: read_3axis_mag

vetor contendo a leitura do magnetômetro, em unidades definidas pela variável k_mag.

Exemplo:

vector3 r_mag; auxi = s_gaussian_noise (0.); axis_d = identity(1.); std_dev = identity(2.e-7); bias._1 = -2.e-7; bias._2 = 4.e-7; bias._3 = -3.e-7; istat = set_3axis_mag (axis_d, std_dev, bias, 1.); r_mag = read_3axis_mag ();

6.3 – Sensor solar analógico Sensores solares são utilizados para determinar a orientação do Sol com relação ao satélite. Eles podem ser digitais ou analógicos, e em ambos há uma diversidade grande de tecnologias e métodos. Em comum a todos eles é a utilização de elementos foto-sensíveis ou foto-células na geração do sinal. Sensores digitais apresentam precisão entre 0,1 a 0,5o; já os analógicos atingem no máximo 1o. Os modelos matemáticos de tais sensores devem seguir a tecnologia empregada na sua produção. Os sensores previstos para utilização na PMM são do tipo analógico grosseiro, em número de 8, sendo cada um deles constituído de uma única foto-célula. Eles estão dispostos numa configuração que seguem as faces de um octógono regular. Quando iluminados pelo Sol, apresentam correntes proporcionais à intensidade luminosa do Sol e aproximadamente proporcionais ao co-seno do ângulo formado pela normal ao sensor e a direção do Sol. Técnicas de calibração permitem obter uma curva da corrente em função do ângulo do sensor relativo ao Sol, o que melhora a precisão obtida. O modelo desenvolvido aqui apresenta as seguintes características:

a) Considera a variação da intensidade luminosa em função da maior ou menor aproximação da Terra ao longo da órbita ao redor do Sol

b) Não considera efeitos do albedo terrestre, que podem interferir nas medições efetudadas.

c) Considera o efeito da sombra da Terra, com transição suave na penumbra (o que leva a medições errôneas).

d) Supõe que os sensores estejam completamente desobstruídos na sua linha de visada, isto é, que o sensor não possa ser sombreado por alguma parte do satélite.

117

e) O sensor apresenta uma curva que segue a lei de Lambert, isto é, proporcional ao co-seno do ângulo de incidência da luz.

f) O Sol é considerado como uma fonte puntual. Nota-se que é necessário propagar a órbita do satélite, uma vez que o cálculo da

sombra da Terra depende da posição orbital. Quando o sensor é conectado a um resistor, a corrente gerada torna-se uma tensão

variável, que pode ser convertida num sinal digital. Consideram-se duas fontes de ruído em cada sensor: uma delas é absoluta e outra é relativa, ponderadas pelo respectivo desvio padrão. A leitura de cada sensor segue então a relação:

2

1( )(1 ) , se > 0

, se 0

css shadow css sun r r a a css sun

css AU

css a a css sun

K s N r N rs D

K N r

+ σ ω +σ ω =

σ ω ≤

i i

i

,

onde DAU é a distância Terra-Sol em unidades astronômicas (aproximadamente 149 10

9 m), rsun é o vetor unitário Terra-Sol, relativo ao sistema geométrico do satélite, Ncss é o vetor unitário normal à foto-célula, e σa e σr são os desvios-padrão do ruído absoluto e relativo apresentado pelo sensor (sem unidades). Kcss é o ganho do sensor, geralmente dado em Volts, e sshadow é a condição de sombra da Terra (função earth_shadow, Seção 5.3) Nota-se que o ruído relativo, ωr, é multiplicativo, enquanto que o absoluto, ωa, é aditivo. O ruído relativo faz com que o ele seja pequeno quando a corrente gerada for também pequena. Este modelo inclui ainda a condição de iluminação, isto é, o sinal só é gerado se o sensor for iluminado diretamente pelo Sol. O vetor unitário rsun é obtido neste modelo por meio de

sunsun

sun

vr A

v=

onde vsun é o vetor Terra-Sol no sistema inercial, e A é a matriz de atitude, obtida pela função quatrmx e get_attitude (Seção 3.8). Caso o sensor seja fixado a um apêndice, então o vetor Terra-Sol deve ser referido ao sistema fixado a este apêndice e, neste caso,

,T sun

sun s ap

sun

vr R A

v= ,

onde Rs,ap é a matriz de rotação entre o apêndice e o satélite (função get_body_rmatrix - ver Seção 3.6). As funções para configuração do sensor solar analógico são apresentadas a seguir. • int set_css_number (int cssnum)

A função set_css_number especifica o número de sensores solares analógicos

(Coarse Sun Sensor) presente no satélite. O valor máximo de sensores é limitado a 16. O valor default para o número de sensores é 0, e se o valor de cssnum for maior ou igual a um, cada sensor é inicializado por esta função com valores default de Ncss = (1, 0, 0), σa = σr = 0.01 e Kcss = 1 e todos relativos ao sistema geométrico do corpo principal.

118


cssnum número de sensores solares no satélite, passado por valor.


set_css_number Valor de retorno: 0 se bem sucedida, ou –1 caso o número de sensores ultrapasse o valor máximo permitido de 16 (ou menor do que 0). Neste caso o valor de cssnum é rejeitado.

Exemplo:

istat = set_css_number(2);

• int get_css_number ()

Esta função retorna com o número de sensores solares especificados para o satélite

pela função set_css_number. Parâmetros de entrada:


get_css_number número de sensores especificados.

Exemplo:

istat = set_css_number(2); istat = get_css_number(); R: istat = 2

• int set_coarse_sun_sensor (int ind_css, int ind_body, vector3

css_normal, double css_abs, css_rel, double k_css)

A função set_coarse_sun_sensor estabelece o vetor normal Ncss ao plano da foto-

célula e o desvio padrão σcss do ruído da célula cujo índice é especificado por ind_css. Os sensores são numerados de 1 até cssnum. A direção da normal é positiva no sentido externo do sensor, referida ao sistema de coordenadas do corpo principal (ind_body = 0) ou do apêndice de índice ind_body. O módulo do vetor css_normal deve ser unitário, mas esta função normaliza o vetor independentemente da sua magnitude. Parâmetros de entrada:

ind_css variável contendo o índice de um dado sensor solar (de 1 até cssnum), passado por valor.

css_normal vetor que fornece a direção da normal ao sensor de número ind_css, passado por referência.

css_abs desvio padrão do ruído absoluto do sensor em fração de unidade, passado por valor.

119

css_rel desvio padrão do ruído relativo do sensor em fração de unidade, passado por valor.

k_css fator de conversão de unidades do sensor solar, Kcss, em geral medido em volts, e passado por valor.


set_coarse_sun_sensor valor de retorno: 0 se bem sucedida, –1 caso o índice ind_css esteja fora da faixa permitida (de 1 a cssnum). Neste caso os parâmetros são rejeitados.

Exemplo:

istat = set_css_number(2); auxi = s_gaussian_noise (0); css_rel = 0.02; css_abs = 0.01; auxi = sqrt(2.)/2.; vec2._1 = 0.5; // +X +Y +Z vec2._2 = 0.5; vec2._3 = auxi; istat = set_coarse_sun_sensor (1, 0, vec2, css_ab, css_rel, 1); vec2._1 = -0.5; // -X +Y +Z vec2._2 = 0.5; vec2._3 = auxi; istat = set_coarse_sun_sensor (2, 0, vec2, css_ab, css_rel, 1);

• double read_coarse_sun_sensor (int ind_css)

A função read_coarse_sun_sensor obtém a leitura do sensor solar analógico de

índice ind_css. O valor de retorno é um número maior ou igual a 0 e menor do que 1.08 Kcss adicionado do ruído. Parâmetros de entrada:

ind_css variável contendo o índice do sensor solar (de 1 até cssnum), passado por valor.


read_coarse_sun_sensor

variável contendo a leitura do sensor solar de índice ind_css, ou –1 caso o índice esteja fora da faixa permitida.

Exemplo:

double r_css1, r_css2; auxi = s_gaussian_noise (0); istat = set_css_number(2); css_rel = 0.02; css_abs = 0.01; auxi = sqrt(2.)/2.; vec2._1 = 0.5; // +X +Y +Z vec2._2 = 0.5; vec2._3 = auxi; istat = set_coarse_sun_sensor (1, 0, vec2, css_ab, css_rel, 1); vec2._1 = -0.5; // -X +Y +Z

120

vec2._2 = 0.5; vec2._3 = auxi; istat = set_coarse_sun_sensor (2, 0, vec2, css_ab, css_rel, 1); r_css1 = read_coarse_sun_sensor(1); r_css2 = read_coarse_sun_sensor(2);

6.4 – Sensor de estrela Sensores de estrela fornecem diretamente a atitude no sistema de referência geocêntrico inercial. Estes sensores são digitais e, portanto, apresentam a saída numa freqüência fixa, em geral da ordem de algumas amostras por segundo. Durante o processo de inicialização do sensor, porém, a taxa de amostragem é muito baixa, em virtude da necessidade de identificar as estrelas presentes no seu campo de visada. É comum, nos sensores atuais, uma inicialização da ordem de 15 segundos a 1 minuto. Neste intervalo o sensor não provê informações. A partir da detecção da atitude, o sensor entra no modo de rastreamento, no qual a atitude é comparada com a anterior e pequenos desvios são detectados. Desta forma não é mais necessário recorrer ao catálogo de estrelas. A busca ao catálogo é mais rápida quando uma estrela entra no campo de visada, pois a atitude já é conhecida. Este intervalo de inicialização do sensor não será modelado aqui, mas tão somente o modo de rastreio. Sensores de estrela apresentam a atitude inercial na sua saída, na forma digital. Esta atitude é atualizada numa freqüência que depende do fabricante, e não será modelada aqui. Supõe-se, portanto, que a medida apresentada pelo sensor seja aquela da última atualização da atitude efetuada pelo propagador de atitude, ou seja, ao fim de um ciclo de integração. Sensores de estrela apresentam um erro direcional, pois sua precisão é maior em direções ortogonais ao eixo ótico do sensor. Assim, deve-se fornecer as direções dos eixos do sensor para que se possa considerar este efeito na modelagem. Alguns sensores de estrela fornecem a atitude do sistema geométrico fixado ao corpo do satélite, desde que sejam informados por telecomando da atitude do sensor relativa a este sistema. Será suposto, por enquanto, que o sensor fornece a atitude no seu próprio sistema de coordenadas. Uma vez que a atitude do satélite é conhecida no sistema de eixos geométrico, será necessário, todavia, que esta seja transformada para o sistema do sensor e, para tanto, requer-se a matriz de rotação entre ambos os sistemas. Esta matriz permite que se configure desalinhamentos entre eixos e erros de alinhamento.

A matriz de atitude do satélite tem a forma

1 2 3

1 2 3

1 2 3

u u u

A v v v

w w w

=

,

onde u, v e w, são os eixos do sistema geométrico do satélite, expressos no sistema inercial. Se a for um vetor no sistema inercial, então o produto A a fornece as componentes deste vetor no sistema geométrico do satélite. Analogamente, se q for o quatérnion da atitude, então o produto q a q fornece as componentes do vetor a no sistema geométrico do satélite (Wertz, 1978), aqui considerando que o vetor a possa ser representado por um quatérnion com parte real nula, e que o produto de dois quatérnios é também um quatérnion que vale:

121

1 1 2 2 3 3 4 4 1 4 2 3 3 2 4 1

1 3 2 4 3 1 4 2 1 2 2 1 3 4 4 3

'' ' ( ) ( )

( ) ( )

q q q q q q q q q q q q q q q q q q q i

q q q q q q q q j q q q q q q q q k

′ ′ ′ ′ ′ ′ ′ ′= = − − − + + + − + +

′ ′ ′ ′ ′ ′ ′ ′− + + + + − − + +,

no qual i, j e k são os versores da base do quatérnion. Considerando agora que Ass seja a matriz de atitude que relaciona o sistema de coordenadas do sensor de estrela em relação ao sistema geométrico do satélite, então a matriz de atitude apresentada pelo sensor será Astar = Ass A. Esta expressão é equivalente, na notação de quatérnios, à qstar = q qss, na qual qss representa a atitude do sistema do sensor em relação ao sistema do satélite.

O modelo proposto aqui considera que o sensor apresente em sua saída um erro

associado a um desvio angular θ, ψ, e φ nos seus três eixos. Supondo que o erro seja pequeno, então estes ângulos tornam-se infinitesimais e vale a relação (Wertz, 1978, Seção 12.1):

1

2

3

4

/ 2

/ 2

/ 2

1

q

q

q

q

ω

ω

ω

ω

θ

ψ

φ

≃

≃

≃

≃

,

no qual os ângulos θ, ψ, e φ estão associados aos eixos x, y e z, respectivamente, de uma rotação de Euler numa seqüência 123, 132, 213, 231 ou 312. Os valores destes ângulos são obtidos a partir de um ruído branco ωstar de média nula e desvio padrão unitário, e da matriz de covariância do erro σstar:

star star

θ ψ = σ ω φ

.

Nota-se que, se z for o eixo ótico do sensor, o desvio padrão do ruído apresentado na terceira componente da diagonal da matriz σstar será maior do que os demais. Como o erro corresponde a uma rotação efetuada em quatérnions, então a leitura apresentada pelo sensor incluindo o erro será

star ssq q q qω=

Finalmente, o quatérnion qss que fornece a orientação do sensor relativo ao satélite, pode ser obtido a partir dos elementos da matriz dos co-senos diretores dos eixos do sensor no sistema do satélite, Ess (Wertz, 1978, Seção 12.1), com o uso da função rmxquat (Seção 4.2). Como o quatérnion que descreve o ruído não é normalizado, é efetuada uma normalização de qstar após seu cálculo. Se o sensor a ser simulado fornecer diretamente o quatérnion de atitude do sistema geométrico do satélite, deve-se atribuir à matriz de atitude do sensor, Ass, uma matriz identidade. Por outro lado, caso o sensor apresente a atitude no seu próprio sistema de referência, então deve-se calcular a matriz de atitude do satélite (ou o quatérnion de atitude) por meio da relação

122

T

ss starA A A=

ou

star ssq q q=

Nota-se que a matriz Ass pode incluir o efeito de desalinhamento do sensor, bastando para isso que: ss ss ssE D A= ,

onde Dss é a matriz de desalinhamento do sensor, ou seja, a matriz cujas linhas descrevem os co-senos diretores dos eixos desalinhados do sensor em relação à posição teórica destes eixos. Na presente implementação não se encontram modelados os efeitos da presença da Terra, Lua ou Sol no campo de visada do sensor. Foram implementadas duas funções para simular um sensor de estrelas: uma para a configuração do sensor e outra para efetuar a leitura:

• int set_star_sensor (matrix3 std_dev_ss, matrix3 att_ss);

Esta função configura o sensor de estrelas a ser usado na simulação. Parâmetros de entrada: std_dev_ss

matriz de correlação do ruído apresentado pelo sensor em direções ortogonais, no sistema de coordenadas fixado ao próprio sensor, em radianos, com valor default igual a uma matriz diagonal com elementos da diagonal iguais a 0.0001 rad, aproximadamente igual a 20 segundos de arco. Variável passada por referência.

att_ss

matriz de atitude relacionando o sistema de coordenadas do sensor com o sistema de coordenadas do satélite, isto é, a matriz cujas linhas representam os co-senos diretores dos eixos do sensor expressos no sistema geométrico do satélite, com valor default igual a uma matriz identidade. Variável passada por referência.


set_star_sensor valor de retorno: 0

Exemplo:

auxi = s_gaussian_noise (0); att_ss = identity(1.); std_dev = identity(6.e-5); std_dev._3._3 = 4.2e-4; istat = set_star_sensor (std_dev, att_ss);

• quaternion read_star_sensor ();

123

Esta função retorna com a atitude simulada pelo sensor de estrelas.


não há Parâmetros de saída: read_star_sensor

quaternion da atitude referida ao sistema de coordenadas fixado ao sensor. Exemplo:

quaternion r_star; auxi = s_gaussian_noise (0); att_ss = identity(1.); std_dev = identity(6.e-5); std_dev._3._3 = 4.2e-4; istat = set_star_sensor (std_dev, att_ss); r_star = read_star_sensor();

6.5 – Sensor GPS O sensor GPS é um receptor de sinais da constelação de satélites GPS, e que tem como função prover a informação de posição do satélite. A modelagem apresentada aqui será bastante simples, sem levar em conta o posicionamento relativo entre o satélite e a constelação, erros devido ao multicaminho, erros de atraso de sinais, etc. Será suposto que o conhecimento da posição é perfeito, e admite-se um erro gaussiano em torno da posição orbital. Sabe-se que este erro pode ser direcional, e portanto admite-se que estas direções sejam aquelas do movimento orbital (velocidade, zênite e perpendicular ao plano orbital). Os modelos para a posição pGPS e velocidade vGPS fornecidas pelo sensor GPS serão dados por: _ _ _( )GPS GPS P inertial orb to in P GPSp K P R= + σ ω ,

_ _ _( )GPS GPS V inertial orb to in V GPSv K V R= + σ ω ,

onde ωGPS é um vetor de ruído branco de média nula e desvio padrão unitário, σP e σV são as matrizes de correlação do ruído em posição e velocidade, respectivamente, Rorb_to_in é a matriz de transformação entre os sistemas geocêntrico orbital e inercial, Pinertial e Vinertial são os vetores de posição e velocidade do satélite no sistema geocêntrico inercial, e finalmente KGPS_P e KGPS_V são fatores de conversão de unidades, necessários caso a saída apresentada pelo sensor seja diferente de metros e metros por segundo. O modelo deste sensor utiliza o valor da posição geocêntrica inercial, obtido da função get_inertial_state_vector (ver seção 3.10). É imperioso notar que a propagação de órbita necessita estar habilitada para que os valores recuperados por esta função estejam corretos. Ademais, é conveniente que a propagação de órbita seja realizada com o modelo SGP8, uma vez que este produz elementos osculadores ao contrário dos elementos médios do modelo simplificado de Brower. Foram implementadas duas funções para a simulação do receptor de GPS: uma para configurar o sensor e outra para efetuar as leituras durante a simulação:

124

• int set_gps_sensor (matrix3 std_dev_p, matrix3 std_dev_v, double k_gps_p, double k_gps_v);

Esta função configura o sensor GPS para ser utilizado na simulação.

Parâmetros de entrada: std_dev_p

matriz de correlação das medidas de posição (desvio padrão σP) em metros, com valor default igual a uma matriz diagonal com elementos da diagonal iguais a 10 m, referida ao sistema orbital, no qual o eixo xo tem direção zenital, o eixo yo está no plano da órbita e tem direção próxima à velocidade, e o eixo zo é perpendicular ao plano orbital. Variável passada por referência.

std_dev_v

matriz de correlação das medidas de velocidade (desvio padrão σV) em metros por segundo, com valor default igual a uma matriz diagonal com elementos da diagonal iguais a 1 m/s, e referida ao sistema orbital. Variável passada por referência.

k_gps_p

ganho do sensor ou fator de escala do sensor em posição, em unidades de leitura por metro. Seu valor default é unitário. Variável passada por valor.

k_gps_v

ganho do sensor ou fator de escala do sensor em velocidade, em unidades de leitura por metro por segundo. Seu valor default é unitário. Variável passada por valor.


set_gps_sensor valor de retorno: 0

Exemplo:

auxi = s_gaussian_noise (0); std_dev = identity(1); istat = set_gps_sensor (10.*std_dev, 0.01*std_dev, 1., 1.);

• vector6 read_gps_sensor ();

Esta função obtém a leitura do sensor GPS, configurado pela função set_gps_sensor.

Para que esta função tenha sucesso é necessário iniciar anteriormente a geração de variáveis aleatórias e a propagação de órbita. Parâmetros de entrada:

não há Parâmetros de saída: read_gps_sensor

vetor contendo a posição do satélite no referencial inercial, no primeiro vetor (read_gps_sensor._1) em metros e a velocidade referida ao mesmo sistema em metros por segundo no segundo vetor (read_gps_sensor._2).

Exemplo:

vector6 r_gps; auxi = s_gaussian_noise (0); std_dev = identity(1);

125

istat = set_gps_sensor (10.*std_dev, 0.01*std_dev, 1., 1.); r_gps = read_gps_sensor ();

6.6 – Unidade inercial Unidades inerciais são equipamentos providos de giroscópios que possuem a finalidade de medir a velocidade angular do satélite. Certos tipos de giros apresentam diretamente a integral da velocidade, ou seja, o deslocamento angular a partir de um dado instante. Giroscópios são equipamentos complexos e com modelamento matemático também complexo em virtude das diversas variáveis e fenômenos físicos envolvidos. Para complicar ainda mais, existem diversos tipos de giroscópios e, em conseqüência, um número ainda maior de unidades inerciais. Grosseiramente eles são classificados em mecânicos (dry tunned, rate gyro, rate integrated, float gyro, strapdown, etc), com nomenclatura muitas vezes sobreposta, FOG ou fiber optics gyro e laser (ou ring laser). Giros mecânicos são ainda bastante utilizados, mas vêm perdendo espaço para os giros FOG e laser. O custo do FOG é significativamente menor do que o laser, e, portanto, é de se esperar que este giro irá equipar a maiorias dos aviões, navios, submarinos, mísseis e satélites no futuro próximo. O modelo matemático, claro, depende do tipo e de características particulares de cada giroscópio. Um modelo simples, mas ainda assim abrangente, é sugerido por Fallon (Wertz, 1978): (1 )IU IU IU e ew k w b= + + + σ ω ,

onde wIU é a velocidade angular medida numa dada direção e w a velocidade angular real nesta direção (get_ang_velocity). kIU é uma correção devido ao desconhecimento do valor real do fator de escala (suposto como sendo unitário), bIU é o bias ou drift rate, e representa um erro fixo apresentado pelo sensor. O bias provoca uma leitura não nula mesmo na ausência de velocidade angular. Ele não é desconhecido totalmente, mas estimado tanto no processo de calibração do sensor quanto durante a operação e compensado posteriormente na determinação da atitude. Porém sempre haverá uma incerteza no real valor deste parâmetro. No caso mais geral o bias não é fixo, mas varia no tempo. σe representa o desvio padrão de um ruído branco ωe (média nula e desvio padrão unitário) apresentado na saída, por vezes denominado de random drift. No caso de giros do tipo FOG (e também em outros tipos de giros mecânicos), o random walk é um efeito particularmente importante. Ele acrescenta um ruído correlacionado no tempo ao resultado, e assim tem-se (1 ) ( )IU IU IU e e vw k w b n k= + + + σ ω + ,

onde o ruído devido ao random walk é obtido no instante k por meio de:

( ) ( 1)v v v vn k n k t= − + σ δ ω

onde δt é o intervalo de amostragem (suposto aqui igual ao intevalo de tempo entre os instantes k e k – 1), σv é o desvio-padrão do random walk e ωv é um ruído gaussiano não correlacionado a nenhum outro. (O random walk é em geral medido em graus por raiz de hora, enquanto que σv deve ser em graus por hora por raiz de hora).

126

Unidades inerciais apresentam diretamente as componentes da velocidade angular num sistema de coordenadas fixado ao sensor, ao passo que um único giroscópio efetua a medida da componente da velocidade na direção do eixo do sensor. Além disso, unidades inerciais apresentam em geral redundância interna, enquanto que são necessários vários giroscópios para se garantir a determinação completa da velocidade angular com redundância. Nas unidades inerciais as medidas individuais dos giros são combinadas para produzir uma única estimativa do vetor de velocidade angular. No modelo adotado aqui para a unidade esta combinação será assumida como perfeita, isto é, será admitido que a unidade inercial forneça este vetor em direções ortogonais. Um modelamento completo só é viável se se conhecer o método empregado na composição do vetor de velocidade angular a partir das componentes medidas pelos giros, o que depende de critérios adotados pelo fabricante. Logo, admite-se que o modelo seja: ( ) ( )IU IU IU IU e e vw A I K w b n k= + + + σ ω + ,

no qual wIU, w, bIU, ωe, nv e ωv são todos vetores e AIU é a matriz que contém as direções dos eixos de medida da unidade em relação ao sistema geométrico do satélite, junto com eventuais desalinhamentos destes eixos. I é uma matriz identidade e KIU é uma matriz diagonal com os erros nos fatores de escala dos giros. Agora σe e σv são as matrizes de correlação do ruído do random drift e do random walk, respectivamente. Igualmente aos modelos de sensores anteriores, foram criadas duas funções para a unidade inercial: uma para configuração e outra para leitura. • int set_inertial_unit (matrix3 axis_dir, vector3 scale_error, vector3

bias, matrix3 random_drift, matrix3 random_walk);

Esta função configura uma unidade inercial de 3 eixos para medidas da velocidade

angular do satélite. Esta função calcula também a raiz de δt, que é suposto igual ao ciclo de integração (função get_step_time). Portanto é necessário que o ciclo de integração tenha sido definido anteriormente (função set_step_time). A configuração da unidade inercial deve ser refeita caso haja alteração no ciclo de integração. Parâmetros de entrada: axis_dir

matriz AIU contendo os vetores unitários das direções dos 3 eixos sensores da unidade, armazenados em linhas, referidos ao sistema geométrico do corpo do satélite. Seu valor default é uma matriz identidade. Variável passada por referência.

scale_error

vetor com os elementos da diagonal da matriz KIU que apresenta os erros no fator de escala do giro, com valor default nulo. Variável passada por referência.

bias

vetor com o viés bIU nas direções do sensor, em unidades de radianos por segundo, com valor default nulo. Variável passada por referência.

random_drift

matriz de correlação do random drift (desvio padrão σe), em unidades de radianos por segundo, com valor default igual a uma matriz diagonal com elementos da diagonal iguais a 10-8. Variável passada por referência.

random_walk

127

matriz de correlação do random walk (desvio padrão σv), em unidades de rad/s3/2, com valor default igual a uma matriz diagonal com elementos da diagonal iguais a 10-8. Variável passada por referência.


set_inertial_unit valor de retorno: 0

Exemplo:

auxi = s_gaussian_noise (0); axis_dir = identity(1.); sc_er._1 = 1.e-7; sc_er._2 = 1.e-7; sc_er._3 = 1.e-7; bias._1 = 5.e-9; bias._2 = 5.e-9; bias._3 = 5.e-9; drift = identity(1.e-9); rand_wk = identity(4.e-10); istat = set_inertial_unit (axis_dir, sc_er, bias, drift, rand_wk);

• vector3 read_inertial_unit ();

Esta função obtém a leitura da unidade inercial configurada pela função

set_inertial_unit. É necessário iniciar anteriormente a geração de variáveis aleatórias. Parâmetros de entrada:

não há Parâmetros de saída: read_inertial_unit

vetor contendo a leitura da unidade inercial, em radianos por segundo. Exemplo:

vector3 r_iuni; auxi = s_gaussian_noise (0); axis_dir = identity(1.); sc_er._1 = 1.e-7; sc_er._2 = 1.e-7; sc_er._3 = 1.e-7; bias._1 = 5.e-9; bias._2 = 5.e-9; bias._3 = 5.e-9; drift = identity(1.e-9); rand_wk = identity(4.e-10); istat = set_inertial_unit (axis_dir, sc_er, bias, drift, rand_wk); r_iuni = read_inertial_unit ();

6.7 – Bobinas magnéticas A modelagem destes e dos demais atuadores será feita posteriormente. Na presente versão as funções apresentadas na Seção 3.2 são suficientes para propósitos de simulação. 6.8 – Propulsores

128

A modelagem destes e dos demais atuadores será feita posteriormente. Na presente versão as funções apresentadas na Seção 3.3 são suficientes para propósitos de simulação. 6.9 – Rodas de reação A modelagem destes e dos demais atuadores será feita posteriormente. Na presente versão as funções apresentadas na Seção 3.4 são suficientes para propósitos de simulação. 6.10 – Mecanismo de rotação do painel solar – BAPTA Modelamento ainda não implementado nesta versão

129

7 – Operações em tempo-real

Um dos principais requisitos para o programa de simulação é que ele deve ser executado em tempo-real. Desta forma, o tempo de execução de uma malha de integração deve ser inferior ao passo de integração numérica adotado. Sabe-se que o tempo de execução é aproximadamente proporcional ao passo, o que significa que o simples aumento do passo de integração não acarreta necessariamente a execução em tempo-real. Por outro lado, o crescente aumento no poder de processamento dos computadores, aliado a adoção de métodos adequados de codificação permitem garantir que esta exigência será atendida com grande folga. Os controladores de atitude embarcados executam ciclos de controle em intervalos aproximadamente constantes. A freqüência típica destes controladores é da ordem de 0.5 a 2 Hz, dependendo de características tanto do satélite quanto do próprio sistema de controle. A amostragem dos sensores é, em geral, efetuada na mesma freqüência, porém admite-se que alguns deles (rodas de reação e giroscópios) possam ser amostrados a taxas superiores, podendo chegar a 100 Hz. Esta condição estabelece um limite ao passo de integração numérica, que deverá ser por volta de 0,01s para assegurar a operação em tempo-real. Além disso, deve-se esperar que não haja sincronismo entre a simulação e o controle, isto é, que a simulação não dependa dos instantes de comando do controle, e este possa efetuar suas amostragens a qualquer instante. Para que isto seja conseguido deve-se, novamente, assegurar que o passo de integração seja de pelo menos uma ordem de grandeza acima do intervalo do ciclo de controle. Existem diversas formas pelas quais pode-se sincronizar o tempo de execução de um programa com o tempo de propagação utilizado no cálculo numérico. Supondo-se que o tempo de execução seja menor do que o passo de integração, como exigido, então pode-se, por exemplo, aguardar, após a execução, que os tempos de ambos se igualem. Durante este intervalo o processamento é detido, e nada é executado. Esta tática apresenta como desvantagem o fato de se desperdiçar tempo de processamento. Além disso, se o processamento for interrompido pelo próprio sistema operacional, haverá uma perda de sincronismo que comprometerá o resultado da simulação. Para reduzir o desperdício de tempo pode-se tentar reduzir o passo até que o tempo de espera seja pequeno ou desprezível. Este ajuste, contudo, deve ser feito sempre que o programa for executado num outro computador, já que o desempenho da máquina influi no passo. Outro método é efetuar este ajuste de forma automática, fazendo com que o próximo passo de integração seja igual ao intervalo de tempo decorrido no cálculo do último passo. Este processo, ainda que melhor que o anterior, não evita a perda de sincronismo em caso de interrupção, porém garante que o sincronismo seja recuperado rapidamente após a espera. A tática sugerida para a simulação da atitude consiste então em:

a) efetuar um ciclo de integração e determinar o intervalo de processamento. b) ajustar o próximo passo de integração para se ajustar a este intervalo.

É bastante provável que esta tática produza amostras da atitude em intervalos de tempo

diferentes entre si, principalmente se o processamento efetuado percorrer caminhos diferentes no programa a cada ciclo. Esta desvantagem é pequena e suportável caso o passo médio conseguido seja pequeno, da ordem de 10-2s.

130

Com a finalidade de se construir ferramentas para a simulação em tempo-real, implementou-se funções para ajuste de passo e para efetuar a espera de processamento. Elas foram agrupadas no pacote realtime.lib e cabeçalho realtime.h. Todas elas utilizam a função clock, que é integrante das bibliotecas da linguagem C. Esta função retorna com o tempo decorrido desde o início de execução do programa, em unidades de 1/CLOCKS_PER_SEC (normalmente milisegundos), em variáveis do tipo clock_t, (definida como long no cabeçalho time.h.

As funções são descritas a seguir. Construíram-se funções para deter o processamento

e para ajuste do passo. A resolução típica das funções apresentadas é de 1 ms. • double rt_timer ();

Esta função fornece o tempo decorrido desde o início da execução do programa, em

unidades de segundos. A resolução é de 1 ms. Parâmetros de entrada: não há Parâmetros de saída: rt_timer

variável do tipo double contendo o tempo decorrido em unidades de segundo. Exemplo: #include “realtime.h” double temp;

... temp = rt_timer();

• double rt_clock_resolution ();

Esta função calcula a resolução do relógio interno do computador, em segundos. É

igual a 1/CLOCKS_PER_SEC. No sistema PC-Windows a resolução é de 0.001 s. Parâmetros de entrada: não há Parâmetros de saída: rt_clock_resolution

variável do tipo double contendo a resolução do relógio interno em unidades de segundo.

Exemplo: #include “realtime.h” double temp;

... temp = rt_clock_resolution();

• void rt_reset_timer ();

Esta função restabelece a contagem de tempo de processamento. Após ter sido

chamada, qualquer outra chamada à função rt_timer retornará com o tempo decorrido entre as chamadas de rt_reset_timer e rt_timer.

131


não há. Exemplo: #include “realtime.h” double temp;

rt_reset_timer(); ...

temp = rt_timer();

• void rt_wait (double timsec);

A função rt_wait detém a execução do programa por um intervalo de tempo de

timsec segundos. Esta função executa uma malha fechada até que o tempo decorrido tenha atingido o valor especificado. Em virtude do incremento do relógio interno do computador TC, que varia em função das características destes (fica entre 10 e 16ms), a função irá esperar por um intervalo de tempo múltiplo deste incremento. O tempo de espera é, portanto, n*TC > tinsec, onde n é um número inteiro não nulo (1, 2, ...). Parâmetros de entrada:

timsec

Intervalo de tempo de espera em segundos. Parâmetros de saída:

não há. Exemplo: #include “realtime.h”

... rt_wait (5.);

• int rt_wait_till (double timsec);

A função rt_wait_till detém a execução do programa até que o tempo decorrido

desde o início da execução deste programa ou desde a última chamada à função rt_reset_timer seja igual ao parâmetro timsec em segundos. Em virtude do incremento do relógio interno do computador TC, que varia em função das características destes (fica entre 10 e 16ms), a função irá esperar até que o tempo do relógio ultrapasse timsec por um múltiplo do incremento. Esta função retorna com o número de vezes que executou o laço de espera. Este número pode ser utilizado para fazer com que o tempo de processamento utilizado em cada passo seja mais uniforme. De fato, se o passo de integração for muito menor do que incremento do relógio, então o processamento é detido na primeira chamada, mas isto faz com que o relógio interno fique bem acima do tempo de integração. Nas chamadas subseqüentes, o processamento já não é detido (porque o relógio acusa um valor acima do tempo de integração), e vários passos são executados rapidamente, causando uma não uniformidade na distribuição temporal do processamento. Veja também que se o passo adotado for muito pequeno, o sincronismo pode não ser respeitado ao utilizar esta função.

132

Parâmetros de entrada: timsec

Instante de tempo de processamento em segundos. Parâmetros de saída: rt_wait_till

Contador do número de vezes de execução do laço de espera. Exemplo: #include “realtime.h”

... rt_wait_till (5.);

• double rt_time_since (double timsec);

Esta função calcula a diferença de tempo entre o instante assinalado por timsec

(tempo decorrido de execução, em segundos) e o instante corrente.Devido ao fato do relógio interno fornecer medidas em unidades entre 10 a 20 ms, a precisão do cálculo deste intervalo é restrita à mesma unidade. Parâmetros de entrada:

timsec

Instante de tempo anterior em segundos. Parâmetros de saída:

rt_time_since

Intervalo de tempo decorrido entre o instante timsec e o instante corrente, em segundos.

Exemplo: #include “realtime.h”

... rt_wait_till (5.);

• double rt_adjust_step_time (double t, double step);

Esta função permite ajustar o passo de integração de tal forma a haver um sincronismo

entre o tempo de cálculo e o passo de propagação. Este ajuste necessita que a função rt_reset_time seja chamada imediatamente antes do início da malha de integração. Parâmetros de entrada:

t

Instante de tempo de propagação, ou tempo de propagação. É o valor atualizado pela função de propagação de atitude, e pode ser recuperado pela função get_current_time. Variável passada por valor, em segundos.

step

Passo de integração utilizado neste momento, em segundos. Se a função rt_adjust_step_time não conseguir atualizar o valor do passo (devido ao fato do relógio interno ainda não ter sido incrementado), esta função retorna com o passo atual step. Caso contrário, ela calcula o passo médio e retorna com o valor do novo passo na própria função

133

Parâmetros de saída: rt_time_since

Intervalo de tempo decorrido entre o instante timsec e o instante corrente, em segundos, ou seja, o novo valor do pass.

Exemplo: #include “realtime.h”

... set_step_time(rt_adjust_step_time(t, get_step_time()));

7.1 – Exemplos de uso

As funções apresentadas aqui permitem executar processamento em tempo real em

diversas situações. Algumas delas são apresentadas a seguir, junto com um comentário a respeito das vantagens encontradas em cada estratégia. Todos os exemplos seguem o roteiro simplificado de um simulador na forma

while (t < t_end)

t = get_current_time (); sat_propagation();

no qual, obviamente, foram suprimidas as funções de configuração da simulação, cálculo do controle, armazenagem da atitude ou envio dos sinais dos sensores. Nos próximos exemplos as funções de tempo-real são destacadas em negrito.

1) Processamento com tempo de espera Neste exemplo utiliza-se a função rt_wait até que o tempo de execução coincida com o tempo de propagação. while (t < t_end)

rt_reset_timer(); sat_propagation(); t = get_current_time (); rt_wait (get_step_time()-rt_timer());

Caso haja uma interrupção causada pelo sistema operacional durante a execução da malha, esta estratégia consegue recuperar o sincronismo somente após vários ciclos de integração. Contudo, no teste efetuado num computador AMD Athlon 64 3400, 2.4 GHz e sistema operacional Windows XP 32 bits, o tempo de processamento necessário para a propagação da atitude ficou inferior ao incremento do relógio interno, de 0.015s. Neste computador, a função rt_timer retorna com um valor nulo ao ser chamada no argumento de rt_wait, que, por sua vez, irá deter o processamento por um intervalo de tempo igual ao próprio passo de integração. Outra forma de se efetuar a espera para efetuar o sincronismo é com o uso da função rt_wait_till. Devido à forma com que a propagação de atitude é efetuada, este método é mais eficiente do que o anterior. O código simplificado é dado por: rt_reset_timer(); while (t < t_end)

sat_propagation(); t = get_current_time ();

134

istat = rt_wait_till (t);

Percebe-se que a estratégia de deter o processamento é eficiente apenas em intervalos grandes de tempo, maiores do que o incremento do relógio, que deve ser determinado para cada máquina. Se o passo de integração for inferior ao incremento do relógio haverá oscilação no sincronismo, como mostra a Figura 7.1, na qual utilizou-se um passo de 0,001s.

0.0 0.1 0.2 0.3 0.4 0.5Propagation time (s)

0.00

0.01

0.02

Real time error (s)

Fig. 7.1 – Erro de sincronismo com passo fixo de 0,001s e processamento com tempo de

espera.

É óbvio que o erro máximo atingido por esta estratégia é próximo do incremento do relógio, que neste caso é de 15 ms.

2) Ajuste dinâmico do passo de integração

No exemplo a seguir procura-se ajustar dinamicamente o próximo passo de integração ao intervalo de tempo decorrido para calcular o último passo. Este método pode incorporar, com poucas alterações, uma mudança gradual do passo que passaria a ter um caráter de passo médio. O código simplificado para o ajuste dinâmico seria:

while (t < t_end) rt_reset_timer(); sat_propagation(); set_step_time (rt_timer());

set_int_step_time (get_step_time);

Se a velocidade de execução do computador for compatível com o incremento do relógio interno, então o procedimento apontado acima funciona adequadamente. Esta compatibilidade é verificada quando o tempo de processamento for superior ao incremento apresentado pelo relógio. Porém, quando a velocidade de processamento for elevada, pode acontecer do relógio interno acusar um intervalo de tempo nulo num ciclo de propagação, isto é, a função rt_timer retorna um valor nulo. Neste caso duas soluções são possíveis. Na primeira introduz-se um tempo de espera no processamento, semelhante aquele adotado no exemplo 1 acima, até que o processamento atinja um incremento do relógio interno. Na segunda solução, o passo

135

só é ajustado quando houver leitura suficiente do relógio para isso. A primeira solução leva ao código: while (t < t_end) rt_reset_timer(); sat_propagation(); if (rt_timer() == 0)

rt_wait (rt_clock_resolution());

auxi = rt_timer(); set_step_time (auxi);

set_int_step_time (get_step_time());

Nota-se que esta solução despreza completamente o tempo de processamento de um ciclo de integração, ou seja, supõe que este tempo seja nulo, o qual, na verdade, não é. Uma vez que não há como medir intervalos menores do o incremento do relógio, então esta solução irá apresentar sempre uma defasagem no tempo com relação ao tempo real. Verificou-se, com isso, que o incremento do relógio interno não é de 1 ms, mas sim de 15 a 16 ms. Embora a função rt_wait seja utilizada para introduzir um tempo de espera de 1 ms (valor da resolução do relógio), na verdade ela aguarda cerca de 15 ms. Em outras palavras, não há como provocar uma espera no processamento de tempos inferiores a 15 ms. No teste efetuado o passo foi ajustado a cada ciclo para valores situados entre 15 e 16 ms. O segundo método utiliza um código semelhante a

icont = 0; rt_reset_timer(); tant = rt_timer(); while (t < t_end)

sat_propagation(); icont++;

t = get_current_time (); auxi = rt_timer();

if (tant < auxi) set_step_time ((auxi-tant)/(double)icont);

set_int_step_time (get_step_time()); icont = 0; tant = auxi;

Assim, nesta solução o passo só é ajustado quando houver resolução suficiente no relógio interno. Para dar mais segurança, a variável scale produz um intervalo de tempo ainda maior, o que permite uma média também melhorada do passo. A variável icont enumera o número de propagações efetuadas neste intervalo de tempo, e é utilizada para definir o passo. A execução deste código no computador mencionado no primeiro exemplo gerou um passo médio de 45,8 µs, ou seja, uma freqüência de cerca de 21,8 kHz, muito superior àquela conseguida com tempo de espera no processamento. Contudo, percebe-se que este código não garante o sincronismo de tempo, uma vez que apenas o passo é ajustado, e não o sincronismo. De fato, na Figura 7.2 percebe-se que o erro no tempo real, ou seja, na diferença entre o instante de propagação e o instante do relógio é sempre crescente. Percebe-se também que a

136

defasagem entre estes tempos aumenta sempre que houver uma alteração na velocidade de execução. A Figura 7.3 mostra a freqüência utilizada a cada ajuste do passo.

0 5 10 15 20 25 30 35 40 45 50 55 60Propagation time (s)

-0.02

0.00

0.02

0.04

0.06

Real time error (s)

Fig. 7.2 – Erro no ajuste de sincronismo entre o tempo de processamento e o tempo do relógio

interno.


5000

10000

15000

20000

25000

Step frequency (Hz)

Fig. 7.3 – Freqüência calculada para o passo de integração quando se utiliza passo variável.

Para corrigir esta defasagem no tempo, deve-se introduzir, além do ajuste do passo, também um critério de sincronização. Este critério deverá aumentar o número de ciclos sempre que houver uma defasagem no sincronismo, e, desta forma, manter o erro sempre próximo de um valor nulo. O código com ajuste de sincronismo fica:

icont = 0;

rt_reset_timer(); tant = rt_timer(); while (t < t_end)

sat_propagation(); icont++;

t = get_current_time ();

137

auxi = rt_timer(); if (tant < auxi)

set_step_time ((2*auxi-tant-t)/(double)icont); set_int_step_time (get_step_time()); icont = 0; tant = auxi;

Como pode ser visto na Figura 7.4, após esta correção o sincronismo fica garantido e o erro fica menor, com média nula.


-0.02

0.00

0.02

0.04

0.06

Real time error (s)

Fig. 7.4 – Erro de sincronismo com ajuste dinâmico de passo e correção de sincronismo.

O algoritmo mostrado no código anterior foi implementado na função rt_adjust_step_time. O código abaixo exemplifica a utilização desta função. O resultado é idêntico ao ajuste automático de passo com sincronização dos instantes. rt_reset_timer(); while (t < t_end)

sat_propagation(); t = get_current_time ();

set_step_time(rt_adjust_step_time(t, get_step_time())); set_int_step_time(get_step_time());

O sincronismo do processamento com tempo de espera é mais adequado para simular a malha de controle, uma vez que esta malha deve ser executada numa freqüência fixa, da ordem de 0,5 a 2 Hz, utilizada comumente em satélites. Por outro lado, o sincronismo com passo ajustável é propício para simulação e propagação da atitude, pois satisfaz dois requisitos: a) torna a malha de controle dessincronizada com relação à malha de propagação, e b) maximiza o número de amostras da atitude por unidade de tempo.

139

Referências bibliográficas [1] – NOAA – http://www.ngdc.noaa.gov/IAGA/vmod/igrf.html [2] – IGRF – http://nssdc.gsfc.nasa.gov/space/model/magnetos/igrf.html [3] – Mersenne Twister HP – http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html [4] – lccwin – http://www.cs.virginia.edu/~lcc-win32/ Brower, D.; Clemence, G. M. Methods of celestial mechanics. New York, NY, Academic,

1961. Flandern, T. C.; Pulkkinen, K. F. Low precision formulae for planetary positions. The

Astrophysical Journal Supplement Series, V. 41, n. 3, pg. 319-411, Nov, 1979. Hoots, F. R.; Roehrich, R. L. Models for propagation of NORAD element sets, Aerospace

Defense Command, United States Air Force, Spacecraft Report No 3. Dec. 1980. Klumpp, A. R. Singularity-free extraction of a quaternion from a direction-cosine matrix.

Journal of Spacecraft and Rockets, Vol 13, n. 12, pg 754-755, 1976. Kuga, H. K.; Carrara, V.; Medeiros, V. M. Rotinas auxiliares de mecânica celeste e geração

de órbita. São José dos Campos, INPE, julho 1981 (INPE-2189-RPE/392). The Astronomical Almanac 1987 - Supplement to the Astronomical Almanac – page C24,

1987. Wertz, J. R. Spacecraft attitude determination and control, London: D. Reidel, 1978

(Astrophysics and Space Science Library).

141

Apêndice A Especificações dos equipamentos da PMM As principais características de inércia da PMM tratada como um todo são: a) após injeção

massa: matriz de inércia: b) fim de vida massa: matriz de inércia:

Quando tratado como um sistema composto por um corpo principal e dois apêndices (painéis) articulados, a plataforma apresenta a) após injeção

massa: matriz de inércia: b) fim de vida massa: matriz de inércia: Os painéis possuem

massa do painel A inércia do painel A massa do painel B inércia do painel B

Parâmetros de Denavit-Hartenberg para o painel A

θ0, d0, a0, t0,

142

θ1, d1, a1, t1, θ2 d2, Parâmetros de Denavit-Hartenberg para o painel B

θ0, d0, a0, t0, θ1, d1, a1, t1, θ2 d2, Figura

Segue abaixo as principais características dos equipamentos especificados ou já adquiridos para o sistema de controle de atitude da Plataforma Multi Missão. GPS:

Erro de posição 10 m 3 σ RMS Erro de velocidade 0.01 m/s 3 σ Freqüência de medidas 1 Hz Precisão do relógio 0.1 10-6 segundo

Giro (Astrix)

Fator de escala +/- 10o/s Resolução (LSB): 0.011 arcsec Drift: 0.001o /h (1 σ) Random walk: 0.0025o /sqrt(hour) 1 σ Estabilidade do fator de escala: 500 ppm em 5 anos Alinhamento absoluto: 24 sec Alinhamento relativo: 35 sec

Bobina (Zarm)

Momento 30 Am2 Orientação das bobinas relativa ao sistema do satélite: Bobina X:

143

Bobina Y: Bobina Z: Erro de alinhamento máximo: Rodas (Teldix)

Momento angular máximo 12 Nms a 6000 rpm Torque de reação máximo: > +/- 50 mNm a 6000 rpm Torque do motor: +/- 75 mNm a 6000 rpm Velocidade: 24 pulsos por rotação

Orientação das rodas relativa ao sistema do satélite: Roda A: Roda B: Roda C: Roda D: Erro de alinhamento máximo: Sensor de estrelas (Sodern)

Taxa de amostragem: até 10 Hz Ruído: 11 sec em X e Y (3 σ), e 70 sec em Z (3 σ) Erros de baixa freqüência: 4” (segundos) em XY e 25” em Z. Bias: 11 sec (3 σ)

Orientação dos sensores relativa ao sistema do satélite: Sensor A: Sensor B:

Erro de alinhamento máximo: Magnetômetro (Taman)

Range: +/- 0.6 G Ruído: 0.02 mG Bias: +/- 5 mG Desalinhamento: 5o (calibrado a 0.2o) Linearidade: +/- 0.2%

Orientação dos magnetômetros relativa ao sistema do satélite: Magnetômetro A: Magnetômetro B:

Erro de alinhamento máximo: Sensor Solar

Tipo: 2 eixos Campo: +/- 90o

144

Precisão: 1o Bias: +/- 1o

Orientação dos sensores relativa ao sistema do satélite:

Sensor 1: Sensor 2: Sensor 3: Sensor 4: Sensor 5: Sensor 6: Sensor 7: Sensor 8: Erro de alinhamento máximo: Propulsores de hidrazina

Empuxo:

Posicionamento dos propulsores: Propulsor 1: Propulsor 2: Propulsor 3: Propulsor 4: Propulsor 5: Propulsor 6:

Orientação dos propulsores relativa ao sistema do satélite:

Propulsor 1: Propulsor 2: Propulsor 3: Propulsor 4: Propulsor 5: Propulsor 6: Erro de alinhamento máximo: Erro de desvio máximo do vetor empuxo: Erro de desvio máximo na magnitude do empuxo: Posicionamento dos propulsores: SADA (BAPTA)

145

Apêndice B Exemplos e testes do simulador de atitude

A Tabela B-1 apresenta o código fonte do programa utilizado para gerar os testes. A seguir são apresentados os testes realizados, bem como o resultado obtido de cada teste. São também fornecidas as linhas do código fonte que foram alteradas em cada teste. Nos gráficos apresentados adotou-se a seguinte padronização: o componente (do torque, da velocidade angular ou da atitude) é vermelho, o componente y é verde o componente z é azul.

Tabela B-1 Código fonte do programa utilizado nos testes da dinâmica

#include <stdlib.h> #include <stdio.h> #include <math.h> #include <float.h> #include "att_pro.h" // A seguinte biblioteca deverá ser unida ao programa principal: // c:\...\attit_pro.lib // Programa de testes void main (void) quaternion quater; matrix3 iner; vector3 w, ezxz; double relerr, abserr; double t, t_start, t_end, t_step; int istat; FILE *nfile;

// >>>>>>>>>>>>>>>>>>>>>>>> inércia e massa iner._11 = 10; iner._12 = 0; iner._13 = 0; iner._21 = 0; iner._22 = 10; iner._23 = 0; iner._31 = 0; iner._32 = 0; iner._33 = 10; istat = set_sat_inertia (iner);

// >>>>>>>>>>>>>>>>>>>>>>>> parâmetros iniciais de atitude ezxz._1 = 0*RADIANS; ezxz._2 = 0*RADIANS; // Parâmetros de euler da atitude inicial ezxz._3 = 0*RADIANS; quater = ezxzquat (ezxz); istat = set_attitude (quater); w._1 = 0; w._2 = 0; // Velocidade angular inicial w._3 = 0; istat = set_ang_velocity (w);

// >>>>>>>>>>>>>>>>>>>>>>>> tempo de integração t_start = 0; t_end = 200; t_step = 1;

146

istat = set_current_time (t_start); istat = set_step_time (t_step); istat = set_int_step_time (0.1); t = t_start;

// >>>>>>>>>>>>>>>>>>>>>>>> configuração do integrador istat = select_integ_method(INTEG_RKF_78, INTEG_FIX); // >>>>>>>>>>>>>>>>>>>>>>>> malha de integração

while (t < t_end) quater = get_attitude (); ezxz = quatezxz (quater); w = get_ang_velocity (); t = get_current_time (); // imprimir instante t, atitude e velocidade angular sat_propagation (); return;

Apresenta-se, a seguir, exemplos e testes efetuados com os diversos módulos desenvolvidos para o simulador de atitude. Os exemplos estão separados em grupos na forma:

• Corpo rígido livre de torques. Movimento de nutação. • Corpo rígido sob a ação de torques externos. Movimento de precessão. • Corpo rígido sob a ação de torques magnéticos. • Corpo rígido sob a ação de torques internos de roda de reação. • Corpo rígido sob a ação de torques de propulsores. • Propagação de órbita. • Sensores • Tempo real

Parte I: Corpo rígido livre de torques. Movimento de nutação. 1) Adota-se como exemplo inicial um satélite com distribuição de massa totalmente

simétrica, cuja matriz de inércia é diagonal com elementos iguais a 10 kgm2. A atitude é propagada por 200 segundos, com atitude inicial nula e velocidade angular de 1 rotação a cada 20 segundos no eixo z, conforme o código:

w._1 = 0; w._2 = 0; // Velocidade angular inicial w._3 = PI/10;

As Figuras B-1 e B-2 mostram as componentes da atitude (rotação 3-1-3) e da velocidade angular do satélite.

147

0 20 40 60 80 100 120 140 160 180 200Time (s)

-180

-120

-60

0

60

120

180

Attitude (z-x-z) (deg)

Fig. B-1 – Atitude (ângulos de Euler de rotação 3-1-3).

0 20 40 60 80 100 120 140 160 180 200Time (s)

0.0

0.1

0.2

0.3

0.4

Angular velocity (rad/s)

Fig. B-2 – Velocidades angulares (as velocidades nos eixos x e y são nulas).

2) Este exemplo é semelhante ao anterior, com posição inicial nula, e velocidade angular de

1 rotação a cada 20 segundos no eixo z, e 0.1 rotação a cada 20 segundos no eixo y. Os resultados são vistos nas Figuras B-3 e B-4. Devido à simetria do corpo, as componentes da velocidade permanecem iguais, como mostra a Figura B-4.

w._1 = 0; w._2 = PI/100; // Velocidade angular inicial w._3 = PI/10; ele = get_sat_ang_momentum ();

148

0 20 40 60 80 100 120 140 160 180 200Time (s)

-180

-120

-60

0

60

120

180


Fig. B-3 – Atitude num corpo totalmente simétrico (esférico) em rotação (atitude inicial nula).

0 20 40 60 80 100 120 140 160 180 200Time (s)

0.0

0.1

0.2

0.3

0.4


Fig. B-4 – Velocidades angulares num corpo totalmente simétrico (esférico) e com atitude

inicial nula.

3) Também neste exemplo as condições são iguais ao anterior (satélite simétrico e velocidades angulares em y e z), porém com com posição inicial não nula nos três eixos, dada pelo código:

ezxz._1 = 50*RADIANS; ezxz._2 = -20*RADIANS; // Parâmetros de euler da atitude inicial ezxz._3 = 140*RADIANS;

Os resultados são mostrados nas Figuras B-5 e B-6

149

0 20 40 60 80 100 120 140 160 180 200Time (s)

-180

-120

-60

0

60

120

180


Fig. B-5 – Atitude num corpo totalmente simétrico (esférico) em rotação e com atitude inicial

não nula.

0 20 40 60 80 100 120 140 160 180 200Time (s)

0.0

0.1

0.2

0.3

0.4


Fig. B-6 – Velocidades angulares num corpo totalmente simétrico (esférico) e com atitude

inicial não nula. 4) Adota-se agora uma distribuição não simétrica de massa, cuja matriz de inércia é diagonal,

com elementos iguais a 10, 15 e 20 kgm2. A atitude é propagada por 200 segundos, com velocidade angular de 1 rotação a cada 20 segundos no eixo z, e 0.1 rotação a cada 20 segundos no eixo y. Os gráficos abaixo apresentam a velocidade angular e as direções

150

inerciais do momento angular em função do tempo. As velocidades angulares aparecem na Figura B-7, onde o movimento de nutação é evidenciado.

0 20 40 60 80 100 120 140 160 180 200Time (s)

-0.1

0.0

0.1

0.2

0.3

0.4Angular velocity (rad/s)

Fig. B-7 – Velocidades angulares num corpo com rotação com movimento de nutação.

A atitude em ângulos de Euler desta simulação é mostrada nas Figuras B-8, B-9, B-10 e B-11, respectivamente em eixos 1-2-3, 3-1-2, 3-1-3 e 3-2-1. A atitude inicial considerada foi de 180o ao redor de z, 4,2892o ao redor de x e 0o ao redor de z (3-1-3), mostrado no código abaixo. Nesta configuração, o momento angular fica alinhado ao eixo z inercial, o que facilita a interpretação dos resultados (Figura B-12).

w._1 = 0.;

w._2 = PI/100.; w._3 = 1.*PI/10.; istat = set_ang_velocity (w); ezxz._1 = 180*RADIANS; ezxz._2 = 4.2892*RADIANS; ezxz._3 = 0*RADIANS; quater = ezxzquat (ezxz); istat = set_attitude (quater);

0 20 40 60 80 100 120 140 160 180 200Time (s)

-180

-90

0

90

180

Euler angles 1-2-3 (deg)

Fig. B-8 – Atitude em graus (rotação x-y-z).

151

0 20 40 60 80 100 120 140 160 180 200Time (s)

-180

-90

0

90

180


Fig. B-9 – Atitude em graus (rotação z-x-y).

0 20 40 60 80 100 120 140 160 180 200Time (s)

-180

-90

0

90

180


Fig. B-10 – Atitude em graus (rotação z-x-z).

0 20 40 60 80 100 120 140 160 180 200Time (s)

-180

-90

0

90

180


Fig. B-11 – Atitude em graus (rotação z-y-x).

152

0 20 40 60 80 100 120 140 160 180 200Time (s)

0

2

4

6

8

Angular mom

entum (Nms)

Fig. B-12 – Momento angular do corpo no sistema inercial.

5) A matriz de inércia é ainda diagonal, com elementos iguais a 10, 15 e 20, com velocidade

angular de 1 rotação a cada 20 segundos no eixo y, e 0.1 rotação a cada 20 segundos no eixo x conforme o código mostrado a seguir. O gráfico da Figura B-13 apresenta a velocidade angular em função do tempo. O movimento de nutação é evidenciado nesta figura, onde se percebe a instabilidade do movimento ao redor do eixo de inércia intermediário.

0 20 40 60 80 100 120 140 160 180 200Time (s)

-0.4

-0.3

-0.2

-0.1

0.0

0.1

0.2

0.3

0.4


Fig. B-13 – Velocidades angulares num corpo com rotação ao redor do eixo de inércia

intermediário.

Adotou-se uma atitude inicial, nesta simulação, de forma a que o momento angular novamente coincida com o eixo z inercial. Neste caso a atitude foi de 180o ao redor de z, 90o ao redor de x e 3,8141o ao redor de z (3-1-3), também mostrado no código a seguir.

w._1 = PI/100.; w._2 = 1.*PI/10.; w._3 = 0; istat = set_ang_velocity (w); ezxz._1 = 180*RADIANS; ezxz._2 = 90*RADIANS;

153

ezxz._3 = 3.8141*RADIANS; quater = ezxzquat (ezxz);

A Figura B-14 mostra a atitude em ângulos de Euler em rotações z-x-y (3-1-2). A Figura B-15 ilustra o momento angular em coordenadas referidas ao sistema inercial, evidenciando o alinhamento com o eixo z (as demais coordenadas são nulas).

0 20 40 60 80 100 120 140 160 180 200Time (s)

-180

-90

0

90

180Euler angles 3-1-2 (deg)

Fig. B-14 – Atitude num movimento de nutação com velocidade angular próxima ao eixo do

momento de inércia intermediário.

0 20 40 60 80 100 120 140 160 180 200Time (s)

0

2

4

6

Angular mom

entum (Nms)

Fig. B-15 – Momento angular do corpo referido ao sistema inercial

6) Neste exemplo mantém-se a matriz de inércia diagonal, com elementos iguais a 10, 15 e

20, com posição inicial nula e velocidade angular de 1 rotação a cada 20 segundos no eixo x, e 0.1 rotação a cada 20 segundos no eixo z. Os gráficos mostrados nas Figuras B-16, B-17 e e B-18 apresentam a velocidade angular e atitude em rotações de Euler nos eixos 3-1-3 e 3-2-1, respectivamente. O momento angular em coordenadas inerciais é apresentado na Figura B-19, no qual percebe-se novamente o alinhamento com o eixo z inercial. Como a velocidade angular encontra-se preferencialmente ao redor do eixo de menor momento de inércia, tem-se novamente um movimento de nutação.

154

0 20 40 60 80 100 120 140 160 180 200Time (s)

-0.1

0.0

0.1

0.2

0.3

0.4


Fig. B-16 – Velocidades angulares de um corpo com movimento de nutação. As componentes da velocidade nas direções y e z são quase senoidais, enquanto que a velocidade ao redor do

eixo x permanece praticamente constante.

0 20 40 60 80 100 120 140 160 180 200Time (s)

-180

-90

0

90

180


Fig. B-17 – Atitude num movimento de nutação em rotações de Euler nos eixos z-x-z, com

velocidade angular próxima ao eixo de menor momento de inércia.

155

0 20 40 60 80 100 120 140 160 180 200Time (s)

-180

-90

0

90

180


Fig. B-18 – Atitude em ângulos de Euler nos eixos z-y-x, e velocidade angular próxima ao

eixo de menor momento de inércia.

0 20 40 60 80 100 120 140 160 180 200Time (s)

0

1

2

3

4

Angular mom

entum (Nms)

Fig. B-19 – Momento angular do corpo no sistema de coordenadas inerciais. Nota-se que não

há variação do momento angular uma vez que não há torques externos.

O código abaixo apresenta a versão do programa utilizada para gerar os Exemplos 4, 5 e 6.

// Código dependente do compilador #ifdef WIN32 #define copysign _copysign #endif

#include <stdlib.h> #include <stdio.h> #include <math.h> #include <float.h>

#include "att_pro.h" // cabeçalho do pacote

int main (void)

quaternion quater;

156

matrix3 iner; matrix3 test; vector3 vec1; vector3 w, ezxz, exyz; double t; double t_start, t_end, t_step; int istat;

// ************** arquivo para impressão de valores de saída

FILE *nfile; nfile = fopen("attit.dat", "w");

// ************** inércia e massa

iner = mat3_def(10., 0., 0., 0., 15., 0., 0., 0., 20.); istat = set_sat_inertia (iner);

test = get_sat_inertia (); printf(" inertia \n"); printf(" %10.4f %10.4f %10.4f \n", test._1._1, test._1._2, test._1._3);

printf(" %10.4f %10.4f %10.4f \n", test._2._1, test._2._2, test._2._3);

printf(" %10.4f %10.4f %10.4f \n", test._3._1, test._3._2, test._3._3);

// **************** tempo de integração

t_start = 0; t_end = 200; t_step = 1.; istat = set_current_time (t_start); istat = set_step_time (t_step); istat = set_int_step_time (t_step/10.);

// **************** parâmetros iniciais de atitude

// w._1 = 0.; // w._2 = PI/100.; // Exemplo 4 // w._3 = 1.*PI/10.; // ezxz._1 = 180*RADIANS; // ezxz._2 = 4.2892*RADIANS; // ezxz._3 = 0*RADIANS;

// w._1 = PI/100.; // w._2 = 1.*PI/10.; // Exemplo 5 // w._3 = 0; // ezxz._1 = 180*RADIANS; // ezxz._2 = 90*RADIANS; // ezxz._3 = 3.8141*RADIANS;

w._1 = 1.*PI/10.; w._2 = 0; // Exemplo 6 w._3 = PI/100.; ezxz._1 = 180*RADIANS; ezxz._2 = 78.6901*RADIANS; ezxz._3 = 90*RADIANS;

istat = set_ang_velocity (w); quater = ezxzquat (ezxz);

157

istat = set_attitude (quater); exyz = DEGREES*quatezxz(quater);

printf(" Quaternion "); printf("%10.4f %10.4f %10.4f %10.4f \n", quater._1, quater._2, quater._3, quater._4); printf(" Euler angles 3-1-3 "); printf("%10.4f %10.4f %10.4f \n", exyz._1, exyz._2, exyz._3); printf(" Momento angular "); exyz = get_sat_ang_momentum(); printf("%10.4f %10.4f %10.4f \n", exyz._1, exyz._2, exyz._3);

// **************** configuração do integrador

istat = select_integ_method(INTEG_RKF_78, INTEG_FIX);

// ***************** malha de integração

while (t < t_end)

quater = get_attitude (); w = get_ang_velocity (); t = get_current_time ();

// ***************** arquivo de saída

fprintf(nfile, " %10.6f, ", t);

fprintf(nfile, " %14.6f, %14.6f, %14.6f, ", w._1, w._2, w._3);

// exyz = DEGREES*rmxexyz(quatrmx(quater)); // exyz = DEGREES*rmxezxy(quatrmx(quater)); exyz = DEGREES*rmxezxz(quatrmx(quater)); // exyz = DEGREES*rmxezyx(quatrmx(quater));

fprintf(nfile, " %14.6f, %14.6f, %14.6f, ", exyz._1,

exyz._2, exyz._3); vec1 = get_sat_ang_momentum(); fprintf(nfile, " %14.6f, %14.6f, %14.6f, \n", vec1._1, vec1._2, vec1._3);

// ***************** propagação da atitude

sat_propagation (); t = get_current_time ();

fclose (nfile); return 0;

Parte II: Corpo rígido sob a ação de torques externos. Movimento de precessão. 1) Neste exemplo adota-se uma matriz de inércia diagonal, com elementos iguais a 10, 15 e

20, com posição inicial nula e velocidade angular nula. Aplica-se um torque de 2 Nm sobre o eixo z, a partir do instante t = 10s até 60s, seguido de torque nulo até 140s quando então o torque é comutado para –2 Nm até 190s e desligado. Como as velocidade angular

158

inicial é nula, o satélite será acelerado e depois desacelerado até atingir o repouso novamente, como mostram as Figuras B-20 e B-21.

0 20 40 60 80 100 120 140 160 180 200Time (s)

0.0

1.0

2.0

3.0

4.0

5.0Angular velocity (rad/s)

Fig. B-20 – Velocidades angulares do corpo sob a ação do torque.

0 20 40 60 80 100 120 140 160 180 200Time (s)

-2.0

-1.0

0.0

1.0

2.0

Torques (Nm)

Fig. B-21 – Perfil do torque aplicado ao corpo.

2) Neste exemplo analisa-se a ação de um torque perpendicular à direção do momento

angular do corpo. A matriz de inércia é diagonal, com elementos iguais a 10, 15 e 20, atitude inicial nula e velocidade angular de 1 rotação a cada 20 segundos no eixo z. O torque é constante com valor de 0,1 Nm no eixo x inercial, a partir de t = 20s. Uma vez que o torque é inercial, o movimento resultante será uma composição de precessão (nos instantes iniciais) e aceleração da velocidade angular. O momento angular altera-se tanto em módulo quanto em direção. Os resultados que confirmam este comportamento são mostrados nas Figuras B-22 e B-23.

159

0 20 40 60 80 100 120 140 160 180 200Time (s)

0.0

5.0

10.0

15.0

20.0

Angular mom

entum (Nms)

Fig. B-22 – Componentes do momento angular do corpo.

0 20 40 60 80 100 120 140 160 180 200Time (s)

-0.5

0.0

0.5

1.0


Fig. B-23 – Velocidades angulares do corpo.

3) Este exemplo mostra um movimento de precessão semelhante ao movimento de um pião.

A matriz de inércia é diagonal, com elementos iguais a 10, 15 e 20, atitude inicial nula e velocidade angular de 1 rotação a cada 10 segundos no eixo z. Aplica-se um torque de 0,5 Nm sobre o eixo perpendicular a z e perpendicular a uma direção inercial que forma 30° com o eixo z (semelhante ao torque de origem magnética) a partir de t = 20s. Foram adotados ainda um passo de integração (interna) de 0.01s e um ciclo de integração de 0.1s. Os resultados são apresentados nas Figuras B-24 e B-25. Nota-se que o torque induz adicionalmente um movimento de nutação, devido à baixa velocidade angular do corpo.

160

0 20 40 60 80 100 120 140 160 180 200Time (s)

-20.0

-10.0

0.0

10.0

20.0

Angular mom

entum (Nms)

Fig. B-24 – Movimento de precessão de um corpo sob a ação de um torque perpendicular à

direção do momento angular.

0 20 40 60 80 100 120 140 160 180 200Time (s)

-0.5

0.0

0.5

1.0


Fig. B-25 – Velocidades angulares de um corpo sob a ação de um torque perpendicular à

direção do momento angular. Parte III: Corpo rígido sob a ação de torques magnéticos. 1) Este exemplo mostra uma aplicação onde é utilizada a geração de torques magnéticos. A

matriz de inércia é diagonal, com elementos iguais a 10, 15 e 20, atitude inicial nula e velocidade angular de 1 rotação a cada 10 s no eixo z. Uma bobina magnética é alinhada ao eixo z com dipolo de 1 Am2. Para evidenciar o efeito do torque gerado, o campo magnético terrestre é considerado supostamente igual a B = (0,5; 0; 0,86) T. O chaveamento da bobina é adotado como sendo 1 no instante t = 20 s. Os resultados podem ser vistos nas Figuras B-26 e B-27, onde evidencia-se um movimento de precessão superposto a uma pequena nutação.

161

0 20 40 60 80 100 120 140 160 180 200Time (s)

-10.0

0.0

10.0

20.0

Angular mom

entum (Nms)

Fig. B-26 – Variação do momento angular do corpo sob a ação de torques magnéticos.

0 20 40 60 80 100 120 140 160 180 200Time (s)

-0.5

0.0

0.5

1.0


Fig. B-27 – Velocidades angulares de um corpo sujeito a torques magnéticos.

Parte IV: Corpo rígido sob a ação de torques internos de roda de reação. 1) Mostra-se, neste exemplo, a ação de torques oriundos de um sistema de rodas de reação. A

matriz de inércia do corpo é diagonal, com elementos iguais a 10, 15 e 20, atitude inicial e velocidade angular nulas. É suposto que uma roda é orientada no eixo z, com velocidade angular inicial nula e momento de inércia em z de 1 kg m2. Aplica-se um torque (exagerado) de 1 Nm nesta roda, a partir do instante t = 20s até 60s, seguido de um torque nulo até 140s quando o torque é comutado para –1 Nm até 180s quando então é desligado. A Figura B-28 mostra a aceleração e desaceleração da roda nos intervalos de acionamento. A Figura B-29 mostra o momento angular total deste corpo, que é nulo, pois a velocidade angular inicial é nula. Uma vez que o torque gerado é interno, não há variação do momento angular. A Figura B-30 mostra a aceleração e desaceleração sofrida pelo corpo neste exemplo. Nota-se que a reação ao torque aplicado à roda é em sentido contrário a este.

162

0 20 40 60 80 100 120 140 160 180 200Time (s)

0

10

20

30

40

Velocidade angular da roda (rd/s)

Fig. B-28 – Velocidade angular da roda de reação.

0 20 40 60 80 100 120 140 160 180 200Time (s)

-1.0

0.0

1.0

Angular mom

entum (Nms)

Fig. B-29 – Momento angular total (satélite e roda).

0 20 40 60 80 100 120 140 160 180 200Time (s)

-2.0

-1.5

-1.0

-0.5

0.0


Fig. B-30 – Velocidade angular do corpo sujeito a torque de reação.

163

Parte V: Corpo rígido sob a ação de torques de propulsores. 1) Neste exemplo mostra-se uma simulação da ação de torques de controle com propulsores.

A matriz de inércia é ainda diagonal, com elementos iguais a 10, 15 e 20 kgm2. Foram usados 6 propulsores, que fornecem torques nas 3 direções em ambos os sentidos. Foi usado um controle bang-bang (liga-desliga) cujo equacionamento pode ser visto em Wertz (1978), com o objetivo de eliminar a velocidade e os erros da atitude. O programa em C é mostrado abaixo, e os resultados são mostrados nas Figuras B-31, B-32, B-33 e B-34. As oscilações que aparecem nas figuras da velocidade angular e diagrama de fase devem-se à comutação entre o controle de redução da velocidade angular e o controle de posição e velocidade (bang-bang). As retas inclinadas no gráfico de fase representam a zona morta de atuação (relacionada ao MIB).

// configuração dos propulsores

istat = set_thruster_flag (); istat = set_number_thrusters (6); vec1._1 = 0.4; // Posição vec1._2 = 0.8; vec1._3 = 0.; vec2._1 = 0.; // Empuxo vec2._2 = -2; vec2._3 = 0; set_thrusters (1, vec1, vec2); vec1._1 = -0.4; // Posição vec1._2 = 0.8; vec1._3 = 0.; set_thrusters (2, vec1, vec2); vec1._1 = 0.; // Posição vec1._2 = 0.8; vec1._3 = 0.4; set_thrusters (3, vec1, vec2); vec1._1 = 0.; // Posição vec1._2 = 0.8; vec1._3 = -0.4; set_thrusters (4, vec1, vec2); vec1._1 = 0.4; // Posição vec1._2 = 0.; vec1._3 = 0.6; vec2._1 = 0.; // Empuxo vec2._2 = 0.; vec2._3 = -2; set_thrusters (5, vec1, vec2); vec1._1 = -0.4; // Posição vec1._2 = 0.; vec1._3 = 0.6; set_thrusters (6, vec1, vec2); // atitude inicial exyz._1 = 80*RADIANS; exyz._2 = -20*RADIANS; exyz._3 = -150*RADIANS; quater = exyzquat (exyz); istat = set_attitude (quater); // velocidades angulares iniciais w._1 = 0.5; w._2 = 0;

164

w._3 = .5; istat = set_ang_velocity (w); // ganhos do controlador e “minimum impulse bit” kp = 1; kd = 6.; mib = 0.05; while (t < t_end) // atitude quater = get_attitude (); w = get_ang_velocity (); t = get_current_time (); // torque de propulsores exyz = quatexyz (quater); if (modulus(w) > .1) vec2 = kp*kd*w; // reduzir a velocidade angular se tcom = t; // for muito alta else vec2 = kp*(ezxz + kd*w); // controle bang-bang

// inserir limitador de duração de ativação if (fabs(vec2._1) > 1) vec2._1 = copysign(1., vec2._1); if (fabs(vec2._2) > 1) vec2._2 = copysign(1., vec2._2); if (fabs(vec2._3) > 1) vec2._3 = copysign(1., vec2._3); // minimum impulse bit if (fabs(vec2._1) < mib) vec2._1 = 0; if (fabs(vec2._2) < mib) vec2._2 = 0; if (fabs(vec2._3) < mib) vec2._3 = 0;

vec2 = vec2*get_step_time(); // duração do acionamento

// acionar os propulsores if (vec2._1 < 0) istat = set_thruster_duty_cycle (3, -vec2._1); if (vec2._1 > 0) istat = set_thruster_duty_cycle (4, vec2._1); if (vec2._2 < 0) istat = set_thruster_duty_cycle (5, -vec2._2); if (vec2._2 > 0) istat = set_thruster_duty_cycle (6, vec2._2); if (vec2._3 < 0) istat = set_thruster_duty_cycle (2, -vec2._3); if (vec2._3 > 0) istat = set_thruster_duty_cycle (1, vec2._3); vec2 = get_thruster_torque (); sat_propagation ();

165

0 20 40 60 80 100 120 140 160 180 200Time (s)

-0.2

-0.1

0.0

0.1

0.2

0.3

0.4

0.5


Fig. B-31 – Velocidades angulares do corpo sob a ação de torques de propulsão.

0 20 40 60 80 100 120 140 160 180 200Time (s)

-180

-120

-60

0

60

120

180


Fig. B-32 – Atitude do corpo em função do tempo, sob a ação de um controle com

propulsores.

166

-180 -150 -120 -90 -60 -30 0 30 60 90 120 150 180Attitude angles (x-y-z) (deg)

-0.6

-0.4

-0.2

0.0

0.2

0.4

0.6


Fig. B-33 – Diagrama de fase de uma simulação de controle com torques gerados por

propulsores.

0 20 40 60 80 100 120 140 160 180 200Time (s)

-1.0

-0.8

-0.6

-0.4

-0.2

0.0

0.2

0.4

0.6

0.8

1.0

Torques (Nm)

Fig. B-34 – Histórico de acionamento dos propulsores para o controle de atitude.

Parte VI: Propagação de órbita.

A propagação automática de órbita em elementos médios foi testada com o programa em C listado a seguir. O gráfico da Figura B-35 mostra a latitude em função da longitude do satélite, em coordenadas geocêntricas terrestres, dadas pela segunda e terceira componentes do vetor vec1. t_start = 0; t_end = 86400; t_step = 60; istat = set_current_time (t_start); istat = set_step_time (t_step); istat = set_int_step_time (0.1); t = t_start;

// >>>>> parâmetros orbitais istat = set_orbit_propagation_flag(); istat = set_orbit_propagation_model(0);

167

istat = set_ephemeris_date (1, 1, 2001, 10, 40, 0.0); kepel._1._1 = EARTH_RADIUS + 600000, kepel._1._2 = 0.06; kepel._1._3 = 1.; kepel._2._1 = 0.; kepel._2._2 = 0.5; kepel._2._3 = 0.; istat = set_keplerian_elements (kepel);

// >>>>>> malha de integração while (t < t_end) t = get_current_time (); // propagação de órbita vec1 = rectangular_to_spherical(get_terrestrial_sat_pos()); stve = get_current_date(); sat_propagation ();

-180 -150 -120 -90 -60 -30 0 30 60 90 120 150 180-90

-60

-30

0

30

60

90

Fig. B-35 – Trajetória corpo numa órbita propagada em elementos médios. Na abcissa

encontra-se a longitude (graus) e na ordenada é mostrada a latitude (graus).

A propagação de órbita em elementos osculadores foi testada com a órbita da Estação Espacial Internacional, cujo arquivo nasa2l.dat é listado a seguir. Utilizou-se o programa em C listado abaixo. O gráfico da Figura B-36 mostra a latitude em função da longitude da estação, em coordenadas geocêntricas terrestres, dadas pela segunda e terceira componentes do vetor vec1. nasa_el nsel; FILE *ifile; t_start = 0; t_end = 86400; t_step = 60; istat = set_current_time (t_start); istat = set_step_time (t_step); istat = set_int_step_time (0.1); t = t_start;

168

// >>>>> parâmetros orbitais istat = set_orbit_propagation_flag();

istat = set_orbit_propagation_model(1); ifile = fopen("nasa2l.dat", "r"); nsel = nasael (ifile, 2); fclose(ifile); istat = set_two_line_elements(nsel);

// >>>>>> malha de integração while (t < t_end) t = get_current_time (); // propagação de órbita vec1 = rectangular_to_spherical(get_terrestrial_sat_pos()); stve = get_current_date(); sat_propagation ();

O arquivo nasa2l.dat contém os elementos da ISS:

1 25544U 98067A 06209.44126052 .00020000 00000-0 20000-3 0 9000 2 25544 51.6328 334.9355 0008434 128.4132 231.7791 15.76108147 39674

-180 -150 -120 -90 -60 -30 0 30 60 90 120 150 180-90

-60

-30

0

30

60

90

Fig. B-36 – Trajetória corpo numa órbita propagada com o modelo SGP8. Na abcissa

encontra-se a longitude (graus) e na ordenada é mostrada a latitude (graus). Parte VII: Sensores

Nesta seção são mostrados os resultados obtidos com a simulação de leituras dos sensores relatados no Capítulo 6. Em todas as simulações apresentadas a seguir, o satélite encontra-se estabilizado inercialmente, com velocidade angular nula e com atitude dada por: 80o, −20o, −150o nos eixos x, y e z, respectivamente:

// >>>>>>>>> parâmetros iniciais de atitude

169

ezxz._1 = 80*rad; ezxz._2 = -20*rad; ezxz._3 = -150*rad; quater = exyzquat (ezxz); istat = set_attitude (quater); w._1 = 0; w._2 = 0; w._3 = 0; istat = set_ang_velocity (w);

A atitude é propagada por 200 segundos, com ciclo de 0.5 segundo (passo externo ao

integrador numérico): // >>>>>>>>> intervalos de tempo t_start = 0; t_end = 200; t_step = 0.5; istat = set_current_time (t_start); istat = set_step_time (t_step); istat = set_int_step_time (0.1); t = t_start;

A dinâmica do satélite é calculada com base numa matriz de inércia diagonal com

momentos iguais a 10, 15 e 20 kg m2: // >>>>>>>>>> inércia e massa iner._1._1 = 10; iner._1._2 = 0; iner._1._3 = 0; iner._2._1 = 0; iner._2._2 = 15; iner._2._3 = 0; iner._3._1 = 0; iner._3._2 = 0; iner._3._3 = 20; istat = set_sat_inertia (iner);

Finalmente, a órbita é estabelecida por meio de elementos keplerianos, porém com

propagação efetuada pelo modelo SGP8: // >>>>>>>>>> parâmetros orbitais istat = set_orbit_propagation_flag(); istat = set_orbit_propagation_model(1); kepel._1._1 = EARTH_RADIUS + 600000; kepel._1._2 = 0.06; kepel._1._3 = 1.; kepel._2._1 = 0.; kepel._2._2 = 0.5; kepel._2._3 = 0.; istat = set_keplerian_elements (kepel); istat = set_ephemeris_date (1, 1, 2001, 10, 40, 0.0);

a) Magnetômetro

170

O magnetômetro foi configurado para apresentar um ruído de 2nT, alinhamento com

os eixos do satélite e viés de −2, 4 e −3 nT nas direções x, y e z, respectivamente: // >>>>>>> magnetômetro auxi = s_gaussian_noise (0.); axis_d = identity(1.); std_dev = identity(2.e-7); bias._1 = -2.e-7; bias._2 = 4.e-7; bias._3 = -3.e-7; istat = set_3axis_mag (axis_d, std_dev, bias, 1.);

Os resultados das leituras simuladas do magnetômetro são apresentados nas Figuras B-

37, B-38 e B-39, relativas aos 3 eixos do satélite.

0 20 40 60 80 100 120 140 160 180 200Time (s)

-335

-330

-325

-320

-315

-310

Magnetometer output X

(nT)

Fig. B-37 – Simulação do magnetômetro na direção x.

0 20 40 60 80 100 120 140 160 180 200Time (s)

0

50

100

150

200

250

Magnetometer output Y

(nT)

Fig. B-38 – Simulação do magnetômetro na direção y.

171

0 20 40 60 80 100 120 140 160 180 200Time (s)

230

240

250

260

270

280

Magnetometer output Z (nT)

Fig. B-39 – Simulação do magnetômetro na direção y.

b) Sensor de estrelas.

Para simular este sensor, adotou-se um ruído de 6 10-5 rad (cerca de 12 segundos de arco) nas direções x e y, e 4.2 10-4 rad (86 segundos de arco) na direção z. Considerou-se que o sensor possui eixos alinhados ao sistema geométrico do satélite:

// >>>>>>>> sensor de estrelas auxi = s_gaussian_noise (0);

att_ss = identity(1.); std_dev = identity(6.e-5); std_dev._3._3 = 4.2e-4; istat = set_star_sensor (std_dev, att_ss);

A simulação apresentou os resultados mostrados nas Figuras B-40, B-41 e B-42, que

correspondem aos ângulos de Euler de uma rotação nos eixos x, y e z, respectivamente. Compare-se os resultados com a atitude inicial fornecida de 80o, −20o, −150o.

0 20 40 60 80 100 120 140 160 180 200Time (s)

79.99

80.00

80.01

80.02

Euler angle X (deg)

Fig. B-40 – Simulação da atitude fornecida pelo sensor de estrelas no eixo x.

172

0 20 40 60 80 100 120 140 160 180 200Time (s)

-20.01

-20.00

-19.99

Euler angle Y (deg)

Fig. B-41 – Simulação da atitude fornecida pelo sensor de estrelas no eixo y.

0 20 40 60 80 100 120 140 160 180 200Time (s)

-150.10

-150.00

-149.90

Euler angle Z (deg)

Fig. B-42 – Simulação da atitude fornecida pelo sensor de estrelas no eixo z.

c) Sensor GPS

Adotou-se para o sensor GPS um desvio padrão não correlacionado uniforme nos três eixos, de 10 m em posição e 0.01 m/s em velocidade. O vetor de estado apresentado pelo sensor (lido a cada 0.5s) foi convertido para elementos keplerianos pela função statvec_kepel, que são apresentados nas Figuras B-43 a B-48 (semi-eixo maior, excentricidade, inclinação, ascenção reta do nodo ascenente, argumento do perigeu e anomalia média). O código usado na configuração do sensor foi:

// >>>>>>>>>> sensor GPS auxi = s_gaussian_noise (0); std_dev = identity(1); istat = set_gps_sensor (10.*std_dev, 0.01*std_dev, 1., 1.);

Os resultados devem ser comparados com os elementos orbitais previamente definidos.

173

0 20 40 60 80 100 120 140 160 180 200Time (s)

6978

6979

6980

6981

6982

6983

Semi m

ajor axis (km)

Fig. B-43 – Simulação do sensor GPS – semi-eixo maior orbital, em km.

0 20 40 60 80 100 120 140 160 180 200Time (s)

0.0602

0.0604

0.0606

0.0608

0.0610

Eccentricity

Fig. B-44 – Simulação do sensor GPS – excentricidade.

0 20 40 60 80 100 120 140 160 180 200Time (s)

1.00000

1.00005

1.00010

1.00015

1.00020

Inclination (rad)

Fig. B-45 – Simulação do sensor GPS – inclinação (rad).

174

0 20 40 60 80 100 120 140 160 180 200Time (s)

0.00020

0.00025

0.00030

0.00035Ascending node (rad)

Fig. B-46 – Simulação do sensor GPS – ascenção reta do nodo (rad).

0 20 40 60 80 100 120 140 160 180 200Time (s)

0.517

0.518

0.519

0.520

Perigee argum

ent (rad)

Fig. B-47 – Simulação do sensor GPS – argumento do perigeu (rad).

0 20 40 60 80 100 120 140 160 180 200Time (s)

-0.05

0.00

0.05

0.10

0.15

0.20

Mean anom

aly (rad)

Fig. B-48 – Simulação do sensor GPS – anomalia média (rad).

d) Sensor solar analógico

Para o teste do modelo do sensor solar analógico adotou-se a configuração da Plataforma Multi-Missão, na qual são fixados oito sensores no satélite, numa geometria octagonal. Utilizou-se um desvio padrão relativo de 0.02 e absoluto de 0.01. O ganho do sensor foi unitário. Alterou-se a anomalia média da órbita para 6,09 rad (kepel._2._3) para

175

que os gráficos mostrassem o instante de ingresso do satélite na sombra da Terra (por volta de 185 s). Os comandos de configuração do sensor foram:

// >>>>>>>>>> sensor solar analógico

auxi = s_gaussian_noise (0); istat = set_css_number(8);

css_rel = 0.02; css_abs = 0.01;

auxi = sqrt(2.)/2.; vec2._1 = 0.5; // +X +Y +Z

vec2._2 = 0.5; vec2._3 = auxi;

istat = set_coarse_sun_sensor (1, 0, vec2, css_ab, css_rel, 1); vec2._1 = -0.5; // -X +Y +Z

vec2._2 = 0.5; vec2._3 = auxi;

istat = set_coarse_sun_sensor (2, 0, vec2, css_ab, css_rel, 1); vec2._1 = -0.5; // -X -Y +Z vec2._2 = -0.5;

vec2._3 = auxi; istat = set_coarse_sun_sensor (3, 0, vec2, css_ab, css_rel, 1);

vec2._1 = 0.5; // +X -Y +Z vec2._2 = -0.5;

vec2._3 = auxi; istat = set_coarse_sun_sensor (4, 0, vec2, css_ab, css_rel, 1);

vec2._1 = 0.5; // +X +Y -Z vec2._2 = 0.5;

vec2._3 = -auxi; istat = set_coarse_sun_sensor (5, 0, vec2, css_ab, css_rel, 1);

vec2._1 = -0.5; // -X +Y -Z vec2._2 = 0.5;


vec2._1 = -0.5; // -X -Y -Z vec2._2 = -0.5;


vec2._1 = 0.5; // +X -Y -Z vec2._2 = -0.5;


A Figura B-49 mostra o fator de sombra obtido pela função earth_shadow, enquanto

que a Figura B-50 apresenta as leituras dos 8 sensores solares. Conforme pode ser visto nesta figura, os sensores 1, 2, 5 e 6 encontram-se do lado oposto ao Sol, e, portanto, suas leituras apresentam apenas um ruído de fundo. Conclui-se desta figura que o Sol encontra-se provavelmente no quadrante –X +Y +Z. No exemplo mostrado na Figura B-51 adotou-se uma velocidade angular no eixo z de 1 rotação a cada 100 segundos.

176

0 20 40 60 80 100 120 140 160 180 200Time (s)

-0.2

0.0

0.2

0.4

0.6

0.8

1.0

1.2

Earth shadow factor

Fig. B-49 – Fator de sombra da Terra utilizado no modelo do sensor solar.

0 20 40 60 80 100 120 140 160 180 200

Time (s)

-0.2

0.0

0.2

0.4

0.6

0.8

1.0

1.2

CSS Readings

Fig. B-50 – Leitura dos 8 sensores solares analógicos, com velocidade angular nula.

0 20 40 60 80 100 120 140 160 180 200Time (s)

-0.2

0.0

0.2

0.4

0.6

0.8

1.0

1.2

CSS Readings

Fig. B-51 – Leitura dos 8 sensores solares analógicos, com velocidade angular de 1

ciclo a cada 100 segundos.

e) Unidade inercial

A unidade inercial testada consiste de giros sem desalinhamento, com erro de fator de escala igual a 10-7 nos três eixos, viés de 5 10-9 rad/s nos três eixos, random drift não

3 4

2

1

5, 6, 7, 8

2

1 3

4

5, 6, 7, 8

177

correlacionado de 10-8 rad/s, e random walk de 4 10-10 rad/s3/2. Acrescentou-se uma velocidade angular de 3,6o/s no eixo x, como visto na listagem a seguir.

w._1 = 2*pi/100.; w._2 = 0;

w._3 = 0; auxi = s_gaussian_noise (0); axis_dir = identity(1.); sc_er._1 = 1.e-7; sc_er._2 = 1.e-7; sc_er._3 = 1.e-7; bias._1 = 5.e-9; bias._2 = 5.e-9; bias._3 = 5.e-9; drift = identity(1.e-9); rand_wk = identity(4.e-10); istat = set_inertial_unit (axis_dir, sc_er, bias, drift, rand_wk);

As Figuras B-52 a B-54 mostram as leituras da unidade inercial, em unidades de grau por hora, nos eixos cartesianos x, y e z do satélite, respectivamente. Subtraiu-se no gráfico da leitura do eixo x o valor de 3,6o/s para que a escala ficasse pequena.

0 20 40 60 80 100 120 140 160 180 200Time (s)

0.000

0.001

0.002

0.003

Angular velocity X (deg/h)

Fig. B-52 – Leitura da velocidade angular na direção x (subtraída de.3,6o/s).

0 20 40 60 80 100 120 140 160 180 200Time (s)

0.000

0.001

0.002

Angular velocity Y (deg/h)

Fig. B-53 – Leitura da velocidade angular na direção y da unidade inercial.

178

0 20 40 60 80 100 120 140 160 180 200Time (s)

0.000

0.001

0.002

Angular velocity Z (deg/h)

Fig. B-54 – Leitura da velocidade angular na direção z da unidade inercial.

Parte VIII: Tempo real Os testes referentes ao processamento em tempo real foram descritos na Seção 7.1. Serão mostrados aqui os resultados de uma propagação de atitude utilizando-se os dois tipos de prodedimentos utilizados para a sincronização de tempo: o intervalo de espera de processamento e o ajuste do passo. Os parâmetros utilizados na atitude foram: propagação por 60 segundos, matriz de inércia diagonal com elementos iguais a 10, 15 e 20 kg m2, atitude inicial em ângulos de Euler z-x-z de 80o, –20o e –150o, respectivamente, velocidade angular sobre o eixo x de uma rotação a cada 100 segundos, e velocidades nulas nos demais eixos. Na propagação por tempo de espera utilizou-se um passo de 0,05 s, e o passo médio obtido na propagação com ajuste de passo foi de 46 µs. As Figuras B-55 e B-56 mostram os resulados da propagação, em termos dos ângulos de Euler de rotações x-y-z.

0 10 20 30 40 50 60Time (s)

-180-150-120-90-60-300306090120150180

Euler angles x-y-z (deg)

Fig. B-55 – Propagação da atitude em tempo-real com sincronização por intervalo de espera, e

passo de 0,05s.

179

0 10 20 30 40 50 60Time (s)

-180-150-120-90-60-300306090120150180

Euler angles x-y-z (deg)

Fig. B-56 – Propagação da atitude em tempo-real com sincronização por ajuste de passo, e

passo médio de 46 µs.

181

Apêndice C Relação de funções

A relação das funções que constituem o pacote de propagação e simulação de atitude é apresentada na Tabela C.1, em ordem alfabética.

Tabela C.1 Funções integrantes do pacote att_pro

Retorno Especificação Argumentos double actan (double sinx, double cosx);

quaternion conjugate (quaternion quat); vector3 dayf_to_time (double dayf);

vector6 delkep (vector6 kep_el); int djm (int day, int month, int year);

vector3 djm_inv (int mjd); double earth_shadow (vector3 sat_pos, vector3

sun_pos); quaternion eulerquat (quaternion euler);

matrix3 eulerrmx (quaternion euler); quaternion exyzquat (vector3 euler);

matrix3 exyzrmx (vector3 euler);

quaternion ezxzquat (vector3 euler); matrix3 ezxyrmx (vector3 euler);

matrix3 ezxzrmx (vector3 euler); matrix3 ezyxrmx (vector3 euler);

double fmod2p (double x); double gaussian_noise (unsigned int id_noise);

vector3 geocentric_to_sph_geodetic (vector3 geoc);

vector3 geomag_field (int output_sel, double date, vector3 geo_cor);

vector3 get_ang_velocity (void); quaternion get_attitude (void);

vector3 get_body_earth_vector (void); vector3 get_body_geomag_vector (void);

vector3 get_body_ovect (int ind); double get_body_pos (int k);

matrix3 get_body_rmatrix (int ind);

vector3 get_body_sun_versor (void); double get_body_vel (int k);

double get_coil_magnetic_moment (int ind_coil); vector3 get_coil_vector (int ind_coil);

vector3 get_control_torque (void); int get_control_torque_flag (void);

int get_css_number (void); vector6 get_current_date (void);

double get_current_time (void);

double get_greenwich_sidereal_time (void); vector3 get_inertial_geomag_strength (void);

vector6 get_inertial_state_vector (void); vector3 get_inertial_sun_vector (void);

double get_int_step_time (void); double get_integ_abs_err (void);

double get_integ_rel_err (void);

int get_number_bodies (void);

182

int get_number_coils (void); int get_number_thrusters (void);

int get_number_wheels (void);

int get_orbit_propagation_flag (void); int get_orbit_propagation_model (void);

vector3 get_sat_ang_momentum (void); vector3 get_sat_center_mass (void);

matrix3 get_sat_inertia (void); double get_sat_mass (void);

double get_step_time (void);

vector3 get_terrestrial_sat_pos (void); double get_thruster_duty_cycle (int ind_thrtr);

int get_thruster_flag (void); vector3 get_thruster_position (int ind_thrtr);

double get_thruster_thrust (int ind_thrtr); vector3 get_thruster_torque (void);

vector3 get_thruster_vector (int ind_thrtr); int get_torque_coil_flag (void);

double get_torque_coil_switch_state (int ind_coil);

vector3 get_torque_coil_torque (void); double get_wheel_inertia (int ind_wheel);

double get_wheel_momentum (int ind_wheel); vector3 get_wheel_momentum_xyz (void);

double get_wheel_speed (int ind_wheel); double get_wheel_torque (int ind_wheel);

int get_wheel_torque_flag (void);

vector3 get_wheel_torque_xyz (void); vector3 get_wheel_vector (int ind_wheel);

double gst (int mjd, double tsec); matrix3 identity (double escalar);

int igrf10syn (double date, double alt, double colat, double elong, double field[3]);

vector3 inertial_to_terrestrial (double tesig, vector3 xi);

matrix3 inverse (matrix3 rmin); vector6 kepel_statvec (vector6 kepel);

double kepler (double mean_anomaly, double eccentricity);

matrix3 mat3_def (double a11, double a12, double a13, double a21, double a22, double a23, double a31, double a32, double a33);

double mean_a (nasa_el nasaelements); double mean_n (vector6 kepel);

double modulus (vector3 vi); nasa_el nasael (FILE *ifile, int itype);

double nodal_period (double semi_major_axis, double inclination);

quaternion quat_def (double q1, double q2, double q3, double q4);

quaternion quateuler (quaternion quater); vector3 quatexyz (quaternion quater);

vector3 quatezxz (quaternion quater);

matrix3 quatrmx (quaternion quater); vector3 read_3axis_mag (void);

double read_coarse_sun_sensor (int ind_css); vector6 read_gps_sensor (void);

vector3 read_inertial_unit (void); quaternion read_star_sensor (void);

183

vector3 rectangular_to_spherical (vector3 rectan); int reset_control_torque_flag (void);

int reset_orbit_propagation_flag (void);

int reset_thruster_flag (void); int reset_torque_coil_flag (void);

int reset_wheel_torque_flag (void); quaternion rmxeuler (matrix3 rotmatrix);

vector3 rmxexyz (matrix3 rotmatrix); vector3 rmxezxy (matrix3 rmat);

vector3 rmxezxz (matrix3 rotmatrix);

vector3 rmxezyx (matrix3 rmat); quaternion rmxquat (matrix3 rmat);

matrix3 rotmax (double angl); matrix3 rotmay (double angl);

matrix3 rotmaz (double angl); double rt_adjust_step_time (double t, double step);

double rt_clock_resolution (void); void rt_reset_timer (void);

double rt_time_since (double temp);

double rt_timer (void); void rt_wait (double temp);

int rt_wait_till (double temp); double s_gaussian_noise (unsigned int seed);

int sat_append (void); int sat_att_dyn (double *time, double *x, double

*xp, void *ptr); matrix3 sat_invmat (matrix3 rmin);

int sat_propagation (void);

int select_integ_method (int inttyp, int intmet); int set_3axis_mag (int ind_body, matrix3 axis_dir,

matrix3 std_dev, vector3 bias, double factor);

int set_ang_velocity (vector3 w);

int set_attitude (quaternion quater);

int set_body_accel (double ack[8]); int set_body_k (int k, double b_mass, matrix3

b_iner, double dh0[4], double dh1[4], double dh2[2]);

int set_body_pos (int k, double b_angl, double b_vel);

int set_coarse_sun_sensor (int ind_css, int ind_body, vector3 css_norm, double css_abs, double css_rel, double k_css);

int set_coil_magnetic_moment (int ind_coil, vector3 vec_coil); int set_control_torque (vector3 tc);

int set_control_torque_flag (void);

int set_css_number (int cssnum); int set_current_time (double time);

int set_ephemeris_date (int day, int month, int year, int hour, int minut, double secon);

int set_gps_sensor (matrix3 std_dev_p, matrix3 std_dev_v, double k_gps_p, double k_gps_v);

int set_greenwich_sidereal_time (double gwsd);

int set_inertial_geomag_strength (vector3 geomagnetic); int set_inertial_sat_pos (vector3 satpos);

int set_inertial_sun_vector (vector3 sunvec); int set_inertial_unit (matrix3 axis_dir, vector3

scale_error, vector3 bias, matrix3

184

random_drift, matrix3 random_walk);

int set_int_step_time (double ditime); int set_integ_precision (double rel_err, double abs_err);

int set_keplerian_elements (vector6 kepel);

int set_number_bodies (int n); int set_number_coils (int ncoils);

int set_number_thrusters (int nthrusters); int set_number_wheels (int nwheels);

int set_orbit_propagation_flag (void); int set_orbit_propagation_model (int orb_model);

int set_sat_inertia (matrix3 sat_in); int set_sat_mass (double mass);

int set_star_sensor (matrix3 std_dev_ss, matrix3 att_ss);

int set_step_time (double dtime);

int set_thruster_duty_cycle (int ind_thrtr, double time_prop); int set_thruster_flag (void);

int set_thrusters (int ind_thrtr, vector3 thrtr_pos, vector3 thrtr_thrust);

int set_torque_coil_flag (void); int set_torque_coil_switch_state (int ind_coil, double act_torq);

int set_two_line_elements (nasa_el tl_elem); int set_wheel_momentum (int ind_wheel, double hw);

int set_wheel_torque (int ind_wheel, double torq);

int set_wheel_torque_flag (void); int set_wheel_vector (int ind_wheel, vector3

vec_wheel);

int sgp8 (nasa_el nasaelements);

vector6 sgp8pr (double tsince); vector6 sgp8pr_mean (double tsince);

matrix3 skew_symmetric (vector3 win); vector3 sph_geodetic_to_geocentric (vector3 spgd);

vector3 spherical_to_rectangular (vector3 spher); vector6 statvec_kepel (vector6 statv);

int sun (double djm, double ts, double s[6]);

vector3 sun_coord (int output_sel, int djm, double ts);

vector3 terrestrial_to_inertial (double tesig, vector3 xt);

double time_to_dayf (int hours, int minutes, double seconds);

matrix3 transpose (matrix3 a); quaternion unity_quaternion (quaternion quat);

vector3 unity_vector (vector3 vi); vector3 vec3_def (double vx, double vy, double vz);

vector6 vec6_def (double vx, double vy, double vz, double wx, double wy, double wz);

vector3 vec_gaussian_noise (unsigned int id_noise);

185

Apêndice D Controle de versões Versão 1.0.2

• Os torques aplicados a rodas de reação, e as acelerações dos apêndices articulados

passaram a ser integrados analiticamente e não mais por meios numéricos. O vetor de integrações, que antes poderia ter até 31 componentes (4 para os quatérnions, 3 para as velocidades angulares, até 8 para os torques nas rodas, até 8 para as acelerações angulares nos apêndices e até 8 para as velocidades angulares dos apêndices) passou a ter apenas 7 componentes (quatérnions e velocidades). De certa forma esta integral analítica limita a possibilidade de se alterar os torques das rodas ou as acelerações dos apêndices durante um ciclo de integração. De fato, previa-se que, em versões futuras, estas alterações nos torques seriam efetuadas por meio de funções “callback”. Uma vez que a integração analítica é incompatível com tais alterações, dever-se-á escolher um passo de integração adequado à velocidade de variação destes torques. Esta alteração teve impacto nas seguintes funções: set_wheel_torque_flag, set_number_wheels, set_number_bodies, set_body_accel, set_body_pos e sat_propagation.

• Introdução do controle de versões. Criação da constante ATT_PRO_VERSION.

• Introdução das constantes de configuração (ver Seção 2.2).

• Criação das seguintes funções: vec3_def, vec6_def, quat_def e mat3_def, todas

descritas na Seção 2.1; seletor do integrador numérico (select_integ_method), descrito na Seção 3.7; função get_wheel_momentum_xyz, descrita na Seção 3.4; e funções de transformação de coordenadas rmxezxy, ezxzrmx, rmxezxy e ezyxrmx, descritas na Seção 4.2.

Versão 1.0.0

Situação original.

Pacote computacional para simulação de atitude de...

Documents

Transcript of Pacote computacional para simulação de atitude de...