Subversion Repositories Projects

Compare Revisions

Ignore whitespace Rev 95 → Rev 96

/OSD and Video Transmitter/License.txt
New file
0,0 → 1,52
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Copyright (c) 04.2007 Holger Buss (Flight Control Source)
// + Copyright (c0 12.2007 Gunter Logemann (serielle steuerung und serial tunnel im Flight Control Source sowie alle
// + MS Robotics Studio und Roboboard bezogenen Komponenten)
// + 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 und gunter@pccon.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 oder dei verwendung von SW Componenten fuer eigene komerzielle Projekte jeglicher art
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + 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. Fuer das Roboboard, das Video Overaly bzw. allem mit Robtics Service in
// + verbindungstehenden Komonenten muss der Autor Gunter Logemann incl. email (gunter@pccon.de) 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 Flight control Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
// + mit unserer Zustimmung zulässig. Fuer dei Software des Roboboards bedarf es einer Genemigung durch Gunter logemann (gunter@pccon.de)
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + die serielle Steuerung durch microsoft Robotics Studio, sowie die notwendigen erweiterungen in FC.c und uart.c unterliegt dem
// + copyright von Gunter Logemann (gunter@pccon.de)
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Das Video Overlay Board inclusive Hardware und Software unterliegt unterliegt dem
// + copyright von Gunter Logemann (gunter@pccon.de)
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + die serielle Steuerung von externen boards (Roboboard) an der 2. Seriellen schnittstelle, sowie die notwendigen erweiterungen in
// + FC.c und uart.c unterliegt unterliegt dem copyright von Gunter Logemann (gunter@pccon.de)
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + 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.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/OSD and Video Transmitter/overlay/Makefile
New file
0,0 → 1,90
PRG = main
OBJ = main.o \
MCU_TARGET = atmega88
OPTIMIZE = -O1
 
DEFS =
LIBS =
 
# You should not have to change anything below here.
 
CC = avr-gcc
 
# Override is only needed by avr-lib build system.
 
override CFLAGS = -g -Wall $(OPTIMIZE) -mmcu=$(MCU_TARGET) $(DEFS)
override LDFLAGS = -Wl,-Map,$(PRG).map
 
OBJCOPY = avr-objcopy
OBJDUMP = avr-objdump
 
all: $(PRG).elf lst text eeprom
 
$(PRG).elf: $(OBJ)
$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LIBS)
 
clean:
rm -rf *.o $(PRG).elf *.eps *.png *.pdf *.bak
rm -rf *.lst *.map $(EXTRA_CLEAN_FILES)
 
lst: $(PRG).lst
 
%.lst: %.elf
$(OBJDUMP) -h -S $< > $@
 
# Rules for building the .text rom images
 
text: hex bin srec
 
hex: $(PRG).hex
bin: $(PRG).bin
srec: $(PRG).srec
 
%.hex: %.elf
$(OBJCOPY) -j .text -j .data -O ihex $< $@
 
%.srec: %.elf
$(OBJCOPY) -j .text -j .data -O srec $< $@
 
%.bin: %.elf
$(OBJCOPY) -j .text -j .data -O binary $< $@
 
# Rules for building the .eeprom rom images
 
eeprom: ehex ebin esrec
 
ehex: $(PRG)_eeprom.hex
ebin: $(PRG)_eeprom.bin
esrec: $(PRG)_eeprom.srec
 
%_eeprom.hex: %.elf
$(OBJCOPY) -j .eeprom --change-section-lma .eeprom=0 -O ihex $< $@
 
%_eeprom.srec: %.elf
$(OBJCOPY) -j .eeprom --change-section-lma .eeprom=0 -O srec $< $@
 
%_eeprom.bin: %.elf
$(OBJCOPY) -j .eeprom --change-section-lma .eeprom=0 -O binary $< $@
 
# Every thing below here is used by avr-libc's build system and can be ignored
# by the casual user.
 
FIG2DEV = fig2dev
EXTRA_CLEAN_FILES = *.bin *.srec
 
dox: eps png pdf
 
eps: $(PRG).eps
png: $(PRG).png
pdf: $(PRG).pdf
 
%.eps: %.fig
$(FIG2DEV) -L eps $< $@
 
%.pdf: %.fig
$(FIG2DEV) -L pdf $< $@
 
%.png: %.fig
$(FIG2DEV) -L png $< $@
 
/OSD and Video Transmitter/overlay/MKvideooverlay.pnps
New file
0,0 → 1,0
<pd><ViewState><e p="MKvideooverlay" x="true"></e></ViewState></pd>
/OSD and Video Transmitter/overlay/main.srec
New file
0,0 → 1,332
S00C00006D61696E2E7372656373
S113000019C070C89CC831C030C02FC02EC02DC0CC
S11300102CC02BC02AC029C028C027C026C025C098
S113002024C023C022C021C020C01FC01EC01DC0C8
S11300301CC01BC011241FBECFEFD4E0DEBFCDBF58
S113004013E0A0E0B1E0E8EBF1E102C005900D920D
S1130050A83DB107D9F714E0A8EDB3E001C01D92A3
S1130060A43AB107E1F7F6D1A6C8CACFDC01141649
S1130070150664F4FB01E95CFE4F20E030E08D914D
S113008081932F5F3F4F42175307C9F70895E7E362
S1130090F1E08FE492E01192E817F907E1F708958F
S11300A0EF92FF921F93CF93DF93EC01162F6623F9
S11300B009F47BC0A4EFB3E0FD01E40FF11D50810E
S11300C0842F8F5FFD01E80FF11D30818F5FFD01EB
S11300D0E80FF11DE0818F5FA80FB11DAC914C5F5B
S11300E0822F99270F2EFEEFEF2EFFEFFF2EF02D1C
S11300F0E80EF91E842F9927E816F9060CF455C06A
S1130100852F8D533D535E2F5D53AD5320E064EF37
S113011073E020C0FB01E40FF11DB081842F8F5FD9
S1130120FB01E80FF11D30818F5FFB01E80FF11D2A
S113013050818F5FFB01E80FF11DA0814C5F842F7C
S11301409927E816F9068CF18B2F8D533D535D5397
S1130150AD532D5FFE01E20FF11D880F880F932F21
S113016092959F70892B80831130F9F0822F8F5FD5
S1130170FE01E80FF11D832F8295807F952F9695C0
S11301809695892B808313501F3F79F0822F8E5FC1
S1130190FE01E80FF11D852F8295880F880F807C62
S11301A08A2B8083112309F0B5CFDF91CF911F9162
S11301B0FF90EF9008958093E1035091E603543645
S11301C010F01092E5038091E1038D3009F05CC0DA
S11301D08091E503823009F057C01092E503652F42
S11301E07727FB01329724EF33E0E20FF31F4081BE
S11301F0CB010197DC01A20FB31F2C918091E9037D
S11302009091EA03841B9109821B91099F7090933A
S1130210EA038093E9039C010024220F331F001C8E
S1130220220F331F001C232F302D235C2093E8035F
S11302308F73382F335C3093E7038081281729F4B8
S11302408C91381711F491E009C08091E3038F5F1A
S11302508093E30385E48093590490E08091E20362
S1130260882309F07EC0992309F47BC081E0809340
S1130270E2035093E403FB01EC50FC4F8DE08083D8
S113028082E5809359046DC08091E503813031F19A
S1130290813020F0823009F05FC03EC08091E103DC
S11302A0833239F48091E203882319F481E0809346
S11302B0E5038091E1038093F40381E08093E603F6
S11302C08091E10399279093EA038093E90381E401
S11302D080935A0488E58093590443C082E0809354
S11302E0E5038091E103E4EFF3E0E50FF11D808382
S11302F0852F8F5F8093E6032091E1038091E903CA
S11303009091EA03820F911D9093EA038093E9038D
S113031082E480935A0425C08091E103E4EFF3E082
S1130320E50FF11D8083543628F4852F8F5F809369
S1130330E60302C01092E5038091E1032091E903F2
S11303403091EA03280F311D3093EA032093E90327
S113035083E480935A0405C01092E50384E48093F7
S11303605A0480910A01882321F481E080930A01D0
S1130370089510920A010895AF92BF92CF92DF922E
S1130380EF92FF920F931F93CF93DF93CDB7DEB716
S113039027970FB6F894DEBF0FBECDBF6C017B016B
S11303A0161617060CF045C080E090E09E012F5F02
S11303B03F4F60E3F901E80FF91F60830196E816E7
S11303C0F906C1F74115510519F187010150104093
S11303D05E010894A11CB11CFA01CA016AE070E034
S11303E0C3D6AB01D501A00FB11FCB01880F991F54
S11303F09B01220F331F220F331F220F331F820F43
S1130400931FE81BE05DEC9301501040672B21F72C
S113041020E030E0AE014F5F5F4FFA01E20FF31FBF
S11304208081F60181936F012F5F3F4FE216F3063F
S1130430A1F727960FB6F894DEBF0FBECDBFDF91AC
S1130440CF911F910F91FF90EF90DF90CF90BF90CD
S1130450AF900895AF92BF92CF92DF92FF920F9325
S11304601F93CF93DF931092000110920101E1E6F4
S1130470F0E080E88083108280E18BB91AB8109292
S1130480C00088E18093C10086E88093C200109286
S1130490C50085E18093C40014BC91E095BD15B8F6
S11304A08EE384B984E58CBD9DBD8AE080936900A8
S11304B083E08DBB8CBB10926800789488E58093B0
S11304C058048093590480935A0480935B04809366
S11304D05C0480935D041092E2031092DA03D7DD8A
S11304E045E150E06CE870E08BEB93E0BFDD81E028
S11304F080930001FF24F3940F2EFFEECF2EF3E040
S1130500DF2EF02D08E014E00F2EFBEBAF2EF3E00E
S1130510BF2EF02D8091C00088232CF4E6ECF0E08F
S11305208081808348DE8091DA03893118F4F09267
S1130530D90306C01092D903833310F01092DA0362
S11305408091E203882331F38091F603843409F027
S11305505FC12091E40343E062E482E694E0A0DD1D
S1130560409174045091750463E070E08CE091E074
S113057003DF20916E0430916F048091EB0390911E
S1130580EC038217930764F4F092DE031092DF0306
S1130590A901481B590B5093DD034093DC0317C09A
S11305A0281739075CF41092DE03F092DF03821BF4
S11305B0930B9093DD038093DC0309C01092DE0358
S11305C01092DF031092DD031092DC030CC08091C3
S11305D0DC039091DD03CD9730F08CE390E09093B1
S11305E0DD038093DC033093EC032093EB0333238C
S11305F05CF48DE280933001C901809590959093CD
S11306006F0480936E0403C08BE2809330014091A9
S11306106E0450916F0465E070E081E391E0ACDE1C
S1130620409176045091770465E070E0C601A4DE41
S11306308091F10380931B018091F20380931C014C
S11306408091F30380931E01809176049091770446
S11306508B35910534F0009310018036910524F414
S113066009C01093100106C000931101853691054D
S113067024F409C01093110106C0009312018A36B4
S1130680910524F409C01093120106C000931301CC
S11306908F36910524F409C01093130106C000930A
S11306A014018437910524F409C01093140106C081
S11306B0009315018937910524F409C0109315019D
S11306C006C0009316018E3791054CF4B4C0109304
S11306D01601109317018E35910524F006C000937E
S11306E0170103C0F092D80302C01092D8032091DE
S11306F078043091790484E690E0AC01249FC00131
S1130700259F900D349F900D11246FEF70E02CD530
S1130710EB01AB0165E070E0C6012EDE8091F103D0
S113072080932C018091F20380932D018091F30337
S113073080932E01CB30D10530F000932001C531D8
S1130740D10520F409C01093200106C000932101B3
S1130750CF31D10520F409C01093210106C00093C4
S11307602201C932D10520F409C01093220106C028
S113077000932301C333D10520F409C0109323014E
S113078006C000932401CD33D10520F409C0109391
S1130790240106C000932501C734D10520F409C003
S11307A01093250106C000932601C135D10520F41C
S11307B006C01093260103C00093270102C01093C2
S11307C02701809164049091650462E370E0E0D4B1
S11307D084E190E0EC01C61BD70BEAF0C632D105E8
S11307E014F555DCBE01660F771F660F771F660F81
S11307F0771F6C1B7D0B45E150E0C50137DC649726
S113080039F047E050E06CE870E080ED93E02EDCD6
S11308101092E2037FCE3BDC45E150E060E070E003
S1130820C50124DCEECF33DC45E150E063E071E048
S1130830C5011CDCE6CF1093170157CF4091ED039F
S11308405091EE03CA018497079708F003C1CA01C7
S113085082959295907F9827807F9827BC016F5549
S11308607F4FCA01880F991F880F991F880F991FFE
S1130870840F951F9C01285C3D4F86B5883CE8F3A6
S113088016BC81E08DBD209A80911001F901E80F1A
S1130890F11D80818EBD0DB407FEFDCF8091110145
S11308A0F901E80FF11D80818EBD0DB407FEFDCF67
S11308B080911201F901E80FF11D80818EBD0DB404
S11308C007FEFDCF80911301F901E80FF11D80812E
S11308D08EBD0DB407FEFDCF80911401F901E80F20
S11308E0F11D80818EBD0DB407FEFDCF80911501F1
S11308F0F901E80FF11D80818EBD0DB407FEFDCF17
S113090080911601F901E80FF11D80818EBD0DB4AF
S113091007FEFDCF80911701F901E80FF11D8081D9
S11309208EBD0DB407FEFDCF209816BC86B580356C
S1130930E8F316BC1DBC209A80910B01F901E80F65
S1130940F11D80818EBD0DB407FEFDCF80910C0199
S1130950FB01E80FF11D80818EBD0DB407FEFDCFB4
S113096080910D01FB01E80FF11D80818EBD0DB456
S113097007FEFDCF80910E01FB01E80FF11D808180
S11309808EBD0DB407FEFDCF80910F01F901E80F74
S1130990F11D80818EBD0DB407FEFDCF209886B574
S11309A08A3FE8F316BC86B58634E8F381E08DBD52
S11309B0209A80912001F901E80FF11D80818EBDFC
S11309C00DB407FEFDCF80912101F901E80FF11D5F
S11309D080818EBD0DB407FEFDCF80912201F90107
S11309E0E80FF11D80818EBD0DB407FEFDCF80910F
S11309F02301F901E80FF11D80818EBD0DB407FEBE
S1130A00FDCF80912401F901E80FF11D80818EBD95
S1130A100DB407FEFDCF80912501F901E80FF11D0A
S1130A2080818EBD0DB407FEFDCF80912601F901B2
S1130A30E80FF11D80818EBD0DB407FEFDCF8091BE
S1130A402701F901E80FF11D80818EBD0DB407FE69
S1130A50FDCF2098CA018D97079708F0D4C0CA012A
S1130A60880F991F840F951F9C01220F331F220F9B
S1130A70331F220F331F820F931FBC01605B724030
S1130A80CA0182959295907F9827807F98279C0130
S1130A902F5E3F4F86B5883CE8F316BC81E08DBDE0
S1130AA0209A80911801FB01E80FF11D80818EBD11
S1130AB00DB407FEFDCF80911901F901E80FF11D76
S1130AC080818EBD0DB407FEFDCF80911A01FB011C
S1130AD0E80FF11D80818EBD0DB407FEFDCF80911E
S1130AE01B01F901E80FF11D80818EBD0DB407FED5
S1130AF0FDCF80911C01F901E80FF11D80818EBDAD
S1130B000DB407FEFDCF80911D01F901E80FF11D21
S1130B1080818EBD0DB407FEFDCF80911E01F901C9
S1130B20E80FF11D80818EBD0DB407FEFDCF8091CD
S1130B301F01FB01E80FF11D80818EBD0DB407FE7E
S1130B40FDCF209816BC86B58035E8F316BC86B573
S1130B508A3FE8F316BC86B58634E8F316BC81E018
S1130B608DBD209A80912801FB01E80FF11D808141
S1130B708EBD0DB407FEFDCF80912901FB01E80F66
S1130B80F11D80818EBD0DB407FEFDCF80912A0139
S1130B90F901E80FF11D80818EBD0DB407FEFDCF74
S1130BA080912B01FB01E80FF11D80818EBD0DB4F6
S1130BB007FEFDCF80912C01F901E80FF11D808122
S1130BC08EBD0DB407FEFDCF80912D01F901E80F14
S1130BD0F11D80818EBD0DB407FEFDCF80912E01E5
S1130BE0F901E80FF11D80818EBD0DB407FEFDCF24
S1130BF080912F01F901E80FF11D80818EBD0DB4A4
S1130C0007FEFDCF2098CA01CD97079708F09CC036
S1130C108091D903882309F497C08091D80388234D
S1130C2009F492C0CA01880F991F840F951F9C0173
S1130C30220F331F220F331F220F331F820F931FE4
S1130C409C012056344086B5883CE8F316BC86B532
S1130C508A3FE8F381E08DBDF901E05CFF4F8081BC
S1130C608EBD0DB407FEFDCFF901E05CFF4F80811E
S1130C708EBD0DB407FEFDCFF901E45BFF4F80810B
S1130C808EBD0DB407FEFDCFF901E15BFF4F8081FE
S1130C908EBD0DB407FEFDCFF901E95AFF4F8081E7
S1130CA08EBD0DB407FEFDCFF901E05CFF4F8081DE
S1130CB08EBD0DB407FEFDCFF901EE5BFF4F8081C1
S1130CC08EBD0DB407FEFDCFF901EF5BFF4F8081B0
S1130CD08EBD0DB407FEFDCFF901EC5AFF4F8081A4
S1130CE08EBD0DB407FEFDCFF901EC5AFF4F808194
S1130CF08EBD0DB407FEFDCFF901EB5BFF4F808184
S1130D008EBD0DB407FEFDCFF901EE5AFF4F808171
S1130D108EBD0DB407FEFDCFF901E75AFF4F808168
S1130D208EBD0DB407FEFDCFF901E05CFF4F80815D
S1130D308EBD0DB407FEFDCFF901E05CFF4F80814D
S1130D408EBD0DB407FEFDCFCA0181559040893A8E
S1130D50910520F486B5883CE8F316BCCA018B5A89
S1130D609040079708F04DC0CA0182959295907FF4
S1130D709827807F98279C012F5C374086B58A305E
S1130D80E8F381E08DBD209A80913001F901E80FEC
S1130D90F11D80818EBD0DB407FEFDCF8091310120
S1130DA0F901E80FF11D80818EBD0DB407FEFDCF62
S1130DB080913201F901E80FF11D80818EBD0DB4DF
S1130DC007FEFDCF80913301F901E80FF11D808109
S1130DD08EBD0DB407FEFDCF80913401F901E80FFB
S1130DE0F11D80818EBD0DB407FEFDCF80913501CC
S1130DF0F901E80FF11D80818EBD0DB407FEFDCF12
S1130E002098443B5105B0F08091DC039091DD03C0
S1130E108D549F4F4817590768F48091DF03882346
S1130E2049F086B58233E8F3809136018EBD0DB466
S1130E3007FEFDCF4091ED035091EE032091DC03BA
S1130E403091DD0389EA90E0821B930B84179507A8
S1130E5080F4493A510568F48091DE03882349F00F
S1130E6086B58233E8F3809136018EBD0DB407FE5A
S1130E70FDCF0000CA018B5590408F39910508F0D1
S1130E8084C080910001813009F07FC086B58A3F1B
S1130E90E8F316BCCA018A559040969587959695B5
S1130EA08795FC01EE0FFF1FEE0FFF1FEE0FFF1FD4
S1130EB0E81BF90B87E391E0DF01A80FB91F4C9100
S1130EC03196DF01A80FB91F3C913196DF01A80FBD
S1130ED0B91F5C913196DF01A80FB91F6C9131964F
S1130EE0DF01A80FB91FAC913196E80FF91F70818B
S1130EF0918186B58431E8F380910101882311F44E
S1130F0020E002C0209A20E0842F880F880F84708C
S1130F1085B946952F5F2830B9F7832F880F880F3E
S1130F20847085B936952F5F2031B9F7852F880FE6
S1130F30880F847085B956952F5F2831B9F7862FAD
S1130F40880F880F847085B966952F5F2032B9F7B2
S1130F508A2F880F880F847085B9A6952F5F283251
S1130F60B9F7872F880F880F847085B976952F5F1E
S1130F702033B9F7892F880F880F847085B9969527
S1130F802F5F2833B9F715B820982091ED033091DD
S1130F90EE03C9018D529140079708F0A2C081E089
S1130FA08DBDC901880F991F820F931F9C01220FC9
S1130FB0331F220F331F220F331F820F931F9C01F5
S1130FC0205B3D4186B5883CE8F3F901ED5BFF4FBA
S1130FD080818EBD0DB407FEFDCFF901E05CFF4FAB
S1130FE080818EBD0DB407FEFDCFF901E95BFF4F93
S1130FF080818EBD0DB407FEFDCFF901EB5AFF4F82
S113100080818EBD0DB407FEFDCFF901E25BFF4F79
S113101080818EBD0DB407FEFDCFF901EC5AFF4F60
S113102080818EBD0DB407FEFDCFF901EB5BFF4F50
S113103080818EBD0DB407FEFDCFF901EE5AFF4F3E
S113104080818EBD0DB407FEFDCFF901E05CFF4F3A
S113105080818EBD0DB407FEFDCFF901E45BFF4F27
S113106080818EBD0DB407FEFDCFF901E15BFF4F1A
S113107080818EBD0DB407FEFDCFF901E95BFF4F02
S113108080818EBD0DB407FEFDCFF901EB5BFF4FF0
S113109080818EBD0DB407FEFDCFF901E35BFF4FE8
S11310A080818EBD0DB407FEFDCFF901EF5BFF4FCC
S11310B080818EBD0DB407FEFDCFF901E25BFF4FC9
S11310C080818EBD0DB407FEFDCFF901E25BFF4FB9
S11310D080818EBD0DB407FEFDCF16BC86B582306F
S11310E0E8F308951F920F920FB60F9211242F93D5
S11310F03F934F935F936F937F938F939F93AF939C
S1131100BF93EF93FF9316BC8091ED039091EE0390
S113111001969093EE038093ED0390DBFF91EF91A2
S1131120BF91AF919F918F917F916F915F914F91FB
S11311303F912F910F900FBE0F901F9018951F9203
S11311400F920FB60F9211248F931092EE03109208
S1131150ED038091DA038F5F8093DA038F910F9010
S11311600FBE0F901F901895AA1BBB1B51E107C01F
S1131170AA1FBB1FA617B70710F0A61BB70B881F23
S1131180991F5A95A9F780959095BC01CD010895B2
S113119097FB092E07260AD077FD04D0E5DF06D099
S11311A000201AF4709561957F4F0895F6F7909595
S10B11B081959F4F0895FFCFC4
S11311B8010154584401405258440102303030036C
S11311C80808080808080808553A4030302E3056F0
S11311D8080808080808080852583A403130302FDF
S11311E82B3030303030FE000000000000000000DA
S11311F800000000000000000000000000000000E3
S1131208000000005500FF00FF0000FF00FF00FF82
S11312180000FF00FF00FF0000FF00FF00FF0000C8
S1131228FF00FF00FF0000FF00FF00FF0000FF00B9
S1131238FF00FF0000FF00FF00FF0000FF00FF00A9
S1131248FF0000FF00FF00FF0000FF00FF00FF0099
S113125800FF00FF00FF00FF00FF00FF00FFFF008A
S1131268FF00FF00FFFF00FF00FF00FFFF00FF007B
S1131278FF00FFFF00FF00FF00FFFF00FF00FF006B
S1131288FFFF00FF00FF00FFFF00FF00FF00FFFF5C
S113129800FF00FF00FFFF00FF00FF00FFFF00FF4B
S11312A800FF00FFFF00FF00FF00FFFF00FF00FF3B
S11312B800FFFF00FF00FF00FFFF00FF00FF00FF2B
S11312C8FF00FF00FF00FFFF00FF00FF00FFFF001B
S11312D8FF00FF00FFFF00FF00FF00FFFF00FF000B
S11312E8FF00FFFF00FF00FF0055FF00FF00FF00A5
S11312F8AAFF00FF00FF0055FF00FF00FF00AA003F
S1131308187C3C787E7E3C427C7E424082823C7CD7
S11313183C7C3C7C4242828282FE0024424244401D
S113132840424210084440C6C2424242424210422D
S11313384282444404004242404240404042100831
S11313484840AAA2424242424010424292282808F7
S113135800427C40427C7C4E7E100870409292424F
S11313687C427C3C10422492101010007E42404281
S11313784040424210084840828A42404C48021089
S113138842249228102000424242444040424210E3
S113139848447E828642404644421042246C4410AB
S11313A84000427C3C787E403C427C30427E8282D3
S11313B83C4032423C103C186C8210FE0000000095
S11313C8307C107C7C1CFE7CFE7C7C0010000000C1
S11313D844823082822480800282821010000000BD
S11313E84482100202448080048282007C007C00D3
S11313F83082100C1C847CFC087C7E0010180000D1
S11314080082103002FE02821082040010180018B4
S113141800821040820482821082081000000018A2
S1131428007C38FE7C047C7C107C3000FEFE183086
S11314380080A0A8AAFE8238380080A0A8AAFE824C
S1131448783C0080A0A8AAFE82FEFE0080A0A8AA7C
S1131458FE827E3C0080A0A8AAFE8238380080A0C4
S1131468A8AAFEFE18300080A0A8AA000000180050
S11314780000FFFFFF24FFFFFF000000180000002A
S10B1488AAAAAAFF555555005C
S9030000FC
/OSD and Video Transmitter/overlay/main.map
New file
0,0 → 1,418
Archive member included because of file (symbol)
 
c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_udivmodhi4.o)
main.o (__udivmodhi4)
c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_divmodhi4.o)
main.o (__divmodhi4)
c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_exit.o)
c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr4/crtm88.o (exit)
c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_copy_data.o)
main.o (__do_copy_data)
c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_clear_bss.o)
main.o (__do_clear_bss)
 
Allocating common symbols
Common symbol size file
 
old_alt 0x2 main.o
line 0x2 main.o
templine 0x5 main.o
RxdBuffer 0x64 main.o
display_line1 0xa main.o
DebugOut 0x42 main.o
 
Discarded input sections
 
.stabstr 0x00000000 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr4/crtm88.o
 
Memory Configuration
 
Name Origin Length Attributes
text 0x00000000 0x00002000 xr
data 0x00800060 0x0000ffa0 rw !x
eeprom 0x00810000 0x00010000 rw !x
*default* 0x00000000 0xffffffff
 
Linker script and memory map
 
Address of section .data set to 0x800100
LOAD c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr4/crtm88.o
LOAD main.o
LOAD c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a
LOAD c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr4\libc.a
LOAD c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a
 
.hash
*(.hash)
 
.dynsym
*(.dynsym)
 
.dynstr
*(.dynstr)
 
.gnu.version
*(.gnu.version)
 
.gnu.version_d
*(.gnu.version_d)
 
.gnu.version_r
*(.gnu.version_r)
 
.rel.init
*(.rel.init)
 
.rela.init
*(.rela.init)
 
.rel.text
*(.rel.text)
*(.rel.text.*)
*(.rel.gnu.linkonce.t*)
 
.rela.text
*(.rela.text)
*(.rela.text.*)
*(.rela.gnu.linkonce.t*)
 
.rel.fini
*(.rel.fini)
 
.rela.fini
*(.rela.fini)
 
.rel.rodata
*(.rel.rodata)
*(.rel.rodata.*)
*(.rel.gnu.linkonce.r*)
 
.rela.rodata
*(.rela.rodata)
*(.rela.rodata.*)
*(.rela.gnu.linkonce.r*)
 
.rel.data
*(.rel.data)
*(.rel.data.*)
*(.rel.gnu.linkonce.d*)
 
.rela.data
*(.rela.data)
*(.rela.data.*)
*(.rela.gnu.linkonce.d*)
 
.rel.ctors
*(.rel.ctors)
 
.rela.ctors
*(.rela.ctors)
 
.rel.dtors
*(.rel.dtors)
 
.rela.dtors
*(.rela.dtors)
 
.rel.got
*(.rel.got)
 
.rela.got
*(.rela.got)
 
.rel.bss
*(.rel.bss)
 
.rela.bss
*(.rela.bss)
 
.rel.plt
*(.rel.plt)
 
.rela.plt
*(.rela.plt)
 
.text 0x00000000 0x11b8
*(.vectors)
.vectors 0x00000000 0x34 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr4/crtm88.o
0x00000000 __vectors
0x00000000 __vector_default
*(.vectors)
*(.progmem.gcc*)
*(.progmem*)
0x00000034 . = ALIGN (0x2)
0x00000034 __trampolines_start = .
*(.trampolines)
.trampolines 0x00000034 0x0 linker stubs
*(.trampolines*)
0x00000034 __trampolines_end = .
*(.jumptables)
*(.jumptables*)
*(.lowtext)
*(.lowtext*)
0x00000034 __ctors_start = .
*(.ctors)
0x00000034 __ctors_end = .
0x00000034 __dtors_start = .
*(.dtors)
0x00000034 __dtors_end = .
SORT(*)(.ctors)
SORT(*)(.dtors)
*(.init0)
.init0 0x00000034 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr4/crtm88.o
0x00000034 __init
*(.init0)
*(.init1)
*(.init1)
*(.init2)
.init2 0x00000034 0xc c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr4/crtm88.o
*(.init2)
*(.init3)
*(.init3)
*(.init4)
.init4 0x00000040 0x16 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_copy_data.o)
0x00000040 __do_copy_data
.init4 0x00000056 0x10 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_clear_bss.o)
0x00000056 __do_clear_bss
*(.init4)
*(.init5)
*(.init5)
*(.init6)
*(.init6)
*(.init7)
*(.init7)
*(.init8)
*(.init8)
*(.init9)
.init9 0x00000066 0x4 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr4/crtm88.o
*(.init9)
*(.text)
.text 0x0000006a 0x2 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr4/crtm88.o
0x0000006a __vector_22
0x0000006a __vector_24
0x0000006a __vector_12
0x0000006a __bad_interrupt
0x0000006a __vector_6
0x0000006a __vector_3
0x0000006a __vector_23
0x0000006a __vector_25
0x0000006a __vector_11
0x0000006a __vector_13
0x0000006a __vector_17
0x0000006a __vector_19
0x0000006a __vector_7
0x0000006a __vector_5
0x0000006a __vector_4
0x0000006a __vector_9
0x0000006a __vector_21
0x0000006a __vector_15
0x0000006a __vector_8
0x0000006a __vector_14
0x0000006a __vector_10
0x0000006a __vector_16
0x0000006a __vector_18
0x0000006a __vector_20
.text 0x0000006c 0x10fc main.o
0x000010e4 __vector_1
0x0000083c draw_line
0x0000008e GR_Clear
0x0000006c GR_Copy
0x000001b6 process_rxdata
0x00000378 convert_uint16
0x00000454 main
0x0000113e __vector_2
0x000000a0 Decode64
.text 0x00001168 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_udivmodhi4.o)
.text 0x00001168 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_divmodhi4.o)
.text 0x00001168 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_exit.o)
.text 0x00001168 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_copy_data.o)
.text 0x00001168 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_clear_bss.o)
0x00001168 . = ALIGN (0x2)
*(.text.*)
.text.libgcc 0x00001168 0x28 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_udivmodhi4.o)
0x00001168 __udivmodhi4
.text.libgcc 0x00001190 0x26 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_divmodhi4.o)
0x00001190 __divmodhi4
0x00001190 _div
.text.libgcc 0x000011b6 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_exit.o)
.text.libgcc 0x000011b6 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_copy_data.o)
.text.libgcc 0x000011b6 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_clear_bss.o)
0x000011b6 . = ALIGN (0x2)
*(.fini9)
.fini9 0x000011b6 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_exit.o)
0x000011b6 exit
0x000011b6 _exit
*(.fini9)
*(.fini8)
*(.fini8)
*(.fini7)
*(.fini7)
*(.fini6)
*(.fini6)
*(.fini5)
*(.fini5)
*(.fini4)
*(.fini4)
*(.fini3)
*(.fini3)
*(.fini2)
*(.fini2)
*(.fini1)
*(.fini1)
*(.fini0)
.fini0 0x000011b6 0x2 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_exit.o)
*(.fini0)
0x000011b8 _etext = .
 
.data 0x00800100 0x2d8 load address 0x000011b8
0x00800100 PROVIDE (__data_start, .)
*(.data)
.data 0x00800100 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr4/crtm88.o
.data 0x00800100 0x2d7 main.o
0x00800118 ubat
0x00800137 dmem
0x00800120 rx
0x00800101 showgraphicb
0x00800102 rxtx
0x00800136 bar1
0x00800128 urx
0x00800100 showgraphic
0x00800110 bat
0x00800130 altv
0x0080010b heading
.data 0x008003d7 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_udivmodhi4.o)
.data 0x008003d7 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_divmodhi4.o)
.data 0x008003d7 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_exit.o)
.data 0x008003d7 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_copy_data.o)
.data 0x008003d7 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_clear_bss.o)
*(.data*)
*(.rodata)
*(.rodata*)
*(.gnu.linkonce.d*)
0x008003d8 . = ALIGN (0x2)
*fill* 0x008003d7 0x1 00
0x008003d8 _edata = .
0x008003d8 PROVIDE (__data_end, .)
 
.bss 0x008003d8 0xcc
0x008003d8 PROVIDE (__bss_start, .)
*(.bss)
.bss 0x008003d8 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr4/crtm88.o
.bss 0x008003d8 0x13 main.o
0x008003e1 SioTmp
0x008003df alt_dec
0x008003db bar0
0x008003d9 showmessage1
0x008003dc alt_delta
0x008003e2 NeuerDatensatzEmpfangen
0x008003e0 mode
0x008003e3 CntCrcError
0x008003da framecounter
0x008003d8 lowbat
0x008003de alt_inc
0x008003e4 AnzahlEmpfangsBytes
.bss 0x008003eb 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_udivmodhi4.o)
.bss 0x008003eb 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_divmodhi4.o)
.bss 0x008003eb 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_exit.o)
.bss 0x008003eb 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_copy_data.o)
.bss 0x008003eb 0x0 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/avr4\libgcc.a(_clear_bss.o)
*(.bss*)
*(COMMON)
COMMON 0x008003eb 0xb9 main.o
0x008003eb old_alt
0x008003ed line
0x008003ef templine
0x008003f4 RxdBuffer
0x00800458 display_line1
0x00800462 DebugOut
0x008004a4 PROVIDE (__bss_end, .)
0x000011b8 __data_load_start = LOADADDR (.data)
0x00001490 __data_load_end = (__data_load_start + SIZEOF (.data))
 
.noinit 0x008004a4 0x0
0x008004a4 PROVIDE (__noinit_start, .)
*(.noinit*)
0x008004a4 PROVIDE (__noinit_end, .)
0x008004a4 _end = .
0x008004a4 PROVIDE (__heap_start, .)
 
.eeprom 0x00810000 0x0
*(.eeprom*)
0x00810000 __eeprom_end = .
 
.stab 0x00000000 0x378
*(.stab)
.stab 0x00000000 0x378 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr4/crtm88.o
 
.stabstr 0x00000000 0x71
*(.stabstr)
.stabstr 0x00000000 0x71 c:/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr4/crtm88.o
 
.stab.excl
*(.stab.excl)
 
.stab.exclstr
*(.stab.exclstr)
 
.stab.index
*(.stab.index)
 
.stab.indexstr
*(.stab.indexstr)
 
.comment
*(.comment)
 
.debug
*(.debug)
 
.line
*(.line)
 
.debug_srcinfo
*(.debug_srcinfo)
 
.debug_sfnames
*(.debug_sfnames)
 
.debug_aranges 0x00000000 0x20
*(.debug_aranges)
.debug_aranges
0x00000000 0x20 main.o
 
.debug_pubnames
0x00000000 0x207
*(.debug_pubnames)
.debug_pubnames
0x00000000 0x207 main.o
 
.debug_info 0x00000000 0x7c7
*(.debug_info)
.debug_info 0x00000000 0x7c7 main.o
*(.gnu.linkonce.wi.*)
 
.debug_abbrev 0x00000000 0x20c
*(.debug_abbrev)
.debug_abbrev 0x00000000 0x20c main.o
 
.debug_line 0x00000000 0xd5d
*(.debug_line)
.debug_line 0x00000000 0xd5d main.o
 
.debug_frame 0x00000000 0xa0
*(.debug_frame)
.debug_frame 0x00000000 0xa0 main.o
 
.debug_str 0x00000000 0x287
*(.debug_str)
.debug_str 0x00000000 0x287 main.o
0x2d4 (size before relaxing)
 
.debug_loc 0x00000000 0x453
*(.debug_loc)
.debug_loc 0x00000000 0x453 main.o
 
.debug_macinfo
*(.debug_macinfo)
OUTPUT(main.elf elf32-avr)
LOAD linker stubs
/OSD and Video Transmitter/overlay/Main.c
New file
0,0 → 1,929
/*****************************************************************************
Project : Video Overlay for RC Planes
Date : 1/14/2007
Author : Gunter Logemann (C) ALL RIGHTS RESERVED
 
Comments:
This project is optimized to work with the Mikrocopter (www.mikrokopter.de)
Many Thanks to Gary Dion who created the first basic implementation
Data communication decoder and encoder functions are taken from the
mikrokopter (www.mikrokopter.de) project.
 
Redistributions of this source code (with or without modifications) or parts
of this sourcode 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 source code permittet for non-commercial use (directly
or indirectly) only.
* Commercial use Is only permitted with our written permission by
Gunter Logemann (gunter@pccon.de)
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.
 
Chip type : ATmega88
Program type : Application
Clock frequency : 20,000000 MHz
*****************************************************************************/
 
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <avr/io.h>
#include "Main.h"
 
#define CPUSPEED_20
//#define CPUSPEED_16
//#define CPUSPEED_11059
 
// Macros
#define WatchdogReset() asm("wdr")
#define Wait() while(!(SPSR & (1<<SPIF)))
 
// Define CPU speed dependant constants:
#ifdef CPUSPEED_20
#define LINESTART 200
#define COPYRIGHTSTART 0
#define HEADINGSTART 200
#endif
 
#ifdef CPUSPEED_16
#define LINESTART 150
#define COPYRIGHTSTART 0
#define HEADINGSTART 200
#endif
 
#ifdef CPUSPEED_11059
#define LINESTART 130
#define COPYRIGHTSTART 0
#endif
 
// Static functions and variables
unsigned int line; // current line to be drawed
unsigned char lowbat = 0;
unsigned char showmessage1 = 0;
unsigned char framecounter = 0;
unsigned char showgraphic = 1;
unsigned char showgraphicb = 1;
 
static unsigned char head[17] = {'C','@','G','U','N','T','E','R','@','L','O','G','E','M','A','N','N'};
static unsigned char Message_LowBat[15] = {'@','@','L','O','W','@','B','A','T','T','E','R','Y','@','@'};
unsigned char rxtx[ 9] = {'T','X','D',0x01,'@','R','X','D',0x01};
unsigned char heading[5] = { 0x02, '0', '0', '0',0x03};
unsigned char bat[8] = { 0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08};
unsigned char ubat[8] = { 'U', ':', '@', '0', '0', '.', '0', 'V'};
unsigned char rx[8] = { 0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08};
unsigned char urx[8] = { 'R', 'X', ':', '@', '1', '0', '0', '/'};
unsigned char altv[6] = { '+','0', '0', '0', '0', '0'};
unsigned char bar0 = 0x00;
unsigned char bar1 = 0xfe;
 
int old_alt;
unsigned int alt_delta = 0;
char alt_inc = 0;
char alt_dec = 0;
 
// define Graphic Area (56x40 pixel)
#define GR_MaxGraph 280
#define GR_BytePerLine 7
#define GR_Lines 40
unsigned char dmem[280] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x55,0x00,0xff,0x00,0xff,0x00,
0x00,0xff,0x00,0xff,0x00,0xff,0x00,
0x00,0xff,0x00,0xff,0x00,0xff,0x00,
0x00,0xff,0x00,0xff,0x00,0xff,0x00,
0x00,0xff,0x00,0xff,0x00,0xff,0x00,
0x00,0xff,0x00,0xff,0x00,0xff,0x00,
0x00,0xff,0x00,0xff,0x00,0xff,0x00,
0x00,0xff,0x00,0xff,0x00,0xff,0x00,
0x00,0xff,0x00,0xff,0x00,0xff,0x00,
0x00,0xff,0x00,0xff,0x00,0xff,0x00,
0x00,0xff,0x00,0xff,0x00,0xff,0x00,
0x00,0xff,0x00,0xff,0x00,0xff,0x00,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
 
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
0xff,0x00,0xff,0x00,0xff,0x00,0xff,
 
0xff,0x00,0xff,0x00,0xff,0x00,0x55,
0xff,0x00,0xff,0x00,0xff,0x00,0xAA,
0xff,0x00,0xff,0x00,0xff,0x00,0x55,
0xff,0x00,0xff,0x00,0xff,0x00,0xAA,
};
 
// ' ' A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
 
static unsigned char ltrs[189] = { 0, 24,124, 60,120,126,126, 60, 66,124,126, 66, 64,130,130, 60,124, 60,124, 60,124, 66, 66,130,130,130,254,
0, 36, 66, 66, 68, 64, 64, 66, 66, 16, 8, 68, 64,198,194, 66, 66, 66, 66, 66, 16, 66, 66,130, 68, 68, 4,
0, 66, 66, 64, 66, 64, 64, 64, 66, 16, 8, 72, 64,170,162, 66, 66, 66, 66, 64, 16, 66, 66,146, 40, 40, 8,
0, 66,124, 64, 66,124,124, 78,126, 16, 8,112, 64,146,146, 66,124, 66,124, 60, 16, 66, 36,146, 16, 16, 16,
0,126, 66, 64, 66, 64, 64, 66, 66, 16, 8, 72, 64,130,138, 66, 64, 76, 72, 2, 16, 66, 36,146, 40, 16, 32,
0, 66, 66, 66, 68, 64, 64, 66, 66, 16, 72, 68,126,130,134, 66, 64, 70, 68, 66, 16, 66, 36,108, 68, 16, 64,
0, 66,124, 60,120,126, 64, 60, 66,124, 48, 66,126,130,130, 60, 64, 50, 66, 60, 16, 60, 24,108,130, 16,254};
 
// + , - . / 0 1 2 3 4 5 6 7 8 9 :
static unsigned char nums[112] = { 0, 0, 0, 0, 48,124, 16,124,124, 28,254,124,254,124,124, 0,
16, 0, 0, 0, 68,130, 48,130,130, 36,128,128, 2,130,130, 16,
16, 0, 0, 0, 68,130, 16, 2, 2, 68,128,128, 4,130,130, 0,
124, 0,124, 0, 48,130, 16, 12, 28,132,124,252, 8,124,126, 0,
16, 24, 0, 0, 0,130, 16, 48, 2,254, 2,130, 16,130, 4, 0,
16, 24, 0, 24, 0,130, 16, 64,130, 4,130,130, 16,130, 8, 16,
0, 0, 0, 24, 0,124, 56,254,124, 4,124,124, 16,124, 48, 0};
 
static unsigned char infos[63] = { 0xfe,0xfe,0x18,0x30,0x00,0x80,0xa0,0xa8,0xaa,
0xfe,0x82,0x38,0x38,0x00,0x80,0xa0,0xa8,0xaa,
0xfe,0x82,0x78,0x3c,0x00,0x80,0xa0,0xa8,0xaa,
0xfe,0x82,0xfe,0xfe,0x00,0x80,0xa0,0xa8,0xaa,
0xfe,0x82,0x7e,0x3c,0x00,0x80,0xa0,0xa8,0xaa,
0xfe,0x82,0x38,0x38,0x00,0x80,0xa0,0xa8,0xaa,
0xfe,0xfe,0x18,0x30,0x00,0x80,0xa0,0xa8,0xaa};
 
 
 
unsigned char display_line1[10];
unsigned char templine[5];
 
unsigned char mode = 0;
 
#define MAX_RX_BUF 100
unsigned volatile char SioTmp = 0;
unsigned volatile char RxdBuffer[MAX_RX_BUF];
unsigned volatile char NeuerDatensatzEmpfangen = 0;
unsigned volatile char CntCrcError = 0;
unsigned volatile char AnzahlEmpfangsBytes = 0;
 
struct str_DebugOut DebugOut;
 
 
static unsigned char grlevel[21] = { 0x00,0x00,0x00,0x18,0x00,0x00,0x00,
0xff,0xff,0xff,0x24,0xff,0xff,0xff,
0x00,0x00,0x00,0x18,0x00,0x00,0x00};
static unsigned char grlevel0[7] = { 0xAA,0xAA,0xAA,0xFF,0x55,0x55,0x55};
 
 
//-----------------------------------------------------------------------------
// copy bitmap
//-----------------------------------------------------------------------------
extern void GR_Copy(unsigned char* source,int start,int max)
{
int i;
for(i=0;i<max;i++)
{
dmem[start+i]=*source;
source++;
}
}
 
//-----------------------------------------------------------------------------
// Clear Graphic Area
//-----------------------------------------------------------------------------
extern void GR_Clear()
{
int i;
for(i=0;i<GR_MaxGraph;i++)
{
dmem[i]=0;
}
}
 
//-----------------------------------------------------------------------------
// Show and Hide Graphic area and Background
//-----------------------------------------------------------------------------
#define SHOWGRAPHIC showgraphic=1
#define HIDEGRAPHIC showgraphic=0
#define SHOWGRAPHICBACK showgraphicb=1
#define HIDEGRAPHICBACK showgraphicb=0
 
 
//-----------------------------------------------------------------------------
// Decode64
//-----------------------------------------------------------------------------
extern void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max)
{
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;
 
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;
}
}
 
//-----------------------------------------------------------------------------
// process RX Data
//-----------------------------------------------------------------------------
extern void process_rxdata(unsigned char c)
{
static unsigned int crc;
static unsigned char crc1,crc2,buf_ptr;
static unsigned char UartState = 0;
unsigned char CrcOkay = 0;
 
SioTmp=c;
 
if(buf_ptr >= MAX_RX_BUF)
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++;
display_line1[1]='E';
 
}
if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet
{
NeuerDatensatzEmpfangen = 1;
AnzahlEmpfangsBytes = buf_ptr;
RxdBuffer[buf_ptr] = '\r';
display_line1[1]='R';
}
}
else
switch(UartState)
{
case 0:
if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet
buf_ptr = 0;
RxdBuffer[buf_ptr++] = SioTmp;
crc = SioTmp;
display_line1[2]='A';
display_line1[1]='X';
break;
case 1: // Adresse auswerten
UartState++;
RxdBuffer[buf_ptr++] = SioTmp;
crc += SioTmp;
display_line1[2]='B';
break;
case 2: // Eingangsdaten sammeln
RxdBuffer[buf_ptr] = SioTmp;
if(buf_ptr < MAX_RX_BUF) buf_ptr++;
else UartState = 0;
crc += SioTmp;
display_line1[2]='C';
break;
default:
UartState = 0;
display_line1[2]='D';
break;
}
if(rxtx[8]==0x00)
rxtx[8]=0x01;
else
rxtx[8]=0x00;
}
 
//-----------------------------------------------------------------------------
// convert_uint16
//-----------------------------------------------------------------------------
extern void convert_uint16(unsigned char * c,int len, unsigned int value)
{
int tempvalue, i;
char c1[7];
if(len<1) return;
for(i=0;i<len;i++) {
c1[i]='0';
}
i=len-1;
while(value>0) {
tempvalue=value;
value=value/10;
c1[i]=(tempvalue-(value*10))+'0';
i--;
}
for(i=0;i<len;i++) {
*c=c1[i];
c++;
 
}
}
 
 
//-----------------------------------------------------------------------------
//main
//main execution loop
//-----------------------------------------------------------------------------
extern int main(void)
{
unsigned char c;
unsigned int i;
int i1;
HIDEGRAPHIC;
HIDEGRAPHICBACK;
CLKPR=0x80;
CLKPR=0x00;
 
// PORT D - unused right now
PORTD = 0x10;
DDRD = 0x00;
 
// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud rate: 57600
UCSR0A=0x00;
UCSR0B=0x18;
UCSR0C=0x86;
#ifdef CPUSPEED_20 //20.000MHz
UBRR0H=0x00;
UBRR0L=0x15;
#endif
 
#ifdef CPUSPEED_16 //16.000MHz
UBRR0H=0x00;
UBRR0L=0x10;
#endif
#ifdef CPUSPEED_11059 //11.059MHz
UBRR0H=0x00;
UBRR0L=0x0B;
#endif
 
// Initialize the 8-bit Timer0 to clock at 20/8 MHz */
TCCR0A=0x00;
TCCR0B=0x01;
 
// Initialize the SPI Interface
PORTB = 0x00;
DDRB = 0x3E; //0x3E
//DDRB = 0x3A;
SPCR = (1<<SPE) | (1<<MSTR) | (1<<CPHA);
SPSR = 1;
 
// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Falling Edge
// INT1: On
// INT1 Mode: Falling Edge
// Interrupt on any change on pins PCINT0-7: Off
// Interrupt on any change on pins PCINT8-14: Off
// Interrupt on any change on pins PCINT16-23: Off
EICRA=0x0A;
EIMSK=0x03;
EIFR=0x03;
PCICR=0x00;
 
// Enable interrupts
sei();
 
// MAIN lOOP
display_line1[0]='X';
display_line1[1]='X';
display_line1[2]='X';
display_line1[3]='X';
display_line1[4]='X';
display_line1[5]='X';
NeuerDatensatzEmpfangen = 0;
framecounter = 0;
GR_Clear();
GR_Copy(&grlevel[0],(GR_Lines/2)*7,21);
SHOWGRAPHIC;
while (1)
{
if (UCSR0A & (1<<RXC0)) {
c=UDR0;
UDR0=c;
process_rxdata(c);
}
if (framecounter<25) showmessage1=1; else showmessage1=0;
if (framecounter>50) framecounter = 0;
if(NeuerDatensatzEmpfangen) {
switch(RxdBuffer[2])
{
case 'D':
//decode the Messagee
Decode64((unsigned char *)&DebugOut,sizeof(DebugOut),3,AnzahlEmpfangsBytes);
// Heading information
convert_uint16((unsigned char *)&heading[1],3,(unsigned int)DebugOut.Analog[8]);
// Altitute Information
if(DebugOut.Analog[5]>old_alt) {
alt_inc=1;
alt_dec=0;
alt_delta=DebugOut.Analog[5]-old_alt;
}
else {
if(DebugOut.Analog[5]<old_alt) {
alt_inc=0;
alt_dec=1;
alt_delta=old_alt-DebugOut.Analog[5];
}
else {
alt_inc=0;
alt_dec=0;
alt_delta=0;
}
}
if(alt_delta>60) alt_delta=60;
if(alt_delta<0) alt_delta=0;
old_alt=DebugOut.Analog[5];
if(DebugOut.Analog[5]<0) {
altv[0]='-';
DebugOut.Analog[5]=(0xffff-(unsigned int)DebugOut.Analog[5]);
}
else {
altv[0]='+';
}
convert_uint16((unsigned char *)&altv[1],5,(unsigned int)DebugOut.Analog[5]);
//Voltage value
convert_uint16((unsigned char *)&templine[0],5,(unsigned int)DebugOut.Analog[9]);
ubat[3]=templine[2];
ubat[4]=templine[3];
ubat[6]=templine[4];
if(DebugOut.Analog[9]>90) bat[0]=0x08; else bat[0]=0x04;
if(DebugOut.Analog[9]>95) bat[1]=0x08; else bat[1]=0x04;
if(DebugOut.Analog[9]>100) bat[2]=0x08; else bat[2]=0x04;
if(DebugOut.Analog[9]>105) bat[3]=0x08; else bat[3]=0x04;
if(DebugOut.Analog[9]>110) bat[4]=0x08; else bat[4]=0x04;
if(DebugOut.Analog[9]>115) bat[5]=0x08; else bat[5]=0x04;
if(DebugOut.Analog[9]>120) bat[6]=0x08; else bat[6]=0x04;
if(DebugOut.Analog[9]>125) bat[7]=0x08; else bat[7]=0x04;
if(DebugOut.Analog[9]<94) lowbat=1; else lowbat = 0;
//RX level
i=((unsigned int)DebugOut.Analog[10]*100)/255;
convert_uint16((unsigned char *)&templine[0],5,(unsigned int)i);
urx[4]=templine[2];
urx[5]=templine[3];
urx[6]=templine[4];
if(i>10) rx[0]=0x08; else rx[0]=0x04;
if(i>20) rx[1]=0x08; else rx[1]=0x04;
if(i>30) rx[2]=0x08; else rx[2]=0x04;
if(i>40) rx[3]=0x08; else rx[3]=0x04;
if(i>50) rx[4]=0x08; else rx[4]=0x04;
if(i>60) rx[5]=0x08; else rx[5]=0x04;
if(i>70) rx[6]=0x08; else rx[6]=0x04;
if(i>80) rx[7]=0x08; else rx[7]=0x04;
// nick
i1=DebugOut.Analog[0]/50;
i1=((GR_Lines/2)-i1);
if(i1<0) i1=0;
if(i1>37) i1=37;
GR_Clear();
GR_Copy(&grlevel[0],i1*7,21);
if(i1!=20) GR_Copy(&grlevel0[0],20*7,7);
break;
 
default:
break;
}
NeuerDatensatzEmpfangen=0;
}
}
return(1);
} /* main */
 
 
 
//-----------------------------------------------------------------------------
// draw line()
// will be executed in interrupt context and will display the overlay content
//-----------------------------------------------------------------------------*/
extern void draw_line()
{
unsigned char *ltr_p;
unsigned char *num_p;
unsigned char *info_p;
short ltemp;
short ntemp;
short itemp;
unsigned int i1;
unsigned char i=0;
unsigned char c1;
unsigned char c2;
unsigned char c3;
unsigned char c4;
unsigned char c5;
unsigned char c6;
unsigned char c7;
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Bat and Heading output
if ((line > 35) && (line < 43))
{
ltemp = (line - 36) * 27 - 64;
ntemp = (line - 36) * 16 - 43;
itemp = (line - 36) * 9;
ltr_p = ltrs+ltemp;
num_p = nums+ntemp;
info_p = infos+itemp;
// +++ Bat
while(TCNT0<LINESTART);
TCNT0=0;
SPSR=1;
DDRB|=1; //sink thru PB0
SPDR = info_p[bat[0]]; Wait();
SPDR = info_p[bat[1]]; Wait();
SPDR = info_p[bat[2]]; Wait();
SPDR = info_p[bat[3]]; Wait();
SPDR = info_p[bat[4]]; Wait();
SPDR = info_p[bat[5]]; Wait();
SPDR = info_p[bat[6]]; Wait();
SPDR = info_p[bat[7]]; Wait();
DDRB&=0xFE; //PB0 Hi-Z again, and load a blank so spacing is right
// +++ Heading
TCNT0=0;
while(TCNT0<80);
TCNT0=0;
SPSR=0;
DDRB|=1;
SPDR = info_p[heading[0]]; Wait();
SPDR = num_p[heading[1]]; Wait();
SPDR = num_p[heading[2]]; Wait();
SPDR = num_p[heading[3]]; Wait();
SPDR = info_p[heading[4]]; Wait();
DDRB&=0xFE; //PB0 Hi-Z again, and load a blank so spacing is right
// +++ RX Level
while(TCNT0<250);
TCNT0=0;
while(TCNT0<70);
SPSR=1;
DDRB|=1;
SPDR = info_p[rx[0]]; Wait();
SPDR = info_p[rx[1]]; Wait();
SPDR = info_p[rx[2]]; Wait();
SPDR = info_p[rx[3]]; Wait();
SPDR = info_p[rx[4]]; Wait();
SPDR = info_p[rx[5]]; Wait();
SPDR = info_p[rx[6]]; Wait();
SPDR = info_p[rx[7]]; Wait();
DDRB&=0xFE;
}
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// UBat
if ((line > 44) && (line < 52))
{
ltemp = (line - 45) * 27 - 64;
ntemp = (line - 45) * 16 - 43;
itemp = (line - 45) * 9;
ltr_p = ltrs+ltemp;
num_p = nums+ntemp;
info_p = infos+itemp;
// +++ UBat
while(TCNT0<LINESTART);
TCNT0=0;
SPSR=1;
DDRB|=1;
SPDR = ltr_p[ubat[0]]; Wait();
SPDR = num_p[ubat[1]]; Wait();
SPDR = ltr_p[ubat[2]]; Wait();
SPDR = num_p[ubat[3]]; Wait();
SPDR = num_p[ubat[4]]; Wait();
SPDR = num_p[ubat[5]]; Wait();
SPDR = num_p[ubat[6]]; Wait();
SPDR = ltr_p[ubat[7]]; Wait();
DDRB&=0xFE;
TCNT0=0;
while(TCNT0<80);
TCNT0=0;
while(TCNT0<250);
TCNT0=0;
while(TCNT0<70);
TCNT0=0;
SPSR=1;
DDRB|=1;
SPDR = ltr_p[urx[0]]; Wait();
SPDR = ltr_p[urx[1]]; Wait();
SPDR = num_p[urx[2]]; Wait();
SPDR = ltr_p[urx[3]]; Wait();
SPDR = num_p[urx[4]]; Wait();
SPDR = num_p[urx[5]]; Wait();
SPDR = num_p[urx[6]]; Wait();
SPDR = num_p[urx[7]]; Wait();
DDRB&=0xFE;
}
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Message
if ((line > 60) && (line < 68) && (showmessage1) && (lowbat))
{
ltemp = (line - 61) * 27 - 64;
ntemp = (line - 61) * 16 - 43;
itemp = (line - 61) * 9;
ltr_p = ltrs+ltemp;
num_p = nums+ntemp;
info_p = infos+itemp;
// +++ UBat
while(TCNT0<LINESTART);
TCNT0=0;
while(TCNT0<250);
SPSR=1;
SPDR = ltr_p[Message_LowBat[0]]; Wait();
SPDR = ltr_p[Message_LowBat[1]]; Wait();
SPDR = ltr_p[Message_LowBat[2]]; Wait();
SPDR = ltr_p[Message_LowBat[3]]; Wait();
SPDR = ltr_p[Message_LowBat[4]]; Wait();
SPDR = ltr_p[Message_LowBat[5]]; Wait();
SPDR = ltr_p[Message_LowBat[6]]; Wait();
SPDR = ltr_p[Message_LowBat[7]]; Wait();
SPDR = ltr_p[Message_LowBat[8]]; Wait();
SPDR = ltr_p[Message_LowBat[9]]; Wait();
SPDR = ltr_p[Message_LowBat[10]]; Wait();
SPDR = ltr_p[Message_LowBat[11]]; Wait();
SPDR = ltr_p[Message_LowBat[12]]; Wait();
SPDR = ltr_p[Message_LowBat[13]]; Wait();
SPDR = ltr_p[Message_LowBat[14]]; Wait();
}
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// alt value
if((line > 80) && (line <250))
{
while(TCNT0<LINESTART);
TCNT0=0;
}
 
if ((line > 170) && (line < 178))
{
ltemp = (line - 171) * 27 - 64;
ntemp = (line - 171) * 16 - 43;
itemp = (line - 171) * 9;
ltr_p = ltrs+ltemp;
num_p = nums+ntemp;
info_p = infos+itemp;
while(TCNT0<10);
SPSR=1;
DDRB|=1;
SPDR = num_p[altv[0]]; Wait();
SPDR = num_p[altv[1]]; Wait();
SPDR = num_p[altv[2]]; Wait();
SPDR = num_p[altv[3]]; Wait();
SPDR = num_p[altv[4]]; Wait();
SPDR = num_p[altv[5]]; Wait();
DDRB&=0xFE;
}
 
if ((line > 179) && (line < (179 + alt_delta)) && alt_dec)
{
while(TCNT0<50);
SPDR = bar1; Wait();
}
 
if ((line > (169 - alt_delta)) && (line < 169) && alt_inc)
{
while(TCNT0<50);
SPDR = bar1; Wait();
}
asm("nop");
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// grafic array
if ((line > 90) && (line < 250) && (showgraphic==1))
{
 
while(TCNT0<250);
TCNT0=0;
 
i1=7*((line-90)>>2);
i=0;
c1=dmem[i1++];
c2=dmem[i1++];
c3=dmem[i1++];
c4=dmem[i1++];
c5=dmem[i1++];
c6=dmem[i1++];
c7=dmem[i1++];
while(TCNT0<20);
if (showgraphicb) DDRB|=1;
do {
PORTB=((c1<<2)&0x04);
c1=c1>>1;
i++;
} while(i<8);
do {
PORTB=((c2<<2)&0x04);
c2=c2>>1;
i++;
} while(i<16);
do {
PORTB=((c3<<2)&0x04);
c3=c3>>1;
i++;
} while(i<24);
do {
PORTB=((c4<<2)&0x04);
c4=c4>>1;
i++;
} while(i<32);
do {
PORTB=((c5<<2)&0x04);
c5=c5>>1;
i++;
} while(i<40);
do {
PORTB=((c6<<2)&0x04);
c6=c6>>1;
i++;
} while(i<48);
do {
PORTB=((c7<<2)&0x04);
c7=c7>>1;
i++;
} while(i<56);
PORTB=0x00;
DDRB&=0xFE;
}
 
 
// Debug - remove for release
// if ((line > 270) && (line < 278))
// {
// SPSR=1;
// ltemp = (line - 271) * 27 - 64;
// ntemp = (line - 271) * 16 - 43;
// itemp = (line - 271) * 8;
// ltr_p = ltrs+ltemp;
// num_p = nums+ntemp;
// info_p = infos+itemp;
// while(TCNT0<LINESTART);
// DDRB|=1; //sink thru PB0
// SPDR = ltr_p[rxtx[0]]; Wait();
// SPDR = ltr_p[rxtx[1]]; Wait();
// SPDR = ltr_p[rxtx[2]]; Wait();
// SPDR = info_p[rxtx[3]]; Wait();
// SPDR = ltr_p[rxtx[4]]; Wait();
// SPDR = ltr_p[rxtx[5]]; Wait();
// SPDR = ltr_p[rxtx[6]]; Wait();
// SPDR = ltr_p[rxtx[7]]; Wait();
// SPDR = info_p[rxtx[8]]; Wait();
// TCNT0=0;
// while(TCNT0<3); // 3 wait a little bit before turning off dimmer so that the
// // length of black box on the right matches the one on the left
// DDRB&=0xFE; //PB0 Hi-Z again, and load a blank so spacing is right
// }
 
// if ((line > 280) && (line < 288))
// {
// SPSR=1;
// ltemp = (line - 281) * 27 - 64;
// ntemp = (line - 281) * 16 - 43;
// ltr_p = ltrs+ltemp; //by calculating this pointer you only have to
// num_p = nums+ntemp; //add ltemp/ntemp once per line, instead of for
//every char. This tightens up printing a bit
//saves about 3 assembly instructions per char
// SPDR = ltr_p['@']; Wait(); //goofy hack to make SPSR=0 work, write an empty char at SPSR=1 first
// SPSR=1;
// while(TCNT0<LINESTART);
// DDRB|=1; //sink thru PB0
// //;display_line1[0]='A';
// SPDR = ltr_p[display_line1[0]]; Wait();
// SPDR = ltr_p[display_line1[1]]; Wait();
// SPDR = ltr_p[display_line1[2]]; Wait();
// SPDR = ltr_p[display_line1[3]]; Wait();
// SPDR = ltr_p[display_line1[4]]; Wait();
// SPDR = ltr_p[display_line1[5]]; Wait();
// TCNT0=0;
// while(TCNT0<3); // 3 wait a little bit before turning off dimmer so that the
// // length of black box on the right matches the one on the left
// DDRB&=0xFE; //PB0 Hi-Z again, and load a blank so spacing is right
// }
if ((line > 300) && (line < 308))
{
SPSR=1;
ltemp = (line - 301) * 27 - 64;
ntemp = (line - 301) * 16 - 43;
ltr_p = ltrs+ltemp;
num_p = nums+ntemp;
while(TCNT0<LINESTART+COPYRIGHTSTART);
SPDR = ltr_p[head[0]]; Wait();
SPDR = ltr_p[head[1]]; Wait();
SPDR = ltr_p[head[2]]; Wait();
SPDR = ltr_p[head[3]]; Wait();
SPDR = ltr_p[head[4]]; Wait();
SPDR = ltr_p[head[5]]; Wait();
SPDR = ltr_p[head[6]]; Wait();
SPDR = ltr_p[head[7]]; Wait();
SPDR = ltr_p[head[8]]; Wait();
SPDR = ltr_p[head[9]]; Wait();
SPDR = ltr_p[head[10]]; Wait();
SPDR = ltr_p[head[11]]; Wait();
SPDR = ltr_p[head[12]]; Wait();
SPDR = ltr_p[head[13]]; Wait();
SPDR = ltr_p[head[14]]; Wait();
SPDR = ltr_p[head[15]]; Wait();
SPDR = ltr_p[head[16]]; Wait();
TCNT0=0;
while(TCNT0<2);
}
} // end draw_line()
 
 
//-----------------------------------------------------------------------------
// H-Sync Interrupt
//-----------------------------------------------------------------------------*/
SIGNAL(SIG_INTERRUPT0)
{
TCNT0=0; // reset timer
line++; // increment line counter
draw_line(); // output the line
}
 
 
//-----------------------------------------------------------------------------
// V-Sync Interrupt
//-----------------------------------------------------------------------------*/
SIGNAL(SIG_INTERRUPT1)
{
line = 0;
framecounter++;
}
/OSD and Video Transmitter/overlay/main.lst
New file
0,0 → 1,2843
 
main.elf: file format elf32-avr
 
Sections:
Idx Name Size VMA LMA File off Algn
0 .data 000002d8 00800100 000011b8 0000124c 2**0
CONTENTS, ALLOC, LOAD, DATA
1 .text 000011b8 00000000 00000000 00000094 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
2 .bss 000000cc 008003d8 008003d8 00001524 2**0
ALLOC
3 .stab 00000378 00000000 00000000 00001524 2**2
CONTENTS, READONLY, DEBUGGING
4 .stabstr 00000071 00000000 00000000 0000189c 2**0
CONTENTS, READONLY, DEBUGGING
5 .debug_aranges 00000020 00000000 00000000 0000190d 2**0
CONTENTS, READONLY, DEBUGGING
6 .debug_pubnames 00000207 00000000 00000000 0000192d 2**0
CONTENTS, READONLY, DEBUGGING
7 .debug_info 000007c7 00000000 00000000 00001b34 2**0
CONTENTS, READONLY, DEBUGGING
8 .debug_abbrev 0000020c 00000000 00000000 000022fb 2**0
CONTENTS, READONLY, DEBUGGING
9 .debug_line 00000d5d 00000000 00000000 00002507 2**0
CONTENTS, READONLY, DEBUGGING
10 .debug_frame 000000a0 00000000 00000000 00003264 2**2
CONTENTS, READONLY, DEBUGGING
11 .debug_str 00000287 00000000 00000000 00003304 2**0
CONTENTS, READONLY, DEBUGGING
12 .debug_loc 00000453 00000000 00000000 0000358b 2**0
CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:
 
00000000 <__vectors>:
0: 19 c0 rjmp .+50 ; 0x34 <__ctors_end>
2: 70 c8 rjmp .-3872 ; 0xfffff0e4 <__eeprom_end+0xff7ef0e4>
4: 9c c8 rjmp .-3784 ; 0xfffff13e <__eeprom_end+0xff7ef13e>
6: 31 c0 rjmp .+98 ; 0x6a <__bad_interrupt>
8: 30 c0 rjmp .+96 ; 0x6a <__bad_interrupt>
a: 2f c0 rjmp .+94 ; 0x6a <__bad_interrupt>
c: 2e c0 rjmp .+92 ; 0x6a <__bad_interrupt>
e: 2d c0 rjmp .+90 ; 0x6a <__bad_interrupt>
10: 2c c0 rjmp .+88 ; 0x6a <__bad_interrupt>
12: 2b c0 rjmp .+86 ; 0x6a <__bad_interrupt>
14: 2a c0 rjmp .+84 ; 0x6a <__bad_interrupt>
16: 29 c0 rjmp .+82 ; 0x6a <__bad_interrupt>
18: 28 c0 rjmp .+80 ; 0x6a <__bad_interrupt>
1a: 27 c0 rjmp .+78 ; 0x6a <__bad_interrupt>
1c: 26 c0 rjmp .+76 ; 0x6a <__bad_interrupt>
1e: 25 c0 rjmp .+74 ; 0x6a <__bad_interrupt>
20: 24 c0 rjmp .+72 ; 0x6a <__bad_interrupt>
22: 23 c0 rjmp .+70 ; 0x6a <__bad_interrupt>
24: 22 c0 rjmp .+68 ; 0x6a <__bad_interrupt>
26: 21 c0 rjmp .+66 ; 0x6a <__bad_interrupt>
28: 20 c0 rjmp .+64 ; 0x6a <__bad_interrupt>
2a: 1f c0 rjmp .+62 ; 0x6a <__bad_interrupt>
2c: 1e c0 rjmp .+60 ; 0x6a <__bad_interrupt>
2e: 1d c0 rjmp .+58 ; 0x6a <__bad_interrupt>
30: 1c c0 rjmp .+56 ; 0x6a <__bad_interrupt>
32: 1b c0 rjmp .+54 ; 0x6a <__bad_interrupt>
 
00000034 <__ctors_end>:
34: 11 24 eor r1, r1
36: 1f be out 0x3f, r1 ; 63
38: cf ef ldi r28, 0xFF ; 255
3a: d4 e0 ldi r29, 0x04 ; 4
3c: de bf out 0x3e, r29 ; 62
3e: cd bf out 0x3d, r28 ; 61
 
00000040 <__do_copy_data>:
40: 13 e0 ldi r17, 0x03 ; 3
42: a0 e0 ldi r26, 0x00 ; 0
44: b1 e0 ldi r27, 0x01 ; 1
46: e8 eb ldi r30, 0xB8 ; 184
48: f1 e1 ldi r31, 0x11 ; 17
4a: 02 c0 rjmp .+4 ; 0x50 <.do_copy_data_start>
 
0000004c <.do_copy_data_loop>:
4c: 05 90 lpm r0, Z+
4e: 0d 92 st X+, r0
 
00000050 <.do_copy_data_start>:
50: a8 3d cpi r26, 0xD8 ; 216
52: b1 07 cpc r27, r17
54: d9 f7 brne .-10 ; 0x4c <.do_copy_data_loop>
 
00000056 <__do_clear_bss>:
56: 14 e0 ldi r17, 0x04 ; 4
58: a8 ed ldi r26, 0xD8 ; 216
5a: b3 e0 ldi r27, 0x03 ; 3
5c: 01 c0 rjmp .+2 ; 0x60 <.do_clear_bss_start>
 
0000005e <.do_clear_bss_loop>:
5e: 1d 92 st X+, r1
 
00000060 <.do_clear_bss_start>:
60: a4 3a cpi r26, 0xA4 ; 164
62: b1 07 cpc r27, r17
64: e1 f7 brne .-8 ; 0x5e <.do_clear_bss_loop>
66: f6 d1 rcall .+1004 ; 0x454 <main>
68: a6 c8 rjmp .-3764 ; 0xfffff1b6 <__eeprom_end+0xff7ef1b6>
 
0000006a <__bad_interrupt>:
6a: ca cf rjmp .-108 ; 0x0 <__vectors>
 
0000006c <GR_Copy>:
//-----------------------------------------------------------------------------
// copy bitmap
//-----------------------------------------------------------------------------
extern void GR_Copy(unsigned char* source,int start,int max)
{
6c: dc 01 movw r26, r24
int i;
for(i=0;i<max;i++)
6e: 14 16 cp r1, r20
70: 15 06 cpc r1, r21
72: 64 f4 brge .+24 ; 0x8c <GR_Copy+0x20>
74: fb 01 movw r30, r22
76: e9 5c subi r30, 0xC9 ; 201
78: fe 4f sbci r31, 0xFE ; 254
7a: 20 e0 ldi r18, 0x00 ; 0
7c: 30 e0 ldi r19, 0x00 ; 0
{
dmem[start+i]=*source;
7e: 8d 91 ld r24, X+
80: 81 93 st Z+, r24
82: 2f 5f subi r18, 0xFF ; 255
84: 3f 4f sbci r19, 0xFF ; 255
86: 42 17 cp r20, r18
88: 53 07 cpc r21, r19
8a: c9 f7 brne .-14 ; 0x7e <GR_Copy+0x12>
8c: 08 95 ret
 
0000008e <GR_Clear>:
source++;
}
}
 
//-----------------------------------------------------------------------------
// Clear Graphic Area
//-----------------------------------------------------------------------------
extern void GR_Clear()
{
8e: e7 e3 ldi r30, 0x37 ; 55
90: f1 e0 ldi r31, 0x01 ; 1
92: 8f e4 ldi r24, 0x4F ; 79
94: 92 e0 ldi r25, 0x02 ; 2
int i;
for(i=0;i<GR_MaxGraph;i++)
{
dmem[i]=0;
96: 11 92 st Z+, r1
98: e8 17 cp r30, r24
9a: f9 07 cpc r31, r25
9c: e1 f7 brne .-8 ; 0x96 <GR_Clear+0x8>
9e: 08 95 ret
 
000000a0 <Decode64>:
}
}
 
//-----------------------------------------------------------------------------
// Show and Hide Graphic area and Background
//-----------------------------------------------------------------------------
#define SHOWGRAPHIC showgraphic=1
#define HIDEGRAPHIC showgraphic=0
#define SHOWGRAPHICBACK showgraphicb=1
#define HIDEGRAPHICBACK showgraphicb=0
 
 
//-----------------------------------------------------------------------------
// Decode64
//-----------------------------------------------------------------------------
extern void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max)
{
a0: ef 92 push r14
a2: ff 92 push r15
a4: 1f 93 push r17
a6: cf 93 push r28
a8: df 93 push r29
aa: ec 01 movw r28, r24
ac: 16 2f mov r17, r22
unsigned char a,b,c,d;
unsigned char ptr = 0;
unsigned char x,y,z;
while(len)
ae: 66 23 and r22, r22
b0: 09 f4 brne .+2 ; 0xb4 <Decode64+0x14>
b2: 7b c0 rjmp .+246 ; 0x1aa <Decode64+0x10a>
{
a = RxdBuffer[ptrIn++] - '=';
b4: a4 ef ldi r26, 0xF4 ; 244
b6: b3 e0 ldi r27, 0x03 ; 3
b8: fd 01 movw r30, r26
ba: e4 0f add r30, r20
bc: f1 1d adc r31, r1
be: 50 81 ld r21, Z
c0: 84 2f mov r24, r20
c2: 8f 5f subi r24, 0xFF ; 255
b = RxdBuffer[ptrIn++] - '=';
c4: fd 01 movw r30, r26
c6: e8 0f add r30, r24
c8: f1 1d adc r31, r1
ca: 30 81 ld r19, Z
cc: 8f 5f subi r24, 0xFF ; 255
c = RxdBuffer[ptrIn++] - '=';
ce: fd 01 movw r30, r26
d0: e8 0f add r30, r24
d2: f1 1d adc r31, r1
d4: e0 81 ld r30, Z
d6: 8f 5f subi r24, 0xFF ; 255
d = RxdBuffer[ptrIn++] - '=';
d8: a8 0f add r26, r24
da: b1 1d adc r27, r1
dc: ac 91 ld r26, X
de: 4c 5f subi r20, 0xFC ; 252
if(ptrIn > max - 2) break;
e0: 82 2f mov r24, r18
e2: 99 27 eor r25, r25
e4: 0f 2e mov r0, r31
e6: fe ef ldi r31, 0xFE ; 254
e8: ef 2e mov r14, r31
ea: ff ef ldi r31, 0xFF ; 255
ec: ff 2e mov r15, r31
ee: f0 2d mov r31, r0
f0: e8 0e add r14, r24
f2: f9 1e adc r15, r25
f4: 84 2f mov r24, r20
f6: 99 27 eor r25, r25
f8: e8 16 cp r14, r24
fa: f9 06 cpc r15, r25
fc: 0c f4 brge .+2 ; 0x100 <Decode64+0x60>
fe: 55 c0 rjmp .+170 ; 0x1aa <Decode64+0x10a>
100: 85 2f mov r24, r21
102: 8d 53 subi r24, 0x3D ; 61
104: 3d 53 subi r19, 0x3D ; 61
106: 5e 2f mov r21, r30
108: 5d 53 subi r21, 0x3D ; 61
10a: ad 53 subi r26, 0x3D ; 61
10c: 20 e0 ldi r18, 0x00 ; 0
10e: 64 ef ldi r22, 0xF4 ; 244
110: 73 e0 ldi r23, 0x03 ; 3
112: 20 c0 rjmp .+64 ; 0x154 <Decode64+0xb4>
114: fb 01 movw r30, r22
116: e4 0f add r30, r20
118: f1 1d adc r31, r1
11a: b0 81 ld r27, Z
11c: 84 2f mov r24, r20
11e: 8f 5f subi r24, 0xFF ; 255
120: fb 01 movw r30, r22
122: e8 0f add r30, r24
124: f1 1d adc r31, r1
126: 30 81 ld r19, Z
128: 8f 5f subi r24, 0xFF ; 255
12a: fb 01 movw r30, r22
12c: e8 0f add r30, r24
12e: f1 1d adc r31, r1
130: 50 81 ld r21, Z
132: 8f 5f subi r24, 0xFF ; 255
134: fb 01 movw r30, r22
136: e8 0f add r30, r24
138: f1 1d adc r31, r1
13a: a0 81 ld r26, Z
13c: 4c 5f subi r20, 0xFC ; 252
13e: 84 2f mov r24, r20
140: 99 27 eor r25, r25
142: e8 16 cp r14, r24
144: f9 06 cpc r15, r25
146: 8c f1 brlt .+98 ; 0x1aa <Decode64+0x10a>
148: 8b 2f mov r24, r27
14a: 8d 53 subi r24, 0x3D ; 61
14c: 3d 53 subi r19, 0x3D ; 61
14e: 5d 53 subi r21, 0x3D ; 61
150: ad 53 subi r26, 0x3D ; 61
152: 2d 5f subi r18, 0xFD ; 253
 
x = (a << 2) | (b >> 4);
y = ((b & 0x0f) << 4) | (c >> 2);
z = ((c & 0x03) << 6) | d;
 
if(len--) ptrOut[ptr++] = x; else break;
154: fe 01 movw r30, r28
156: e2 0f add r30, r18
158: f1 1d adc r31, r1
15a: 88 0f add r24, r24
15c: 88 0f add r24, r24
15e: 93 2f mov r25, r19
160: 92 95 swap r25
162: 9f 70 andi r25, 0x0F ; 15
164: 89 2b or r24, r25
166: 80 83 st Z, r24
if(len--) ptrOut[ptr++] = y; else break;
168: 11 30 cpi r17, 0x01 ; 1
16a: f9 f0 breq .+62 ; 0x1aa <Decode64+0x10a>
16c: 82 2f mov r24, r18
16e: 8f 5f subi r24, 0xFF ; 255
170: fe 01 movw r30, r28
172: e8 0f add r30, r24
174: f1 1d adc r31, r1
176: 83 2f mov r24, r19
178: 82 95 swap r24
17a: 80 7f andi r24, 0xF0 ; 240
17c: 95 2f mov r25, r21
17e: 96 95 lsr r25
180: 96 95 lsr r25
182: 89 2b or r24, r25
184: 80 83 st Z, r24
186: 13 50 subi r17, 0x03 ; 3
if(len--) ptrOut[ptr++] = z; else break;
188: 1f 3f cpi r17, 0xFF ; 255
18a: 79 f0 breq .+30 ; 0x1aa <Decode64+0x10a>
18c: 82 2f mov r24, r18
18e: 8e 5f subi r24, 0xFE ; 254
190: fe 01 movw r30, r28
192: e8 0f add r30, r24
194: f1 1d adc r31, r1
196: 85 2f mov r24, r21
198: 82 95 swap r24
19a: 88 0f add r24, r24
19c: 88 0f add r24, r24
19e: 80 7c andi r24, 0xC0 ; 192
1a0: 8a 2b or r24, r26
1a2: 80 83 st Z, r24
1a4: 11 23 and r17, r17
1a6: 09 f0 breq .+2 ; 0x1aa <Decode64+0x10a>
1a8: b5 cf rjmp .-150 ; 0x114 <Decode64+0x74>
1aa: df 91 pop r29
1ac: cf 91 pop r28
1ae: 1f 91 pop r17
1b0: ff 90 pop r15
1b2: ef 90 pop r14
1b4: 08 95 ret
 
000001b6 <process_rxdata>:
}
}
 
//-----------------------------------------------------------------------------
// process RX Data
//-----------------------------------------------------------------------------
extern void process_rxdata(unsigned char c)
{
1b6: 80 93 e1 03 sts 0x03E1, r24
static unsigned int crc;
static unsigned char crc1,crc2,buf_ptr;
static unsigned char UartState = 0;
unsigned char CrcOkay = 0;
 
SioTmp=c;
 
if(buf_ptr >= MAX_RX_BUF)
1ba: 50 91 e6 03 lds r21, 0x03E6
1be: 54 36 cpi r21, 0x64 ; 100
1c0: 10 f0 brcs .+4 ; 0x1c6 <process_rxdata+0x10>
UartState = 0;
1c2: 10 92 e5 03 sts 0x03E5, r1
if(SioTmp == '\r' && UartState == 2)
1c6: 80 91 e1 03 lds r24, 0x03E1
1ca: 8d 30 cpi r24, 0x0D ; 13
1cc: 09 f0 breq .+2 ; 0x1d0 <process_rxdata+0x1a>
1ce: 5c c0 rjmp .+184 ; 0x288 <process_rxdata+0xd2>
1d0: 80 91 e5 03 lds r24, 0x03E5
1d4: 82 30 cpi r24, 0x02 ; 2
1d6: 09 f0 breq .+2 ; 0x1da <process_rxdata+0x24>
1d8: 57 c0 rjmp .+174 ; 0x288 <process_rxdata+0xd2>
{
UartState = 0;
1da: 10 92 e5 03 sts 0x03E5, r1
crc -= RxdBuffer[buf_ptr-2];
1de: 65 2f mov r22, r21
1e0: 77 27 eor r23, r23
1e2: fb 01 movw r30, r22
1e4: 32 97 sbiw r30, 0x02 ; 2
1e6: 24 ef ldi r18, 0xF4 ; 244
1e8: 33 e0 ldi r19, 0x03 ; 3
1ea: e2 0f add r30, r18
1ec: f3 1f adc r31, r19
1ee: 40 81 ld r20, Z
crc -= RxdBuffer[buf_ptr-1];
1f0: cb 01 movw r24, r22
1f2: 01 97 sbiw r24, 0x01 ; 1
1f4: dc 01 movw r26, r24
1f6: a2 0f add r26, r18
1f8: b3 1f adc r27, r19
1fa: 2c 91 ld r18, X
crc %= 4096;
1fc: 80 91 e9 03 lds r24, 0x03E9
200: 90 91 ea 03 lds r25, 0x03EA
204: 84 1b sub r24, r20
206: 91 09 sbc r25, r1
208: 82 1b sub r24, r18
20a: 91 09 sbc r25, r1
20c: 9f 70 andi r25, 0x0F ; 15
20e: 90 93 ea 03 sts 0x03EA, r25
212: 80 93 e9 03 sts 0x03E9, r24
crc1 = '=' + crc / 64;
216: 9c 01 movw r18, r24
218: 00 24 eor r0, r0
21a: 22 0f add r18, r18
21c: 33 1f adc r19, r19
21e: 00 1c adc r0, r0
220: 22 0f add r18, r18
222: 33 1f adc r19, r19
224: 00 1c adc r0, r0
226: 23 2f mov r18, r19
228: 30 2d mov r19, r0
22a: 23 5c subi r18, 0xC3 ; 195
22c: 20 93 e8 03 sts 0x03E8, r18
crc2 = '=' + crc % 64;
230: 8f 73 andi r24, 0x3F ; 63
232: 38 2f mov r19, r24
234: 33 5c subi r19, 0xC3 ; 195
236: 30 93 e7 03 sts 0x03E7, r19
CrcOkay = 0;
if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1]))
23a: 80 81 ld r24, Z
23c: 28 17 cp r18, r24
23e: 29 f4 brne .+10 ; 0x24a <process_rxdata+0x94>
240: 8c 91 ld r24, X
242: 38 17 cp r19, r24
244: 11 f4 brne .+4 ; 0x24a <process_rxdata+0x94>
246: 91 e0 ldi r25, 0x01 ; 1
248: 09 c0 rjmp .+18 ; 0x25c <process_rxdata+0xa6>
{
CrcOkay = 1;
}
else
{
CrcOkay = 0;
CntCrcError++;
24a: 80 91 e3 03 lds r24, 0x03E3
24e: 8f 5f subi r24, 0xFF ; 255
250: 80 93 e3 03 sts 0x03E3, r24
display_line1[1]='E';
254: 85 e4 ldi r24, 0x45 ; 69
256: 80 93 59 04 sts 0x0459, r24
25a: 90 e0 ldi r25, 0x00 ; 0
 
}
if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet
25c: 80 91 e2 03 lds r24, 0x03E2
260: 88 23 and r24, r24
262: 09 f0 breq .+2 ; 0x266 <process_rxdata+0xb0>
264: 7e c0 rjmp .+252 ; 0x362 <process_rxdata+0x1ac>
266: 99 23 and r25, r25
268: 09 f4 brne .+2 ; 0x26c <process_rxdata+0xb6>
26a: 7b c0 rjmp .+246 ; 0x362 <process_rxdata+0x1ac>
{
NeuerDatensatzEmpfangen = 1;
26c: 81 e0 ldi r24, 0x01 ; 1
26e: 80 93 e2 03 sts 0x03E2, r24
AnzahlEmpfangsBytes = buf_ptr;
272: 50 93 e4 03 sts 0x03E4, r21
RxdBuffer[buf_ptr] = '\r';
276: fb 01 movw r30, r22
278: ec 50 subi r30, 0x0C ; 12
27a: fc 4f sbci r31, 0xFC ; 252
27c: 8d e0 ldi r24, 0x0D ; 13
27e: 80 83 st Z, r24
display_line1[1]='R';
280: 82 e5 ldi r24, 0x52 ; 82
282: 80 93 59 04 sts 0x0459, r24
286: 6d c0 rjmp .+218 ; 0x362 <process_rxdata+0x1ac>
}
}
else
switch(UartState)
288: 80 91 e5 03 lds r24, 0x03E5
28c: 81 30 cpi r24, 0x01 ; 1
28e: 31 f1 breq .+76 ; 0x2dc <process_rxdata+0x126>
290: 81 30 cpi r24, 0x01 ; 1
292: 20 f0 brcs .+8 ; 0x29c <process_rxdata+0xe6>
294: 82 30 cpi r24, 0x02 ; 2
296: 09 f0 breq .+2 ; 0x29a <process_rxdata+0xe4>
298: 5f c0 rjmp .+190 ; 0x358 <process_rxdata+0x1a2>
29a: 3e c0 rjmp .+124 ; 0x318 <process_rxdata+0x162>
{
case 0:
if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1; // Startzeichen und Daten schon verarbeitet
29c: 80 91 e1 03 lds r24, 0x03E1
2a0: 83 32 cpi r24, 0x23 ; 35
2a2: 39 f4 brne .+14 ; 0x2b2 <process_rxdata+0xfc>
2a4: 80 91 e2 03 lds r24, 0x03E2
2a8: 88 23 and r24, r24
2aa: 19 f4 brne .+6 ; 0x2b2 <process_rxdata+0xfc>
2ac: 81 e0 ldi r24, 0x01 ; 1
2ae: 80 93 e5 03 sts 0x03E5, r24
buf_ptr = 0;
RxdBuffer[buf_ptr++] = SioTmp;
2b2: 80 91 e1 03 lds r24, 0x03E1
2b6: 80 93 f4 03 sts 0x03F4, r24
2ba: 81 e0 ldi r24, 0x01 ; 1
2bc: 80 93 e6 03 sts 0x03E6, r24
crc = SioTmp;
2c0: 80 91 e1 03 lds r24, 0x03E1
2c4: 99 27 eor r25, r25
2c6: 90 93 ea 03 sts 0x03EA, r25
2ca: 80 93 e9 03 sts 0x03E9, r24
display_line1[2]='A';
2ce: 81 e4 ldi r24, 0x41 ; 65
2d0: 80 93 5a 04 sts 0x045A, r24
display_line1[1]='X';
2d4: 88 e5 ldi r24, 0x58 ; 88
2d6: 80 93 59 04 sts 0x0459, r24
2da: 43 c0 rjmp .+134 ; 0x362 <process_rxdata+0x1ac>
break;
case 1: // Adresse auswerten
UartState++;
2dc: 82 e0 ldi r24, 0x02 ; 2
2de: 80 93 e5 03 sts 0x03E5, r24
RxdBuffer[buf_ptr++] = SioTmp;
2e2: 80 91 e1 03 lds r24, 0x03E1
2e6: e4 ef ldi r30, 0xF4 ; 244
2e8: f3 e0 ldi r31, 0x03 ; 3
2ea: e5 0f add r30, r21
2ec: f1 1d adc r31, r1
2ee: 80 83 st Z, r24
2f0: 85 2f mov r24, r21
2f2: 8f 5f subi r24, 0xFF ; 255
2f4: 80 93 e6 03 sts 0x03E6, r24
crc += SioTmp;
2f8: 20 91 e1 03 lds r18, 0x03E1
2fc: 80 91 e9 03 lds r24, 0x03E9
300: 90 91 ea 03 lds r25, 0x03EA
304: 82 0f add r24, r18
306: 91 1d adc r25, r1
308: 90 93 ea 03 sts 0x03EA, r25
30c: 80 93 e9 03 sts 0x03E9, r24
display_line1[2]='B';
310: 82 e4 ldi r24, 0x42 ; 66
312: 80 93 5a 04 sts 0x045A, r24
316: 25 c0 rjmp .+74 ; 0x362 <process_rxdata+0x1ac>
break;
case 2: // Eingangsdaten sammeln
RxdBuffer[buf_ptr] = SioTmp;
318: 80 91 e1 03 lds r24, 0x03E1
31c: e4 ef ldi r30, 0xF4 ; 244
31e: f3 e0 ldi r31, 0x03 ; 3
320: e5 0f add r30, r21
322: f1 1d adc r31, r1
324: 80 83 st Z, r24
if(buf_ptr < MAX_RX_BUF) buf_ptr++;
326: 54 36 cpi r21, 0x64 ; 100
328: 28 f4 brcc .+10 ; 0x334 <process_rxdata+0x17e>
32a: 85 2f mov r24, r21
32c: 8f 5f subi r24, 0xFF ; 255
32e: 80 93 e6 03 sts 0x03E6, r24
332: 02 c0 rjmp .+4 ; 0x338 <process_rxdata+0x182>
else UartState = 0;
334: 10 92 e5 03 sts 0x03E5, r1
crc += SioTmp;
338: 80 91 e1 03 lds r24, 0x03E1
33c: 20 91 e9 03 lds r18, 0x03E9
340: 30 91 ea 03 lds r19, 0x03EA
344: 28 0f add r18, r24
346: 31 1d adc r19, r1
348: 30 93 ea 03 sts 0x03EA, r19
34c: 20 93 e9 03 sts 0x03E9, r18
display_line1[2]='C';
350: 83 e4 ldi r24, 0x43 ; 67
352: 80 93 5a 04 sts 0x045A, r24
356: 05 c0 rjmp .+10 ; 0x362 <process_rxdata+0x1ac>
break;
default:
UartState = 0;
358: 10 92 e5 03 sts 0x03E5, r1
display_line1[2]='D';
35c: 84 e4 ldi r24, 0x44 ; 68
35e: 80 93 5a 04 sts 0x045A, r24
break;
}
if(rxtx[8]==0x00)
362: 80 91 0a 01 lds r24, 0x010A
366: 88 23 and r24, r24
368: 21 f4 brne .+8 ; 0x372 <process_rxdata+0x1bc>
rxtx[8]=0x01;
36a: 81 e0 ldi r24, 0x01 ; 1
36c: 80 93 0a 01 sts 0x010A, r24
370: 08 95 ret
else
rxtx[8]=0x00;
372: 10 92 0a 01 sts 0x010A, r1
376: 08 95 ret
 
00000378 <convert_uint16>:
}
 
//-----------------------------------------------------------------------------
// convert_uint16
//-----------------------------------------------------------------------------
extern void convert_uint16(unsigned char * c,int len, unsigned int value)
{
378: af 92 push r10
37a: bf 92 push r11
37c: cf 92 push r12
37e: df 92 push r13
380: ef 92 push r14
382: ff 92 push r15
384: 0f 93 push r16
386: 1f 93 push r17
388: cf 93 push r28
38a: df 93 push r29
38c: cd b7 in r28, 0x3d ; 61
38e: de b7 in r29, 0x3e ; 62
390: 27 97 sbiw r28, 0x07 ; 7
392: 0f b6 in r0, 0x3f ; 63
394: f8 94 cli
396: de bf out 0x3e, r29 ; 62
398: 0f be out 0x3f, r0 ; 63
39a: cd bf out 0x3d, r28 ; 61
39c: 6c 01 movw r12, r24
39e: 7b 01 movw r14, r22
int tempvalue, i;
char c1[7];
if(len<1) return;
3a0: 16 16 cp r1, r22
3a2: 17 06 cpc r1, r23
3a4: 0c f0 brlt .+2 ; 0x3a8 <convert_uint16+0x30>
3a6: 45 c0 rjmp .+138 ; 0x432 <convert_uint16+0xba>
3a8: 80 e0 ldi r24, 0x00 ; 0
3aa: 90 e0 ldi r25, 0x00 ; 0
3ac: 9e 01 movw r18, r28
3ae: 2f 5f subi r18, 0xFF ; 255
3b0: 3f 4f sbci r19, 0xFF ; 255
3b2: 60 e3 ldi r22, 0x30 ; 48
for(i=0;i<len;i++) {
c1[i]='0';
3b4: f9 01 movw r30, r18
3b6: e8 0f add r30, r24
3b8: f9 1f adc r31, r25
3ba: 60 83 st Z, r22
3bc: 01 96 adiw r24, 0x01 ; 1
3be: e8 16 cp r14, r24
3c0: f9 06 cpc r15, r25
3c2: c1 f7 brne .-16 ; 0x3b4 <convert_uint16+0x3c>
}
i=len-1;
while(value>0) {
3c4: 41 15 cp r20, r1
3c6: 51 05 cpc r21, r1
3c8: 19 f1 breq .+70 ; 0x410 <convert_uint16+0x98>
3ca: 87 01 movw r16, r14
3cc: 01 50 subi r16, 0x01 ; 1
3ce: 10 40 sbci r17, 0x00 ; 0
3d0: 5e 01 movw r10, r28
3d2: 08 94 sec
3d4: a1 1c adc r10, r1
3d6: b1 1c adc r11, r1
tempvalue=value;
3d8: fa 01 movw r30, r20
value=value/10;
3da: ca 01 movw r24, r20
3dc: 6a e0 ldi r22, 0x0A ; 10
3de: 70 e0 ldi r23, 0x00 ; 0
3e0: c3 d6 rcall .+3462 ; 0x1168 <__udivmodhi4>
3e2: ab 01 movw r20, r22
c1[i]=(tempvalue-(value*10))+'0';
3e4: d5 01 movw r26, r10
3e6: a0 0f add r26, r16
3e8: b1 1f adc r27, r17
3ea: cb 01 movw r24, r22
3ec: 88 0f add r24, r24
3ee: 99 1f adc r25, r25
3f0: 9b 01 movw r18, r22
3f2: 22 0f add r18, r18
3f4: 33 1f adc r19, r19
3f6: 22 0f add r18, r18
3f8: 33 1f adc r19, r19
3fa: 22 0f add r18, r18
3fc: 33 1f adc r19, r19
3fe: 82 0f add r24, r18
400: 93 1f adc r25, r19
402: e8 1b sub r30, r24
404: e0 5d subi r30, 0xD0 ; 208
406: ec 93 st X, r30
i--;
408: 01 50 subi r16, 0x01 ; 1
40a: 10 40 sbci r17, 0x00 ; 0
40c: 67 2b or r22, r23
40e: 21 f7 brne .-56 ; 0x3d8 <convert_uint16+0x60>
410: 20 e0 ldi r18, 0x00 ; 0
412: 30 e0 ldi r19, 0x00 ; 0
414: ae 01 movw r20, r28
416: 4f 5f subi r20, 0xFF ; 255
418: 5f 4f sbci r21, 0xFF ; 255
}
for(i=0;i<len;i++) {
*c=c1[i];
41a: fa 01 movw r30, r20
41c: e2 0f add r30, r18
41e: f3 1f adc r31, r19
420: 80 81 ld r24, Z
422: f6 01 movw r30, r12
424: 81 93 st Z+, r24
426: 6f 01 movw r12, r30
428: 2f 5f subi r18, 0xFF ; 255
42a: 3f 4f sbci r19, 0xFF ; 255
42c: e2 16 cp r14, r18
42e: f3 06 cpc r15, r19
430: a1 f7 brne .-24 ; 0x41a <convert_uint16+0xa2>
432: 27 96 adiw r28, 0x07 ; 7
434: 0f b6 in r0, 0x3f ; 63
436: f8 94 cli
438: de bf out 0x3e, r29 ; 62
43a: 0f be out 0x3f, r0 ; 63
43c: cd bf out 0x3d, r28 ; 61
43e: df 91 pop r29
440: cf 91 pop r28
442: 1f 91 pop r17
444: 0f 91 pop r16
446: ff 90 pop r15
448: ef 90 pop r14
44a: df 90 pop r13
44c: cf 90 pop r12
44e: bf 90 pop r11
450: af 90 pop r10
452: 08 95 ret
 
00000454 <main>:
c++;
 
}
}
 
 
//-----------------------------------------------------------------------------
//main
//main execution loop
//-----------------------------------------------------------------------------
extern int main(void)
{
454: af 92 push r10
456: bf 92 push r11
458: cf 92 push r12
45a: df 92 push r13
45c: ff 92 push r15
45e: 0f 93 push r16
460: 1f 93 push r17
462: cf 93 push r28
464: df 93 push r29
unsigned char c;
unsigned int i;
int i1;
HIDEGRAPHIC;
466: 10 92 00 01 sts 0x0100, r1
HIDEGRAPHICBACK;
46a: 10 92 01 01 sts 0x0101, r1
CLKPR=0x80;
46e: e1 e6 ldi r30, 0x61 ; 97
470: f0 e0 ldi r31, 0x00 ; 0
472: 80 e8 ldi r24, 0x80 ; 128
474: 80 83 st Z, r24
CLKPR=0x00;
476: 10 82 st Z, r1
 
// PORT D - unused right now
PORTD = 0x10;
478: 80 e1 ldi r24, 0x10 ; 16
47a: 8b b9 out 0x0b, r24 ; 11
DDRD = 0x00;
47c: 1a b8 out 0x0a, r1 ; 10
 
// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud rate: 57600
UCSR0A=0x00;
47e: 10 92 c0 00 sts 0x00C0, r1
UCSR0B=0x18;
482: 88 e1 ldi r24, 0x18 ; 24
484: 80 93 c1 00 sts 0x00C1, r24
UCSR0C=0x86;
488: 86 e8 ldi r24, 0x86 ; 134
48a: 80 93 c2 00 sts 0x00C2, r24
#ifdef CPUSPEED_20 //20.000MHz
UBRR0H=0x00;
48e: 10 92 c5 00 sts 0x00C5, r1
UBRR0L=0x15;
492: 85 e1 ldi r24, 0x15 ; 21
494: 80 93 c4 00 sts 0x00C4, r24
#endif
 
#ifdef CPUSPEED_16 //16.000MHz
UBRR0H=0x00;
UBRR0L=0x10;
#endif
#ifdef CPUSPEED_11059 //11.059MHz
UBRR0H=0x00;
UBRR0L=0x0B;
#endif
 
// Initialize the 8-bit Timer0 to clock at 20/8 MHz */
TCCR0A=0x00;
498: 14 bc out 0x24, r1 ; 36
TCCR0B=0x01;
49a: 91 e0 ldi r25, 0x01 ; 1
49c: 95 bd out 0x25, r25 ; 37
 
// Initialize the SPI Interface
PORTB = 0x00;
49e: 15 b8 out 0x05, r1 ; 5
DDRB = 0x3E; //0x3E
4a0: 8e e3 ldi r24, 0x3E ; 62
4a2: 84 b9 out 0x04, r24 ; 4
//DDRB = 0x3A;
SPCR = (1<<SPE) | (1<<MSTR) | (1<<CPHA);
4a4: 84 e5 ldi r24, 0x54 ; 84
4a6: 8c bd out 0x2c, r24 ; 44
SPSR = 1;
4a8: 9d bd out 0x2d, r25 ; 45
 
// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Falling Edge
// INT1: On
// INT1 Mode: Falling Edge
// Interrupt on any change on pins PCINT0-7: Off
// Interrupt on any change on pins PCINT8-14: Off
// Interrupt on any change on pins PCINT16-23: Off
EICRA=0x0A;
4aa: 8a e0 ldi r24, 0x0A ; 10
4ac: 80 93 69 00 sts 0x0069, r24
EIMSK=0x03;
4b0: 83 e0 ldi r24, 0x03 ; 3
4b2: 8d bb out 0x1d, r24 ; 29
EIFR=0x03;
4b4: 8c bb out 0x1c, r24 ; 28
PCICR=0x00;
4b6: 10 92 68 00 sts 0x0068, r1
 
// Enable interrupts
sei();
4ba: 78 94 sei
 
// MAIN lOOP
display_line1[0]='X';
4bc: 88 e5 ldi r24, 0x58 ; 88
4be: 80 93 58 04 sts 0x0458, r24
display_line1[1]='X';
4c2: 80 93 59 04 sts 0x0459, r24
display_line1[2]='X';
4c6: 80 93 5a 04 sts 0x045A, r24
display_line1[3]='X';
4ca: 80 93 5b 04 sts 0x045B, r24
display_line1[4]='X';
4ce: 80 93 5c 04 sts 0x045C, r24
display_line1[5]='X';
4d2: 80 93 5d 04 sts 0x045D, r24
NeuerDatensatzEmpfangen = 0;
4d6: 10 92 e2 03 sts 0x03E2, r1
framecounter = 0;
4da: 10 92 da 03 sts 0x03DA, r1
GR_Clear();
4de: d7 dd rcall .-1106 ; 0x8e <GR_Clear>
GR_Copy(&grlevel[0],(GR_Lines/2)*7,21);
4e0: 45 e1 ldi r20, 0x15 ; 21
4e2: 50 e0 ldi r21, 0x00 ; 0
4e4: 6c e8 ldi r22, 0x8C ; 140
4e6: 70 e0 ldi r23, 0x00 ; 0
4e8: 8b eb ldi r24, 0xBB ; 187
4ea: 93 e0 ldi r25, 0x03 ; 3
4ec: bf dd rcall .-1154 ; 0x6c <GR_Copy>
SHOWGRAPHIC;
4ee: 81 e0 ldi r24, 0x01 ; 1
4f0: 80 93 00 01 sts 0x0100, r24
4f4: ff 24 eor r15, r15
4f6: f3 94 inc r15
4f8: 0f 2e mov r0, r31
4fa: ff ee ldi r31, 0xEF ; 239
4fc: cf 2e mov r12, r31
4fe: f3 e0 ldi r31, 0x03 ; 3
500: df 2e mov r13, r31
502: f0 2d mov r31, r0
504: 08 e0 ldi r16, 0x08 ; 8
506: 14 e0 ldi r17, 0x04 ; 4
508: 0f 2e mov r0, r31
50a: fb eb ldi r31, 0xBB ; 187
50c: af 2e mov r10, r31
50e: f3 e0 ldi r31, 0x03 ; 3
510: bf 2e mov r11, r31
512: f0 2d mov r31, r0
while (1)
{
if (UCSR0A & (1<<RXC0)) {
514: 80 91 c0 00 lds r24, 0x00C0
518: 88 23 and r24, r24
51a: 2c f4 brge .+10 ; 0x526 <__stack+0x27>
c=UDR0;
51c: e6 ec ldi r30, 0xC6 ; 198
51e: f0 e0 ldi r31, 0x00 ; 0
520: 80 81 ld r24, Z
UDR0=c;
522: 80 83 st Z, r24
process_rxdata(c);
524: 48 de rcall .-880 ; 0x1b6 <process_rxdata>
}
if (framecounter<25) showmessage1=1; else showmessage1=0;
526: 80 91 da 03 lds r24, 0x03DA
52a: 89 31 cpi r24, 0x19 ; 25
52c: 18 f4 brcc .+6 ; 0x534 <__stack+0x35>
52e: f0 92 d9 03 sts 0x03D9, r15
532: 06 c0 rjmp .+12 ; 0x540 <__stack+0x41>
534: 10 92 d9 03 sts 0x03D9, r1
if (framecounter>50) framecounter = 0;
538: 83 33 cpi r24, 0x33 ; 51
53a: 10 f0 brcs .+4 ; 0x540 <__stack+0x41>
53c: 10 92 da 03 sts 0x03DA, r1
if(NeuerDatensatzEmpfangen) {
540: 80 91 e2 03 lds r24, 0x03E2
544: 88 23 and r24, r24
546: 31 f3 breq .-52 ; 0x514 <__stack+0x15>
switch(RxdBuffer[2])
548: 80 91 f6 03 lds r24, 0x03F6
54c: 84 34 cpi r24, 0x44 ; 68
54e: 09 f0 breq .+2 ; 0x552 <__stack+0x53>
550: 5f c1 rjmp .+702 ; 0x810 <__stack+0x311>
{
case 'D':
//decode the Messagee
Decode64((unsigned char *)&DebugOut,sizeof(DebugOut),3,AnzahlEmpfangsBytes);
552: 20 91 e4 03 lds r18, 0x03E4
556: 43 e0 ldi r20, 0x03 ; 3
558: 62 e4 ldi r22, 0x42 ; 66
55a: 82 e6 ldi r24, 0x62 ; 98
55c: 94 e0 ldi r25, 0x04 ; 4
55e: a0 dd rcall .-1216 ; 0xa0 <Decode64>
// Heading information
convert_uint16((unsigned char *)&heading[1],3,(unsigned int)DebugOut.Analog[8]);
560: 40 91 74 04 lds r20, 0x0474
564: 50 91 75 04 lds r21, 0x0475
568: 63 e0 ldi r22, 0x03 ; 3
56a: 70 e0 ldi r23, 0x00 ; 0
56c: 8c e0 ldi r24, 0x0C ; 12
56e: 91 e0 ldi r25, 0x01 ; 1
570: 03 df rcall .-506 ; 0x378 <convert_uint16>
// Altitute Information
if(DebugOut.Analog[5]>old_alt) {
572: 20 91 6e 04 lds r18, 0x046E
576: 30 91 6f 04 lds r19, 0x046F
57a: 80 91 eb 03 lds r24, 0x03EB
57e: 90 91 ec 03 lds r25, 0x03EC
582: 82 17 cp r24, r18
584: 93 07 cpc r25, r19
586: 64 f4 brge .+24 ; 0x5a0 <__stack+0xa1>
alt_inc=1;
588: f0 92 de 03 sts 0x03DE, r15
alt_dec=0;
58c: 10 92 df 03 sts 0x03DF, r1
alt_delta=DebugOut.Analog[5]-old_alt;
590: a9 01 movw r20, r18
592: 48 1b sub r20, r24
594: 59 0b sbc r21, r25
596: 50 93 dd 03 sts 0x03DD, r21
59a: 40 93 dc 03 sts 0x03DC, r20
59e: 17 c0 rjmp .+46 ; 0x5ce <__stack+0xcf>
}
else {
if(DebugOut.Analog[5]<old_alt) {
5a0: 28 17 cp r18, r24
5a2: 39 07 cpc r19, r25
5a4: 5c f4 brge .+22 ; 0x5bc <__stack+0xbd>
alt_inc=0;
5a6: 10 92 de 03 sts 0x03DE, r1
alt_dec=1;
5aa: f0 92 df 03 sts 0x03DF, r15
alt_delta=old_alt-DebugOut.Analog[5];
5ae: 82 1b sub r24, r18
5b0: 93 0b sbc r25, r19
5b2: 90 93 dd 03 sts 0x03DD, r25
5b6: 80 93 dc 03 sts 0x03DC, r24
5ba: 09 c0 rjmp .+18 ; 0x5ce <__stack+0xcf>
}
else {
alt_inc=0;
5bc: 10 92 de 03 sts 0x03DE, r1
alt_dec=0;
5c0: 10 92 df 03 sts 0x03DF, r1
alt_delta=0;
5c4: 10 92 dd 03 sts 0x03DD, r1
5c8: 10 92 dc 03 sts 0x03DC, r1
5cc: 0c c0 rjmp .+24 ; 0x5e6 <__stack+0xe7>
}
}
if(alt_delta>60) alt_delta=60;
5ce: 80 91 dc 03 lds r24, 0x03DC
5d2: 90 91 dd 03 lds r25, 0x03DD
5d6: cd 97 sbiw r24, 0x3d ; 61
5d8: 30 f0 brcs .+12 ; 0x5e6 <__stack+0xe7>
5da: 8c e3 ldi r24, 0x3C ; 60
5dc: 90 e0 ldi r25, 0x00 ; 0
5de: 90 93 dd 03 sts 0x03DD, r25
5e2: 80 93 dc 03 sts 0x03DC, r24
if(alt_delta<0) alt_delta=0;
old_alt=DebugOut.Analog[5];
5e6: 30 93 ec 03 sts 0x03EC, r19
5ea: 20 93 eb 03 sts 0x03EB, r18
if(DebugOut.Analog[5]<0) {
5ee: 33 23 and r19, r19
5f0: 5c f4 brge .+22 ; 0x608 <__stack+0x109>
altv[0]='-';
5f2: 8d e2 ldi r24, 0x2D ; 45
5f4: 80 93 30 01 sts 0x0130, r24
DebugOut.Analog[5]=(0xffff-(unsigned int)DebugOut.Analog[5]);
5f8: c9 01 movw r24, r18
5fa: 80 95 com r24
5fc: 90 95 com r25
5fe: 90 93 6f 04 sts 0x046F, r25
602: 80 93 6e 04 sts 0x046E, r24
606: 03 c0 rjmp .+6 ; 0x60e <__stack+0x10f>
}
else {
altv[0]='+';
608: 8b e2 ldi r24, 0x2B ; 43
60a: 80 93 30 01 sts 0x0130, r24
}
convert_uint16((unsigned char *)&altv[1],5,(unsigned int)DebugOut.Analog[5]);
60e: 40 91 6e 04 lds r20, 0x046E
612: 50 91 6f 04 lds r21, 0x046F
616: 65 e0 ldi r22, 0x05 ; 5
618: 70 e0 ldi r23, 0x00 ; 0
61a: 81 e3 ldi r24, 0x31 ; 49
61c: 91 e0 ldi r25, 0x01 ; 1
61e: ac de rcall .-680 ; 0x378 <convert_uint16>
//Voltage value
convert_uint16((unsigned char *)&templine[0],5,(unsigned int)DebugOut.Analog[9]);
620: 40 91 76 04 lds r20, 0x0476
624: 50 91 77 04 lds r21, 0x0477
628: 65 e0 ldi r22, 0x05 ; 5
62a: 70 e0 ldi r23, 0x00 ; 0
62c: c6 01 movw r24, r12
62e: a4 de rcall .-696 ; 0x378 <convert_uint16>
ubat[3]=templine[2];
630: 80 91 f1 03 lds r24, 0x03F1
634: 80 93 1b 01 sts 0x011B, r24
ubat[4]=templine[3];
638: 80 91 f2 03 lds r24, 0x03F2
63c: 80 93 1c 01 sts 0x011C, r24
ubat[6]=templine[4];
640: 80 91 f3 03 lds r24, 0x03F3
644: 80 93 1e 01 sts 0x011E, r24
if(DebugOut.Analog[9]>90) bat[0]=0x08; else bat[0]=0x04;
648: 80 91 76 04 lds r24, 0x0476
64c: 90 91 77 04 lds r25, 0x0477
650: 8b 35 cpi r24, 0x5B ; 91
652: 91 05 cpc r25, r1
654: 34 f0 brlt .+12 ; 0x662 <__stack+0x163>
656: 00 93 10 01 sts 0x0110, r16
if(DebugOut.Analog[9]>95) bat[1]=0x08; else bat[1]=0x04;
65a: 80 36 cpi r24, 0x60 ; 96
65c: 91 05 cpc r25, r1
65e: 24 f4 brge .+8 ; 0x668 <__stack+0x169>
660: 09 c0 rjmp .+18 ; 0x674 <__stack+0x175>
662: 10 93 10 01 sts 0x0110, r17
666: 06 c0 rjmp .+12 ; 0x674 <__stack+0x175>
668: 00 93 11 01 sts 0x0111, r16
if(DebugOut.Analog[9]>100) bat[2]=0x08; else bat[2]=0x04;
66c: 85 36 cpi r24, 0x65 ; 101
66e: 91 05 cpc r25, r1
670: 24 f4 brge .+8 ; 0x67a <__stack+0x17b>
672: 09 c0 rjmp .+18 ; 0x686 <__stack+0x187>
674: 10 93 11 01 sts 0x0111, r17
678: 06 c0 rjmp .+12 ; 0x686 <__stack+0x187>
67a: 00 93 12 01 sts 0x0112, r16
if(DebugOut.Analog[9]>105) bat[3]=0x08; else bat[3]=0x04;
67e: 8a 36 cpi r24, 0x6A ; 106
680: 91 05 cpc r25, r1
682: 24 f4 brge .+8 ; 0x68c <__stack+0x18d>
684: 09 c0 rjmp .+18 ; 0x698 <__stack+0x199>
686: 10 93 12 01 sts 0x0112, r17
68a: 06 c0 rjmp .+12 ; 0x698 <__stack+0x199>
68c: 00 93 13 01 sts 0x0113, r16
if(DebugOut.Analog[9]>110) bat[4]=0x08; else bat[4]=0x04;
690: 8f 36 cpi r24, 0x6F ; 111
692: 91 05 cpc r25, r1
694: 24 f4 brge .+8 ; 0x69e <__stack+0x19f>
696: 09 c0 rjmp .+18 ; 0x6aa <__stack+0x1ab>
698: 10 93 13 01 sts 0x0113, r17
69c: 06 c0 rjmp .+12 ; 0x6aa <__stack+0x1ab>
69e: 00 93 14 01 sts 0x0114, r16
if(DebugOut.Analog[9]>115) bat[5]=0x08; else bat[5]=0x04;
6a2: 84 37 cpi r24, 0x74 ; 116
6a4: 91 05 cpc r25, r1
6a6: 24 f4 brge .+8 ; 0x6b0 <__stack+0x1b1>
6a8: 09 c0 rjmp .+18 ; 0x6bc <__stack+0x1bd>
6aa: 10 93 14 01 sts 0x0114, r17
6ae: 06 c0 rjmp .+12 ; 0x6bc <__stack+0x1bd>
6b0: 00 93 15 01 sts 0x0115, r16
if(DebugOut.Analog[9]>120) bat[6]=0x08; else bat[6]=0x04;
6b4: 89 37 cpi r24, 0x79 ; 121
6b6: 91 05 cpc r25, r1
6b8: 24 f4 brge .+8 ; 0x6c2 <__stack+0x1c3>
6ba: 09 c0 rjmp .+18 ; 0x6ce <__stack+0x1cf>
6bc: 10 93 15 01 sts 0x0115, r17
6c0: 06 c0 rjmp .+12 ; 0x6ce <__stack+0x1cf>
6c2: 00 93 16 01 sts 0x0116, r16
if(DebugOut.Analog[9]>125) bat[7]=0x08; else bat[7]=0x04;
6c6: 8e 37 cpi r24, 0x7E ; 126
6c8: 91 05 cpc r25, r1
6ca: 4c f4 brge .+18 ; 0x6de <__stack+0x1df>
6cc: b4 c0 rjmp .+360 ; 0x836 <__stack+0x337>
6ce: 10 93 16 01 sts 0x0116, r17
6d2: 10 93 17 01 sts 0x0117, r17
if(DebugOut.Analog[9]<94) lowbat=1; else lowbat = 0;
6d6: 8e 35 cpi r24, 0x5E ; 94
6d8: 91 05 cpc r25, r1
6da: 24 f0 brlt .+8 ; 0x6e4 <__stack+0x1e5>
6dc: 06 c0 rjmp .+12 ; 0x6ea <__stack+0x1eb>
6de: 00 93 17 01 sts 0x0117, r16
6e2: 03 c0 rjmp .+6 ; 0x6ea <__stack+0x1eb>
6e4: f0 92 d8 03 sts 0x03D8, r15
6e8: 02 c0 rjmp .+4 ; 0x6ee <__stack+0x1ef>
6ea: 10 92 d8 03 sts 0x03D8, r1
//RX level
i=((unsigned int)DebugOut.Analog[10]*100)/255;
6ee: 20 91 78 04 lds r18, 0x0478
6f2: 30 91 79 04 lds r19, 0x0479
6f6: 84 e6 ldi r24, 0x64 ; 100
6f8: 90 e0 ldi r25, 0x00 ; 0
6fa: ac 01 movw r20, r24
6fc: 24 9f mul r18, r20
6fe: c0 01 movw r24, r0
700: 25 9f mul r18, r21
702: 90 0d add r25, r0
704: 34 9f mul r19, r20
706: 90 0d add r25, r0
708: 11 24 eor r1, r1
70a: 6f ef ldi r22, 0xFF ; 255
70c: 70 e0 ldi r23, 0x00 ; 0
70e: 2c d5 rcall .+2648 ; 0x1168 <__udivmodhi4>
710: eb 01 movw r28, r22
convert_uint16((unsigned char *)&templine[0],5,(unsigned int)i);
712: ab 01 movw r20, r22
714: 65 e0 ldi r22, 0x05 ; 5
716: 70 e0 ldi r23, 0x00 ; 0
718: c6 01 movw r24, r12
71a: 2e de rcall .-932 ; 0x378 <convert_uint16>
urx[4]=templine[2];
71c: 80 91 f1 03 lds r24, 0x03F1
720: 80 93 2c 01 sts 0x012C, r24
urx[5]=templine[3];
724: 80 91 f2 03 lds r24, 0x03F2
728: 80 93 2d 01 sts 0x012D, r24
urx[6]=templine[4];
72c: 80 91 f3 03 lds r24, 0x03F3
730: 80 93 2e 01 sts 0x012E, r24
if(i>10) rx[0]=0x08; else rx[0]=0x04;
734: cb 30 cpi r28, 0x0B ; 11
736: d1 05 cpc r29, r1
738: 30 f0 brcs .+12 ; 0x746 <__stack+0x247>
73a: 00 93 20 01 sts 0x0120, r16
if(i>20) rx[1]=0x08; else rx[1]=0x04;
73e: c5 31 cpi r28, 0x15 ; 21
740: d1 05 cpc r29, r1
742: 20 f4 brcc .+8 ; 0x74c <__stack+0x24d>
744: 09 c0 rjmp .+18 ; 0x758 <__stack+0x259>
746: 10 93 20 01 sts 0x0120, r17
74a: 06 c0 rjmp .+12 ; 0x758 <__stack+0x259>
74c: 00 93 21 01 sts 0x0121, r16
if(i>30) rx[2]=0x08; else rx[2]=0x04;
750: cf 31 cpi r28, 0x1F ; 31
752: d1 05 cpc r29, r1
754: 20 f4 brcc .+8 ; 0x75e <__stack+0x25f>
756: 09 c0 rjmp .+18 ; 0x76a <__stack+0x26b>
758: 10 93 21 01 sts 0x0121, r17
75c: 06 c0 rjmp .+12 ; 0x76a <__stack+0x26b>
75e: 00 93 22 01 sts 0x0122, r16
if(i>40) rx[3]=0x08; else rx[3]=0x04;
762: c9 32 cpi r28, 0x29 ; 41
764: d1 05 cpc r29, r1
766: 20 f4 brcc .+8 ; 0x770 <__stack+0x271>
768: 09 c0 rjmp .+18 ; 0x77c <__stack+0x27d>
76a: 10 93 22 01 sts 0x0122, r17
76e: 06 c0 rjmp .+12 ; 0x77c <__stack+0x27d>
770: 00 93 23 01 sts 0x0123, r16
if(i>50) rx[4]=0x08; else rx[4]=0x04;
774: c3 33 cpi r28, 0x33 ; 51
776: d1 05 cpc r29, r1
778: 20 f4 brcc .+8 ; 0x782 <__stack+0x283>
77a: 09 c0 rjmp .+18 ; 0x78e <__stack+0x28f>
77c: 10 93 23 01 sts 0x0123, r17
780: 06 c0 rjmp .+12 ; 0x78e <__stack+0x28f>
782: 00 93 24 01 sts 0x0124, r16
if(i>60) rx[5]=0x08; else rx[5]=0x04;
786: cd 33 cpi r28, 0x3D ; 61
788: d1 05 cpc r29, r1
78a: 20 f4 brcc .+8 ; 0x794 <__stack+0x295>
78c: 09 c0 rjmp .+18 ; 0x7a0 <__stack+0x2a1>
78e: 10 93 24 01 sts 0x0124, r17
792: 06 c0 rjmp .+12 ; 0x7a0 <__stack+0x2a1>
794: 00 93 25 01 sts 0x0125, r16
if(i>70) rx[6]=0x08; else rx[6]=0x04;
798: c7 34 cpi r28, 0x47 ; 71
79a: d1 05 cpc r29, r1
79c: 20 f4 brcc .+8 ; 0x7a6 <__stack+0x2a7>
79e: 09 c0 rjmp .+18 ; 0x7b2 <__stack+0x2b3>
7a0: 10 93 25 01 sts 0x0125, r17
7a4: 06 c0 rjmp .+12 ; 0x7b2 <__stack+0x2b3>
7a6: 00 93 26 01 sts 0x0126, r16
if(i>80) rx[7]=0x08; else rx[7]=0x04;
7aa: c1 35 cpi r28, 0x51 ; 81
7ac: d1 05 cpc r29, r1
7ae: 20 f4 brcc .+8 ; 0x7b8 <__stack+0x2b9>
7b0: 06 c0 rjmp .+12 ; 0x7be <__stack+0x2bf>
7b2: 10 93 26 01 sts 0x0126, r17
7b6: 03 c0 rjmp .+6 ; 0x7be <__stack+0x2bf>
7b8: 00 93 27 01 sts 0x0127, r16
7bc: 02 c0 rjmp .+4 ; 0x7c2 <__stack+0x2c3>
7be: 10 93 27 01 sts 0x0127, r17
// nick
i1=DebugOut.Analog[0]/50;
7c2: 80 91 64 04 lds r24, 0x0464
7c6: 90 91 65 04 lds r25, 0x0465
7ca: 62 e3 ldi r22, 0x32 ; 50
7cc: 70 e0 ldi r23, 0x00 ; 0
7ce: e0 d4 rcall .+2496 ; 0x1190 <__divmodhi4>
i1=((GR_Lines/2)-i1);
7d0: 84 e1 ldi r24, 0x14 ; 20
7d2: 90 e0 ldi r25, 0x00 ; 0
7d4: ec 01 movw r28, r24
7d6: c6 1b sub r28, r22
7d8: d7 0b sbc r29, r23
if(i1<0) i1=0;
7da: ea f0 brmi .+58 ; 0x816 <__stack+0x317>
if(i1>37) i1=37;
7dc: c6 32 cpi r28, 0x26 ; 38
7de: d1 05 cpc r29, r1
7e0: 14 f5 brge .+68 ; 0x826 <__stack+0x327>
GR_Clear();
7e2: 55 dc rcall .-1878 ; 0x8e <GR_Clear>
GR_Copy(&grlevel[0],i1*7,21);
7e4: be 01 movw r22, r28
7e6: 66 0f add r22, r22
7e8: 77 1f adc r23, r23
7ea: 66 0f add r22, r22
7ec: 77 1f adc r23, r23
7ee: 66 0f add r22, r22
7f0: 77 1f adc r23, r23
7f2: 6c 1b sub r22, r28
7f4: 7d 0b sbc r23, r29
7f6: 45 e1 ldi r20, 0x15 ; 21
7f8: 50 e0 ldi r21, 0x00 ; 0
7fa: c5 01 movw r24, r10
7fc: 37 dc rcall .-1938 ; 0x6c <GR_Copy>
if(i1!=20) GR_Copy(&grlevel0[0],20*7,7);
7fe: 64 97 sbiw r28, 0x14 ; 20
800: 39 f0 breq .+14 ; 0x810 <__stack+0x311>
802: 47 e0 ldi r20, 0x07 ; 7
804: 50 e0 ldi r21, 0x00 ; 0
806: 6c e8 ldi r22, 0x8C ; 140
808: 70 e0 ldi r23, 0x00 ; 0
80a: 80 ed ldi r24, 0xD0 ; 208
80c: 93 e0 ldi r25, 0x03 ; 3
80e: 2e dc rcall .-1956 ; 0x6c <GR_Copy>
break;
 
default:
break;
}
NeuerDatensatzEmpfangen=0;
810: 10 92 e2 03 sts 0x03E2, r1
814: 7f ce rjmp .-770 ; 0x514 <__stack+0x15>
816: 3b dc rcall .-1930 ; 0x8e <GR_Clear>
818: 45 e1 ldi r20, 0x15 ; 21
81a: 50 e0 ldi r21, 0x00 ; 0
81c: 60 e0 ldi r22, 0x00 ; 0
81e: 70 e0 ldi r23, 0x00 ; 0
820: c5 01 movw r24, r10
822: 24 dc rcall .-1976 ; 0x6c <GR_Copy>
824: ee cf rjmp .-36 ; 0x802 <__stack+0x303>
826: 33 dc rcall .-1946 ; 0x8e <GR_Clear>
828: 45 e1 ldi r20, 0x15 ; 21
82a: 50 e0 ldi r21, 0x00 ; 0
82c: 63 e0 ldi r22, 0x03 ; 3
82e: 71 e0 ldi r23, 0x01 ; 1
830: c5 01 movw r24, r10
832: 1c dc rcall .-1992 ; 0x6c <GR_Copy>
834: e6 cf rjmp .-52 ; 0x802 <__stack+0x303>
836: 10 93 17 01 sts 0x0117, r17
83a: 57 cf rjmp .-338 ; 0x6ea <__stack+0x1eb>
 
0000083c <draw_line>:
}
}
return(1);
} /* main */
 
 
 
//-----------------------------------------------------------------------------
// draw line()
// will be executed in interrupt context and will display the overlay content
//-----------------------------------------------------------------------------*/
extern void draw_line()
{
83c: 40 91 ed 03 lds r20, 0x03ED
840: 50 91 ee 03 lds r21, 0x03EE
844: ca 01 movw r24, r20
846: 84 97 sbiw r24, 0x24 ; 36
848: 07 97 sbiw r24, 0x07 ; 7
84a: 08 f0 brcs .+2 ; 0x84e <draw_line+0x12>
84c: 03 c1 rjmp .+518 ; 0xa54 <draw_line+0x218>
unsigned char *ltr_p;
unsigned char *num_p;
unsigned char *info_p;
short ltemp;
short ntemp;
short itemp;
unsigned int i1;
unsigned char i=0;
unsigned char c1;
unsigned char c2;
unsigned char c3;
unsigned char c4;
unsigned char c5;
unsigned char c6;
unsigned char c7;
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Bat and Heading output
if ((line > 35) && (line < 43))
{
ltemp = (line - 36) * 27 - 64;
ntemp = (line - 36) * 16 - 43;
itemp = (line - 36) * 9;
ltr_p = ltrs+ltemp;
num_p = nums+ntemp;
84e: ca 01 movw r24, r20
850: 82 95 swap r24
852: 92 95 swap r25
854: 90 7f andi r25, 0xF0 ; 240
856: 98 27 eor r25, r24
858: 80 7f andi r24, 0xF0 ; 240
85a: 98 27 eor r25, r24
85c: bc 01 movw r22, r24
85e: 6f 55 subi r22, 0x5F ; 95
860: 7f 4f sbci r23, 0xFF ; 255
info_p = infos+itemp;
862: ca 01 movw r24, r20
864: 88 0f add r24, r24
866: 99 1f adc r25, r25
868: 88 0f add r24, r24
86a: 99 1f adc r25, r25
86c: 88 0f add r24, r24
86e: 99 1f adc r25, r25
870: 84 0f add r24, r20
872: 95 1f adc r25, r21
874: 9c 01 movw r18, r24
876: 28 5c subi r18, 0xC8 ; 200
878: 3d 4f sbci r19, 0xFD ; 253
// +++ Bat
while(TCNT0<LINESTART);
87a: 86 b5 in r24, 0x26 ; 38
87c: 88 3c cpi r24, 0xC8 ; 200
87e: e8 f3 brcs .-6 ; 0x87a <draw_line+0x3e>
TCNT0=0;
880: 16 bc out 0x26, r1 ; 38
SPSR=1;
882: 81 e0 ldi r24, 0x01 ; 1
884: 8d bd out 0x2d, r24 ; 45
DDRB|=1; //sink thru PB0
886: 20 9a sbi 0x04, 0 ; 4
SPDR = info_p[bat[0]]; Wait();
888: 80 91 10 01 lds r24, 0x0110
88c: f9 01 movw r30, r18
88e: e8 0f add r30, r24
890: f1 1d adc r31, r1
892: 80 81 ld r24, Z
894: 8e bd out 0x2e, r24 ; 46
896: 0d b4 in r0, 0x2d ; 45
898: 07 fe sbrs r0, 7
89a: fd cf rjmp .-6 ; 0x896 <draw_line+0x5a>
SPDR = info_p[bat[1]]; Wait();
89c: 80 91 11 01 lds r24, 0x0111
8a0: f9 01 movw r30, r18
8a2: e8 0f add r30, r24
8a4: f1 1d adc r31, r1
8a6: 80 81 ld r24, Z
8a8: 8e bd out 0x2e, r24 ; 46
8aa: 0d b4 in r0, 0x2d ; 45
8ac: 07 fe sbrs r0, 7
8ae: fd cf rjmp .-6 ; 0x8aa <draw_line+0x6e>
SPDR = info_p[bat[2]]; Wait();
8b0: 80 91 12 01 lds r24, 0x0112
8b4: f9 01 movw r30, r18
8b6: e8 0f add r30, r24
8b8: f1 1d adc r31, r1
8ba: 80 81 ld r24, Z
8bc: 8e bd out 0x2e, r24 ; 46
8be: 0d b4 in r0, 0x2d ; 45
8c0: 07 fe sbrs r0, 7
8c2: fd cf rjmp .-6 ; 0x8be <draw_line+0x82>
SPDR = info_p[bat[3]]; Wait();
8c4: 80 91 13 01 lds r24, 0x0113
8c8: f9 01 movw r30, r18
8ca: e8 0f add r30, r24
8cc: f1 1d adc r31, r1
8ce: 80 81 ld r24, Z
8d0: 8e bd out 0x2e, r24 ; 46
8d2: 0d b4 in r0, 0x2d ; 45
8d4: 07 fe sbrs r0, 7
8d6: fd cf rjmp .-6 ; 0x8d2 <draw_line+0x96>
SPDR = info_p[bat[4]]; Wait();
8d8: 80 91 14 01 lds r24, 0x0114
8dc: f9 01 movw r30, r18
8de: e8 0f add r30, r24
8e0: f1 1d adc r31, r1
8e2: 80 81 ld r24, Z
8e4: 8e bd out 0x2e, r24 ; 46
8e6: 0d b4 in r0, 0x2d ; 45
8e8: 07 fe sbrs r0, 7
8ea: fd cf rjmp .-6 ; 0x8e6 <draw_line+0xaa>
SPDR = info_p[bat[5]]; Wait();
8ec: 80 91 15 01 lds r24, 0x0115
8f0: f9 01 movw r30, r18
8f2: e8 0f add r30, r24
8f4: f1 1d adc r31, r1
8f6: 80 81 ld r24, Z
8f8: 8e bd out 0x2e, r24 ; 46
8fa: 0d b4 in r0, 0x2d ; 45
8fc: 07 fe sbrs r0, 7
8fe: fd cf rjmp .-6 ; 0x8fa <draw_line+0xbe>
SPDR = info_p[bat[6]]; Wait();
900: 80 91 16 01 lds r24, 0x0116
904: f9 01 movw r30, r18
906: e8 0f add r30, r24
908: f1 1d adc r31, r1
90a: 80 81 ld r24, Z
90c: 8e bd out 0x2e, r24 ; 46
90e: 0d b4 in r0, 0x2d ; 45
910: 07 fe sbrs r0, 7
912: fd cf rjmp .-6 ; 0x90e <draw_line+0xd2>
SPDR = info_p[bat[7]]; Wait();
914: 80 91 17 01 lds r24, 0x0117
918: f9 01 movw r30, r18
91a: e8 0f add r30, r24
91c: f1 1d adc r31, r1
91e: 80 81 ld r24, Z
920: 8e bd out 0x2e, r24 ; 46
922: 0d b4 in r0, 0x2d ; 45
924: 07 fe sbrs r0, 7
926: fd cf rjmp .-6 ; 0x922 <draw_line+0xe6>
DDRB&=0xFE; //PB0 Hi-Z again, and load a blank so spacing is right
928: 20 98 cbi 0x04, 0 ; 4
// +++ Heading
TCNT0=0;
92a: 16 bc out 0x26, r1 ; 38
while(TCNT0<80);
92c: 86 b5 in r24, 0x26 ; 38
92e: 80 35 cpi r24, 0x50 ; 80
930: e8 f3 brcs .-6 ; 0x92c <draw_line+0xf0>
TCNT0=0;
932: 16 bc out 0x26, r1 ; 38
SPSR=0;
934: 1d bc out 0x2d, r1 ; 45
DDRB|=1;
936: 20 9a sbi 0x04, 0 ; 4
SPDR = info_p[heading[0]]; Wait();
938: 80 91 0b 01 lds r24, 0x010B
93c: f9 01 movw r30, r18
93e: e8 0f add r30, r24
940: f1 1d adc r31, r1
942: 80 81 ld r24, Z
944: 8e bd out 0x2e, r24 ; 46
946: 0d b4 in r0, 0x2d ; 45
948: 07 fe sbrs r0, 7
94a: fd cf rjmp .-6 ; 0x946 <draw_line+0x10a>
SPDR = num_p[heading[1]]; Wait();
94c: 80 91 0c 01 lds r24, 0x010C
950: fb 01 movw r30, r22
952: e8 0f add r30, r24
954: f1 1d adc r31, r1
956: 80 81 ld r24, Z
958: 8e bd out 0x2e, r24 ; 46
95a: 0d b4 in r0, 0x2d ; 45
95c: 07 fe sbrs r0, 7
95e: fd cf rjmp .-6 ; 0x95a <draw_line+0x11e>
SPDR = num_p[heading[2]]; Wait();
960: 80 91 0d 01 lds r24, 0x010D
964: fb 01 movw r30, r22
966: e8 0f add r30, r24
968: f1 1d adc r31, r1
96a: 80 81 ld r24, Z
96c: 8e bd out 0x2e, r24 ; 46
96e: 0d b4 in r0, 0x2d ; 45
970: 07 fe sbrs r0, 7
972: fd cf rjmp .-6 ; 0x96e <draw_line+0x132>
SPDR = num_p[heading[3]]; Wait();
974: 80 91 0e 01 lds r24, 0x010E
978: fb 01 movw r30, r22
97a: e8 0f add r30, r24
97c: f1 1d adc r31, r1
97e: 80 81 ld r24, Z
980: 8e bd out 0x2e, r24 ; 46
982: 0d b4 in r0, 0x2d ; 45
984: 07 fe sbrs r0, 7
986: fd cf rjmp .-6 ; 0x982 <draw_line+0x146>
SPDR = info_p[heading[4]]; Wait();
988: 80 91 0f 01 lds r24, 0x010F
98c: f9 01 movw r30, r18
98e: e8 0f add r30, r24
990: f1 1d adc r31, r1
992: 80 81 ld r24, Z
994: 8e bd out 0x2e, r24 ; 46
996: 0d b4 in r0, 0x2d ; 45
998: 07 fe sbrs r0, 7
99a: fd cf rjmp .-6 ; 0x996 <draw_line+0x15a>
DDRB&=0xFE; //PB0 Hi-Z again, and load a blank so spacing is right
99c: 20 98 cbi 0x04, 0 ; 4
// +++ RX Level
while(TCNT0<250);
99e: 86 b5 in r24, 0x26 ; 38
9a0: 8a 3f cpi r24, 0xFA ; 250
9a2: e8 f3 brcs .-6 ; 0x99e <draw_line+0x162>
TCNT0=0;
9a4: 16 bc out 0x26, r1 ; 38
while(TCNT0<70);
9a6: 86 b5 in r24, 0x26 ; 38
9a8: 86 34 cpi r24, 0x46 ; 70
9aa: e8 f3 brcs .-6 ; 0x9a6 <draw_line+0x16a>
SPSR=1;
9ac: 81 e0 ldi r24, 0x01 ; 1
9ae: 8d bd out 0x2d, r24 ; 45
DDRB|=1;
9b0: 20 9a sbi 0x04, 0 ; 4
SPDR = info_p[rx[0]]; Wait();
9b2: 80 91 20 01 lds r24, 0x0120
9b6: f9 01 movw r30, r18
9b8: e8 0f add r30, r24
9ba: f1 1d adc r31, r1
9bc: 80 81 ld r24, Z
9be: 8e bd out 0x2e, r24 ; 46
9c0: 0d b4 in r0, 0x2d ; 45
9c2: 07 fe sbrs r0, 7
9c4: fd cf rjmp .-6 ; 0x9c0 <draw_line+0x184>
SPDR = info_p[rx[1]]; Wait();
9c6: 80 91 21 01 lds r24, 0x0121
9ca: f9 01 movw r30, r18
9cc: e8 0f add r30, r24
9ce: f1 1d adc r31, r1
9d0: 80 81 ld r24, Z
9d2: 8e bd out 0x2e, r24 ; 46
9d4: 0d b4 in r0, 0x2d ; 45
9d6: 07 fe sbrs r0, 7
9d8: fd cf rjmp .-6 ; 0x9d4 <draw_line+0x198>
SPDR = info_p[rx[2]]; Wait();
9da: 80 91 22 01 lds r24, 0x0122
9de: f9 01 movw r30, r18
9e0: e8 0f add r30, r24
9e2: f1 1d adc r31, r1
9e4: 80 81 ld r24, Z
9e6: 8e bd out 0x2e, r24 ; 46
9e8: 0d b4 in r0, 0x2d ; 45
9ea: 07 fe sbrs r0, 7
9ec: fd cf rjmp .-6 ; 0x9e8 <draw_line+0x1ac>
SPDR = info_p[rx[3]]; Wait();
9ee: 80 91 23 01 lds r24, 0x0123
9f2: f9 01 movw r30, r18
9f4: e8 0f add r30, r24
9f6: f1 1d adc r31, r1
9f8: 80 81 ld r24, Z
9fa: 8e bd out 0x2e, r24 ; 46
9fc: 0d b4 in r0, 0x2d ; 45
9fe: 07 fe sbrs r0, 7
a00: fd cf rjmp .-6 ; 0x9fc <draw_line+0x1c0>
SPDR = info_p[rx[4]]; Wait();
a02: 80 91 24 01 lds r24, 0x0124
a06: f9 01 movw r30, r18
a08: e8 0f add r30, r24
a0a: f1 1d adc r31, r1
a0c: 80 81 ld r24, Z
a0e: 8e bd out 0x2e, r24 ; 46
a10: 0d b4 in r0, 0x2d ; 45
a12: 07 fe sbrs r0, 7
a14: fd cf rjmp .-6 ; 0xa10 <draw_line+0x1d4>
SPDR = info_p[rx[5]]; Wait();
a16: 80 91 25 01 lds r24, 0x0125
a1a: f9 01 movw r30, r18
a1c: e8 0f add r30, r24
a1e: f1 1d adc r31, r1
a20: 80 81 ld r24, Z
a22: 8e bd out 0x2e, r24 ; 46
a24: 0d b4 in r0, 0x2d ; 45
a26: 07 fe sbrs r0, 7
a28: fd cf rjmp .-6 ; 0xa24 <draw_line+0x1e8>
SPDR = info_p[rx[6]]; Wait();
a2a: 80 91 26 01 lds r24, 0x0126
a2e: f9 01 movw r30, r18
a30: e8 0f add r30, r24
a32: f1 1d adc r31, r1
a34: 80 81 ld r24, Z
a36: 8e bd out 0x2e, r24 ; 46
a38: 0d b4 in r0, 0x2d ; 45
a3a: 07 fe sbrs r0, 7
a3c: fd cf rjmp .-6 ; 0xa38 <draw_line+0x1fc>
SPDR = info_p[rx[7]]; Wait();
a3e: 80 91 27 01 lds r24, 0x0127
a42: f9 01 movw r30, r18
a44: e8 0f add r30, r24
a46: f1 1d adc r31, r1
a48: 80 81 ld r24, Z
a4a: 8e bd out 0x2e, r24 ; 46
a4c: 0d b4 in r0, 0x2d ; 45
a4e: 07 fe sbrs r0, 7
a50: fd cf rjmp .-6 ; 0xa4c <draw_line+0x210>
DDRB&=0xFE;
a52: 20 98 cbi 0x04, 0 ; 4
}
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// UBat
if ((line > 44) && (line < 52))
a54: ca 01 movw r24, r20
a56: 8d 97 sbiw r24, 0x2d ; 45
a58: 07 97 sbiw r24, 0x07 ; 7
a5a: 08 f0 brcs .+2 ; 0xa5e <draw_line+0x222>
a5c: d4 c0 rjmp .+424 ; 0xc06 <draw_line+0x3ca>
{
ltemp = (line - 45) * 27 - 64;
ntemp = (line - 45) * 16 - 43;
itemp = (line - 45) * 9;
ltr_p = ltrs+ltemp;
a5e: ca 01 movw r24, r20
a60: 88 0f add r24, r24
a62: 99 1f adc r25, r25
a64: 84 0f add r24, r20
a66: 95 1f adc r25, r21
a68: 9c 01 movw r18, r24
a6a: 22 0f add r18, r18
a6c: 33 1f adc r19, r19
a6e: 22 0f add r18, r18
a70: 33 1f adc r19, r19
a72: 22 0f add r18, r18
a74: 33 1f adc r19, r19
a76: 82 0f add r24, r18
a78: 93 1f adc r25, r19
a7a: bc 01 movw r22, r24
a7c: 60 5b subi r22, 0xB0 ; 176
a7e: 72 40 sbci r23, 0x02 ; 2
num_p = nums+ntemp;
a80: ca 01 movw r24, r20
a82: 82 95 swap r24
a84: 92 95 swap r25
a86: 90 7f andi r25, 0xF0 ; 240
a88: 98 27 eor r25, r24
a8a: 80 7f andi r24, 0xF0 ; 240
a8c: 98 27 eor r25, r24
a8e: 9c 01 movw r18, r24
a90: 2f 5e subi r18, 0xEF ; 239
a92: 3f 4f sbci r19, 0xFF ; 255
info_p = infos+itemp;
// +++ UBat
while(TCNT0<LINESTART);
a94: 86 b5 in r24, 0x26 ; 38
a96: 88 3c cpi r24, 0xC8 ; 200
a98: e8 f3 brcs .-6 ; 0xa94 <draw_line+0x258>
TCNT0=0;
a9a: 16 bc out 0x26, r1 ; 38
SPSR=1;
a9c: 81 e0 ldi r24, 0x01 ; 1
a9e: 8d bd out 0x2d, r24 ; 45
DDRB|=1;
aa0: 20 9a sbi 0x04, 0 ; 4
SPDR = ltr_p[ubat[0]]; Wait();
aa2: 80 91 18 01 lds r24, 0x0118
aa6: fb 01 movw r30, r22
aa8: e8 0f add r30, r24
aaa: f1 1d adc r31, r1
aac: 80 81 ld r24, Z
aae: 8e bd out 0x2e, r24 ; 46
ab0: 0d b4 in r0, 0x2d ; 45
ab2: 07 fe sbrs r0, 7
ab4: fd cf rjmp .-6 ; 0xab0 <draw_line+0x274>
SPDR = num_p[ubat[1]]; Wait();
ab6: 80 91 19 01 lds r24, 0x0119
aba: f9 01 movw r30, r18
abc: e8 0f add r30, r24
abe: f1 1d adc r31, r1
ac0: 80 81 ld r24, Z
ac2: 8e bd out 0x2e, r24 ; 46
ac4: 0d b4 in r0, 0x2d ; 45
ac6: 07 fe sbrs r0, 7
ac8: fd cf rjmp .-6 ; 0xac4 <draw_line+0x288>
SPDR = ltr_p[ubat[2]]; Wait();
aca: 80 91 1a 01 lds r24, 0x011A
ace: fb 01 movw r30, r22
ad0: e8 0f add r30, r24
ad2: f1 1d adc r31, r1
ad4: 80 81 ld r24, Z
ad6: 8e bd out 0x2e, r24 ; 46
ad8: 0d b4 in r0, 0x2d ; 45
ada: 07 fe sbrs r0, 7
adc: fd cf rjmp .-6 ; 0xad8 <draw_line+0x29c>
SPDR = num_p[ubat[3]]; Wait();
ade: 80 91 1b 01 lds r24, 0x011B
ae2: f9 01 movw r30, r18
ae4: e8 0f add r30, r24
ae6: f1 1d adc r31, r1
ae8: 80 81 ld r24, Z
aea: 8e bd out 0x2e, r24 ; 46
aec: 0d b4 in r0, 0x2d ; 45
aee: 07 fe sbrs r0, 7
af0: fd cf rjmp .-6 ; 0xaec <draw_line+0x2b0>
SPDR = num_p[ubat[4]]; Wait();
af2: 80 91 1c 01 lds r24, 0x011C
af6: f9 01 movw r30, r18
af8: e8 0f add r30, r24
afa: f1 1d adc r31, r1
afc: 80 81 ld r24, Z
afe: 8e bd out 0x2e, r24 ; 46
b00: 0d b4 in r0, 0x2d ; 45
b02: 07 fe sbrs r0, 7
b04: fd cf rjmp .-6 ; 0xb00 <draw_line+0x2c4>
SPDR = num_p[ubat[5]]; Wait();
b06: 80 91 1d 01 lds r24, 0x011D
b0a: f9 01 movw r30, r18
b0c: e8 0f add r30, r24
b0e: f1 1d adc r31, r1
b10: 80 81 ld r24, Z
b12: 8e bd out 0x2e, r24 ; 46
b14: 0d b4 in r0, 0x2d ; 45
b16: 07 fe sbrs r0, 7
b18: fd cf rjmp .-6 ; 0xb14 <draw_line+0x2d8>
SPDR = num_p[ubat[6]]; Wait();
b1a: 80 91 1e 01 lds r24, 0x011E
b1e: f9 01 movw r30, r18
b20: e8 0f add r30, r24
b22: f1 1d adc r31, r1
b24: 80 81 ld r24, Z
b26: 8e bd out 0x2e, r24 ; 46
b28: 0d b4 in r0, 0x2d ; 45
b2a: 07 fe sbrs r0, 7
b2c: fd cf rjmp .-6 ; 0xb28 <draw_line+0x2ec>
SPDR = ltr_p[ubat[7]]; Wait();
b2e: 80 91 1f 01 lds r24, 0x011F
b32: fb 01 movw r30, r22
b34: e8 0f add r30, r24
b36: f1 1d adc r31, r1
b38: 80 81 ld r24, Z
b3a: 8e bd out 0x2e, r24 ; 46
b3c: 0d b4 in r0, 0x2d ; 45
b3e: 07 fe sbrs r0, 7
b40: fd cf rjmp .-6 ; 0xb3c <draw_line+0x300>
DDRB&=0xFE;
b42: 20 98 cbi 0x04, 0 ; 4
TCNT0=0;
b44: 16 bc out 0x26, r1 ; 38
while(TCNT0<80);
b46: 86 b5 in r24, 0x26 ; 38
b48: 80 35 cpi r24, 0x50 ; 80
b4a: e8 f3 brcs .-6 ; 0xb46 <draw_line+0x30a>
TCNT0=0;
b4c: 16 bc out 0x26, r1 ; 38
while(TCNT0<250);
b4e: 86 b5 in r24, 0x26 ; 38
b50: 8a 3f cpi r24, 0xFA ; 250
b52: e8 f3 brcs .-6 ; 0xb4e <draw_line+0x312>
TCNT0=0;
b54: 16 bc out 0x26, r1 ; 38
while(TCNT0<70);
b56: 86 b5 in r24, 0x26 ; 38
b58: 86 34 cpi r24, 0x46 ; 70
b5a: e8 f3 brcs .-6 ; 0xb56 <draw_line+0x31a>
TCNT0=0;
b5c: 16 bc out 0x26, r1 ; 38
SPSR=1;
b5e: 81 e0 ldi r24, 0x01 ; 1
b60: 8d bd out 0x2d, r24 ; 45
DDRB|=1;
b62: 20 9a sbi 0x04, 0 ; 4
SPDR = ltr_p[urx[0]]; Wait();
b64: 80 91 28 01 lds r24, 0x0128
b68: fb 01 movw r30, r22
b6a: e8 0f add r30, r24
b6c: f1 1d adc r31, r1
b6e: 80 81 ld r24, Z
b70: 8e bd out 0x2e, r24 ; 46
b72: 0d b4 in r0, 0x2d ; 45
b74: 07 fe sbrs r0, 7
b76: fd cf rjmp .-6 ; 0xb72 <draw_line+0x336>
SPDR = ltr_p[urx[1]]; Wait();
b78: 80 91 29 01 lds r24, 0x0129
b7c: fb 01 movw r30, r22
b7e: e8 0f add r30, r24
b80: f1 1d adc r31, r1
b82: 80 81 ld r24, Z
b84: 8e bd out 0x2e, r24 ; 46
b86: 0d b4 in r0, 0x2d ; 45
b88: 07 fe sbrs r0, 7
b8a: fd cf rjmp .-6 ; 0xb86 <draw_line+0x34a>
SPDR = num_p[urx[2]]; Wait();
b8c: 80 91 2a 01 lds r24, 0x012A
b90: f9 01 movw r30, r18
b92: e8 0f add r30, r24
b94: f1 1d adc r31, r1
b96: 80 81 ld r24, Z
b98: 8e bd out 0x2e, r24 ; 46
b9a: 0d b4 in r0, 0x2d ; 45
b9c: 07 fe sbrs r0, 7
b9e: fd cf rjmp .-6 ; 0xb9a <draw_line+0x35e>
SPDR = ltr_p[urx[3]]; Wait();
ba0: 80 91 2b 01 lds r24, 0x012B
ba4: fb 01 movw r30, r22
ba6: e8 0f add r30, r24
ba8: f1 1d adc r31, r1
baa: 80 81 ld r24, Z
bac: 8e bd out 0x2e, r24 ; 46
bae: 0d b4 in r0, 0x2d ; 45
bb0: 07 fe sbrs r0, 7
bb2: fd cf rjmp .-6 ; 0xbae <draw_line+0x372>
SPDR = num_p[urx[4]]; Wait();
bb4: 80 91 2c 01 lds r24, 0x012C
bb8: f9 01 movw r30, r18
bba: e8 0f add r30, r24
bbc: f1 1d adc r31, r1
bbe: 80 81 ld r24, Z
bc0: 8e bd out 0x2e, r24 ; 46
bc2: 0d b4 in r0, 0x2d ; 45
bc4: 07 fe sbrs r0, 7
bc6: fd cf rjmp .-6 ; 0xbc2 <draw_line+0x386>
SPDR = num_p[urx[5]]; Wait();
bc8: 80 91 2d 01 lds r24, 0x012D
bcc: f9 01 movw r30, r18
bce: e8 0f add r30, r24
bd0: f1 1d adc r31, r1
bd2: 80 81 ld r24, Z
bd4: 8e bd out 0x2e, r24 ; 46
bd6: 0d b4 in r0, 0x2d ; 45
bd8: 07 fe sbrs r0, 7
bda: fd cf rjmp .-6 ; 0xbd6 <draw_line+0x39a>
SPDR = num_p[urx[6]]; Wait();
bdc: 80 91 2e 01 lds r24, 0x012E
be0: f9 01 movw r30, r18
be2: e8 0f add r30, r24
be4: f1 1d adc r31, r1
be6: 80 81 ld r24, Z
be8: 8e bd out 0x2e, r24 ; 46
bea: 0d b4 in r0, 0x2d ; 45
bec: 07 fe sbrs r0, 7
bee: fd cf rjmp .-6 ; 0xbea <draw_line+0x3ae>
SPDR = num_p[urx[7]]; Wait();
bf0: 80 91 2f 01 lds r24, 0x012F
bf4: f9 01 movw r30, r18
bf6: e8 0f add r30, r24
bf8: f1 1d adc r31, r1
bfa: 80 81 ld r24, Z
bfc: 8e bd out 0x2e, r24 ; 46
bfe: 0d b4 in r0, 0x2d ; 45
c00: 07 fe sbrs r0, 7
c02: fd cf rjmp .-6 ; 0xbfe <draw_line+0x3c2>
DDRB&=0xFE;
c04: 20 98 cbi 0x04, 0 ; 4
}
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Message
if ((line > 60) && (line < 68) && (showmessage1) && (lowbat))
c06: ca 01 movw r24, r20
c08: cd 97 sbiw r24, 0x3d ; 61
c0a: 07 97 sbiw r24, 0x07 ; 7
c0c: 08 f0 brcs .+2 ; 0xc10 <draw_line+0x3d4>
c0e: 9c c0 rjmp .+312 ; 0xd48 <draw_line+0x50c>
c10: 80 91 d9 03 lds r24, 0x03D9
c14: 88 23 and r24, r24
c16: 09 f4 brne .+2 ; 0xc1a <draw_line+0x3de>
c18: 97 c0 rjmp .+302 ; 0xd48 <draw_line+0x50c>
c1a: 80 91 d8 03 lds r24, 0x03D8
c1e: 88 23 and r24, r24
c20: 09 f4 brne .+2 ; 0xc24 <draw_line+0x3e8>
c22: 92 c0 rjmp .+292 ; 0xd48 <draw_line+0x50c>
{
ltemp = (line - 61) * 27 - 64;
ntemp = (line - 61) * 16 - 43;
itemp = (line - 61) * 9;
ltr_p = ltrs+ltemp;
c24: ca 01 movw r24, r20
c26: 88 0f add r24, r24
c28: 99 1f adc r25, r25
c2a: 84 0f add r24, r20
c2c: 95 1f adc r25, r21
c2e: 9c 01 movw r18, r24
c30: 22 0f add r18, r18
c32: 33 1f adc r19, r19
c34: 22 0f add r18, r18
c36: 33 1f adc r19, r19
c38: 22 0f add r18, r18
c3a: 33 1f adc r19, r19
c3c: 82 0f add r24, r18
c3e: 93 1f adc r25, r19
c40: 9c 01 movw r18, r24
c42: 20 56 subi r18, 0x60 ; 96
c44: 34 40 sbci r19, 0x04 ; 4
num_p = nums+ntemp;
info_p = infos+itemp;
// +++ UBat
while(TCNT0<LINESTART);
c46: 86 b5 in r24, 0x26 ; 38
c48: 88 3c cpi r24, 0xC8 ; 200
c4a: e8 f3 brcs .-6 ; 0xc46 <draw_line+0x40a>
TCNT0=0;
c4c: 16 bc out 0x26, r1 ; 38
while(TCNT0<250);
c4e: 86 b5 in r24, 0x26 ; 38
c50: 8a 3f cpi r24, 0xFA ; 250
c52: e8 f3 brcs .-6 ; 0xc4e <draw_line+0x412>
SPSR=1;
c54: 81 e0 ldi r24, 0x01 ; 1
c56: 8d bd out 0x2d, r24 ; 45
SPDR = ltr_p[Message_LowBat[0]]; Wait();
c58: f9 01 movw r30, r18
c5a: e0 5c subi r30, 0xC0 ; 192
c5c: ff 4f sbci r31, 0xFF ; 255
c5e: 80 81 ld r24, Z
c60: 8e bd out 0x2e, r24 ; 46
c62: 0d b4 in r0, 0x2d ; 45
c64: 07 fe sbrs r0, 7
c66: fd cf rjmp .-6 ; 0xc62 <draw_line+0x426>
SPDR = ltr_p[Message_LowBat[1]]; Wait();
c68: f9 01 movw r30, r18
c6a: e0 5c subi r30, 0xC0 ; 192
c6c: ff 4f sbci r31, 0xFF ; 255
c6e: 80 81 ld r24, Z
c70: 8e bd out 0x2e, r24 ; 46
c72: 0d b4 in r0, 0x2d ; 45
c74: 07 fe sbrs r0, 7
c76: fd cf rjmp .-6 ; 0xc72 <draw_line+0x436>
SPDR = ltr_p[Message_LowBat[2]]; Wait();
c78: f9 01 movw r30, r18
c7a: e4 5b subi r30, 0xB4 ; 180
c7c: ff 4f sbci r31, 0xFF ; 255
c7e: 80 81 ld r24, Z
c80: 8e bd out 0x2e, r24 ; 46
c82: 0d b4 in r0, 0x2d ; 45
c84: 07 fe sbrs r0, 7
c86: fd cf rjmp .-6 ; 0xc82 <draw_line+0x446>
SPDR = ltr_p[Message_LowBat[3]]; Wait();
c88: f9 01 movw r30, r18
c8a: e1 5b subi r30, 0xB1 ; 177
c8c: ff 4f sbci r31, 0xFF ; 255
c8e: 80 81 ld r24, Z
c90: 8e bd out 0x2e, r24 ; 46
c92: 0d b4 in r0, 0x2d ; 45
c94: 07 fe sbrs r0, 7
c96: fd cf rjmp .-6 ; 0xc92 <draw_line+0x456>
SPDR = ltr_p[Message_LowBat[4]]; Wait();
c98: f9 01 movw r30, r18
c9a: e9 5a subi r30, 0xA9 ; 169
c9c: ff 4f sbci r31, 0xFF ; 255
c9e: 80 81 ld r24, Z
ca0: 8e bd out 0x2e, r24 ; 46
ca2: 0d b4 in r0, 0x2d ; 45
ca4: 07 fe sbrs r0, 7
ca6: fd cf rjmp .-6 ; 0xca2 <draw_line+0x466>
SPDR = ltr_p[Message_LowBat[5]]; Wait();
ca8: f9 01 movw r30, r18
caa: e0 5c subi r30, 0xC0 ; 192
cac: ff 4f sbci r31, 0xFF ; 255
cae: 80 81 ld r24, Z
cb0: 8e bd out 0x2e, r24 ; 46
cb2: 0d b4 in r0, 0x2d ; 45
cb4: 07 fe sbrs r0, 7
cb6: fd cf rjmp .-6 ; 0xcb2 <draw_line+0x476>
SPDR = ltr_p[Message_LowBat[6]]; Wait();
cb8: f9 01 movw r30, r18
cba: ee 5b subi r30, 0xBE ; 190
cbc: ff 4f sbci r31, 0xFF ; 255
cbe: 80 81 ld r24, Z
cc0: 8e bd out 0x2e, r24 ; 46
cc2: 0d b4 in r0, 0x2d ; 45
cc4: 07 fe sbrs r0, 7
cc6: fd cf rjmp .-6 ; 0xcc2 <draw_line+0x486>
SPDR = ltr_p[Message_LowBat[7]]; Wait();
cc8: f9 01 movw r30, r18
cca: ef 5b subi r30, 0xBF ; 191
ccc: ff 4f sbci r31, 0xFF ; 255
cce: 80 81 ld r24, Z
cd0: 8e bd out 0x2e, r24 ; 46
cd2: 0d b4 in r0, 0x2d ; 45
cd4: 07 fe sbrs r0, 7
cd6: fd cf rjmp .-6 ; 0xcd2 <draw_line+0x496>
SPDR = ltr_p[Message_LowBat[8]]; Wait();
cd8: f9 01 movw r30, r18
cda: ec 5a subi r30, 0xAC ; 172
cdc: ff 4f sbci r31, 0xFF ; 255
cde: 80 81 ld r24, Z
ce0: 8e bd out 0x2e, r24 ; 46
ce2: 0d b4 in r0, 0x2d ; 45
ce4: 07 fe sbrs r0, 7
ce6: fd cf rjmp .-6 ; 0xce2 <draw_line+0x4a6>
SPDR = ltr_p[Message_LowBat[9]]; Wait();
ce8: f9 01 movw r30, r18
cea: ec 5a subi r30, 0xAC ; 172
cec: ff 4f sbci r31, 0xFF ; 255
cee: 80 81 ld r24, Z
cf0: 8e bd out 0x2e, r24 ; 46
cf2: 0d b4 in r0, 0x2d ; 45
cf4: 07 fe sbrs r0, 7
cf6: fd cf rjmp .-6 ; 0xcf2 <draw_line+0x4b6>
SPDR = ltr_p[Message_LowBat[10]]; Wait();
cf8: f9 01 movw r30, r18
cfa: eb 5b subi r30, 0xBB ; 187
cfc: ff 4f sbci r31, 0xFF ; 255
cfe: 80 81 ld r24, Z
d00: 8e bd out 0x2e, r24 ; 46
d02: 0d b4 in r0, 0x2d ; 45
d04: 07 fe sbrs r0, 7
d06: fd cf rjmp .-6 ; 0xd02 <draw_line+0x4c6>
SPDR = ltr_p[Message_LowBat[11]]; Wait();
d08: f9 01 movw r30, r18
d0a: ee 5a subi r30, 0xAE ; 174
d0c: ff 4f sbci r31, 0xFF ; 255
d0e: 80 81 ld r24, Z
d10: 8e bd out 0x2e, r24 ; 46
d12: 0d b4 in r0, 0x2d ; 45
d14: 07 fe sbrs r0, 7
d16: fd cf rjmp .-6 ; 0xd12 <draw_line+0x4d6>
SPDR = ltr_p[Message_LowBat[12]]; Wait();
d18: f9 01 movw r30, r18
d1a: e7 5a subi r30, 0xA7 ; 167
d1c: ff 4f sbci r31, 0xFF ; 255
d1e: 80 81 ld r24, Z
d20: 8e bd out 0x2e, r24 ; 46
d22: 0d b4 in r0, 0x2d ; 45
d24: 07 fe sbrs r0, 7
d26: fd cf rjmp .-6 ; 0xd22 <draw_line+0x4e6>
SPDR = ltr_p[Message_LowBat[13]]; Wait();
d28: f9 01 movw r30, r18
d2a: e0 5c subi r30, 0xC0 ; 192
d2c: ff 4f sbci r31, 0xFF ; 255
d2e: 80 81 ld r24, Z
d30: 8e bd out 0x2e, r24 ; 46
d32: 0d b4 in r0, 0x2d ; 45
d34: 07 fe sbrs r0, 7
d36: fd cf rjmp .-6 ; 0xd32 <draw_line+0x4f6>
SPDR = ltr_p[Message_LowBat[14]]; Wait();
d38: f9 01 movw r30, r18
d3a: e0 5c subi r30, 0xC0 ; 192
d3c: ff 4f sbci r31, 0xFF ; 255
d3e: 80 81 ld r24, Z
d40: 8e bd out 0x2e, r24 ; 46
d42: 0d b4 in r0, 0x2d ; 45
d44: 07 fe sbrs r0, 7
d46: fd cf rjmp .-6 ; 0xd42 <draw_line+0x506>
}
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// alt value
if((line > 80) && (line <250))
d48: ca 01 movw r24, r20
d4a: 81 55 subi r24, 0x51 ; 81
d4c: 90 40 sbci r25, 0x00 ; 0
d4e: 89 3a cpi r24, 0xA9 ; 169
d50: 91 05 cpc r25, r1
d52: 20 f4 brcc .+8 ; 0xd5c <draw_line+0x520>
{
while(TCNT0<LINESTART);
d54: 86 b5 in r24, 0x26 ; 38
d56: 88 3c cpi r24, 0xC8 ; 200
d58: e8 f3 brcs .-6 ; 0xd54 <draw_line+0x518>
TCNT0=0;
d5a: 16 bc out 0x26, r1 ; 38
}
 
if ((line > 170) && (line < 178))
d5c: ca 01 movw r24, r20
d5e: 8b 5a subi r24, 0xAB ; 171
d60: 90 40 sbci r25, 0x00 ; 0
d62: 07 97 sbiw r24, 0x07 ; 7
d64: 08 f0 brcs .+2 ; 0xd68 <draw_line+0x52c>
d66: 4d c0 rjmp .+154 ; 0xe02 <draw_line+0x5c6>
{
ltemp = (line - 171) * 27 - 64;
ntemp = (line - 171) * 16 - 43;
itemp = (line - 171) * 9;
ltr_p = ltrs+ltemp;
num_p = nums+ntemp;
d68: ca 01 movw r24, r20
d6a: 82 95 swap r24
d6c: 92 95 swap r25
d6e: 90 7f andi r25, 0xF0 ; 240
d70: 98 27 eor r25, r24
d72: 80 7f andi r24, 0xF0 ; 240
d74: 98 27 eor r25, r24
d76: 9c 01 movw r18, r24
d78: 2f 5c subi r18, 0xCF ; 207
d7a: 37 40 sbci r19, 0x07 ; 7
info_p = infos+itemp;
while(TCNT0<10);
d7c: 86 b5 in r24, 0x26 ; 38
d7e: 8a 30 cpi r24, 0x0A ; 10
d80: e8 f3 brcs .-6 ; 0xd7c <draw_line+0x540>
SPSR=1;
d82: 81 e0 ldi r24, 0x01 ; 1
d84: 8d bd out 0x2d, r24 ; 45
DDRB|=1;
d86: 20 9a sbi 0x04, 0 ; 4
SPDR = num_p[altv[0]]; Wait();
d88: 80 91 30 01 lds r24, 0x0130
d8c: f9 01 movw r30, r18
d8e: e8 0f add r30, r24
d90: f1 1d adc r31, r1
d92: 80 81 ld r24, Z
d94: 8e bd out 0x2e, r24 ; 46
d96: 0d b4 in r0, 0x2d ; 45
d98: 07 fe sbrs r0, 7
d9a: fd cf rjmp .-6 ; 0xd96 <draw_line+0x55a>
SPDR = num_p[altv[1]]; Wait();
d9c: 80 91 31 01 lds r24, 0x0131
da0: f9 01 movw r30, r18
da2: e8 0f add r30, r24
da4: f1 1d adc r31, r1
da6: 80 81 ld r24, Z
da8: 8e bd out 0x2e, r24 ; 46
daa: 0d b4 in r0, 0x2d ; 45
dac: 07 fe sbrs r0, 7
dae: fd cf rjmp .-6 ; 0xdaa <draw_line+0x56e>
SPDR = num_p[altv[2]]; Wait();
db0: 80 91 32 01 lds r24, 0x0132
db4: f9 01 movw r30, r18
db6: e8 0f add r30, r24
db8: f1 1d adc r31, r1
dba: 80 81 ld r24, Z
dbc: 8e bd out 0x2e, r24 ; 46
dbe: 0d b4 in r0, 0x2d ; 45
dc0: 07 fe sbrs r0, 7
dc2: fd cf rjmp .-6 ; 0xdbe <draw_line+0x582>
SPDR = num_p[altv[3]]; Wait();
dc4: 80 91 33 01 lds r24, 0x0133
dc8: f9 01 movw r30, r18
dca: e8 0f add r30, r24
dcc: f1 1d adc r31, r1
dce: 80 81 ld r24, Z
dd0: 8e bd out 0x2e, r24 ; 46
dd2: 0d b4 in r0, 0x2d ; 45
dd4: 07 fe sbrs r0, 7
dd6: fd cf rjmp .-6 ; 0xdd2 <draw_line+0x596>
SPDR = num_p[altv[4]]; Wait();
dd8: 80 91 34 01 lds r24, 0x0134
ddc: f9 01 movw r30, r18
dde: e8 0f add r30, r24
de0: f1 1d adc r31, r1
de2: 80 81 ld r24, Z
de4: 8e bd out 0x2e, r24 ; 46
de6: 0d b4 in r0, 0x2d ; 45
de8: 07 fe sbrs r0, 7
dea: fd cf rjmp .-6 ; 0xde6 <draw_line+0x5aa>
SPDR = num_p[altv[5]]; Wait();
dec: 80 91 35 01 lds r24, 0x0135
df0: f9 01 movw r30, r18
df2: e8 0f add r30, r24
df4: f1 1d adc r31, r1
df6: 80 81 ld r24, Z
df8: 8e bd out 0x2e, r24 ; 46
dfa: 0d b4 in r0, 0x2d ; 45
dfc: 07 fe sbrs r0, 7
dfe: fd cf rjmp .-6 ; 0xdfa <draw_line+0x5be>
DDRB&=0xFE;
e00: 20 98 cbi 0x04, 0 ; 4
}
 
if ((line > 179) && (line < (179 + alt_delta)) && alt_dec)
e02: 44 3b cpi r20, 0xB4 ; 180
e04: 51 05 cpc r21, r1
e06: b0 f0 brcs .+44 ; 0xe34 <draw_line+0x5f8>
e08: 80 91 dc 03 lds r24, 0x03DC
e0c: 90 91 dd 03 lds r25, 0x03DD
e10: 8d 54 subi r24, 0x4D ; 77
e12: 9f 4f sbci r25, 0xFF ; 255
e14: 48 17 cp r20, r24
e16: 59 07 cpc r21, r25
e18: 68 f4 brcc .+26 ; 0xe34 <draw_line+0x5f8>
e1a: 80 91 df 03 lds r24, 0x03DF
e1e: 88 23 and r24, r24
e20: 49 f0 breq .+18 ; 0xe34 <draw_line+0x5f8>
{
while(TCNT0<50);
e22: 86 b5 in r24, 0x26 ; 38
e24: 82 33 cpi r24, 0x32 ; 50
e26: e8 f3 brcs .-6 ; 0xe22 <draw_line+0x5e6>
SPDR = bar1; Wait();
e28: 80 91 36 01 lds r24, 0x0136
e2c: 8e bd out 0x2e, r24 ; 46
e2e: 0d b4 in r0, 0x2d ; 45
e30: 07 fe sbrs r0, 7
e32: fd cf rjmp .-6 ; 0xe2e <draw_line+0x5f2>
}
 
if ((line > (169 - alt_delta)) && (line < 169) && alt_inc)
e34: 40 91 ed 03 lds r20, 0x03ED
e38: 50 91 ee 03 lds r21, 0x03EE
e3c: 20 91 dc 03 lds r18, 0x03DC
e40: 30 91 dd 03 lds r19, 0x03DD
e44: 89 ea ldi r24, 0xA9 ; 169
e46: 90 e0 ldi r25, 0x00 ; 0
e48: 82 1b sub r24, r18
e4a: 93 0b sbc r25, r19
e4c: 84 17 cp r24, r20
e4e: 95 07 cpc r25, r21
e50: 80 f4 brcc .+32 ; 0xe72 <draw_line+0x636>
e52: 49 3a cpi r20, 0xA9 ; 169
e54: 51 05 cpc r21, r1
e56: 68 f4 brcc .+26 ; 0xe72 <draw_line+0x636>
e58: 80 91 de 03 lds r24, 0x03DE
e5c: 88 23 and r24, r24
e5e: 49 f0 breq .+18 ; 0xe72 <draw_line+0x636>
{
while(TCNT0<50);
e60: 86 b5 in r24, 0x26 ; 38
e62: 82 33 cpi r24, 0x32 ; 50
e64: e8 f3 brcs .-6 ; 0xe60 <draw_line+0x624>
SPDR = bar1; Wait();
e66: 80 91 36 01 lds r24, 0x0136
e6a: 8e bd out 0x2e, r24 ; 46
e6c: 0d b4 in r0, 0x2d ; 45
e6e: 07 fe sbrs r0, 7
e70: fd cf rjmp .-6 ; 0xe6c <draw_line+0x630>
}
asm("nop");
e72: 00 00 nop
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// grafic array
if ((line > 90) && (line < 250) && (showgraphic==1))
e74: ca 01 movw r24, r20
e76: 8b 55 subi r24, 0x5B ; 91
e78: 90 40 sbci r25, 0x00 ; 0
e7a: 8f 39 cpi r24, 0x9F ; 159
e7c: 91 05 cpc r25, r1
e7e: 08 f0 brcs .+2 ; 0xe82 <draw_line+0x646>
e80: 84 c0 rjmp .+264 ; 0xf8a <draw_line+0x74e>
e82: 80 91 00 01 lds r24, 0x0100
e86: 81 30 cpi r24, 0x01 ; 1
e88: 09 f0 breq .+2 ; 0xe8c <draw_line+0x650>
e8a: 7f c0 rjmp .+254 ; 0xf8a <draw_line+0x74e>
{
 
while(TCNT0<250);
e8c: 86 b5 in r24, 0x26 ; 38
e8e: 8a 3f cpi r24, 0xFA ; 250
e90: e8 f3 brcs .-6 ; 0xe8c <draw_line+0x650>
TCNT0=0;
e92: 16 bc out 0x26, r1 ; 38
 
i1=7*((line-90)>>2);
e94: ca 01 movw r24, r20
e96: 8a 55 subi r24, 0x5A ; 90
e98: 90 40 sbci r25, 0x00 ; 0
e9a: 96 95 lsr r25
e9c: 87 95 ror r24
e9e: 96 95 lsr r25
ea0: 87 95 ror r24
ea2: fc 01 movw r30, r24
ea4: ee 0f add r30, r30
ea6: ff 1f adc r31, r31
ea8: ee 0f add r30, r30
eaa: ff 1f adc r31, r31
eac: ee 0f add r30, r30
eae: ff 1f adc r31, r31
eb0: e8 1b sub r30, r24
eb2: f9 0b sbc r31, r25
i=0;
c1=dmem[i1++];
eb4: 87 e3 ldi r24, 0x37 ; 55
eb6: 91 e0 ldi r25, 0x01 ; 1
eb8: df 01 movw r26, r30
eba: a8 0f add r26, r24
ebc: b9 1f adc r27, r25
ebe: 4c 91 ld r20, X
ec0: 31 96 adiw r30, 0x01 ; 1
c2=dmem[i1++];
ec2: df 01 movw r26, r30
ec4: a8 0f add r26, r24
ec6: b9 1f adc r27, r25
ec8: 3c 91 ld r19, X
eca: 31 96 adiw r30, 0x01 ; 1
c3=dmem[i1++];
ecc: df 01 movw r26, r30
ece: a8 0f add r26, r24
ed0: b9 1f adc r27, r25
ed2: 5c 91 ld r21, X
ed4: 31 96 adiw r30, 0x01 ; 1
c4=dmem[i1++];
ed6: df 01 movw r26, r30
ed8: a8 0f add r26, r24
eda: b9 1f adc r27, r25
edc: 6c 91 ld r22, X
ede: 31 96 adiw r30, 0x01 ; 1
c5=dmem[i1++];
ee0: df 01 movw r26, r30
ee2: a8 0f add r26, r24
ee4: b9 1f adc r27, r25
ee6: ac 91 ld r26, X
ee8: 31 96 adiw r30, 0x01 ; 1
c6=dmem[i1++];
eea: e8 0f add r30, r24
eec: f9 1f adc r31, r25
eee: 70 81 ld r23, Z
c7=dmem[i1++];
ef0: 91 81 ldd r25, Z+1 ; 0x01
while(TCNT0<20);
ef2: 86 b5 in r24, 0x26 ; 38
ef4: 84 31 cpi r24, 0x14 ; 20
ef6: e8 f3 brcs .-6 ; 0xef2 <draw_line+0x6b6>
if (showgraphicb) DDRB|=1;
ef8: 80 91 01 01 lds r24, 0x0101
efc: 88 23 and r24, r24
efe: 11 f4 brne .+4 ; 0xf04 <draw_line+0x6c8>
f00: 20 e0 ldi r18, 0x00 ; 0
f02: 02 c0 rjmp .+4 ; 0xf08 <draw_line+0x6cc>
f04: 20 9a sbi 0x04, 0 ; 4
f06: 20 e0 ldi r18, 0x00 ; 0
do {
PORTB=((c1<<2)&0x04);
f08: 84 2f mov r24, r20
f0a: 88 0f add r24, r24
f0c: 88 0f add r24, r24
f0e: 84 70 andi r24, 0x04 ; 4
f10: 85 b9 out 0x05, r24 ; 5
c1=c1>>1;
f12: 46 95 lsr r20
i++;
f14: 2f 5f subi r18, 0xFF ; 255
} while(i<8);
f16: 28 30 cpi r18, 0x08 ; 8
f18: b9 f7 brne .-18 ; 0xf08 <draw_line+0x6cc>
do {
PORTB=((c2<<2)&0x04);
f1a: 83 2f mov r24, r19
f1c: 88 0f add r24, r24
f1e: 88 0f add r24, r24
f20: 84 70 andi r24, 0x04 ; 4
f22: 85 b9 out 0x05, r24 ; 5
c2=c2>>1;
f24: 36 95 lsr r19
i++;
f26: 2f 5f subi r18, 0xFF ; 255
} while(i<16);
f28: 20 31 cpi r18, 0x10 ; 16
f2a: b9 f7 brne .-18 ; 0xf1a <draw_line+0x6de>
do {
PORTB=((c3<<2)&0x04);
f2c: 85 2f mov r24, r21
f2e: 88 0f add r24, r24
f30: 88 0f add r24, r24
f32: 84 70 andi r24, 0x04 ; 4
f34: 85 b9 out 0x05, r24 ; 5
c3=c3>>1;
f36: 56 95 lsr r21
i++;
f38: 2f 5f subi r18, 0xFF ; 255
} while(i<24);
f3a: 28 31 cpi r18, 0x18 ; 24
f3c: b9 f7 brne .-18 ; 0xf2c <draw_line+0x6f0>
do {
PORTB=((c4<<2)&0x04);
f3e: 86 2f mov r24, r22
f40: 88 0f add r24, r24
f42: 88 0f add r24, r24
f44: 84 70 andi r24, 0x04 ; 4
f46: 85 b9 out 0x05, r24 ; 5
c4=c4>>1;
f48: 66 95 lsr r22
i++;
f4a: 2f 5f subi r18, 0xFF ; 255
} while(i<32);
f4c: 20 32 cpi r18, 0x20 ; 32
f4e: b9 f7 brne .-18 ; 0xf3e <draw_line+0x702>
do {
PORTB=((c5<<2)&0x04);
f50: 8a 2f mov r24, r26
f52: 88 0f add r24, r24
f54: 88 0f add r24, r24
f56: 84 70 andi r24, 0x04 ; 4
f58: 85 b9 out 0x05, r24 ; 5
c5=c5>>1;
f5a: a6 95 lsr r26
i++;
f5c: 2f 5f subi r18, 0xFF ; 255
} while(i<40);
f5e: 28 32 cpi r18, 0x28 ; 40
f60: b9 f7 brne .-18 ; 0xf50 <draw_line+0x714>
do {
PORTB=((c6<<2)&0x04);
f62: 87 2f mov r24, r23
f64: 88 0f add r24, r24
f66: 88 0f add r24, r24
f68: 84 70 andi r24, 0x04 ; 4
f6a: 85 b9 out 0x05, r24 ; 5
c6=c6>>1;
f6c: 76 95 lsr r23
i++;
f6e: 2f 5f subi r18, 0xFF ; 255
} while(i<48);
f70: 20 33 cpi r18, 0x30 ; 48
f72: b9 f7 brne .-18 ; 0xf62 <draw_line+0x726>
do {
PORTB=((c7<<2)&0x04);
f74: 89 2f mov r24, r25
f76: 88 0f add r24, r24
f78: 88 0f add r24, r24
f7a: 84 70 andi r24, 0x04 ; 4
f7c: 85 b9 out 0x05, r24 ; 5
c7=c7>>1;
f7e: 96 95 lsr r25
i++;
f80: 2f 5f subi r18, 0xFF ; 255
} while(i<56);
f82: 28 33 cpi r18, 0x38 ; 56
f84: b9 f7 brne .-18 ; 0xf74 <draw_line+0x738>
PORTB=0x00;
f86: 15 b8 out 0x05, r1 ; 5
DDRB&=0xFE;
f88: 20 98 cbi 0x04, 0 ; 4
}
 
 
// Debug - remove for release
// if ((line > 270) && (line < 278))
// {
// SPSR=1;
// ltemp = (line - 271) * 27 - 64;
// ntemp = (line - 271) * 16 - 43;
// itemp = (line - 271) * 8;
// ltr_p = ltrs+ltemp;
// num_p = nums+ntemp;
// info_p = infos+itemp;
// while(TCNT0<LINESTART);
// DDRB|=1; //sink thru PB0
// SPDR = ltr_p[rxtx[0]]; Wait();
// SPDR = ltr_p[rxtx[1]]; Wait();
// SPDR = ltr_p[rxtx[2]]; Wait();
// SPDR = info_p[rxtx[3]]; Wait();
// SPDR = ltr_p[rxtx[4]]; Wait();
// SPDR = ltr_p[rxtx[5]]; Wait();
// SPDR = ltr_p[rxtx[6]]; Wait();
// SPDR = ltr_p[rxtx[7]]; Wait();
// SPDR = info_p[rxtx[8]]; Wait();
// TCNT0=0;
// while(TCNT0<3); // 3 wait a little bit before turning off dimmer so that the
// // length of black box on the right matches the one on the left
// DDRB&=0xFE; //PB0 Hi-Z again, and load a blank so spacing is right
// }
 
// if ((line > 280) && (line < 288))
// {
// SPSR=1;
// ltemp = (line - 281) * 27 - 64;
// ntemp = (line - 281) * 16 - 43;
// ltr_p = ltrs+ltemp; //by calculating this pointer you only have to
// num_p = nums+ntemp; //add ltemp/ntemp once per line, instead of for
//every char. This tightens up printing a bit
//saves about 3 assembly instructions per char
// SPDR = ltr_p['@']; Wait(); //goofy hack to make SPSR=0 work, write an empty char at SPSR=1 first
// SPSR=1;
// while(TCNT0<LINESTART);
// DDRB|=1; //sink thru PB0
// //;display_line1[0]='A';
// SPDR = ltr_p[display_line1[0]]; Wait();
// SPDR = ltr_p[display_line1[1]]; Wait();
// SPDR = ltr_p[display_line1[2]]; Wait();
// SPDR = ltr_p[display_line1[3]]; Wait();
// SPDR = ltr_p[display_line1[4]]; Wait();
// SPDR = ltr_p[display_line1[5]]; Wait();
// TCNT0=0;
// while(TCNT0<3); // 3 wait a little bit before turning off dimmer so that the
// // length of black box on the right matches the one on the left
// DDRB&=0xFE; //PB0 Hi-Z again, and load a blank so spacing is right
// }
if ((line > 300) && (line < 308))
f8a: 20 91 ed 03 lds r18, 0x03ED
f8e: 30 91 ee 03 lds r19, 0x03EE
f92: c9 01 movw r24, r18
f94: 8d 52 subi r24, 0x2D ; 45
f96: 91 40 sbci r25, 0x01 ; 1
f98: 07 97 sbiw r24, 0x07 ; 7
f9a: 08 f0 brcs .+2 ; 0xf9e <draw_line+0x762>
f9c: a2 c0 rjmp .+324 ; 0x10e2 <draw_line+0x8a6>
{
SPSR=1;
f9e: 81 e0 ldi r24, 0x01 ; 1
fa0: 8d bd out 0x2d, r24 ; 45
ltemp = (line - 301) * 27 - 64;
ntemp = (line - 301) * 16 - 43;
ltr_p = ltrs+ltemp;
fa2: c9 01 movw r24, r18
fa4: 88 0f add r24, r24
fa6: 99 1f adc r25, r25
fa8: 82 0f add r24, r18
faa: 93 1f adc r25, r19
fac: 9c 01 movw r18, r24
fae: 22 0f add r18, r18
fb0: 33 1f adc r19, r19
fb2: 22 0f add r18, r18
fb4: 33 1f adc r19, r19
fb6: 22 0f add r18, r18
fb8: 33 1f adc r19, r19
fba: 82 0f add r24, r18
fbc: 93 1f adc r25, r19
fbe: 9c 01 movw r18, r24
fc0: 20 5b subi r18, 0xB0 ; 176
fc2: 3d 41 sbci r19, 0x1D ; 29
num_p = nums+ntemp;
while(TCNT0<LINESTART+COPYRIGHTSTART);
fc4: 86 b5 in r24, 0x26 ; 38
fc6: 88 3c cpi r24, 0xC8 ; 200
fc8: e8 f3 brcs .-6 ; 0xfc4 <draw_line+0x788>
SPDR = ltr_p[head[0]]; Wait();
fca: f9 01 movw r30, r18
fcc: ed 5b subi r30, 0xBD ; 189
fce: ff 4f sbci r31, 0xFF ; 255
fd0: 80 81 ld r24, Z
fd2: 8e bd out 0x2e, r24 ; 46
fd4: 0d b4 in r0, 0x2d ; 45
fd6: 07 fe sbrs r0, 7
fd8: fd cf rjmp .-6 ; 0xfd4 <draw_line+0x798>
SPDR = ltr_p[head[1]]; Wait();
fda: f9 01 movw r30, r18
fdc: e0 5c subi r30, 0xC0 ; 192
fde: ff 4f sbci r31, 0xFF ; 255
fe0: 80 81 ld r24, Z
fe2: 8e bd out 0x2e, r24 ; 46
fe4: 0d b4 in r0, 0x2d ; 45
fe6: 07 fe sbrs r0, 7
fe8: fd cf rjmp .-6 ; 0xfe4 <draw_line+0x7a8>
SPDR = ltr_p[head[2]]; Wait();
fea: f9 01 movw r30, r18
fec: e9 5b subi r30, 0xB9 ; 185
fee: ff 4f sbci r31, 0xFF ; 255
ff0: 80 81 ld r24, Z
ff2: 8e bd out 0x2e, r24 ; 46
ff4: 0d b4 in r0, 0x2d ; 45
ff6: 07 fe sbrs r0, 7
ff8: fd cf rjmp .-6 ; 0xff4 <draw_line+0x7b8>
SPDR = ltr_p[head[3]]; Wait();
ffa: f9 01 movw r30, r18
ffc: eb 5a subi r30, 0xAB ; 171
ffe: ff 4f sbci r31, 0xFF ; 255
1000: 80 81 ld r24, Z
1002: 8e bd out 0x2e, r24 ; 46
1004: 0d b4 in r0, 0x2d ; 45
1006: 07 fe sbrs r0, 7
1008: fd cf rjmp .-6 ; 0x1004 <draw_line+0x7c8>
SPDR = ltr_p[head[4]]; Wait();
100a: f9 01 movw r30, r18
100c: e2 5b subi r30, 0xB2 ; 178
100e: ff 4f sbci r31, 0xFF ; 255
1010: 80 81 ld r24, Z
1012: 8e bd out 0x2e, r24 ; 46
1014: 0d b4 in r0, 0x2d ; 45
1016: 07 fe sbrs r0, 7
1018: fd cf rjmp .-6 ; 0x1014 <draw_line+0x7d8>
SPDR = ltr_p[head[5]]; Wait();
101a: f9 01 movw r30, r18
101c: ec 5a subi r30, 0xAC ; 172
101e: ff 4f sbci r31, 0xFF ; 255
1020: 80 81 ld r24, Z
1022: 8e bd out 0x2e, r24 ; 46
1024: 0d b4 in r0, 0x2d ; 45
1026: 07 fe sbrs r0, 7
1028: fd cf rjmp .-6 ; 0x1024 <draw_line+0x7e8>
SPDR = ltr_p[head[6]]; Wait();
102a: f9 01 movw r30, r18
102c: eb 5b subi r30, 0xBB ; 187
102e: ff 4f sbci r31, 0xFF ; 255
1030: 80 81 ld r24, Z
1032: 8e bd out 0x2e, r24 ; 46
1034: 0d b4 in r0, 0x2d ; 45
1036: 07 fe sbrs r0, 7
1038: fd cf rjmp .-6 ; 0x1034 <draw_line+0x7f8>
SPDR = ltr_p[head[7]]; Wait();
103a: f9 01 movw r30, r18
103c: ee 5a subi r30, 0xAE ; 174
103e: ff 4f sbci r31, 0xFF ; 255
1040: 80 81 ld r24, Z
1042: 8e bd out 0x2e, r24 ; 46
1044: 0d b4 in r0, 0x2d ; 45
1046: 07 fe sbrs r0, 7
1048: fd cf rjmp .-6 ; 0x1044 <draw_line+0x808>
SPDR = ltr_p[head[8]]; Wait();
104a: f9 01 movw r30, r18
104c: e0 5c subi r30, 0xC0 ; 192
104e: ff 4f sbci r31, 0xFF ; 255
1050: 80 81 ld r24, Z
1052: 8e bd out 0x2e, r24 ; 46
1054: 0d b4 in r0, 0x2d ; 45
1056: 07 fe sbrs r0, 7
1058: fd cf rjmp .-6 ; 0x1054 <draw_line+0x818>
SPDR = ltr_p[head[9]]; Wait();
105a: f9 01 movw r30, r18
105c: e4 5b subi r30, 0xB4 ; 180
105e: ff 4f sbci r31, 0xFF ; 255
1060: 80 81 ld r24, Z
1062: 8e bd out 0x2e, r24 ; 46
1064: 0d b4 in r0, 0x2d ; 45
1066: 07 fe sbrs r0, 7
1068: fd cf rjmp .-6 ; 0x1064 <draw_line+0x828>
SPDR = ltr_p[head[10]]; Wait();
106a: f9 01 movw r30, r18
106c: e1 5b subi r30, 0xB1 ; 177
106e: ff 4f sbci r31, 0xFF ; 255
1070: 80 81 ld r24, Z
1072: 8e bd out 0x2e, r24 ; 46
1074: 0d b4 in r0, 0x2d ; 45
1076: 07 fe sbrs r0, 7
1078: fd cf rjmp .-6 ; 0x1074 <draw_line+0x838>
SPDR = ltr_p[head[11]]; Wait();
107a: f9 01 movw r30, r18
107c: e9 5b subi r30, 0xB9 ; 185
107e: ff 4f sbci r31, 0xFF ; 255
1080: 80 81 ld r24, Z
1082: 8e bd out 0x2e, r24 ; 46
1084: 0d b4 in r0, 0x2d ; 45
1086: 07 fe sbrs r0, 7
1088: fd cf rjmp .-6 ; 0x1084 <draw_line+0x848>
SPDR = ltr_p[head[12]]; Wait();
108a: f9 01 movw r30, r18
108c: eb 5b subi r30, 0xBB ; 187
108e: ff 4f sbci r31, 0xFF ; 255
1090: 80 81 ld r24, Z
1092: 8e bd out 0x2e, r24 ; 46
1094: 0d b4 in r0, 0x2d ; 45
1096: 07 fe sbrs r0, 7
1098: fd cf rjmp .-6 ; 0x1094 <draw_line+0x858>
SPDR = ltr_p[head[13]]; Wait();
109a: f9 01 movw r30, r18
109c: e3 5b subi r30, 0xB3 ; 179
109e: ff 4f sbci r31, 0xFF ; 255
10a0: 80 81 ld r24, Z
10a2: 8e bd out 0x2e, r24 ; 46
10a4: 0d b4 in r0, 0x2d ; 45
10a6: 07 fe sbrs r0, 7
10a8: fd cf rjmp .-6 ; 0x10a4 <draw_line+0x868>
SPDR = ltr_p[head[14]]; Wait();
10aa: f9 01 movw r30, r18
10ac: ef 5b subi r30, 0xBF ; 191
10ae: ff 4f sbci r31, 0xFF ; 255
10b0: 80 81 ld r24, Z
10b2: 8e bd out 0x2e, r24 ; 46
10b4: 0d b4 in r0, 0x2d ; 45
10b6: 07 fe sbrs r0, 7
10b8: fd cf rjmp .-6 ; 0x10b4 <draw_line+0x878>
SPDR = ltr_p[head[15]]; Wait();
10ba: f9 01 movw r30, r18
10bc: e2 5b subi r30, 0xB2 ; 178
10be: ff 4f sbci r31, 0xFF ; 255
10c0: 80 81 ld r24, Z
10c2: 8e bd out 0x2e, r24 ; 46
10c4: 0d b4 in r0, 0x2d ; 45
10c6: 07 fe sbrs r0, 7
10c8: fd cf rjmp .-6 ; 0x10c4 <draw_line+0x888>
SPDR = ltr_p[head[16]]; Wait();
10ca: f9 01 movw r30, r18
10cc: e2 5b subi r30, 0xB2 ; 178
10ce: ff 4f sbci r31, 0xFF ; 255
10d0: 80 81 ld r24, Z
10d2: 8e bd out 0x2e, r24 ; 46
10d4: 0d b4 in r0, 0x2d ; 45
10d6: 07 fe sbrs r0, 7
10d8: fd cf rjmp .-6 ; 0x10d4 <draw_line+0x898>
TCNT0=0;
10da: 16 bc out 0x26, r1 ; 38
while(TCNT0<2);
10dc: 86 b5 in r24, 0x26 ; 38
10de: 82 30 cpi r24, 0x02 ; 2
10e0: e8 f3 brcs .-6 ; 0x10dc <draw_line+0x8a0>
10e2: 08 95 ret
 
000010e4 <__vector_1>:
}
} // end draw_line()
 
 
//-----------------------------------------------------------------------------
// H-Sync Interrupt
//-----------------------------------------------------------------------------*/
SIGNAL(SIG_INTERRUPT0)
{
10e4: 1f 92 push r1
10e6: 0f 92 push r0
10e8: 0f b6 in r0, 0x3f ; 63
10ea: 0f 92 push r0
10ec: 11 24 eor r1, r1
10ee: 2f 93 push r18
10f0: 3f 93 push r19
10f2: 4f 93 push r20
10f4: 5f 93 push r21
10f6: 6f 93 push r22
10f8: 7f 93 push r23
10fa: 8f 93 push r24
10fc: 9f 93 push r25
10fe: af 93 push r26
1100: bf 93 push r27
1102: ef 93 push r30
1104: ff 93 push r31
TCNT0=0; // reset timer
1106: 16 bc out 0x26, r1 ; 38
line++; // increment line counter
1108: 80 91 ed 03 lds r24, 0x03ED
110c: 90 91 ee 03 lds r25, 0x03EE
1110: 01 96 adiw r24, 0x01 ; 1
1112: 90 93 ee 03 sts 0x03EE, r25
1116: 80 93 ed 03 sts 0x03ED, r24
draw_line(); // output the line
111a: 90 db rcall .-2272 ; 0x83c <draw_line>
111c: ff 91 pop r31
111e: ef 91 pop r30
1120: bf 91 pop r27
1122: af 91 pop r26
1124: 9f 91 pop r25
1126: 8f 91 pop r24
1128: 7f 91 pop r23
112a: 6f 91 pop r22
112c: 5f 91 pop r21
112e: 4f 91 pop r20
1130: 3f 91 pop r19
1132: 2f 91 pop r18
1134: 0f 90 pop r0
1136: 0f be out 0x3f, r0 ; 63
1138: 0f 90 pop r0
113a: 1f 90 pop r1
113c: 18 95 reti
 
0000113e <__vector_2>:
}
 
 
//-----------------------------------------------------------------------------
// V-Sync Interrupt
//-----------------------------------------------------------------------------*/
SIGNAL(SIG_INTERRUPT1)
{
113e: 1f 92 push r1
1140: 0f 92 push r0
1142: 0f b6 in r0, 0x3f ; 63
1144: 0f 92 push r0
1146: 11 24 eor r1, r1
1148: 8f 93 push r24
line = 0;
114a: 10 92 ee 03 sts 0x03EE, r1
114e: 10 92 ed 03 sts 0x03ED, r1
framecounter++;
1152: 80 91 da 03 lds r24, 0x03DA
1156: 8f 5f subi r24, 0xFF ; 255
1158: 80 93 da 03 sts 0x03DA, r24
115c: 8f 91 pop r24
115e: 0f 90 pop r0
1160: 0f be out 0x3f, r0 ; 63
1162: 0f 90 pop r0
1164: 1f 90 pop r1
1166: 18 95 reti
 
00001168 <__udivmodhi4>:
1168: aa 1b sub r26, r26
116a: bb 1b sub r27, r27
116c: 51 e1 ldi r21, 0x11 ; 17
116e: 07 c0 rjmp .+14 ; 0x117e <__udivmodhi4_ep>
 
00001170 <__udivmodhi4_loop>:
1170: aa 1f adc r26, r26
1172: bb 1f adc r27, r27
1174: a6 17 cp r26, r22
1176: b7 07 cpc r27, r23
1178: 10 f0 brcs .+4 ; 0x117e <__udivmodhi4_ep>
117a: a6 1b sub r26, r22
117c: b7 0b sbc r27, r23
 
0000117e <__udivmodhi4_ep>:
117e: 88 1f adc r24, r24
1180: 99 1f adc r25, r25
1182: 5a 95 dec r21
1184: a9 f7 brne .-22 ; 0x1170 <__udivmodhi4_loop>
1186: 80 95 com r24
1188: 90 95 com r25
118a: bc 01 movw r22, r24
118c: cd 01 movw r24, r26
118e: 08 95 ret
 
00001190 <__divmodhi4>:
1190: 97 fb bst r25, 7
1192: 09 2e mov r0, r25
1194: 07 26 eor r0, r23
1196: 0a d0 rcall .+20 ; 0x11ac <__divmodhi4_neg1>
1198: 77 fd sbrc r23, 7
119a: 04 d0 rcall .+8 ; 0x11a4 <__divmodhi4_neg2>
119c: e5 df rcall .-54 ; 0x1168 <__udivmodhi4>
119e: 06 d0 rcall .+12 ; 0x11ac <__divmodhi4_neg1>
11a0: 00 20 and r0, r0
11a2: 1a f4 brpl .+6 ; 0x11aa <__divmodhi4_exit>
 
000011a4 <__divmodhi4_neg2>:
11a4: 70 95 com r23
11a6: 61 95 neg r22
11a8: 7f 4f sbci r23, 0xFF ; 255
 
000011aa <__divmodhi4_exit>:
11aa: 08 95 ret
 
000011ac <__divmodhi4_neg1>:
11ac: f6 f7 brtc .-4 ; 0x11aa <__divmodhi4_exit>
11ae: 90 95 com r25
11b0: 81 95 neg r24
11b2: 9f 4f sbci r25, 0xFF ; 255
11b4: 08 95 ret
 
000011b6 <_exit>:
11b6: ff cf rjmp .-2 ; 0x11b6 <_exit>
/OSD and Video Transmitter/overlay/MKvideooverlay.pnproj
New file
0,0 → 1,0
<Project name="MKvideooverlay"><File path="Main.c"></File><File path="Main.h"></File><File path="main.hex"></File><File path="main_eeprom.hex"></File><File path="Makefile"></File><File path="main.lst"></File></Project>
/OSD and Video Transmitter/overlay/main.hex
New file
0,0 → 1,331
:1000000019C070C89CC831C030C02FC02EC02DC0D0
:100010002CC02BC02AC029C028C027C026C025C09C
:1000200024C023C022C021C020C01FC01EC01DC0CC
:100030001CC01BC011241FBECFEFD4E0DEBFCDBF5C
:1000400013E0A0E0B1E0E8EBF1E102C005900D9211
:10005000A83DB107D9F714E0A8EDB3E001C01D92A7
:10006000A43AB107E1F7F6D1A6C8CACFDC0114164D
:10007000150664F4FB01E95CFE4F20E030E08D9151
:1000800081932F5F3F4F42175307C9F70895E7E366
:10009000F1E08FE492E01192E817F907E1F7089593
:1000A000EF92FF921F93CF93DF93EC01162F6623FD
:1000B00009F47BC0A4EFB3E0FD01E40FF11D508112
:1000C000842F8F5FFD01E80FF11D30818F5FFD01EF
:1000D000E80FF11DE0818F5FA80FB11DAC914C5F5F
:1000E000822F99270F2EFEEFEF2EFFEFFF2EF02D20
:1000F000E80EF91E842F9927E816F9060CF455C06E
:10010000852F8D533D535E2F5D53AD5320E064EF3B
:1001100073E020C0FB01E40FF11DB081842F8F5FDD
:10012000FB01E80FF11D30818F5FFB01E80FF11D2E
:1001300050818F5FFB01E80FF11DA0814C5F842F80
:100140009927E816F9068CF18B2F8D533D535D539B
:10015000AD532D5FFE01E20FF11D880F880F932F25
:1001600092959F70892B80831130F9F0822F8F5FD9
:10017000FE01E80FF11D832F8295807F952F9695C4
:100180009695892B808313501F3F79F0822F8E5FC5
:10019000FE01E80FF11D852F8295880F880F807C66
:1001A0008A2B8083112309F0B5CFDF91CF911F9166
:1001B000FF90EF9008958093E1035091E603543649
:1001C00010F01092E5038091E1038D3009F05CC0DE
:1001D0008091E503823009F057C01092E503652F46
:1001E0007727FB01329724EF33E0E20FF31F4081C2
:1001F000CB010197DC01A20FB31F2C918091E90381
:100200009091EA03841B9109821B91099F7090933E
:10021000EA038093E9039C010024220F331F001C92
:10022000220F331F001C232F302D235C2093E80363
:100230008F73382F335C3093E7038081281729F4BC
:100240008C91381711F491E009C08091E3038F5F1E
:100250008093E30385E48093590490E08091E20366
:10026000882309F07EC0992309F47BC081E0809344
:10027000E2035093E403FB01EC50FC4F8DE08083DC
:1002800082E5809359046DC08091E503813031F19E
:10029000813020F0823009F05FC03EC08091E103E0
:1002A000833239F48091E203882319F481E080934A
:1002B000E5038091E1038093F40381E08093E603FA
:1002C0008091E10399279093EA038093E90381E405
:1002D00080935A0488E58093590443C082E0809358
:1002E000E5038091E103E4EFF3E0E50FF11D808386
:1002F000852F8F5F8093E6032091E1038091E903CE
:100300009091EA03820F911D9093EA038093E90391
:1003100082E480935A0425C08091E103E4EFF3E086
:10032000E50FF11D8083543628F4852F8F5F80936D
:10033000E60302C01092E5038091E1032091E903F6
:100340003091EA03280F311D3093EA032093E9032B
:1003500083E480935A0405C01092E50384E48093FB
:100360005A0480910A01882321F481E080930A01D4
:10037000089510920A010895AF92BF92CF92DF9232
:10038000EF92FF920F931F93CF93DF93CDB7DEB71A
:1003900027970FB6F894DEBF0FBECDBF6C017B016F
:1003A000161617060CF045C080E090E09E012F5F06
:1003B0003F4F60E3F901E80FF91F60830196E816EB
:1003C000F906C1F74115510519F187010150104097
:1003D0005E010894A11CB11CFA01CA016AE070E038
:1003E000C3D6AB01D501A00FB11FCB01880F991F58
:1003F0009B01220F331F220F331F220F331F820F47
:10040000931FE81BE05DEC9301501040672B21F730
:1004100020E030E0AE014F5F5F4FFA01E20FF31FC3
:100420008081F60181936F012F5F3F4FE216F30643
:10043000A1F727960FB6F894DEBF0FBECDBFDF91B0
:10044000CF911F910F91FF90EF90DF90CF90BF90D1
:10045000AF900895AF92BF92CF92DF92FF920F9329
:100460001F93CF93DF931092000110920101E1E6F8
:10047000F0E080E88083108280E18BB91AB8109296
:10048000C00088E18093C10086E88093C20010928A
:10049000C50085E18093C40014BC91E095BD15B8FA
:1004A0008EE384B984E58CBD9DBD8AE080936900AC
:1004B00083E08DBB8CBB10926800789488E58093B4
:1004C00058048093590480935A0480935B0480936A
:1004D0005C0480935D041092E2031092DA03D7DD8E
:1004E00045E150E06CE870E08BEB93E0BFDD81E02C
:1004F00080930001FF24F3940F2EFFEECF2EF3E044
:10050000DF2EF02D08E014E00F2EFBEBAF2EF3E012
:10051000BF2EF02D8091C00088232CF4E6ECF0E093
:100520008081808348DE8091DA03893118F4F0926B
:10053000D90306C01092D903833310F01092DA0366
:100540008091E203882331F38091F603843409F02B
:100550005FC12091E40343E062E482E694E0A0DD21
:10056000409174045091750463E070E08CE091E078
:1005700003DF20916E0430916F048091EB03909122
:10058000EC038217930764F4F092DE031092DF030A
:10059000A901481B590B5093DD034093DC0317C09E
:1005A000281739075CF41092DE03F092DF03821BF8
:1005B000930B9093DD038093DC0309C01092DE035C
:1005C0001092DF031092DD031092DC030CC08091C7
:1005D000DC039091DD03CD9730F08CE390E09093B5
:1005E000DD038093DC033093EC032093EB03332390
:1005F0005CF48DE280933001C901809590959093D1
:100600006F0480936E0403C08BE2809330014091AD
:100610006E0450916F0465E070E081E391E0ACDE20
:10062000409176045091770465E070E0C601A4DE45
:100630008091F10380931B018091F20380931C0150
:100640008091F30380931E0180917604909177044A
:100650008B35910534F0009310018036910524F418
:1006600009C01093100106C0009311018536910551
:1006700024F409C01093110106C0009312018A36B8
:10068000910524F409C01093120106C000931301D0
:100690008F36910524F409C01093130106C000930E
:1006A00014018437910524F409C01093140106C085
:1006B000009315018937910524F409C010931501A1
:1006C00006C0009316018E3791054CF4B4C0109308
:1006D0001601109317018E35910524F006C0009382
:1006E000170103C0F092D80302C01092D8032091E2
:1006F00078043091790484E690E0AC01249FC00135
:10070000259F900D349F900D11246FEF70E02CD534
:10071000EB01AB0165E070E0C6012EDE8091F103D4
:1007200080932C018091F20380932D018091F3033B
:1007300080932E01CB30D10530F000932001C531DC
:10074000D10520F409C01093200106C000932101B7
:10075000CF31D10520F409C01093210106C00093C8
:100760002201C932D10520F409C01093220106C02C
:1007700000932301C333D10520F409C01093230152
:1007800006C000932401CD33D10520F409C0109395
:10079000240106C000932501C734D10520F409C007
:1007A0001093250106C000932601C135D10520F420
:1007B00006C01093260103C00093270102C01093C6
:1007C0002701809164049091650462E370E0E0D4B5
:1007D00084E190E0EC01C61BD70BEAF0C632D105EC
:1007E00014F555DCBE01660F771F660F771F660F85
:1007F000771F6C1B7D0B45E150E0C50137DC64972A
:1008000039F047E050E06CE870E080ED93E02EDCDA
:100810001092E2037FCE3BDC45E150E060E070E007
:10082000C50124DCEECF33DC45E150E063E071E04C
:10083000C5011CDCE6CF1093170157CF4091ED03A3
:100840005091EE03CA018497079708F003C1CA01CB
:1008500082959295907F9827807F9827BC016F554D
:100860007F4FCA01880F991F880F991F880F991F02
:10087000840F951F9C01285C3D4F86B5883CE8F3AA
:1008800016BC81E08DBD209A80911001F901E80F1E
:10089000F11D80818EBD0DB407FEFDCF8091110149
:1008A000F901E80FF11D80818EBD0DB407FEFDCF6B
:1008B00080911201F901E80FF11D80818EBD0DB408
:1008C00007FEFDCF80911301F901E80FF11D808132
:1008D0008EBD0DB407FEFDCF80911401F901E80F24
:1008E000F11D80818EBD0DB407FEFDCF80911501F5
:1008F000F901E80FF11D80818EBD0DB407FEFDCF1B
:1009000080911601F901E80FF11D80818EBD0DB4B3
:1009100007FEFDCF80911701F901E80FF11D8081DD
:100920008EBD0DB407FEFDCF209816BC86B5803570
:10093000E8F316BC1DBC209A80910B01F901E80F69
:10094000F11D80818EBD0DB407FEFDCF80910C019D
:10095000FB01E80FF11D80818EBD0DB407FEFDCFB8
:1009600080910D01FB01E80FF11D80818EBD0DB45A
:1009700007FEFDCF80910E01FB01E80FF11D808184
:100980008EBD0DB407FEFDCF80910F01F901E80F78
:10099000F11D80818EBD0DB407FEFDCF209886B578
:1009A0008A3FE8F316BC86B58634E8F381E08DBD56
:1009B000209A80912001F901E80FF11D80818EBD00
:1009C0000DB407FEFDCF80912101F901E80FF11D63
:1009D00080818EBD0DB407FEFDCF80912201F9010B
:1009E000E80FF11D80818EBD0DB407FEFDCF809113
:1009F0002301F901E80FF11D80818EBD0DB407FEC2
:100A0000FDCF80912401F901E80FF11D80818EBD99
:100A10000DB407FEFDCF80912501F901E80FF11D0E
:100A200080818EBD0DB407FEFDCF80912601F901B6
:100A3000E80FF11D80818EBD0DB407FEFDCF8091C2
:100A40002701F901E80FF11D80818EBD0DB407FE6D
:100A5000FDCF2098CA018D97079708F0D4C0CA012E
:100A6000880F991F840F951F9C01220F331F220F9F
:100A7000331F220F331F820F931FBC01605B724034
:100A8000CA0182959295907F9827807F98279C0134
:100A90002F5E3F4F86B5883CE8F316BC81E08DBDE4
:100AA000209A80911801FB01E80FF11D80818EBD15
:100AB0000DB407FEFDCF80911901F901E80FF11D7A
:100AC00080818EBD0DB407FEFDCF80911A01FB0120
:100AD000E80FF11D80818EBD0DB407FEFDCF809122
:100AE0001B01F901E80FF11D80818EBD0DB407FED9
:100AF000FDCF80911C01F901E80FF11D80818EBDB1
:100B00000DB407FEFDCF80911D01F901E80FF11D25
:100B100080818EBD0DB407FEFDCF80911E01F901CD
:100B2000E80FF11D80818EBD0DB407FEFDCF8091D1
:100B30001F01FB01E80FF11D80818EBD0DB407FE82
:100B4000FDCF209816BC86B58035E8F316BC86B577
:100B50008A3FE8F316BC86B58634E8F316BC81E01C
:100B60008DBD209A80912801FB01E80FF11D808145
:100B70008EBD0DB407FEFDCF80912901FB01E80F6A
:100B8000F11D80818EBD0DB407FEFDCF80912A013D
:100B9000F901E80FF11D80818EBD0DB407FEFDCF78
:100BA00080912B01FB01E80FF11D80818EBD0DB4FA
:100BB00007FEFDCF80912C01F901E80FF11D808126
:100BC0008EBD0DB407FEFDCF80912D01F901E80F18
:100BD000F11D80818EBD0DB407FEFDCF80912E01E9
:100BE000F901E80FF11D80818EBD0DB407FEFDCF28
:100BF00080912F01F901E80FF11D80818EBD0DB4A8
:100C000007FEFDCF2098CA01CD97079708F09CC03A
:100C10008091D903882309F497C08091D803882351
:100C200009F492C0CA01880F991F840F951F9C0177
:100C3000220F331F220F331F220F331F820F931FE8
:100C40009C012056344086B5883CE8F316BC86B536
:100C50008A3FE8F381E08DBDF901E05CFF4F8081C0
:100C60008EBD0DB407FEFDCFF901E05CFF4F808122
:100C70008EBD0DB407FEFDCFF901E45BFF4F80810F
:100C80008EBD0DB407FEFDCFF901E15BFF4F808102
:100C90008EBD0DB407FEFDCFF901E95AFF4F8081EB
:100CA0008EBD0DB407FEFDCFF901E05CFF4F8081E2
:100CB0008EBD0DB407FEFDCFF901EE5BFF4F8081C5
:100CC0008EBD0DB407FEFDCFF901EF5BFF4F8081B4
:100CD0008EBD0DB407FEFDCFF901EC5AFF4F8081A8
:100CE0008EBD0DB407FEFDCFF901EC5AFF4F808198
:100CF0008EBD0DB407FEFDCFF901EB5BFF4F808188
:100D00008EBD0DB407FEFDCFF901EE5AFF4F808175
:100D10008EBD0DB407FEFDCFF901E75AFF4F80816C
:100D20008EBD0DB407FEFDCFF901E05CFF4F808161
:100D30008EBD0DB407FEFDCFF901E05CFF4F808151
:100D40008EBD0DB407FEFDCFCA0181559040893A92
:100D5000910520F486B5883CE8F316BCCA018B5A8D
:100D60009040079708F04DC0CA0182959295907FF8
:100D70009827807F98279C012F5C374086B58A3062
:100D8000E8F381E08DBD209A80913001F901E80FF0
:100D9000F11D80818EBD0DB407FEFDCF8091310124
:100DA000F901E80FF11D80818EBD0DB407FEFDCF66
:100DB00080913201F901E80FF11D80818EBD0DB4E3
:100DC00007FEFDCF80913301F901E80FF11D80810D
:100DD0008EBD0DB407FEFDCF80913401F901E80FFF
:100DE000F11D80818EBD0DB407FEFDCF80913501D0
:100DF000F901E80FF11D80818EBD0DB407FEFDCF16
:100E00002098443B5105B0F08091DC039091DD03C4
:100E10008D549F4F4817590768F48091DF0388234A
:100E200049F086B58233E8F3809136018EBD0DB46A
:100E300007FEFDCF4091ED035091EE032091DC03BE
:100E40003091DD0389EA90E0821B930B84179507AC
:100E500080F4493A510568F48091DE03882349F013
:100E600086B58233E8F3809136018EBD0DB407FE5E
:100E7000FDCF0000CA018B5590408F39910508F0D5
:100E800084C080910001813009F07FC086B58A3F1F
:100E9000E8F316BCCA018A559040969587959695B9
:100EA0008795FC01EE0FFF1FEE0FFF1FEE0FFF1FD8
:100EB000E81BF90B87E391E0DF01A80FB91F4C9104
:100EC0003196DF01A80FB91F3C913196DF01A80FC1
:100ED000B91F5C913196DF01A80FB91F6C91319653
:100EE000DF01A80FB91FAC913196E80FF91F70818F
:100EF000918186B58431E8F380910101882311F452
:100F000020E002C0209A20E0842F880F880F847090
:100F100085B946952F5F2830B9F7832F880F880F42
:100F2000847085B936952F5F2031B9F7852F880FEA
:100F3000880F847085B956952F5F2831B9F7862FB1
:100F4000880F880F847085B966952F5F2032B9F7B6
:100F50008A2F880F880F847085B9A6952F5F283255
:100F6000B9F7872F880F880F847085B976952F5F22
:100F70002033B9F7892F880F880F847085B996952B
:100F80002F5F2833B9F715B820982091ED033091E1
:100F9000EE03C9018D529140079708F0A2C081E08D
:100FA0008DBDC901880F991F820F931F9C01220FCD
:100FB000331F220F331F220F331F820F931F9C01F9
:100FC000205B3D4186B5883CE8F3F901ED5BFF4FBE
:100FD00080818EBD0DB407FEFDCFF901E05CFF4FAF
:100FE00080818EBD0DB407FEFDCFF901E95BFF4F97
:100FF00080818EBD0DB407FEFDCFF901EB5AFF4F86
:1010000080818EBD0DB407FEFDCFF901E25BFF4F7D
:1010100080818EBD0DB407FEFDCFF901EC5AFF4F64
:1010200080818EBD0DB407FEFDCFF901EB5BFF4F54
:1010300080818EBD0DB407FEFDCFF901EE5AFF4F42
:1010400080818EBD0DB407FEFDCFF901E05CFF4F3E
:1010500080818EBD0DB407FEFDCFF901E45BFF4F2B
:1010600080818EBD0DB407FEFDCFF901E15BFF4F1E
:1010700080818EBD0DB407FEFDCFF901E95BFF4F06
:1010800080818EBD0DB407FEFDCFF901EB5BFF4FF4
:1010900080818EBD0DB407FEFDCFF901E35BFF4FEC
:1010A00080818EBD0DB407FEFDCFF901EF5BFF4FD0
:1010B00080818EBD0DB407FEFDCFF901E25BFF4FCD
:1010C00080818EBD0DB407FEFDCFF901E25BFF4FBD
:1010D00080818EBD0DB407FEFDCF16BC86B5823073
:1010E000E8F308951F920F920FB60F9211242F93D9
:1010F0003F934F935F936F937F938F939F93AF93A0
:10110000BF93EF93FF9316BC8091ED039091EE0394
:1011100001969093EE038093ED0390DBFF91EF91A6
:10112000BF91AF919F918F917F916F915F914F91FF
:101130003F912F910F900FBE0F901F9018951F9207
:101140000F920FB60F9211248F931092EE0310920C
:10115000ED038091DA038F5F8093DA038F910F9014
:101160000FBE0F901F901895AA1BBB1B51E107C023
:10117000AA1FBB1FA617B70710F0A61BB70B881F27
:10118000991F5A95A9F780959095BC01CD010895B6
:1011900097FB092E07260AD077FD04D0E5DF06D09D
:1011A00000201AF4709561957F4F0895F6F7909599
:0811B00081959F4F0895FFCFC8
:1011B8000101545844014052584401023030300370
:1011C8000808080808080808553A4030302E3056F4
:1011D800080808080808080852583A403130302FE3
:1011E8002B3030303030FE000000000000000000DE
:1011F80000000000000000000000000000000000E7
:10120800000000005500FF00FF0000FF00FF00FF86
:101218000000FF00FF00FF0000FF00FF00FF0000CC
:10122800FF00FF00FF0000FF00FF00FF0000FF00BD
:10123800FF00FF0000FF00FF00FF0000FF00FF00AD
:10124800FF0000FF00FF00FF0000FF00FF00FF009D
:1012580000FF00FF00FF00FF00FF00FF00FFFF008E
:10126800FF00FF00FFFF00FF00FF00FFFF00FF007F
:10127800FF00FFFF00FF00FF00FFFF00FF00FF006F
:10128800FFFF00FF00FF00FFFF00FF00FF00FFFF60
:1012980000FF00FF00FFFF00FF00FF00FFFF00FF4F
:1012A80000FF00FFFF00FF00FF00FFFF00FF00FF3F
:1012B80000FFFF00FF00FF00FFFF00FF00FF00FF2F
:1012C800FF00FF00FF00FFFF00FF00FF00FFFF001F
:1012D800FF00FF00FFFF00FF00FF00FFFF00FF000F
:1012E800FF00FFFF00FF00FF0055FF00FF00FF00A9
:1012F800AAFF00FF00FF0055FF00FF00FF00AA0043
:10130800187C3C787E7E3C427C7E424082823C7CDB
:101318003C7C3C7C4242828282FE00244242444021
:1013280040424210084440C6C24242424242104231
:101338004282444404004242404240404042100835
:101348004840AAA2424242424010424292282808FB
:1013580000427C40427C7C4E7E1008704092924253
:101368007C427C3C10422492101010007E42404285
:101378004040424210084840828A42404C4802108D
:1013880042249228102000424242444040424210E7
:1013980048447E828642404644421042246C4410AF
:1013A8004000427C3C787E403C427C30427E8282D7
:1013B8003C4032423C103C186C8210FE0000000099
:1013C800307C107C7C1CFE7CFE7C7C0010000000C5
:1013D80044823082822480800282821010000000C1
:1013E8004482100202448080048282007C007C00D7
:1013F8003082100C1C847CFC087C7E0010180000D5
:101408000082103002FE02821082040010180018B8
:1014180000821040820482821082081000000018A6
:10142800007C38FE7C047C7C107C3000FEFE18308A
:101438000080A0A8AAFE8238380080A0A8AAFE8250
:10144800783C0080A0A8AAFE82FEFE0080A0A8AA80
:10145800FE827E3C0080A0A8AAFE8238380080A0C8
:10146800A8AAFEFE18300080A0A8AA000000180054
:101478000000FFFFFF24FFFFFF000000180000002E
:08148800AAAAAAFF5555550060
:00000001FF
/OSD and Video Transmitter/overlay/main.elf
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
/OSD and Video Transmitter/overlay/main.elf
New file
Property changes:
Added: svn:mime-type
## -0,0 +1 ##
+application/octet-stream
\ No newline at end of property
Index: overlay/Main.h
===================================================================
--- overlay/Main.h (revision 0)
+++ overlay/Main.h (revision 96)
@@ -0,0 +1,51 @@
+/*****************************************************************************
+Project : Video Overlay for RC Planes
+Date : 1/14/2007
+Author : Gunter Logemann (C) ALL RIGHTS RESERVED
+
+Comments:
+This project is optimized to work with the Mikrocopter (www.mikrokopter.de)
+Many Thanks to Gary Dion who created the first basic implementation
+Data communication decoder and encoder functions are taken from the
+mikrokopter (www.mikrokopter.de) project.
+
+Redistributions of this source code (with or without modifications) or parts
+of this sourcode 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 source code permittet for non-commercial use (directly
+ or indirectly) only.
+* Commercial use Is only permitted with our written permission by
+ Gunter Logemann (gunter@pccon.de)
+
+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.
+
+Chip type : ATmega88
+Program type : Application
+Clock frequency : 20,000000 MHz
+*****************************************************************************/
+
+struct str_DebugOut
+{
+ unsigned char Digital[2];
+ int Analog[32]; // Debugwerte
+};
+
+
+extern struct str_DebugOut DebugOut;
+
+extern int main(void);
+
+
Index: overlay/main.bin
===================================================================
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Index: overlay/main.bin
===================================================================
--- overlay/main.bin (revision 0)
+++ overlay/main.bin (revision 96)
/overlay/main.bin
Property changes:
Added: svn:mime-type
## -0,0 +1 ##
+application/octet-stream
\ No newline at end of property
Index: pcb/Mk Camera.T3000
===================================================================
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Index: pcb/Mk Camera.T3000
===================================================================
--- pcb/Mk Camera.T3000 (revision 0)
+++ pcb/Mk Camera.T3000 (revision 96)
/pcb/Mk Camera.T3000
Property changes:
Added: svn:mime-type
## -0,0 +1 ##
+application/octet-stream
\ No newline at end of property