0,0 → 1,657 |
|
/****************************************************************/ |
/* */ |
/* NG-Video 5,8GHz */ |
/* */ |
/* Copyright (C) 2011 - gebad */ |
/* */ |
/* This code is distributed under the GNU Public License */ |
/* which can be found at http://www.gnu.org/licenses/gpl.txt */ |
/* */ |
/****************************************************************/ |
|
#include <avr/io.h> |
#include <stdlib.h> |
#include <avr/interrupt.h> |
#include <avr/eeprom.h> |
#include <util/delay.h> |
|
#include "config.h" |
#include "dogm.h" |
#include "messages.h" |
#include "ngvideo.h" |
#include "menue.h" |
#include "servo.h" |
#include "tracking.c" |
|
|
/************************************************************************************/ |
/* initialisiert den EEPROM mit default Werten, bzw. liest EEPROM gespeicherte */ |
/* Werte in gloabale Variablen. */ |
/* Parameter: */ |
/* uint8_t ep_reset :0 = zwangsweises Rückstetzen auf default-Werte */ |
/* */ |
/************************************************************************************/ |
void Init_EEPROM(uint8_t ep_reset) |
{ char ver[sizeof(VERSION)]; |
uint8_t eep_init; |
|
eep_init = eeprom_read_byte(&ep_eep_init); |
eeprom_read_block(&ver, &ep_version, sizeof(VERSION)); |
_delay_ms(1); |
|
if ((eep_init != EEP_INITB) || (ep_reset == 0) || strcmp(VERSION, ver)) |
{ |
// nur bei Erstinitialisierung DOGM auf default 3,3V setzen |
if ((eep_init != EEP_INITB) || strcmp(VERSION, ver)){ |
eeprom_write_byte(&ep_eep_init, EEP_INITB); |
eeprom_write_byte(&ep_dogm_vers, DOGM3V); |
eeprom_write_byte(&ep_contrast, CONTRAST3V); |
eeprom_write_block(&VERSION, &ep_version, sizeof(VERSION)); |
} |
eeprom_write_byte(&ep_light_time, BACKGR_LIGHT_MAX); |
eeprom_write_byte(&ep_u_offset, U_OFFSET); |
eeprom_write_dword(&ep_u_min, U_MIN); |
eeprom_write_byte(&ep_channel, CHANNEL); |
eeprom_write_byte(&ep_av_source, AV_SOURCE); |
eeprom_write_byte(&ep_language, NO_LANGUAGE); |
eeprom_write_word(&ep_udbm_min, UDBM_MIN); |
eeprom_write_word(&ep_udbm_max, UDBM_MAX); |
eeprom_write_word(&ep_udbm_korr_1, UDBM_KORR_FA); |
eeprom_write_word(&ep_udbm_korr_2, UDBM_KORR_FA); |
eeprom_write_byte(&ep_sIdxSteps, STEPS_255); |
eeprom_write_block(&servo[0],&ep_servo[0],sizeof(servo_t)); |
eeprom_write_block(&servo[1],&ep_servo[1],sizeof(servo_t)); |
eeprom_write_byte(&ep_tracking, TRACKING_MIN); |
eeprom_write_byte(&ep_track_hyst, TRACKING_HYSTERESE); |
eeprom_write_byte(&ep_track_tx, 0); |
eeprom_write_byte(&ep_baudrate, BAUDRATE); |
sIdxSteps = STEPS_255; |
} |
else |
{ |
light_time = eeprom_read_byte(&ep_light_time); |
u_offset = eeprom_read_byte(&ep_u_offset); |
u_min = eeprom_read_dword(&ep_u_min); |
channel = eeprom_read_byte(&ep_channel); |
av_source = eeprom_read_byte(&ep_av_source); |
language = eeprom_read_byte(&ep_language); |
udbm_min = eeprom_read_word(&ep_udbm_min); |
udbm_max = eeprom_read_word(&ep_udbm_max); |
udbm_korr_1 = eeprom_read_word(&ep_udbm_korr_1); |
udbm_korr_2 = eeprom_read_word(&ep_udbm_korr_2); |
sIdxSteps = eeprom_read_byte(&ep_sIdxSteps); |
eeprom_read_block(&servo[0],&ep_servo[0],sizeof(servo_t)); |
eeprom_read_block(&servo[1],&ep_servo[1],sizeof(servo_t)); |
tracking = eeprom_read_byte(&ep_tracking); |
track_hyst = eeprom_read_byte(&ep_track_hyst); |
track_tx = eeprom_read_byte(&ep_track_tx); |
baudrate = eeprom_read_byte(&ep_baudrate); |
} |
dogm_vers = eeprom_read_byte(&ep_dogm_vers); |
contrast = eeprom_read_byte(&ep_contrast); |
hyst_u_min = u_min; |
RSSI_Calc_UdBm(pudbm); // Vergleichstabelle für dBm-Balken berechnen |
sw_avx = av_source; |
for (uint8_t i = 0; i < SERVO_NUM_CHANNELS; i++) { |
servoSet_rev(i, servo[i].rev); |
servoSet_min(i, servo[i].min); |
servoSet_max(i, servo[i].max); |
servoSet_mid(i, servo[i].mid); |
} |
// Vorberechnung von ServoChannels[channel].duty |
servoSetDefaultPos(); // Ausgangsstellung beider Servos |
coldstart = 1; |
USART_Init_Baudrate(); |
USART_RX_Mode(tracking); |
} |
|
void servoSetDefaultPos(void) |
{ |
servoSetPosition(SERVO_PAN, ServoSteps()/2); // Ausgangsstellung SERVO_PAN |
servoSetPosition(SERVO_TILT, 0); // Ausgangsstellung SERVO_TILT |
} |
|
void USART_Init_Baudrate(void) |
{ |
if (tracking == TRACKING_MKCOCKPIT) |
USART_Init(baud[baudrate]); |
else |
USART_Init(baud[6]); //57600 |
} |
|
/************************************************************************************/ |
/* setzt Flag für 3,3V oder 5V DOGM */ |
/* Parameter: */ |
/* uint8_t dogm :Version */ |
/* */ |
/************************************************************************************/ |
void Set_DOGM_Version(void) |
{ |
if(dogm_vers == DOGM5V) { |
dogm_vers = DOGM3V; |
contrast = CONTRAST3V; |
} |
else { |
dogm_vers = DOGM5V; |
contrast = CONTRAST5V; |
} |
eeprom_write_byte(&ep_dogm_vers, dogm_vers); |
eeprom_write_byte(&ep_contrast, contrast); |
} |
|
/************************************************************************************/ |
/* setzt den RX-Kanal von 1 bis 7 */ |
/* Parameter: */ |
/* uint8_t channel :Kanal */ |
/* */ |
/************************************************************************************/ |
void Set_Channel(uint8_t channel) |
{ uint8_t tmp; |
|
channel--; |
tmp = channel & 0b00000111; // Kanal 1 bis 7 Werte 0 bis 6 setzen |
PORTA |= tmp; |
PORTB |= tmp; |
tmp = channel | 0b11111000; |
PORTA &= tmp; |
PORTB &= tmp; |
} |
|
/************************************************************************************/ |
/* schaltet den MUX auf AV1 oder AV2 ohne Darstellung und en-/disabled Interrupt */ |
/* wird nur in main.c (Initialisierung) und Menü Sourceumschaltung eingesetzt */ |
/* deswegen cli() und sei() nur in Menu_AV_Source(void) */ |
/* Parameter: */ |
/* uint8_t src :0-AV1, 1-AV2 */ |
/* */ |
/************************************************************************************/ |
uint8_t Set_AV_Source(uint8_t src) |
{ |
switch(src) { |
case AV1: CLEAR_INT10; // Interrupt für Sync ausschalten |
SET_MUX_0; |
break; |
case AV2: CLEAR_INT10; // Interrupt für Sync ausschalten |
SET_MUX_1; |
break; |
case DIVERSITY: SET_INT10; // External Interrupt Mask Register ein |
SET_MUX_0; |
break; |
} |
return(src); |
} |
|
|
/**************************************************************/ |
/* */ |
/* LCD-Backlight */ |
/* */ |
/**************************************************************/ |
|
void lcdSet_BackgrLight_Off(void) |
{ |
backgr_light = OFF; |
lcdBacklightOff(); |
} |
|
void lcd_BackgrLight_On(void) |
{ // ...&& (light_count < light_time)) ==> sonst wird Beleuchtung laufend wieder eingeschaltet |
if ((backgr_light == OFF) && (light_time > BACKGR_LIGHT_MIN) && (light_count < light_time)) { |
cli(); |
light_count = 0; |
sei(); |
backgr_light = ON; |
lcdBacklightOn(); |
} |
} |
|
void lcd_BackgrLight(void) |
{ |
if (backgr_light == ON) { // nur wenn Beleuchtung an |
if (light_time == BACKGR_LIGHT_MIN) // Hintergrundbeleuchtung immer aus? |
lcdSet_BackgrLight_Off(); |
else |
if (light_time < BACKGR_LIGHT_MAX) { // Hintergrundbeleuchtung immer an? |
cli(); |
light_count++; |
sei(); |
if (light_count >= light_time) lcdSet_BackgrLight_Off(); |
} |
} |
} |
|
/**************************************************************/ |
/* */ |
/* ADC */ |
/* */ |
/* http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial */ |
/* */ |
/**************************************************************/ |
|
void ADC_Init(void) |
{ |
uint16_t result; |
|
ADMUX = (0<<REFS1) | (1<<REFS0); // AVcc als Referenz benutzen, da an AREF 4,8 V |
ADCSRA = (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0); // Frequenzvorteiler Prescaler 128 |
ADCSRA |= (1<<ADEN); // ADC aktivieren |
|
/* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest |
also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */ |
|
ADCSRA |= (1<<ADSC); // eine ADC-Wandlung |
while (ADCSRA & (1<<ADSC) ) {} // auf Abschluss der Konvertierung warten |
/* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten |
Wandlung nicht übernommen. */ |
result = ADCW; |
} |
|
/* ADC Einzelmessung */ |
uint16_t ADC_Read( uint8_t channel ) |
{ |
// Kanal waehlen, ohne andere Bits zu beeinflußen |
ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F); |
ADCSRA |= (1<<ADSC); // eine Wandlung "single conversion" |
while (ADCSRA & (1<<ADSC) ) {} // auf Abschluss der Konvertierung warten |
return ADCW; // ADC auslesen und zurückgeben |
} |
|
/* ADC Mehrfachmessung mit Mittelwertbbildung */ |
uint16_t ADC_Read_Avg( uint8_t channel, uint16_t average ) |
{ |
uint32_t result = 0; |
|
for (uint16_t i = 0; i < average; ++i ){ |
result += ADC_Read( channel ); |
_delay_ms(1); |
} |
return (uint16_t)( result / average ); |
} |
|
|
/**************************************************************/ |
/* */ |
/* Beeper */ |
/* */ |
/**************************************************************/ |
|
void Beep(uint8_t time) |
{ |
PINB |= (1<<BEEPER); |
PINB &= ~(1<<BEEPER); |
_delay_ms(time); |
PINB |= (1<<BEEPER); |
PINB &= ~(1<<BEEPER); |
} |
|
void Double_Beep(uint8_t time, uint8_t pause) |
{ |
Beep(time); |
_delay_ms(pause); |
Beep(time); |
} |
|
/**************************************************************/ |
/* */ |
/* U-Batterie */ |
/* */ |
/**************************************************************/ |
|
void Displ_Format_U(uint32_t u, uint8_t nkst) |
{ char s[3]; |
uint16_t d1; |
int i; |
|
/* vereinfacht Variablenübergabe funktion change_value(uint32_t x), |
kein printf, double oder float |
siehe http://www.mikrocontroller.net/articles/Festkommaarithmetik */ |
//nkst für 1 bis 2 Nachkommastellen mitgeben |
d1 = u / 100 ; |
if (d1 < 10) lcdPutc(' '); |
utoa(d1 ,s ,10 ); |
lcdPuts(s); |
lcdPuts(Msg(MSG_KOMMA)); |
for ( i = 1; i >= 0; i--) // Zahl hat hier immer 2 Nachkommatellen |
{ |
s[i] = (u % 10) + '0'; // modulo für Nachkommastelle gleich als char |
u /= 10; |
} |
s[nkst] = '\0'; |
lcdPuts(s); |
} |
|
// uint32_t u, da bei Displ_Fnct[fu_index](val) der größte Wert UBat gleich 32 Bit |
void Displ_1Nk(uint32_t u) |
{ |
Displ_Format_U(u, 1); |
} |
|
void Displ_U_2Nk(uint32_t u) |
{ |
Displ_Format_U(u, 2); |
lcdPutc('V'); |
} |
|
// uint8_t beep_timer :Akku-leer-Beeper nur mit Task_0_1()-Intervalle bei Menü-Rücksprung |
uint32_t U_Messen_cmp(uint8_t beep_timer) |
{ uint32_t ubat; |
static struct |
{ uint8_t time; |
uint8_t count; |
} beep_low; |
|
|
/* ubat = ((ADC_Read(VBAT) * Vref * (R104 + R103)) /(1024 * R103)) + UD10 (UD10 ist Offset) |
Verhältniswert * 100 *8192 ( Verhältniswert = realer Korrekturwert; |
mal 100 da alle Werte 2 Nachkommastellen berücksichtigt, aber ohne gerechnet wird |
mal 8192 => ohne Bruch gerechnet aber dabei mehr Kommastellen berücksichtigt) */ |
ubat = (ADC_Read(VBAT) * (uint64_t)43504 + (uint64_t)u_offset * 8192)/ 8192; |
if ( ubat <= hyst_u_min ) |
{ |
if (bat_low != 0) { // nicht laufend Display neu schreiben |
hyst_u_min = u_min + 20; // 200mV Hysterese - beruhigt Anzeige |
lcdClear(); |
lcdPuts(Msg(MSG_ACCU_LOW)); |
bat_low = 0; |
Beep(BEEPBAT); |
// da derzeit Fkt. aller 500ms aufgerufen, mit 2 Min Abstand beginnen |
beep_low.time = BEEP_LOW_TIME; |
beep_low.count = 0; |
} |
// Akku leer, in immer kürzeren Intervallen Beep |
if ((beep_timer == 1) && (beep_low.count++ >= beep_low.time)){ |
Beep(BEEPBAT); |
if (beep_low.time > 2) |
beep_low.time /= 2; |
beep_low.count = 0; |
} |
} |
else { |
if (hyst_u_min > u_min) { // falls Anzeige von Batterie leer |
bat_low = 1; // und zurück geschaltet wird, |
hyst_u_min = u_min; // dann Main_Disp wieder darstellen |
Displ_Main_Disp(); |
} |
} |
return(ubat); |
} |
|
void Displ_VBat(void) // da u_offset globale Variable |
{ uint32_t ubat; |
|
ubat = U_Messen_cmp(ENABLE_BTIMER); |
if (bat_low != 0) { // würde sonst Anzeige Akku leer überschreiben |
lcdGotoXY(11, 0); |
Displ_1Nk(ubat); |
} |
} |
|
|
/**************************************************************/ |
/* */ |
/* RSSI */ |
/* */ |
/**************************************************************/ |
|
/* RSSI Werte Korrekturfaktor berechnen */ |
uint16_t RSSI_Calc_Korr(uint16_t u0, uint16_t u1) |
{ uint16_t u_max; |
|
// immer nur den kleineren Wert vergrößern |
if (u0 < u1) { |
udbm_korr_1 = (((uint32_t)u1 * UDBM_KORR_FA) / u0)+0.5; // nur mit Integer und 2 Nachkommastellen rechnen |
udbm_korr_2 = UDBM_KORR_FA; |
u_max = u1; |
} |
else { |
udbm_korr_2 = (((uint32_t)u0 * UDBM_KORR_FA) / u1)+0.5; // nur mit Integer und 2 Nachkommastellen rechnen |
udbm_korr_1 = UDBM_KORR_FA; |
u_max = u0; |
} |
eeprom_write_word(&ep_udbm_korr_1, udbm_korr_1); |
eeprom_write_word(&ep_udbm_korr_2, udbm_korr_2); |
return(u_max); |
} |
|
void Displ_Calibr_Aktiv(void) |
{ |
lcdClear(); |
Disp_Str_mid(Msg(MSG_CALIBRATION),0); |
Disp_Str_mid(Msg(MSG_RUNNING),1); |
} |
|
void Displ_Error_TX(uint8_t message) |
{ |
lcdClear(); |
Disp_Str_mid(Msg(MSG_ERROR),0); |
Disp_Str_mid(Msg(MSG_TX_NOT),1); |
Disp_Str_mid(Msg(message), 2); |
for ( uint8_t i=0; i<=30;i++) |
_delay_ms(100); |
} |
|
void RSSI_Min_Calibrate(uint16_t *pudbm) |
{ uint16_t u0, u1; |
|
Displ_Calibr_Aktiv(); |
u0 = ADC_Read_Avg(RSSI0, 1000); //1000 Wiederholungen mit |
u1 = ADC_Read_Avg(RSSI1, 1000); //Mittelwertbildung |
// Plausibilitätsprüfung ob Sender ausgeschaltet |
if (u0 + u1 > 500) { |
udbm_min = RSSI_Calc_Korr(u0, u1); // ist real die größere Spannung, aber der kleinere dbm Wert |
eeprom_write_word(&ep_udbm_min, udbm_min); |
Double_Beep(DBEEPWR, DBEEPWRP); |
RSSI_Calc_UdBm(pudbm); |
} |
else Displ_Error_TX(MSG_TX_OFF); |
} |
|
void RSSI_Max_Calibrate(uint16_t *pudbm) |
{ uint16_t u0, u1; |
|
Displ_Calibr_Aktiv(); |
u0 = ADC_Read_Avg(RSSI0, 1000); //1000 Wiederholungen mit |
u1 = ADC_Read_Avg(RSSI1, 1000); //Mittelwertbildung |
// Plausibilitätsprüfung ob Sender in der Nähe eingeschaltet |
if (u0 + u1 < 400) { |
udbm_max = RSSI_Calc_Korr(u0, u1); // ist real die kleinere Spannung, aber der größere dbm Wert |
eeprom_write_word(&ep_udbm_max, udbm_max); |
Double_Beep(DBEEPWR, DBEEPWRP); |
RSSI_Calc_UdBm(pudbm); |
} |
else Displ_Error_TX(MSG_TX_ON); |
} |
|
// Vergleichstabelle für RSSI-Bargraph berechnen, vermeidet laufend gleiche Berechnung |
void RSSI_Calc_UdBm(uint16_t *pudbm) |
{ uint8_t n; |
n = (udbm_min - udbm_max -3)/11; // -3 um Ende dBm Skala sicher zu erreichen |
for (uint8_t i = 0; i < 12; i++) |
pudbm[i] = (udbm_min - i * n); |
} |
|
void Displ_RSSI_Bargraph(uint16_t *pudbm, uint16_t uadc) |
{ uint8_t i; |
|
// Balken zeichnen - udbm |
for (i = 0; i < 12; i++) |
if (uadc < pudbm[i]) lcdPutc(0); else lcdPutc(' '); |
} |
|
uint8_t RSSI_Diversity(uint8_t src, uint16_t *pudbm, uint8_t visible) |
{ uint16_t u0, u1; |
static uint8_t div_flag, ret_div_flag; |
char marker; |
|
u0 = (ADC_Read(RSSI0) * (uint32_t)udbm_korr_1)/UDBM_KORR_FA; |
u1 = (ADC_Read(RSSI1) * (uint32_t)udbm_korr_2)/UDBM_KORR_FA; |
|
// falls beide RX gleich gut/schlecht synchronisieren |
// Achtung! Niedrigere Spannung - größere Feldstärke |
if (src == DIVERSITY) { |
if (u0 < u1) { |
ret_div_flag = AV1; |
if ((vscount0 == 255) && (vscount1 == 255)) SET_MUX_0; |
} |
else { |
ret_div_flag = AV2; |
if ((vscount0 == 255) && (vscount1 == 255)) SET_MUX_1; |
} |
} |
else ret_div_flag = src; // sonst leerer Returnwert |
|
if (visible) { |
if (src == DIVERSITY) { |
// Synchronisation vorrangig zur Feldstärke |
if ((vsync0 != vsync1) && ((vscount0 & vscount1) < 255)) { |
// ist nur zur Anzeige - Sync-MUX wird über Interrupt gesteuert |
if (vsync0 == 0) { |
div_flag = AV1; |
} |
else { |
div_flag = AV2; |
} |
marker = MARKER_SYNC; |
} |
else { |
div_flag = ret_div_flag; |
marker = MARKER_RSSI; |
} |
} |
else marker = MARKER_AV; |
// wäre unschön - keine RSSI-Anzeige, aber Marker springt |
if ((u0 > pudbm[0]) && (u1 > pudbm[0])) marker = ' '; |
lcdGotoXY(2, 1); |
Displ_RSSI_Bargraph(pudbm, u0); |
lcdGotoXY(2, 2); |
Displ_RSSI_Bargraph(pudbm, u1); |
if (src == DIVERSITY) Displ_AV_Mark(div_flag, marker); |
} |
return(ret_div_flag); |
} |
|
/**************************************************************/ |
/* */ |
/* Diversity v-Synchronisation Interruptroutinen */ |
/* */ |
/**************************************************************/ |
|
/* Impulszähler für V-Synchronisation 0 und 1 |
wird durch Interrupt des jewiligen vSync einzeln zurückgesetzt */ |
ISR(TIMER2_OVF_vect) |
{ |
TCNT2 = (int8_t)(int16_t)-(F_CPU / 64 * 500e-6); // preload |
if (vscount0 < 255) ++vscount0; // Überlauf von vscount vermeiden |
if (vscount1 < 255) ++vscount1; // Überlauf von vscount vermeiden |
if (rx_timeout < RX_TIME_OLD) ++rx_timeout; // veranlasst bei GPS-Tracking MK Datensatz senden |
} |
|
/* Messung von Impulsabstand v-Synchronisation 0 |
Zur Vermeidung von Bildstörunen erfolgt MUX-Umschaltung in Bildaustastung */ |
ISR(INT0_vect) |
{ |
if ((vscount0 >= 79) && (vscount0 <= 81)) |
vsync0 = 0; |
else { |
vsync0 = 1; |
if (vsync1 == 0) |
SET_MUX_1; |
} |
if (vsync0 == vsync1) { //nur wenn vSynchronisation gleich gut/schlecht ist greift RSSI |
if (sw_avx == AV1) { |
SET_MUX_0; |
} |
else |
SET_MUX_1; |
} |
vscount0 = 0; |
} |
|
/* Messung von Impulsabstand v-Synchronisation 1 |
Zur Vermeidung von Bildstörunen erfolgt MUX-Umschaltung in Bildaustastung */ |
ISR(INT1_vect) |
{ |
if ((vscount1 >= 79) && (vscount1 <= 81)) |
vsync1 = 0; |
else { |
vsync1 = 1; |
if (vsync0 == 0) |
SET_MUX_0; |
} |
if (vsync0 == vsync1) { //nur wenn vSynchronisation gleich gut/schlecht ist greift RSSI |
if (sw_avx == AV1) { |
SET_MUX_0; |
} |
else |
SET_MUX_1; |
} |
vscount1 = 0; |
} |
|
/**************************************************************/ |
/* */ |
/* Tasks */ |
/* ermöglicht unterschiedliche Zeiten f. UBat, Sync... */ |
/* */ |
/**************************************************************/ |
|
void Task_0_1(void) |
{ |
if (task_timer0_1) { |
cli(); |
task_timer0_1 = 0; |
sei(); |
Displ_VBat(); |
} |
} |
|
void Task_0_2(void) |
{ |
if (task_timer0_2) { |
cli(); |
task_timer0_2 = 0; |
sei(); |
sw_avx = RSSI_Diversity(av_source, pudbm, bat_low); |
} |
} |
|
void Task_0_3(void) |
{ |
if (task_timer0_3) { |
cli(); |
task_timer0_3 = 0; |
sei(); |
sw_avx = RSSI_Diversity(av_source, pudbm, 0); |
if (tracking == TRACKING_MKCOCKPIT) Tracking_MKCockpit(); |
} |
} |
|
void Task_0_4(void) |
{ |
if (task_timer0_4) { |
cli(); |
task_timer0_4 = 0; |
sei(); |
if (tracking == TRACKING_GPS) Tracking_GPS(); |
} |
} |
|
void Task_0_5(void) |
{ |
lcd_BackgrLight_On(); // muss bei beliebiger Taste sofort eingeschaltet werden |
if (task_timer0_5) { |
cli(); |
task_timer0_5 = 0; |
sei(); |
lcd_BackgrLight(); |
} |
} |
|
void Tasks_unvisible(void) |
{ |
Task_0_3(); |
Task_0_4(); |
Task_0_5(); |
if (tracking == TRACKING_RSSI) Tracking_RSSI(); |
} |