| /branches/salvo_gps/GPS.c |
|---|
| 0,0 → 1,211 |
| /* |
| This program (files gps.c and gps.h) is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the Free Software Foundation; |
| either version 3 of the License, or (at your option) any later version. |
| This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; |
| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. You should have received a copy of the GNU General Public License |
| along with this program. If not, see <http://www.gnu.org/licenses/>. |
| Please note: All the other files for the project "Mikrokopter" by H.Buss are under the license (license_buss.txt) published by www.mikrokopter.de |
| */ |
| /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| Peter Muehlenbrock |
| Auswertung der Daten vom GPS im ublox Format |
| Regelung fuer GPS noch nicht implementiert |
| Stand 11.9.2007 |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| */ |
| #include "main.h" |
| // Defines fuer ublox Messageformat um Auswertung zu steuern |
| #define UBLOX_IDLE 0 |
| #define UBLOX_SYNC1 1 |
| #define UBLOX_SYNC2 2 |
| #define UBLOX_CLASS 3 |
| #define UBLOX_ID 4 |
| #define UBLOX_LEN1 5 |
| #define UBLOX_LEN2 6 |
| #define UBLOX_CKA 7 |
| #define UBLOX_CKB 8 |
| #define UBLOX_PAYLOAD 9 |
| // ublox Protokoll Identifier |
| #define UBLOX_NAV_POSUTM 0x08 |
| #define UBLOX_NAV_STATUS 0x03 |
| #define UBLOX_NAV_VELED 0x12 |
| #define UBLOX_NAV_CLASS 0x01 |
| #define UBLOX_SYNCH1_CHAR 0xB5 |
| #define UBLOX_SYNCH2_CHAR 0x62 |
| signed int GPS_Nick = 0; |
| signed int GPS_Roll = 0; |
| static uint8_t ublox_msg_state = UBLOX_IDLE; |
| static uint8_t chk_a =0; //Checksum |
| static uint8_t chk_b =0; |
| static unsigned int rx_len; |
| unsigned int cnt0,cnt1,cnt2; //******Provisorisch |
| static unsigned int ptr_payload_data_end; |
| static uint8_t *ptr_payload_data; |
| static uint8_t *ptr_pac_status; |
| NAV_POSUTM_t actual_pos; // Aktuelle Nav Daten werden hier im ublox Format abgelegt |
| NAV_STATUS_t actual_status; // Aktueller Nav Status |
| NAV_VELNED_t actual_speed; // Aktueller Geschwindigkeits und Richtungsdaten |
| GPS_POSITION_t gps_act_position; // Alle wichtigen Daten zusammengefasst |
| void GPS_Neutral(void) // Initialisierung |
| { |
| ublox_msg_state = UBLOX_IDLE; |
| actual_pos.status= 0; |
| actual_speed.status= 0; |
| actual_status.status= 0; |
| } |
| void Get_GPS_data(void) // Daten aus aktuellen ublox Messages extrahieren |
| { |
| if (actual_pos.status == 0) return; //damit es schnell geht, wenn nix zu tun ist |
| if ((actual_pos.status > 0) && (actual_status.status > 0) && (actual_speed.status > 0)) |
| { |
| cnt1++; //**** noch Rausschmeissen |
| if (((actual_status.gpsfix_type & 0x03) >=2) && ((actual_status.nav_status_flag & 0x01) >=1)) // nur wenn Daten aktuell und gueltig sind |
| { |
| gps_act_position.utm_east = actual_pos.utm_east/10; |
| gps_act_position.utm_north = actual_pos.utm_north/10; |
| gps_act_position.utm_alt = actual_pos.utm_alt/10; |
| gps_act_position.speed_gnd = actual_speed.speed_gnd/10; |
| gps_act_position.speed_gnd = actual_speed.speed_gnd/10; |
| gps_act_position.heading = actual_speed.heading/100000; |
| gps_act_position.status = 1; |
| } |
| actual_pos.status = 0; |
| actual_status.status = 0; |
| actual_speed.status = 0; |
| } |
| } |
| /* |
| Daten vom GPS im ublox MSG Format auswerten |
| Die Routine wird bei jedem Empfang eines Zeichens vom GPS Modul durch den UART IRQ aufgerufen |
| // Die UBX Messages NAV_POSUTM, NAV_STATUS und NAV_VALED muessen aktiviert sein |
| */ |
| void Get_Ublox_Msg(uint8_t rx) |
| { |
| switch (ublox_msg_state) |
| { |
| case UBLOX_IDLE: // Zuerst Synchcharacters pruefen |
| if ( rx == UBLOX_SYNCH1_CHAR ) ublox_msg_state = UBLOX_SYNC1; |
| else ublox_msg_state = UBLOX_IDLE; |
| break; |
| case UBLOX_SYNC1: |
| if (rx == UBLOX_SYNCH2_CHAR) ublox_msg_state = UBLOX_SYNC2; |
| else ublox_msg_state = UBLOX_IDLE; |
| chk_a = 0,chk_b = 0; |
| break; |
| case UBLOX_SYNC2: |
| if (rx == UBLOX_NAV_CLASS) ublox_msg_state = UBLOX_CLASS; |
| else ublox_msg_state = UBLOX_IDLE; |
| break; |
| case UBLOX_CLASS: // Nur NAV Meldungen auswerten |
| switch (rx) |
| { |
| case UBLOX_NAV_POSUTM: |
| ptr_pac_status = &actual_pos.status; |
| if (*ptr_pac_status > 0) ublox_msg_state = UBLOX_IDLE; //Abbruch weil Daten noch nicht verwendet wurden |
| else |
| { |
| ptr_payload_data = &actual_pos; |
| ptr_payload_data_end = &actual_pos.status; |
| ublox_msg_state = UBLOX_LEN1; |
| } |
| break; |
| case UBLOX_NAV_STATUS: |
| ptr_pac_status = &actual_status.status; |
| if (*ptr_pac_status > 0) ublox_msg_state = UBLOX_IDLE; |
| else |
| { |
| ptr_payload_data = &actual_status; |
| ptr_payload_data_end = &actual_status.status; |
| ublox_msg_state = UBLOX_LEN1; |
| } |
| break; |
| case UBLOX_NAV_VELED: |
| ptr_pac_status = &actual_speed.status; |
| if (*ptr_pac_status > 0) ublox_msg_state = UBLOX_IDLE; |
| else |
| { |
| ptr_payload_data = &actual_speed; |
| ptr_payload_data_end = &actual_speed.status; |
| ublox_msg_state = UBLOX_LEN1; |
| } |
| break; |
| default: |
| ublox_msg_state = UBLOX_IDLE; |
| break; |
| } |
| chk_a = UBLOX_NAV_CLASS + rx; |
| chk_b = UBLOX_NAV_CLASS + chk_a; |
| break; |
| case UBLOX_LEN1: // Laenge auswerten |
| rx_len = rx; |
| chk_a += rx; |
| chk_b += chk_a; |
| ublox_msg_state = UBLOX_LEN2; |
| break; |
| case UBLOX_LEN2: // Laenge auswerten |
| rx_len = rx_len + (rx *256); // Laenge ermitteln |
| chk_a += rx; |
| chk_b += chk_a; |
| ublox_msg_state = UBLOX_PAYLOAD; |
| break; |
| case UBLOX_PAYLOAD: // jetzt Nutzdaten einlesen |
| if (rx_len > 0) |
| { |
| *ptr_payload_data = rx; |
| chk_a += rx; |
| chk_b += chk_a; |
| --rx_len; |
| if ((rx_len > 0) && (ptr_payload_data <= ptr_payload_data_end)) |
| { |
| ptr_payload_data++; |
| ublox_msg_state = UBLOX_PAYLOAD; |
| } |
| else ublox_msg_state = UBLOX_CKA; |
| } |
| else ublox_msg_state = UBLOX_IDLE; // Abbruch wegen Fehler |
| break; |
| case UBLOX_CKA: // Checksum pruefen |
| if (rx == chk_a) ublox_msg_state = UBLOX_CKB; |
| else ublox_msg_state = UBLOX_IDLE; // Abbruch wegen Fehler |
| break; |
| case UBLOX_CKB: // Checksum pruefen |
| if (rx == chk_b) *ptr_pac_status = 1; // Paket ok |
| ublox_msg_state = UBLOX_IDLE; |
| break; |
| default: |
| ublox_msg_state = UBLOX_IDLE; |
| break; |
| } |
| } |
| /branches/salvo_gps/License_buss.txt |
|---|
| 0,0 → 1,52 |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Copyright (c) 04.2007 Holger Buss |
| // + Nur für den privaten Gebrauch |
| // + www.MikroKopter.com |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation), |
| // + dass eine Nutzung (auch auszugsweise) nur für den privaten und nichtkommerziellen Gebrauch zulässig ist. |
| // + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt |
| // + bzgl. der Nutzungsbedingungen aufzunehmen. |
| // + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen, |
| // + Verkauf von Luftbildaufnahmen, usw. |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht, |
| // + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts |
| // + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de" |
| // + eindeutig als Ursprung verlinkt und genannt werden |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion |
| // + Benutzung auf eigene Gefahr |
| // + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Die Portierung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur |
| // + mit unserer Zustimmung zulässig |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Redistributions of source code (with or without modifications) must retain the above copyright notice, |
| // + this list of conditions and the following disclaimer. |
| // + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived |
| // + from this software without specific prior written permission. |
| // + * The use of this project (hardware, software, binary files, sources and documentation) is only permittet |
| // + for non-profit use (directly or indirectly) |
| // + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted |
| // + with our written permission |
| // + * If sources or documentations are redistributet, our webpage (http://www.MikroKopter.de) must be |
| // + clearly linked and named as origin |
| // + * porting to systems other than hardware from www.mikrokopter.de is not allowed |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| // + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| // + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| // + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| // + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| // + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| // + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| // + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| // + POSSIBILITY OF SUCH DAMAGE. |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| /branches/salvo_gps/Settings.h |
|---|
| --- _Settings.h (nonexistent) |
| +++ _Settings.h (revision 153) |
| @@ -0,0 +1,50 @@ |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Testmodi |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +#define MOTOR_OFF 0 |
| +#define MOTOR_TEST 0 |
| + |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Abstimmung |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +#define ACC_AMPLIFY 16 |
| +#define FAKTOR_P 1 |
| +#define FAKTOR_I 0.0001 |
| + |
| + |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Debug-Interface |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +#define SIO_DEBUG 1 // Soll der Debugger aktiviert sein? |
| +#define MIN_DEBUG_INTERVALL 250 // in diesem Intervall werden Degugdaten ohne Aufforderung gesendet |
| + |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Sender |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + #define K_NICK 0 |
| + #define K_ROLL 1 |
| + #define K_GAS 2 |
| + #define K_GIER 3 |
| + #define K_POTI1 4 |
| + #define K_POTI2 5 |
| + #define K_POTI3 6 |
| + #define K_POTI4 7 |
| +// +++++++++++++++++++++++++++++++ |
| +// + Getestete Settings: |
| +// +++++++++++++++++++++++++++++++ |
| +// Setting: Kamera |
| +// Stick_P:3 |
| +// Stick_D:0 |
| +// Gyro_P: 175 |
| +// Gyro_I: 175 |
| +// Ki_Anteil: 10 |
| +// +++++++++++++++++++++++++++++++ |
| +// + Getestete Settings: |
| +// +++++++++++++++++++++++++++++++ |
| +// Setting: Normal |
| +// Stick_P:2 |
| +// Stick_D:8 |
| +// Gyro_P: 80 |
| +// Gyro_I: 150 |
| +// Ki_Anteil: 5 |
| + |
| /branches/salvo_gps/analog.c |
|---|
| 0,0 → 1,157 |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Copyright (c) 04.2007 Holger Buss |
| // + only for non-profit use |
| // + www.MikroKopter.com |
| // + see the File "License.txt" for further Informations |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| #include "main.h" |
| volatile int Aktuell_Nick,Aktuell_Roll,Aktuell_Gier,Aktuell_ax, Aktuell_ay,Aktuell_az, UBat = 100; |
| volatile int AccumulateNick = 0, AccumulateRoll = 0, AccumulateGier = 0; |
| volatile int accumulate_AccRoll = 0,accumulate_AccNick = 0,accumulate_AccHoch = 0; |
| volatile char MessanzahlNick = 0, MessanzahlRoll = 0, MessanzahlGier = 0; |
| volatile char messanzahl_AccNick = 0, messanzahl_AccRoll = 0, messanzahl_AccHoch = 0; |
| volatile long Luftdruck = 32000; |
| volatile int StartLuftdruck; |
| volatile unsigned int MessLuftdruck = 1023; |
| unsigned char DruckOffsetSetting; |
| volatile int HoeheD = 0; |
| volatile char messanzahl_Druck; |
| volatile int tmpLuftdruck; |
| volatile unsigned int ZaehlMessungen = 0; |
| //####################################################################################### |
| // |
| void ADC_Init(void) |
| //####################################################################################### |
| { |
| ADMUX = 0;//Referenz ist extern |
| ADCSRA=(1<<ADEN)|(1<<ADSC)|(1<<ADATE)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)|(1<<ADIE); |
| //Free Running Mode, Division Factor 128, Interrupt on |
| } |
| void SucheLuftruckOffset(void) |
| { |
| unsigned int off; |
| for(off=0; off < 250;off++) |
| { |
| OCR0A = off; |
| Delay_ms(50); |
| printf("."); |
| if(MessLuftdruck < 900) break; |
| } |
| DruckOffsetSetting = off; |
| Delay_ms(200); |
| } |
| //####################################################################################### |
| // |
| SIGNAL(SIG_ADC) |
| //####################################################################################### |
| { |
| static unsigned char kanal=0,state = 0; |
| signed int wert; |
| ANALOG_OFF; |
| switch(state++) |
| { |
| case 0: |
| wert = (signed int) AdNeutralGier - ADC; |
| AccumulateGier += wert; // |
| MessanzahlGier++; |
| Mess_Integral_Gier += wert;// / 16; |
| Mess_Integral_Gier2 += wert; |
| GyroKomp_Int += wert; |
| GyroKomp_Int2 += wert; |
| kanal = 1; |
| ZaehlMessungen++; |
| break; |
| case 1: |
| wert = (signed int) ADC - AdNeutralRoll; |
| Mess_IntegralRoll += wert; |
| Mess_IntegralRoll2 += wert; |
| if(ADC < 10) wert = -700; |
| if(ADC > 1000) wert = +700; |
| AccumulateRoll += wert; |
| MessanzahlRoll++; |
| kanal = 2; |
| break; |
| case 2: |
| wert = (signed int) ADC - AdNeutralNick; |
| Mess_IntegralNick += wert; |
| Mess_IntegralNick2 += wert; |
| if(ADC < 10) wert = -700; |
| if(ADC > 1000) wert = +700; |
| AccumulateNick += wert; |
| MessanzahlNick++; |
| kanal = 4; |
| break; |
| case 3: |
| UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19) / 2; |
| kanal = 6; |
| break; |
| case 4: |
| Aktuell_ay = NeutralAccY - ADC; |
| accumulate_AccRoll += Aktuell_ay; |
| messanzahl_AccRoll++; |
| kanal = 7; |
| break; |
| case 5: |
| Aktuell_ay = ADC - NeutralAccX; |
| accumulate_AccNick += Aktuell_ay; |
| messanzahl_AccNick++; |
| kanal = 5; |
| state = 6; |
| break; |
| case 6: |
| accumulate_AccHoch = (signed int) ADC - NeutralAccZ; |
| accumulate_AccHoch += abs(Aktuell_ay) / 4 + abs(Aktuell_ax) / 4; |
| if(accumulate_AccHoch > 1) |
| { |
| if(NeutralAccZ < 800) NeutralAccZ+= 0.02; |
| } |
| else if(accumulate_AccHoch < -1) |
| { |
| if(NeutralAccZ > 600) NeutralAccZ-= 0.02; |
| } |
| messanzahl_AccHoch = 1; |
| Aktuell_az = ADC; |
| Mess_Integral_Hoch += accumulate_AccHoch; // Integrieren |
| Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen |
| // Mess_Integral_Hoch -= Mess_Integral_Hoch / 512; // dämfen |
| /* if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG) |
| { |
| kanal = 3; |
| state = 7; |
| } |
| else |
| { |
| kanal = 0; |
| state = 0; |
| }*/ |
| kanal = 3; |
| state = 7; |
| break; |
| case 7: |
| tmpLuftdruck += ADC; |
| if(++messanzahl_Druck >= 5) |
| { |
| MessLuftdruck = ADC; |
| messanzahl_Druck = 0; |
| HoeheD = (int)(StartLuftdruck - tmpLuftdruck - HoehenWert); // D-Anteil = neuerWert - AlterWert |
| Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4; |
| HoehenWert = StartLuftdruck - Luftdruck; |
| tmpLuftdruck = 0; |
| } |
| kanal = 0; |
| state = 0; |
| break; |
| default: |
| kanal = 0; |
| state = 0; |
| break; |
| } |
| ADMUX = kanal; |
| ANALOG_ON; |
| } |
| /branches/salvo_gps/analog.h |
|---|
| 0,0 → 1,23 |
| /*####################################################################################### |
| #######################################################################################*/ |
| extern volatile int UBat; |
| extern volatile int AccumulateNick, AccumulateRoll, AccumulateGier,accumulate_AccRoll,accumulate_AccNick,accumulate_AccHoch; |
| extern volatile char MessanzahlNick, MessanzahlRoll, MessanzahlGier,messanzahl_AccNick, messanzahl_AccRoll,messanzahl_AccHoch; |
| extern volatile int Aktuell_Nick,Aktuell_Roll,Aktuell_Gier,Aktuell_ax, Aktuell_ay,Aktuell_az; |
| extern volatile long Luftdruck; |
| extern volatile char messanzahl_Druck; |
| extern volatile unsigned int ZaehlMessungen; |
| extern unsigned char DruckOffsetSetting; |
| extern volatile int HoeheD; |
| extern volatile unsigned int MessLuftdruck; |
| extern volatile int StartLuftdruck; |
| extern unsigned int ReadADC(unsigned char adc_input); |
| extern void ADC_Init(void); |
| extern void SucheLuftruckOffset(void); |
| #define ANALOG_OFF ADCSRA=0 |
| #define ANALOG_ON ADCSRA=(1<<ADEN)|(1<<ADSC)|(1<<ADATE)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)|(1<<ADIE) |
| /branches/salvo_gps/eeprom.c |
|---|
| --- fc.c (nonexistent) |
| +++ fc.c (revision 153) |
| @@ -0,0 +1,974 @@ |
| +/*####################################################################################### |
| +Flight Control |
| +#######################################################################################*/ |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// + Copyright (c) 04.2007 Holger Buss |
| +// + Nur für den privaten Gebrauch |
| +// + www.MikroKopter.com |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation), |
| +// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist. |
| +// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt |
| +// + bzgl. der Nutzungsbedingungen aufzunehmen. |
| +// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen, |
| +// + Verkauf von Luftbildaufnahmen, usw. |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht, |
| +// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts |
| +// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de" |
| +// + eindeutig als Ursprung verlinkt werden |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion |
| +// + Benutzung auf eigene Gefahr |
| +// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// + Die Portierung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur |
| +// + mit unserer Zustimmung zulässig |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// + Redistributions of source code (with or without modifications) must retain the above copyright notice, |
| +// + this list of conditions and the following disclaimer. |
| +// + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived |
| +// + from this software without specific prior written permission. |
| +// + * The use of this project (hardware, software, binary files, sources and documentation) is only permittet |
| +// + for non-commercial use (directly or indirectly) |
| +// + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted |
| +// + with our written permission |
| +// + * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be |
| +// + clearly linked as origin |
| +// + * porting to systems other than hardware from www.mikrokopter.de is not allowed |
| +// + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| +// + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| +// + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| +// + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| +// + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| +// + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| +// + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| +// + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| +// + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| +// + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| +// + POSSIBILITY OF SUCH DAMAGE. |
| +// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + |
| +#include "main.h" |
| + |
| +unsigned char h,m,s; |
| +volatile unsigned char Timeout = 0; |
| +volatile int MesswertNick,MesswertRoll,MesswertGier; |
| +volatile int AdNeutralNick = 0,AdNeutralRoll = 0,AdNeutralGier = 0; |
| +volatile int Mittelwert_AccNick, Mittelwert_AccRoll,Mittelwert_AccHoch, NeutralAccX=0, NeutralAccY=0; |
| +volatile float NeutralAccZ = 0; |
| +unsigned char CosinusNickWinkel = 0, CosinusRollWinkel = 0; |
| +volatile long IntegralNick = 0,IntegralNick2 = 0; |
| +volatile long IntegralRoll = 0,IntegralRoll2 = 0; |
| +volatile long Integral_Gier = 0; |
| +volatile long Mess_IntegralNick = 0,Mess_IntegralNick2 = 0; |
| +volatile long Mess_IntegralRoll = 0,Mess_IntegralRoll2 = 0; |
| +volatile long Mess_Integral_Gier = 0,Mess_Integral_Gier2 = 0; |
| +volatile long Mess_Integral_Hoch = 0; |
| +volatile int KompassValue = 0; |
| +volatile int KompassStartwert = 0; |
| +volatile int KompassRichtung = 0; |
| +unsigned char MAX_GAS,MIN_GAS; |
| +unsigned char Notlandung = 0; |
| +unsigned char HoehenReglerAktiv = 0; |
| +static int SignalSchlecht = 0; |
| + //Salvo 2.9.2007 Ersatzkompass |
| +volatile long GyroKomp_Int,GyroKomp_Int2; |
| +volatile int GyroKomp_Inc_Grad; // Gyroincrements / Grad |
| +volatile int GyroKomp_Value; // Der ermittelte Kompasswert aus Gyro und Magnetkompass |
| +// Salvo End |
| +float GyroFaktor; |
| +float IntegralFaktor; |
| + |
| +volatile int DiffNick,DiffRoll; |
| +int Poti1 = 0, Poti2 = 0, Poti3 = 0, Poti4 = 0; |
| +volatile unsigned char Motor_Vorne,Motor_Hinten,Motor_Rechts,Motor_Links, Count; |
| +unsigned char MotorWert[5]; |
| +volatile unsigned char SenderOkay = 0; |
| +int StickNick = 0,StickRoll = 0,StickGier = 0; |
| +char MotorenEin = 0; |
| +int HoehenWert = 0; |
| +int SollHoehe = 0; |
| +int w,v; |
| + |
| +float Kp = FAKTOR_P; |
| +float Ki = FAKTOR_I; |
| + |
| +unsigned char Parameter_Luftdruck_D = 48; // Wert : 0-250 |
| +unsigned char Parameter_MaxHoehe = 251; // Wert : 0-250 |
| +unsigned char Parameter_Hoehe_P = 16; // Wert : 0-32 |
| +unsigned char Parameter_Hoehe_ACC_Wirkung = 58; // Wert : 0-250 |
| +unsigned char Parameter_KompassWirkung = 64; // Wert : 0-250 |
| +unsigned char Parameter_Gyro_P = 50; // Wert : 10-250 |
| +unsigned char Parameter_Gyro_I = 150; // Wert : 0-250 |
| +unsigned char Parameter_Gier_P = 2; // Wert : 1-20 |
| +unsigned char Parameter_I_Faktor = 10; // Wert : 1-20 |
| +unsigned char Parameter_UserParam1 = 0; |
| +unsigned char Parameter_UserParam2 = 0; |
| +unsigned char Parameter_UserParam3 = 0; |
| +unsigned char Parameter_UserParam4 = 0; |
| +unsigned char Parameter_ServoNickControl = 100; |
| +struct mk_param_struct EE_Parameter; |
| + |
| +void Piep(unsigned char Anzahl) |
| +{ |
| + while(Anzahl--) |
| + { |
| + if(MotorenEin) return; //auf keinen Fall im Flug! |
| + beeptime = 100; |
| + Delay_ms(250); |
| + } |
| +} |
| + |
| +//############################################################################ |
| +// Nullwerte ermitteln |
| +void SetNeutral(void) |
| +//############################################################################ |
| +{ |
| + unsigned int timer; |
| + NeutralAccX = 0; |
| + NeutralAccY = 0; |
| + NeutralAccZ = 0; |
| + AdNeutralNick = 0; |
| + AdNeutralRoll = 0; |
| + AdNeutralGier = 0; |
| + CalibrierMittelwert(); |
| + timer = SetDelay(5); |
| + while (!CheckDelay(timer)); |
| + CalibrierMittelwert(); |
| + if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG)) // Höhenregelung aktiviert? |
| + { |
| + if((MessLuftdruck > 950) || (MessLuftdruck < 750)) SucheLuftruckOffset(); |
| + } |
| + AdNeutralNick= abs(MesswertNick); |
| + AdNeutralRoll= abs(MesswertRoll); |
| + AdNeutralGier= abs(MesswertGier); |
| +// Salvo 1.9.2007 ACC mit festen neutralwerten ***** |
| + if (ACC_NEUTRAL_FIXED > 0) |
| + { |
| + NeutralAccX = ACC_X_NEUTRAL; |
| + NeutralAccY = ACC_Y_NEUTRAL; |
| + } |
| + else |
| + { // Automatisch bei Offsetabgleich ermitteln |
| + NeutralAccY = abs(Mittelwert_AccRoll) / ACC_AMPLIFY; |
| + NeutralAccX = abs(Mittelwert_AccNick) / ACC_AMPLIFY; |
| + } |
| + // Salvo End |
| + NeutralAccZ = Aktuell_az; |
| + Mess_IntegralNick = 0; |
| + Mess_IntegralNick2 = 0; |
| + Mess_IntegralRoll = 0; |
| + Mess_IntegralRoll2 = 0; |
| + Mess_Integral_Gier = 0; |
| + MesswertNick = 0; |
| + MesswertRoll = 0; |
| + MesswertGier = 0; |
| + StartLuftdruck = Luftdruck; |
| + HoeheD = 0; |
| + Mess_Integral_Hoch = 0; |
| + KompassStartwert = KompassValue; |
| + GPS_Neutral(); |
| + beeptime = 50; |
| +//Salvo 2.9.2007 Ersatzkompass |
| + GyroKomp_Int = 0; |
| + GyroKomp_Int2 = 0; |
| + GyroKomp_Inc_Grad = GYROKOMP_INC_GRAD_DEFAULT; |
| +// Salvo End |
| +} |
| + |
| +//############################################################################ |
| +// Bildet den Mittelwert aus den Messwerten |
| +void Mittelwert(void) |
| +//############################################################################ |
| +{ |
| + // ADC auschalten, damit die Werte sich nicht während der Berechnung ändern |
| + ANALOG_OFF; |
| + if(MessanzahlNick) (MesswertNick = AccumulateNick / MessanzahlNick); |
| + if(MessanzahlRoll) (MesswertRoll = AccumulateRoll / MessanzahlRoll); |
| + if(MessanzahlGier) (MesswertGier = AccumulateGier / MessanzahlGier); |
| + if(messanzahl_AccNick) Mittelwert_AccNick = ((long)Mittelwert_AccNick * 7 + ((ACC_AMPLIFY * (long)accumulate_AccNick) / messanzahl_AccNick)) / 8L; |
| + if(messanzahl_AccRoll) Mittelwert_AccRoll = ((long)Mittelwert_AccRoll * 7 + ((ACC_AMPLIFY * (long)accumulate_AccRoll) / messanzahl_AccRoll)) / 8L; |
| + if(messanzahl_AccHoch) Mittelwert_AccHoch = ((long)Mittelwert_AccHoch * 7 + ((long)accumulate_AccHoch) / messanzahl_AccHoch) / 8L; |
| + AccumulateNick = 0; MessanzahlNick = 0; |
| + AccumulateRoll = 0; MessanzahlRoll = 0; |
| + AccumulateGier = 0; MessanzahlGier = 0; |
| + accumulate_AccRoll = 0;messanzahl_AccRoll = 0; |
| + accumulate_AccNick = 0;messanzahl_AccNick = 0; |
| + accumulate_AccHoch = 0;messanzahl_AccHoch = 0; |
| + Integral_Gier = Mess_Integral_Gier; |
| +// Integral_Gier2 = Mess_Integral_Gier2; |
| + IntegralNick = Mess_IntegralNick; |
| + IntegralRoll = Mess_IntegralRoll; |
| + IntegralNick2 = Mess_IntegralNick2; |
| + IntegralRoll2 = Mess_IntegralRoll2; |
| + // ADC einschalten |
| + ANALOG_ON; |
| + |
| +//------------------------------------------------------------------------------ |
| + if(MesswertNick > 200) MesswertNick += 4 * (MesswertNick - 200); |
| + else |
| + if(MesswertNick < -200) MesswertNick += 4 * (MesswertNick + 200); |
| + |
| + if(MesswertRoll > 200) MesswertRoll += 4 * (MesswertRoll - 200); |
| + else |
| + if(MesswertRoll < -200) MesswertRoll += 4 * (MesswertRoll + 200); |
| +//------------------------------------------------------------------------------ |
| + if(Poti1 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI1]] + 110) Poti1++; else if(Poti1 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI1]] + 110 && Poti1) Poti1--; |
| + if(Poti2 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI2]] + 110) Poti2++; else if(Poti2 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI2]] + 110 && Poti2) Poti2--; |
| + if(Poti3 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI3]] + 110) Poti3++; else if(Poti3 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI3]] + 110 && Poti3) Poti3--; |
| + if(Poti4 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI4]] + 110) Poti4++; else if(Poti4 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI4]] + 110 && Poti4) Poti4--; |
| + if(Poti1 < 0) Poti1 = 0; else if(Poti1 > 255) Poti1 = 255; |
| + if(Poti2 < 0) Poti2 = 0; else if(Poti2 > 255) Poti2 = 255; |
| + if(Poti3 < 0) Poti3 = 0; else if(Poti3 > 255) Poti3 = 255; |
| + if(Poti4 < 0) Poti4 = 0; else if(Poti4 > 255) Poti4 = 255; |
| +} |
| + |
| +//############################################################################ |
| +// Messwerte beim Ermitteln der Nullage |
| +void CalibrierMittelwert(void) |
| +//############################################################################ |
| +{ |
| + // ADC auschalten, damit die Werte sich nicht während der Berechnung ändern |
| + ANALOG_OFF; |
| + if(MessanzahlNick) (MesswertNick = AccumulateNick / MessanzahlNick); |
| + if(MessanzahlRoll) (MesswertRoll = AccumulateRoll / MessanzahlRoll); |
| + if(MessanzahlGier) (MesswertGier = AccumulateGier / MessanzahlGier); |
| + if(messanzahl_AccNick) Mittelwert_AccNick = ((ACC_AMPLIFY * (long)accumulate_AccNick) / messanzahl_AccNick); |
| + if(messanzahl_AccRoll) Mittelwert_AccRoll = (ACC_AMPLIFY * (long)accumulate_AccRoll) / messanzahl_AccRoll; |
| + if(messanzahl_AccHoch) Mittelwert_AccHoch = ((long)accumulate_AccHoch) / messanzahl_AccHoch; |
| + AccumulateNick = 0; MessanzahlNick = 0; |
| + AccumulateRoll = 0; MessanzahlRoll = 0; |
| + AccumulateGier = 0; MessanzahlGier = 0; |
| + accumulate_AccRoll = 0;messanzahl_AccRoll = 0; |
| + accumulate_AccNick = 0;messanzahl_AccNick = 0; |
| + accumulate_AccHoch = 0;messanzahl_AccHoch = 0; |
| + // ADC einschalten |
| + ANALOG_ON; |
| + if(Poti1 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI1]] + 110) Poti1++; else if(Poti1 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI1]] + 110 && Poti1) Poti1--; |
| + if(Poti2 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI2]] + 110) Poti2++; else if(Poti2 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI2]] + 110 && Poti2) Poti2--; |
| + if(Poti3 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI3]] + 110) Poti3++; else if(Poti3 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI3]] + 110 && Poti3) Poti3--; |
| + if(Poti4 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI4]] + 110) Poti4++; else if(Poti4 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI4]] + 110 && Poti4) Poti4--; |
| + if(Poti1 < 0) Poti1 = 0; else if(Poti1 > 255) Poti1 = 255; |
| + if(Poti2 < 0) Poti2 = 0; else if(Poti2 > 255) Poti2 = 255; |
| + if(Poti3 < 0) Poti3 = 0; else if(Poti3 > 255) Poti3 = 255; |
| + if(Poti4 < 0) Poti4 = 0; else if(Poti4 > 255) Poti4 = 255; |
| +} |
| + |
| +//############################################################################ |
| +// Senden der Motorwerte per I2C-Bus |
| +void SendMotorData(void) |
| +//############################################################################ |
| +{ |
| + if(MOTOR_OFF || !MotorenEin) |
| + { |
| + Motor_Hinten = 0; |
| + Motor_Vorne = 0; |
| + Motor_Rechts = 0; |
| + Motor_Links = 0; |
| + if(MotorTest[0]) Motor_Vorne = MotorTest[0]; |
| + if(MotorTest[1]) Motor_Hinten = MotorTest[1]; |
| + if(MotorTest[2]) Motor_Links = MotorTest[2]; |
| + if(MotorTest[3]) Motor_Rechts = MotorTest[3]; |
| + } |
| + |
| + DebugOut.Analog[12] = Motor_Vorne; |
| + DebugOut.Analog[13] = Motor_Hinten; |
| + DebugOut.Analog[14] = Motor_Links; |
| + DebugOut.Analog[15] = Motor_Rechts; |
| + |
| + //Start I2C Interrupt Mode |
| + twi_state = 0; |
| + motor = 0; |
| + i2c_start(); |
| +} |
| + |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// + Konstanten |
| +// + 0-250 -> normale Werte |
| +// + 251 -> Poti1 |
| +// + 252 -> Poti2 |
| +// + 253 -> Poti3 |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +void DefaultKonstanten1(void) |
| +{ |
| + EE_Parameter.Kanalbelegung[K_NICK] = 1; |
| + EE_Parameter.Kanalbelegung[K_ROLL] = 2; |
| + EE_Parameter.Kanalbelegung[K_GAS] = 3; |
| + EE_Parameter.Kanalbelegung[K_GIER] = 4; |
| + EE_Parameter.Kanalbelegung[K_POTI1] = 5; |
| + EE_Parameter.Kanalbelegung[K_POTI2] = 6; |
| + EE_Parameter.Kanalbelegung[K_POTI3] = 7; |
| + EE_Parameter.Kanalbelegung[K_POTI4] = 8; |
| + EE_Parameter.GlobalConfig = 0;//CFG_HOEHENREGELUNG | /*CFG_HOEHEN_SCHALTER |*/ CFG_KOMPASS_AKTIV | CFG_KOMPASS_FIX;//0x01; |
| + EE_Parameter.Hoehe_MinGas = 30; |
| + EE_Parameter.MaxHoehe = 251; // Wert : 0-32 251 -> Poti1 |
| + EE_Parameter.Hoehe_P = 10; // Wert : 0-32 |
| + EE_Parameter.Luftdruck_D = 70; // Wert : 0-250 |
| + EE_Parameter.Hoehe_ACC_Wirkung = 30; // Wert : 0-250 |
| + EE_Parameter.Hoehe_Verstaerkung = 2; // Wert : 0-50 |
| + EE_Parameter.Stick_P = 2; //2 // Wert : 1-6 |
| + EE_Parameter.Stick_D = 4; //8 // Wert : 0-64 |
| + EE_Parameter.Gier_P = 16; // Wert : 1-20 |
| + EE_Parameter.Gas_Min = 15; // Wert : 0-32 |
| + EE_Parameter.Gas_Max = 250; // Wert : 33-250 |
| + EE_Parameter.GyroAccFaktor = 26; // Wert : 1-64 |
| + EE_Parameter.KompassWirkung = 64; // Wert : 0-250 |
| + EE_Parameter.Gyro_P = 120; //80 // Wert : 0-250 |
| + EE_Parameter.Gyro_I = 150; // Wert : 0-250 |
| + EE_Parameter.UnterspannungsWarnung = 100; // Wert : 0-250 |
| + EE_Parameter.NotGas = 90; // Wert : 0-250 // Gaswert bei Empangsverlust |
| + EE_Parameter.NotGasZeit = 50; // Wert : 0-250 // Zeit bis auf NotGas geschaltet wird, wg. Rx-Problemen |
| + EE_Parameter.UfoAusrichtung = 0; // X oder + Formation |
| + EE_Parameter.I_Faktor = 5; |
| + EE_Parameter.UserParam1 = 0; //zur freien Verwendung |
| + EE_Parameter.UserParam2 = 0; //zur freien Verwendung |
| + EE_Parameter.UserParam3 = 0; //zur freien Verwendung |
| + EE_Parameter.UserParam4 = 0; //zur freien Verwendung |
| + EE_Parameter.ServoNickControl = 100; // Wert : 0-250 // Stellung des Servos |
| + EE_Parameter.ServoNickComp = 40; // Wert : 0-250 // Einfluss Gyro/Servo |
| + EE_Parameter.ServoNickCompInvert = 0; // Wert : 0-250 // Richtung Einfluss Gyro/Servo |
| + EE_Parameter.ServoNickMin = 50; // Wert : 0-250 // Anschlag |
| + EE_Parameter.ServoNickMax = 150; // Wert : 0-250 // Anschlag |
| + EE_Parameter.ServoNickRefresh = 5; |
| + memcpy(EE_Parameter.Name, "Normal\0", 12); |
| +} |
| + |
| +void DefaultKonstanten2(void) |
| +{ |
| + EE_Parameter.Kanalbelegung[K_NICK] = 1; |
| + EE_Parameter.Kanalbelegung[K_ROLL] = 2; |
| + EE_Parameter.Kanalbelegung[K_GAS] = 3; |
| + EE_Parameter.Kanalbelegung[K_GIER] = 4; |
| + EE_Parameter.Kanalbelegung[K_POTI1] = 5; |
| + EE_Parameter.Kanalbelegung[K_POTI2] = 6; |
| + EE_Parameter.Kanalbelegung[K_POTI3] = 7; |
| + EE_Parameter.GlobalConfig = 0;//CFG_HOEHENREGELUNG | /*CFG_HOEHEN_SCHALTER |*/ CFG_KOMPASS_AKTIV;//0x01; |
| + EE_Parameter.Hoehe_MinGas = 30; |
| + EE_Parameter.MaxHoehe = 251; // Wert : 0-32 251 -> Poti1 |
| + EE_Parameter.Hoehe_P = 10; // Wert : 0-32 |
| + EE_Parameter.Luftdruck_D = 50; // Wert : 0-250 |
| + EE_Parameter.Hoehe_ACC_Wirkung = 50; // Wert : 0-250 |
| + EE_Parameter.Hoehe_Verstaerkung = 2; // Wert : 0-50 |
| + EE_Parameter.Stick_P = 2; //2 // Wert : 1-6 |
| + EE_Parameter.Stick_D = 0; //8 // Wert : 0-64 |
| + EE_Parameter.Gier_P = 16; // Wert : 1-20 |
| + EE_Parameter.Gas_Min = 15; // Wert : 0-32 |
| + EE_Parameter.Gas_Max = 250; // Wert : 33-250 |
| + EE_Parameter.GyroAccFaktor = 26; // Wert : 1-64 |
| + EE_Parameter.KompassWirkung = 64; // Wert : 0-250 |
| + EE_Parameter.Gyro_P = 175; //80 // Wert : 0-250 |
| + EE_Parameter.Gyro_I = 175; // Wert : 0-250 |
| + EE_Parameter.UnterspannungsWarnung = 100; // Wert : 0-250 |
| + EE_Parameter.NotGas = 90; // Wert : 0-250 // Gaswert bei Empangsverlust |
| + EE_Parameter.NotGasZeit = 50; // Wert : 0-250 // Zeit bis auf NotGas geschaltet wird, wg. Rx-Problemen |
| + EE_Parameter.UfoAusrichtung = 0; // X oder + Formation |
| + EE_Parameter.I_Faktor = 5; |
| + EE_Parameter.UserParam1 = 0; //zur freien Verwendung |
| + EE_Parameter.UserParam2 = 0; //zur freien Verwendung |
| + EE_Parameter.UserParam3 = 0; //zur freien Verwendung |
| + EE_Parameter.UserParam4 = 0; //zur freien Verwendung |
| + EE_Parameter.UserParam3 = 0; //zur freien Verwendung |
| + EE_Parameter.UserParam4 = 0; //zur freien Verwendung |
| + EE_Parameter.ServoNickControl = 100; // Wert : 0-250 // Stellung des Servos |
| + EE_Parameter.ServoNickComp = 40; // Wert : 0-250 // Einfluss Gyro/Servo |
| + EE_Parameter.ServoNickCompInvert = 0; // Wert : 0-250 // Richtung Einfluss Gyro/Servo |
| + EE_Parameter.ServoNickMin = 50; // Wert : 0-250 // Anschlag |
| + EE_Parameter.ServoNickMax = 150; // Wert : 0-250 // Anschlag |
| + EE_Parameter.ServoNickRefresh = 5; |
| + memcpy(EE_Parameter.Name, "Kamera\0", 12); |
| +} |
| + |
| + |
| +//############################################################################ |
| +// Trägt ggf. das Poti als Parameter ein |
| +void ParameterZuordnung(void) |
| +//############################################################################ |
| +{ |
| + |
| + #define CHK_POTI(b,a,min,max) { if(a > 250) { if(a == 251) b = Poti1; else if(a == 252) b = Poti2; else if(a == 253) b = Poti3; else if(a == 254) b = Poti4;} else b = a; if(b <= min) b = min; else if(b >= max) b = max;} |
| + CHK_POTI(Parameter_MaxHoehe,EE_Parameter.MaxHoehe,0,255); |
| + CHK_POTI(Parameter_Luftdruck_D,EE_Parameter.Luftdruck_D,0,100); |
| + CHK_POTI(Parameter_Hoehe_P,EE_Parameter.Hoehe_P,0,100); |
| + CHK_POTI(Parameter_Hoehe_ACC_Wirkung,EE_Parameter.Hoehe_ACC_Wirkung,0,255); |
| + CHK_POTI(Parameter_KompassWirkung,EE_Parameter.KompassWirkung,0,255); |
| + CHK_POTI(Parameter_Gyro_P,EE_Parameter.Gyro_P,10,255); |
| + CHK_POTI(Parameter_Gyro_I,EE_Parameter.Gyro_I,0,255); |
| + CHK_POTI(Parameter_I_Faktor,EE_Parameter.I_Faktor,0,255); |
| + CHK_POTI(Parameter_UserParam1,EE_Parameter.UserParam1,0,255); |
| + CHK_POTI(Parameter_UserParam2,EE_Parameter.UserParam2,0,255); |
| + CHK_POTI(Parameter_UserParam3,EE_Parameter.UserParam3,0,255); |
| + CHK_POTI(Parameter_UserParam4,EE_Parameter.UserParam4,0,255); |
| + |
| + unsigned char ServoNickComp; // Wert : 0-250 // Einfluss Gyro/Servo |
| + unsigned char ServoNickCompInvert; // Wert : 0-250 // Richtung Einfluss Gyro/Servo |
| + unsigned char ServoNickMin; // Wert : 0-250 // Anschlag |
| + unsigned char ServoNickMax; // Wert : 0-250 // Anschlag |
| + |
| + |
| + CHK_POTI(Parameter_ServoNickControl,EE_Parameter.ServoNickControl,0,255); |
| + CHK_POTI(Parameter_ServoNickControl,EE_Parameter.ServoNickControl,0,255); |
| + CHK_POTI(Parameter_ServoNickControl,EE_Parameter.ServoNickControl,0,255); |
| + |
| + Ki = (float) Parameter_I_Faktor * 0.0001; |
| + MAX_GAS = EE_Parameter.Gas_Max; |
| + MIN_GAS = EE_Parameter.Gas_Min; |
| +} |
| + |
| + |
| +//############################################################################ |
| +// |
| +void MotorRegler(void) |
| +//############################################################################ |
| +{ |
| + int motorwert,pd_ergebnis,h,tmp_int; |
| + int GierMischanteil,GasMischanteil; |
| + static long SummeNick=0,SummeRoll=0; |
| + static long sollGier = 0,tmp_long,tmp_long2; |
| + static int IntegralFehlerNick = 0; |
| + static int IntegralFehlerRoll = 0; |
| + static unsigned int RcLostTimer; |
| + static unsigned char delay_neutral = 0; |
| + static unsigned char delay_einschalten = 0,delay_ausschalten = 0; |
| + static unsigned int modell_fliegt = 0; |
| + static int hoehenregler = 0; |
| + static char TimerWerteausgabe = 0; |
| + static char NeueKompassRichtungMerken = 0; |
| + Mittelwert(); |
| +//******PROVISORISCH*************** |
| + Get_GPS_data(); |
| + if (gps_act_position.status > 0) |
| + { |
| + ROT_ON; |
| + gps_act_position.status = 0; |
| + } |
| + |
| +//******PROVISORISCH*************** |
| + GRN_ON; |
| + |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Gaswert ermitteln |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + GasMischanteil = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] + 120; |
| + if(GasMischanteil < 0) GasMischanteil = 0; |
| + |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Emfang schlecht |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + if(SenderOkay < 100) |
| + { |
| + if(!PcZugriff) beeptime = 500; |
| + if(RcLostTimer) RcLostTimer--; |
| + else |
| + { |
| + MotorenEin = 0; |
| + Notlandung = 0; |
| + } |
| + ROT_ON; |
| + if(modell_fliegt > 2000) // wahrscheinlich in der Luft --> langsam absenken |
| + { |
| + GasMischanteil = EE_Parameter.NotGas; |
| + Notlandung = 1; |
| + PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] = 0; |
| + PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] = 0; |
| + PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] = 0; |
| +/* Poti1 = 65; |
| + Poti2 = 48; |
| + Poti3 = 0; |
| +*/ } |
| + else MotorenEin = 0; |
| + } |
| + else |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Emfang gut |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + if(SenderOkay > 140) |
| + { |
| + Notlandung = 0; |
| + RcLostTimer = EE_Parameter.NotGasZeit * 50; |
| + if(GasMischanteil > 40) |
| + { |
| + if(modell_fliegt < 0xffff) modell_fliegt++; |
| + } |
| + if((modell_fliegt < 200) || (GasMischanteil < 40)) |
| + { |
| + SummeNick = 0; |
| + SummeRoll = 0; |
| + Mess_Integral_Gier = 0; |
| + Mess_Integral_Gier2 = 0; |
| + } |
| + if((GasMischanteil > 200) && MotorenEin == 0) |
| + { |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// auf Nullwerte kalibrieren |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] > 75) // Neutralwerte |
| + { |
| + unsigned char setting; |
| + if(++delay_neutral > 200) // nicht sofort |
| + { |
| + GRN_OFF; |
| + SetNeutral(); |
| + MotorenEin = 0; |
| + delay_neutral = 0; |
| + modell_fliegt = 0; |
| + if(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > 70 || abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) > 70) |
| + { |
| + if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > 70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < 70) setting = 1; |
| + if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > 70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > 70) setting = 2; |
| + if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] < 70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > 70) setting = 3; |
| + if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] <-70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > 70) setting = 4; |
| + if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] <-70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < 70) setting = 5; |
| + eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], setting); // aktiven Datensatz merken |
| + } |
| + ReadParameterSet(GetActiveParamSetNumber(), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE); |
| + Piep(GetActiveParamSetNumber()); |
| + if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG)) // Höhenregelung aktiviert? |
| + { |
| + if((MessLuftdruck > 950) || (MessLuftdruck < 750)) SucheLuftruckOffset(); |
| + } |
| + } |
| + } |
| + else delay_neutral = 0; |
| + } |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Gas ist unten |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + if(GasMischanteil < 35) |
| + { |
| + // Starten |
| + if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] < -75) |
| + { |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Einschalten |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + if(++delay_einschalten > 200) |
| + { |
| + delay_einschalten = 200; |
| + modell_fliegt = 1; |
| + MotorenEin = 1; |
| + sollGier = 0; |
| + Mess_Integral_Gier = 0; |
| + Mess_Integral_Gier2 = 0; |
| + Mess_IntegralNick = 0; |
| + Mess_IntegralRoll = 0; |
| + Mess_IntegralNick2 = IntegralNick; |
| + Mess_IntegralRoll2 = IntegralRoll; |
| + SummeNick = 0; |
| + SummeRoll = 0; |
| + } |
| + } |
| + else delay_einschalten = 0; |
| + //Auf Neutralwerte setzen |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Auschalten |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] > 75) |
| + { |
| + if(++delay_ausschalten > 200) // nicht sofort |
| + { |
| + MotorenEin = 0; |
| + delay_ausschalten = 200; |
| + modell_fliegt = 0; |
| + } |
| + } |
| + else delay_ausschalten = 0; |
| + } |
| + } |
| + |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// neue Werte von der Funke |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + if(!NewPpmData-- || Notlandung) |
| + { |
| + ParameterZuordnung(); |
| + StickNick = PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] * EE_Parameter.Stick_P; |
| + StickNick += PPM_diff[EE_Parameter.Kanalbelegung[K_NICK]] * EE_Parameter.Stick_D; |
| + StickRoll = PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] * EE_Parameter.Stick_P; |
| + StickRoll += PPM_diff[EE_Parameter.Kanalbelegung[K_ROLL]] * EE_Parameter.Stick_D; |
| + StickGier = -PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]; |
| + |
| + GyroFaktor = ((float)Parameter_Gyro_P + 10.0) / 256.0; |
| + IntegralFaktor = ((float) Parameter_Gyro_I) / 44000; |
| + |
| + if(EE_Parameter.GlobalConfig & CFG_HEADING_HOLD) IntegralFaktor = 0; |
| + if(GyroFaktor < 0) GyroFaktor = 0; |
| + if(IntegralFaktor < 0) IntegralFaktor = 0; |
| + } |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Bei Empfangsausfall im Flug |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + if(Notlandung) |
| + { |
| + StickGier = 0; |
| + StickNick = 0; |
| + StickRoll = 0; |
| + GyroFaktor = 0.1; |
| + IntegralFaktor = 0.005; |
| + } |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Gyro-Drift kompensieren |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +#define DRIFT_FAKTOR 3 |
| + if(ZaehlMessungen >= 1000 / DRIFT_FAKTOR) |
| + { |
| +// Salvo 8.9.2007 Ersatzkompass ******* |
| + ANALOG_OFF; // ADC ausschalten, damit die Werte sich nicht während der Berechnung ändern |
| + if (GyroKomp_Int/GYROKOMP_INC_GRAD_DEFAULT >=360 ) |
| + { |
| +// GyroKomp_Int = GyroKomp_Int- (long)(GYROKOMP_INC_GRAD_DEFAULT *360); |
| + GyroKomp_Int = 0; |
| + } |
| + ANALOG_ON; // ADC einschalten |
| + ROT_OFF; |
| +// Salvo End |
| + |
| + IntegralFehlerNick = IntegralNick2 - IntegralNick; |
| + IntegralFehlerRoll = IntegralRoll2 - IntegralRoll; |
| + ZaehlMessungen = 0; |
| +// Salvo 1.9.2007 ************************* |
| +// Abgleich Roll und Nick Gyro vollsteandig nur, wenn nahezu waagrechte Lage, ansonsten abschwaechen |
| + ANALOG_OFF; // ADC ausschalten, damit die Werte sich nicht während der Berechnung ändern |
| + w = (abs(Mittelwert_AccNick)); |
| + v = (abs(Mittelwert_AccRoll)); |
| + ANALOG_ON; // ADC einschalten |
| + if ((w < ACC_WAAGRECHT_LIMIT) && (v < ACC_WAAGRECHT_LIMIT)) |
| + { |
| + if(IntegralFehlerNick > 500/DRIFT_FAKTOR) AdNeutralNick++; |
| + if(IntegralFehlerNick < -500/DRIFT_FAKTOR) AdNeutralNick--; |
| + if(IntegralFehlerRoll > 500/DRIFT_FAKTOR) AdNeutralRoll++; |
| + if(IntegralFehlerRoll < -500/DRIFT_FAKTOR) AdNeutralRoll--; |
| + } |
| + else if ((w < 2*ACC_WAAGRECHT_LIMIT) && (v < 2*ACC_WAAGRECHT_LIMIT)) // langsamer kompensieren, weil ACC Werte unsicherer sind, was die Neigung angeht |
| + { |
| + if(IntegralFehlerNick > 500*2/DRIFT_FAKTOR) AdNeutralNick++; |
| + if(IntegralFehlerNick < -500*2/DRIFT_FAKTOR) AdNeutralNick--; |
| + if(IntegralFehlerRoll > 500*2/DRIFT_FAKTOR) AdNeutralRoll++; |
| + if(IntegralFehlerRoll < -500*2/DRIFT_FAKTOR) AdNeutralRoll--; |
| + } |
| + else // noch langsamer kompensieren, weil ACC Werte unsicherer sind, was die Neigung angeht |
| + { |
| + if(IntegralFehlerNick > 500*4/DRIFT_FAKTOR) AdNeutralNick++; |
| + if(IntegralFehlerNick < -500*4/DRIFT_FAKTOR) AdNeutralNick--; |
| + if(IntegralFehlerRoll > 500*4/DRIFT_FAKTOR) AdNeutralRoll++; |
| + if(IntegralFehlerRoll < -500*4/DRIFT_FAKTOR) AdNeutralRoll--; |
| + } |
| +// Salvo End |
| + |
| +// Salvo 31.8.2007 Abgleich Giergyro nur wenn Kompass aktiv und ok ist *********************** |
| +// Ohne Kompass wird die Pseudo-Gyrodrift durch die Driftkompensation nur verschlimmert |
| +// Ohne Driftkompensation ist die Gierachse wesentlich stabiler |
| + if ((EE_Parameter.GlobalConfig & CFG_KOMPASS_AKTIV) && (!SignalSchlecht)) |
| + { |
| + if(Mess_Integral_Gier2 > 500/DRIFT_FAKTOR) AdNeutralGier--; |
| + if(Mess_Integral_Gier2 <-500/DRIFT_FAKTOR) AdNeutralGier++; |
| + } |
| + else |
| + { |
| + Mess_Integral_Gier2 = 0; |
| + } |
| +// Salvo End *********************** |
| + ANALOG_OFF; // ADC ausschalten, damit die Werte sich nicht während der Berechnung ändern |
| + Mess_IntegralNick2 = IntegralNick; |
| + Mess_IntegralRoll2 = IntegralRoll; |
| + Mess_Integral_Gier2 = Integral_Gier; |
| + ANALOG_ON; // ADC einschalten |
| + } |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Integrale auf ACC-Signal abgleichen |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + tmp_long = (long)(IntegralNick / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccNick) / 16; |
| + tmp_long2 = (long)(IntegralRoll / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccRoll) / 16; |
| +#define AUSGLEICH 500 |
| + if(tmp_long > AUSGLEICH) tmp_long = AUSGLEICH; |
| + if(tmp_long < -AUSGLEICH) tmp_long =-AUSGLEICH; |
| + if(tmp_long2 > AUSGLEICH) tmp_long2 = AUSGLEICH; |
| + if(tmp_long2 <-AUSGLEICH) tmp_long2 =-AUSGLEICH; |
| + |
| + ANALOG_OFF; // ADC ausschalten, damit die Werte sich nicht während der Berechnung ändern |
| + // Salvo 1.9.2007 Volle Korrektur nur wenn waagrechte Lage, sonst abgeschawecht ***************** |
| + w = (abs(Mittelwert_AccNick)); |
| + v = (abs(Mittelwert_AccRoll)); |
| + if ((w < ACC_WAAGRECHT_LIMIT) && (v < ACC_WAAGRECHT_LIMIT)) |
| + { |
| + Mess_IntegralNick -= tmp_long; |
| + Mess_IntegralRoll -= tmp_long2; |
| + } |
| + else if ((w < 2 * ACC_WAAGRECHT_LIMIT) && (v < 2 * ACC_WAAGRECHT_LIMIT)) |
| + { |
| + Mess_IntegralNick -= tmp_long/2; //Vorher 8 |
| + Mess_IntegralRoll -= tmp_long2/2; |
| + } |
| + else if ((w < 4 * ACC_WAAGRECHT_LIMIT) && (v < 4 * ACC_WAAGRECHT_LIMIT)) |
| + { |
| + Mess_IntegralNick -= tmp_long/4; |
| + Mess_IntegralRoll -= tmp_long2/4; |
| + } |
| + else |
| + { |
| + Mess_IntegralNick -= tmp_long/8; |
| + Mess_IntegralRoll -= tmp_long2/8; |
| + } |
| +// Salvo End *********************** |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Gieren |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + sollGier = StickGier; |
| + if(abs(StickGier) > 35) |
| + { |
| + if(!(EE_Parameter.GlobalConfig & CFG_KOMPASS_FIX)) NeueKompassRichtungMerken = 1; |
| + } |
| + tmp_int = EE_Parameter.Gier_P * (sollGier * abs(sollGier)) / 256; // expo |
| + Mess_Integral_Gier -= tmp_int; |
| + if(Mess_Integral_Gier > 30000) Mess_Integral_Gier = 30000; // begrenzen |
| + if(Mess_Integral_Gier <-30000) Mess_Integral_Gier =-30000; |
| +// Salvo Gewolltes Gieren ignorieren 30.8.2007 ********************** |
| + Mess_Integral_Gier2 -= tmp_int; |
| +// Salvo End ************************* |
| + ANALOG_ON; // ADC einschalten |
| + |
| +// Salvo Ersatzkompass 8.9.2007 ********************** |
| + if (Kompass_Neuer_Wert > 0) |
| + { |
| + w = (abs(Mittelwert_AccNick)); |
| + v = (abs(Mittelwert_AccRoll)); |
| + if ((w < ACC_WAAGRECHT_LIMIT) && (v < ACC_WAAGRECHT_LIMIT)) //Ersatzkompass nur mit Magnetkompass aktualisieren wenn alle sok |
| + { |
| + if ((abs(KompassValue - Kompass_Value_Old)) < 5) // Aufeinanderfolgende Werte duerfen nur minimal abweichen |
| + { |
| + ANALOG_OFF; // ADC ausschalten, damit die Werte sich nicht während der Berechnung ändern |
| + GyroKomp_Int = (GyroKomp_Int )/GYROKOMP_INC_GRAD_DEFAULT; |
| + w = KompassValue - GyroKomp_Int; |
| + if ((w > 0) && (w < 180)) |
| + { |
| + ++GyroKomp_Int; |
| + } |
| + else if ((w > 0) && (w >= 180)) |
| + { |
| + --GyroKomp_Int; |
| + } |
| + else if ((w < 0) && (w >= -180)) |
| + { |
| + --GyroKomp_Int; |
| + } |
| + else if ((w < 0) && (w < -180)) |
| + { |
| + ++GyroKomp_Int; |
| + } |
| + if (GyroKomp_Int < 0) GyroKomp_Int = GyroKomp_Int + 360; |
| + |
| + GyroKomp_Int = (GyroKomp_Int%360) * GYROKOMP_INC_GRAD_DEFAULT; // An Magnetkompasswert annaehern |
| + ANALOG_ON; // ADC einschalten |
| + } |
| + } |
| + Kompass_Neuer_Wert = 0; |
| + } |
| + |
| +// Salvo End ************************* |
| + |
| + |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Kompass |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + //KompassValue = 12; |
| + if(KompassValue && (EE_Parameter.GlobalConfig & CFG_KOMPASS_AKTIV)) |
| + { |
| + w = abs(IntegralNick /512); // mit zunehmender Neigung den Einfluss drosseln |
| + v = abs(IntegralRoll /512); |
| + if(v > w) w = v; // grösste Neigung ermitteln |
| + if(w < 20 && NeueKompassRichtungMerken && !SignalSchlecht) |
| + { |
| + KompassStartwert = KompassValue; |
| + NeueKompassRichtungMerken = 0; |
| + } |
| + w = (w * Parameter_KompassWirkung) / 64; // auf die Wirkung normieren |
| + w = Parameter_KompassWirkung - w; // Wirkung ggf drosseln |
| + if(w > 0) |
| + { |
| + ANALOG_OFF; // ADC ausschalten, damit die Werte sich nicht während der Berechnung ändern |
| + |
| +// Salvo 30.8.2007 Winkelbegrenzung ********************** |
| + if ((!SignalSchlecht) ) |
| + { |
| + if (abs(KompassRichtung) < 135 ) |
| + { |
| + Mess_Integral_Gier += (KompassRichtung * w) / 32; // nach Kompass ausrichten |
| + } |
| + } |
| + // Salvo End ************************* |
| + |
| + ANALOG_ON; // ADC einschalten |
| + if(SignalSchlecht) SignalSchlecht--; |
| + } |
| + else SignalSchlecht = 500; // so lange das Signal taub stellen --> ca. 1 sek |
| + } |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Debugwerte zuordnen |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +DebugOut.Sekunden++; |
| + if(!TimerWerteausgabe--) |
| + { |
| + TimerWerteausgabe = 49; |
| +// DebugOut.Analog[0] = MesswertNick; |
| +// DebugOut.Analog[1] = MesswertRoll; |
| +// DebugOut.Analog[2] = MesswertGier; |
| + DebugOut.Analog[0] = IntegralNick / EE_Parameter.GyroAccFaktor; |
| + DebugOut.Analog[1] = IntegralRoll / EE_Parameter.GyroAccFaktor; |
| + DebugOut.Analog[2] = Mittelwert_AccNick; |
| + DebugOut.Analog[3] = Mittelwert_AccRoll; |
| + DebugOut.Analog[4] = MesswertGier; |
| + DebugOut.Analog[5] = HoehenWert; |
| + DebugOut.Analog[6] = (Mess_Integral_Hoch / 512); |
| + DebugOut.Analog[7] = GasMischanteil; |
| + DebugOut.Analog[8] = KompassValue; |
| +// ******provisorisch |
| + DebugOut.Analog[9] = cnt1; |
| +// DebugOut.Analog[10] = cnt1; |
| +// DebugOut.Analog[11] = cnt2; |
| + DebugOut.Analog[10] = (gps_act_position.utm_east/10) % 10000; |
| + DebugOut.Analog[11] = (gps_act_position.utm_north/10) % 10000; |
| +// ******provisorisch |
| + |
| + /* |
| + DebugOut.Analog[9] = GyroKomp_Int/GYROKOMP_INC_GRAD_DEFAULT; |
| + DebugOut.Analog[10] = GyroKomp_Int2/GYROKOMP_INC_GRAD_DEFAULT; |
| + DebugOut.Analog[11] = GyroKomp_Inc_Grad; |
| + DebugOut.Analog[12] = GyroKomp_Value; |
| +*/ |
| +// DebugOut.Analog[9] = SollHoehe; |
| +// DebugOut.Analog[10] = Mess_Integral_Gier / 128; |
| +// DebugOut.Analog[11] = KompassStartwert; |
| +// DebugOut.Analog[10] = Parameter_Gyro_I; |
| +// DebugOut.Analog[10] = EE_Parameter.Gyro_I; |
| +// DebugOut.Analog[9] = KompassRichtung; |
| +// DebugOut.Analog[10] = GasMischanteil; |
| +// DebugOut.Analog[3] = HoeheD * 32; |
| +// DebugOut.Analog[4] = hoehenregler; |
| + } |
| + |
| + |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Drehgeschwindigkeit und -winkel zu einem Istwert zusammenfassen |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + MesswertNick = IntegralNick * IntegralFaktor + MesswertNick * GyroFaktor; |
| + MesswertRoll = IntegralRoll * IntegralFaktor + MesswertRoll * GyroFaktor; |
| + MesswertGier = MesswertGier * (GyroFaktor/2) + Integral_Gier * IntegralFaktor; |
| + |
| + // Maximalwerte abfangen |
| + #define MAX_SENSOR 2048 |
| + if(MesswertNick > MAX_SENSOR) MesswertNick = MAX_SENSOR; |
| + if(MesswertNick < -MAX_SENSOR) MesswertNick = -MAX_SENSOR; |
| + if(MesswertRoll > MAX_SENSOR) MesswertRoll = MAX_SENSOR; |
| + if(MesswertRoll < -MAX_SENSOR) MesswertRoll = -MAX_SENSOR; |
| + if(MesswertGier > MAX_SENSOR) MesswertGier = MAX_SENSOR; |
| + if(MesswertGier < -MAX_SENSOR) MesswertGier = -MAX_SENSOR; |
| + |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Höhenregelung |
| +// Die Höhenregelung schwächt lediglich das Gas ab, erhöht es allerdings nicht |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +//OCR0B = 180 - (Poti1 + 120) / 4; |
| +//DruckOffsetSetting = OCR0B; |
| + if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG)) // Höhenregelung |
| + { |
| + int tmp_int; |
| + if(EE_Parameter.GlobalConfig & CFG_HOEHEN_SCHALTER) // Regler wird über Schalter gesteuert |
| + { |
| + if(Parameter_MaxHoehe < 50) |
| + { |
| + SollHoehe = HoehenWert - 20; // Parameter_MaxHoehe ist der PPM-Wert des Schalters |
| + HoehenReglerAktiv = 0; |
| + } |
| + else |
| + HoehenReglerAktiv = 1; |
| + } |
| + else |
| + { |
| + SollHoehe = Parameter_MaxHoehe * EE_Parameter.Hoehe_Verstaerkung - 20; |
| + HoehenReglerAktiv = 1; |
| + } |
| + |
| + if(Notlandung) SollHoehe = 0; |
| + h = HoehenWert; |
| + if((h > SollHoehe) && HoehenReglerAktiv) // zu hoch --> drosseln |
| + { h = ((h - SollHoehe) * (int) Parameter_Hoehe_P) / 16; // Differenz bestimmen --> P-Anteil |
| + h = GasMischanteil - h; // vom Gas abziehen |
| + h -= (HoeheD * Parameter_Luftdruck_D)/8; // D-Anteil |
| + tmp_int = ((Mess_Integral_Hoch / 512) * (signed long) Parameter_Hoehe_ACC_Wirkung) / 32; |
| + if(tmp_int > 50) tmp_int = 50; |
| + else if(tmp_int < -50) tmp_int = -50; |
| + h -= tmp_int; |
| + hoehenregler = (hoehenregler*15 + h) / 16; |
| + if(hoehenregler < EE_Parameter.Hoehe_MinGas) // nicht unter MIN |
| + { |
| + if(GasMischanteil >= EE_Parameter.Hoehe_MinGas) hoehenregler = EE_Parameter.Hoehe_MinGas; |
| + if(GasMischanteil < EE_Parameter.Hoehe_MinGas) hoehenregler = GasMischanteil; |
| + } |
| + if(hoehenregler > GasMischanteil) hoehenregler = GasMischanteil; // nicht mehr als Gas |
| + GasMischanteil = hoehenregler; |
| + } |
| + } |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// + Mischer und PI-Regler |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Gier-Anteil |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + GierMischanteil = MesswertGier - sollGier; // Regler für Gier |
| + if(GierMischanteil > 100) GierMischanteil = 100; |
| + if(GierMischanteil < -100) GierMischanteil = -100; |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Nick-Achse |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + DiffNick = Kp * (MesswertNick - (StickNick - GPS_Nick)); // Differenz bestimmen |
| + SummeNick += DiffNick; // I-Anteil |
| + if(SummeNick > 0) SummeNick-= (abs(SummeNick)/256 + 1); else SummeNick += abs(SummeNick)/256 + 1; |
| + if(SummeNick > 16000) SummeNick = 16000; |
| + if(SummeNick < -16000) SummeNick = -16000; |
| + pd_ergebnis = DiffNick + Ki * SummeNick; // PI-Regler für Nick |
| + // Motor Vorn |
| + motorwert = GasMischanteil + pd_ergebnis + GierMischanteil; // Mischer |
| + if ((motorwert < 0) | (GasMischanteil < 10)) motorwert = 0; |
| + else if(motorwert > MAX_GAS) motorwert = MAX_GAS; |
| + if (motorwert < MIN_GAS) motorwert = MIN_GAS; |
| + Motor_Vorne = motorwert; |
| + // Motor Heck |
| + motorwert = GasMischanteil - pd_ergebnis + GierMischanteil; |
| + if ((motorwert < 0) | (GasMischanteil < 10)) motorwert = 0; |
| + else if(motorwert > MAX_GAS) motorwert = MAX_GAS; |
| + if (motorwert < MIN_GAS) motorwert = MIN_GAS; |
| + Motor_Hinten = motorwert; |
| + |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| +// Roll-Achse |
| +// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| + DiffRoll = Kp * (MesswertRoll - (StickRoll - GPS_Roll)); // Differenz bestimmen |
| + SummeRoll += DiffRoll; // I-Anteil |
| + if(SummeRoll > 0) SummeRoll-= (abs(SummeRoll)/256 + 1); else SummeRoll += abs(SummeRoll)/256 + 1; |
| + if(SummeRoll > 16000) SummeRoll = 16000; |
| + if(SummeRoll < -16000) SummeRoll = -16000; |
| + pd_ergebnis = DiffRoll + Ki * SummeRoll; // PI-Regler für Roll |
| + // Motor Links |
| + motorwert = GasMischanteil + pd_ergebnis - GierMischanteil; |
| + if ((motorwert < 0) | (GasMischanteil < 10)) motorwert = 0; |
| + else if(motorwert > MAX_GAS) motorwert = MAX_GAS; |
| + if (motorwert < MIN_GAS) motorwert = MIN_GAS; |
| + Motor_Links = motorwert; |
| + // Motor Rechts |
| + motorwert = GasMischanteil - pd_ergebnis - GierMischanteil; |
| + if ((motorwert < 0) | (GasMischanteil < 10)) motorwert = 0; |
| + else if(motorwert > MAX_GAS) motorwert = MAX_GAS; |
| + if (motorwert < MIN_GAS) motorwert = MIN_GAS; |
| + Motor_Rechts = motorwert; |
| + // +++++++++++++++++++++++++++++++++++++++++++++++ |
| + |
| +} |
| + |
| /branches/salvo_gps/fc.h |
|---|
| 0,0 → 1,126 |
| /*####################################################################################### |
| Flight Control |
| #######################################################################################*/ |
| #ifndef _FC_H |
| #define _FC_H |
| //Salvo 1.9.2007 Neutralwerte fuer ACC Sensor fest einstellen. Startausrichtung ist dann egal ! ***** |
| // Laut Datenblatt sind die Werte ueber Zeit und Temperatur sehr stabil. |
| #define ACC_NEUTRAL_FIXED 1 // wenn eins werden die neutralwerte fuer den ACC Sensor festeingestellt |
| #define ACC_X_NEUTRAL 518 // ADC Wandler Wert in Neutrallage (0g): Vom individuellen Sensor abhaengig |
| #define ACC_Y_NEUTRAL 516 // ADC Wandler wert in Neutrallage (0g) |
| #define ACC_Z_NEUTRAL 745 // ADC Wandler Wert in Neutrallage (1g) |
| #define ACC_WAAGRECHT_LIMIT 100 // Nick und Roll kleiner als dieser Wert gelten als kriterium fuer waagrechte Lage |
| // Salvo End |
| //Salvo 2.9.2007 Ersatzkompass: Gyroincrements/Grad als Defaultwert ***** |
| // Laut Datenblatt sind die Werte ueber Zeit und Temperatur sehr stabil. |
| #define GYROKOMP_INC_GRAD_DEFAULT 1250 // Gyroincrements/Grad als Defaultwert |
| // Salvo End |
| extern volatile unsigned char Timeout; |
| extern unsigned char Sekunde,Minute; |
| extern volatile long IntegralNick,IntegralNick2; |
| extern volatile long IntegralRoll,IntegralRoll2; |
| extern volatile long Mess_IntegralNick,Mess_IntegralNick2; |
| extern volatile long Mess_IntegralRoll,Mess_IntegralRoll2; |
| extern volatile long Mess_Integral_Hoch; |
| extern volatile long Integral_Gier,Mess_Integral_Gier,Mess_Integral_Gier2; |
| extern volatile int KompassValue; |
| extern volatile int KompassStartwert; |
| extern volatile int KompassRichtung; |
| extern int HoehenWert; |
| extern int SollHoehe; |
| extern volatile int MesswertNick,MesswertRoll,MesswertGier; |
| extern volatile int AdNeutralNick,AdNeutralRoll,AdNeutralGier, Mittelwert_AccNick, Mittelwert_AccRoll; |
| extern volatile int NeutralAccX, NeutralAccY,Mittelwert_AccHoch; |
| extern volatile float NeutralAccZ; |
| //Salvo 2.9.2007 Ersatzkompass |
| extern volatile long GyroKomp_Int,GyroKomp_Int2; |
| extern volatile int GyroKomp_Inc_Grad; |
| extern volatile int GyroKomp_Value; // Der ermittelte Kompasswert aus Gyro und Magnetkompass |
| // Salvo End |
| void MotorRegler(void); |
| void SendMotorData(void); |
| void CalibrierMittelwert(void); |
| void Mittelwert(void); |
| void SetNeutral(void); |
| unsigned char h,m,s; |
| volatile unsigned char Timeout ; |
| unsigned char CosinusNickWinkel, CosinusRollWinkel; |
| volatile long IntegralNick,IntegralNick2; |
| volatile long IntegralRoll,IntegralRoll2; |
| volatile long Integral_Gier; |
| volatile long Mess_IntegralNick,Mess_IntegralNick2; |
| volatile long Mess_IntegralRoll,Mess_IntegralRoll2; |
| volatile long Mess_Integral_Gier; |
| volatile int DiffNick,DiffRoll; |
| extern int Poti1, Poti2, Poti3, Poti4; |
| volatile unsigned char Motor_Vorne,Motor_Hinten,Motor_Rechts,Motor_Links, Count; |
| unsigned char MotorWert[5]; |
| volatile unsigned char SenderOkay; |
| int StickNick,StickRoll,StickGier; |
| char MotorenEin; |
| extern void DefaultKonstanten(void); |
| #define STRUCT_PARAM_LAENGE 58 |
| struct mk_param_struct |
| { |
| unsigned char Kanalbelegung[8]; // GAS[0], GIER[1],NICK[2], ROLL[3], POTI1, POTI2, POTI3 |
| unsigned char GlobalConfig; // 0x01=Höhenregler aktiv,0x02=Kompass aktiv, 0x04=GPS aktiv, 0x08=Heading Hold aktiv |
| unsigned char Hoehe_MinGas; // Wert : 0-100 |
| unsigned char Luftdruck_D; // Wert : 0-250 |
| unsigned char MaxHoehe; // Wert : 0-32 |
| unsigned char Hoehe_P; // Wert : 0-32 |
| unsigned char Hoehe_Verstaerkung; // Wert : 0-50 |
| unsigned char Hoehe_ACC_Wirkung; // Wert : 0-250 |
| unsigned char Stick_P; // Wert : 1-6 |
| unsigned char Stick_D; // Wert : 0-64 |
| unsigned char Gier_P; // Wert : 1-20 |
| unsigned char Gas_Min; // Wert : 0-32 |
| unsigned char Gas_Max; // Wert : 33-250 |
| unsigned char GyroAccFaktor; // Wert : 1-64 |
| unsigned char KompassWirkung; // Wert : 0-32 |
| unsigned char Gyro_P; // Wert : 10-250 |
| unsigned char Gyro_I; // Wert : 0-250 |
| unsigned char UnterspannungsWarnung; // Wert : 0-250 |
| unsigned char NotGas; // Wert : 0-250 //Gaswert bei Empängsverlust |
| unsigned char NotGasZeit; // Wert : 0-250 // Zeitbis auf NotGas geschaltet wird, wg. Rx-Problemen |
| unsigned char UfoAusrichtung; // X oder + Formation |
| unsigned char I_Faktor; // Wert : 0-250 |
| unsigned char UserParam1; // Wert : 0-250 |
| unsigned char UserParam2; // Wert : 0-250 |
| unsigned char UserParam3; // Wert : 0-250 |
| unsigned char UserParam4; // Wert : 0-250 |
| unsigned char ServoNickControl; // Wert : 0-250 // Stellung des Servos |
| unsigned char ServoNickComp; // Wert : 0-250 // Einfluss Gyro/Servo |
| unsigned char ServoNickMin; // Wert : 0-250 // Anschlag |
| unsigned char ServoNickMax; // Wert : 0-250 // Anschlag |
| unsigned char ServoNickRefresh; // Wert : 0-250 // Richtung Einfluss Gyro/Servo |
| unsigned char ServoNickCompInvert; // Wert : 0-250 // Richtung Einfluss Gyro/Servo |
| unsigned char Reserved[7]; |
| char Name[12]; |
| }; |
| extern struct mk_param_struct EE_Parameter; |
| extern unsigned char Parameter_Luftdruck_D; |
| extern unsigned char Parameter_MaxHoehe; |
| extern unsigned char Parameter_Hoehe_P; |
| extern unsigned char Parameter_Hoehe_ACC_Wirkung; |
| extern unsigned char Parameter_KompassWirkung; |
| extern unsigned char Parameter_Gyro_P; |
| extern unsigned char Parameter_Gyro_I; |
| extern unsigned char Parameter_Gier_P; |
| extern unsigned char Parameter_ServoNickControl; |
| #endif //_FC_H |
| /branches/salvo_gps/flight_ctrl.aps |
|---|
| 0,0 → 1,0 |
| <AVRStudio><MANAGEMENT><ProjectName>flight_ctrl</ProjectName><Created>28-Aug-2007 19:41:41</Created><LastEdit>11-Sep-2007 20:26:56</LastEdit><ICON>241</ICON><ProjectType>0</ProjectType><Created>28-Aug-2007 19:41:41</Created><Version>4</Version><Build>4, 13, 0, 528</Build><ProjectTypeName>AVR GCC</ProjectTypeName></MANAGEMENT><CODE_CREATION><ObjectFile>flight_ctrl.elf</ObjectFile><EntryFile></EntryFile><SaveFolder>C:\Mikrokopter\Flight_Crtl\svn\work\</SaveFolder></CODE_CREATION><DEBUG_TARGET><CURRENT_TARGET>AVR Simulator</CURRENT_TARGET><CURRENT_PART>ATmega644.xml</CURRENT_PART><BREAKPOINTS></BREAKPOINTS><IO_EXPAND><HIDE>false</HIDE></IO_EXPAND><REGISTERNAMES><Register>R00</Register><Register>R01</Register><Register>R02</Register><Register>R03</Register><Register>R04</Register><Register>R05</Register><Register>R06</Register><Register>R07</Register><Register>R08</Register><Register>R09</Register><Register>R10</Register><Register>R11</Register><Register>R12</Register><Register>R13</Register><Register>R14</Register><Register>R15</Register><Register>R16</Register><Register>R17</Register><Register>R18</Register><Register>R19</Register><Register>R20</Register><Register>R21</Register><Register>R22</Register><Register>R23</Register><Register>R24</Register><Register>R25</Register><Register>R26</Register><Register>R27</Register><Register>R28</Register><Register>R29</Register><Register>R30</Register><Register>R31</Register></REGISTERNAMES><COM>Auto</COM><COMType>0</COMType><WATCHNUM>0</WATCHNUM><WATCHNAMES><Pane0></Pane0><Pane1></Pane1><Pane2></Pane2><Pane3></Pane3></WATCHNAMES><BreakOnTrcaeFull>0</BreakOnTrcaeFull></DEBUG_TARGET><Debugger><modules><module></module></modules><Triggers><trigger clsid="{11A8571C-BF39-4FA7-8642-286DD19644B8}" enabled="1" variable="{"GPS.c", 44} ptr_position" condition="0" access="0" value1="0" value2="0" elements="1" hitcount="1" continue="0" customType="0" customScope="0"/></Triggers></Debugger><AVRGCCPLUGIN><FILES><SOURCEFILE>main.c</SOURCEFILE><SOURCEFILE>uart.c</SOURCEFILE><SOURCEFILE>analog.c</SOURCEFILE><SOURCEFILE>eeprom.c</SOURCEFILE><SOURCEFILE>fc.c</SOURCEFILE><SOURCEFILE>GPS.c</SOURCEFILE><SOURCEFILE>menu.c</SOURCEFILE><SOURCEFILE>printf_P.c</SOURCEFILE><SOURCEFILE>rc.c</SOURCEFILE><SOURCEFILE>timer0.c</SOURCEFILE><SOURCEFILE>twimaster.c</SOURCEFILE><SOURCEFILE>math.c</SOURCEFILE><HEADERFILE>uart.h</HEADERFILE><HEADERFILE>_Settings.h</HEADERFILE><HEADERFILE>analog.h</HEADERFILE><HEADERFILE>fc.h</HEADERFILE><HEADERFILE>gps.h</HEADERFILE><HEADERFILE>main.h</HEADERFILE><HEADERFILE>menu.h</HEADERFILE><HEADERFILE>old_macros.h</HEADERFILE><HEADERFILE>printf_P.h</HEADERFILE><HEADERFILE>rc.h</HEADERFILE><HEADERFILE>Settings.h</HEADERFILE><HEADERFILE>timer0.h</HEADERFILE><HEADERFILE>twimaster.h</HEADERFILE><HEADERFILE>math.h</HEADERFILE><OTHERFILE>makefile</OTHERFILE></FILES><CONFIGS><CONFIG><NAME>default</NAME><USESEXTERNALMAKEFILE>YES</USESEXTERNALMAKEFILE><EXTERNALMAKEFILE>makefile</EXTERNALMAKEFILE><PART>atmega644</PART><HEX>1</HEX><LIST>0</LIST><MAP>0</MAP><OUTPUTFILENAME>flight_ctrl.elf</OUTPUTFILENAME><OUTPUTDIR>default\</OUTPUTDIR><ISDIRTY>0</ISDIRTY><OPTIONS><OPTION><FILE>GPS.c</FILE><OPTIONLIST></OPTIONLIST></OPTION><OPTION><FILE>analog.c</FILE><OPTIONLIST></OPTIONLIST></OPTION><OPTION><FILE>eeprom.c</FILE><OPTIONLIST></OPTIONLIST></OPTION><OPTION><FILE>fc.c</FILE><OPTIONLIST></OPTIONLIST></OPTION><OPTION><FILE>main.c</FILE><OPTIONLIST></OPTIONLIST></OPTION><OPTION><FILE>math.c</FILE><OPTIONLIST></OPTIONLIST></OPTION><OPTION><FILE>menu.c</FILE><OPTIONLIST></OPTIONLIST></OPTION><OPTION><FILE>printf_P.c</FILE><OPTIONLIST></OPTIONLIST></OPTION><OPTION><FILE>rc.c</FILE><OPTIONLIST></OPTIONLIST></OPTION><OPTION><FILE>timer0.c</FILE><OPTIONLIST></OPTIONLIST></OPTION><OPTION><FILE>twimaster.c</FILE><OPTIONLIST></OPTIONLIST></OPTION><OPTION><FILE>uart.c</FILE><OPTIONLIST></OPTIONLIST></OPTION></OPTIONS><INCDIRS/><LIBDIRS/><LIBS/><LINKOBJECTS/><OPTIONSFORALL>-Wall -gdwarf-2 -O0 -fsigned-char</OPTIONSFORALL><LINKEROPTIONS></LINKEROPTIONS><SEGMENTS/></CONFIG></CONFIGS><LASTCONFIG>default</LASTCONFIG><USES_WINAVR>1</USES_WINAVR><GCC_LOC>C:\Programme\WinAVR-20070525\bin\avr-gcc.exe</GCC_LOC><MAKE_LOC>C:\Programme\WinAVR-20070525\utils\bin\make.exe</MAKE_LOC></AVRGCCPLUGIN><IOView><usergroups/></IOView><Files><File00000><FileId>00000</FileId><FileName>main.c</FileName><Status>1</Status></File00000><File00001><FileId>00001</FileId><FileName>fc.c</FileName><Status>1</Status></File00001><File00002><FileId>00002</FileId><FileName>fc.h</FileName><Status>1</Status></File00002><File00003><FileId>00003</FileId><FileName>timer0.c</FileName><Status>1</Status></File00003><File00004><FileId>00004</FileId><FileName>timer0.h</FileName><Status>1</Status></File00004><File00005><FileId>00005</FileId><FileName>uart.c</FileName><Status>1</Status></File00005><File00006><FileId>00006</FileId><FileName>C:\Mikrokopter\PitSchu\070812_v5.1b\GPS.c</FileName><Status>1</Status></File00006><File00007><FileId>00007</FileId><FileName>math.c</FileName><Status>1</Status></File00007><File00008><FileId>00008</FileId><FileName>analog.c</FileName><Status>1</Status></File00008><File00009><FileId>00009</FileId><FileName>menu.c</FileName><Status>1</Status></File00009><File00010><FileId>00010</FileId><FileName>main.h</FileName><Status>1</Status></File00010><File00011><FileId>00011</FileId><FileName>math.h</FileName><Status>1</Status></File00011><File00012><FileId>00012</FileId><FileName>gps.h</FileName><Status>1</Status></File00012><File00013><FileId>00013</FileId><FileName>GPS.c</FileName><Status>1</Status></File00013><File00014><FileId>00014</FileId><FileName>analog.h</FileName><Status>1</Status></File00014></Files><Workspace><File00000><Position>262 81 1402 765</Position><LineCol>89 12</LineCol><State>Maximized</State></File00000><File00001><Position>365 311 1335 745</Position><LineCol>445 0</LineCol></File00001><File00002><Position>203 101 1173 535</Position><LineCol>0 0</LineCol></File00002><File00003><Position>230 136 1200 570</Position><LineCol>144 0</LineCol></File00003><File00004><Position>257 171 1227 605</Position><LineCol>23 0</LineCol></File00004><File00005><Position>226 57 1366 741</Position><LineCol>60 0</LineCol></File00005><File00006><Position>208 45 1348 729</Position><LineCol>57 0</LineCol></File00006><File00007><Position>371 255 1341 689</Position><LineCol>18 0</LineCol></File00007><File00008><Position>202 41 1342 725</Position><LineCol>157 0</LineCol></File00008><File00009><Position>290 184 1260 618</Position><LineCol>18 0</LineCol></File00009><File00010><Position>344 220 1314 654</Position><LineCol>75 17</LineCol></File00010><File00011><Position>425 325 1395 759</Position><LineCol>9 0</LineCol></File00011><File00012><Position>263 115 1233 549</Position><LineCol>0 0</LineCol></File00012><File00013><Position>266 117 1236 551</Position><LineCol>0 0</LineCol></File00013><File00014><Position>293 152 1263 586</Position><LineCol>0 0</LineCol></File00014></Workspace><Events><Bookmarks></Bookmarks></Events><Trace><Filters></Filters></Trace></AVRStudio> |
| /branches/salvo_gps/gps.h |
|---|
| 0,0 → 1,66 |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // Peter Muehlenbrock |
| // Definitionen fuer Modul GPS |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| extern signed int GPS_Nick; |
| extern signed int GPS_Roll; |
| extern void GPS_Neutral(void); |
| extern void Get_Ublox_Msg(uint8_t rx) ; |
| extern void Get_GPS_data(void); |
| typedef struct { |
| unsigned long utm_itow; // time of week |
| long utm_east; // UTM Ost in cm |
| long utm_north; // UTM Nord in cm |
| long utm_alt; // hoehe in cm |
| uint8_t utm_zone; // |
| uint8_t utm_hem; // Hemisphere Indicator |
| uint8_t status; // 0: kein gueltiges Paket 1: alles ok |
| } NAV_POSUTM_t; |
| typedef struct { |
| unsigned long itow; // time of week |
| uint8_t gpsfix_type;// 3=3D Fix |
| uint8_t nav_status_flag; |
| uint8_t nav_diff_status; |
| uint8_t nav_resevd; |
| long nav_tff; // Time to First Fix in ms |
| long nav_msss; // ms since startup |
| uint8_t status; // 0: kein gueltiges Paket 1: alles ok |
| } NAV_STATUS_t; |
| typedef struct { |
| unsigned long itow; |
| long speed_n; // in cm/s |
| long speed_e; // in cm/s |
| long speed_alt; // in cm/s |
| unsigned long speed_3d; // in cm/s |
| unsigned long speed_gnd; // V ueber Grund in cm/s |
| long heading; // Richtung in deg/10000 |
| unsigned long sacc; // Speed Genauigkeit in cm/s |
| unsigned long cacc; // Richtungsgenauigkeit in deg |
| uint8_t status; // 0: kein gueltiges Paket 1: alles ok |
| } NAV_VELNED_t; |
| typedef struct { |
| long utm_east; // UTM Ost in 10 cm |
| long utm_north; // UTM Nord in 10 cm |
| long utm_alt; // hoehe in 10 cm |
| unsigned long speed_gnd; // V ueber Grund in 10cm/s |
| unsigned heading; // Richtung in Grad |
| uint8_t status; // 0: keine gueltigen Daten 1: alles ok |
| } GPS_POSITION_t; |
| /* |
| extern NAV_VELNED_t actual_speed; |
| extern NAV_STATUS_t actual_status; |
| extern NAV_POSUTM_t actual_position; |
| */ |
| extern GPS_POSITION_t gps_act_position; |
| extern unsigned int cnt0,cnt1,cnt2; |
| /branches/salvo_gps/main.c |
|---|
| 0,0 → 1,211 |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Copyright (c) 04.2007 Holger Buss |
| // + Nur für den privaten Gebrauch |
| // + www.MikroKopter.com |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation), |
| // + dass eine Nutzung (auch auszugsweise) nur für den privaten und nicht-kommerziellen Gebrauch zulässig ist. |
| // + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt |
| // + bzgl. der Nutzungsbedingungen aufzunehmen. |
| // + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen, |
| // + Verkauf von Luftbildaufnahmen, usw. |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht, |
| // + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts |
| // + auf anderen Webseiten oder Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de" |
| // + eindeutig als Ursprung verlinkt und genannt werden |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion |
| // + Benutzung auf eigene Gefahr |
| // + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Die Portierung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur |
| // + mit unserer Zustimmung zulässig |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Redistributions of source code (with or without modifications) must retain the above copyright notice, |
| // + this list of conditions and the following disclaimer. |
| // + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived |
| // + from this software without specific prior written permission. |
| // + * The use of this project (hardware, software, binary files, sources and documentation) is only permittet |
| // + for non-commercial use (directly or indirectly) |
| // + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted |
| // + with our written permission |
| // + * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be |
| // + clearly linked as origin |
| // + * porting to systems other than hardware from www.mikrokopter.de is not allowed |
| // + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| // + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| // + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| // + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| // + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| // + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| // + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| // + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| // + POSSIBILITY OF SUCH DAMAGE. |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| #include "main.h" |
| unsigned char EEPromArray[E2END+1] EEMEM; |
| // -- Parametersatz aus EEPROM lesen --- |
| // number [0..5] |
| void ReadParameterSet(unsigned char number, unsigned char *buffer, unsigned char length) |
| { |
| if (number > 5) number = 5; |
| eeprom_read_block(buffer, &EEPromArray[EEPROM_ADR_PARAM_BEGIN + length * number], length); |
| } |
| // -- Parametersatz ins EEPROM schreiben --- |
| // number [0..5] |
| void WriteParameterSet(unsigned char number, unsigned char *buffer, unsigned char length) |
| { |
| if (number > 5) number = 5; |
| eeprom_write_block(buffer, &EEPromArray[EEPROM_ADR_PARAM_BEGIN + length * number], length); |
| eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], number); // diesen Parametersatz als aktuell merken |
| } |
| unsigned char GetActiveParamSetNumber(void) |
| { |
| return(eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET])); |
| } |
| //############################################################################ |
| //Hauptprogramm |
| int main (void) |
| //############################################################################ |
| { |
| unsigned int timer; |
| unsigned int timer2 = 0; |
| DDRC = 0x01; // SCL |
| PORTC = 0xff; // Pullup SDA |
| DDRB = 0x1B; // LEDs und Druckoffset |
| PORTB = 0x01; // LED_Rot |
| DDRD = 0x3E; // Speaker & TXD & J3 J4 J5 |
| DDRD |=0x80; // J7 |
| PORTD = 0xF7; // LED |
| MCUSR &=~(1<<WDRF); |
| WDTCSR |= (1<<WDCE)|(1<<WDE); |
| WDTCSR = 0; |
| beeptime = 2000; |
| StickGier = 0; PPM_in[K_GAS] = 0;StickRoll = 0; StickNick = 0; |
| ROT_OFF; |
| Timer_Init(); |
| UART_Init(); |
| rc_sum_init(); |
| ADC_Init(); |
| i2c_init(); |
| sei(); |
| VersionInfo.Hauptversion = VERSION_HAUPTVERSION; |
| VersionInfo.Nebenversion = VERSION_NEBENVERSION; |
| VersionInfo.PCKompatibel = VERSION_KOMPATIBEL; |
| printf("\n\rFlightControl V%d.%d ", VERSION_HAUPTVERSION, VERSION_NEBENVERSION); |
| printf("\n\r=============================="); |
| GRN_ON; |
| if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) != 59) // seit V 0.60 |
| { |
| printf("\n\rInit. EEPROM: Generiere Default-Parameter..."); |
| DefaultKonstanten1(); |
| for (unsigned char i=0;i<6;i++) |
| { |
| if(i==2) DefaultKonstanten2(); |
| WriteParameterSet(i, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE); |
| } |
| eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], 1); |
| eeprom_write_byte(&EEPromArray[EEPROM_ADR_VALID], 59); |
| } |
| ReadParameterSet(GetActiveParamSetNumber(), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE); |
| printf("\n\rBenutze Parametersatz %d", GetActiveParamSetNumber()); |
| if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG) |
| { |
| printf("\n\rAbgleich Luftdrucksensor.."); |
| timer = SetDelay(2500); |
| SucheLuftruckOffset(); |
| while (!CheckDelay(timer)); |
| printf("OK\n\r"); |
| } |
| SetNeutral(); |
| ROT_OFF; |
| beeptime = 2000; |
| DebugIn.Analog[1] = 1000; |
| DebugIn.Digital[0] = 0x55; |
| printf("\n\rSteuerung: "); |
| if (EE_Parameter.GlobalConfig & CFG_HEADING_HOLD) printf("HeadingHold"); |
| else printf("Neutral"); |
| printf("\n\n\r"); |
| LcdClear(); |
| while (1) |
| { |
| if (UpdateMotor) // ReglerIntervall |
| { |
| UpdateMotor=0; |
| MotorRegler(); |
| SendMotorData(); |
| ROT_OFF; |
| if(PcZugriff) PcZugriff--; |
| if(SenderOkay) SenderOkay--; |
| if (UBat < EE_Parameter.UnterspannungsWarnung) |
| { |
| beeptime = 2000; |
| } |
| if(!Timeout) |
| { |
| i2c_init(); |
| } |
| else |
| { |
| ROT_OFF; |
| } |
| } |
| if(SIO_DEBUG) |
| { |
| DatenUebertragung(); |
| BearbeiteRxDaten(); |
| } |
| else BearbeiteRxDaten(); |
| if(CheckDelay(timer2)) |
| { |
| if(MotorenEin) PORTC ^= 0x10; else PORTC &= ~0x10; |
| timer = SetDelay(500); |
| } |
| } |
| return (1); |
| } |
| /branches/salvo_gps/main.h |
|---|
| 0,0 → 1,93 |
| #ifndef _MAIN_H |
| #define _MAIN_H |
| //Hier die Quarz Frequenz einstellen |
| #if defined (__AVR_ATmega32__) |
| #define SYSCLK 20000000L //Quarz Frequenz in Hz |
| #endif |
| #if defined (__AVR_ATmega644__) |
| #define SYSCLK 20000000L //Quarz Frequenz in Hz |
| //#define SYSCLK 16000000L //Quarz Frequenz in Hz |
| #endif |
| // neue Hardware |
| #define ROT_OFF PORTB &=~0x01 |
| #define ROT_ON PORTB |= 0x01 |
| #define ROT_FLASH PORTB ^= 0x01 |
| #define GRN_OFF PORTB &=~0x02 |
| #define GRN_ON PORTB |= 0x02 |
| #define GRN_FLASH PORTD ^= 0x02 |
| //#ifndef F_CPU |
| //#error ################## F_CPU nicht definiert oder ungültig ############# |
| //#endif |
| //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| //#define ANZ_MITTELWERT 4 |
| #define EEPROM_ADR_VALID 1 |
| #define EEPROM_ADR_ACTIVE_SET 2 |
| #define EEPROM_ADR_PARAM_BEGIN 100 |
| #define CFG_HOEHENREGELUNG 0x01 |
| #define CFG_HOEHEN_SCHALTER 0x02 |
| #define CFG_HEADING_HOLD 0x04 |
| #define CFG_KOMPASS_AKTIV 0x08 |
| #define CFG_KOMPASS_FIX 0x10 |
| #define CFG_GPS_AKTIV 0x20 |
| //#define SYSCLK |
| //extern unsigned long SYSCLK; |
| extern volatile int i_Nick[20],i_Roll[20],DiffNick,DiffRoll; |
| extern volatile unsigned char SenderOkay; |
| extern unsigned char CosinusNickWinkel, CosinusRollWinkel; |
| extern void ReadParameterSet (unsigned char number, unsigned char *buffer, unsigned char length); |
| extern void WriteParameterSet(unsigned char number, unsigned char *buffer, unsigned char length); |
| extern unsigned char GetActiveParamSetNumber(void); |
| extern unsigned char EEPromArray[]; |
| #include <stdlib.h> |
| #include <string.h> |
| #include <avr/io.h> |
| #include <avr/pgmspace.h> |
| #include <avr/interrupt.h> |
| #include <avr/eeprom.h> |
| #include <avr/boot.h> |
| #include <avr/wdt.h> |
| #include "old_macros.h" |
| #include "_settings.h" |
| #include "printf_P.h" |
| #include "timer0.h" |
| #include "uart.h" |
| #include "analog.h" |
| #include "twimaster.h" |
| #include "menu.h" |
| #include "rc.h" |
| #include "fc.h" |
| #include "gps.h" |
| #include "math.h" |
| #ifndef EEMEM |
| #define EEMEM __attribute__ ((section (".eeprom"))) |
| #endif |
| #define DEBUG_DISPLAY_INTERVALL 123 // in ms |
| #define DELAY_US(x) ((unsigned int)( (x) * 1e-6 * F_CPU )) |
| #endif //_MAIN_H |
| /branches/salvo_gps/makefile |
|---|
| 0,0 → 1,391 |
| #-------------------------------------------------------------------- |
| # MCU name |
| MCU = atmega644 |
| F_CPU = 20000000 |
| #------------------------------------------------------------------- |
| HAUPT_VERSION = 0 |
| NEBEN_VERSION = 06 |
| VERSION_KOMPATIBEL = 4 # PC-Kompatibilität |
| #------------------------------------------------------------------- |
| ifeq ($(MCU), atmega32) |
| # FUSE_SETTINGS= -u -U lfuse:w:0xff:m -U hfuse:w:0xcf:m |
| HEX_NAME = MEGA32 |
| endif |
| ifeq ($(MCU), atmega644) |
| FUSE_SETTINGS = -u -U lfuse:w:0xff:m -U hfuse:w:0xdf:m |
| #FUSE_SETTINGS = -U lfuse:w:0xff:m -U hfuse:w:0xdf:m |
| # -u bei neuen Controllern wieder einspielen |
| HEX_NAME = MEGA644 |
| endif |
| ifeq ($(F_CPU), 16000000) |
| QUARZ = 16MHZ |
| endif |
| ifeq ($(F_CPU), 20000000) |
| QUARZ = 20MHZ |
| endif |
| # Output format. (can be srec, ihex, binary) |
| FORMAT = ihex |
| # Target file name (without extension). |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(HAUPT_VERSION)_$(NEBEN_VERSION) |
| # Optimization level, can be [0, 1, 2, 3, s]. 0 turns off optimization. |
| # (Note: 3 is not always the best optimization level. See avr-libc FAQ.) |
| OPT = s |
| ########################################################################################################## |
| # List C source files here. (C dependencies are automatically generated.) |
| SRC = main.c uart.c printf_P.c timer0.c analog.c menu.c math.c |
| SRC += twimaster.c rc.c fc.c GPS.c |
| ########################################################################################################## |
| # List Assembler source files here. |
| # Make them always end in a capital .S. Files ending in a lowercase .s |
| # will not be considered source files but generated files (assembler |
| # output from the compiler), and will be deleted upon "make clean"! |
| # Even though the DOS/Win* filesystem matches both .s and .S the same, |
| # it will preserve the spelling of the filenames, and gcc itself does |
| # care about how the name is spelled on its command-line. |
| ASRC = |
| # List any extra directories to look for include files here. |
| # Each directory must be seperated by a space. |
| EXTRAINCDIRS = |
| # Optional compiler flags. |
| # -g: generate debugging information (for GDB, or for COFF conversion) |
| # -O*: optimization level |
| # -f...: tuning, see gcc manual and avr-libc documentation |
| # -Wall...: warning level |
| # -Wa,...: tell GCC to pass this to the assembler. |
| # -ahlms: create assembler listing |
| CFLAGS = -O$(OPT) \ |
| -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums \ |
| -Wall -Wstrict-prototypes \ |
| -Wa,-adhlns=$(<:.c=.lst) \ |
| $(patsubst %,-I%,$(EXTRAINCDIRS)) |
| # Set a "language standard" compiler flag. |
| # Unremark just one line below to set the language standard to use. |
| # gnu99 = C99 + GNU extensions. See GCC manual for more information. |
| #CFLAGS += -std=c89 |
| #CFLAGS += -std=gnu89 |
| #CFLAGS += -std=c99 |
| CFLAGS += -std=gnu99 |
| CFLAGS += -DVERSION_HAUPTVERSION=$(HAUPT_VERSION) -DVERSION_NEBENVERSION=$(NEBEN_VERSION) -DVERSION_KOMPATIBEL=$(VERSION_KOMPATIBEL) |
| # Optional assembler flags. |
| # -Wa,...: tell GCC to pass this to the assembler. |
| # -ahlms: create listing |
| # -gstabs: have the assembler create line number information; note that |
| # for use in COFF files, additional information about filenames |
| # and function names needs to be present in the assembler source |
| # files -- see avr-libc docs [FIXME: not yet described there] |
| ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs |
| # Optional linker flags. |
| # -Wl,...: tell GCC to pass this to linker. |
| # -Map: create map file |
| # --cref: add cross reference to map file |
| LDFLAGS = -Wl,-Map=$(TARGET).map,--cref |
| # Additional libraries |
| # Minimalistic printf version |
| #LDFLAGS += -Wl,-u,vfprintf -lprintf_min |
| # Floating point printf version (requires -lm below) |
| #LDFLAGS += -Wl,-u,vfprintf -lprintf_flt |
| # -lm = math library |
| LDFLAGS += -lm |
| ##LDFLAGS += -T./linkerfile/avr5.x |
| # Programming support using avrdude. Settings and variables. |
| # Programming hardware: alf avr910 avrisp bascom bsd |
| # dt006 pavr picoweb pony-stk200 sp12 stk200 stk500 |
| # |
| # Type: avrdude -c ? |
| # to get a full listing. |
| # |
| #AVRDUDE_PROGRAMMER = stk200 |
| AVRDUDE_PROGRAMMER = dt006 |
| #AVRDUDE_PROGRAMMER = ponyser |
| #falls Ponyser ausgewählt wird, muss sich unsere avrdude-Configdatei im Bin-Verzeichnis des Compilers befinden |
| #AVRDUDE_PORT = com1 # programmer connected to serial device |
| AVRDUDE_PORT = lpt1 # programmer connected to parallel port |
| #AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex |
| AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex $(FUSE_SETTINGS) |
| #AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep |
| AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER) |
| # Uncomment the following if you want avrdude's erase cycle counter. |
| # Note that this counter needs to be initialized first using -Yn, |
| # see avrdude manual. |
| #AVRDUDE_ERASE += -y |
| # Uncomment the following if you do /not/ wish a verification to be |
| # performed after programming the device. |
| AVRDUDE_FLAGS += -V |
| # Increase verbosity level. Please use this when submitting bug |
| # reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude> |
| # to submit bug reports. |
| #AVRDUDE_FLAGS += -v -v |
| # --------------------------------------------------------------------------- |
| # Define directories, if needed. |
| DIRAVR = c:/winavr |
| DIRAVRBIN = $(DIRAVR)/bin |
| DIRAVRUTILS = $(DIRAVR)/utils/bin |
| DIRINC = . |
| DIRLIB = $(DIRAVR)/avr/lib |
| # Define programs and commands. |
| SHELL = sh |
| CC = avr-gcc |
| OBJCOPY = avr-objcopy |
| OBJDUMP = avr-objdump |
| SIZE = avr-size |
| # Programming support using avrdude. |
| AVRDUDE = avrdude |
| REMOVE = rm -f |
| COPY = cp |
| HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex |
| ELFSIZE = $(SIZE) -A $(TARGET).elf |
| # Define Messages |
| # English |
| MSG_ERRORS_NONE = Errors: none |
| MSG_BEGIN = -------- begin -------- |
| MSG_END = -------- end -------- |
| MSG_SIZE_BEFORE = Size before: |
| MSG_SIZE_AFTER = Size after: |
| MSG_COFF = Converting to AVR COFF: |
| MSG_EXTENDED_COFF = Converting to AVR Extended COFF: |
| MSG_FLASH = Creating load file for Flash: |
| MSG_EEPROM = Creating load file for EEPROM: |
| MSG_EXTENDED_LISTING = Creating Extended Listing: |
| MSG_SYMBOL_TABLE = Creating Symbol Table: |
| MSG_LINKING = Linking: |
| MSG_COMPILING = Compiling: |
| MSG_ASSEMBLING = Assembling: |
| MSG_CLEANING = Cleaning project: |
| # Define all object files. |
| OBJ = $(SRC:.c=.o) $(ASRC:.S=.o) |
| # Define all listing files. |
| LST = $(ASRC:.S=.lst) $(SRC:.c=.lst) |
| # Combine all necessary flags and optional flags. |
| # Add target processor to flags. |
| #ALL_CFLAGS = -mmcu=$(MCU) -DF_CPU=$(F_CPU) -I. $(CFLAGS) |
| ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) |
| ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS) |
| # Default target. |
| all: begin gccversion sizebefore $(TARGET).elf $(TARGET).hex $(TARGET).eep \ |
| $(TARGET).lss $(TARGET).sym sizeafter finished end |
| # Eye candy. |
| # AVR Studio 3.x does not check make's exit code but relies on |
| # the following magic strings to be generated by the compile job. |
| begin: |
| @echo |
| @echo $(MSG_BEGIN) |
| finished: |
| @echo $(MSG_ERRORS_NONE) |
| end: |
| @echo $(MSG_END) |
| @echo |
| # Display size of file. |
| sizebefore: |
| @if [ -f $(TARGET).elf ]; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); echo; fi |
| sizeafter: |
| @if [ -f $(TARGET).elf ]; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); echo; fi |
| # Display compiler version information. |
| gccversion : |
| @$(CC) --version |
| # Convert ELF to COFF for use in debugging / simulating in |
| # AVR Studio or VMLAB. |
| COFFCONVERT=$(OBJCOPY) --debugging \ |
| --change-section-address .data-0x800000 \ |
| --change-section-address .bss-0x800000 \ |
| --change-section-address .noinit-0x800000 \ |
| --change-section-address .eeprom-0x810000 |
| coff: $(TARGET).elf |
| @echo |
| @echo $(MSG_COFF) $(TARGET).cof |
| $(COFFCONVERT) -O coff-avr $< $(TARGET).cof |
| extcoff: $(TARGET).elf |
| @echo |
| @echo $(MSG_EXTENDED_COFF) $(TARGET).cof |
| $(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof |
| # Program the device. |
| program: $(TARGET).hex $(TARGET).eep |
| $(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM) |
| # Create final output files (.hex, .eep) from ELF output file. |
| %.hex: %.elf |
| @echo |
| @echo $(MSG_FLASH) $@ |
| $(OBJCOPY) -O $(FORMAT) -R .eeprom $< $@ |
| %.eep: %.elf |
| @echo |
| @echo $(MSG_EEPROM) $@ |
| -$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \ |
| --change-section-lma .eeprom=0 -O $(FORMAT) $< $@ |
| # Create extended listing file from ELF output file. |
| %.lss: %.elf |
| @echo |
| @echo $(MSG_EXTENDED_LISTING) $@ |
| $(OBJDUMP) -h -S $< > $@ |
| # Create a symbol table from ELF output file. |
| %.sym: %.elf |
| @echo |
| @echo $(MSG_SYMBOL_TABLE) $@ |
| avr-nm -n $< > $@ |
| # Link: create ELF output file from object files. |
| .SECONDARY : $(TARGET).elf |
| .PRECIOUS : $(OBJ) |
| %.elf: $(OBJ) |
| @echo |
| @echo $(MSG_LINKING) $@ |
| $(CC) $(ALL_CFLAGS) $(OBJ) --output $@ $(LDFLAGS) |
| # Compile: create object files from C source files. |
| %.o : %.c |
| @echo |
| @echo $(MSG_COMPILING) $< |
| $(CC) -c $(ALL_CFLAGS) $< -o $@ |
| # Compile: create assembler files from C source files. |
| %.s : %.c |
| $(CC) -S $(ALL_CFLAGS) $< -o $@ |
| # Assemble: create object files from assembler source files. |
| %.o : %.S |
| @echo |
| @echo $(MSG_ASSEMBLING) $< |
| $(CC) -c $(ALL_ASFLAGS) $< -o $@ |
| # Target: clean project. |
| clean: begin clean_list finished end |
| clean_list : |
| @echo |
| @echo $(MSG_CLEANING) |
| # $(REMOVE) $(TARGET).hex |
| $(REMOVE) $(TARGET).eep |
| $(REMOVE) $(TARGET).obj |
| $(REMOVE) $(TARGET).cof |
| $(REMOVE) $(TARGET).elf |
| $(REMOVE) $(TARGET).map |
| $(REMOVE) $(TARGET).obj |
| $(REMOVE) $(TARGET).a90 |
| $(REMOVE) $(TARGET).sym |
| $(REMOVE) $(TARGET).lnk |
| $(REMOVE) $(TARGET).lss |
| $(REMOVE) $(OBJ) |
| $(REMOVE) $(LST) |
| $(REMOVE) $(SRC:.c=.s) |
| $(REMOVE) $(SRC:.c=.d) |
| # Automatically generate C source code dependencies. |
| # (Code originally taken from the GNU make user manual and modified |
| # (See README.txt Credits).) |
| # |
| # Note that this will work with sh (bash) and sed that is shipped with WinAVR |
| # (see the SHELL variable defined above). |
| # This may not work with other shells or other seds. |
| # |
| %.d: %.c |
| set -e; $(CC) -MM $(ALL_CFLAGS) $< \ |
| | sed 's,\(.*\)\.o[ :]*,\1.o \1.d : ,g' > $@; \ |
| [ -s $@ ] || rm -f $@ |
| # Remove the '-' if you want to see the dependency files generated. |
| -include $(SRC:.c=.d) |
| # Listing of phony targets. |
| .PHONY : all begin finish end sizebefore sizeafter gccversion coff extcoff \ |
| clean clean_list program |
| /branches/salvo_gps/math.c |
|---|
| 0,0 → 1,373 |
| /* |
| This program (files math.c and math.h) is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the Free Software Foundation; |
| either version 3 of the License, or (at your option) any later version. |
| This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; |
| without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. You should have received a copy of the GNU General Public License |
| along with this program. If not, see <http://www.gnu.org/licenses/>. |
| Please note: All the other files for the project "Mikrokopter" by H.Buss are under the license (license_buss.txt) published by www.mikrokopter.de |
| */ |
| /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| Peter Muehlenbrock |
| Winkelfunktionen sin, cos und arctan in |
| brute-force Art: Sehr Schnell, nicht sonderlich genau, aber ausreichend |
| Stand 11.9.2007 |
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| */ |
| // arctan Funktion: Eingabewert x,y Rueckgabe =arctan(x,y) in grad |
| signed int arctan_i(signed int x, signed int y) |
| { |
| short int sign = 0; |
| signed int i; |
| if (y > x) // x,y Werte vertauschen |
| { |
| sign = 1; |
| i = x; |
| x = y; |
| y = i; |
| } |
| } |
| // cosinus Funktion: Eingabewert Winkel in Grad, Rueckgabe =cos(winkel)*1000 |
| signed int cos_i(signed int winkel) |
| { |
| winkel = sin_i(90-winkel); |
| return winkel; |
| } |
| // sinus Funktion: Eingabewert Winkel in Grad, Rueckgabe =sin(winkel)*1000 |
| signed int sin_i(signed int winkel) |
| { |
| short int m; |
| winkel = winkel % 360; |
| // Quadranten auswerten |
| if ((winkel >= 90 ) && (winkel <180)) |
| { |
| winkel = 180 - winkel; |
| m = 1; |
| } |
| else if ((winkel >= 180 ) && (winkel <270)) |
| { |
| winkel = winkel - 180; |
| m = -1; |
| } |
| else if ((winkel >= 270 ) && (winkel < 360)) |
| { |
| winkel = 360 -winkel ; |
| m = -1; |
| } |
| else if ((winkel < 0) && (winkel > -90)) |
| { |
| winkel = (abs(winkel)); |
| m = -1; |
| } |
| else if ((winkel < -90) && (winkel > -180)) |
| { |
| winkel = 180-(abs(winkel)); |
| m = -1; |
| } |
| else if ((winkel < -180) && (winkel > -270)) |
| { |
| winkel = (abs(winkel))-180; |
| m = +1; |
| } |
| else if ((winkel < -270) && (winkel > -360)) |
| { |
| winkel = 360-abs(winkel); |
| m = +1; |
| } |
| else |
| { |
| m = +1; |
| } |
| //Aus Tabelle Werte holen |
| switch (winkel) |
| { |
| case 1: |
| winkel = 17; |
| break; |
| case 2: |
| winkel = 35; |
| break; |
| case 3: |
| winkel = 52; |
| break; |
| case 4: |
| winkel = 70; |
| break; |
| case 5: |
| winkel = 87; |
| break; |
| case 6: |
| winkel = 105; |
| break; |
| case 7: |
| winkel = 122; |
| break; |
| case 8: |
| winkel = 139; |
| break; |
| case 9: |
| winkel = 156; |
| break; |
| case 10: |
| winkel = 174; |
| break; |
| case 11: |
| winkel = 191; |
| break; |
| case 12: |
| winkel = 208; |
| break; |
| case 13: |
| winkel = 225; |
| break; |
| case 14: |
| winkel = 242; |
| break; |
| case 15: |
| winkel = 259; |
| break; |
| case 16: |
| winkel = 276; |
| break; |
| case 17: |
| winkel = 292; |
| break; |
| case 18: |
| winkel = 309; |
| break; |
| case 19: |
| winkel = 326; |
| break; |
| case 20: |
| winkel = 342; |
| break; |
| case 21: |
| winkel = 359; |
| break; |
| case 22: |
| winkel = 375; |
| break; |
| case 23: |
| winkel = 391; |
| break; |
| case 24: |
| winkel = 407; |
| break; |
| case 25: |
| winkel = 423; |
| break; |
| case 26: |
| winkel = 438; |
| break; |
| case 27: |
| winkel = 454; |
| break; |
| case 28: |
| winkel = 469; |
| break; |
| case 29: |
| winkel = 485; |
| break; |
| case 30: |
| winkel = 500; |
| break; |
| case 31: |
| winkel = 515; |
| break; |
| case 32: |
| winkel = 530; |
| break; |
| case 33: |
| winkel = 545; |
| break; |
| case 34: |
| winkel = 559; |
| break; |
| case 35: |
| winkel = 574; |
| break; |
| case 36: |
| winkel = 588; |
| break; |
| case 37: |
| winkel = 602; |
| break; |
| case 38: |
| winkel = 616; |
| break; |
| case 39: |
| winkel = 630; |
| break; |
| case 40: |
| winkel = 643; |
| break; |
| case 41: |
| winkel = 656; |
| break; |
| case 42: |
| winkel = 682; |
| break; |
| case 43: |
| winkel = 682; |
| break; |
| case 44: |
| winkel = 695; |
| break; |
| case 45: |
| winkel = 707; |
| break; |
| case 46: |
| winkel = 719; |
| break; |
| case 47: |
| winkel = 731; |
| case 48: |
| winkel = 743; |
| break; |
| case 49: |
| winkel = 755; |
| break; |
| case 50: |
| winkel = 766; |
| break; |
| case 51: |
| winkel = 777; |
| break; |
| case 52: |
| winkel = 788; |
| break; |
| case 53: |
| winkel = 799; |
| break; |
| case 54: |
| winkel = 809; |
| break; |
| case 55: |
| winkel = 819; |
| break; |
| case 56: |
| winkel = 829; |
| break; |
| case 57: |
| winkel = 839; |
| break; |
| case 58: |
| winkel = 848; |
| break; |
| case 59: |
| winkel = 857; |
| break; |
| case 60: |
| winkel = 866; |
| break; |
| case 61: |
| winkel = 875; |
| break; |
| case 62: |
| winkel = 883; |
| break; |
| case 63: |
| winkel = 891; |
| break; |
| case 64: |
| winkel = 899; |
| break; |
| case 65: |
| winkel = 906; |
| break; |
| case 66: |
| winkel = 914; |
| break; |
| case 67: |
| winkel = 921; |
| break; |
| case 68: |
| winkel = 927; |
| break; |
| case 69: |
| winkel = 934; |
| break; |
| case 70: |
| winkel = 940; |
| break; |
| case 71: |
| winkel = 946; |
| break; |
| case 72: |
| winkel = 951; |
| break; |
| case 73: |
| winkel = 956; |
| break; |
| case 74: |
| winkel = 961; |
| break; |
| case 75: |
| winkel = 966; |
| break; |
| case 76: |
| winkel = 970; |
| break; |
| case 77: |
| winkel = 974; |
| break; |
| case 78: |
| winkel = 978; |
| break; |
| case 79: |
| winkel = 982; |
| break; |
| case 80: |
| winkel = 985; |
| break; |
| case 81: |
| winkel = 988; |
| break; |
| case 82: |
| winkel = 990; |
| break; |
| case 83: |
| winkel = 993; |
| break; |
| case 84: |
| winkel = 995; |
| break; |
| case 85: |
| winkel = 996; |
| break; |
| case 86: |
| winkel = 998; |
| break; |
| case 87: |
| winkel = 999; |
| break; |
| case 88: |
| winkel = 999; |
| break; |
| case 89: |
| winkel = 1000; |
| break; |
| case 90: |
| winkel = 1000; |
| break; |
| default: |
| winkel = 0; |
| break; |
| } |
| return (winkel*m); |
| } |
| /branches/salvo_gps/math.h |
|---|
| 0,0 → 1,9 |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // Peter Muehlenbrock |
| // Definitionen fuer Modul math |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| extern signed int sin_i(signed int winkel); |
| extern signed int cos_i(signed int winkel); |
| extern signed int arctan_i(signed int x, signed int y); |
| /branches/salvo_gps/menu.c |
|---|
| 0,0 → 1,118 |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Copyright (c) 04.2007 Holger Buss |
| // + only for non-profit use |
| // + www.MikroKopter.com |
| // + see the File "License.txt" for further Informations |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| #include "main.h" |
| unsigned int TestInt = 0; |
| #define ARRAYGROESSE 10 |
| unsigned char Array[ARRAYGROESSE] = {1,2,3,4,5,6,7,8,9,10}; |
| char DisplayBuff[80] = "Hallo Welt"; |
| unsigned char DispPtr = 0; |
| unsigned char RemoteTasten = 0; |
| #define KEY1 0x01 |
| #define KEY2 0x02 |
| #define KEY3 0x04 |
| #define KEY4 0x08 |
| #define KEY5 0x10 |
| void LcdClear(void) |
| { |
| unsigned char i; |
| for(i=0;i<80;i++) DisplayBuff[i] = ' '; |
| } |
| void Menu(void) |
| { |
| static unsigned char MaxMenue = 10,MenuePunkt=0; |
| if(RemoteTasten & KEY1) { if(MenuePunkt) MenuePunkt--; else MenuePunkt = MaxMenue; LcdClear(); } |
| if(RemoteTasten & KEY2) { MenuePunkt++; LcdClear(); } |
| if((RemoteTasten & KEY1) && (RemoteTasten & KEY2)) MenuePunkt = 0; |
| LCD_printfxy(17,0,"[%i]",MenuePunkt); |
| switch(MenuePunkt) |
| { |
| case 0: |
| LCD_printfxy(0,0,"++ MikroKopter ++"); |
| // LCD_printfxy(0,1,"V%d.%d",VERSION_HAUPTVERSION, VERSION_NEBENVERSION); |
| LCD_printfxy(0,2,"Setting: %d ",GetActiveParamSetNumber()); |
| LCD_printfxy(0,3,"(c) Holger Buss"); |
| // if(RemoteTasten & KEY3) TestInt--; |
| // if(RemoteTasten & KEY4) TestInt++; |
| break; |
| case 1: |
| if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG) |
| { |
| LCD_printfxy(0,0,"Hoehe: %5i",HoehenWert); |
| LCD_printfxy(0,1,"SollHoehe: %5i",SollHoehe); |
| LCD_printfxy(0,2,"Luftdruck: %5i",MessLuftdruck); |
| LCD_printfxy(0,3,"Off : %5i",DruckOffsetSetting); |
| } |
| else |
| { |
| LCD_printfxy(0,1,"Keine "); |
| LCD_printfxy(0,2,"Höhenregelung"); |
| } |
| break; |
| case 2: |
| LCD_printfxy(0,0,"akt. Lage"); |
| LCD_printfxy(0,1,"Nick: %5i",IntegralNick/1024); |
| LCD_printfxy(0,2,"Roll: %5i",IntegralRoll/1024); |
| LCD_printfxy(0,3,"Kompass: %5i",KompassValue); |
| break; |
| case 3: |
| LCD_printfxy(0,0,"K1:%4i K2:%4i ",PPM_in[1],PPM_in[2]); |
| LCD_printfxy(0,1,"K3:%4i K4:%4i ",PPM_in[3],PPM_in[4]); |
| LCD_printfxy(0,2,"K5:%4i K6:%4i ",PPM_in[5],PPM_in[6]); |
| LCD_printfxy(0,3,"K7:%4i Kanäle ",PPM_in[7]); |
| break; |
| case 4: |
| LCD_printfxy(0,0,"Ni:%4i Ro:%4i ",PPM_in[EE_Parameter.Kanalbelegung[K_NICK]],PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]); |
| LCD_printfxy(0,1,"Gs:%4i Gi:%4i ",PPM_in[EE_Parameter.Kanalbelegung[K_GAS]],PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]); |
| LCD_printfxy(0,2,"P1:%4i P2:%4i ",PPM_in[EE_Parameter.Kanalbelegung[K_POTI1]],PPM_in[EE_Parameter.Kanalbelegung[K_POTI2]]); |
| LCD_printfxy(0,3,"P3:%4i Kanäle ",PPM_in[EE_Parameter.Kanalbelegung[K_POTI3]]); |
| break; |
| case 5: |
| LCD_printfxy(0,0,"Gyro - Sensor"); |
| LCD_printfxy(0,1,"Nick %4i (%3i)",AccumulateNick / MessanzahlNick, AdNeutralNick); |
| LCD_printfxy(0,2,"Roll %4i (%3i)",AccumulateRoll / MessanzahlRoll, AdNeutralRoll); |
| LCD_printfxy(0,3,"Gier %4i (%3i)",AccumulateGier / MessanzahlGier, AdNeutralGier); |
| break; |
| case 6: |
| LCD_printfxy(0,0,"ACC - Sensor"); |
| LCD_printfxy(0,1,"Nick %4i (%3i)",accumulate_AccNick / messanzahl_AccNick,NeutralAccX); |
| LCD_printfxy(0,2,"Roll %4i (%3i)",accumulate_AccRoll / messanzahl_AccRoll,NeutralAccY); |
| LCD_printfxy(0,3,"Hoch %4i (%3i)",Aktuell_az/*accumulate_AccHoch / messanzahl_AccHoch*/,(int)NeutralAccZ); |
| break; |
| case 7: |
| LCD_printfxy(0,1,"Spannung: %5i",UBat); |
| LCD_printfxy(0,2,"Empf.Pegel:%5i",SenderOkay); |
| break; |
| case 8: |
| LCD_printfxy(0,0,"Kompass "); |
| LCD_printfxy(0,1,"Richtung: %5i",KompassRichtung); |
| LCD_printfxy(0,2,"Messwert: %5i",KompassValue); |
| LCD_printfxy(0,3,"Start: %5i",KompassStartwert); |
| break; |
| case 9: |
| LCD_printfxy(0,0,"Poti1: %3i",Poti1); |
| LCD_printfxy(0,1,"Poti2: %3i",Poti2); |
| LCD_printfxy(0,2,"Poti3: %3i",Poti3); |
| LCD_printfxy(0,3,"Poti4: %3i",Poti4); |
| break; |
| case 10: |
| LCD_printfxy(0,0,"Servo " ); |
| LCD_printfxy(0,1,"Setpoint %3i",Parameter_ServoNickControl); |
| LCD_printfxy(0,2,"Stellung: %3i",ServoValue); |
| LCD_printfxy(0,3,"Range:%3i-%3i",EE_Parameter.ServoNickMin,EE_Parameter.ServoNickMax); |
| break; |
| default: MaxMenue = MenuePunkt - 1; |
| MenuePunkt = 0; |
| break; |
| } |
| RemoteTasten = 0; |
| } |
| /branches/salvo_gps/menu.h |
|---|
| 0,0 → 1,5 |
| extern void Menu(void); |
| extern char DisplayBuff[80]; |
| extern unsigned char DispPtr; |
| unsigned char RemoteTasten; |
| /branches/salvo_gps/old_macros.h |
|---|
| 0,0 → 1,47 |
| /* |
| For backwards compatibility only. |
| Ingo Busker ingo@mikrocontroller.com |
| */ |
| #ifndef cbi |
| #define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) |
| #endif |
| #ifndef sbi |
| #define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit)) |
| #endif |
| #ifndef inb |
| #define inb(sfr) _SFR_BYTE(sfr) |
| #endif |
| #ifndef outb |
| #define outb(sfr, val) (_SFR_BYTE(sfr) = (val)) |
| #endif |
| #ifndef inw |
| #define inw(sfr) _SFR_WORD(sfr) |
| #endif |
| #ifndef outw |
| #define outw(sfr, val) (_SFR_WORD(sfr) = (val)) |
| #endif |
| #ifndef outp |
| #define outp(val, sfr) outb(sfr, val) |
| #endif |
| #ifndef inp |
| #define inp(sfr) inb(sfr) |
| #endif |
| #ifndef BV |
| #define BV(bit) _BV(bit) |
| #endif |
| #ifndef PRG_RDB |
| #define PRG_RDB pgm_read_byte |
| #endif |
| /branches/salvo_gps/printf_P.c |
|---|
| 0,0 → 1,480 |
| // Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist nicht von der Lizenz für den MikroKopter-Teil unterstellt |
| /* |
| Copyright (C) 1993 Free Software Foundation |
| This file is part of the GNU IO Library. This library is free |
| software; you can redistribute it and/or modify it under the |
| terms of the GNU General Public License as published by the |
| Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| This library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| You should have received a copy of the GNU General Public License |
| along with this library; see the file COPYING. If not, write to the Free |
| Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| As a special exception, if you link this library with files |
| compiled with a GNU compiler to produce an executable, this does not cause |
| the resulting executable to be covered by the GNU General Public License. |
| This exception does not however invalidate any other reasons why |
| the executable file might be covered by the GNU General Public License. */ |
| /* |
| * Copyright (c) 1990 Regents of the University of California. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. [rescinded 22 July 1999] |
| * 4. Neither the name of the University nor the names of its contributors |
| * may be used to endorse or promote products derived from this software |
| * without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| */ |
| /****************************************************************************** |
| This file is a patched version of printf called _printf_P |
| It is made to work with avr-gcc for Atmel AVR MCUs. |
| There are some differences from standard printf: |
| 1. There is no floating point support (with fp the code is about 8K!) |
| 2. Return type is void |
| 3. Format string must be in program memory (by using macro printf this is |
| done automaticaly) |
| 4. %n is not implemented (just remove the comment around it if you need it) |
| 5. If LIGHTPRINTF is defined, the code is about 550 bytes smaller and the |
| folowing specifiers are disabled : |
| space # * . - + p s o O |
| 6. A function void uart_sendchar(char c) is used for output. The UART must |
| be initialized before using printf. |
| Alexander Popov |
| sasho@vip.orbitel.bg |
| ******************************************************************************/ |
| /* |
| * Actual printf innards. |
| * |
| * This code is large and complicated... |
| */ |
| #include <string.h> |
| #ifdef __STDC__ |
| #include <stdarg.h> |
| #else |
| #include <varargs.h> |
| #endif |
| #include "main.h" |
| //#define LIGHTPRINTF |
| char PrintZiel; |
| char Putchar(char zeichen) |
| { |
| if(PrintZiel == OUT_LCD) { DisplayBuff[DispPtr++] = zeichen; return(1);} |
| else return(uart_putchar(zeichen)); |
| } |
| void PRINT(const char * ptr, unsigned int len) |
| { |
| for(;len;len--) Putchar(*ptr++); |
| } |
| void PRINTP(const char * ptr, unsigned int len) |
| { |
| for(;len;len--) Putchar(pgm_read_byte(ptr++)); |
| } |
| void PAD_SP(signed char howmany) |
| { |
| for(;howmany>0;howmany--) Putchar(' '); |
| } |
| void PAD_0(signed char howmany) |
| { |
| for(;howmany>0;howmany--) Putchar('0'); |
| } |
| #define BUF 40 |
| /* |
| * Macros for converting digits to letters and vice versa |
| */ |
| #define to_digit(c) ((c) - '0') |
| #define is_digit(c) ((c)<='9' && (c)>='0') |
| #define to_char(n) ((n) + '0') |
| /* |
| * Flags used during conversion. |
| */ |
| #define LONGINT 0x01 /* long integer */ |
| #define LONGDBL 0x02 /* long double; unimplemented */ |
| #define SHORTINT 0x04 /* short integer */ |
| #define ALT 0x08 /* alternate form */ |
| #define LADJUST 0x10 /* left adjustment */ |
| #define ZEROPAD 0x20 /* zero (as opposed to blank) pad */ |
| #define HEXPREFIX 0x40 /* add 0x or 0X prefix */ |
| void _printf_P (char ziel,char const *fmt0, ...) /* Works with string from FLASH */ |
| { |
| va_list ap; |
| register const char *fmt; /* format string */ |
| register char ch; /* character from fmt */ |
| register int n; /* handy integer (short term usage) */ |
| register char *cp; /* handy char pointer (short term usage) */ |
| const char *fmark; /* for remembering a place in fmt */ |
| register unsigned char flags; /* flags as above */ |
| signed char width; /* width from format (%8d), or 0 */ |
| signed char prec; /* precision from format (%.3d), or -1 */ |
| char sign; /* sign prefix (' ', '+', '-', or \0) */ |
| unsigned long _ulong=0; /* integer arguments %[diouxX] */ |
| #define OCT 8 |
| #define DEC 10 |
| #define HEX 16 |
| unsigned char base; /* base for [diouxX] conversion */ |
| signed char dprec; /* a copy of prec if [diouxX], 0 otherwise */ |
| signed char dpad; /* extra 0 padding needed for integers */ |
| signed char fieldsz; /* field size expanded by sign, dpad etc */ |
| /* The initialization of 'size' is to suppress a warning that |
| 'size' might be used unitialized. It seems gcc can't |
| quite grok this spaghetti code ... */ |
| signed char size = 0; /* size of converted field or string */ |
| char buf[BUF]; /* space for %c, %[diouxX], %[eEfgG] */ |
| char ox[2]; /* space for 0x hex-prefix */ |
| PrintZiel = ziel; // bestimmt, LCD oder UART |
| va_start(ap, fmt0); |
| fmt = fmt0; |
| /* |
| * Scan the format for conversions (`%' character). |
| */ |
| for (;;) { |
| for (fmark = fmt; (ch = pgm_read_byte(fmt)) != '\0' && ch != '%'; fmt++) |
| /* void */; |
| if ((n = fmt - fmark) != 0) { |
| PRINTP(fmark, n); |
| } |
| if (ch == '\0') |
| goto done; |
| fmt++; /* skip over '%' */ |
| flags = 0; |
| dprec = 0; |
| width = 0; |
| prec = -1; |
| sign = '\0'; |
| rflag: ch = PRG_RDB(fmt++); |
| reswitch: |
| #ifdef LIGHTPRINTF |
| if (ch=='o' || ch=='u' || (ch|0x20)=='x') { |
| #else |
| if (ch=='u' || (ch|0x20)=='x') { |
| #endif |
| if (flags&LONGINT) { |
| _ulong=va_arg(ap, unsigned long); |
| } else { |
| register unsigned int _d; |
| _d=va_arg(ap, unsigned int); |
| _ulong = flags&SHORTINT ? (unsigned long)(unsigned short)_d : (unsigned long)_d; |
| } |
| } |
| #ifndef LIGHTPRINTF |
| if(ch==' ') { |
| /* |
| * ``If the space and + flags both appear, the space |
| * flag will be ignored.'' |
| * -- ANSI X3J11 |
| */ |
| if (!sign) |
| sign = ' '; |
| goto rflag; |
| } else if (ch=='#') { |
| flags |= ALT; |
| goto rflag; |
| } else if (ch=='*'||ch=='-') { |
| if (ch=='*') { |
| /* |
| * ``A negative field width argument is taken as a |
| * - flag followed by a positive field width.'' |
| * -- ANSI X3J11 |
| * They don't exclude field widths read from args. |
| */ |
| if ((width = va_arg(ap, int)) >= 0) |
| goto rflag; |
| width = -width; |
| } |
| flags |= LADJUST; |
| flags &= ~ZEROPAD; /* '-' disables '0' */ |
| goto rflag; |
| } else if (ch=='+') { |
| sign = '+'; |
| goto rflag; |
| } else if (ch=='.') { |
| if ((ch = PRG_RDB(fmt++)) == '*') { |
| n = va_arg(ap, int); |
| prec = n < 0 ? -1 : n; |
| goto rflag; |
| } |
| n = 0; |
| while (is_digit(ch)) { |
| n = n*10 + to_digit(ch); |
| ch = PRG_RDB(fmt++); |
| } |
| prec = n < 0 ? -1 : n; |
| goto reswitch; |
| } else |
| #endif /* LIGHTPRINTF */ |
| if (ch=='0') { |
| /* |
| * ``Note that 0 is taken as a flag, not as the |
| * beginning of a field width.'' |
| * -- ANSI X3J11 |
| */ |
| if (!(flags & LADJUST)) |
| flags |= ZEROPAD; /* '-' disables '0' */ |
| goto rflag; |
| } else if (ch>='1' && ch<='9') { |
| n = 0; |
| do { |
| n = 10 * n + to_digit(ch); |
| ch = PRG_RDB(fmt++); |
| } while (is_digit(ch)); |
| width = n; |
| goto reswitch; |
| } else if (ch=='h') { |
| flags |= SHORTINT; |
| goto rflag; |
| } else if (ch=='l') { |
| flags |= LONGINT; |
| goto rflag; |
| } else if (ch=='c') { |
| *(cp = buf) = va_arg(ap, int); |
| size = 1; |
| sign = '\0'; |
| } else if (ch=='D'||ch=='d'||ch=='i') { |
| if(ch=='D') |
| flags |= LONGINT; |
| if (flags&LONGINT) { |
| _ulong=va_arg(ap, long); |
| } else { |
| register int _d; |
| _d=va_arg(ap, int); |
| _ulong = flags&SHORTINT ? (long)(short)_d : (long)_d; |
| } |
| if ((long)_ulong < 0) { |
| _ulong = -_ulong; |
| sign = '-'; |
| } |
| base = DEC; |
| goto number; |
| } else |
| /* |
| if (ch=='n') { |
| if (flags & LONGINT) |
| *va_arg(ap, long *) = ret; |
| else if (flags & SHORTINT) |
| *va_arg(ap, short *) = ret; |
| else |
| *va_arg(ap, int *) = ret; |
| continue; // no output |
| } else |
| */ |
| #ifndef LIGHTPRINTF |
| if (ch=='O'||ch=='o') { |
| if (ch=='O') |
| flags |= LONGINT; |
| base = OCT; |
| goto nosign; |
| } else if (ch=='p') { |
| /* |
| * ``The argument shall be a pointer to void. The |
| * value of the pointer is converted to a sequence |
| * of printable characters, in an implementation- |
| * defined manner.'' |
| * -- ANSI X3J11 |
| */ |
| /* NOSTRICT */ |
| _ulong = (unsigned int)va_arg(ap, void *); |
| base = HEX; |
| flags |= HEXPREFIX; |
| ch = 'x'; |
| goto nosign; |
| } else if (ch=='s') { // print a string from RAM |
| if ((cp = va_arg(ap, char *)) == NULL) { |
| cp=buf; |
| cp[0] = '('; |
| cp[1] = 'n'; |
| cp[2] = 'u'; |
| cp[4] = cp[3] = 'l'; |
| cp[5] = ')'; |
| cp[6] = '\0'; |
| } |
| if (prec >= 0) { |
| /* |
| * can't use strlen; can only look for the |
| * NUL in the first `prec' characters, and |
| * strlen() will go further. |
| */ |
| char *p = (char*)memchr(cp, 0, prec); |
| if (p != NULL) { |
| size = p - cp; |
| if (size > prec) |
| size = prec; |
| } else |
| size = prec; |
| } else |
| size = strlen(cp); |
| sign = '\0'; |
| } else |
| #endif /* LIGHTPRINTF */ |
| if(ch=='U'||ch=='u') { |
| if (ch=='U') |
| flags |= LONGINT; |
| base = DEC; |
| goto nosign; |
| } else if (ch=='X'||ch=='x') { |
| base = HEX; |
| /* leading 0x/X only if non-zero */ |
| if (flags & ALT && _ulong != 0) |
| flags |= HEXPREFIX; |
| /* unsigned conversions */ |
| nosign: sign = '\0'; |
| /* |
| * ``... diouXx conversions ... if a precision is |
| * specified, the 0 flag will be ignored.'' |
| * -- ANSI X3J11 |
| */ |
| number: if ((dprec = prec) >= 0) |
| flags &= ~ZEROPAD; |
| /* |
| * ``The result of converting a zero value with an |
| * explicit precision of zero is no characters.'' |
| * -- ANSI X3J11 |
| */ |
| cp = buf + BUF; |
| if (_ulong != 0 || prec != 0) { |
| register unsigned char _d,notlastdigit; |
| do { |
| notlastdigit=(_ulong>=base); |
| _d = _ulong % base; |
| if (_d<10) { |
| _d+='0'; |
| } else { |
| _d+='a'-10; |
| if (ch=='X') _d&=~0x20; |
| } |
| *--cp=_d; |
| _ulong /= base; |
| } while (notlastdigit); |
| #ifndef LIGHTPRINTF |
| // handle octal leading 0 |
| if (base==OCT && flags & ALT && *cp != '0') |
| *--cp = '0'; |
| #endif |
| } |
| size = buf + BUF - cp; |
| } else { //default |
| /* "%?" prints ?, unless ? is NUL */ |
| if (ch == '\0') |
| goto done; |
| /* pretend it was %c with argument ch */ |
| cp = buf; |
| *cp = ch; |
| size = 1; |
| sign = '\0'; |
| } |
| /* |
| * All reasonable formats wind up here. At this point, |
| * `cp' points to a string which (if not flags&LADJUST) |
| * should be padded out to `width' places. If |
| * flags&ZEROPAD, it should first be prefixed by any |
| * sign or other prefix; otherwise, it should be blank |
| * padded before the prefix is emitted. After any |
| * left-hand padding and prefixing, emit zeroes |
| * required by a decimal [diouxX] precision, then print |
| * the string proper, then emit zeroes required by any |
| * leftover floating precision; finally, if LADJUST, |
| * pad with blanks. |
| */ |
| /* |
| * compute actual size, so we know how much to pad. |
| */ |
| fieldsz = size; |
| dpad = dprec - size; |
| if (dpad < 0) |
| dpad = 0; |
| if (sign) |
| fieldsz++; |
| else if (flags & HEXPREFIX) |
| fieldsz += 2; |
| fieldsz += dpad; |
| /* right-adjusting blank padding */ |
| if ((flags & (LADJUST|ZEROPAD)) == 0) |
| PAD_SP(width - fieldsz); |
| /* prefix */ |
| if (sign) { |
| PRINT(&sign, 1); |
| } else if (flags & HEXPREFIX) { |
| ox[0] = '0'; |
| ox[1] = ch; |
| PRINT(ox, 2); |
| } |
| /* right-adjusting zero padding */ |
| if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD) |
| PAD_0(width - fieldsz); |
| /* leading zeroes from decimal precision */ |
| PAD_0(dpad); |
| /* the string or number proper */ |
| PRINT(cp, size); |
| /* left-adjusting padding (always blank) */ |
| if (flags & LADJUST) |
| PAD_SP(width - fieldsz); |
| } |
| done: |
| va_end(ap); |
| } |
| /branches/salvo_gps/printf_P.h |
|---|
| 0,0 → 1,19 |
| #ifndef _PRINTF_P_H_ |
| #define _PRINTF_P_H_ |
| #include <avr/pgmspace.h> |
| #define OUT_V24 0 |
| #define OUT_LCD 1 |
| extern void _printf_P (char, char const *fmt0, ...); |
| extern char PrintZiel; |
| #define printf_P(format, args...) _printf_P(OUT_V24,format , ## args) |
| #define printf(format, args...) _printf_P(OUT_V24,PSTR(format) , ## args) |
| #define LCD_printfxy(x,y,format, args...) { DispPtr = y * 20 + x; _printf_P(OUT_LCD,PSTR(format) , ## args);} |
| #define LCD_printf(format, args...) { _printf_P(OUT_LCD,PSTR(format) , ## args);} |
| #endif |
| /branches/salvo_gps/rc.c |
|---|
| 0,0 → 1,85 |
| /*####################################################################################### |
| Decodieren eines RC Summen Signals |
| #######################################################################################*/ |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Copyright (c) 04.2007 Holger Buss |
| // + only for non-profit use |
| // + www.MikroKopter.com |
| // + see the File "License.txt" for further Informations |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| #include "rc.h" |
| #include "main.h" |
| volatile int PPM_in[11]; |
| volatile int PPM_diff[11]; // das diffenzierte Stick-Signal |
| volatile unsigned char NewPpmData = 1; |
| //############################################################################ |
| //zum decodieren des PPM-Signals wird Timer1 mit seiner Input |
| //Capture Funktion benutzt: |
| void rc_sum_init (void) |
| //############################################################################ |
| { |
| TCCR1B=(1<<CS11)|(1<<CS10)|(1<<ICES1)|(1<<ICNC1);//|(1 << WGM12); //timer1 prescale 64 |
| // PWM |
| //TCCR1A = (1 << COM1B1) | (1 << WGM11) | (1 << WGM10); |
| //TCCR1B |= (1 << WGM12); |
| //OCR1B = 55; |
| TIMSK1 |= _BV(ICIE1); |
| AdNeutralGier = 0; |
| AdNeutralRoll = 0; |
| AdNeutralNick = 0; |
| return; |
| } |
| //############################################################################ |
| //Diese Routine startet und inizialisiert den Timer für RC |
| SIGNAL(SIG_INPUT_CAPTURE1) |
| //############################################################################ |
| { |
| static unsigned int AltICR=0; |
| signed int signal = 0; |
| static int index; |
| signal = (unsigned int) ICR1 - AltICR; |
| AltICR = ICR1; |
| //Syncronisationspause? |
| if ((signal > 1500) && (signal < 8000)) |
| { |
| index = 1; |
| NewPpmData = 0; // Null bedeutet: Neue Daten |
| // OCR2A = Poti2/2 + 80; |
| } |
| else |
| { |
| if(index < 10) |
| { |
| if((signal > 250) && (signal < 687)) |
| { |
| signal -= 466; |
| // Stabiles Signal |
| if(abs(signal - PPM_in[index]) < 6) { if(SenderOkay < 200) SenderOkay += 10;} |
| signal = (3 * (PPM_in[index]) + signal) / 4; |
| //373 entspricht ca. 1.5ms also Mittelstellung |
| PPM_diff[index] = signal - PPM_in[index]; |
| PPM_in[index] = signal; |
| } |
| index++; |
| /* if(index == 5) PORTD |= 0x20; else PORTD &= ~0x20; // Servosignal an J3 anlegen |
| if(index == 6) PORTD |= 0x10; else PORTD &= ~0x10; // Servosignal an J4 anlegen |
| if(index == 7) PORTD |= 0x08; else PORTD &= ~0x08; // Servosignal an J5 anlegen */ |
| } |
| } |
| } |
| /branches/salvo_gps/rc.h |
|---|
| 0,0 → 1,29 |
| /*####################################################################################### |
| Derkodieren eines RC Summen Signals |
| #######################################################################################*/ |
| #ifndef _RC_H |
| #define _RC_H |
| #if defined (__AVR_ATmega32__) |
| #define TIMER_TEILER CK64 |
| #define TIMER_RELOAD_VALUE 250 |
| #endif |
| #if defined (__AVR_ATmega644__) |
| //#define TIMER_TEILER CK64 |
| #define TIMER_RELOAD_VALUE 250 |
| //#define TIMER_TEILER CK256 // bei 20MHz |
| //#define TIMER_RELOAD_VALUE -78 // bei 20MHz |
| #endif |
| #define GAS PPM_in[2] |
| extern void rc_sum_init (void); |
| extern volatile int PPM_in[11]; |
| extern volatile int PPM_diff[11]; // das diffenzierte Stick-Signal |
| extern volatile unsigned char NewPpmData; |
| #endif //_RC_H |
| /branches/salvo_gps/timer0.c |
|---|
| 0,0 → 1,155 |
| #include "main.h" |
| volatile unsigned int CountMilliseconds = 0; |
| volatile static unsigned int tim_main; |
| volatile unsigned char UpdateMotor = 0; |
| volatile unsigned int cntKompass = 0; |
| volatile unsigned int beeptime = 0; |
| int ServoValue = 0; |
| //Salvo 8.9.2007 |
| volatile uint8_t Kompass_Neuer_Wert= 0; |
| volatile unsigned int Kompass_Value_Old = 0; |
| // Salvo End |
| enum { |
| STOP = 0, |
| CK = 1, |
| CK8 = 2, |
| CK64 = 3, |
| CK256 = 4, |
| CK1024 = 5, |
| T0_FALLING_EDGE = 6, |
| T0_RISING_EDGE = 7 |
| }; |
| SIGNAL (SIG_OVERFLOW0) // 8kHz |
| { |
| static unsigned char cnt_1ms = 1,cnt = 0; |
| // TCNT0 -= 250;//TIMER_RELOAD_VALUE; |
| if(!cnt--) |
| { |
| cnt = 9; |
| cnt_1ms++; |
| cnt_1ms %= 2; |
| if(!cnt_1ms) UpdateMotor = 1; |
| CountMilliseconds++; |
| if(Timeout) Timeout--; |
| } |
| if(beeptime > 1) |
| { |
| beeptime--; |
| PORTD |= (1<<2); |
| } |
| else |
| PORTD &= ~(1<<2); |
| // if(EE_Parameter.GlobalConfig & CFG_KOMPASS_AKTIV) |
| { |
| if(PINC & 0x10) |
| { |
| cntKompass++; |
| } |
| else |
| { |
| if((cntKompass) && (cntKompass < 4000)) |
| { |
| // Salvo Kompassoffset 30.8.2007 *********** |
| Kompass_Value_Old = KompassValue; |
| KompassValue = cntKompass -KOMPASS_OFFSET; |
| if (KompassValue < 0) |
| { |
| KompassValue += 360; |
| } |
| if (KompassValue >= 360) |
| { |
| KompassValue -= 360; |
| } |
| // Salvo End |
| } |
| // if(cntKompass < 10) cntKompass = 10; |
| // KompassValue = (unsigned long)((unsigned long)(cntKompass-10)*720L + 1L) / 703L; |
| KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180; |
| Kompass_Neuer_Wert = 1; |
| cntKompass = 0; |
| } |
| } |
| } |
| void Timer_Init(void) |
| { |
| tim_main = SetDelay(10); |
| TCCR0B = CK8; |
| TCCR0A = (1<<COM0A1)|(1<<COM0B1)|3;//fast PWM |
| OCR0A = 0; |
| OCR0B = 120; |
| TCNT0 = -TIMER_RELOAD_VALUE; // reload |
| //OCR1 = 0x00; |
| TCCR2A=(1<<COM2A1)|(1<<COM2A0)|3; |
| TCCR2B=(0<<CS20)|(1<<CS21)|(1<<CS22); |
| // TIMSK2 |= _BV(TOIE2); |
| TIMSK2 |= _BV(OCIE2A); |
| TIMSK0 |= _BV(TOIE0); |
| OCR2A = 10; |
| TCNT2 = 0; |
| } |
| // ----------------------------------------------------------------------- |
| unsigned int SetDelay (unsigned int t) |
| { |
| // TIMSK0 &= ~_BV(TOIE0); |
| return(CountMilliseconds + t + 1); |
| // TIMSK0 |= _BV(TOIE0); |
| } |
| // ----------------------------------------------------------------------- |
| char CheckDelay(unsigned int t) |
| { |
| // TIMSK0 &= ~_BV(TOIE0); |
| return(((t - CountMilliseconds) & 0x8000) >> 9); |
| // TIMSK0 |= _BV(TOIE0); |
| } |
| // ----------------------------------------------------------------------- |
| void Delay_ms(unsigned int w) |
| { |
| unsigned int akt; |
| akt = SetDelay(w); |
| while (!CheckDelay(akt)); |
| } |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // Servo ansteuern |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| SIGNAL(SIG_OUTPUT_COMPARE2A) |
| { |
| static unsigned char timer = 10; |
| if(!timer--) |
| { |
| TCCR2A=(1<<COM2A1)|(0<<COM2A0)|3; |
| ServoValue = Parameter_ServoNickControl; |
| if(EE_Parameter.ServoNickCompInvert & 0x01) ServoValue += ((long) EE_Parameter.ServoNickComp * (IntegralNick / 128)) / 512; |
| else ServoValue -= ((long) EE_Parameter.ServoNickComp * (IntegralNick / 128)) / 512; |
| if(ServoValue < EE_Parameter.ServoNickMin) ServoValue = EE_Parameter.ServoNickMin; |
| else if(ServoValue > EE_Parameter.ServoNickMax) ServoValue = EE_Parameter.ServoNickMax; |
| // DebugOut.Analog[10] = ServoValue; |
| OCR2A = ServoValue;// + 75; |
| timer = EE_Parameter.ServoNickRefresh; |
| } |
| else |
| { |
| TCCR2A =3; |
| PORTD&=~0x80; |
| } |
| } |
| /branches/salvo_gps/timer0.h |
|---|
| 0,0 → 1,23 |
| #define TIMER_TEILER CK8 |
| #define TIMER_RELOAD_VALUE 250 |
| // Salvo Kompassoffset 31.8.2007 *********** |
| #define KOMPASS_OFFSET 135 // Winkel zwischen Nordachse Kopter und Nordachse Kompass |
| // Salvo End |
| void Timer_Init(void); |
| void Delay_ms(unsigned int); |
| unsigned int SetDelay (unsigned int t); |
| char CheckDelay (unsigned int t); |
| extern volatile unsigned int CountMilliseconds; |
| extern volatile unsigned char UpdateMotor; |
| extern volatile unsigned int beeptime; |
| extern volatile unsigned int cntKompass; |
| extern int ServoValue; |
| //Salvo 9.9.2007 |
| extern volatile uint8_t Kompass_Neuer_Wert; |
| extern volatile unsigned int Kompass_Value_Old; |
| // Salvo End |
| /branches/salvo_gps/twimaster.c |
|---|
| 0,0 → 1,131 |
| /*############################################################################ |
| ############################################################################*/ |
| #include "main.h" |
| unsigned char twi_state = 0; |
| unsigned char motor = 0; |
| unsigned char motorread = 0; |
| unsigned char motor_rx[8]; |
| //############################################################################ |
| //Initzialisieren der I2C (TWI) Schnittstelle |
| void i2c_init(void) |
| //############################################################################ |
| { |
| TWSR = 0; |
| TWBR = ((SYSCLK/SCL_CLOCK)-16)/2; |
| } |
| //############################################################################ |
| //Start I2C |
| char i2c_start(void) |
| //############################################################################ |
| { |
| TWCR = (1<<TWSTA) | (1<<TWEN) | (1<<TWINT) | (1<<TWIE); |
| return(0); |
| } |
| //############################################################################ |
| //Start I2C |
| void i2c_stop(void) |
| //############################################################################ |
| { |
| TWCR = (1<<TWEN) | (1<<TWSTO) | (1<<TWINT); |
| } |
| //############################################################################ |
| //Start I2C |
| char i2c_write_byte(char byte) |
| //############################################################################ |
| { |
| TWSR = 0x00; |
| TWDR = byte; |
| TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE); |
| return(0); |
| } |
| //############################################################################ |
| //Start I2C |
| SIGNAL (TWI_vect) |
| //############################################################################ |
| { |
| switch (twi_state++) |
| { |
| case 0: |
| i2c_write_byte(0x52+(motor*2)); |
| break; |
| case 1: |
| switch(motor++) |
| { |
| case 0: |
| i2c_write_byte(Motor_Vorne); |
| break; |
| case 1: |
| i2c_write_byte(Motor_Hinten); |
| break; |
| case 2: |
| i2c_write_byte(Motor_Rechts); |
| break; |
| case 3: |
| i2c_write_byte(Motor_Links); |
| break; |
| } |
| break; |
| case 2: |
| i2c_stop(); |
| if (motor<4) twi_state = 0; |
| else motor = 0; |
| i2c_start(); |
| break; |
| //Liest Daten von Motor |
| case 3: |
| i2c_write_byte(0x53+(motorread*2)); |
| break; |
| case 4: |
| switch(motorread) |
| { |
| case 0: |
| i2c_write_byte(Motor_Vorne); |
| break; |
| case 1: |
| i2c_write_byte(Motor_Hinten); |
| break; |
| case 2: |
| i2c_write_byte(Motor_Rechts); |
| break; |
| case 3: |
| i2c_write_byte(Motor_Links); |
| break; |
| } |
| break; |
| case 5: //1 Byte vom Motor lesen |
| motor_rx[motorread] = TWDR; |
| case 6: |
| switch(motorread) |
| { |
| case 0: |
| i2c_write_byte(Motor_Vorne); |
| break; |
| case 1: |
| i2c_write_byte(Motor_Hinten); |
| break; |
| case 2: |
| i2c_write_byte(Motor_Rechts); |
| break; |
| case 3: |
| i2c_write_byte(Motor_Links); |
| break; |
| } |
| break; |
| case 7: //2 Byte vom Motor lesen |
| motor_rx[motorread+4] = TWDR; |
| motorread++; |
| if (motorread>3) motorread=0; |
| i2c_stop(); |
| twi_state = 0; |
| } |
| } |
| /branches/salvo_gps/twimaster.h |
|---|
| 0,0 → 1,32 |
| /*############################################################################ |
| ############################################################################*/ |
| #ifndef _I2C_MASTER_H |
| #define _I2C_MASTER_H |
| //############################################################################ |
| // I2C Konstanten |
| #define SCL_CLOCK 200000L |
| #define I2C_TIMEOUT 30000 |
| #define I2C_START 0x08 |
| #define I2C_REPEATED_START 0x10 |
| #define I2C_TX_SLA_ACK 0x18 |
| #define I2C_TX_DATA_ACK 0x28 |
| #define I2C_RX_SLA_ACK 0x40 |
| #define I2C_RX_DATA_ACK 0x50 |
| //############################################################################ |
| extern unsigned char twi_state; |
| extern unsigned char motor; |
| extern unsigned char motorread; |
| extern unsigned char motor_rx[8]; |
| void i2c_init (void); // I2C initialisieren |
| char i2c_start (void); // Start I2C |
| void i2c_stop (void); // Stop I2C |
| char i2c_write_byte (char byte); // 1 Byte schreiben |
| #endif |
| /branches/salvo_gps/uart.c |
|---|
| 0,0 → 1,330 |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Copyright (c) 04.2007 Holger Buss |
| // + only for non-profit use |
| // + www.MikroKopter.com |
| // + see the File "License.txt" for further Informations |
| // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| #include "main.h" |
| #include "uart.h" |
| unsigned char DebugGetAnforderung = 0,DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0; |
| unsigned volatile char SioTmp = 0; |
| unsigned volatile char SendeBuffer[MAX_SENDE_BUFF]; |
| unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF]; |
| unsigned volatile char NMEABuffer[MAX_EMPFANGS_BUFF]; |
| unsigned volatile char NeuerDatensatzEmpfangen = 0; |
| unsigned volatile char NeueKoordinateEmpfangen = 0; |
| unsigned volatile char UebertragungAbgeschlossen = 1; |
| unsigned volatile char CntCrcError = 0; |
| unsigned volatile char AnzahlEmpfangsBytes = 0; |
| unsigned volatile char PC_DebugTimeout = 0; |
| unsigned char PcZugriff = 100; |
| unsigned char MotorTest[4] = {0,0,0,0}; |
| unsigned char MeineSlaveAdresse; |
| struct str_DebugOut DebugOut; |
| struct str_Debug DebugIn; |
| struct str_VersionInfo VersionInfo; |
| int Debug_Timer; |
| //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| //++ Sende-Part der Datenübertragung |
| //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| SIGNAL(INT_VEC_TX) |
| { |
| static unsigned int ptr = 0; |
| unsigned char tmp_tx; |
| if(!UebertragungAbgeschlossen) |
| { |
| ptr++; // die [0] wurde schon gesendet |
| tmp_tx = SendeBuffer[ptr]; |
| if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF)) |
| { |
| ptr = 0; |
| UebertragungAbgeschlossen = 1; |
| } |
| UDR = tmp_tx; |
| } |
| else ptr = 0; |
| } |
| //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| //++ Empfangs-Part der Datenübertragung, incl. CRC-Auswertung |
| //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| SIGNAL(INT_VEC_RX) |
| { |
| static unsigned int crc; |
| static unsigned char crc1,crc2,buf_ptr; |
| static unsigned char UartState = 0; |
| unsigned char CrcOkay = 0; |
| SioTmp = UDR; |
| //Salvo 11.9.2007 GPS Daten holen |
| Get_Ublox_Msg(SioTmp); // Daten vom GPS Modul holen |
| // Salvo End |
| if(buf_ptr >= MAX_EMPFANGS_BUFF) UartState = 0; |
| if(SioTmp == '\r' && UartState == 2) |
| { |
| UartState = 0; |
| crc -= RxdBuffer[buf_ptr-2]; |
| crc -= RxdBuffer[buf_ptr-1]; |
| crc %= 4096; |
| crc1 = '=' + crc / 64; |
| crc2 = '=' + crc % 64; |
| CrcOkay = 0; |
| if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; CntCrcError++;}; |
| if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet |
| { |
| NeuerDatensatzEmpfangen = 1; |
| AnzahlEmpfangsBytes = buf_ptr; |
| RxdBuffer[buf_ptr] = '\r'; |
| if(/*(RxdBuffer[1] == MeineSlaveAdresse || (RxdBuffer[1] == 'a')) && */(RxdBuffer[2] == 'R')) wdt_enable(WDTO_250MS); // Reset-Commando |
| } |
| } |
| else |
| switch(UartState) |
| { |
| case 0: |
| if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet |
| buf_ptr = 0; |
| RxdBuffer[buf_ptr++] = SioTmp; |
| crc = SioTmp; |
| break; |
| case 1: // Adresse auswerten |
| UartState++; |
| RxdBuffer[buf_ptr++] = SioTmp; |
| crc += SioTmp; |
| break; |
| case 2: // Eingangsdaten sammeln |
| RxdBuffer[buf_ptr] = SioTmp; |
| if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++; |
| else UartState = 0; |
| crc += SioTmp; |
| break; |
| default: |
| UartState = 0; |
| break; |
| } |
| } |
| // -------------------------------------------------------------------------- |
| void AddCRC(unsigned int wieviele) |
| { |
| unsigned int tmpCRC = 0,i; |
| for(i = 0; i < wieviele;i++) |
| { |
| tmpCRC += SendeBuffer[i]; |
| } |
| tmpCRC %= 4096; |
| SendeBuffer[i++] = '=' + tmpCRC / 64; |
| SendeBuffer[i++] = '=' + tmpCRC % 64; |
| SendeBuffer[i++] = '\r'; |
| UebertragungAbgeschlossen = 0; |
| UDR = SendeBuffer[0]; |
| } |
| // -------------------------------------------------------------------------- |
| void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len) |
| { |
| unsigned int pt = 0; |
| unsigned char a,b,c; |
| unsigned char ptr = 0; |
| SendeBuffer[pt++] = '#'; // Startzeichen |
| SendeBuffer[pt++] = modul; // Adresse (a=0; b=1,...) |
| SendeBuffer[pt++] = cmd; // Commando |
| while(len) |
| { |
| if(len) { a = snd[ptr++]; len--;} else a = 0; |
| if(len) { b = snd[ptr++]; len--;} else b = 0; |
| if(len) { c = snd[ptr++]; len--;} else c = 0; |
| SendeBuffer[pt++] = '=' + (a >> 2); |
| SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4)); |
| SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6)); |
| SendeBuffer[pt++] = '=' + ( c & 0x3f); |
| } |
| AddCRC(pt); |
| } |
| // -------------------------------------------------------------------------- |
| void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max) // Wohin mit den Daten; Wie lang; Wo im RxdBuffer |
| { |
| unsigned char a,b,c,d; |
| unsigned char ptr = 0; |
| unsigned char x,y,z; |
| while(len) |
| { |
| a = RxdBuffer[ptrIn++] - '='; |
| b = RxdBuffer[ptrIn++] - '='; |
| c = RxdBuffer[ptrIn++] - '='; |
| d = RxdBuffer[ptrIn++] - '='; |
| if(ptrIn > max - 2) break; // nicht mehr Daten verarbeiten, als empfangen wurden |
| x = (a << 2) | (b >> 4); |
| y = ((b & 0x0f) << 4) | (c >> 2); |
| z = ((c & 0x03) << 6) | d; |
| if(len--) ptrOut[ptr++] = x; else break; |
| if(len--) ptrOut[ptr++] = y; else break; |
| if(len--) ptrOut[ptr++] = z; else break; |
| } |
| } |
| // -------------------------------------------------------------------------- |
| void BearbeiteRxDaten(void) |
| { |
| if(!NeuerDatensatzEmpfangen) return; |
| unsigned int tmp_int_arr1[1]; |
| unsigned int tmp_int_arr2[2]; |
| unsigned int tmp_int_arr3[3]; |
| unsigned char tmp_char_arr2[2]; |
| unsigned char tmp_char_arr3[3]; |
| unsigned char tmp_char_arr4[4]; |
| //if(!MotorenEin) |
| PcZugriff = 255; |
| switch(RxdBuffer[2]) |
| { |
| case 'c':// Debugdaten incl. Externe IOs usw |
| Decode64((unsigned char *) &DebugIn,sizeof(DebugIn),3,AnzahlEmpfangsBytes); |
| /* for(unsigned char i=0; i<4;i++) |
| { |
| EE_CheckAndWrite(&EE_Buffer[EE_DEBUGWERTE + i*2], DebugIn.Analog[i]); |
| EE_CheckAndWrite(&EE_Buffer[EE_DEBUGWERTE + i*2 + 1], DebugIn.Analog[i] >> 8); |
| }*/ |
| RemoteTasten |= DebugIn.RemoteTasten; |
| DebugDataAnforderung = 1; |
| break; |
| case 'h':// x-1 Displayzeilen |
| Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes); |
| RemoteTasten |= tmp_char_arr2[0]; |
| DebugDisplayAnforderung = 1; |
| break; |
| case 't':// Motortest |
| Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes); |
| break; |
| case 'v': // Version-Anforderung und Ausbaustufe |
| GetVersionAnforderung = 1; |
| break; |
| case 'g':// "Get"-Anforderung für Debug-Daten |
| // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen |
| DebugGetAnforderung = 1; |
| break; |
| case 'q':// "Get"-Anforderung für Settings |
| // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen |
| Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes); |
| if(tmp_char_arr2[0] != 0xff) |
| { |
| if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5; |
| ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE); |
| SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE); |
| } |
| else |
| SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE); |
| break; |
| case 'l': |
| case 'm': |
| case 'n': |
| case 'o': |
| case 'p': // Parametersatz speichern |
| Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes); |
| WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE); |
| eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1); // aktiven Datensatz merken |
| Piep(GetActiveParamSetNumber()); |
| break; |
| } |
| // DebugOut.AnzahlZyklen = Debug_Timer_Intervall; |
| NeuerDatensatzEmpfangen = 0; |
| } |
| //############################################################################ |
| //Routine für die Serielle Ausgabe |
| int uart_putchar (char c) |
| //############################################################################ |
| { |
| if (c == '\n') |
| uart_putchar('\r'); |
| //Warten solange bis Zeichen gesendet wurde |
| loop_until_bit_is_set(USR, UDRE); |
| //Ausgabe des Zeichens |
| UDR = c; |
| return (0); |
| } |
| // -------------------------------------------------------------------------- |
| void WriteProgramData(unsigned int pos, unsigned char wert) |
| { |
| //if (ProgramLocation == IN_RAM) Buffer[pos] = wert; |
| // else eeprom_write_byte(&EE_Buffer[pos], wert); |
| // Buffer[pos] = wert; |
| } |
| //############################################################################ |
| //INstallation der Seriellen Schnittstelle |
| void UART_Init (void) |
| //############################################################################ |
| { |
| //Enable TXEN im Register UCR TX-Data Enable & RX Enable |
| UCR=(1 << TXEN) | (1 << RXEN); |
| // UART Double Speed (U2X) |
| USR |= (1<<U2X); |
| // RX-Interrupt Freigabe |
| UCSRB |= (1<<RXCIE); |
| // TX-Interrupt Freigabe |
| UCSRB |= (1<<TXCIE); |
| //Teiler wird gesetzt |
| UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1); |
| //UBRR = 33; |
| //öffnet einen Kanal für printf (STDOUT) |
| //fdevopen (uart_putchar, 0); |
| //sbi(PORTD,4); |
| Debug_Timer = SetDelay(200); |
| } |
| //--------------------------------------------------------------------------------------------- |
| void DatenUebertragung(void) |
| { |
| static char dis_zeile = 0; |
| if(!UebertragungAbgeschlossen) return; |
| if(DebugGetAnforderung && UebertragungAbgeschlossen) // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen |
| { |
| SendOutData('G',MeineSlaveAdresse,(unsigned char *) &DebugIn,sizeof(DebugIn)); |
| DebugGetAnforderung = 0; |
| } |
| if((CheckDelay(Debug_Timer) || DebugDataAnforderung) && UebertragungAbgeschlossen) |
| { |
| SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut)); |
| DebugDataAnforderung = 0; |
| Debug_Timer = SetDelay(MIN_DEBUG_INTERVALL); |
| } |
| if(DebugDisplayAnforderung && UebertragungAbgeschlossen) |
| { |
| Menu(); |
| DebugDisplayAnforderung = 0; |
| if(++dis_zeile == 4) dis_zeile = 0; |
| SendOutData('0' + dis_zeile,0,&DisplayBuff[20 * dis_zeile],20); // DisplayZeile übertragen |
| } |
| if(GetVersionAnforderung && UebertragungAbgeschlossen) |
| { |
| SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo)); |
| GetVersionAnforderung = 0; |
| } |
| } |
| /branches/salvo_gps/uart.h |
|---|
| 0,0 → 1,93 |
| #ifndef _UART_H |
| #define _UART_H |
| #define MAX_SENDE_BUFF 150 |
| #define MAX_EMPFANGS_BUFF 150 |
| extern unsigned char DebugGetAnforderung; |
| extern unsigned volatile char SendeBuffer[MAX_SENDE_BUFF]; |
| extern unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF]; |
| extern unsigned volatile char UebertragungAbgeschlossen; |
| extern unsigned volatile char PC_DebugTimeout; |
| extern unsigned volatile char NeueKoordinateEmpfangen; |
| extern unsigned char MeineSlaveAdresse; |
| extern unsigned char PcZugriff; |
| extern int Debug_Timer; |
| extern void UART_Init (void); |
| extern int uart_putchar (char c); |
| extern void boot_program_page (uint32_t page, uint8_t *buf); |
| extern void DatenUebertragung(void); |
| extern void DecodeNMEA(void); |
| extern unsigned char MotorTest[4]; |
| struct str_DebugOut |
| { |
| unsigned char Digital[13]; |
| unsigned int AnzahlZyklen; |
| unsigned int Zeit; |
| unsigned char Sekunden; |
| unsigned int Analog[16]; // Debugwerte |
| }; |
| extern struct str_DebugOut DebugOut; |
| struct str_Debug |
| { |
| unsigned char Digital[2]; |
| unsigned char RemoteTasten; |
| unsigned int Analog[4]; |
| }; |
| extern struct str_Debug DebugIn; |
| struct str_VersionInfo |
| { |
| unsigned char Hauptversion; |
| unsigned char Nebenversion; |
| unsigned char PCKompatibel; |
| unsigned char Rserved[7]; |
| }; |
| extern struct str_VersionInfo VersionInfo; |
| //Die Baud_Rate der Seriellen Schnittstelle ist 9600 Baud |
| //#define BAUD_RATE 9600 //Baud Rate für die Serielle Schnittstelle |
| //#define BAUD_RATE 14400 //Baud Rate für die Serielle Schnittstelle |
| //#define BAUD_RATE 28800 //Baud Rate für die Serielle Schnittstelle |
| //#define BAUD_RATE 38400 //Baud Rate für die Serielle Schnittstelle |
| #define BAUD_RATE 57600 //Baud Rate für die Serielle Schnittstelle |
| //Anpassen der seriellen Schnittstellen Register wenn ein ATMega128 benutzt wird |
| #if defined (__AVR_ATmega128__) |
| # define USR UCSR0A |
| # define UCR UCSR0B |
| # define UDR UDR0 |
| # define UBRR UBRR0L |
| # define EICR EICRB |
| #endif |
| #if defined (__AVR_ATmega32__) |
| # define USR UCSRA |
| # define UCR UCSRB |
| # define UBRR UBRRL |
| # define EICR EICRB |
| # define INT_VEC_RX SIG_UART_RECV |
| # define INT_VEC_TX SIG_UART_TRANS |
| #endif |
| #if defined (__AVR_ATmega644__) |
| # define USR UCSR0A |
| # define UCR UCSR0B |
| # define UDR UDR0 |
| # define UBRR UBRR0L |
| # define EICR EICR0B |
| # define TXEN TXEN0 |
| # define RXEN RXEN0 |
| # define RXCIE RXCIE0 |
| # define TXCIE TXCIE0 |
| # define U2X U2X0 |
| # define UCSRB UCSR0B |
| # define UDRE UDRE0 |
| # define INT_VEC_RX SIG_USART_RECV |
| # define INT_VEC_TX SIG_USART_TRANS |
| #endif |
| #endif //_UART_H |
| /branches/salvo_gps/version.txt |
|---|
| 0,0 → 1,49 |
| ------- |
| V0.53 27.04.2007 H.Buss |
| - erste öffentliche Version |
| V0.53b 29.04.2007 H.Buss |
| - der FAKTOR_I war versehentlich auf Null, dann liegt der MikroKopter nicht so hart in der Luft |
| V0.53c 29.04.2007 H.Buss |
| - es gib ein Menü, in dem die Werte der Kanäle nach Nick, Roll, Gas,... sortiert sind. |
| Die angezeigten Werte waren nicht die Werte der Funke |
| V0.54 01.05.2007 H.Buss |
| - die Paramtersätze können jetzt vor dem Start ausgewählt werden |
| Dazu wird beim Kalibrieren der Messwerte (Gashebel oben links) der Nick-Rollhebel abgefragt: |
| 2 3 4 |
| 1 x 5 |
| - - - |
| Bedeutet: Nick-Rollhebel Links Mitte = Setting:1 Links Oben = Setting:2 usw. |
| - der Faktor_I für den Hauptregler ist hinzugekommen. Im Heading-Hold-Modus sollte er vergössert werden, was Stabilität bringt |
| V0.55 14.05.2007 H.Buss |
| - es können nun Servos an J3,J4,J5 mit den Kanälen 5-7 gesteuert werden |
| V0.56 14.05.2007 H.Buss |
| - es gab Probleme mit Funken, die mehr als 8 Kanäle haben, wenn mehrere Kanäle dann auf Null waren |
| - Funken, die nicht bis +-120 aussteuern können, sollten jetzt auch gehen |
| V0.57 24.05.2007 H.Buss |
| - Der Höhenregler kann nun auch mittels Schalter bedient werden |
| - Bug im Gier-Algorithmus behoben; Schnelles Gieren fürhrte dazu, dass der MK zu weit gedreht hat |
| - Kompass-Einfluss dämpfen bei Neigung |
| - Man kann zwischen Kompass FIX (Richtung beim Kalibrieren) und Variabel (einstellbar per Gier) wählen |
| - Der Motortest vom Kopter-Tool geht jetzt |
| - Man kann den Parametersätzen einen Namen geben |
| - Das Kamerasetting ist unter Setting 2 defaultmässig integriert |
| V0.58 30.05.2007 H.Buss |
| - Der Höhenregler-Algorithmus wird nun umgangen, wenn der Höhenreglerschalter aus ist |
| V0.60 17.08.2007 H.Buss |
| - "Schwindel-Bug" behoben |
| - Die Poti-Werte werden jetzt auf Unterlauf (<0) überprüft |
| - Poti4 zugefügt |
| - Es werden jetzt 8 Kanäle ausgewertet |
| - Kamera-Servo (an J7) |
| - Die Settings müssen überschrieben werden |
| /branches/salvo_gps/. |
|---|
| Property changes: |
| Added: svn:ignore |
| +Flight-Ctrl_MEGA644_V0_60.map |
| +Flight-Ctrl_MEGA644_V0_60.sym |
| +Flight-Ctrl_MEGA644_V0_60.eep |
| +Flight-Ctrl_MEGA644_V0_60.elf |
| +Flight-Ctrl_MEGA644_V0_60.hex |
| +Flight-Ctrl_MEGA644_V0_60.lss |
| +*.map |
| +*.hex |
| +Flight-Ctrl_MEGA644_V0_06.elf |
| +Flight-Ctrl_MEGA644_V0_06.hex |
| +Flight-Ctrl_MEGA644_V0_06.lss |
| +Flight-Ctrl_MEGA644_V0_06.map |
| +Flight-Ctrl_MEGA644_V0_06.sym |
| +Flight-Ctrl_MEGA644_V0_06.eep |
| +*.chm |