sun.c

// --- [ sun.c ] --------------------------------------------------------------

//       02.01.09

// Der Rechenweg für den Sonnenstand kommt von:

//-----------------------------------------------------------------------------

// Prozessor : ATmega8

// Sprache   : C

// Datum     : 20.09.2008

// Version   : 1.0

// Autor     : Cusoe

// Programm  : vereinfachte Sonnenstandsberechnung

//-----------------------------------------------------------------------------

#include  <avr\io.h>        //AVR Register und Konstantendefinitionen

#include  <avr\interrupt.h>   //AVR Interrupt Vektoren

#include  <stdlib.h>

#include  <inttypes.h>

#include  <math.h>

#include "global.h"

#include "lcd.h"

#include "sun.h"

#ifdef SUN

// ----------------------------------------------------------------------------

// zeigt die Daten an

// stellt zuerst das Vorzeichen fest, wandelt ggf. in positiven Wert um

// multipliziert mit 100, damit 2 Nachkommastellen mitgenommen werden

// wandelt dann die Floats um in uint16_t

// und legt upper und lower Byte in Array SUN_data ab.

// und zeigt natürlich die Werte auch noch an.

void SUN_display (void)

{

static uint8_t x = 0;

uint16_t tmp;

DCF_make_UTC_time();              // UTC-Zeit aus der aktuellen Uhrzeit erzeugen

SUN_calc();                    // Elevation und Azimuth für UTC-Zeit berechnen 

                          // und in die globalen Variablen schreiben

// Elevation und Azimuth umwandeln von double nach 2x uint8_t/uint16_t

// die Werte speichern und ausgeben

if (elevation > 0)               // Elevation -90 ... + 90, Vorzeichen bestimmen

  {

  SUN_data[SUN_EL_SIGN] = PLUS; 

  }

else

  {

  SUN_data[SUN_EL_SIGN] = MINUS;

  elevation = 0 - elevation;        // zu positivem Wert machen

  }

tmp = (uint16_t) (elevation * 100);    // für zwei Nachkommastellen mit 100 multiplizieren

SUN_data[SUN_EL_HIGH] = (uint8_t) (tmp / 256); // zerlegen und speichern

SUN_data[SUN_EL_LOW] = (uint8_t) tmp;

#ifdef LCD

lcd_goto_xy(3,6);                // 0 - 90

SUN_print(tmp, SUN_data[SUN_EL_SIGN], 2);  // Ausgeben

#endif

tmp = (uint16_t) (azimuth * 100);    // Azimuth 0 ... 360

SUN_data[SUN_AZ_HIGH] = (uint8_t) (tmp / 256); // zerlegen und speichern

SUN_data[SUN_AZ_LOW] = (uint8_t) tmp;

#ifdef LCD

lcd_goto_xy(4,5);  

SUN_print(tmp, '+', 3);

#endif

if (!(x == (CLK_time[TAG])))        // 1mal am jedem Tag und direkt nach dem Programmstart

  {                        // Sonnenauf-Untergang berechnen 

  x = CLK_time[TAG];            // das dauert einige Zeit ... 

  SUN_check_sunrise();            // Durch Iteration Sonnenaufgang/Untergang bestimmen

  }

#ifdef LCD

lcd_goto_xy(3, 13);              // Sonnenaufgang ausdrucken

lcd_dezprint(SUN_data[SUN_UP_H]);

lcd_putc('.');

lcd_dezprint(SUN_data[SUN_UP_M]);

lcd_goto_xy(4, 13);              // Sonnenuntergang ausdrucken

lcd_dezprint(SUN_data[SUN_DN_H]);

lcd_putc('.');

lcd_dezprint(SUN_data[SUN_DN_M]);

#endif

}

//----------------------------------------------------------------------

// Dezimaltag vom aktuellen Tag berechnen

//----------------------------------------------------------------------

float dezimal_day(void)

{

// wenn nur zu voller Minuten berechnet wird sollte dies ausreichen:

// die Sekundenbruchteile werden vernachlässigt

return(UTC_time[STUNDE] / 24.0 + UTC_time[MINUTE] / 1440.0 );

}

//----------------------------------------------------------------------

// Anzahl Dezimaltage seit 2000 bis aktuelles Datum berechnen

//----------------------------------------------------------------------

float julian_day(void)

{

return((float) (UTC_time[JAHR] * 365 + floor((UTC_time[JAHR] / 4)) + day_of_year(UTC_time) - 0.5));

}

//----------------------------------------------------------------------

// Reduzierung eines Winkel auf 0... 2PI rad, Stunden auf 0... 24 h etc.

// x=Wert der reduziert werden soll; y=Reduzierbereich z.B. auf 24h

//----------------------------------------------------------------------

float degr(float x, float y)

{

if(x < 0) x = x + y;

return((x - (floor(x / y) * y)));

}

// --------------------------------------------------------------------

// Den Sonnenauf/untergang durch "Probieren" bestimmen

// entspricht ungefähr der 'Bürgerlichen Dämmerung' ??

// von 09.00h in 1 Stunden Intervallen bis unter -x Grad,

// dann in 1 Minuten Intervallen zurück > -x Grad

// von 15.00h in Stunden-Intervallen bis unter -x Grad,

// dann in 1 Minuten-Intervallen zurück bis > -x Grad

void SUN_check_sunrise(void)

{

// die UTC-Zeit muss am Ende der Funktion neu aufgebaut werden !

UTC_time[MINUTE] = 0;

UTC_time[STUNDE] = 10;

do  {                         // Sonnenaufgang bestimmen

  UTC_time[STUNDE]--;            // um eine Stunde decrementieren

  SUN_calc();

  } while (elevation > (ELEVATION));  // bis der gewählte Grenzwert unterschritten ist

do {

  DCF_incr_time(UTC_time, 1);       // um 1 Minute incrementieren

  SUN_calc();

  } while (elevation < (ELEVATION));  // bis der gewählte Grenzwert überschritten ist

SUN_data[SUN_UP_M] = UTC_time[MINUTE];  // die Uhrzeit speichern

SUN_data[SUN_UP_H] = UTC_time[STUNDE] + 1;// für unsere Zeitzone im Winter + 1 Stunde

                           // während der Sommerzeit + 2 Stunden

if (is_summertime(CLK_time)) UTC_time[STUNDE]++;

UTC_time[MINUTE] = 59;

UTC_time[STUNDE] = 14;

do  {                        // Sonnenuntergang bestimmen

  UTC_time[STUNDE]++;            // um eine Stunde incrementieren

  SUN_calc();

  }

  while (elevation > (ELEVATION));    // bis der gewählte Grenzwert unterschritten ist

do  {

  DCF_decr_time(UTC_time, 1);       // um 1 Minute decrementieren

  SUN_calc();

  } while (elevation < (ELEVATION));  // bis der gewählte Grenzwert überschritten ist

SUN_data[SUN_DN_M] = UTC_time[MINUTE]; // die Uhrzeit speichern

SUN_data[SUN_DN_H] = UTC_time[STUNDE] + 1;// für unsere Zeitzone im Winter + 1 Stunde

                          // während der Sommerzeit + 2 Stunden

if (is_summertime(CLK_time)) UTC_time[STUNDE]++;

DCF_make_UTC_time();              // UTC_Zeit neu aus der Uhr kopieren

}

//----------------------------------------------------------------------

// Vereinfachte Sonnenstandsberechnung

//----------------------------------------------------------------------

void SUN_calc(void)

{

double j, l, g, a, e, rekt, dekl, t0, sh, t, mz, rz, el, kr;

double jd0, dt, la, br;

double azi, elev;

jd0 = julian_day();

dt  = dezimal_day();

la  = geo_laenge / KO; 

br  = geo_breite / KO;

j = jd0 + dt;

l = degr(4.894950420 + 0.01720279239 * j, M_2PI);   // Postion der Sonne auf der Ekliptik

g = degr(6.240040768 + 0.01720197034 * j, M_2PI);   // mittlere Anomalie

a = l + 0.03342305518 * sin(g) + 0.0003490658504 * sin(2 * g); // ekliptikale Länge der Sonne

e = 0.4090928042 - 0.000000006981317008 * j;     // Schiefe der Ekliptik

rekt = atan(cos(e) * sin(a) / cos(a));         // Rektaszension

if(cos(a) < 0) rekt = rekt + M_PI;

dekl = asin(sin(e) * sin(a));               // Deklination

t0 = jd0 / 36525.0;                       // Tageszahl in julianischen Jahrhunderten

sh = degr(6.697376 + 2400.05134 * t0 + 1.002738 * dt * 24, 24); // mittlere Sternzeit

t = sh * 0.2617993878 + la - rekt;             // Stundenwinkel der Sonne bezogen auf den Ort

mz = cos(t) * sin(br) - tan(dekl) * cos(br);     // Nenner Azimut

rz = atan(sin(t) / mz) + M_PI;               // Azimunt wird von 0° Nord gezählt

if(mz < 0) rz = rz + M_PI;                  // wenn Nenner vom Azimut kleiner 0

                                  // dann den Winkel in den richtigen Quadranten bringen

azi = degr(rz, M_2PI);                     // Azimut reduzieren

                                  // Elevation

el = asin(cos(dekl) * cos(t) * cos(br) + sin(dekl) * sin(br));

                                  // Korrekturwert für Refraktion

kr = 0.0002967059728 / tan(el + 0.179768913 / (el + 0.08918632478));

elev = el + kr;                         // Elevation einschliesslich Refraktion

// Ausgabe des Ergebnisses in globale Variable

azimuth   = (azi * KO);

elevation = (elev * KO);

}

// ---------------------------------------------------------------------------

// eine bereits 'vorverdaute' Float-Zahl ausgeben

#ifdef LCD

void SUN_print(uint16_t j, uint8_t c, uint8_t vorkomma)

{

register uint8_t i = 0;

lcd_putc(c);                  // Vorzeichen ausgeben

if (vorkomma > 2)                // bei dreistelligen Ziffern

  {

  i = 0;

  while (j > 9999)

    {

    j -= 10000;

    i++;

    }

  lcd_putc('0' + i);            // Hunderterstelle

  }

i = 0;

while (j > 999)

  {

  j -= 1000;

  i++;

  }

lcd_putc('0' + i);              // Zehnerstelle

i = 0;

while (j > 99)

  {

  j -= 100;

  i++;

  }

lcd_putc('0' + i);              // Einerstelle

lcd_putc('.');                  // Dezimalpunkt einschmuggeln

i = 0;

while (j > 9)

  {

  j -= 10;

  i++;

  }

lcd_putc('0' + i);              // 1. Nachkommastelle

lcd_putc('0' + j);              // 2. Nachkommastelle

}

#endif

// ----------------------------------------------------------------------------

// Ausgabe einer Dezimalzahl mit Nachkommastellen ohne Systemfunktion

// hier durchgängig mit float Variable (diese Code scheint kleiner zu sein)

/*

void out_float(double f, uint8_t vorkomma)

{

register uint8_t i = 0;

double ff;

if (f < 0) 

  {

  f = 0 - f;

  lcd_putc('-');

  }

else lcd_putc('+');

if (vorkomma > 2)

  {

  ff = 99.9999;

  while (f > ff)

    {

    f -= 100;

    i++;

    }

  lcd_putc('0' + i);            // Hunderterstelle

  }

i = 0; 

ff = 9.9999;

while (f > ff)

  {

  f -= 10;

  i++;

  }

lcd_putc('0' + i);              // Zehnerstelle

i = 0;

ff = 0.9999;

while (f > ff)

  {

  f -= 1;

  i++;

  }

lcd_putc('0' + i);              // Einerstelle

lcd_putc('.');

i = 0;

ff = 0.09999;

while (f > ff)            

  {

  f -= 0.1;

  i++;

  }

lcd_putc('0' + i);              // 1. Dezimalstelle

i = 0;                      // ohne 2. Dez. können 50 Byte eingespart werden

ff = 0.00999;

while (f > ff)

  {

  f -= 0.01;

  i++;

  }

lcd_putc('0' + i);              // 2. Dezimalstelle

}

*/

/*

// ----------------------------------------------------------------------------

// Ausgabe einer Dezimalzahl mit Nachkommastellen ohne Systemfunktion

// hier über uint16_t und Multiplikation mit 100 für 2 Nachkommastellen

void out_float(double f, uint8_t vorkomma)

{

uint16_t j;

uint8_t i;

if (f < 0) 

  {

  f = 0 - f;

  lcd_putc('-');

  }

else lcd_putc('+');

j = (uint16_t) (f * 100);

if (vorkomma > 2)

  {

  i = 0;

  while (j > 9999)

    {

    j -= 10000;

    i++;

    }

  lcd_putc('0' + i);            // Hunderterstelle

  }

i = 0;

while (j > 999)

  {

  j -= 1000;

  i++;

  }

lcd_putc('0' + i);              // Zehnerstelle

i = 0;

while (j > 99)

  {

  j -= 100;

  i++;

  }

lcd_putc('0' + i);              // Einerstelle

lcd_putc('.');                  // Dezimalpunkt

i = 0;

while (j > 9)

  {

  j -= 10;

  i++;

  }

lcd_putc('0' + i);              // 1. Nachkommastelle

lcd_putc('0' + j);              // 2. Nachkommastelle

}

*/

#endif

// --- [ eof ] ----------------------------------------------------------------