CCS PCW C Compiler, Version 3.110, 15448
Filename: c:\krouzek\test\mb01a.LST
ROM used: 1523 (74%)
Largest free fragment is 512
RAM used: 29 (17%) at main() level
88 (50%) worst case
Stack: 6 worst case (5 in main + 1 for interrupts)
*
0000: MOVLW 00
0001: MOVWF 0A
0002: GOTO 590
0003: NOP
0004: MOVWF 7F
0005: SWAPF 03,W
0006: CLRF 03
0007: MOVWF 21
0008: MOVF 7F,W
0009: MOVWF 20
000A: MOVF 0A,W
000B: MOVWF 28
000C: CLRF 0A
000D: SWAPF 20,F
000E: MOVF 04,W
000F: MOVWF 22
0010: MOVF 77,W
0011: MOVWF 23
0012: MOVF 78,W
0013: MOVWF 24
0014: MOVF 79,W
0015: MOVWF 25
0016: MOVF 7A,W
0017: MOVWF 26
0018: MOVF 7B,W
0019: MOVWF 27
001A: BCF 03.7
001B: BCF 03.5
001C: MOVLW 8C
001D: MOVWF 04
001E: BTFSS 00.2
001F: GOTO 022
0020: BTFSC 0C.2
0021: GOTO 0CB
0022: MOVF 22,W
0023: MOVWF 04
0024: MOVF 23,W
0025: MOVWF 77
0026: MOVF 24,W
0027: MOVWF 78
0028: MOVF 25,W
0029: MOVWF 79
002A: MOVF 26,W
002B: MOVWF 7A
002C: MOVF 27,W
002D: MOVWF 7B
002E: MOVF 28,W
002F: MOVWF 0A
0030: SWAPF 21,W
0031: MOVWF 03
0032: SWAPF 7F,F
0033: SWAPF 7F,W
0034: RETFIE
.................... // Melodicky zvonek MB01A_1_00
.................... //
.................... // Prohram pro melodicky zvonek s pouzitim knihovny Sound_t1.C
.................... //
.................... // (c)miho 2004
.................... //
.................... // Historie:
.................... // 1.00 Uvodni verze
....................
.................... #include <16F819.h> // Definice procesoru
.................... //////// Standard Header file for the PIC16F628 device ////////////////
.................... #device PIC16F819
.................... #list
....................
.................... #fuses HS,NOPROTECT,NOWDT,PUT,NOLVP,NOBROWNOUT,WRT // Definice konfiguracniho slova
....................
.................... #define POWER_386 PIN_A4 // L zapne napajeni pro zesilovac LM386
.................... #define POWER_PIC PIN_A3 // L pripoji GND pro procesor PIC
....................
.................... #define SOUND_HI PIN_B3 // Akusticky vystup
.................... #define SOUND_LO PIN_B2 // Akusticky vystup
.................... #define SOUND_CLOCK 20000000 // Frekvence hodin
.................... #define SOUND_LowOctave 1 // O oktavu vys protoze mame moc rychly krystal
.................... #include "Sound_T1.c" // Hudebni knihovna
.................... // Knihovna pro generovani hudebnich zvuku dane frekvence a delky nebo
.................... // dane noty temperovaneho ladeni a delky.
.................... //
.................... // Pro gnerovani pouziva casovac T0, T1 a jednotku CCP1.
.................... //
.................... // POZOR -- POZOR -- POZOR
.................... // Pri nizsi frekvenci XTALu (nez asi 5MHz) je rezie preruseni tak velka, ze spotrebuje
.................... // veskery strojovy cas a uz nedojde k ukonceni rozehraneho tonu vyssi frekvence (z oktavy 7
.................... // nebo nad cca 8KHz). Resenim je pouzit vlastni INT proceduru s minimalni rezii.
.................... //
.................... // (c)miho 2004
.................... //
.................... // Historie
.................... // 1.00 Uvodni verze
....................
....................
.................... // Konfiguracni parametry
.................... //#define SOUND_HI PIN_xx // Pozitivni vystup
.................... //#define SOUND_LO PIN_xx // Komplementarni vystup
.................... #ifndef SOUND_CLOCK
.................... #define SOUND_CLOCK 4000000 // Frelvence krystalu v Hz
.................... #endif
....................
....................
.................... // Definice hudebnich tonu (not) pro proceduru SoundNote()
.................... #define SOUND_C 0
.................... #define SOUND_Cis 1
.................... #define SOUND_D 2
.................... #define SOUND_Dis 3
.................... #define SOUND_E 4
.................... #define SOUND_F 5
.................... #define SOUND_Fis 6
.................... #define SOUND_G 7
.................... #define SOUND_Gis 8
.................... #define SOUND_A 9
.................... #define SOUND_Ais 10
.................... #define SOUND_H 11
.................... #define SOUND_Space 12 // Pomlka
....................
....................
.................... // Prototypy verejnych procedur
....................
.................... void SoundBeep(unsigned int16 Frequency, unsigned int16 Duration);
.................... // Predava se frekvence v Hz a doba trvani v ms (0 znamena ticho)
....................
.................... void SoundNote(unsigned int8 Note, Octave, unsigned int16 Duration);
.................... // Predava se cislo noty (0 je C), posunuti v oktavach (0 nejnizsi ton,
.................... // SOUND_Space je ticho), doba trvani v ms
....................
.................... // Alternativni makra pro generovani konstatnich tonu
.................... // SoundBeepMacro(Frequency, Duration) - frekvence nesmi byt 0
.................... // SoundNoteMacro(Note, Octave, Duration) - nepodporuje SOUND_Space
.................... // SoundSpaceMacro(Duration) - hraje ticho
....................
.................... // Privatni cast
....................
....................
.................... #int_ccp1
.................... void IntCCP1()
.................... // Preruseni od jednotky CCP1 generuje vystup
.................... {
.................... volatile int1 Data; // Posledni stav vystupu
.................... output_bit(SOUND_HI,Data); // Nastav vystup
*
00CB: BTFSC 72.0
00CC: GOTO 0CF
00CD: BCF 06.3
00CE: GOTO 0D0
00CF: BSF 06.3
00D0: BSF 03.5
00D1: BCF 06.3
.................... output_bit(SOUND_LO,~Data);
00D2: BTFSS 72.0
00D3: GOTO 0D8
00D4: BCF 03.5
00D5: BCF 06.2
00D6: GOTO 0DA
00D7: BSF 03.5
00D8: BCF 03.5
00D9: BSF 06.2
00DA: BSF 03.5
00DB: BCF 06.2
.................... Data=~Data; // Otoc stav vystupu
00DC: MOVLW 01
00DD: XORWF 72,F
.................... }
....................
....................
.................... #if SOUND_CLOCK < (65535*32*4*2) // < 16.7 MHz
.................... #define SOUND_PRESCALE 1
.................... #elif SOUND_CLOCK < (65535*32*4*2*2) // < 33.6 MHz
.................... #define SOUND_PRESCALE 2
.................... #elif SOUND_CLOCK < (65535*32*4*2*4) // < 67.1 MHz
.................... #define SOUND_PRESCALE 4
.................... #elif SOUND_CLOCK < (65535*32*4*2*8) // < 134 MHz
.................... #define SOUND_PRESCALE 8
.................... #else
.................... #error SOUND_CLOCK Frequency too high
.................... #endif
00DE: BCF 03.5
00DF: BCF 0C.2
00E0: BCF 0A.3
00E1: GOTO 022
.................... #bit T0IF=0x0B.2
.................... void SoundBeep(unsigned int16 Frequency, unsigned int16 Duration)
.................... // Predava se frekvence v Hz a doba trvani v ms (0 znamena ticho)
.................... // Rozumne frekvence jsou od 32Hz
.................... {
.................... unsigned int16 Time; // Pocitadlo zlomkoveho casu
....................
.................... // Inicializace casovace
.................... if (Frequency!=0) // Frekvence 0 znamena ticho
.................... {
.................... setup_ccp1(CCP_COMPARE_RESET_TIMER);
.................... set_timer1(0);
.................... (int16)CCP_1=SOUND_CLOCK/SOUND_PRESCALE/4/2/Frequency;
.................... #if SOUND_PRESCALE==1
.................... setup_timer_1(T1_INTERNAL|T1_DIV_BY_1);
.................... #elif SOUND_PRESCALE==2
.................... setup_timer_1(T1_INTERNAL|T1_DIV_BY_2);
.................... #elif SOUND_PRESCALE==4
.................... setup_timer_1(T1_INTERNAL|T1_DIV_BY_4);
.................... #elif SOUND_PRESCALE==8
.................... setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
.................... #endif
.................... enable_interrupts(int_ccp1);
.................... enable_interrupts(global);
.................... }
....................
.................... // Delka tonu merena casovacem T0 (bez preruseni)
.................... Time=0;
.................... setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
.................... while (Duration)
.................... {
.................... if (T0IF) // Preteceni T0 - kazdych (1/CLK)*4*256
.................... {
.................... T0IF = 0;
.................... Time += (256*4*1000*2048+SOUND_CLOCK/2)/SOUND_CLOCK;
.................... }
.................... if (Time>>11)
.................... {
.................... Time -= 2048;
.................... Duration--;
.................... }
.................... }
....................
.................... // Konec casovace
.................... disable_interrupts(int_ccp1);
.................... disable_interrupts(global);
.................... }
....................
....................
.................... // Definice casu pulperody pro nejnizsi oktavu, v kvantech casovace T1
.................... // Pulperiody tonu v dalsich oktavach se ziskavaji rotaci vpravo
.................... #define SOUND_Peri_C ((30578*(SOUND_CLOCK/1000)/1000/4/2)/SOUND_PRESCALE) // Perioda 30578us
.................... #define SOUND_Peri_Cis ((28862*(SOUND_CLOCK/1000)/1000/4/2)/SOUND_PRESCALE) // Perioda 28862us
.................... #define SOUND_Peri_D ((27242*(SOUND_CLOCK/1000)/1000/4/2)/SOUND_PRESCALE) // Perioda 27242us
.................... #define SOUND_Peri_Dis ((25713*(SOUND_CLOCK/1000)/1000/4/2)/SOUND_PRESCALE) // Perioda 25713us
.................... #define SOUND_Peri_E ((24270*(SOUND_CLOCK/1000)/1000/4/2)/SOUND_PRESCALE) // Perioda 24270us
.................... #define SOUND_Peri_F ((22908*(SOUND_CLOCK/1000)/1000/4/2)/SOUND_PRESCALE) // Perioda 22908us
.................... #define SOUND_Peri_Fis ((21622*(SOUND_CLOCK/1000)/1000/4/2)/SOUND_PRESCALE) // Perioda 21622us
.................... #define SOUND_Peri_G ((20408*(SOUND_CLOCK/1000)/1000/4/2)/SOUND_PRESCALE) // Perioda 20408us
.................... #define SOUND_Peri_Gis ((19263*(SOUND_CLOCK/1000)/1000/4/2)/SOUND_PRESCALE) // Perioda 19263us
.................... #define SOUND_Peri_A ((18182*(SOUND_CLOCK/1000)/1000/4/2)/SOUND_PRESCALE) // Perioda 18182us
.................... #define SOUND_Peri_Ais ((17161*(SOUND_CLOCK/1000)/1000/4/2)/SOUND_PRESCALE) // Perioda 17161us
.................... #define SOUND_Peri_H ((16198*(SOUND_CLOCK/1000)/1000/4/2)/SOUND_PRESCALE) // Perioda 16198us
....................
.................... // Kontrola na delku konstanty (musi byt mensi nez delka citace)
.................... #if SOUND_Peri_C > 65535
.................... #error "SOUND_Peri_C too long (Note C requires delay > 65535 cycles)"
.................... #endif
....................
.................... // Casove konstanty pro noty nejnizsi oktavy
.................... const unsigned int16 Table[12] =
.................... SOUND_Peri_C, SOUND_Peri_Cis, SOUND_Peri_D, SOUND_Peri_Dis,
.................... SOUND_Peri_E, SOUND_Peri_F, SOUND_Peri_Fis, SOUND_Peri_G,
.................... SOUND_Peri_Gis, SOUND_Peri_A, SOUND_Peri_Ais, SOUND_Peri_H;
*
0035: BCF 0A.0
0036: BCF 0A.1
0037: BCF 0A.2
0038: ADDWF 02,F
0039: RETLW 4E
003A: RETLW 95
003B: RETLW ED
003C: RETLW 8C
003D: RETLW 04
003E: RETLW 85
003F: RETLW 8D
0040: RETLW 7D
0041: RETLW 81
0042: RETLW 76
0043: RETLW DB
0044: RETLW 6F
0045: RETLW 93
0046: RETLW 69
0047: RETLW A6
0048: RETLW 63
0049: RETLW 0E
004A: RETLW 5E
004B: RETLW C7
004C: RETLW 58
004D: RETLW CB
004E: RETLW 53
004F: RETLW 17
0050: RETLW 4F
....................
....................
.................... void SoundNote(unsigned int8 Note, Octave, unsigned int16 Duration)
.................... // Predava se cislo noty (0 je C), posunuti v oktavach (0 nejnizsi ton)
.................... // doba trvani v ms (0 znamena ticho)
.................... // Zahraje zadanou notu v zadane oktave dane delky
.................... {
.................... unsigned int16 Time; // Pocitadlo zlomkoveho casu
....................
.................... // Inicializace casovace
.................... if (Note!=SOUND_Space) // Pokud se ma hrat spust hrani
*
00E2: MOVF 69,W
00E3: SUBLW 0C
00E4: BTFSC 03.2
00E5: GOTO 109
.................... {
.................... setup_ccp1(CCP_COMPARE_RESET_TIMER);
00E6: MOVLW 0B
00E7: MOVWF 17
.................... set_timer1(0);
00E8: CLRF 0F
00E9: CLRF 0E
.................... (int16)CCP_1=Table[Note]>>Octave;
00EA: BCF 03.0
00EB: RLF 69,W
00EC: MOVWF 77
00ED: MOVWF 6F
00EE: INCF 6F,W
00EF: CALL 035
00F0: MOVWF 7A
00F1: MOVF 6F,W
00F2: CALL 035
00F3: MOVWF 70
00F4: MOVF 7A,W
00F5: MOVWF 71
00F6: MOVWF 16
00F7: MOVF 70,W
00F8: MOVWF 15
00F9: MOVF 6A,W
00FA: MOVWF 77
00FB: BTFSC 03.2
00FC: GOTO 102
00FD: BCF 03.0
00FE: RRF 16,F
00FF: RRF 15,F
0100: DECFSZ 77,F
0101: GOTO 0FD
.................... #if SOUND_PRESCALE==1
.................... setup_timer_1(T1_INTERNAL|T1_DIV_BY_1);
.................... #elif SOUND_PRESCALE==2
.................... setup_timer_1(T1_INTERNAL|T1_DIV_BY_2);
0102: MOVLW 95
0103: MOVWF 10
.................... #elif SOUND_PRESCALE==4
.................... setup_timer_1(T1_INTERNAL|T1_DIV_BY_4);
.................... #elif SOUND_PRESCALE==8
.................... setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
.................... #endif
.................... enable_interrupts(int_ccp1);
0104: BSF 03.5
0105: BSF 0C.2
.................... enable_interrupts(global);
0106: MOVLW C0
0107: BCF 03.5
0108: IORWF 0B,F
.................... }
....................
.................... // Delka tonu merena casovacem T0 (bez preruseni)
.................... Time=0;
0109: CLRF 6E
010A: CLRF 6D
.................... setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
010B: BSF 03.5
010C: MOVF 01,W
010D: ANDLW C0
010E: IORLW 08
010F: MOVWF 01
.................... while (Duration)
0110: BCF 03.5
0111: MOVF 6B,W
0112: IORWF 6C,W
0113: BTFSC 03.2
0114: GOTO 132
.................... {
.................... if (T0IF) // Preteceni T0 - kazdych (1/CLK)*4*256
0115: BTFSS 0B.2
0116: GOTO 11C
.................... {
.................... T0IF = 0;
0117: BCF 0B.2
.................... Time += (256*4*1000*2048+SOUND_CLOCK/2)/SOUND_CLOCK;
0118: MOVLW 69
0119: ADDWF 6D,F
011A: BTFSC 03.0
011B: INCF 6E,F
.................... }
.................... if (Time>>11)
011C: CLRF 7A
011D: RRF 6E,W
011E: MOVWF 79
011F: RRF 79,F
0120: RRF 79,F
0121: MOVLW 1F
0122: ANDWF 79,F
0123: MOVF 79,W
0124: IORWF 7A,W
0125: BTFSC 03.2
0126: GOTO 131
.................... {
.................... Time -= 2048;
0127: MOVLW 00
0128: SUBWF 6D,F
0129: MOVLW 08
012A: BTFSS 03.0
012B: MOVLW 09
012C: SUBWF 6E,F
.................... Duration--;
012D: MOVF 6B,W
012E: BTFSC 03.2
012F: DECF 6C,F
0130: DECF 6B,F
.................... }
.................... }
0131: GOTO 111
....................
.................... // Konec casovace
.................... disable_interrupts(int_ccp1);
0132: BSF 03.5
0133: BCF 0C.2
.................... disable_interrupts(global);
0134: BCF 03.5
0135: BCF 0B.6
0136: BCF 0B.7
0137: BTFSC 0B.7
0138: GOTO 136
0139: RETLW 00
.................... }
....................
....................
.................... #include "Data.c" // Datovy blok pro predpripravene skladby
.................... // Tento soubor definuje vse potrebne pro ulozeni skladeb do pameti programu.
.................... // Dale definuje pislusna makra pro snadne definice. Tyto definice jsou voleny
.................... // zamerne tak, aby mohl byt pouzit stejny soubor s definici skladby jak
.................... // pro vlozeni primo do firmwaru v dobe prekladu tak i k dodatecnemu nahrani
.................... // skladby pres seriovou linku.
....................
.................... // Definice hranic pameti pro ulozeni pisnicek
.................... #define STARTMEM 0x600 // Zde zacina pametoa oblast pro pisnicky
.................... #define ENDMEM 0x7ff // Zde konci pametova oblast pro pisnicky
....................
.................... // Definice konstant pro kodovani dat
.................... #define ENDOFDATA 0x3FFF // Priznak konce pisnicek (prazdna pamet)
.................... #define DATABEGIN 0x2000 // Kod zacatku skladby
.................... #define MASKBEGIN 0x3800
.................... #define DATATEMPO 0x2800 // Kod pro nastaveni tempa
.................... #define MASKTEMPO 0x3800
.................... #define DATAPAUSE 0x3000 // Kod pro nastaveni mezery mezi notami
.................... #define MASKPAUSE 0x3800
.................... #define MASKNOTE 0x2000 // Nejvissi bit 0 urcuje, ze jde o notu
....................
.................... // Pseudomakra pro jednoduchy zapis skladeb do zdrojaku jazyka C
.................... #define BEGIN DATABEGIN+ // Zacatek pisnicky + posunuti oktav
.................... #define TEMPO DATATEMPO+ // Delka nejskratsi noty v ms
.................... #define PAUSE DATAPAUSE+ // Delka mezery mezi notami
.................... #define END // Konec skladby, zde nic neznamena
....................
.................... // Pseudomakra pro zapis not, zapisuje se cislo oktavy, nota, delka noty
.................... #define C *16 + SOUND_C + 128 *
.................... #define Cis *16 + SOUND_Cis + 128 *
.................... #define D *16 + SOUND_D + 128 *
.................... #define Dis *16 + SOUND_Dis + 128 *
.................... #define E *16 + SOUND_E + 128 *
.................... #define F *16 + SOUND_F + 128 *
.................... #define Fis *16 + SOUND_Fis + 128 *
.................... #define G *16 + SOUND_G + 128 *
.................... #define Gis *16 + SOUND_Gis + 128 *
.................... #define A *16 + SOUND_A + 128 *
.................... #define Ais *16 + SOUND_Ais + 128 *
.................... #define H *16 + SOUND_H + 128 *
.................... #define Space SOUND_Space + 128 *
....................
.................... // Pametova oblast
.................... #ORG 0x600,0x7FF {} // Vyhrazeni oblasti pameti pro ulozeni pisnicek
.................... #ROM 0x600 = { // Naplneni oblasti pameti daty
....................
.................... // Pisnicky jako soucast firwaru se vkladaji sem
.................... // Museji mit stejny format jako uvedene priklady aby zafungovaly makra
.................... #include "Skladby\TheFinalSoundDown.txt"
.................... // Pisnicka "The Final Sound Down"
.................... //
.................... // Tato pisnicka je napsana ve formatu, ktery se da pouzit jak pro primy
.................... // preklad do firmwaru melodickeho zvonku tak i pro dodatecne nahrani
....................
.................... BEGIN 3, // Zacatek skladby
.................... TEMPO 100, // Delka nejkratsi noty v ms
.................... PAUSE 100, // Delka mezery mezi notami
....................
.................... 1 A 1,
.................... 1 G 1,
.................... 1 A 4,
.................... 1 D 4,
.................... Space 2,
....................
.................... 1 Ais 1,
.................... 1 A 1,
.................... 1 Ais 2,
.................... 1 A 2,
.................... 1 G 4,
.................... Space 2,
....................
.................... 1 Ais 1,
.................... 1 A 1,
.................... 1 Ais 4,
.................... 1 D 4,
.................... Space 2,
....................
.................... 1 G 1,
.................... 1 F 1,
.................... 1 G 2,
.................... 1 F 2,
.................... 1 E 2,
.................... 1 G 2,
.................... 1 F 4,
.................... Space 2,
....................
.................... 1 E 1,
.................... 1 F 1,
.................... 1 G 4,
.................... Space 2,
....................
.................... 1 F 1,
.................... 1 G 1,
.................... 1 A 2,
.................... 1 G 2,
.................... 1 F 2,
.................... 1 E 2,
.................... 1 D 4,
.................... 1 Ais 4,
.................... 1 A 4,
.................... Space 2,
....................
.................... 1 A 1,
.................... 1 Ais 1,
.................... 1 A 1,
.................... 1 G 1,
.................... 1 A 4,
.................... Space 2,
....................
.................... END
....................
.................... #include "Skladby\BednaOdWhisky.txt"
.................... // Pisnicka "Bedna od Whisky"
.................... //
.................... // Tato pisnicka je napsana ve formatu, ktery se da pouzit jak pro primy
.................... // preklad do firmwaru melodickeho zvonku tak i pro dodatecne nahrani
....................
.................... BEGIN 2, // Zacatek skladby
.................... TEMPO 100, // Delka nejkratsi noty v ms
.................... PAUSE 100, // Delka mezery mezi notami
....................
.................... 1 A 2,
.................... 2 C 2,
.................... 2 E 2,
.................... 2 A 2,
.................... 2 G 4,
.................... 2 E 2,
.................... 2 E 2,
.................... 2 A 2,
.................... 2 G 2,
.................... 2 E 2,
.................... 2 D 2,
.................... 2 E 4,
.................... Space 4,
.................... 1 A 2,
.................... 2 C 2,
.................... 2 E 2,
.................... 2 A 2,
.................... 2 G 2,
.................... 2 G 2,
.................... 2 E 2,
.................... 2 E 2,
.................... 1 A 2,
.................... 2 E 2,
.................... 1 H 2,
.................... 2 E 2,
.................... 1 A 4,
.................... Space 4,
.................... 1 A 2,
.................... 2 C 2,
.................... 2 E 2,
.................... 2 A 2,
.................... 2 G 2,
.................... 2 G 2,
.................... 2 E 4,
.................... 2 A 2,
.................... 2 G 2,
.................... 2 E 2,
.................... 2 D 2,
.................... 2 E 4,
.................... Space 2,
.................... 2 E 2,
.................... 1 A 2,
.................... 2 C 2,
.................... 2 E 2,
.................... 2 A 2,
.................... 2 G 2,
.................... 2 E 4,
.................... 2 E 2,
.................... 2 A 2,
.................... 2 A 2,
.................... 2 GIS 2,
.................... 2 H 2,
.................... 2 A 4,
.................... Space 8,
.................... 2 E 2,
.................... 2 A 2,
.................... 2 A 2,
.................... 2 A 2,
.................... 2 GIS 2,
.................... 2 FIS 2,
.................... 2 A 4,
.................... 2 A 2,
.................... 2 H 2,
.................... 2 H 2,
.................... 2 A 2,
.................... 2 H 2,
.................... 3 CIS 2,
.................... 2 A 4,
.................... 2 E 2,
.................... 2 A 2,
.................... 2 A 2,
.................... 2 A 2,
.................... 2 GIS 2,
.................... 2 FIS 2,
.................... 2 A 2,
.................... 2 A 2,
.................... 2 A 2,
.................... 2 H 2,
.................... 2 H 2,
.................... 2 A 2,
.................... 2 GIS 2,
.................... 2 A 4,
.................... Space 2,
.................... 2 E 2,
.................... 2 A 2,
.................... 2 A 2,
.................... 2 A 2,
.................... 2 GIS 2,
.................... 2 FIS 2,
.................... 2 A 4,
.................... 2 A 2,
.................... 2 H 2,
.................... 2 H 2,
.................... 2 A 2,
.................... 2 H 2,
.................... 3 CIS 2,
.................... 2 A 4,
.................... 2 E 2,
.................... 2 A 2,
.................... 2 A 2,
.................... 2 A 2,
.................... 2 GIS 2,
.................... 2 FIS 2,
.................... 2 A 2,
.................... Space 2,
.................... 2 A 2,
.................... 2 H 2,
.................... 2 H 2,
.................... 2 A 2,
.................... 2 GIS 2,
.................... 2 A 8,
.................... 2 G 2,
.................... 2 A 8,
.................... 2 G 2,
.................... 2 A 8,
....................
.................... END
....................
.................... #include "Skladby\KdyzMeBaliZaVojacka.txt"
.................... // Pisnicka "Kdyz me brali za vojacka"
.................... //
.................... // Tato pisnicka je napsana ve formatu, ktery se da pouzit jak pro primy
.................... // preklad do firmwaru melodickeho zvonku tak i pro dodatecne nahrani
....................
.................... BEGIN 2, // Zacatek skladby
.................... TEMPO 150, // Delka nejkratsi noty v ms
.................... PAUSE 100, // Delka mezery mezi notami
....................
.................... 1 A 1,
.................... 2 C 1,
.................... 2 E 1,
.................... 2 D 1,
.................... 2 C 1,
.................... 1 H 1,
.................... 2 C 2,
.................... 2 D 1,
.................... 2 E 2,
.................... 2 D 1,
.................... 2 G 1,
.................... 2 G 1,
.................... 2 G 1,
.................... 2 G 1,
.................... 2 A 1,
.................... 2 E 2,
.................... Space 4,
.................... 2 D 1,
.................... 2 F 1,
.................... 2 A 1,
.................... 2 G 1,
.................... 2 F 1,
.................... 2 E 1,
.................... 2 E 1,
.................... 2 F 1,
.................... 2 E 1,
.................... 2 C 1,
.................... 1 A 2,
.................... 1 GIS 1,
.................... 1 H 1,
.................... 2 E 1,
.................... 2 D 1,
.................... 1 H 1,
.................... 2 C 1,
.................... 1 A 2,
.................... Space 2,
.................... 1 H 2,
.................... 2 C 2,
.................... Space 2,
.................... 2 D 2,
.................... 2 E 1,
.................... 2 E 1,
.................... 2 E 1,
.................... 2 D 1,
.................... 1 H 1,
.................... 2 C 1,
.................... 1 A 2,
....................
.................... END
....................
.................... #include "Skladby\Medvedi.txt"
.................... // Pisnicka "Medvedi"
.................... //
.................... // Tato pisnicka je napsana ve formatu, ktery se da pouzit jak pro primy
.................... // preklad do firmwaru melodickeho zvonku tak i pro dodatecne nahrani
....................
.................... BEGIN 1, // Zacatek skladby
.................... TEMPO 150, // Delka nejkratsi noty v ms
.................... PAUSE 100, // Delka mezery mezi notami
....................
.................... 1 C 1, // 1
.................... 1 C 1,
.................... 1 C 1,
.................... 1 E 1,
.................... 1 D 1,
.................... 0 G 1,
....................
.................... 1 C 3, // 2
.................... Space 4,
....................
.................... 1 E 1, // 3
.................... 1 E 1,
.................... 1 E 1,
.................... 1 E 1,
.................... 1 D 1,
.................... 1 G 1,
....................
.................... 1 E 2, // 4
.................... Space 4,
....................
.................... 1 G 1, // 5
.................... 1 G 1,
.................... 1 A 1,
.................... 1 G 1,
.................... 1 F 1,
.................... 1 E 1,
....................
.................... 1 F 1, // 6
.................... 1 A 1,
.................... 1 G 1,
.................... 1 F 1,
.................... 1 E 1,
.................... 1 D 1,
....................
.................... 1 C 1, // 7
.................... 0 H 1,
.................... 1 C 1,
.................... 1 E 1,
.................... 1 D 1,
.................... 0 G 1,
....................
.................... 1 C 3, // 8
.................... Space 4,
.................... 1 A 1, // 9
.................... 1 A 1,
.................... 1 A 1,
.................... 1 A 1,
.................... 1 H 1,
.................... 2 D 1,
....................
.................... 2 C 4, // 10
.................... Space 2,
....................
.................... 2 E 1, // 11
.................... 2 E 1,
.................... 2 E 1,
.................... 2 E 1,
.................... 2 D 1,
.................... 2 G 1,
....................
.................... 2 E 4, // 12
.................... Space 2,
....................
.................... 2 G 1, // 13
.................... 2 G 1,
.................... 2 A 1,
.................... 2 G 1,
.................... 2 F 1,
.................... 2 E 1,
....................
.................... 2 F 1, // 14
.................... 2 A 1,
.................... 2 G 1,
.................... 2 F 1,
.................... 2 E 1,
.................... 2 D 1,
....................
.................... 2 C 1, // 15
.................... 1 H 1,
.................... 2 C 1,
.................... 2 E 1,
.................... 2 D 1,
.................... 1 G 1,
....................
.................... 2 C 4, // 16
.................... Space 2,
....................
.................... 1 C 6, // 1
.................... 0 G 2,
....................
.................... 1 D 3, // 2
.................... Space 3,
....................
.................... 1 G 1, // 3
.................... 1 G 1,
.................... 1 Fis 1,
.................... 1 G 1,
.................... 1 A 1,
.................... 1 Fis 1,
....................
.................... 1 G 2, // 4
.................... Space 4,
....................
.................... 1 G 1, // 5
.................... 1 G 1,
.................... 1 A 1,
.................... 1 G 1,
.................... 1 F 1,
.................... 1 E 1,
....................
.................... 1 F 1, // 6
.................... 1 A 1,
.................... 1 G 1,
.................... 1 F 1,
.................... 1 E 1,
.................... 1 D 1,
....................
.................... 1 C 6, // 7
.................... 1 E 2,
....................
.................... 1 D 3, // 8
.................... Space 3,
....................
.................... 1 C 6, // 9
.................... 0 G 2,
....................
.................... 1 D 3, // 10
.................... Space 3,
....................
.................... 1 G 1, // 11
.................... 1 G 1,
.................... 1 Fis 1,
.................... 1 G 1,
.................... 1 A 1,
.................... 1 Fis 1,
....................
.................... 1 G 2, // 12
.................... Space 4,
....................
.................... 1 G 1, // 13
.................... 1 G 1,
.................... 1 A 1,
.................... 1 G 1,
.................... 1 F 1,
.................... 1 E 1,
....................
.................... 1 F 1, // 14
.................... 1 A 1,
.................... 1 G 1,
.................... 1 F 1,
.................... 1 E 1,
.................... 1 D 1,
....................
.................... 1 C 1, // 15
.................... 0 H 1,
.................... 1 C 1,
.................... 1 E 1,
.................... 1 D 1,
.................... 0 G 1,
....................
.................... 1 C 2, // 16
.................... Space 4,
....................
.................... END
....................
....................
.................... // Koncova znacka a konec oblasti pro skladby
.................... ENDOFDATA
.................... }
....................
.................... // Zruseni definic maker pro definici skladeb
.................... // V dalsim programu uz nebudou potreba
.................... #undef BEGIN
.................... #undef TEMPO
.................... #undef PAUSE
.................... #undef END
.................... #undef C
.................... #undef Cis
.................... #undef D
.................... #undef Dis
.................... #undef E
.................... #undef F
.................... #undef Fis
.................... #undef G
.................... #undef Gis
.................... #undef A
.................... #undef Ais
.................... #undef H
.................... #undef Space
....................
....................
.................... #define RXD PIN_B1 // Port pro RS232
.................... #use delay(CLOCK=20000000) // Konfigurace pro casovani RS232
.................... #use rs232(BAUD=9600,RCV=RXD,INVERT,PARITY=N,BITS=8) // Prenosove parametry RS232
*
0152: MOVLW 08
0153: MOVWF 77
0154: BSF 03.5
0155: BSF 06.1
0156: BCF 03.5
0157: BTFSS 06.1
0158: GOTO 157
0159: CLRF 61
015A: BSF 77.7
015B: GOTO 16A
015C: BCF 77.7
015D: GOTO 16A
015E: BCF 03.0
015F: BTFSS 06.1
0160: BSF 03.0
0161: RRF 61,F
0162: BSF 77.6
0163: GOTO 16A
0164: BCF 77.6
0165: DECFSZ 77,F
0166: GOTO 15E
0167: MOVF 61,W
0168: MOVWF 78
0169: GOTO 176
016A: MOVLW A7
016B: BTFSC 77.7
016C: MOVLW 2D
016D: MOVWF 78
016E: DECFSZ 78,F
016F: GOTO 16E
0170: NOP
0171: BTFSC 77.7
0172: GOTO 15C
0173: BTFSC 77.6
0174: GOTO 164
0175: GOTO 15E
0176: RETLW 00
....................
....................
.................... // Sada globalnich promennych
.................... // --------------------------
.................... // Vyuzivame globalni promenne protoze je to vyhodne z hlediska spotreby zdroju. Usetri
.................... // se vyznmane mnoho pameti programu pri predavani parametru
....................
....................
.................... unsigned int16 Adr; // Adresovy ukazatel do pameti skladeb
.................... unsigned int16 Data; // Prectena data nebo data pro zapis
.................... unsigned int1 Mode; // 0=rezim testovani, 1=rezim zapisu do FLASH
....................
.................... unsigned int16 Tempo; // Tempo (delka nejkratsi skladby v ms)
.................... unsigned int16 Pause; // Delka mezery mezi notami v ms
.................... unsigned int8 Octava; // Posunuti skladby v oktavach
....................
.................... unsigned int8 Beep; // Druh pipnuti pro proceduru SoundSpec
.................... unsigned int1 Error; // Priznak chyby
....................
.................... unsigned int8 CisloSkladby; // Cislo skladby pro proceduru Find a Play
....................
....................
.................... // Zvuky, posloupnost zadaneho poctu tonu
.................... #define SoundEndOfLine 0x01 // Kratke pipnuti na konci radky
.................... #define SoundPGM 0x03 // Trilek pri vstupu do rezimu programovani
.................... #define SoundPostPlay 0x03 // Po ukonceni prehravani
.................... #define SoundERASE 0x02 // Zvuk pri smazani bloku FLASH pameti
.................... #define SoundERR 0x05 // Chyba syntaxe
.................... void SpecBeep()
.................... // Data - pocet pipnuti, 0 znamena ticho
.................... {
.................... int Oct;
....................
.................... if (Error) Beep=SoundERR;
*
013A: BTFSS 2D.1
013B: GOTO 13E
013C: MOVLW 05
013D: MOVWF 33
....................
.................... for(Oct=2;Beep!=0;Beep--)
013E: MOVLW 02
013F: MOVWF 61
0140: MOVF 33,F
0141: BTFSC 03.2
0142: GOTO 150
.................... {
.................... SoundNote(SOUND_A,Oct++,50);
0143: MOVF 61,W
0144: INCF 61,F
0145: MOVWF 62
0146: MOVLW 09
0147: MOVWF 69
0148: MOVF 62,W
0149: MOVWF 6A
014A: CLRF 6C
014B: MOVLW 32
014C: MOVWF 6B
014D: CALL 0E2
.................... }
014E: DECF 33,F
014F: GOTO 140
....................
.................... Error=0;
0150: BCF 2D.1
0151: RETLW 00
.................... }
....................
....................
.................... // Precti slovo z pameti programu
.................... int16 ReadData()
.................... // Adr - adresa ze ktere se cte
.................... // Data - prectena data
.................... {
.................... int8 a,b; // Pomocne promenne
....................
.................... (int8)*EEADR = Adr; // Adresa, spodni cast
*
01EB: MOVF 29,W
01EC: BSF 03.6
01ED: MOVWF 0D
.................... (int8)*EEADRH = Adr >> 8; // Adresa, horni cast
01EE: BCF 03.6
01EF: MOVF 2A,W
01F0: BSF 03.6
01F1: MOVWF 0F
.................... bit_set(*EECON1,EECON1_EEPGD); // Pamet programu
01F2: BSF 03.5
01F3: BSF 0C.7
.................... bit_set(*EECON1,EECON1_RD); // Operace cteni
01F4: BSF 0C.0
.................... #ASM
.................... nop; // Povinne nop
01F5: NOP
.................... nop;
.................... #ENDASM
01F6: NOP
.................... a = (int8)*EEDATA; // Prevezmi data
01F7: BCF 03.5
01F8: MOVF 0C,W
01F9: BCF 03.6
01FA: MOVWF 61
.................... b = (int8)*EEDATAH;
01FB: BSF 03.6
01FC: MOVF 0E,W
01FD: BCF 03.6
01FE: MOVWF 62
.................... Data=make16(b,a); // Sestav vysledek ze 2 bajtu
01FF: MOVF 62,W
0200: MOVWF 2C
0201: MOVF 61,W
0202: MOVWF 2B
0203: RETLW 00
.................... }
....................
....................
.................... // Smazani cele pameti vyhrazene pro skladby
.................... void Erase()
.................... {
.................... for(Adr=STARTMEM; Adr<=ENDMEM; Adr++) // Cela oblast
*
047D: MOVLW 06
047E: MOVWF 2A
047F: CLRF 29
0480: MOVF 2A,W
0481: SUBLW 07
0482: BTFSS 03.0
0483: GOTO 4B3
.................... {
.................... ReadData();
0484: CALL 1EB
.................... if (Data!=0x3FFF) // Mazu jen bloky, ktere to potrebuji
0485: INCFSZ 2B,W
0486: GOTO 48B
0487: MOVF 2C,W
0488: SUBLW 3F
0489: BTFSC 03.2
048A: GOTO 4AF
.................... {
.................... if (input(POWER_PIC)!=0) return; // Nezapisuj pokud neni jumper povoleni programovani
048B: BSF 03.5
048C: BSF 05.3
048D: MOVLW 00
048E: BCF 03.5
048F: BTFSC 05.3
0490: MOVLW 01
0491: XORLW 00
0492: BTFSC 03.2
0493: GOTO 495
0494: GOTO 4B3
.................... (int8)*EEADR = Adr; // Adresa bloku, spodni cast
0495: MOVF 29,W
0496: BSF 03.6
0497: MOVWF 0D
.................... (int8)*EEADRH = Adr >> 8; // Adresa bloku, horni cast
0498: BCF 03.6
0499: MOVF 2A,W
049A: BSF 03.6
049B: MOVWF 0F
.................... bit_set(*EECON1,EECON1_EEPGD); // Pamet programu
049C: BSF 03.5
049D: BSF 0C.7
.................... bit_set(*EECON1,EECON1_WREN); // Povolit zapis
049E: BSF 0C.2
.................... bit_set(*EECON1,EECON1_FREE); // Operace mazani
049F: BSF 0C.4
.................... (int8)*EECON2 = 0x55; // Povinna segvence pro zapis
04A0: MOVLW 55
04A1: MOVWF 0D
.................... (int8)*EECON2 = 0xAA;
04A2: MOVLW AA
04A3: MOVWF 0D
.................... bit_set(*EECON1,EECON1_WR); // Zahajeni mazani
04A4: BSF 0C.1
.................... #ASM
.................... nop; // Povinne prazdne instrukce
04A5: NOP
.................... nop;
.................... #ENDASM
04A6: NOP
.................... bit_clear(*EECON1,EECON1_WREN); // Uz ne zapis
04A7: BCF 0C.2
.................... bit_clear(*EECON1,EECON1_FREE); // Uz ne mazani
04A8: BCF 0C.4
.................... bit_clear(*EECON1,EECON1_EEPGD); // Uz ne pamet programu
04A9: BCF 0C.7
.................... Beep=SoundERASE;
04AA: MOVLW 02
04AB: BCF 03.5
04AC: BCF 03.6
04AD: MOVWF 33
.................... SpecBeep();
04AE: CALL 13A
.................... }
.................... }
04AF: INCF 29,F
04B0: BTFSC 03.2
04B1: INCF 2A,F
04B2: GOTO 480
.................... }
....................
....................
.................... // Zapis do pameti programu po jednotlivych slovech.
.................... // Soucastka vyzaduje zapis vzdy celych osmi slov najednou. Vyuziva se toho, ze pamet FLASH
.................... // umi zapisovat jen smerem do nuly a tak staci na pozice, ktere zrovna nechceme programovat
.................... // zapsat same jednicky cimz se stav jejich stav nezmeni.
.................... void WriteData()
.................... // Adr - adresa, kam se bude zapisovat
.................... // Data - data, ktera se budou zapisovat
.................... {
.................... int i;
....................
.................... bit_set(*EECON1,EECON1_EEPGD); // Pamet programu
*
0300: BSF 03.5
0301: BSF 03.6
0302: BSF 0C.7
.................... bit_set(*EECON1,EECON1_WREN); // Zapis
0303: BSF 0C.2
.................... (int8)*EEADR = Adr & ~3; // Adresa, spodni cast, zaokrouhleno dolu na nasobek 8
0304: BCF 03.5
0305: BCF 03.6
0306: MOVF 29,W
0307: ANDLW FC
0308: BSF 03.6
0309: MOVWF 0D
.................... (int8)*EEADRH = Adr >> 8; // Adresa, horni cast
030A: BCF 03.6
030B: MOVF 2A,W
030C: BSF 03.6
030D: MOVWF 0F
.................... for (i=0; i<4; i++)
030E: BCF 03.6
030F: CLRF 61
0310: MOVF 61,W
0311: SUBLW 03
0312: BTFSS 03.0
0313: GOTO 33B
.................... {
.................... if ((Adr & 3) == i) // Pokud je adresa slova v bloku totozna s pozadovanou
0314: MOVF 29,W
0315: ANDLW 03
0316: MOVWF 62
0317: MOVF 2A,W
0318: ANDLW 00
0319: MOVWF 63
031A: MOVF 61,W
031B: SUBWF 62,W
031C: BTFSS 03.2
031D: GOTO 32A
031E: MOVF 63,F
031F: BTFSS 03.2
0320: GOTO 32A
.................... {
.................... (int8)*EEDATA =Data; // Platne slovo, spodni cast
0321: MOVF 2B,W
0322: BSF 03.6
0323: MOVWF 0C
.................... (int8)*EEDATAH=Data >> 8; // Platne slovo, horni cast
0324: BCF 03.6
0325: MOVF 2C,W
0326: BSF 03.6
0327: MOVWF 0E
.................... }
.................... else // Ostatni bunky nemenime
0328: GOTO 32E
0329: BCF 03.6
.................... {
.................... (int8)*EEDATA =0xFF; // Zbytek same jednicky
032A: MOVLW FF
032B: BSF 03.6
032C: MOVWF 0C
.................... (int8)*EEDATAH=0xFF;
032D: MOVWF 0E
.................... }
.................... (int8)*EECON2 = 0x55; // Povinna sekvence pro zapis
032E: MOVLW 55
032F: BSF 03.5
0330: MOVWF 0D
.................... (int8)*EECON2 = 0xAA;
0331: MOVLW AA
0332: MOVWF 0D
.................... bit_set(*EECON1,EECON1_WR); // Zahajeni zapisu
0333: BSF 0C.1
.................... #ASM
.................... nop; // Povinne dve prazdne instrukce
0334: NOP
.................... nop;
.................... #ENDASM
0335: NOP
.................... ((int8)*EEADR) ++; // Dalsi slovo
0336: BCF 03.5
0337: INCF 0D,F
.................... }
0338: BCF 03.6
0339: INCF 61,F
033A: GOTO 310
.................... bit_clear(*EECON1,EECON1_WREN); // Konec zapisu
033B: BSF 03.5
033C: BSF 03.6
033D: BCF 0C.2
.................... bit_clear(*EECON1,EECON1_EEPGD); // Uz ne pamet programu (bezpecnost)
033E: BCF 0C.7
.................... }
....................
....................
.................... // Zapise data Data na adresu Adr a provede posun na dalsi adresu, zapisuje se jen do
.................... // dovolene oblasti pameti a jen v pripade, ze je Mode=1
.................... void WriteDataInc()
.................... // Data - co se zapisuje
.................... // Adr - kam se zapisuje, po zapisu se adresa posouva
.................... {
.................... if (~Mode) return; // Neni rezim zapisu
*
02DC: BTFSC 2D.0
02DD: GOTO 2DF
02DE: GOTO 346
.................... if ( (Adr>=STARTMEM) & (Adr<=ENDMEM) & (input(POWER_PIC)==0) )
02DF: MOVF 2A,W
02E0: SUBLW 05
02E1: BTFSS 03.0
02E2: GOTO 2E5
02E3: MOVLW 00
02E4: GOTO 2E6
02E5: MOVLW 01
02E6: MOVWF 61
02E7: MOVF 2A,W
02E8: SUBLW 07
02E9: BTFSC 03.0
02EA: GOTO 2ED
02EB: MOVLW 00
02EC: GOTO 2EE
02ED: MOVLW 01
02EE: ANDWF 61,W
02EF: MOVWF 62
02F0: BSF 03.5
02F1: BSF 05.3
02F2: MOVLW 00
02F3: BCF 03.5
02F4: BTFSC 05.3
02F5: MOVLW 01
02F6: XORLW 00
02F7: BTFSC 03.2
02F8: GOTO 2FB
02F9: MOVLW 00
02FA: GOTO 2FC
02FB: MOVLW 01
02FC: ANDWF 62,W
02FD: XORLW 00
02FE: BTFSC 03.2
02FF: GOTO 345
.................... {
.................... WriteData();
.................... Adr++;
*
033F: BCF 03.5
0340: BCF 03.6
0341: INCF 29,F
0342: BTFSC 03.2
0343: INCF 2A,F
.................... }
.................... else
0344: GOTO 346
.................... {
.................... Error=1;
0345: BSF 2D.1
.................... }
0346: RETLW 00
.................... }
....................
....................
.................... // Najdi zacatek zadaneho cisla skladby. Promenna Adr ukazuje na zacatek skladby.
.................... // Neni-li skladba nalezena ukazuje Adr na koncovou znacku (0x3FFF) posledni skladby
.................... // nebo na konec pameti.
.................... int1 Find()
.................... // CisloSkladby - poradove cislo skladby
.................... // Adr - adresa zacatku skladby
.................... {
.................... Adr=STARTMEM-1; // Od zacatku oblasti pro skladby
*
0204: MOVLW 05
0205: MOVWF 2A
0206: MOVLW FF
0207: MOVWF 29
.................... for(;1;)
.................... {
.................... Adr++;
0208: INCF 29,F
0209: BTFSC 03.2
020A: INCF 2A,F
.................... ReadData(); // Precti data
020B: CALL 1EB
.................... if (Data==ENDOFDATA) return 1; // Priznak konce dat
020C: INCFSZ 2B,W
020D: GOTO 215
020E: MOVF 2C,W
020F: SUBLW 3F
0210: BTFSS 03.2
0211: GOTO 215
0212: MOVLW 01
0213: MOVWF 78
0214: GOTO 232
.................... if (Adr==ENDMEM+1) return 1; // Uz jsme prosli celou pamet
0215: MOVF 29,F
0216: BTFSS 03.2
0217: GOTO 21F
0218: MOVF 2A,W
0219: SUBLW 08
021A: BTFSS 03.2
021B: GOTO 21F
021C: MOVLW 01
021D: MOVWF 78
021E: GOTO 232
.................... if ((Data&MASKBEGIN)==DATABEGIN) // Priznak zacatku skladby
021F: MOVF 2B,W
0220: ANDLW 00
0221: MOVWF 61
0222: MOVF 2C,W
0223: ANDLW 38
0224: MOVWF 62
0225: MOVF 61,F
0226: BTFSS 03.2
0227: GOTO 231
0228: MOVF 62,W
0229: SUBLW 20
022A: BTFSS 03.2
022B: GOTO 231
.................... {
.................... CisloSkladby--; // Otestuj pocitadlo skladeb
022C: DECFSZ 34,F
.................... if (CisloSkladby==0) return 0; // Je to tato skladba
022D: GOTO 231
022E: MOVLW 00
022F: MOVWF 78
0230: GOTO 232
.................... }
.................... }
0231: GOTO 208
0232: RETLW 00
.................... }
....................
....................
.................... // Zahraj jednu notu
.................... void PlayData()
.................... // Data = zakodovana nota
.................... // Tempo, Octava, Pause = parametry hrane noty
.................... {
.................... SoundNote((int8)Data&0xF,Octava+(((int8)Data>>4)&0x7),Tempo*((Data>>7)&0x3F)); // Zahraj notu
0233: MOVF 2B,W
0234: ANDLW 0F
0235: MOVWF 61
0236: SWAPF 2B,W
0237: MOVWF 77
0238: MOVLW 0F
0239: ANDWF 77,F
023A: MOVF 77,W
023B: ANDLW 07
023C: ADDWF 32,W
023D: MOVWF 63
023E: RRF 2C,W
023F: MOVWF 65
0240: RRF 2B,W
0241: MOVWF 64
0242: RRF 65,F
0243: RRF 64,F
0244: RRF 65,F
0245: RRF 64,F
0246: RRF 65,F
0247: RRF 64,F
0248: RRF 65,F
0249: RRF 64,F
024A: RRF 65,F
024B: RRF 64,F
024C: RRF 65,F
024D: RRF 64,F
024E: MOVLW 01
024F: ANDWF 65,F
0250: MOVF 64,W
0251: ANDLW 3F
0252: MOVWF 77
0253: MOVF 65,W
0254: ANDLW 00
0255: MOVWF 7A
0256: MOVF 77,W
0257: MOVWF 66
0258: MOVF 7A,W
0259: MOVWF 67
025A: MOVF 2F,W
025B: MOVWF 69
025C: MOVF 2E,W
025D: MOVWF 68
025E: MOVF 7A,W
025F: MOVWF 6B
0260: MOVF 77,W
0261: MOVWF 6A
0262: CALL 177
0263: MOVF 79,W
0264: MOVWF 68
0265: MOVF 78,W
0266: MOVWF 67
0267: MOVF 61,W
0268: MOVWF 69
0269: MOVF 63,W
026A: MOVWF 6A
026B: MOVF 79,W
026C: MOVWF 6C
026D: MOVF 78,W
026E: MOVWF 6B
026F: CALL 0E2
.................... SoundNote(SOUND_Space,0,Pause); // Zahraj mezeru mezi notami
0270: MOVLW 0C
0271: MOVWF 69
0272: CLRF 6A
0273: MOVF 31,W
0274: MOVWF 6C
0275: MOVF 30,W
0276: MOVWF 6B
0277: CALL 0E2
0278: RETLW 00
.................... }
....................
....................
.................... // Zahraj skladbu od zadane adresy v promenne Adr.
.................... void Play()
.................... // CisloSkladby - cislo skladby k hrani
.................... {
.................... if (Find()) // Najdi zacatek skladby v pameti skladeb
0279: CALL 204
027A: MOVF 78,F
027B: BTFSC 03.2
027C: GOTO 27E
.................... {
.................... return; // Skladba nenalezena
027D: GOTO 2DB
.................... }
....................
.................... Tempo=100; // Default delka noty
027E: CLRF 2F
027F: MOVLW 64
0280: MOVWF 2E
.................... Pause=100; // Default mezera mezi notami
0281: CLRF 31
0282: MOVWF 30
....................
.................... Octava=Data&~MASKBEGIN; // Posunuti oktav (povinna soucast zacatku skladby)
0283: MOVF 2B,W
0284: MOVWF 32
.................... Adr++;
0285: INCF 29,F
0286: BTFSC 03.2
0287: INCF 2A,F
....................
.................... for (;1;)
.................... {
.................... if (Adr==ENDMEM+1) return; // Konec pametove oblasti
0288: MOVF 29,F
0289: BTFSS 03.2
028A: GOTO 290
028B: MOVF 2A,W
028C: SUBLW 08
028D: BTFSS 03.2
028E: GOTO 290
028F: GOTO 2DB
.................... ReadData(); // Vezmi data
0290: CALL 1EB
.................... Adr++; // Posun adresu
0291: INCF 29,F
0292: BTFSC 03.2
0293: INCF 2A,F
.................... if (Data==ENDOFDATA) return; // Konec dat
0294: INCFSZ 2B,W
0295: GOTO 29B
0296: MOVF 2C,W
0297: SUBLW 3F
0298: BTFSS 03.2
0299: GOTO 29B
029A: GOTO 2DB
.................... if ((Data&MASKBEGIN)==DATABEGIN) return; // Zacatek dalsi skladby
029B: MOVF 2B,W
029C: ANDLW 00
029D: MOVWF 61
029E: MOVF 2C,W
029F: ANDLW 38
02A0: MOVWF 62
02A1: MOVF 61,F
02A2: BTFSS 03.2
02A3: GOTO 2A9
02A4: MOVF 62,W
02A5: SUBLW 20
02A6: BTFSS 03.2
02A7: GOTO 2A9
02A8: GOTO 2DB
.................... if ((Data&MASKTEMPO)==DATATEMPO) Tempo=Data&~DATATEMPO; // Paramter TEMPO
02A9: MOVF 2B,W
02AA: ANDLW 00
02AB: MOVWF 61
02AC: MOVF 2C,W
02AD: ANDLW 38
02AE: MOVWF 62
02AF: MOVF 61,F
02B0: BTFSS 03.2
02B1: GOTO 2BB
02B2: MOVF 62,W
02B3: SUBLW 28
02B4: BTFSS 03.2
02B5: GOTO 2BB
02B6: MOVF 2B,W
02B7: MOVWF 2E
02B8: MOVF 2C,W
02B9: ANDLW D7
02BA: MOVWF 2F
.................... if ((Data&MASKPAUSE)==DATAPAUSE) Pause=Data&~DATAPAUSE; // Parametr PAUSE
02BB: MOVF 2B,W
02BC: ANDLW 00
02BD: MOVWF 61
02BE: MOVF 2C,W
02BF: ANDLW 38
02C0: MOVWF 62
02C1: MOVF 61,F
02C2: BTFSS 03.2
02C3: GOTO 2CD
02C4: MOVF 62,W
02C5: SUBLW 30
02C6: BTFSS 03.2
02C7: GOTO 2CD
02C8: MOVF 2B,W
02C9: MOVWF 30
02CA: MOVF 2C,W
02CB: ANDLW CF
02CC: MOVWF 31
.................... if ((Data&MASKNOTE)==0) // Nota
02CD: MOVF 2B,W
02CE: ANDLW 00
02CF: MOVWF 61
02D0: MOVF 2C,W
02D1: ANDLW 20
02D2: MOVWF 62
02D3: MOVF 61,F
02D4: BTFSS 03.2
02D5: GOTO 2DA
02D6: MOVF 62,F
02D7: BTFSS 03.2
02D8: GOTO 2DA
.................... {
.................... PlayData(); // Zahraj notu
02D9: CALL 233
.................... }
.................... }
02DA: GOTO 288
02DB: RETLW 00
.................... }
....................
....................
.................... // Vycisli cislo z bufferu, posune ukazovatko na prvni nezpracovany znak, preskakuje mezery
.................... int16 Number(char line[], int *a, len)
.................... {
.................... int16 Data;
.................... char c;
....................
.................... while((line[*a]==' ')&(*a<len)) // Vynech mezery na zacatku
*
018C: MOVF 62,W
018D: MOVWF 04
018E: MOVF 61,W
018F: ADDWF 00,W
0190: MOVWF 04
0191: MOVF 00,W
0192: SUBLW 20
0193: BTFSC 03.2
0194: GOTO 197
0195: MOVLW 00
0196: GOTO 198
0197: MOVLW 01
0198: MOVWF 69
0199: MOVF 62,W
019A: MOVWF 04
019B: MOVF 63,W
019C: SUBWF 00,W
019D: BTFSS 03.0
019E: GOTO 1A1
019F: MOVLW 00
01A0: GOTO 1A2
01A1: MOVLW 01
01A2: ANDWF 69,W
01A3: XORLW 00
01A4: BTFSC 03.2
01A5: GOTO 1AA
.................... (*a)++; // Posouvej ukazovatko
01A6: MOVF 62,W
01A7: MOVWF 04
01A8: INCF 00,F
01A9: GOTO 18C
....................
.................... Data=0;
01AA: CLRF 65
01AB: CLRF 64
.................... while (1)
.................... {
.................... if (*a>=len) return Data; // Konec retezce
01AC: MOVF 62,W
01AD: MOVWF 04
01AE: MOVF 63,W
01AF: SUBWF 00,W
01B0: BTFSS 03.0
01B1: GOTO 1B7
01B2: MOVF 64,W
01B3: MOVWF 78
01B4: MOVF 65,W
01B5: MOVWF 79
01B6: GOTO 1EA
.................... c=line[*a]; // Vezmi znak z pole
01B7: MOVF 62,W
01B8: MOVWF 04
01B9: MOVF 61,W
01BA: ADDWF 00,W
01BB: MOVWF 04
01BC: MOVF 00,W
01BD: MOVWF 66
.................... if ((c<'0')|(c>'9')) return Data; // Koncime pokud znak neni cislice
01BE: MOVF 66,W
01BF: SUBLW 2F
01C0: BTFSC 03.0
01C1: GOTO 1C4
01C2: MOVLW 00
01C3: GOTO 1C5
01C4: MOVLW 01
01C5: MOVWF 67
01C6: MOVF 66,W
01C7: SUBLW 39
01C8: BTFSS 03.0
01C9: GOTO 1CC
01CA: MOVLW 00
01CB: GOTO 1CD
01CC: MOVLW 01
01CD: IORWF 67,W
01CE: XORLW 00
01CF: BTFSC 03.2
01D0: GOTO 1D6
01D1: MOVF 64,W
01D2: MOVWF 78
01D3: MOVF 65,W
01D4: MOVWF 79
01D5: GOTO 1EA
.................... Data = Data * 10 + (c-'0'); // Pouzij cislici
01D6: MOVF 65,W
01D7: MOVWF 69
01D8: MOVF 64,W
01D9: MOVWF 68
01DA: CLRF 6B
01DB: MOVLW 0A
01DC: MOVWF 6A
01DD: CALL 177
01DE: MOVLW 30
01DF: SUBWF 66,W
01E0: ADDWF 78,W
01E1: MOVWF 64
01E2: MOVF 79,W
01E3: MOVWF 65
01E4: BTFSC 03.0
01E5: INCF 65,F
.................... (*a)++; // Dalsi znak
01E6: MOVF 62,W
01E7: MOVWF 04
01E8: INCF 00,F
.................... }
01E9: GOTO 1AC
01EA: RETLW 00
.................... }
....................
....................
.................... // Vyhledej klicove slovo a vrat jeho zkraceny kod
.................... // Pokud slovo neexistuje vraci -1
.................... // Format definice - retezec ukonceny nulou + zastupny znak, na konci prazdny retezec (nula)
.................... const char KeyWords[] =
.................... {
.................... 'P','L','A','Y',0, 'P',
.................... 'E','R','A','S','E',0, 'E',
.................... 'T','E','M','P','O',0, 't',
.................... 'P','A','U','S','E',0, 'p',
.................... 'B','E','G','I','N',0, 'B',
.................... 'T','E','S','T',0, 'b',
.................... 'E','N','D',0, 'Z',
.................... 'C',0. SOUND_C,
.................... 'C','I','S',0, SOUND_Cis,
.................... 'D',0, SOUND_D,
.................... 'D','I','S',0, SOUND_Dis,
.................... 'E',0, SOUND_E,
.................... 'F',0, SOUND_F,
.................... 'F','I','S',0, SOUND_Fis,
.................... 'G',0, SOUND_G,
.................... 'G','I','S',0, SOUND_Gis,
.................... 'A',0, SOUND_A,
.................... 'A','I','S',0, SOUND_Ais,
.................... 'H',0, SOUND_H,
.................... 'S','P','A','C','E',0, SOUND_Space
.................... };
*
0051: BCF 0A.0
0052: BCF 0A.1
0053: BCF 0A.2
0054: ADDWF 02,F
0055: RETLW 50
0056: RETLW 4C
0057: RETLW 41
0058: RETLW 59
0059: RETLW 00
005A: RETLW 50
005B: RETLW 45
005C: RETLW 52
005D: RETLW 41
005E: RETLW 53
005F: RETLW 45
0060: RETLW 00
0061: RETLW 45
0062: RETLW 54
0063: RETLW 45
0064: RETLW 4D
0065: RETLW 50
0066: RETLW 4F
0067: RETLW 00
0068: RETLW 74
0069: RETLW 50
006A: RETLW 41
006B: RETLW 55
006C: RETLW 53
006D: RETLW 45
006E: RETLW 00
006F: RETLW 70
0070: RETLW 42
0071: RETLW 45
0072: RETLW 47
0073: RETLW 49
0074: RETLW 4E
0075: RETLW 00
0076: RETLW 42
0077: RETLW 54
0078: RETLW 45
0079: RETLW 53
007A: RETLW 54
007B: RETLW 00
007C: RETLW 62
007D: RETLW 45
007E: RETLW 4E
007F: RETLW 44
0080: RETLW 00
0081: RETLW 5A
0082: RETLW 43
0083: RETLW 00
0084: RETLW 00
0085: RETLW 43
0086: RETLW 49
0087: RETLW 53
0088: RETLW 00
0089: RETLW 01
008A: RETLW 44
008B: RETLW 00
008C: RETLW 02
008D: RETLW 44
008E: RETLW 49
008F: RETLW 53
0090: RETLW 00
0091: RETLW 03
0092: RETLW 45
0093: RETLW 00
0094: RETLW 04
0095: RETLW 46
0096: RETLW 00
0097: RETLW 05
0098: RETLW 46
0099: RETLW 49
009A: RETLW 53
009B: RETLW 00
009C: RETLW 06
009D: RETLW 47
009E: RETLW 00
009F: RETLW 07
00A0: RETLW 47
00A1: RETLW 49
00A2: RETLW 53
00A3: RETLW 00
00A4: RETLW 08
00A5: RETLW 41
00A6: RETLW 00
00A7: RETLW 09
00A8: RETLW 41
00A9: RETLW 49
00AA: RETLW 53
00AB: RETLW 00
00AC: RETLW 0A
00AD: RETLW 48
00AE: RETLW 00
00AF: RETLW 0B
00B0: RETLW 53
00B1: RETLW 50
00B2: RETLW 41
00B3: RETLW 43
00B4: RETLW 45
00B5: RETLW 00
00B6: RETLW 0C
.................... signed int Word(char line[], unsigned int8 *a, len)
.................... {
.................... unsigned int8 i; // Index do pole klicovych slov
.................... unsigned int8 j; // index do zpracovavane radky
....................
.................... while((line[*a]==' ')&(*a<len)) // Vynech mezery na zacatku
*
03A1: MOVF 62,W
03A2: MOVWF 04
03A3: MOVF 61,W
03A4: ADDWF 00,W
03A5: MOVWF 04
03A6: MOVF 00,W
03A7: SUBLW 20
03A8: BTFSC 03.2
03A9: GOTO 3AC
03AA: MOVLW 00
03AB: GOTO 3AD
03AC: MOVLW 01
03AD: MOVWF 68
03AE: MOVF 62,W
03AF: MOVWF 04
03B0: MOVF 63,W
03B1: SUBWF 00,W
03B2: BTFSS 03.0
03B3: GOTO 3B6
03B4: MOVLW 00
03B5: GOTO 3B7
03B6: MOVLW 01
03B7: ANDWF 68,W
03B8: XORLW 00
03B9: BTFSC 03.2
03BA: GOTO 3BF
.................... (*a)++; // Posouvej ukazovatko
03BB: MOVF 62,W
03BC: MOVWF 04
03BD: INCF 00,F
03BE: GOTO 3A1
....................
.................... for (i=0;i<sizeof(KeyWords);) // Slova ze slovniku
03BF: CLRF 64
03C0: MOVF 64,W
03C1: SUBLW 61
03C2: BTFSS 03.0
03C3: GOTO 42B
.................... {
.................... for (j=*a;(j<len)&(KeyWords[i]!=0)&(KeyWords[i]==line[j]);i++,j++) // Znaky ze slova
03C4: MOVF 62,W
03C5: MOVWF 04
03C6: MOVF 00,W
03C7: MOVWF 65
03C8: MOVF 63,W
03C9: SUBWF 65,W
03CA: BTFSS 03.0
03CB: GOTO 3CE
03CC: MOVLW 00
03CD: GOTO 3CF
03CE: MOVLW 01
03CF: MOVWF 66
03D0: MOVF 64,W
03D1: CALL 051
03D2: XORLW 00
03D3: BTFSS 03.2
03D4: GOTO 3D7
03D5: MOVLW 00
03D6: GOTO 3D8
03D7: MOVLW 01
03D8: ANDWF 66,W
03D9: MOVWF 68
03DA: MOVF 64,W
03DB: CALL 051
03DC: MOVWF 69
03DD: MOVF 61,W
03DE: ADDWF 65,W
03DF: MOVWF 04
03E0: MOVF 00,W
03E1: SUBWF 69,W
03E2: BTFSC 03.2
03E3: GOTO 3E6
03E4: MOVLW 00
03E5: GOTO 3E7
03E6: MOVLW 01
03E7: ANDWF 68,W
03E8: XORLW 00
03E9: BTFSC 03.2
03EA: GOTO 3EF
.................... {
.................... }
03EB: MOVF 64,W
03EC: INCF 64,F
03ED: INCF 65,F
03EE: GOTO 3C8
.................... if ((KeyWords[i]==0)&((line[j]==' ')|(j==len)))
03EF: MOVF 64,W
03F0: CALL 051
03F1: XORLW 00
03F2: BTFSC 03.2
03F3: GOTO 3F6
03F4: MOVLW 00
03F5: GOTO 3F7
03F6: MOVLW 01
03F7: MOVWF 67
03F8: MOVF 61,W
03F9: ADDWF 65,W
03FA: MOVWF 04
03FB: MOVF 00,W
03FC: SUBLW 20
03FD: BTFSC 03.2
03FE: GOTO 401
03FF: MOVLW 00
0400: GOTO 402
0401: MOVLW 01
0402: MOVWF 69
0403: MOVF 63,W
0404: SUBWF 65,W
0405: BTFSC 03.2
0406: GOTO 409
0407: MOVLW 00
0408: GOTO 40A
0409: MOVLW 01
040A: IORWF 69,W
040B: ANDWF 67,W
040C: XORLW 00
040D: BTFSC 03.2
040E: GOTO 421
.................... {
.................... if (j>=len) j=len-1; // Korekce abychom se nedostali za konec retezce
040F: MOVF 63,W
0410: SUBWF 65,W
0411: BTFSS 03.0
0412: GOTO 416
0413: MOVLW 01
0414: SUBWF 63,W
0415: MOVWF 65
.................... *a=j+1; // Posun ukazovatko za zpracovane slovo
0416: MOVF 62,W
0417: MOVWF 04
0418: MOVLW 01
0419: ADDWF 65,W
041A: MOVWF 00
....................
.................... return KeyWords[i+1]; // Vrat zastupnou hodnotu z tabulky klicovych slov
041B: MOVLW 01
041C: ADDWF 64,W
041D: CALL 051
041E: MOVWF 78
041F: MOVWF 78
0420: GOTO 42D
.................... }
.................... while(KeyWords[i]!=0) i++; // Preskoc zbytek slova v tabulce
0421: MOVF 64,W
0422: CALL 051
0423: XORLW 00
0424: BTFSC 03.2
0425: GOTO 428
0426: INCF 64,F
0427: GOTO 421
.................... i++; // Preskoc oddelovac
0428: INCF 64,F
.................... i++; // Preskoc polozku se zastupnou hodnotou
0429: INCF 64,F
.................... }
042A: GOTO 3C0
.................... return -1; // Prosli jsme cely slovnik a nedoslo ke shode
042B: MOVLW FF
042C: MOVWF 78
.................... }
....................
....................
.................... // Programovani pres RS232
.................... #define LINELEN 40 // Delka radky pro RS232
.................... #define CR 0x0D // Odradkovani
.................... #define BS 0x08 // Back Space
.................... void Download()
.................... {
.................... char line[LINELEN]; // Buffer na radku
.................... unsigned char c; // Znak
.................... unsigned int8 a; // Ukazovatko do bufferu
.................... unsigned int8 len; // Delka retezce v radce
.................... unsigned int8 Oct; // Cislo oktavy u noty
....................
.................... output_low(POWER_386); // Zapni napajeni zesilovace
*
0347: BSF 03.5
0348: BCF 05.4
0349: BCF 03.5
034A: BCF 05.4
.................... SoundNote(SOUND_Space,3,10); // Mezera
034B: MOVLW 0C
034C: MOVWF 69
034D: MOVLW 03
034E: MOVWF 6A
034F: CLRF 6C
0350: MOVLW 0A
0351: MOVWF 6B
0352: CALL 0E2
.................... Beep=SoundPGM;
0353: MOVLW 03
0354: MOVWF 33
.................... Error=0;
0355: BCF 2D.1
.................... SpecBeep(); // Pipni na znameni vstupu do programovani
0356: CALL 13A
....................
.................... Tempo=100; // Default hodnoty
0357: CLRF 2F
0358: MOVLW 64
0359: MOVWF 2E
.................... Pause=100;
035A: CLRF 31
035B: MOVWF 30
.................... Octava=0;
035C: CLRF 32
.................... Mode=0; // Mod hrani
035D: BCF 2D.0
.................... Oct=0;
035E: CLRF 60
.................... a=0; // Na zacatku je radka prazdna
035F: CLRF 5E
....................
.................... for(;input(POWER_PIC)==0;) // Opakuj vse dokud je PGM rezim
0360: BSF 03.5
0361: BSF 05.3
0362: MOVLW 00
0363: BCF 03.5
0364: BTFSC 05.3
0365: MOVLW 01
0366: XORLW 00
0367: BTFSS 03.2
0368: GOTO 58F
.................... {
.................... Loop:
.................... c=Getc(); // Vezmi znak ze seriovky
0369: CALL 152
036A: MOVF 78,W
036B: MOVWF 5D
.................... if (c>=0x80) goto Loop; // Ignoruj znaky nad ASCII
036C: MOVF 5D,W
036D: SUBLW 7F
036E: BTFSC 03.0
036F: GOTO 371
0370: GOTO 369
.................... if (c>=0x60) c=c-0x20; // Preved velka pismena na velka pismena
0371: MOVF 5D,W
0372: SUBLW 5F
0373: BTFSC 03.0
0374: GOTO 377
0375: MOVLW 20
0376: SUBWF 5D,F
.................... if ((c==CR)|(c=='/')) // Konec radky nebo komentar
0377: MOVF 5D,W
0378: SUBLW 0D
0379: BTFSC 03.2
037A: GOTO 37D
037B: MOVLW 00
037C: GOTO 37E
037D: MOVLW 01
037E: MOVWF 61
037F: MOVF 5D,W
0380: SUBLW 2F
0381: BTFSC 03.2
0382: GOTO 385
0383: MOVLW 00
0384: GOTO 386
0385: MOVLW 01
0386: IORWF 61,W
0387: XORLW 00
0388: BTFSC 03.2
0389: GOTO 55B
.................... {
.................... while (c!=CR) c=Getc(); // Zpracuj znaky komentare
038A: MOVF 5D,W
038B: SUBLW 0D
038C: BTFSC 03.2
038D: GOTO 392
038E: CALL 152
038F: MOVF 78,W
0390: MOVWF 5D
0391: GOTO 38A
.................... len=a; // Zapamatuj si delku radky
0392: MOVF 5E,W
0393: MOVWF 5F
.................... a=0; // Postav se na zacatek radky
0394: CLRF 5E
.................... Beep=SoundEndOfLine; // Default zuk na konci radky
0395: MOVLW 01
0396: MOVWF 33
.................... // Zpracovani radky
.................... while(a<len)
0397: MOVF 5F,W
0398: SUBWF 5E,W
0399: BTFSC 03.0
039A: GOTO 558
.................... {
.................... c=Word(line,&a,len);
039B: MOVLW 35
039C: MOVWF 61
039D: MOVLW 5E
039E: MOVWF 62
039F: MOVF 5F,W
03A0: MOVWF 63
*
042D: MOVF 78,W
042E: MOVWF 5D
.................... if (c==-1) // Nezname klicove slovo
042F: MOVF 5D,W
0430: SUBLW FF
0431: BTFSS 03.2
0432: GOTO 466
.................... {
.................... if (a<len) // Nejsme uz na konci radky ??
0433: MOVF 5F,W
0434: SUBWF 5E,W
0435: BTFSC 03.0
0436: GOTO 465
.................... {
.................... if ((line[a]>='0')&(line[a]<='9')) // Stojime na cislici -> je to cislo
0437: MOVLW 35
0438: ADDWF 5E,W
0439: MOVWF 04
043A: MOVF 00,W
043B: SUBLW 2F
043C: BTFSS 03.0
043D: GOTO 440
043E: MOVLW 00
043F: GOTO 441
0440: MOVLW 01
0441: MOVWF 62
0442: MOVLW 35
0443: ADDWF 5E,W
0444: MOVWF 04
0445: MOVF 00,W
0446: SUBLW 39
0447: BTFSC 03.0
0448: GOTO 44B
0449: MOVLW 00
044A: GOTO 44C
044B: MOVLW 01
044C: ANDWF 62,W
044D: XORLW 00
044E: BTFSC 03.2
044F: GOTO 45C
.................... {
.................... // Oct=Number(line,&a,len)&0x7; // tohle nefunguje protoze je chyba v prekladaci
.................... Oct=Number(line,&a,len); // prekladac prepoklada, z W obsahuje spodni bajt vysledku
0450: MOVLW 35
0451: MOVWF 61
0452: MOVLW 5E
0453: MOVWF 62
0454: MOVF 5F,W
0455: MOVWF 63
0456: CALL 18C
0457: MOVF 78,W
0458: MOVWF 60
.................... Oct&=0x7; // ale k navratu pouziva RETLW 0 coz smaze W !
0459: MOVLW 07
045A: ANDWF 60,F
.................... }
.................... else // Stojime na pismenu nebo oddelovaci
045B: GOTO 465
.................... {
.................... if (line[a]!=' ') Error=1; // Neni to oddelovac - chyba
045C: MOVLW 35
045D: ADDWF 5E,W
045E: MOVWF 04
045F: MOVF 00,W
0460: SUBLW 20
0461: BTFSC 03.2
0462: GOTO 464
0463: BSF 2D.1
.................... a++; // Preskocim 1 znak (a kdyz to nepomuze dostanu se zase sem)
0464: INCF 5E,F
.................... }
.................... }
.................... }
.................... else if (c=='P') // Play
0465: GOTO 557
0466: MOVF 5D,W
0467: SUBLW 50
0468: BTFSS 03.2
0469: GOTO 478
.................... {
.................... CisloSkladby=Number(line,&a,len);
046A: MOVLW 35
046B: MOVWF 61
046C: MOVLW 5E
046D: MOVWF 62
046E: MOVF 5F,W
046F: MOVWF 63
0470: CALL 18C
0471: MOVF 78,W
0472: MOVWF 34
.................... Mode=0;
0473: BCF 2D.0
.................... Play();
0474: CALL 279
.................... Beep=SoundPGM;
0475: MOVLW 03
0476: MOVWF 33
.................... }
.................... else if (c=='E') // Erase
0477: GOTO 557
0478: MOVF 5D,W
0479: SUBLW 45
047A: BTFSS 03.2
047B: GOTO 4B6
.................... {
.................... Mode=0;
047C: BCF 2D.0
.................... Erase();
.................... Beep=SoundPGM;
*
04B3: MOVLW 03
04B4: MOVWF 33
.................... }
.................... else if (c=='t') // Tempo
04B5: GOTO 557
04B6: MOVF 5D,W
04B7: SUBLW 74
04B8: BTFSS 03.2
04B9: GOTO 4D6
.................... {
.................... Tempo=Number(line,&a,len)&~MASKTEMPO;
04BA: MOVLW 35
04BB: MOVWF 61
04BC: MOVLW 5E
04BD: MOVWF 62
04BE: MOVF 5F,W
04BF: MOVWF 63
04C0: CALL 18C
04C1: MOVF 78,W
04C2: MOVWF 2E
04C3: MOVF 79,W
04C4: ANDLW C7
04C5: MOVWF 2F
.................... if (Tempo==0) Tempo=100;
04C6: MOVF 2E,F
04C7: BTFSS 03.2
04C8: GOTO 4CF
04C9: MOVF 2F,F
04CA: BTFSS 03.2
04CB: GOTO 4CF
04CC: CLRF 2F
04CD: MOVLW 64
04CE: MOVWF 2E
.................... Data=Tempo|DATATEMPO;
04CF: MOVF 2E,W
04D0: MOVWF 2B
04D1: MOVF 2F,W
04D2: IORLW 28
04D3: MOVWF 2C
.................... WriteDataInc(); // Podmineny zapis do FLASH a posun na dalsi adresu
04D4: CALL 2DC
.................... }
.................... else if (c=='p') // Pause
04D5: GOTO 557
04D6: MOVF 5D,W
04D7: SUBLW 70
04D8: BTFSS 03.2
04D9: GOTO 4F6
.................... {
.................... Pause=Number(line,&a,len)&~MASKPAUSE;
04DA: MOVLW 35
04DB: MOVWF 61
04DC: MOVLW 5E
04DD: MOVWF 62
04DE: MOVF 5F,W
04DF: MOVWF 63
04E0: CALL 18C
04E1: MOVF 78,W
04E2: MOVWF 30
04E3: MOVF 79,W
04E4: ANDLW C7
04E5: MOVWF 31
.................... if (Pause==0) Pause=100;
04E6: MOVF 30,F
04E7: BTFSS 03.2
04E8: GOTO 4EF
04E9: MOVF 31,F
04EA: BTFSS 03.2
04EB: GOTO 4EF
04EC: CLRF 31
04ED: MOVLW 64
04EE: MOVWF 30
.................... Data=Pause|DATAPAUSE;
04EF: MOVF 30,W
04F0: MOVWF 2B
04F1: MOVF 31,W
04F2: IORLW 30
04F3: MOVWF 2C
.................... WriteDataInc(); // Podmineny zapis do FLASH a posun na dalsi adresu
04F4: CALL 2DC
.................... }
.................... else if (c=='B') // Begin
04F5: GOTO 557
04F6: MOVF 5D,W
04F7: SUBLW 42
04F8: BTFSS 03.2
04F9: GOTO 50D
.................... {
.................... CisloSkladby=~0; // Neplatne cislo skladby
04FA: MOVLW FF
04FB: MOVWF 34
.................... Find(); // najde konec posledni skladby
04FC: CALL 204
.................... Octava=Number(line,&a,len)&~MASKBEGIN;
04FD: MOVLW 35
04FE: MOVWF 61
04FF: MOVLW 5E
0500: MOVWF 62
0501: MOVF 5F,W
0502: MOVWF 63
0503: CALL 18C
0504: MOVF 78,W
0505: MOVWF 32
.................... Data=DATABEGIN|Octava; // Zacatecni znacka
0506: MOVF 32,W
0507: MOVWF 2B
0508: MOVLW 20
0509: MOVWF 2C
.................... Mode=1; // Mod zapisu do FLASH pameti
050A: BSF 2D.0
.................... WriteDataInc(); // Podmineny zapis do FLASH a posun na dalsi adresu
050B: CALL 2DC
.................... }
.................... else if (c=='b') // Test
050C: GOTO 557
050D: MOVF 5D,W
050E: SUBLW 62
050F: BTFSS 03.2
0510: GOTO 51C
.................... {
.................... Octava=Number(line,&a,len)&~MASKBEGIN;
0511: MOVLW 35
0512: MOVWF 61
0513: MOVLW 5E
0514: MOVWF 62
0515: MOVF 5F,W
0516: MOVWF 63
0517: CALL 18C
0518: MOVF 78,W
0519: MOVWF 32
.................... Mode=0;
051A: BCF 2D.0
.................... }
.................... else if (c=='Z') // End
051B: GOTO 557
051C: MOVF 5D,W
051D: SUBLW 5A
051E: BTFSS 03.2
051F: GOTO 522
.................... {
.................... Mode=0;
0520: BCF 2D.0
.................... }
.................... else // Nota
0521: GOTO 557
.................... {
.................... Data=Number(line,&a,len); // Delka noty (nepovinna)
0522: MOVLW 35
0523: MOVWF 61
0524: MOVLW 5E
0525: MOVWF 62
0526: MOVF 5F,W
0527: MOVWF 63
0528: CALL 18C
0529: MOVF 79,W
052A: MOVWF 2C
052B: MOVF 78,W
052C: MOVWF 2B
.................... Data&=0x3F; // Jen platny rozsah
052D: MOVLW 3F
052E: ANDWF 2B,F
052F: MOVLW 00
0530: ANDWF 2C,F
.................... if (Data==0) Data++; // Je-li nulova delka - dej jednotkovou
0531: MOVF 2B,F
0532: BTFSS 03.2
0533: GOTO 53A
0534: MOVF 2C,F
0535: BTFSS 03.2
0536: GOTO 53A
0537: INCF 2B,F
0538: BTFSC 03.2
0539: INCF 2C,F
.................... Data<<=7; // Delka
053A: RLF 2B,F
053B: RLF 2C,F
053C: RLF 2B,F
053D: RLF 2C,F
053E: RLF 2B,F
053F: RLF 2C,F
0540: RLF 2B,F
0541: RLF 2C,F
0542: RLF 2B,F
0543: RLF 2C,F
0544: RLF 2B,F
0545: RLF 2C,F
0546: RLF 2B,F
0547: RLF 2C,F
0548: MOVLW 80
0549: ANDWF 2B,F
.................... Data|=c; // Nota
054A: MOVF 5D,W
054B: IORWF 2B,F
.................... Data|=(Oct<<4); // Oktava
054C: SWAPF 60,W
054D: MOVWF 77
054E: MOVLW F0
054F: ANDWF 77,F
0550: MOVF 77,W
0551: IORWF 2B,F
.................... WriteDataInc(); // Podmineny zapis do FLASH a posun na dalsi adresu
0552: CALL 2DC
.................... if (~Mode)
0553: BTFSC 2D.0
0554: GOTO 557
.................... {
.................... PlayData(); // Zahraj notu
0555: CALL 233
.................... Beep=0; // Po zahrani noty uz nepipej na konci radky
0556: CLRF 33
.................... }
.................... }
.................... }
0557: GOTO 397
.................... a=0; // Radka zpracovana, nuluj jeji delku
0558: CLRF 5E
.................... SpecBeep(); // Pipni
0559: CALL 13A
.................... goto Loop;
055A: GOTO 369
.................... }
.................... if ((c==BS)&(a>0)) {a--;goto Loop;} // Smaz znak
055B: MOVF 5D,W
055C: SUBLW 08
055D: BTFSC 03.2
055E: GOTO 561
055F: MOVLW 00
0560: GOTO 562
0561: MOVLW 01
0562: MOVWF 61
0563: MOVF 5E,F
0564: BTFSS 03.2
0565: GOTO 568
0566: MOVLW 00
0567: GOTO 569
0568: MOVLW 01
0569: ANDWF 61,W
056A: XORLW 00
056B: BTFSC 03.2
056C: GOTO 56F
056D: DECF 5E,F
056E: GOTO 369
.................... if ((c==',')|(c<=' ')) c=' '; // Vsechny ostatni ridici znaky i carka jsou oddelovac
056F: MOVF 5D,W
0570: SUBLW 2C
0571: BTFSC 03.2
0572: GOTO 575
0573: MOVLW 00
0574: GOTO 576
0575: MOVLW 01
0576: MOVWF 61
0577: MOVF 5D,W
0578: SUBLW 20
0579: BTFSC 03.0
057A: GOTO 57D
057B: MOVLW 00
057C: GOTO 57E
057D: MOVLW 01
057E: IORWF 61,W
057F: XORLW 00
0580: BTFSC 03.2
0581: GOTO 584
0582: MOVLW 20
0583: MOVWF 5D
.................... if (a<LINELEN) line[a++]=c; // Zapis znak do bufferu a posun ukazovatko
0584: MOVF 5E,W
0585: SUBLW 27
0586: BTFSS 03.0
0587: GOTO 58E
0588: MOVF 5E,W
0589: INCF 5E,F
058A: ADDLW 35
058B: MOVWF 04
058C: MOVF 5D,W
058D: MOVWF 00
.................... }
058E: GOTO 360
058F: GOTO 5BE (RETURN)
.................... }
....................
....................
.................... // Tabulka pro prekodovani tlacitek
.................... const int8 KeyTranslate[16] = {0, 1, 2, 5, 3, 6, 8, 11, 4, 7, 9, 12, 10, 13, 14, 15};
*
00B7: BCF 0A.0
00B8: BCF 0A.1
00B9: BCF 0A.2
00BA: ADDWF 02,F
00BB: RETLW 00
00BC: RETLW 01
00BD: RETLW 02
00BE: RETLW 05
00BF: RETLW 03
00C0: RETLW 06
00C1: RETLW 08
00C2: RETLW 0B
00C3: RETLW 04
00C4: RETLW 07
00C5: RETLW 09
00C6: RETLW 0C
00C7: RETLW 0A
00C8: RETLW 0D
00C9: RETLW 0E
00CA: RETLW 0F
....................
.................... void main()
.................... {
*
0590: CLRF 04
0591: MOVLW 1F
0592: ANDWF 03,F
0593: MOVLW 07
0594: BSF 03.5
0595: MOVWF 1F
0596: BCF 05.0
0597: BCF 03.5
0598: BCF 05.0
.................... Start:
....................
.................... // Inicializace
.................... port_b_pullups(TRUE); // Zapni pull-up odpory na portu B
0599: BSF 03.5
059A: BCF 01.7
.................... set_tris_a(0b00001000); // Nastav nepouzite vyvody jako vystupy
059B: MOVLW 08
059C: MOVWF 05
.................... set_tris_b(0b11110000); // 1 znamena vstup
059D: MOVLW F0
059E: MOVWF 06
.................... *0x9F = 6; // Vsechny vstupy jsou digitalni
059F: MOVLW 06
05A0: MOVWF 1F
....................
.................... // Test na rezim programovani
.................... if ((input(POWER_PIC)==0)&(input(RXD)==0)) // Podminka programovani
05A1: BSF 05.3
05A2: MOVLW 00
05A3: BCF 03.5
05A4: BTFSC 05.3
05A5: MOVLW 01
05A6: XORLW 00
05A7: BTFSC 03.2
05A8: GOTO 5AB
05A9: MOVLW 00
05AA: GOTO 5AC
05AB: MOVLW 01
05AC: MOVWF 36
05AD: BSF 03.5
05AE: BSF 06.1
05AF: MOVLW 00
05B0: BCF 03.5
05B1: BTFSC 06.1
05B2: MOVLW 01
05B3: XORLW 00
05B4: BTFSC 03.2
05B5: GOTO 5B8
05B6: MOVLW 00
05B7: GOTO 5B9
05B8: MOVLW 01
05B9: ANDWF 36,W
05BA: XORLW 00
05BB: BTFSC 03.2
05BC: GOTO 5BE
.................... Download(); // Pripojen RS232 a propojka na PGM
05BD: GOTO 347
....................
.................... // Zapnuti napajeni
.................... output_low(POWER_PIC); // Pripoj GND pro procesor
05BE: BSF 03.5
05BF: BCF 05.3
05C0: BCF 03.5
05C1: BCF 05.3
.................... SoundNote(SOUND_Space,3,10); // Mezera
05C2: MOVLW 0C
05C3: MOVWF 69
05C4: MOVLW 03
05C5: MOVWF 6A
05C6: CLRF 6C
05C7: MOVLW 0A
05C8: MOVWF 6B
05C9: CALL 0E2
.................... output_low(POWER_386); // Zapni napajeni zesilovace
05CA: BSF 03.5
05CB: BCF 05.4
05CC: BCF 03.5
05CD: BCF 05.4
.................... SoundNote(SOUND_Space,3,100); // Mezera (jinak se chybne detekuje tlacitko)
05CE: MOVLW 0C
05CF: MOVWF 69
05D0: MOVLW 03
05D1: MOVWF 6A
05D2: CLRF 6C
05D3: MOVLW 64
05D4: MOVWF 6B
05D5: CALL 0E2
....................
.................... // Cteni tlacitek
.................... #use FAST_IO(B)
.................... CisloSkladby=(input_b() >> 4) ^ 0xFF & 0xF; // Precti stav tlacitek
05D6: SWAPF 06,W
05D7: MOVWF 77
05D8: MOVLW 0F
05D9: ANDWF 77,F
05DA: MOVF 77,W
05DB: XORLW 0F
05DC: MOVWF 34
.................... #use STANDARD_IO(B)
.................... CisloSkladby=KeyTranslate[CisloSkladby]; // Prekoduj je do binarniho kodu
05DD: MOVF 34,W
05DE: CALL 0B7
05DF: MOVWF 78
05E0: MOVWF 34
....................
.................... // Prehrani skladby
.................... Play(); // Zahraj skladbu
05E1: CALL 279
....................
.................... // Po odehrani usni a cekej na zmacknuti tlacitka
.................... #use FAST_IO(B)
.................... if (input_B()); // Precti stav portu B (vuci tomuto stavu se bude hlidat zmena)
05E2: MOVF 06,W
05E3: XORLW 00
05E4: BTFSC 03.2
05E5: GOTO 5E6
.................... #use STANDARD_IO(B)
.................... bit_clear(*0xB,0); // Nuluj priznak preruseni od zmeny stavu portu B
05E6: BCF 0B.0
.................... enable_interrupts(INT_RB); // Povol preruseni od zmeny stavu portu B
05E7: BSF 0B.3
....................
.................... output_high(POWER_386); // Vypni napajeni zesilovace
05E8: BSF 03.5
05E9: BCF 05.4
05EA: BCF 03.5
05EB: BSF 05.4
.................... output_float(POWER_PIC); // Odpoj GND
05EC: BSF 03.5
05ED: BSF 05.3
.................... Sleep(); // Usni aby byla minimalni klidova spotreba
05EE: SLEEP
....................
.................... disable_interrupts(INT_RB); // Zakaz preruseni od portu
05EF: BCF 03.5
05F0: BCF 0B.3
.................... goto Start; // Po probuzeni skoc na zacatek
05F1: GOTO 599
.................... }
....................
05F2: SLEEP