Subversion Repositories FlightCtrl

Rev

Rev 2019 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2019 Rev 2052
1 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - 
 
2 
// + Copyright (c) 04.2007 Holger Buss
 - 
 
3 
// + Nur für den privaten Gebrauch
 - 
 
4 
// + www.MikroKopter.com
 - 
 
5 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - 
 
6 
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
 - 
 
7 
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
 - 
 
8 
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
 - 
 
9 
// + bzgl. der Nutzungsbedingungen aufzunehmen.
 - 
 
10 
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
 - 
 
11 
// + Verkauf von Luftbildaufnahmen, usw.
 - 
 
12 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - 
 
13 
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
 - 
 
14 
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
 - 
 
15 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - 
 
16 
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
 - 
 
17 
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
 - 
 
18 
// + eindeutig als Ursprung verlinkt werden
 - 
 
19 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - 
 
20 
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
 - 
 
21 
// + Benutzung auf eigene Gefahr
 - 
 
22 
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
 - 
 
23 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - 
 
24 
// + Die Portierung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
 - 
 
25 
// + mit unserer Zustimmung zulässig
 - 
 
26 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - 
 
27 
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
 - 
 
28 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - 
 
29 
// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
 - 
 
30 
// + this list of conditions and the following disclaimer.
 - 
 
31 
// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
 - 
 
32 
// +     from this software without specific prior written permission.
 - 
 
33 
// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permittet
 - 
 
34 
// +     for non-commercial use (directly or indirectly)
 - 
 
35 
// +     Commercial use (for example: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
 - 
 
36 
// +     with our written permission
 - 
 
37 
// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
 - 
 
38 
// +     clearly linked as origin
 - 
 
39 
// +   * porting to systems other than hardware from www.mikrokopter.de is not allowed
 - 
 
40 
// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 - 
 
41 
// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 - 
 
42 
// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 - 
 
43 
// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 - 
 
44 
// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 - 
 
45 
// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 - 
 
46 
// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 - 
 
47 
// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 - 
 
48 
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 - 
 
49 
// +  POSSIBILITY OF SUCH DAMAGE.
 - 
 
50 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - 
 
51 
#include <inttypes.h>
 1 
#include <inttypes.h>
52 
#include "output.h"
 2 
#include "output.h"
53 
#include "eeprom.h"
 3 
#include "eeprom.h"
54 
#include "timer0.h"
 4 
#include "timer0.h"
55 
// To access the DebugOut struct.
 - 
 
56 
#include "uart0.h"
 - 
 
57 
uint8_t flashCnt[2], flashMask[2];
 5 
uint8_t flashCnt[2], flashMask[2];
58 
// initializes the LED control outputs J16, J17
 - 
 
- 
 
 6 
 
59 
 
 7 
DebugOut_t debugOut;
60 
 
 8 
 
61 
void output_init(void) {
 9 
void output_init(void) {
62 
  // set PC2 & PC3 as output (control of J16 & J17)
 10 
  // set PC2 & PC3 as output (control of J16 & J17)
63 
  DDRC |= (1 << DDC2) | (1 << DDC3);
 11 
  DDRC |= (1 << DDC2) | (1 << DDC3);
64 
  outputSet(0,0);
 12 
  outputSet(0,0);
65 
  outputSet(1,0);
 13 
  outputSet(1,0);
66 
  flashCnt[0] = flashCnt[1] = 0;
 14 
  flashCnt[0] = flashCnt[1] = 0;
67 
  flashMask[0] = flashMask[1] = 128;
 15 
  flashMask[0] = flashMask[1] = 128;
68 
}
 16 
}
69 
 
 17 
 
70 
void outputSet(uint8_t num, uint8_t state) {
 18 
void outputSet(uint8_t num, uint8_t state) {
71 
  if (staticParams.outputFlags & (OUTPUTFLAGS_INVERT_0 << num)) {
 19 
  if (staticParams.outputFlags & (OUTPUTFLAGS_INVERT_0 << num)) {
72 
    if (state) OUTPUT_LOW(num) else OUTPUT_HIGH(num);
 20 
    if (state) OUTPUT_LOW(num) else OUTPUT_HIGH(num);
73 
  } else {
 21 
  } else {
74 
    if (state) OUTPUT_HIGH(num) else OUTPUT_LOW(num);
 22 
    if (state) OUTPUT_HIGH(num) else OUTPUT_LOW(num);
75 
  }
 23 
  }
76 
  if (staticParams.outputFlags & OUTPUTFLAGS_USE_ONBOARD_LEDS) {
 24 
  if (staticParams.outputFlags & OUTPUTFLAGS_USE_ONBOARD_LEDS) {
77 
    if (num) {
 25 
    if (num) {
78 
      if (state) GRN_ON else GRN_OFF;
 26 
      if (state) GRN_ON else GRN_OFF;
79 
    } else {
 27 
    } else {
80 
      if (state) RED_ON else RED_OFF;
 28 
      if (state) RED_ON else RED_OFF;
81 
    }
 29 
    }
82 
  }
 30 
  }
83 
}
 31 
}
84 
 
 32 
 
85 
void flashingLight(uint8_t port, uint8_t timing, uint8_t bitmask, uint8_t manual) {
 33 
void flashingLight(uint8_t port, uint8_t timing, uint8_t bitmask, uint8_t manual) {
86 
  if (timing > 250 && manual > 230) {
 34 
  if (timing > 250 && manual > 230) {
87 
    // "timing" is set to "manual (a variable)" and the value is very high --> Set to the value in bitmask bit 7.
 35 
    // "timing" is set to "manual (a variable)" and the value is very high --> Set to the value in bitmask bit 7.
88 
    outputSet(port, 1);
 36 
    outputSet(port, 1);
89 
  } else if (timing > 250 && manual < 10) {
 37 
  } else if (timing > 250 && manual < 10) {
90 
    // "timing" is set to "manual" (a variable) and the value is very low --> Set to the negated value in bitmask bit 7.
 38 
    // "timing" is set to "manual" (a variable) and the value is very low --> Set to the negated value in bitmask bit 7.
91 
    outputSet(port, 0);
 39 
    outputSet(port, 0);
92 
  } else if (!flashCnt[port]--) {
 40 
  } else if (!flashCnt[port]--) {
93 
    // rotating mask over bitmask...
 41 
    // rotating mask over bitmask...
94 
    flashCnt[port] = timing - 1;
 42 
    flashCnt[port] = timing - 1;
95 
    if (flashMask[port] == 1)
 43 
    if (flashMask[port] == 1)
96 
      flashMask[port] = 128;
 44 
      flashMask[port] = 128;
97 
    else
 45 
    else
98 
      flashMask[port] >>= 1;
 46 
      flashMask[port] >>= 1;
99 
    outputSet(port, flashMask[port] & bitmask);
 47 
    outputSet(port, flashMask[port] & bitmask);
100 
  }
 48 
  }
101 
}
 49 
}
102 
 
 50 
 
103 
void output_update(void) {
 51 
void output_update(void) {
104 
  static int8_t delay = 0;
 52 
  static int8_t delay = 0;
105 
  if (!delay--) { // 10 ms intervals
 53 
  if (!delay--) { // 10 ms intervals
106 
    delay = 4;
 54 
    delay = 4;
107 
  }
 55 
  }
108 
  if (staticParams.outputFlags & OUTPUTFLAGS_TEST_ON) {
 56 
  if (staticParams.outputFlags & OUTPUTFLAGS_TEST_ON) {
109 
    outputSet(0, 1);
 57 
    outputSet(0, 1);
110 
    outputSet(1, 1);
 58 
    outputSet(1, 1);
111 
  } else if (staticParams.outputFlags & OUTPUTFLAGS_TEST_OFF) {
 59 
  } else if (staticParams.outputFlags & OUTPUTFLAGS_TEST_OFF) {
112 
    outputSet(0, 0);
 60 
    outputSet(0, 0);
113 
    outputSet(1, 0);
 61 
    outputSet(1, 0);
114 
  } else {
 62 
  } else {
115 
    if (staticParams.outputFlags & OUTPUTFLAGS_FLASH_0_AT_BEEP && beepModulation != BEEP_MODULATION_NONE) {
 63 
    if (staticParams.outputFlags & OUTPUTFLAGS_FLASH_0_AT_BEEP && beepModulation != BEEP_MODULATION_NONE) {
116 
      flashingLight(0, 25, 0x55, 25);
 64 
      flashingLight(0, 25, 0x55, 25);
117 
    } else if (staticParams.outputDebugMask) {
 65 
    } else if (staticParams.outputDebugMask) {
118 
      outputSet(0, debugOut.digital[0] & staticParams.outputDebugMask);
 66 
      outputSet(0, debugOut.digital[0] & staticParams.outputDebugMask);
119 
    } else if (!delay) {
 67 
    } else if (!delay) {
120 
      flashingLight(0, staticParams.outputFlash[0].timing, staticParams.outputFlash[0].bitmask, dynamicParams.output0Timing);
 68 
      flashingLight(0, staticParams.outputFlash[0].timing, staticParams.outputFlash[0].bitmask, dynamicParams.output0Timing);
121 
    }
 69 
    }
122 
    if (staticParams.outputFlags & OUTPUTFLAGS_FLASH_1_AT_BEEP && beepModulation != BEEP_MODULATION_NONE) {
 70 
    if (staticParams.outputFlags & OUTPUTFLAGS_FLASH_1_AT_BEEP && beepModulation != BEEP_MODULATION_NONE) {
123 
      flashingLight(1, 25, 0x55, 25);
 71 
      flashingLight(1, 25, 0x55, 25);
124 
    } else if (staticParams.outputDebugMask) {
 72 
    } else if (staticParams.outputDebugMask) {
125 
      outputSet(1, debugOut.digital[1] & staticParams.outputDebugMask);
 73 
      outputSet(1, debugOut.digital[1] & staticParams.outputDebugMask);
126 
    } else if (!delay) {
 74 
    } else if (!delay) {
127 
      flashingLight(1, staticParams.outputFlash[1].timing, staticParams.outputFlash[1].bitmask, dynamicParams.output1Timing);
 75 
      flashingLight(1, staticParams.outputFlash[1].timing, staticParams.outputFlash[1].bitmask, dynamicParams.output1Timing);
128 
    }
 76 
    }
129 
  }
 77 
  }
130 
}
 78 
}
131 
 
 79 
 
132 
void beep(uint16_t millis) {
 80 
void beep(uint16_t millis) {
133 
  beepTime = millis;
 81 
  beepTime = millis;
134 
}
 82 
}
135 
 
 83 
 
136 
/*
 84 
/*
137 
 * Make [numbeeps] beeps.
 85 
 * Make [numbeeps] beeps.
138 
 */
 86 
 */
139 
void beepNumber(uint8_t numbeeps) {
 87 
void beepNumber(uint8_t numbeeps) {
140 
  while(numbeeps--) {
 88 
  while(numbeeps--) {
141 
    if(MKFlags & MKFLAG_MOTOR_RUN) return; //auf keinen Fall bei laufenden Motoren!
 89 
    if(MKFlags & MKFLAG_MOTOR_RUN) return; //auf keinen Fall bei laufenden Motoren!
142 
    beep(100); // 0.1 second
 90 
    beep(100); // 0.1 second
143 
    delay_ms(250); // blocks 250 ms as pause to next beep,
 91 
    delay_ms(250); // blocks 250 ms as pause to next beep,
144 
    // this will block the flight control loop,
 92 
    // this will block the flight control loop,
145 
    // therefore do not use this function if motors are running
 93 
    // therefore do not use this function if motors are running
146 
  }
 94 
  }
147 
}
 95 
}
148 
 
 96 
 
149 
/*
 97 
/*
150 
 * Beep the R/C alarm signal
 98 
 * Beep the R/C alarm signal
151 
 */
 99 
 */
152 
void beepRCAlarm(void) {
 100 
void beepRCAlarm(void) {
153 
  if(beepModulation == BEEP_MODULATION_NONE) { // If not already beeping an alarm signal (?)
 101 
  if(beepModulation == BEEP_MODULATION_NONE) { // If not already beeping an alarm signal (?)
154 
    beepTime = 15000; // 1.5 seconds
 102 
    beepTime = 15000; // 1.5 seconds
155 
    beepModulation = BEEP_MODULATION_RCALARM;
 103 
    beepModulation = BEEP_MODULATION_RCALARM;
156 
  }
 104 
  }
157 
}
 105 
}
158 
 
 106 
 
159 
/*
 107 
/*
160 
 * Beep the I2C bus error signal
 108 
 * Beep the I2C bus error signal
161 
 */
 109 
 */
162 
void beepI2CAlarm(void) {
 110 
void beepI2CAlarm(void) {
163 
  if((beepModulation == BEEP_MODULATION_NONE) && (MKFlags & MKFLAG_MOTOR_RUN)) {
 111 
  if((beepModulation == BEEP_MODULATION_NONE) && (MKFlags & MKFLAG_MOTOR_RUN)) {
164 
    beepTime = 10000; // 1 second
 112 
    beepTime = 10000; // 1 second
165 
    beepModulation = BEEP_MODULATION_I2CALARM;
 113 
    beepModulation = BEEP_MODULATION_I2CALARM;
166 
  }
 114 
  }
167 
}
 115 
}
168 
 
 116 
 
169 
/*
 117 
/*
170 
 * Beep the battery low alarm signal
 118 
 * Beep the battery low alarm signal
171 
 */
 119 
 */
172 
void beepBatteryAlarm(void) {
 120 
void beepBatteryAlarm(void) {
173 
  beepModulation = BEEP_MODULATION_BATTERYALARM;
 121 
  beepModulation = BEEP_MODULATION_BATTERYALARM;
174 
  if(!beepTime) {
 122 
  if(!beepTime) {
175 
    beepTime = 6000; // 0.6 seconds
 123 
    beepTime = 6000; // 0.6 seconds
176 
  }
 124 
  }
177 
}
 125 
}
178 
 
 126 
 
179 
/*
 127 
/*
180 
 * Beep the EEPROM checksum alarm
 128 
 * Beep the EEPROM checksum alarm
181 
 */
 129 
 */
182 
void beepEEPROMAlarm(void) {
 130 
void beepEEPROMAlarm(void) {
183 
  beepModulation = BEEP_MODULATION_EEPROMALARM;
 131 
  beepModulation = BEEP_MODULATION_EEPROMALARM;
184 
  if(!beepTime) {
 132 
  if(!beepTime) {
185 
    beepTime = 6000; // 0.6 seconds
 133 
    beepTime = 6000; // 0.6 seconds
186 
  }
 134 
  }
187 
}
 135 
}
188 
 
 136