1               		.file	"yack.c"
   2               	__SREG__ = 0x3f
   3               	__SP_H__ = 0x3e
   4               	__SP_L__ = 0x3d
   5               	__CCP__  = 0x34
   6               	__tmp_reg__ = 0
   7               	__zero_reg__ = 1
   9               		.text
  10               	.Ltext0:
  96               	.global	__vector_2
  98               	__vector_2:
   1:yack.c        **** /*!
   2:yack.c        ****  
   3:yack.c        ****  @file      yack.c
   4:yack.c        ****  @brief     CW Keyer library
   5:yack.c        ****  @author    Jan Lategahn DK3LJ jan@lategahn.com (C) 2011; modified by Jack Welch AI4SV; modified by
   6:yack.c        ****  
   7:yack.c        ****  @version   0.87
   8:yack.c        ****  
   9:yack.c        ****  This program is free software: you can redistribute it and/or modify
  10:yack.c        ****  it under the terms of the GNU General Public License as published by
  11:yack.c        ****  the Free Software Foundation, either version 3 of the License, or
  12:yack.c        ****  (at your option) any later version.
  13:yack.c        ****  
  14:yack.c        ****  This program is distributed in the hope that it will be useful,
  15:yack.c        ****  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16:yack.c        ****  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17:yack.c        ****  GNU General Public License for more details.
  18:yack.c        ****  
  19:yack.c        ****  You should have received a copy of the GNU General Public License
  20:yack.c        ****  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21:yack.c        ****  
  22:yack.c        ****  @date      15.10.2010  - Created
  23:yack.c        ****  @date      03.10.2013  - Last update
  24:yack.c        ****  @date      21.12.2016  - Added additional prosigns and punctuation. Added 2 additional memories fo
  25:yack.c        ****  @date      03.01.2017  - If memory recording is interrupted by command button, keyer now returns t
  26:yack.c        ****                           Memory playback halts immediately on command key instead of looping throu
  27:yack.c        **** 						  Removed playback of recorded message before saving.
  28:yack.c        **** 						  Changed yackstring command to return to command mode instead of normal mode if interrupted 
  29:yack.c        ****  
  30:yack.c        ****  @todo      Make the delay dependent on T/C 1 
  31:yack.c        **** 
  32:yack.c        **** */ 
  33:yack.c        **** 
  34:yack.c        **** 
  35:yack.c        **** #include <avr/io.h> 
  36:yack.c        **** #include <avr/pgmspace.h>
  37:yack.c        **** #include <avr/eeprom.h>
  38:yack.c        **** #include <avr/interrupt.h>
  39:yack.c        **** #include <avr/sleep.h>
  40:yack.c        **** #include <util/delay.h>
  41:yack.c        **** #include <stdint.h>
  42:yack.c        **** #include "yack.h"
  43:yack.c        **** 
  44:yack.c        **** // Forward declaration of private functions
  45:yack.c        **** static      void key( byte mode); 
  46:yack.c        **** static      char morsechar(byte buffer);
  47:yack.c        **** static      void keylatch(void);
  48:yack.c        **** 
  49:yack.c        **** // Enumerations
  50:yack.c        **** 
  51:yack.c        **** enum FSMSTATE { 
  52:yack.c        ****                 IDLE,   //!< Not keyed, waiting for paddle
  53:yack.c        ****                 KEYED,  //!< Keyed, waiting for duration of current element
  54:yack.c        ****                 IEG     //!< In Inter-Element-Gap 
  55:yack.c        ****               };   
  56:yack.c        **** 
  57:yack.c        **** // Module local definitions
  58:yack.c        **** 
  59:yack.c        **** static		byte	yackflags;		// Permanent (stored) status of module flags
  60:yack.c        **** static		byte	volflags=0;		// Temporary working flags (volatile)
  61:yack.c        **** static 		word	ctcvalue;		// Pitch
  62:yack.c        **** static		word	wpmcnt;			// Speed
  63:yack.c        **** static      byte    wpm;            // Real wpm
  64:yack.c        **** static      byte    farnsworth;     // Additional Farnsworth pause
  65:yack.c        **** 
  66:yack.c        **** // EEPROM Data
  67:yack.c        **** 
  68:yack.c        **** byte		magic EEMEM = MAGPAT;	// Needs to contain 'A5' if mem is valid
  69:yack.c        **** byte		flagstor EEMEM = ( IAMBICB | TXKEY | SIDETONE);	//	Defaults	
  70:yack.c        **** word		ctcstor EEMEM = DEFCTC;	// Pitch = 800Hz
  71:yack.c        **** byte		wpmstor EEMEM = DEFWPM;	// 15 WPM
  72:yack.c        **** byte        fwstor  EEMEM = 0; // No farnsworth pause
  73:yack.c        **** word		user1 EEMEM = 0; // User storage
  74:yack.c        **** word		user2 EEMEM = 0; // User storage
  75:yack.c        **** 
  76:yack.c        **** //char		eebuffer1[100] EEMEM = "message 1";
  77:yack.c        **** //char		eebuffer2[100] EEMEM = "message 2";
  78:yack.c        **** char		eebuffer1[100] EEMEM = "message 1"; 
  79:yack.c        **** char		eebuffer2[100] EEMEM = "message 2"; 
  80:yack.c        **** char		eebuffer3[100] EEMEM = "message 3";
  81:yack.c        **** char		eebuffer4[100] EEMEM = "message 4"; 
  82:yack.c        **** 
  83:yack.c        **** // Flash data
  84:yack.c        **** 
  85:yack.c        **** //! Morse code table in Flash
  86:yack.c        **** 
  87:yack.c        **** //! Encoding: Each byte is read from the left. 0 stands for a dot, 1
  88:yack.c        **** //! stands for a dash. After each played element the content is shifted
  89:yack.c        **** //! left. Playback stops when the leftmost bit contains a "1" and the rest
  90:yack.c        **** //! of the bits are all zero.
  91:yack.c        **** //!
  92:yack.c        **** //! Example: A = .-
  93:yack.c        **** //! Encoding: 01100000
  94:yack.c        **** //!           .-
  95:yack.c        **** //!             | This is the stop marker (1 with all trailing zeros)
  96:yack.c        **** 
  97:yack.c        **** const byte morse[] PROGMEM = 
  98:yack.c        **** {
  99:yack.c        **** 	
 100:yack.c        **** 	0b11111100, // 0
 101:yack.c        **** 	0b01111100, // 1
 102:yack.c        **** 	0b00111100, // 2
 103:yack.c        **** 	0b00011100, // 3
 104:yack.c        **** 	0b00001100, // 4
 105:yack.c        **** 	0b00000100, // 5
 106:yack.c        **** 	0b10000100, // 6
 107:yack.c        **** 	0b11000100, // 7
 108:yack.c        **** 	0b11100100, // 8
 109:yack.c        **** 	0b11110100, // 9
 110:yack.c        **** 	0b01100000, // A
 111:yack.c        **** 	0b10001000, // B
 112:yack.c        **** 	0b10101000, // C
 113:yack.c        **** 	0b10010000, // D
 114:yack.c        **** 	0b01000000, // E
 115:yack.c        **** 	0b00101000, // F
 116:yack.c        **** 	0b11010000, // G
 117:yack.c        **** 	0b00001000, // H
 118:yack.c        **** 	0b00100000, // I                                
 119:yack.c        **** 	0b01111000, // J
 120:yack.c        **** 	0b10110000, // K
 121:yack.c        **** 	0b01001000, // L
 122:yack.c        **** 	0b11100000, // M
 123:yack.c        **** 	0b10100000, // N
 124:yack.c        **** 	0b11110000, // O
 125:yack.c        **** 	0b01101000, // P
 126:yack.c        **** 	0b11011000, // Q
 127:yack.c        **** 	0b01010000, // R
 128:yack.c        **** 	0b00010000, // S
 129:yack.c        **** 	0b11000000, // T
 130:yack.c        **** 	0b00110000, // U
 131:yack.c        **** 	0b00011000, // V
 132:yack.c        **** 	0b01110000, // W
 133:yack.c        **** 	0b10011000, // X
 134:yack.c        **** 	0b10111000, // Y
 135:yack.c        **** 	0b11001000, // Z
 136:yack.c        **** 	0b00110010, // ?
 137:yack.c        **** 	0b01010110, // .
 138:yack.c        **** 	0b10010100, // /
 139:yack.c        **** 	0b11101000, // ! (American Morse version, commonly used in ham circles)
 140:yack.c        **** 	0b11001110, // ,
 141:yack.c        **** 	0b11100010, // :
 142:yack.c        **** 	0b10101010, // ;
 143:yack.c        **** 	0b01001010, // "
 144:yack.c        **** 	0b00010011, // $
 145:yack.c        **** 	0b01111010, // ' (Apostrophe)
 146:yack.c        **** 	0b10110100, // ( or [ (also prosign KN)
 147:yack.c        ****     0b10110110, // ) or ]
 148:yack.c        **** 	0b10000110, // - (Hyphen or single dash)
 149:yack.c        **** 	0b01101010, // @
 150:yack.c        **** 	0b00110110, // _ (Underline)
 151:yack.c        **** 	0b01010010, // Paragaraph break symbol
 152:yack.c        **** 	0b10001100, // = and BT
 153:yack.c        **** 	0b00010110, // SK
 154:yack.c        **** 	0b01010100, // + and AR
 155:yack.c        **** 	0b10001011, // BK
 156:yack.c        **** 	0b01000100, // AS
 157:yack.c        **** 	0b10101100, // KA (also ! in alternate Continental Morse)
 158:yack.c        **** 	0b00010100, // VE
 159:yack.c        **** 	0b01011000  // AA
 160:yack.c        **** };
 161:yack.c        **** 
 162:yack.c        **** 
 163:yack.c        **** // The special characters at the end of the above table can not be decoded
 164:yack.c        **** // without a small table to define their content. # stands for SK, $ for AR
 165:yack.c        **** 
 166:yack.c        **** // To add new characters, add them in the code table above at the end and below
 167:yack.c        **** // Do not forget to increase the legth of the array..
 168:yack.c        **** 
 169:yack.c        **** const char spechar[24] PROGMEM = "?./!,:;~$^()-@_|=#+*%&<>";
 170:yack.c        **** 
 171:yack.c        **** 
 172:yack.c        **** 
 173:yack.c        **** // Functions
 174:yack.c        **** 
 175:yack.c        **** // ***************************************************************************
 176:yack.c        **** // Control functions
 177:yack.c        **** // ***************************************************************************
 178:yack.c        **** 
 179:yack.c        **** void yackreset (void)
 180:yack.c        **** /*! 
 181:yack.c        ****  @brief     Sets all yack parameters to standard values
 182:yack.c        **** 
 183:yack.c        ****  This function resets all YACK EEPROM settings to their default values as 
 184:yack.c        ****  stored in the .h file. It sets the dirty flag and calls the save routine
 185:yack.c        ****  to write the data into EEPROM immediately.
 186:yack.c        **** */
 187:yack.c        **** {
 188:yack.c        **** 
 189:yack.c        **** 	ctcvalue=DEFCTC; // Initialize to 800 Hz
 190:yack.c        ****     wpm=DEFWPM; // Init to default speed
 191:yack.c        **** 	wpmcnt=(1200/YACKBEAT)/DEFWPM; // default speed
 192:yack.c        ****     farnsworth=0; // No Farnsworth gap
 193:yack.c        **** 	yackflags = FLAGDEFAULT;  
 194:yack.c        **** 
 195:yack.c        **** 	volflags |= DIRTYFLAG;
 196:yack.c        **** 	yacksave(); // Store them in EEPROM
 197:yack.c        **** 
 198:yack.c        **** }
 199:yack.c        **** 
 200:yack.c        **** 
 201:yack.c        **** void yackinit (void)
 202:yack.c        **** /*! 
 203:yack.c        ****  @brief     Initializes the YACK library
 204:yack.c        ****  
 205:yack.c        ****  This function initializes the keyer hardware according to configurations in the .h file.
 206:yack.c        ****  Then it attempts to read saved configuration settings from EEPROM. If not possible, it
 207:yack.c        ****  will reset all values to their defaults.
 208:yack.c        ****  This function must be called once before the remaining fuctions can be used.
 209:yack.c        **** */
 210:yack.c        **** {
 211:yack.c        **** 	
 212:yack.c        **** 	byte magval;
 213:yack.c        **** 	
 214:yack.c        **** 	// Configure DDR. Make OUT and ST output ports
 215:yack.c        **** 	SETBIT (OUTDDR,OUTPIN);    
 216:yack.c        **** 	SETBIT (STDDR,STPIN);
 217:yack.c        **** 	
 218:yack.c        **** 	// Raise internal pullups for all inputs
 219:yack.c        **** 	SETBIT (KEYPORT,DITPIN);  
 220:yack.c        **** 	SETBIT (KEYPORT,DAHPIN);
 221:yack.c        **** 	SETBIT (BTNPORT,BTNPIN);
 222:yack.c        **** 	
 223:yack.c        **** 	magval = eeprom_read_byte(&magic); // Retrieve magic value
 224:yack.c        **** 	
 225:yack.c        **** 	if (magval == MAGPAT) // Is memory valid
 226:yack.c        **** 	{
 227:yack.c        **** 		ctcvalue = eeprom_read_word(&ctcstor); // Retrieve last ctc setting
 228:yack.c        **** 		wpm = eeprom_read_byte(&wpmstor); // Retrieve last wpm setting
 229:yack.c        ****         wpmcnt=(1200/YACKBEAT)/wpm; // Calculate speed
 230:yack.c        **** 		farnsworth = eeprom_read_byte(&fwstor); // Retrieve last wpm setting	
 231:yack.c        **** 		yackflags = eeprom_read_byte(&flagstor); // Retrieve last flags	
 232:yack.c        **** 	}
 233:yack.c        **** 	else
 234:yack.c        **** 	{
 235:yack.c        **** 		yackreset();
 236:yack.c        **** 	}	
 237:yack.c        **** 	
 238:yack.c        **** 	yackinhibit(OFF);
 239:yack.c        **** 
 240:yack.c        **** #ifdef POWERSAVE
 241:yack.c        ****     
 242:yack.c        ****     PCMSK |= PWRWAKE;    // Define which keys wake us up
 243:yack.c        ****     GIMSK |= (1<<PCIE);  // Enable pin change interrupt
 244:yack.c        ****     
 245:yack.c        **** #endif
 246:yack.c        ****     
 247:yack.c        ****     // Initialize timer1 to serve as the system heartbeat
 248:yack.c        ****     // CK runs at 1MHz. Prescaling by 64 makes that 15625 Hz.
 249:yack.c        ****     // Counting 78 cycles of that generates an overflow every 5ms
 250:yack.c        ****     
 251:yack.c        ****     OCR1C = 78; // 77 counts per cycle
 252:yack.c        ****     TCCR1 |= (1<<CTC1) | 0b00000111 ; // Clear Timer on match, prescale ck by 64
 253:yack.c        ****     OCR1A = 1; // CTC mode does not create an overflow so we use OCR1A
 254:yack.c        ****     
 255:yack.c        **** }
 256:yack.c        **** 
 257:yack.c        **** #ifdef POWERSAVE
 258:yack.c        **** 
 259:yack.c        **** ISR(PCINT0_vect)
 260:yack.c        **** /*! 
 261:yack.c        ****  @brief     A dummy pin change interrupt
 262:yack.c        ****  
 263:yack.c        ****  This function is called whenever the system is in sleep mode and there is a level change on one of
 264:yack.c        ****  we are monitoring (dit, dah and the command key). As all handling is already taken care of by poll
 265:yack.c        ****  routines, there is nothing we need to do here.
 266:yack.c        ****  */
 267:yack.c        **** {
  99               		68,0,267,.LM0-.LFBB1
 100               	.LM0:
 101               	.LFBB1:
 102 0000 1F92      		push __zero_reg__
 103 0002 0F92      		push r0
 104 0004 0FB6      		in r0,__SREG__
 105 0006 0F92      		push r0
 106 0008 1124      		clr __zero_reg__
 107               	/* prologue: Signal */
 108               	/* frame size = 0 */
 109               	/* epilogue start */
 268:yack.c        **** led in yackbeat intervals with either a TRUE or FALSE as parameter. Whenever the
 269:yack.c        ****  parameter is TRUE a beat counter is advanced until the timeout level is reached. When timeout
 110               	0,269,.LM1-.LFBB1
 111               	.LM1:
 112 000a 0F90      		pop r0
 113 000c 0FBE      		out __SREG__,r0
 114 000e 0F90      		pop r0
 115 0010 1F90      		pop __zero_reg__
 116 0012 1895      		reti
 118               	.Lscope1:
 121               	.global	yackpower
 123               	yackpower:
 270:yack.c        **** s reached, the chip shuts down and will only wake up again when issued a level change interrupt on
 271:yack.c        ****  either of the input pins.
 272:yack.c        ****  
 273:yack.c        ****  When the parameter is FALSE, the counter is reset.
 274:yack.c        ****  
 275:yack.c        ****  @param n   TRUE: OK to sleep, FALSE: Can not sleep now
 276:yack.c        ****  
 277:yack.c        **** */
 278:yack.c        **** 
 279:yack.c        **** {
 280:yack.c        ****     static uint32_t shdntimer=0;
 281:yack.c        ****     
 282:yack.c        ****     if (n) // True = we could go to sleep
 283:yack.c        ****     {
 284:yack.c        ****         if(shdntimer++ == YACKSECS(PSTIME))
 285:yack.c        ****         {
 286:yack.c        ****             shdntimer=0; // So we do not go to sleep right after waking up..
 287:yack.c        **** 
 124               	87,.LM2-.LFBB2
 125               	.LM2:
 126               	.LFBB2:
 127               	/* prologue: function */
 128               	/* frame size = 0 */
 288:yack.c        **** eep_mode(SLEEP_MODE_PWR_DOWN);
 289:yack.c        ****             sleep_bod_disable();
 290:yack.c        ****             sleep_enable();
 129               	bn	68,0,290,.LM3-.LFBB2
 130               	.LM3:
 131 0014 8823      		tst r24
 132 0016 01F4      		brne .+2
 133 0018 00C0      		rjmp .L4
 291:yack.c        ****          sei();
 292:yack.c        ****             sleep_cpu();
 134               	bn	68,0,292,.LM4-.LFBB2
 135               	.LM4:
 136 001a 8091 0000 		lds r24,shdntimer.1529
 137 001e 9091 0000 		lds r25,(shdntimer.1529)+1
 138 0022 A091 0000 		lds r26,(shdntimer.1529)+2
 139 0026 B091 0000 		lds r27,(shdntimer.1529)+3
 140 002a 0196      		adiw r24,1
 141 002c A11D      		adc r26,__zero_reg__
 142 002e B11D      		adc r27,__zero_reg__
 143 0030 8093 0000 		sts shdntimer.1529,r24
 144 0034 9093 0000 		sts (shdntimer.1529)+1,r25
 145 0038 A093 0000 		sts (shdntimer.1529)+2,r26
 146 003c B093 0000 		sts (shdntimer.1529)+3,r27
 147 0040 0197      		sbiw r24,1
 148 0042 A109      		sbc r26,__zero_reg__
 149 0044 B109      		sbc r27,__zero_reg__
 150 0046 8057      		subi r24,lo8(6000)
 151 0048 9741      		sbci r25,hi8(6000)
 152 004a A040      		sbci r26,hlo8(6000)
 153 004c B040      		sbci r27,hhi8(6000)
 154 004e 01F4      		brne .L6
 293:yack.c        ****           cli();
 294:yack.c        ****             
 155               	-.LFBB2
 156               	.LM5:
 157 0050 1092 0000 		sts shdntimer.1529,__zero_reg__
 158 0054 1092 0000 		sts (shdntimer.1529)+1,__zero_reg__
 159 0058 1092 0000 		sts (shdntimer.1529)+2,__zero_reg__
 160 005c 1092 0000 		sts (shdntimer.1529)+3,__zero_reg__
 295:yack.c        ****           // There is no technical reason to CLI here but it avoids hitting the ISR every time
 296:yack.c        ****             // the paddles are touched. If the remaining code needs the interrupts this is OK to re
 161               	n	68,0,296,.LM6-.LFBB2
 162               	.LM6:
 163 0060 85B7      		in r24,85-32
 164 0062 877E      		andi r24,lo8(-25)
 165 0064 8061      		ori r24,lo8(16)
 166 0066 85BF      		out 85-32,r24
 167               	.LBB28:
 297:yack.c        ****           
 168               		68,0,297,.LM7-.LFBB2
 169               	.LM7:
 170               	/* #APP */
 171               	 ;  297 "yack.c" 1
 172 0068 85B7      		in r24, 53
 173 006a 8468      		ori r24, 132
 174 006c 85BF      		out 53, r24
 175 006e 8B7F      		andi r24, -5
 176 0070 85BF      		out 53, r24
 177               	 ;  0 "" 2
 178               	/* #NOAPP */
 179               	.LBE28:
 298:yack.c        ****        }
 180               	,298,.LM8-.LFBB2
 181               	.LM8:
 182 0072 85B7      		in r24,85-32
 183 0074 8062      		ori r24,lo8(32)
 184 0076 85BF      		out 85-32,r24
 299:yack.c        ****        
 185               	bn	68,0,299,.LM9-.LFBB2
 186               	.LM9:
 187               	/* #APP */
 188               	 ;  299 "yack.c" 1
 189 0078 7894      		sei
 190               	 ;  0 "" 2
 300:yack.c        ****    }
 191               	n	68,0,300,.LM10-.LFBB2
 192               	.LM10:
 193               	 ;  300 "yack.c" 1
 194 007a 8895      		sleep
 195               		
 196               	 ;  0 "" 2
 301:yack.c        ****    else // Passed parameter is FALSE
 197               	n	68,0,301,.LM11-.LFBB2
 198               	.LM11:
 199               	 ;  301 "yack.c" 1
 200 007c F894      		cli
 201               	 ;  0 "" 2
 202               	/* #NOAPP */
 203 007e 0895      		ret
 204               	.L4:
 302:yack.c        ****    {
 303:yack.c        ****         shdntimer=0;
 304:yack.c        ****     }
 305:yack.c        **** 
 306:yack.c        **** }
 307:yack.c        **** 
 308:yack.c        **** #endif
 309:yack.c        **** 
 310:yack.c        **** 
 311:yack.c        **** 
 205               	68,0,311,.LM12-.LFBB2
 206               	.LM12:
 207 0080 1092 0000 		sts shdntimer.1529,__zero_reg__
 208 0084 1092 0000 		sts (shdntimer.1529)+1,__zero_reg__
 209 0088 1092 0000 		sts (shdntimer.1529)+2,__zero_reg__
 210 008c 1092 0000 		sts (shdntimer.1529)+3,__zero_reg__
 211               	.L6:
 212 0090 0895      		ret
 220               	.Lscope2:
 222               	.global	yackwpm
 224               	yackwpm:
 312:yack.c        **** ave (void)
 313:yack.c        **** /*! 
 314:yack.c        ****  @brief     Saves all permanent settings to EEPROM
 315:yack.c        ****  
 316:yack.c        ****  To save EEPROM write cycles, writing only happens when the flag DIRTYFLAG is set.
 317:yack.c        ****  After writing the flag is cleared
 318:yack.c        ****  
 319:yack.c        ****  @callergraph
 320:yack.c        ****  
 321:yack.c        ****  */
 322:yack.c        **** {
 323:yack.c        **** 	
 324:yack.c        **** 	if(volflags & DIRTYFLAG) // Dirty flag set?
 325:yack.c        **** 	{	
 326:yack.c        **** 		
 327:yack.c        **** 		eeprom_write_byte(&magic, MAGPAT);
 328:yack.c        **** 		eeprom_write_word(&ctcstor, ctcvalue);
 329:yack.c        **** 		eeprom_write_byte(&wpmstor, wpm);
 330:yack.c        **** 		eeprom_write_byte(&flagstor, yackflags);
 331:yack.c        ****         eeprom_write_byte(&fwstor, farnsworth);
 332:yack.c        **** 		
 333:yack.c        **** 		volflags &= ~DIRTYFLAG; // Clear the dirty flag
 334:yack.c        **** 	}
 335:yack.c        **** 	
 336:yack.c        **** }
 337:yack.c        **** 
 338:yack.c        **** 
 339:yack.c        **** 
 340:yack.c        **** void yackinhibit (byte mode)
 341:yack.c        **** /*! 
 342:yack.c        ****  @brief     Inhibits keying during command phases
 343:yack.c        ****  
 344:yack.c        ****  This function is used to inhibit and re-enable TX keying (if configured) and enforce the internal 
 345:yack.c        ****  sidetone oscillator to be active so that the user can communicate with the keyer.
 346:yack.c        ****  
 347:yack.c        ****  @param mode   ON inhibits keying, OFF re-enables keying 
 348:yack.c        ****  
 349:yack.c        ****  */
 350:yack.c        **** {
 351:yack.c        **** 	
 352:yack.c        **** 	if (mode)
 353:yack.c        **** 	{
 354:yack.c        **** 		volflags &= ~(TXKEY | SIDETONE);
 355:yack.c        **** 		volflags |= SIDETONE;
 356:yack.c        **** 	}
 357:yack.c        **** 	
 358:yack.c        **** 	else
 359:yack.c        **** 		
 360:yack.c        **** 	{
 361:yack.c        **** 		volflags &= ~(TXKEY | SIDETONE);
 362:yack.c        **** 		volflags |= (yackflags & (TXKEY | SIDETONE));
 363:yack.c        ****         key(UP);
 364:yack.c        **** 	}
 365:yack.c        **** 	
 366:yack.c        **** }
 367:yack.c        **** 
 368:yack.c        **** 
 369:yack.c        **** 
 370:yack.c        **** word yackuser (byte func, byte nr, word content)
 371:yack.c        **** /*! 
 372:yack.c        ****  @brief     Saves user defined settings
 373:yack.c        ****  
 374:yack.c        ****  The routine using this library is given the opportunity to save up to two 16 bit sized
 375:yack.c        ****  values in EEPROM. In case of the sample main function this is used to store the beacon interval 
 376:yack.c        ****  timer value. The routine is not otherwise used by the library.
 377:yack.c        ****  
 378:yack.c        ****  @param func    States if the data is retrieved (READ) or written (WRITE) to EEPROM
 379:yack.c        ****  @param nr      1 or 2 (Number of user storage to access)
 380:yack.c        ****  @param content The 16 bit word to write. Not used in read mode.
 381:yack.c        ****  @return        The content of the retrieved value in read mode.
 382:yack.c        ****  
 383:yack.c        ****  */
 384:yack.c        **** {
 385:yack.c        **** 	
 386:yack.c        ****     
 387:yack.c        **** 	if (func == READ)
 388:yack.c        **** 	{
 389:yack.c        **** 		if (nr == 1) 
 390:yack.c        **** 			return (eeprom_read_word(&user1));
 391:yack.c        **** 		else if (nr == 2)
 392:yack.c        **** 			return (eeprom_read_word(&user2));
 393:yack.c        **** 	}
 394:yack.c        **** 	
 395:yack.c        **** 	if (func == WRITE)
 396:yack.c        **** 	{
 397:yack.c        ****         
 398:yack.c        **** 		if (nr == 1)
 399:yack.c        **** 			eeprom_write_word(&user1, content);
 400:yack.c        **** 		else if (nr == 2)
 401:yack.c        **** 			eeprom_write_word(&user2, content);
 402:yack.c        **** 	}
 403:yack.c        **** 
 404:yack.c        ****     return (FALSE);
 405:yack.c        ****     
 406:yack.c        **** }
 407:yack.c        **** 
 408:yack.c        **** 
 409:yack.c        **** 
 410:yack.c        **** word yackwpm(void)
 411:yack.c        **** /*! 
 412:yack.c        ****  @brief     Retrieves the current WPM speed
 413:yack.c        ****  
 414:yack.c        ****  This function delivers the current WPM speed. 
 415:yack.c        **** 
 416:yack.c        ****  @return        Current speed in WPM
 417:yack.c        ****  
 418:yack.c        ****  */
 419:yack.c        **** {
 420:yack.c        ****     
 421:yack.c        ****     return wpm; 
 422:yack.c        ****     
 423:yack.c        **** }
 424:yack.c        **** 
 425:yack.c        **** 
 426:yack.c        **** void yackspeed (byte dir, byte mode)
 427:yack.c        **** /*! 
 225               	13-.LFBB3
 226               	.LM13:
 227               	.LFBB3:
 228               	/* prologue: function */
 229               	/* frame size = 0 */
 428:yack.c        **** nt. Those are close to real
 429:yack.c        ****  WPM in a 10ms heartbeat but can significantly differ at higher heartbeat speeds.
 430:yack.c        ****  
 431:yack.c        ****  @param dir     UP (faster) or DOWN (slower)
 230               	bn	68,0,431,.LM14-.LFBB3
 231               	.LM14:
 232 0092 8091 0000 		lds r24,wpm
 233 0096 90E0      		ldi r25,lo8(0)
 234               	/* epilogue start */
 235 0098 0895      		ret
 237               	.Lscope3:
 239               	.global	yackbeat
 241               	yackbeat:
 432:yack.c        **** /
 433:yack.c        **** {
 434:yack.c        ****     
 435:yack.c        ****     if (mode == FARNSWORTH)
 436:yack.c        ****     {
 437:yack.c        ****         if ((dir == UP) && (farnsworth > 0))
 438:yack.c        ****             farnsworth--;
 439:yack.c        ****         
 440:yack.c        ****         if ((dir == DOWN) && (farnsworth < MAXFARN))
 441:yack.c        ****             farnsworth++;
 442:yack.c        ****     }
 443:yack.c        ****     else // WPMSPEED
 444:yack.c        ****     {
 445:yack.c        ****         if ((dir == UP) && (wpm < MAXWPM))
 446:yack.c        ****             wpm++;
 447:yack.c        ****         
 448:yack.c        ****         if ((dir == DOWN) && (wpm > MINWPM))
 449:yack.c        ****             wpm--;
 450:yack.c        ****         
 451:yack.c        ****         wpmcnt=(1200/YACKBEAT)/wpm; // Calculate beats
 452:yack.c        **** 
 453:yack.c        **** 	}
 454:yack.c        **** 	
 455:yack.c        **** 	volflags |= DIRTYFLAG; // Set the dirty flag	
 456:yack.c        ****     
 457:yack.c        ****     yackplay(DIT);
 458:yack.c        ****     yackdelay(IEGLEN);	// Inter Element gap  
 459:yack.c        ****     yackplay(DAH);
 460:yack.c        ****     yackdelay(ICGLEN);	// Inter Character gap  
 461:yack.c        ****     yackfarns(); // Additional Farnsworth delay
 462:yack.c        ****     
 463:yack.c        **** }
 464:yack.c        **** 
 465:yack.c        **** 
 466:yack.c        **** 
 467:yack.c        **** void yackbeat (void)
 468:yack.c        **** /*! 
 469:yack.c        ****  @brief     Heartbeat delay
 470:yack.c        ****  
 471:yack.c        ****  Several functions in the keyer are timing dependent. The most prominent example is the
 472:yack.c        ****  yackiambic function that implements the IAMBIC keyer finite state machine.
 473:yack.c        ****  The same expects to be called in intervals of YACKBEAT milliseconds. How this is 
 474:yack.c        ****  implemented is left to the user. In a more complex application this would be done
 475:yack.c        ****  using an interrupt or a timer. For simpler cases this is a busy wait routine
 476:yack.c        ****  that delays exactly YACKBEAT ms.
 477:yack.c        ****  
 478:yack.c        ****  */
 479:yack.c        **** {
 480:yack.c        ****     while((TIFR & (1<<OCF1A)) == 0); // Wait for Timeout
 481:yack.c        ****     TIFR |= (1<<OCF1A);                // Reset output compare flag
 482:yack.c        **** }
 483:yack.c        **** 
 484:yack.c        **** 
 485:yack.c        **** 
 486:yack.c        **** void yackpitch (byte dir)
 487:yack.c        **** /*! 
 488:yack.c        ****  @brief     Increases or decreases the sidetone pitch
 489:yack.c        ****  
 490:yack.c        ****  Changes are done not in Hz but in ctc control values. This is to avoid extensive 
 242               	,490,.LM15-.LFBB4
 243               	.LM15:
 244               	.LFBB4:
 245               	/* prologue: function */
 246               	/* frame size = 0 */
 247               	.L10:
 491:yack.c        **** y the preprocessor.
 248               	n	68,0,491,.LM16-.LFBB4
 249               	.LM16:
 250 009a 08B6      		in __tmp_reg__,88-32
 251 009c 06FE      		sbrs __tmp_reg__,6
 252 009e 00C0      		rjmp .L10
 492:yack.c        **** 
 253               	bn	68,0,492,.LM17-.LFBB4
 254               	.LM17:
 255 00a0 88B7      		in r24,88-32
 256 00a2 8064      		ori r24,lo8(64)
 257 00a4 88BF      		out 88-32,r24
 258               	/* epilogue start */
 493:yack.c        ****  @param dir     UP or DOWN
 259               	n	68,0,493,.LM18-.LFBB4
 260               	.LM18:
 261 00a6 0895      		ret
 263               	.Lscope4:
 266               	.global	yackpitch
 268               	yackpitch:
 494:yack.c        **** 
 495:yack.c        ****  */
 496:yack.c        **** {
 497:yack.c        **** 	if (dir == UP)
 498:yack.c        **** 		ctcvalue--;
 499:yack.c        **** 	if (dir == DOWN)
 500:yack.c        **** 		ctcvalue++;
 501:yack.c        **** 	
 502:yack.c        **** 	if (ctcvalue < MAXCTC)
 503:yack.c        **** 		ctcvalue = MAXCTC;
 504:yack.c        **** 	
 505:yack.c        **** 	if (ctcvalue > MINCTC)
 506:yack.c        **** 		ctcvalue = MINCTC;
 507:yack.c        **** 	
 269               	,0,507,.LM19-.LFBB5
 270               	.LM19:
 271               	.LFBB5:
 272               	/* prologue: function */
 273               	/* frame size = 0 */
 508:yack.c        **** DIRTYFLAG; // Set the dirty flag	
 274               	bn	68,0,508,.LM20-.LFBB5
 275               	.LM20:
 276 00a8 8130      		cpi r24,lo8(1)
 277 00aa 01F4      		brne .L14
 509:yack.c        **** 
 278               	abn	68,0,509,.LM21-.LFBB5
 279               	.LM21:
 280 00ac 8091 0000 		lds r24,ctcvalue
 281 00b0 9091 0000 		lds r25,(ctcvalue)+1
 282 00b4 0197      		sbiw r24,1
 283 00b6 00C0      		rjmp .L19
 284               	.L14:
 510:yack.c        **** }
 285               		68,0,510,.LM22-.LFBB5
 286               	.LM22:
 287 00b8 8230      		cpi r24,lo8(2)
 288 00ba 01F4      		brne .L15
 511:yack.c        **** 
 289               	abn	68,0,511,.LM23-.LFBB5
 290               	.LM23:
 291 00bc 8091 0000 		lds r24,ctcvalue
 292 00c0 9091 0000 		lds r25,(ctcvalue)+1
 293 00c4 0196      		adiw r24,1
 294               	.L19:
 295 00c6 9093 0000 		sts (ctcvalue)+1,r25
 296 00ca 8093 0000 		sts ctcvalue,r24
 297               	.L15:
 512:yack.c        **** 
 513:yack.c        **** 
 298               	8,0,513,.LM24-.LFBB5
 299               	.LM24:
 300 00ce 8091 0000 		lds r24,ctcvalue
 301 00d2 9091 0000 		lds r25,(ctcvalue)+1
 302 00d6 8897      		sbiw r24,40
 303 00d8 00F4      		brsh .L16
 514:yack.c        **** oid yacktune (void)
 304               	n	68,0,514,.LM25-.LFBB5
 305               	.LM25:
 306 00da 88E2      		ldi r24,lo8(40)
 307 00dc 90E0      		ldi r25,hi8(40)
 308 00de 9093 0000 		sts (ctcvalue)+1,r25
 309 00e2 8093 0000 		sts ctcvalue,r24
 310               	.L16:
 515:yack.c        **** *! 
 516:yack.c        ****  @brief     Activates Tuning mode
 311               		68,0,516,.LM26-.LFBB5
 312               	.LM26:
 313 00e6 8091 0000 		lds r24,ctcvalue
 314 00ea 9091 0000 		lds r25,(ctcvalue)+1
 315 00ee 8C39      		cpi r24,156
 316 00f0 9105      		cpc r25,__zero_reg__
 317 00f2 00F0      		brlo .L17
 517:yack.c        ****  This produces a solid keydown for TUNEDURATION seconds. After this the TX is unkeyed.
 318               		68,0,517,.LM27-.LFBB5
 319               	.LM27:
 320 00f4 8BE9      		ldi r24,lo8(155)
 321 00f6 90E0      		ldi r25,hi8(155)
 322 00f8 9093 0000 		sts (ctcvalue)+1,r25
 323 00fc 8093 0000 		sts ctcvalue,r24
 324               	.L17:
 518:yack.c        **** The same can be achieved by presing either the DIT or the DAH contact or the control key.
 519:yack.c        ****  
 325               		68,0,519,.LM28-.LFBB5
 326               	.LM28:
 327 0100 8091 0000 		lds r24,volflags
 328 0104 8460      		ori r24,lo8(4)
 329 0106 8093 0000 		sts volflags,r24
 330               	/* epilogue start */
 520:yack.c        **** 
 521:yack.c        **** {
 331               	n	68,0,521,.LM29-.LFBB5
 332               	.LM29:
 333 010a 0895      		ret
 335               	.Lscope5:
 338               	.global	yackmode
 340               	yackmode:
 522:yack.c        **** word timer = YACKSECS(TUNEDURATION);
 523:yack.c        **** 	
 524:yack.c        **** 	key(DOWN);
 525:yack.c        **** 	
 526:yack.c        **** 	while(timer && (KEYINP & (1<<DITPIN)) && (KEYINP & (1<<DAHPIN)) && !yackctrlkey(TRUE) )
 527:yack.c        **** 	{
 528:yack.c        **** 		timer--;
 529:yack.c        **** 		yackbeat();
 530:yack.c        **** 	}
 531:yack.c        **** 	
 532:yack.c        **** 	key(UP);
 533:yack.c        **** }
 534:yack.c        **** 
 535:yack.c        **** 
 536:yack.c        **** 
 537:yack.c        **** 
 538:yack.c        **** void yackmode (byte mode)
 539:yack.c        **** /*! 
 540:yack.c        ****  @brief     Sets the keyer mode (e.g. IAMBIC A)
 541:yack.c        ****  
 542:yack.c        ****  This allows to set the content of the two mode bits in yackflags. Currently only
 543:yack.c        ****  two modes are supported, IAMBIC A and IAMBIC B.
 544:yack.c        ****  
 545:yack.c        ****  @param mode    IAMBICA or IAMBICB
 546:yack.c        ****  @return    TRUE is all was OK, FALSE if configuration lock prevented changes
 547:yack.c        ****  
 548:yack.c        ****  */
 549:yack.c        **** {
 550:yack.c        **** 
 551:yack.c        **** 	yackflags &= ~MODE;
 552:yack.c        **** 	yackflags |= mode;
 553:yack.c        **** 	
 554:yack.c        **** 	volflags |= DIRTYFLAG; // Set the dirty flag	
 555:yack.c        **** 
 556:yack.c        **** }
 557:yack.c        **** 
 558:yack.c        **** 
 559:yack.c        **** byte yackflag(byte flag)
 560:yack.c        **** /*! 
 561:yack.c        ****  @brief     Query feature flags
 562:yack.c        ****  
 341               	,0,562,.LM30-.LFBB6
 342               	.LM30:
 343               	.LFBB6:
 344               	/* prologue: function */
 345               	/* frame size = 0 */
 563:yack.c        **** flags are to be queried 
 564:yack.c        ****  @return     0 if the flag(s) were clear, >0 if flag(s) were set
 565:yack.c        ****  
 346               	bn	68,0,565,.LM31-.LFBB6
 347               	.LM31:
 348 010c 9091 0000 		lds r25,yackflags
 349 0110 937F      		andi r25,lo8(-13)
 350 0112 982B      		or r25,r24
 351 0114 9093 0000 		sts yackflags,r25
 566:yack.c        **** 
 567:yack.c        **** {
 352               	n	68,0,567,.LM32-.LFBB6
 353               	.LM32:
 354 0118 8091 0000 		lds r24,volflags
 355 011c 8460      		ori r24,lo8(4)
 356 011e 8093 0000 		sts volflags,r24
 357               	/* epilogue start */
 568:yack.c        ****    return yackflags & flag;
 569:yack.c        **** }
 358               	n	68,0,569,.LM33-.LFBB6
 359               	.LM33:
 360 0122 0895      		ret
 362               	.Lscope6:
 365               	.global	yackflag
 367               	yackflag:
 570:yack.c        **** 
 571:yack.c        **** void yacktoggle(byte flag)
 572:yack.c        **** /*! 
 573:yack.c        ****  @brief     Toggle feature flags
 574:yack.c        ****  
 575:yack.c        ****  When passed one (or more) flags, this routine flips the according bit in yackflags and
 576:yack.c        ****  thereby enables or disables the corresponding feature.
 577:yack.c        ****  
 578:yack.c        ****  @param flag    A byte where any bit to toggle is set e.g. SIDETONE 
 579:yack.c        ****  @return    TRUE if all was OK, FALSE if configuration lock prevented changes
 580:yack.c        ****  
 368               	,0,580,.LM34-.LFBB7
 369               	.LM34:
 370               	.LFBB7:
 371               	/* prologue: function */
 372               	/* frame size = 0 */
 374               	.LM35:
 375 0124 9091 0000 		lds r25,yackflags
 581:yack.c        **** 
 582:yack.c        ****     yackflags ^= flag;      // Toggle the feature bit
 376               	68,0,582,.LM36-.LFBB7
 377               	.LM36:
 378 0128 8923      		and r24,r25
 379               	/* epilogue start */
 380 012a 0895      		ret
 382               	.Lscope7:
 385               	.global	yacktoggle
 387               	yacktoggle:
 583:yack.c        ****    volflags |= DIRTYFLAG;  // Set the dirty flag	
 584:yack.c        **** 
 585:yack.c        **** }
 586:yack.c        **** 
 587:yack.c        **** 
 588:yack.c        **** 
 589:yack.c        **** 
 590:yack.c        **** void yackerror (void)
 591:yack.c        **** /*! 
 592:yack.c        ****  @brief     Creates a series of 8 dits
 593:yack.c        ****  
 594:yack.c        ****  The error prosign (8 dits) can not be encoded in our coding table. A call to this
 595:yack.c        ****  function produces it..
 596:yack.c        ****  
 597:yack.c        ****  */
 388               	,597,.LM37-.LFBB8
 389               	.LM37:
 390               	.LFBB8:
 391               	/* prologue: function */
 392               	/* frame size = 0 */
 598:yack.c        **** or (i=0;i<8;i++)
 599:yack.c        **** 	{
 393               	bn	68,0,599,.LM38-.LFBB8
 394               	.LM38:
 395 012c 9091 0000 		lds r25,yackflags
 396 0130 9827      		eor r25,r24
 397 0132 9093 0000 		sts yackflags,r25
 600:yack.c        **** yackplay(DIT);
 398               	bn	68,0,600,.LM39-.LFBB8
 399               	.LM39:
 400 0136 8091 0000 		lds r24,volflags
 401 013a 8460      		ori r24,lo8(4)
 402 013c 8093 0000 		sts volflags,r24
 403               	/* epilogue start */
 601:yack.c        **** 	yackdelay(DITLEN);
 602:yack.c        **** 	}
 404               	n	68,0,602,.LM40-.LFBB8
 405               	.LM40:
 406 0140 0895      		ret
 408               	.Lscope8:
 412               	key:
 603:yack.c        **** ackdelay(DAHLEN);
 604:yack.c        **** 	
 605:yack.c        **** }
 606:yack.c        **** 
 607:yack.c        **** 
 608:yack.c        **** 
 609:yack.c        **** 
 610:yack.c        **** // ***************************************************************************
 611:yack.c        **** // CW Playback related functions
 612:yack.c        **** // ***************************************************************************
 613:yack.c        **** 
 614:yack.c        **** static void key(byte mode) 
 615:yack.c        **** /*! 
 616:yack.c        ****  @brief     Keys the transmitter and produces a sidetone
 617:yack.c        ****  
 618:yack.c        ****  .. but only if the corresponding functions (TXKEY and SIDETONE) have been set in
 619:yack.c        ****  the feature register. This function also handles a request to invert the keyer line
 620:yack.c        ****  if necessary (TXINV bit).
 621:yack.c        ****  
 622:yack.c        ****  This is a private function.
 623:yack.c        **** 
 624:yack.c        ****  @param mode    UP or DOWN
 625:yack.c        ****  
 626:yack.c        ****  */
 627:yack.c        **** {
 628:yack.c        **** 	
 629:yack.c        ****     if (mode == DOWN) 
 630:yack.c        ****     {
 631:yack.c        ****         if (volflags & SIDETONE) // Are we generating a Sidetone?
 632:yack.c        ****         {
 633:yack.c        ****             OCR0A = ctcvalue;		// Then switch on the Sidetone generator
 634:yack.c        ****             OCR0B = ctcvalue;
 635:yack.c        ****             
 636:yack.c        ****             // Activate CTC mode
 637:yack.c        ****             TCCR0A |= (1<<COM0B0 | 1<<WGM01);
 638:yack.c        ****             
 639:yack.c        ****             // Configure prescaler
 640:yack.c        ****             TCCR0B = 1<<CS01;
 641:yack.c        ****         }
 642:yack.c        ****         
 643:yack.c        ****         if (volflags & TXKEY) // Are we keying the TX?
 644:yack.c        ****         {
 645:yack.c        ****             if (yackflags & TXINV) // Do we need to invert keying?
 646:yack.c        ****                 CLEARBIT(OUTPORT,OUTPIN);
 647:yack.c        ****             else
 413               	8,0,647,.LM41-.LFBB9
 414               	.LM41:
 415               	.LFBB9:
 416               	/* prologue: function */
 417               	/* frame size = 0 */
 418 0142 982F      		mov r25,r24
 648:yack.c        ****    }
 649:yack.c        **** 
 419               	n	68,0,649,.LM42-.LFBB9
 420               	.LM42:
 421 0144 8230      		cpi r24,lo8(2)
 422 0146 01F4      		brne .L27
 650:yack.c        ****   }
 651:yack.c        ****     
 423               	abn	68,0,651,.LM43-.LFBB9
 424               	.LM43:
 425 0148 8091 0000 		lds r24,volflags
 426 014c 282F      		mov r18,r24
 427 014e 84FF      		sbrs r24,4
 428 0150 00C0      		rjmp .L28
 652:yack.c        ****   if (mode == UP) 
 653:yack.c        ****     {
 429               	n	68,0,653,.LM44-.LFBB9
 430               	.LM44:
 431 0152 8091 0000 		lds r24,ctcvalue
 432 0156 89BD      		out 73-32,r24
 654:yack.c        ****        if (volflags & SIDETONE) // Sidetone active?
 433               	abn	68,0,654,.LM45-.LFBB9
 434               	.LM45:
 435 0158 88BD      		out 72-32,r24
 655:yack.c        ****        {
 656:yack.c        ****             TCCR0A = 0;
 657:yack.c        ****             TCCR0B = 0;
 436               	tabn	68,0,657,.LM46-.LFBB9
 437               	.LM46:
 438 015a 8AB5      		in r24,74-32
 439 015c 8261      		ori r24,lo8(18)
 440 015e 8ABD      		out 74-32,r24
 658:yack.c        ****      }
 659:yack.c        ****         
 660:yack.c        ****         if (volflags & TXKEY) // Are we keying the TX?
 441               	bn	68,0,660,.LM47-.LFBB9
 442               	.LM47:
 443 0160 93BF      		out 83-32,r25
 444               	.L28:
 661:yack.c        ****      {
 662:yack.c        ****             if (yackflags & TXINV) // Do we need to invert keying?
 663:yack.c        ****                 SETBIT(OUTPORT,OUTPIN);
 445               	abn	68,0,663,.LM48-.LFBB9
 446               	.LM48:
 447 0162 25FF      		sbrs r18,5
 448 0164 00C0      		rjmp .L33
 664:yack.c        ****          else
 665:yack.c        ****                 CLEARBIT(OUTPORT,OUTPIN);
 449               	abn	68,0,665,.LM49-.LFBB9
 450               	.LM49:
 451 0166 8091 0000 		lds r24,yackflags
 452 016a 86FF      		sbrs r24,6
 453 016c 00C0      		rjmp .L34
 666:yack.c        ****       }
 454               	bn	68,0,666,.LM50-.LFBB9
 455               	.LM50:
 456 016e C098      		cbi 56-32,0
 457 0170 0895      		ret
 458               	.L27:
 667:yack.c        ****     }
 668:yack.c        ****     
 669:yack.c        **** }
 670:yack.c        **** 
 671:yack.c        **** 
 672:yack.c        **** 
 673:yack.c        **** void yackfarns(void)
 459               	bn	68,0,673,.LM51-.LFBB9
 460               	.LM51:
 461 0172 8130      		cpi r24,lo8(1)
 462 0174 01F4      		brne .L33
 674:yack.c        **** brief     Produces an additional waiting delay for farnsworth mode.
 675:yack.c        ****  
 676:yack.c        ****  */
 463               	abn	68,0,676,.LM52-.LFBB9
 464               	.LM52:
 465 0176 8091 0000 		lds r24,volflags
 466 017a 84FF      		sbrs r24,4
 467 017c 00C0      		rjmp .L31
 677:yack.c        **** 
 678:yack.c        ****     word i=farnsworth;
 468               	bn	68,0,678,.LM53-.LFBB9
 469               	.LM53:
 470 017e 1ABC      		out 74-32,__zero_reg__
 679:yack.c        **** 
 471               	tabn	68,0,679,.LM54-.LFBB9
 472               	.LM54:
 473 0180 13BE      		out 83-32,__zero_reg__
 474               	.L31:
 680:yack.c        **** 	while (i--)
 681:yack.c        **** 	{
 682:yack.c        ****     	yackdelay(1);
 475               	abn	68,0,682,.LM55-.LFBB9
 476               	.LM55:
 477 0182 85FF      		sbrs r24,5
 478 0184 00C0      		rjmp .L33
 683:yack.c        **** 	
 684:yack.c        **** }
 479               	abn	68,0,684,.LM56-.LFBB9
 480               	.LM56:
 481 0186 8091 0000 		lds r24,yackflags
 482 018a 86FF      		sbrs r24,6
 483 018c 00C0      		rjmp .L32
 484               	.L34:
 685:yack.c        **** 
 485               	n	68,0,685,.LM57-.LFBB9
 486               	.LM57:
 487 018e C09A      		sbi 56-32,0
 488 0190 0895      		ret
 489               	.L32:
 686:yack.c        **** void yackdelay(byte n)
 687:yack.c        **** /*! 
 490               	bn	68,0,687,.LM58-.LFBB9
 491               	.LM58:
 492 0192 C098      		cbi 56-32,0
 493               	.L33:
 494 0194 0895      		ret
 496               	.Lscope9:
 499               	.global	yackinhibit
 501               	yackinhibit:
 503               	.LM59:
 504               	.LFBB10:
 505               	/* prologue: function */
 506               	/* frame size = 0 */
 507 0196 9091 0000 		lds r25,volflags
 509               	.LM60:
 510 019a 8823      		tst r24
 511 019c 01F0      		breq .L36
 513               	.LM61:
 514 019e 9F7C      		andi r25,lo8(-49)
 515 01a0 9061      		ori r25,lo8(16)
 516 01a2 9093 0000 		sts volflags,r25
 517 01a6 0895      		ret
 518               	.L36:
 520               	.LM62:
 521 01a8 8091 0000 		lds r24,yackflags
 522 01ac 8073      		andi r24,lo8(48)
 523 01ae 9F7C      		andi r25,lo8(-49)
 524 01b0 892B      		or r24,r25
 525 01b2 8093 0000 		sts volflags,r24
 527               	.LM63:
 528 01b6 81E0      		ldi r24,lo8(1)
 529 01b8 00D0      		rcall key
 530 01ba 0895      		ret
 532               	.Lscope10:
 535               	.global	yackdelay
 537               	yackdelay:
 688:yack.c        **** brief     Produces an active waiting delay for n dot counts
 689:yack.c        ****  
 690:yack.c        ****  This is used during the playback functions where active waiting is needed
 691:yack.c        ****  
 692:yack.c        ****  @param n   number of dot durations to delay (dependent on current keying speed!
 693:yack.c        ****  
 694:yack.c        ****  */
 695:yack.c        **** {
 696:yack.c        **** 	
 697:yack.c        **** 	byte i=n;
 698:yack.c        **** 	byte x;
 699:yack.c        **** 	
 700:yack.c        **** 	while (i--)
 701:yack.c        **** 	{
 702:yack.c        **** 		x=wpmcnt;
 703:yack.c        **** 		while (x--)    
 704:yack.c        **** 			yackbeat();
 705:yack.c        **** 	}
 706:yack.c        **** 	
 707:yack.c        **** }
 708:yack.c        **** 
 709:yack.c        **** 
 710:yack.c        **** 
 711:yack.c        **** 
 712:yack.c        **** void yackplay(byte i) 
 713:yack.c        **** /*! 
 714:yack.c        ****  @brief     Key the TX / Sidetone for the duration of a dit or a dah
 715:yack.c        ****  
 716:yack.c        ****  @param i   DIT or DAH
 717:yack.c        ****  
 718:yack.c        ****  */
 719:yack.c        **** {
 720:yack.c        **** 	
 721:yack.c        ****     key(DOWN); 
 722:yack.c        **** 
 723:yack.c        **** #ifdef POWERSAVE
 538               	* prologue: function */
 539               	/* frame size = 0 */
 540               		mov r18,r24
 542               	.LM65:
 543 01bc 282F      		lds r19,wpmcnt
 724:yack.c        **** powerdowns when keying
 725:yack.c        ****     
 726:yack.c        **** #endif
 727:yack.c        ****     
 728:yack.c        **** 	switch (i)
 729:yack.c        **** 	{
 730:yack.c        **** 		case DAH:
 544               	.L40
 545               	.L45:
 546 01be 3091 0000 	.LBB29:
 547 01c2 00C0      	.LBB30:
 549               	.LM66:
 550               		in __tmp_reg__,88-32
 551               		sbrs __tmp_reg__,6
 552               		rjmp .L45
 554 01c6 06FE      	.LM67:
 555 01c8 00C0      		in r24,88-32
 556               		ori r24,lo8(64)
 557               		out 88-32,r24
 558 01ca 88B7      		subi r25,lo8(-(-1))
 559 01cc 8064      	.L43:
 560 01ce 88BF      	.LBE30:
 561 01d0 9150      	.LBE29:
 563               	.LM68:
 564               		tst r25
 731:yack.c        **** delay(DAHLEN);
 565               	lo8(-(-1))
 566               	.L40:
 568 01d4 01F4      	.LM69:
 569 01d6 2150      		tst r18
 570               		breq .L44
 571               		mov r25,r19
 572               		rjmp .L43
 573 01d8 2223      	.L44:
 574 01da 01F0      		ret
 579               	.Lscope11:
 581               	.global	yackfarns
 583               	yackfarns:
 585               	.LM70:
 586               	.LFBB12:
 587               		push r28
 588               		push r29
 589               	/* prologue: function */
 590               	/* frame size = 0 */
 592 01e4 DF93      	.LM71:
 593               		lds r24,farnsworth
 594               		mov r28,r24
 595               		ldi r29,lo8(0)
 596               		rjmp .L48
 597 01e6 8091 0000 	.L49:
 599 01ec D0E0      	.LM72:
 600 01ee 00C0      		ldi r24,lo8(1)
 601               		rcall yackdelay
 602               		sbiw r28,1
 603               	.L48:
 605 01f2 00D0      	.LM73:
 606 01f4 2197      		sbiw r28,0
 607               		brne .L49
 608               	/* epilogue start */
 610 01f6 2097      	.LM74:
 611 01f8 01F4      		pop r29
 612               		pop r28
 613               		ret
 618               	.Lscope12:
 621               	.global	yackplay
 623               	yackplay:
 625               	.LM75:
 626               	.LFBB13:
 627               		push r17
 732:yack.c        **** 		break;
 733:yack.c        **** 			
 734:yack.c        **** 		case DIT:
 735:yack.c        **** 			yackdelay(DITLEN);
 736:yack.c        **** 			break;
 737:yack.c        **** 	}
 738:yack.c        ****     
 739:yack.c        ****     key(UP);
 740:yack.c        **** 	
 741:yack.c        **** }
 742:yack.c        **** 
 743:yack.c        **** 
 744:yack.c        **** 
 745:yack.c        **** 
 746:yack.c        **** void yackchar(char c)
 747:yack.c        **** /*! 
 628               	abn	68,0,749,.LM76-.LFBB13
 629               	.LM76:
 630               		ldi r24,lo8(2)
 631 0200 1F93      		rcall key
 633               	.LM77:
 634 0202 182F      		ldi r24,lo8(0)
 748:yack.c        ****  a character in morse code
 749:yack.c        ****  
 635               	yackpower
 637 0204 82E0      	.LM78:
 638 0206 00D0      		cpi r17,lo8(1)
 750:yack.c        **** his function translates a character passed as parameter into morse code using the 
 751:yack.c        ****  translation table in Flash memory. It then keys transmitter / sidetone with the characters
 752:yack.c        ****  elements and adds all necessary gaps (as if the character was part of a longer word).
 753:yack.c        ****  
 639               	q .L53
 640               		cpi r17,lo8(2)
 641 0208 80E0      		brne .L52
 754:yack.c        **** the character can not be translated, nothing is sent.
 755:yack.c        ****  
 756:yack.c        ****  If a space is received, an interword gap is sent.
 757:yack.c        ****   
 643               	9:
 644               		ldi r24,lo8(3)
 645 020c 1130      		rjmp .L56
 646 020e 01F0      	.L53:
 648 0212 01F4      	.LM80:
 758:yack.c        **** ram c   The character to send
 759:yack.c        ****  
 760:yack.c        **** */
 649               	24,lo8(1)
 650               	.L56:
 651 0214 83E0      		rcall yackdelay
 652 0216 00C0      	.L52:
 761:yack.c        **** 
 762:yack.c        **** 	byte	code=0x80; // 0x80 is an empty morse character (just eoc bit set)
 763:yack.c        **** 	byte 	i; // a counter
 764:yack.c        **** 	
 654               	:
 655               		ldi r24,lo8(1)
 656 0218 81E0      		rcall key
 657               	/* epilogue start */
 659               	.LM82:
 765:yack.c        ****  First we need to map the actual character to the encoded morse sequence in
 766:yack.c        **** 	// the array "morse"
 767:yack.c        **** 	if(c>='0' && c<='9') // Is it a numerical digit?
 768:yack.c        **** 		code = pgm_read_byte(&morse[c-'0']); // Find it in the beginning of array
 660               	17
 661               		ret
 663 021e 00D0      	.Lscope13:
 769:yack.c        **** 
 770:yack.c        **** 	if(c>='a' && c<='z') // Is it a character?
 665               	al	yackerror
 667 0220 1F91      	yackerror:
 669               	.LM83:
 670               	.LFBB14:
 671               		push r17
 672               	/* prologue: function */
 673               	/* frame size = 0 */
 675               	.LM84:
 676               		ldi r17,lo8(0)
 677               	.L58:
 679               	.LM85:
 680               		ldi r24,lo8(1)
 681               		rcall yackplay
 683 0226 10E0      	.LM86:
 684               		ldi r24,lo8(1)
 685               		rcall yackdelay
 687 0228 81E0      	.LM87:
 688 022a 00D0      		subi r17,lo8(-(1))
 689               		cpi r17,lo8(8)
 690               		brne .L58
 692 022e 00D0      	.LM88:
 693               		ldi r24,lo8(3)
 694               		rcall yackdelay
 695 0230 1F5F      	/* epilogue start */
 697 0234 01F4      	.LM89:
 698               		pop r17
 699               		ret
 704               	.Lscope14:
 708               	.global	yackspeed
 710               	yackspeed:
 712               	.LM90:
 713               	.LFBB15:
 714               	/* prologue: function */
 715               	/* frame size = 0 */
 717               	.LM91:
 718               		cpi r22,lo8(1)
 719               		brne .L62
 721               	.LM92:
 722               		cpi r24,lo8(1)
 723               		brne .L63
 724               		lds r24,farnsworth
 725 023e 6130      		tst r24
 726 0240 01F4      		breq .L64
 728               	.LM93:
 729 0242 8130      		subi r24,lo8(-(-1))
 730 0244 01F4      		rjmp .L69
 731 0246 8091 0000 	.L63:
 733 024c 01F0      	.LM94:
 734               		cpi r24,lo8(2)
 735               		brne .L64
 736 024e 8150      		lds r24,farnsworth
 737 0250 00C0      		cpi r24,lo8(-1)
 738               		breq .L64
 740               	.LM95:
 741 0252 8230      		subi r24,lo8(-(1))
 742 0254 01F4      	.L69:
 743 0256 8091 0000 		sts farnsworth,r24
 744 025a 8F3F      		rjmp .L64
 745 025c 01F0      	.L62:
 747               	.LM96:
 748 025e 8F5F      		cpi r24,lo8(1)
 749               		brne .L65
 750 0260 8093 0000 		lds r24,wpm
 751 0264 00C0      		cpi r24,lo8(50)
 752               		brsh .L66
 754               	.LM97:
 755 0266 8130      		subi r24,lo8(-(1))
 756 0268 01F4      		rjmp .L68
 757 026a 8091 0000 	.L65:
 759 0270 00F4      	.LM98:
 760               		cpi r24,lo8(2)
 761               		brne .L66
 762 0272 8F5F      		lds r24,wpm
 763 0274 00C0      		cpi r24,lo8(6)
 764               		brlo .L66
 766               	.LM99:
 767 0276 8230      		subi r24,lo8(-(-1))
 768 0278 01F4      	.L68:
 769 027a 8091 0000 		sts wpm,r24
 770 027e 8630      	.L66:
 772               	.LM100:
 773               		lds r22,wpm
 774 0282 8150      		ldi r24,lo8(240)
 775               		ldi r25,hi8(240)
 776 0284 8093 0000 		ldi r23,lo8(0)
 777               		rcall __divmodhi4
 778               		sts (wpmcnt)+1,r23
 779               		sts wpmcnt,r22
 780 0288 6091 0000 	.L64:
 782 028e 90E0      	.LM101:
 783 0290 70E0      		lds r24,volflags
 784 0292 00D0      		ori r24,lo8(4)
 785 0294 7093 0000 		sts volflags,r24
 787               	.LM102:
 788               		ldi r24,lo8(1)
 789               		rcall yackplay
 791 02a0 8460      	.LM103:
 792 02a2 8093 0000 		ldi r24,lo8(1)
 793               		rcall yackdelay
 795 02a6 81E0      	.LM104:
 796 02a8 00D0      		ldi r24,lo8(2)
 797               		rcall yackplay
 799 02aa 81E0      	.LM105:
 800 02ac 00D0      		ldi r24,lo8(3)
 801               		rcall yackdelay
 803 02ae 82E0      	.LM106:
 804 02b0 00D0      		rcall yackfarns
 805               	/* epilogue start */
 807 02b2 83E0      	.LM107:
 808 02b4 00D0      		ret
 810               	.Lscope15:
 813               	keylatch:
 815 02b8 0895      	.LM108:
 816               	.LFBB16:
 817               	/* prologue: function */
 818               	/* frame size = 0 */
 820               	.LM109:
 771:yack.c        **** 	code = pgm_read_byte(&morse[c-'a'+10]); // Find it from position 10
 772:yack.c        **** 	
 773:yack.c        **** 	if(c>='A' && c<='Z') // Is it a character in upper case?
 774:yack.c        **** 		code = pgm_read_byte(&morse[c-'A'+10]); // Same as above
 775:yack.c        **** 	
 776:yack.c        **** 	// Last we need to handle special characters. There is a small char
 777:yack.c        **** 	// array "spechar" which contains the characters for the morse elements
 778:yack.c        **** 	// at the end of the "morse" array (see there!)
 779:yack.c        **** 	for(i=0;i<sizeof(spechar);i++) // Read through the array
 780:yack.c        **** 		if (c == pgm_read_byte(&spechar[i])) // Does it contain our character
 781:yack.c        **** 			code = pgm_read_byte(&morse[i+36]); // Map it to morse code
 782:yack.c        **** 	
 783:yack.c        **** 	if(c==' ') // Do they want us to transmit a space (a gap of 7 dots)
 784:yack.c        **** 		yackdelay(IWGLEN-ICGLEN); // ICG was already played after previous char
 785:yack.c        **** 	else
 786:yack.c        **** 	{
 787:yack.c        ****   		while (code != 0x80) // Stop when EOC bit has reached MSB
 788:yack.c        ****   		{
 789:yack.c        **** 			if (yackctrlkey(FALSE)) // Stop playing if someone pushes key
 790:yack.c        **** 				return;
 791:yack.c        **** 			
 792:yack.c        ****      		if (code & 0x80) 	// MSB set ?
 793:yack.c        ****        			yackplay(DAH);      // ..then play a dash
 794:yack.c        ****      		else				// MSB cleared ?
 795:yack.c        ****        			yackplay(DIT);		// .. then play a dot
 796:yack.c        **** 			
 797:yack.c        ****      		yackdelay(IEGLEN);	// Inter Element gap  
 798:yack.c        ****             
 799:yack.c        ****      		code = code << 1;	// Shift code on position left (to next element)
 800:yack.c        ****   		}
 801:yack.c        **** 		
 802:yack.c        ****   		yackdelay(ICGLEN - IEGLEN); // IEG was already played after element
 803:yack.c        **** 
 804:yack.c        ****         yackfarns(); // Insert another gap for farnsworth keying
 805:yack.c        **** 
 806:yack.c        **** 	}
 807:yack.c        **** 	
 808:yack.c        **** }
 809:yack.c        **** 
 810:yack.c        **** 
 811:yack.c        **** 
 812:yack.c        **** void yackstring(const char *p)
 813:yack.c        **** /*! 
 814:yack.c        ****  @brief     Sends a 0-terminated string in CW which resides in Flash
 815:yack.c        ****  
 816:yack.c        ****  Reads character by character from flash, translates into CW and keys the transmitter
 817:yack.c        ****  and/or sidetone depending on feature bit settings.
 818:yack.c        ****  
 819:yack.c        ****  @param p   Pointer to string location in FLASH 
 820:yack.c        ****  
 821:yack.c        ****  */
 822:yack.c        **** {
 823:yack.c        **** 	
 824:yack.c        **** 	char c;
 825:yack.c        **** 	
 826:yack.c        **** 	while ((c = pgm_read_byte(p++))&& !(yackctrlkey(TRUE)) )
 827:yack.c        **** 		// While end of string in flash not reached and ctrl not pressed
 828:yack.c        **** 		yackchar(c);            // Play the read character
 829:yack.c        **** 								// abort now if someone presses command key
 830:yack.c        **** 	
 831:yack.c        **** }
 832:yack.c        **** 
 833:yack.c        **** 
 834:yack.c        **** 
 835:yack.c        **** void yacknumber(word n)
 836:yack.c        **** /*! 
 837:yack.c        ****  @brief     Sends a number in CW
 838:yack.c        ****  
 839:yack.c        ****  Transforms a number up to 65535 into its digits and sends them in CW
 840:yack.c        ****  
 841:yack.c        ****  @param n   The number to send
 842:yack.c        ****  
 843:yack.c        ****  */
 844:yack.c        **** 
 845:yack.c        **** {
 846:yack.c        ****     
 847:yack.c        ****     char buffer[5];
 848:yack.c        ****     byte i = 0;
 849:yack.c        **** 	
 850:yack.c        **** 	while (n) // Until nothing left or control key pressed
 851:yack.c        **** 	{
 852:yack.c        **** 		buffer[i++] = n%10+'0'; // Store rest of division by 10
 853:yack.c        **** 		n /= 10;                // Divide by 10
 854:yack.c        **** 	}
 855:yack.c        **** 	
 856:yack.c        ****     while (i)
 857:yack.c        ****     {
 858:yack.c        **** 		if (yackctrlkey(TRUE)) {break;}
 859:yack.c        ****         yackchar(buffer[--i]);
 860:yack.c        ****     }
 861:yack.c        ****     
 862:yack.c        ****     yackchar (' ');
 863:yack.c        ****     
 864:yack.c        **** }
 865:yack.c        **** 
 866:yack.c        **** 
 867:yack.c        **** 
 868:yack.c        **** // ***************************************************************************
 869:yack.c        **** // CW Keying related functions
 870:yack.c        **** // ***************************************************************************
 871:yack.c        **** 
 872:yack.c        **** 
 873:yack.c        **** static void keylatch(void)
 874:yack.c        **** /*! 
 875:yack.c        ****  @brief     Latches the status of the DIT and DAH paddles
 876:yack.c        ****  
 877:yack.c        ****  If either DIT or DAH are keyed, this function sets the corresponding bit in 
 878:yack.c        ****  volflags. This is used by the IAMBIC keyer to determine which element needs to 
 879:yack.c        ****  be sounded next.
 880:yack.c        ****  
 881:yack.c        ****  This is a private function.
 882:yack.c        **** 
 883:yack.c        ****  */
 884:yack.c        **** {
 885:yack.c        **** 	
 886:yack.c        **** 	byte	swap;	 // Status of swap flag
 887:yack.c        **** 	
 888:yack.c        **** 	swap    = ( yackflags & PDLSWAP);
 889:yack.c        **** 	
 890:yack.c        **** 	if (!( KEYINP & (1<<DITPIN)))
 891:yack.c        **** 		volflags |= (swap?DAHLATCH:DITLATCH);
 892:yack.c        **** 	
 893:yack.c        **** 	if (!( KEYINP & (1<<DAHPIN)))
 894:yack.c        **** 		volflags |= (swap?DITLATCH:DAHLATCH);
 895:yack.c        **** 	
 896:yack.c        **** }
 897:yack.c        **** 
 898:yack.c        **** 
 899:yack.c        **** 
 900:yack.c        **** byte yackctrlkey(byte mode)
 901:yack.c        **** /*! 
 902:yack.c        ****  @brief     Scans for the Control key
 903:yack.c        ****  
 904:yack.c        ****  This function is regularly called at different points in the program. In a normal case
 905:yack.c        ****  it terminates instantly. When the command key is found to be closed, the routine idles
 906:yack.c        ****  until it is released again and returns a TRUE return value.
 907:yack.c        ****  
 908:yack.c        ****  If, during the period where the contact was closed one of the paddles was closed too,
 909:yack.c        ****  the wpm speed is changed and the keypress not interpreted as a Control request. 
 910:yack.c        **** 
 911:yack.c        ****  @param mode    TRUE if caller has taken care of command key press, FALSE if not
 912:yack.c        ****  @return        TRUE if a press of the command key is not yet handled. 
 913:yack.c        ****  
 914:yack.c        ****  @callergraph
 915:yack.c        ****  
 821               	flags
 822               		tst r25
 823               		brne .L72
 824               		ldi r24,lo8(1)
 825               		rjmp .L73
 916:yack.c        **** ressed
 917:yack.c        **** 	{
 918:yack.c        ****         
 919:yack.c        ****         volbfr |= CKLATCH; // Set control key latch
 826               	
 827               		ldi r24,lo8(2)
 828 02ba 9091 0000 	.L73:
 829 02be 9078      		or r24,r18
 920:yack.c        **** 	// Apparently the control key has been pressed. To avoid bouncing
 921:yack.c        **** 		// We will now wait a short while and then busy wait until the key is
 830               	s volflags,r24
 831               	.L71:
 833 02c2 00C0      	.LM112:
 922:yack.c        **** // released.
 834               	c 54-32,4
 835               		rjmp .L77
 837 02c8 9923      	.LM113:
 838 02ca 01F4      		lds r18,volflags
 839 02cc 81E0      		tst r25
 840 02ce 00C0      		brne .L75
 841               		ldi r24,lo8(2)
 842 02d0 82E0      		rjmp .L76
 843               	.L75:
 844 02d2 822B      		ldi r24,lo8(1)
 845 02d4 8093 0000 	.L76:
 846               		or r24,r18
 923:yack.c        **** 	// Should we find that someone is keying the paddle, let him change
 924:yack.c        **** 		// the speed and pretend ctrl was never pressed in the first place..
 847               	,r24
 848               	.L77:
 849 02d8 B499      		ret
 925:yack.c        **** 	yackinhibit(ON); // Stop keying, switch on sidetone.
 851               	abs	"swap:r(10,1)",64,0,0,25
 854 02e0 9923      	.Lscope16:
 857 02e6 00C0      	.global	yackiambic
 859 02e8 81E0      	yackiambic:
 861 02ea 822B      	.LM114:
 862 02ec 8093 0000 	.LFBB17:
 863               		push r17
 864 02f0 0895      	/* prologue: function */
 865               	/* frame size = 0 */
 867               	.LM115:
 868               		lds r18,timer.1869
 869               		lds r19,(timer.1869)+1
 870               		cp r18,__zero_reg__
 871               		cpc r19,__zero_reg__
 872               		breq .L79
 873               		subi r18,lo8(-(-1))
 874               		sbci r19,hi8(-(-1))
 926:yack.c        **** 	
 927:yack.c        **** 		_delay_ms(50);
 928:yack.c        **** 		
 929:yack.c        **** 		while(!(BTNINP & (1<<BTNPIN))) // Busy wait for release
 930:yack.c        **** 		{
 931:yack.c        ****             
 932:yack.c        **** 			if (!( KEYINP & (1<<DITPIN))) // Someone pressing DIT paddle
 933:yack.c        **** 			{
 934:yack.c        **** 				yackspeed(DOWN,WPMSPEED);
 935:yack.c        ****                 volbfr &= ~(CKLATCH); // Ignore that control key was pressed
 936:yack.c        **** 			}	
 937:yack.c        **** 			
 938:yack.c        **** 			if (!( KEYINP & (1<<DAHPIN))) // Someone pressing DAH paddle
 939:yack.c        **** 			{
 940:yack.c        **** 				yackspeed(UP,WPMSPEED);
 941:yack.c        ****                 volbfr &= ~(CKLATCH);
 942:yack.c        **** 			}	
 943:yack.c        **** 			
 944:yack.c        **** 		}
 945:yack.c        ****         
 946:yack.c        **** 		_delay_ms(50); // Trailing edge debounce
 947:yack.c        **** 		
 948:yack.c        ****         yacksave();	// In case we had a speed change	
 949:yack.c        **** 		
 950:yack.c        **** 	}
 951:yack.c        **** 
 952:yack.c        ****     volflags = volbfr; // Restore previous state
 953:yack.c        **** 
 954:yack.c        ****     if (mode==TRUE) // Does caller want us to reset latch?
 955:yack.c        ****     {
 956:yack.c        ****         volflags &= ~(CKLATCH);
 957:yack.c        ****     }
 958:yack.c        ****     
 959:yack.c        ****     //yacksave(); // In case we had a speed change (Does NOT work if command is here - moved immedi
 960:yack.c        ****     
 961:yack.c        **** 	return((volbfr&CKLATCH)!=0); // Tell caller if we had a ctrl button press
 962:yack.c        **** 	
 963:yack.c        **** }
 964:yack.c        **** 
 965:yack.c        **** 
 966:yack.c        **** 
 967:yack.c        **** static char morsechar(byte buffer)
 968:yack.c        **** /*! 
 969:yack.c        ****  @brief     Reverse maps a combination of dots and dashes to a character
 970:yack.c        ****  
 971:yack.c        ****  This routine is passed a sequence of dots and dashes in the format we use for morse
 972:yack.c        ****  character encoding (see top of this file). It looks up the corresponding character in
 973:yack.c        ****  the Flash table and returns it to the caller. 
 974:yack.c        ****  
 975:yack.c        ****  This is a private function.
 976:yack.c        ****  
 977:yack.c        ****  @param buffer    A character in YACK CW notation
 978:yack.c        ****  @return          The mapped character or /0 if no match was found  
 979:yack.c        ****  
 980:yack.c        ****  */
 981:yack.c        **** {
 982:yack.c        **** 	byte i;
 983:yack.c        **** 	
 984:yack.c        **** 	for(i=0;i<sizeof(morse);i++)
 985:yack.c        **** 	{
 986:yack.c        **** 		
 987:yack.c        **** 		if (pgm_read_byte(&morse[i]) == buffer)
 988:yack.c        **** 		{
 989:yack.c        **** 			if (i < 10) return ('0' + i); 		// First 10 chars are digits
 990:yack.c        **** 			if (i < 36) return ('A' + i - 10); 	// Then follow letters
 991:yack.c        **** 			return (pgm_read_byte(&spechar[i - 36])); // Then special chars
 992:yack.c        **** 		}
 993:yack.c        **** 		
 994:yack.c        **** 	}
 995:yack.c        **** 	
 996:yack.c        **** 	return '\0';
 997:yack.c        **** }
 998:yack.c        **** 
 999:yack.c        **** 
1000:yack.c        **** 
1001:yack.c        **** void yackmessage(byte function, byte msgnr)
1002:yack.c        **** /*! 
1003:yack.c        ****  @brief     Handles EEPROM stored CW messages (macros)
1004:yack.c        ****  
1005:yack.c        ****  When called in RECORD mode, the function records a message up to 100 characters and stores it in 
1006:yack.c        ****  EEPROM. The routine stops recording when timing out after DEFTIMEOUT seconds. Recording
1007:yack.c        ****  can be aborted using the control key. If more than 100 characters are recorded, the error prosign
1008:yack.c        ****  is sounded and recording starts from the beginning. After recording and timing out the message is 
1009:yack.c        ****  back once before it is stored. To erase a message, do not key one.
1010:yack.c        ****  
1011:yack.c        ****  When called in PLAY mode, the message is just played back. Playback can be aborted using the comma
1012:yack.c        ****  key.
1013:yack.c        ****  
1014:yack.c        ****  @param     function    RECORD or PLAY
1015:yack.c        ****  @param     msgnr       1 or 2 or 3 or 4
1016:yack.c        ****  @return    TRUE if all OK, FALSE if lock prevented message recording
1017:yack.c        ****  
1018:yack.c        ****  */
1019:yack.c        **** {
1020:yack.c        **** 	unsigned char	rambuffer[RBSIZE];  // Storage for the message
1021:yack.c        **** 	unsigned char	c;					// Work character
1022:yack.c        **** 	
1023:yack.c        **** 	word			extimer = 0;		// Detects end of message (10 sec)
1024:yack.c        **** 	
1025:yack.c        **** 	byte 			i = 0;       		// Pointer into RAM buffer
1026:yack.c        **** 	byte 			n;					// Generic counter
1027:yack.c        **** 	
1028:yack.c        **** 	if (function == RECORD)
1029:yack.c        **** 	{
1030:yack.c        **** 
1031:yack.c        **** 		extimer = YACKSECS(DEFTIMEOUT);	// 5 Second until message end
1032:yack.c        **** 	   	while(extimer--)	// Continue until we waited 10 seconds
1033:yack.c        ****    		{
1034:yack.c        **** 			if (yackctrlkey(TRUE)) return;
1035:yack.c        **** 			
1036:yack.c        **** 			if ((c = yackiambic(ON))) // Check for a character from the key
1037:yack.c        **** 			{
1038:yack.c        **** 				rambuffer[i++] = c; // Add that character to our buffer
1039:yack.c        **** 				extimer = YACKSECS(DEFTIMEOUT); // Reset End of message timer
1040:yack.c        **** 			}
1041:yack.c        **** 			
1042:yack.c        **** 			if (i>=RBSIZE) // End of buffer reached?
1043:yack.c        **** 			{
1044:yack.c        **** 				yackerror();
1045:yack.c        **** 				i = 0;
1046:yack.c        **** 			}
1047:yack.c        **** 			
1048:yack.c        **** 			yackbeat(); // 10 ms heartbeat
1049:yack.c        **** 		}	
1050:yack.c        **** 		
1051:yack.c        **** 		// Extimer has expired. Message has ended
1052:yack.c        **** 		
1053:yack.c        **** 		if(i) // Was anything received at all?
1054:yack.c        **** 		{
1055:yack.c        **** 			rambuffer[--i] = 0; // Add a \0 end marker over last space
1056:yack.c        **** 			
1057:yack.c        **** 			// Replay the message
1058:yack.c        **** 			//for (n=0;n<i;n++){
1059:yack.c        **** 			//	if (yackctrlkey(TRUE)) {return;} //Break to command mode without saving if command key presse
1060:yack.c        **** 			//	yackchar(rambuffer[n]);
1061:yack.c        **** 	        //    }
1062:yack.c        **** 			
1063:yack.c        **** 			// Store it in EEPROM
1064:yack.c        **** 			if (msgnr == 1)
1065:yack.c        **** 	  			eeprom_write_block(rambuffer,eebuffer1,RBSIZE);
1066:yack.c        **** 			if (msgnr == 2)
1067:yack.c        **** 	  			eeprom_write_block(rambuffer,eebuffer2,RBSIZE);
1068:yack.c        **** 			if (msgnr == 3)
1069:yack.c        **** 	  			eeprom_write_block(rambuffer,eebuffer3,RBSIZE);
1070:yack.c        **** 			if (msgnr == 4)
1071:yack.c        **** 	  			eeprom_write_block(rambuffer,eebuffer4,RBSIZE);
1072:yack.c        **** 		}
1073:yack.c        **** 		else
1074:yack.c        **** 			yackerror();
1075:yack.c        **** 	}
1076:yack.c        **** 	
1077:yack.c        **** 	
1078:yack.c        **** 	if (function == PLAY)
1079:yack.c        **** 	{
1080:yack.c        **** 		// Retrieve the message from EEPROM
1081:yack.c        **** 		if (msgnr == 1)
1082:yack.c        **** 	  		eeprom_read_block(rambuffer,eebuffer1,RBSIZE);
1083:yack.c        **** 		if (msgnr == 2)
1084:yack.c        **** 	  		eeprom_read_block(rambuffer,eebuffer2,RBSIZE);
1085:yack.c        **** 		if (msgnr == 3)
1086:yack.c        **** 	  		eeprom_read_block(rambuffer,eebuffer3,RBSIZE);
1087:yack.c        **** 		if (msgnr == 4)
1088:yack.c        **** 	  		eeprom_read_block(rambuffer,eebuffer4,RBSIZE);
1089:yack.c        **** 		
1090:yack.c        **** 		// Replay the message
1091:yack.c        **** 		for (n=0;(c=rambuffer[n]);n++){ // Read until end of message
1092:yack.c        **** 		if (yackctrlkey(FALSE)) {return;} //Break immediately if command key pressed
1093:yack.c        **** 			yackchar(c); // play it back 
1094:yack.c        **** 		}
1095:yack.c        **** 		
1096:yack.c        **** 	}
1097:yack.c        **** 	
1098:yack.c        **** }
1099:yack.c        **** 
1100:yack.c        **** 
1101:yack.c        **** 
1102:yack.c        **** 
1103:yack.c        **** char yackiambic(byte ctrl)
1104:yack.c        **** /*! 
1105:yack.c        ****  @brief     Finite state machine for the IAMBIC keyer
1106:yack.c        ****  
1107:yack.c        ****  If IAMBIC (squeeze) keying is requested, this routine, which usually terminates
1108:yack.c        ****  immediately needs to be called in regular intervals of YACKBEAT milliseconds.
1109:yack.c        ****  
1110:yack.c        ****  This can happen though an outside busy waiting loop or a counter mechanism.
1111:yack.c        ****  
1112:yack.c        ****  @param ctrl    ON if the keyer should recognize when a word ends. OFF if not.
1113:yack.c        ****  @return        The character if one was recognized, /0 if not
1114:yack.c        ****  
1115:yack.c        ****  */
1116:yack.c        **** {
1117:yack.c        **** 	
1118:yack.c        **** 	static enum FSMSTATE	fsms = IDLE;	// FSM state indicator
1119:yack.c        **** 	static 		word		timer;			// A countdown timer
1120:yack.c        **** 	static		byte		lastsymbol;		// The last symbol sent
1121:yack.c        **** 	static		byte		buffer = 0;		// A place to store a sent char
1122:yack.c        **** 	static		byte		bcntr = 0;		// Number of elements sent
1123:yack.c        **** 	static		byte		iwgflag = 0;	// Flag: Are we in interword gap?
1124:yack.c        ****     static      byte        ultimem = 0;    // Buffer for last keying status
1125:yack.c        **** 				char		retchar;		// The character to return to caller
1126:yack.c        **** 	
1127:yack.c        **** 	// This routine is called every YACKBEAT ms. It starts with idle mode where
1128:yack.c        **** 	// the morse key is polled. Once a contact close is sensed, the TX key is 
1129:yack.c        **** 	// closed, the sidetone oscillator is fired up and the FSM progresses
1130:yack.c        **** 	// to the next state (KEYED). There it waits for the timer to expire, 
1131:yack.c        **** 	// afterwards progressing to IEG (Inter Element Gap).
1132:yack.c        **** 	// Once the IEG has completed, processing returns to the IDLE state.
1133:yack.c        **** 	
1134:yack.c        **** 	// If the FSM remains in idle state long enough (one dash time), the
1135:yack.c        **** 	// character is assumed to be complete and a decoding is attempted. If
1136:yack.c        **** 	// succesful, the ascii code of the character is returned to the caller
1137:yack.c        **** 	
1138:yack.c        **** 	// If the FSM remains in idle state for another 4 dot times (7 dot times 
1139:yack.c        **** 	// altogether), we assume that the word has ended. A space char
1140:yack.c        **** 	// is transmitted in this case.
1141:yack.c        **** 	
1142:yack.c        **** 	if (timer) timer--; // Count down
1143:yack.c        **** 	
1144:yack.c        **** 	if (ctrl == OFF) iwgflag = 0; // No space detection
1145:yack.c        **** 	
1146:yack.c        **** 	switch (fsms)
1147:yack.c        **** 	{
1148:yack.c        **** 			
1149:yack.c        **** 		case IDLE:
1150:yack.c        **** 			
1151:yack.c        **** 			keylatch();
1152:yack.c        ****            
1153:yack.c        **** #ifdef POWERSAVE            
1154:yack.c        ****             
1155:yack.c        ****             yackpower(TRUE); // OK to go to sleep when here.
1156:yack.c        **** 
 875               		sts timer.1869,r18
 876               	.L79:
 878 02f2 1F93      	.LM116:
 879               		tst r24
 880               		brne .L80
1157:yack.c        **** us keyer modes
1158:yack.c        ****             switch (yackflags & MODE)
1159:yack.c        ****             {
1160:yack.c        ****                 case IAMBICA:
1161:yack.c        ****                 case IAMBICB:
1162:yack.c        ****                     // When the paddle keys are squeezed, we need to ensure that
1163:yack.c        ****                     // dots and dashes are alternating. To do that, whe delete
1164:yack.c        ****                     // any latched paddle of the same kind that we just sent.
1165:yack.c        ****                     // However, we only do this ONCE
1166:yack.c        ****                     
1167:yack.c        ****                     volflags &= ~lastsymbol;
1168:yack.c        ****                     lastsymbol = 0;
1169:yack.c        ****                     break;                    
1170:yack.c        ****                  
1171:yack.c        ****                 case ULTIMATIC:
1172:yack.c        ****                     // Ultimatic logic: The last paddle to be active will be repeated indefinitely
1173:yack.c        ****                     // In case the keyer is squeezed right out of idle mode, we just send a DAH 
1174:yack.c        ****                     if ((volflags & SQUEEZED) == SQUEEZED) // Squeezed?
1175:yack.c        ****                     {
1176:yack.c        ****                         if (ultimem)
1177:yack.c        ****                           volflags &= ~ultimem; // Opposite symbol from last one
1178:yack.c        ****                         else
1179:yack.c        ****                           volflags &= ~DITLATCH; // Reset the DIT latch
1180:yack.c        ****                     }
1181:yack.c        ****                     else
1182:yack.c        ****                     {
 881               	wgflag.1873,__zero_reg__
 882               	.L80:
 884 02f8 3091 0000 	.LM117:
 885 02fc 2115      		lds r24,fsms.1868
 886 02fe 3105      		cpi r24,lo8(1)
 887 0300 01F0      		brne .+2
 888 0302 2150      		rjmp .L83
 889 0304 3040      		cpi r24,lo8(1)
 890 0306 3093 0000 		brlo .L82
 891 030a 2093 0000 		cpi r24,lo8(2)
 892               		breq .+2
1183:yack.c        **** timem = volflags & SQUEEZED; // Remember the last single key
1184:yack.c        ****                     }
 893               	rjmp .L107
 894               	.L82:
 896 0310 01F4      	.LM118:
 897 0312 1092 0000 		rcall keylatch
1185:yack.c        ****                       ultimem = volflags & SQUEEZED; // Remember the last single key
1186:yack.c        ****                     }
 899               	:
 900               		ldi r24,lo8(1)
 901 0316 8091 0000 		rcall yackpower
 903 031c 01F4      	.LM120:
 904 031e 00C0      		lds r24,yackflags
 905 0320 8130      		ldi r25,lo8(0)
 906 0322 00F0      		andi r24,lo8(12)
 907 0324 8230      		andi r25,hi8(12)
 908 0326 01F0      		cpi r24,4
 909 0328 00C0      		cpc r25,__zero_reg__
 910 032a 00C0      		breq .L86
 911               		cpi r24,5
1187:yack.c        ****                       ultimem = volflags & SQUEEZED; // Remember the last single key
1188:yack.c        ****                     }
1189:yack.c        **** 
1190:yack.c        ****                     break;
1191:yack.c        ****                             
 912               	ro_reg__
 913               		brge .L89
 914 032c 00D0      		or r24,r25
1192:yack.c        **** mber the last single key
1193:yack.c        ****                     }
1194:yack.c        **** 
1195:yack.c        ****                     break;
 915               	eq .L86
 916               		rjmp .L85
 917 032e 81E0      	.L89:
 918 0330 00D0      		cpi r24,8
1196:yack.c        **** = volflags & SQUEEZED; // Remember the last single key
1197:yack.c        ****                     }
1198:yack.c        **** 
1199:yack.c        ****                     break;
1200:yack.c        ****                             
 919               	 r25,__zero_reg__
 920               		breq .L87
 921 0332 8091 0000 		sbiw r24,12
 922 0336 90E0      		brne .L85
 923 0338 8C70      		rjmp .L108
 924 033a 9070      	.L86:
 926 033e 9105      	.LM121:
 927 0340 01F0      		lds r25,lastsymbol.1870
 928 0342 8530      		com r25
 929 0344 9105      		lds r24,volflags
 930 0346 04F4      		and r24,r25
 931 0348 892B      		sts volflags,r24
 933 034c 00C0      	.LM122:
 934               		sts lastsymbol.1870,__zero_reg__
 935 034e 8830      		rjmp .L85
 936 0350 9105      	.L87:
 938 0354 0C97      	.LM123:
 939 0356 01F4      		lds r25,volflags
 940 0358 00C0      		mov r24,r25
 941               		andi r24,lo8(3)
1201:yack.c        **** mber the last single key
1202:yack.c        ****                     }
1203:yack.c        **** 
1204:yack.c        ****                     break;
1205:yack.c        ****                             
1206:yack.c        ****                 case DAHPRIO:            
1207:yack.c        ****                     // If both paddles pressed, DAH is given priority
1208:yack.c        ****                     if ((volflags & SQUEEZED) == SQUEEZED)
1209:yack.c        ****                     {
 942               	L90
 944 035a 9091 0000 	.LM124:
 945 035e 9095      		lds r24,ultimem.1874
 946 0360 8091 0000 		tst r24
 947 0364 8923      		breq .L105
1210:yack.c        ****  is given priority
 949               	
 950               		com r24
 951 036a 1092 0000 		and r24,r25
 952 036e 00C0      		sts volflags,r24
 953               		rjmp .L85
1211:yack.c        ****       case DAHPRIO:            
1212:yack.c        ****                     // If both paddles pressed, DAH is given priority
1213:yack.c        ****                     if ((volflags & SQUEEZED) == SQUEEZED)
1214:yack.c        ****                     {
1215:yack.c        ****                         volflags &= ~DITLATCH; // Reset the DIT latch
1216:yack.c        ****                     }
 954               	:
 956 0370 9091 0000 	.LM126:
 957 0374 892F      		andi r25,lo8(3)
 958 0376 8370      		sts ultimem.1874,r25
 959 0378 8330      		rjmp .L85
 960 037a 01F4      	.L108:
1217:yack.c        ****     {
1218:yack.c        ****                         volflags &= ~DITLATCH; // Reset the DIT latch
 961               		68,0,1232,.LM127-.LFBB17
 962               	.LM127:
 963 037c 8091 0000 		lds r25,volflags
 964 0380 8823      		mov r24,r25
 965 0382 01F0      		andi r24,lo8(3)
1219:yack.c        **** EEZED)
 966               	r24,lo8(3)
 967               		brne .L85
 968 0384 8095      	.L105:
 970 0388 8093 0000 	.LM128:
 971 038c 00C0      		andi r25,lo8(-2)
 972               		sts volflags,r25
1220:yack.c        **** th paddles pressed, DAH is given priority
1221:yack.c        ****                     if ((volflags & SQUEEZED) == SQUEEZED)
1222:yack.c        ****                     {
1223:yack.c        ****                         volflags &= ~DITLATCH; // Reset the DIT latch
1224:yack.c        ****                     }
1225:yack.c        ****                     break;
 974               	.LM129:
 975 038e 9370      		lds r24,timer.1869
 976 0390 9093 0000 		lds r25,(timer.1869)+1
 977 0394 00C0      		or r24,r25
 978               		breq .+2
1226:yack.c        ****   volflags &= ~DITLATCH; // Reset the DIT latch
1227:yack.c        ****                     }
1228:yack.c        ****                     break;
1229:yack.c        ****             }        
1230:yack.c        ****             
1231:yack.c        ****             
1232:yack.c        **** 			// The following handles the inter-character gap. When there are
 979               	.L92
 980               		lds r20,bcntr.1872
 981 0396 9091 0000 		tst r20
 982 039a 892F      		brne .+2
 983 039c 8370      		rjmp .L93
 985 03a0 01F4      	.LM130:
 986               		lds r24,buffer.1871
1233:yack.c        ****            
1234:yack.c        ****             
 987               	
 988               		ori r24,lo8(1)
 989 03a2 9E7F      		ldi r25,lo8(0)
 990 03a4 9093 0000 		ldi r18,lo8(7)
 991               		ldi r19,hi8(7)
1235:yack.c        ****                  }
1236:yack.c        ****                     break;
1237:yack.c        ****             }        
1238:yack.c        ****             
1239:yack.c        ****             
1240:yack.c        **** 			// The following handles the inter-character gap. When there are
1241:yack.c        **** 			// three (default) dot lengths of space after an element, the
1242:yack.c        **** 			// character is complete and can be returned to caller
1243:yack.c        **** 			if (timer == 0 && bcntr != 0) // Have we idled for 3 dots
 992               	 r18,r20
 993               		sbc r19,__zero_reg__
 994 03a8 8091 0000 		rjmp 2f
 995 03ac 9091 0000 	1:	lsl r24
 996 03b0 892B      		rol r25
 997 03b2 01F0      	2:	dec r18
 998 03b4 00C0      		brpl 1b
 999 03b6 4091 0000 		mov r25,r24
 1000 03ba 4423      		ldi r18,lo8(0)
 1001 03bc 01F4      		ldi r19,hi8(0)
 1002 03be 00C0      	.L98:
1244:yack.c        **** nd can be returned to caller
1245:yack.c        **** 			if (timer == 0 && bcntr != 0) // Have we idled for 3 dots
1246:yack.c        **** 				// and is there something to decode?
1247:yack.c        **** 			{
1248:yack.c        **** 				buffer = buffer << 1;	  // Make space for the termination bit
 1003               	B32:
 1004               	.LBB33:
 1006 03c4 880F      	.LM131:
 1007 03c6 8160      		movw r30,r18
 1008 03c8 90E0      		subi r30,lo8(-(morse))
 1009 03ca 27E0      		sbci r31,hi8(-(morse))
 1010 03cc 30E0      	/* #APP */
 1011 03ce 241B      	 ;  1027 "yack.c" 1
 1012 03d0 3109      		lpm r30, Z
 1013 03d2 00C0      		
 1014 03d4 880F      	 ;  0 "" 2
 1015 03d6 991F      	/* #NOAPP */
 1016 03d8 2A95      	.LBE33:
 1017 03da 02F4      		cp r30,r25
 1018 03dc 982F      		brne .L94
 1020 03e0 30E0      	.LM132:
 1021               		cpi r18,lo8(10)
 1022               		brsh .L95
 1023               		subi r18,lo8(-(48))
 1024               		rjmp .L96
 1025               	.L95:
 1027 03e2 F901      	.LM133:
 1028 03e4 E050      		cpi r18,lo8(36)
 1029 03e6 F040      		brsh .L97
 1030               		subi r18,lo8(-(55))
 1031               		rjmp .L96
 1032 03e8 E491      	.L97:
 1033               	.LBB34:
 1035               	.LM134:
 1036               		subi r18,lo8(-(spechar-36))
 1037 03ea E917      		sbci r19,hi8(-(spechar-36))
 1038 03ec 01F4      		movw r30,r18
 1039               	/* #APP */
 1040               	 ;  1031 "yack.c" 1
 1041 03ee 2A30      		lpm r18, Z
 1042 03f0 00F4      		
 1043 03f2 205D      	 ;  0 "" 2
 1044 03f4 00C0      	/* #NOAPP */
 1045               		rjmp .L96
 1046               	.L94:
 1047               		subi r18,lo8(-(1))
 1048 03f6 2432      		sbci r19,hi8(-(1))
 1049 03f8 00F4      	.LBE34:
 1051 03fc 00C0      	.LM135:
 1052               		cpi r18,60
 1053               		cpc r19,__zero_reg__
 1054               		brne .L98
 1055               		ldi r18,lo8(0)
 1056 03fe 2050      	.L96:
 1057 0400 3040      	.LBE32:
 1058 0402 F901      	.LBE31:
 1060               	.LM136:
 1061 0404 2491      		sts bcntr.1872,__zero_reg__
 1062               		sts buffer.1871,__zero_reg__
 1064               	.LM137:
 1065 0406 00C0      		lds r24,wpmcnt
 1066               		lds r25,(wpmcnt)+1
 1067 0408 2F5F      		lsl r24
 1068 040a 3F4F      		rol r25
 1069               		lsl r24
 1070               		rol r25
 1071               		sts (timer.1869)+1,r25
 1072 040c 2C33      		sts timer.1869,r24
 1074 0410 01F4      	.LM138:
 1075 0412 20E0      		ldi r24,lo8(1)
 1076               		sts iwgflag.1873,r24
 1077               		rjmp .L99
 1078               	.L93:
1249:yack.c        **** hing to decode?
1250:yack.c        **** 			{
 1079               	q .L92
 1081 0414 1092 0000 	.LM140:
 1082 0418 1092 0000 		sts iwgflag.1873,__zero_reg__
1251:yack.c        **** & bcntr != 0) // Have we idled for 3 dots
 1083               	 r18,lo8(32)
 1084               		rjmp .L99
 1085 041c 8091 0000 	.L92:
 1087 0424 880F      	.LM141:
 1088 0426 991F      		lds r17,volflags
 1089 0428 880F      		mov r20,r17
 1090 042a 991F      		ldi r21,lo8(0)
 1091 042c 9093 0000 		movw r24,r20
 1092 0430 8093 0000 		andi r24,lo8(3)
1252:yack.c        **** nd can be returned to caller
1253:yack.c        **** 			if (timer == 0 && bcntr != 0) // Have we idled for 3 dots
 1093               	hi8(3)
 1094               		or r24,r25
 1095 0434 81E0      		brne .+2
 1096 0436 8093 0000 		rjmp .L81
 1098               	.LM142:
1254:yack.c        **** nd can be returned to caller
1255:yack.c        **** 			if (timer == 0 && bcntr != 0) // Have we idled for 3 dots
1256:yack.c        **** 				// and is there something to decode?
1257:yack.c        **** 			{
1258:yack.c        **** 				buffer = buffer << 1;	  // Make space for the termination bit
1259:yack.c        **** 				buffer |= 1;			  // The 1 on the right signals end
 1099               	wgflag.1873,__zero_reg__
 1101 043c 8091 0000 	.LM143:
 1102 0440 8823      		lds r24,bcntr.1872
 1103 0442 01F0      		subi r24,lo8(-(1))
1260:yack.c        ****  space for the termination bit
1261:yack.c        **** 				buffer |= 1;			  // The 1 on the right signals end
 1104               	bcntr.1872,r24
 1106 0444 1092 0000 	.LM144:
 1107 0448 20E2      		lds r18,buffer.1871
 1108 044a 00C0      		lsl r18
 1109               		sts buffer.1871,r18
1262:yack.c        ****  space for the termination bit
1263:yack.c        **** 				buffer |= 1;			  // The 1 on the right signals end
1264:yack.c        **** 				buffer = buffer << (7-bcntr); // Shift to left justify
1265:yack.c        **** 				retchar = morsechar(buffer); // Attempt decoding
1266:yack.c        **** 				buffer = bcntr = 0;			// Clear buffer
 1110               	24,wpmcnt
 1111               		lds r25,(wpmcnt)+1
 1113 0450 412F      	.LM145:
 1114 0452 50E0      		sbrs r17,0
 1115 0454 CA01      		rjmp .L100
 1117 0458 9070      	.LM146:
 1118 045a 892B      		sts (timer.1869)+1,r25
 1119 045c 01F4      		sts timer.1869,r24
1267:yack.c        **** = morsechar(buffer); // Attempt decoding
1268:yack.c        **** 				buffer = bcntr = 0;			// Clear buffer
 1121               	i r24,lo8(1)
 1122               		sts lastsymbol.1870,r24
 1123 0460 1092 0000 		rjmp .L101
1269:yack.c        **** = morsechar(buffer); // Attempt decoding
 1124               	00:
 1126 0464 8091 0000 	.LM148:
 1127 0468 8F5F      		ldi r22,lo8(3)
 1128 046a 8093 0000 		ldi r23,hi8(3)
1270:yack.c        **** ntr); // Shift to left justify
 1129               	l __mulhi3
 1130               		sts (timer.1869)+1,r25
 1131 046e 2091 0000 		sts timer.1869,r24
 1133 0474 2093 0000 	.LM149:
 1134 0478 8091 0000 		ldi r24,lo8(2)
 1135 047c 9091 0000 		sts lastsymbol.1870,r24
1271:yack.c        ****  on the right signals end
1272:yack.c        **** 				buffer = buffer << (7-bcntr); // Shift to left justify
 1136               		68,0,1281,.LM150-.LFBB17
 1137               	.LM150:
 1138 0480 10FF      		ori r18,lo8(1)
 1139 0482 00C0      		sts buffer.1871,r18
1273:yack.c        ****  on the right signals end
1274:yack.c        **** 				buffer = buffer << (7-bcntr); // Shift to left justify
 1140               	1:
 1142 0484 9093 0000 	.LM151:
 1143 0488 8093 0000 		ldi r24,lo8(2)
1275:yack.c        ****  on the right signals end
 1144               	ll key
 1146 048c 81E0      	.LM152:
 1147 048e 8093 0000 		andi r17,lo8(-4)
 1148 0492 00C0      		sts volflags,r17
1276:yack.c        ****  space for the termination bit
1277:yack.c        **** 				buffer |= 1;			  // The 1 on the right signals end
1278:yack.c        **** 				buffer = buffer << (7-bcntr); // Shift to left justify
1279:yack.c        **** 				retchar = morsechar(buffer); // Attempt decoding
 1150               	:
 1151               		ldi r24,lo8(1)
 1152 0494 63E0      		rjmp .L106
 1153 0496 70E0      	.L83:
 1155 049a 9093 0000 	.LM154:
 1156 049e 8093 0000 		ldi r24,lo8(0)
1280:yack.c        **** ntr); // Shift to left justify
 1157               	yackpower
 1159 04a2 82E0      	.LM155:
 1160 04a4 8093 0000 		lds r24,yackflags
1281:yack.c        ****  on the right signals end
 1161               	i r24,lo8(12)
 1162               		cpi r24,lo8(4)
 1163 04a8 2160      		brne .L102
 1165               	.LM156:
1282:yack.c        ****  space for the termination bit
1283:yack.c        **** 				buffer |= 1;			  // The 1 on the right signals end
1284:yack.c        **** 				buffer = buffer << (7-bcntr); // Shift to left justify
 1166               	l keylatch
 1167               	.L102:
 1169 04b0 00D0      	.LM157:
1285:yack.c        ****  on the right signals end
 1170               	 r24,timer.1869
 1171               		lds r25,(timer.1869)+1
 1172 04b2 1C7F      		or r24,r25
 1173 04b4 1093 0000 		brne .L81
1286:yack.c        ****  space for the termination bit
1287:yack.c        **** 				buffer |= 1;			  // The 1 on the right signals end
 1174               	abn	68,0,1305,.LM158-.LFBB17
 1175               	.LM158:
 1176 04b8 81E0      		ldi r24,lo8(1)
 1177 04ba 00C0      		rcall key
1288:yack.c        ****  space for the termination bit
1289:yack.c        **** 				buffer |= 1;			  // The 1 on the right signals end
1290:yack.c        **** 				buffer = buffer << (7-bcntr); // Shift to left justify
1291:yack.c        **** 				retchar = morsechar(buffer); // Attempt decoding
1292:yack.c        **** 				buffer = bcntr = 0;			// Clear buffer
1293:yack.c        **** 				timer = (IWGLEN - ICGLEN) * wpmcnt;	// If 4 further dots of gap,
1294:yack.c        **** 				// this might be a Word gap.
1295:yack.c        **** 				iwgflag = 1;                // Signal we are waiting for IWG                          
1296:yack.c        **** 				return (retchar);			// and return decoded char
 1179               	9:
 1180               		lds r24,wpmcnt
 1181 04bc 80E0      		lds r25,(wpmcnt)+1
 1182 04be 00D0      		sts (timer.1869)+1,r25
1297:yack.c        **** G                          
1298:yack.c        **** 				return (retchar);			// and return decoded char
1299:yack.c        **** 			}
1300:yack.c        **** 			
 1183               	 timer.1869,r24
 1185 04c0 8091 0000 	.LM160:
 1186 04c4 8C70      		ldi r24,lo8(2)
 1187 04c6 8430      	.L106:
 1188 04c8 01F4      		sts fsms.1868,r24
1301:yack.c        ****                 
 1189               	.L81
 1190               	.L107:
 1192               	.LM161:
1302:yack.c        ****  = 1;                // Signal we are waiting for IWG                          
1303:yack.c        **** 				return (retchar);			// and return decoded char
 1193               	ll keylatch
 1195 04cc 8091 0000 	.LM162:
 1196 04d0 9091 0000 		lds r24,timer.1869
 1197 04d4 892B      		lds r25,(timer.1869)+1
 1198 04d6 01F4      		or r24,r25
1304:yack.c        **** G                          
1305:yack.c        **** 				return (retchar);			// and return decoded char
 1199               	.L81
 1201 04d8 81E0      	.LM163:
 1202 04da 00D0      		sts fsms.1868,__zero_reg__
1306:yack.c        **** G                          
 1203               	abn	68,0,1323,.LM164-.LFBB17
 1204               	.LM164:
 1205 04dc 8091 0000 		lds r24,wpmcnt
 1206 04e0 9091 0000 		lds r25,(wpmcnt)+1
 1207 04e4 9093 0000 		sts (timer.1869)+1,r25
 1208 04e8 8093 0000 		sts timer.1869,r24
1307:yack.c        ****  = 1;                // Signal we are waiting for IWG                          
 1209               		ldi r18,lo8(0)
 1210               	.L99:
 1212               	.LM165:
 1213 04ee 8093 0000 		mov r24,r18
 1214 04f2 00C0      	/* epilogue start */
 1215               		pop r17
1308:yack.c        ****  = 1;                // Signal we are waiting for IWG                          
1309:yack.c        **** 				return (retchar);			// and return decoded char
1310:yack.c        **** 			}
1311:yack.c        **** 			
1312:yack.c        **** 			// This handles the Inter-word gap. Already 3 dots have been
1313:yack.c        **** 			// waited for, if 4 more follow, interpret this as a word end
1314:yack.c        **** 			if (timer == 0 && iwgflag) // Have we idled for 4+3 = 7 dots?
1315:yack.c        **** 			{
 1216               	size	yackiambic, .-yackiambic
1316:yack.c        **** nd
1317:yack.c        **** 			if (timer == 0 && iwgflag) // Have we idled for 4+3 = 7 dots?
 1219               	tabs	"lastsymbol:V(10,1)",40,0,0,lastsymbol.1870
1318:yack.c        **** word end
1319:yack.c        **** 			if (timer == 0 && iwgflag) // Have we idled for 4+3 = 7 dots?
 1225               	n	192,0,0,.LFBB17-.LFBB17
1320:yack.c        **** word end
1321:yack.c        **** 			if (timer == 0 && iwgflag) // Have we idled for 4+3 = 7 dots?
1322:yack.c        **** 			{
1323:yack.c        **** 				iwgflag = 0;   // Clear Interword Gap flag
 1228               	tabs	"__result:r(4,2)",64,0,0,30
 1233 0512 8093 0000 	.Lscope17:
1324:yack.c        **** d for 4+3 = 7 dots?
1325:yack.c        **** 			{
1326:yack.c        **** 				iwgflag = 0;   // Clear Interword Gap flag
1327:yack.c        **** 				return (' ');  // And return a space
1328:yack.c        **** 			}
1329:yack.c        **** 			
1330:yack.c        **** 			// Now evaluate the latch and determine what to send next
1331:yack.c        **** 			if ( volflags & (DITLATCH | DAHLATCH)) // Anything in the latch?
 1237               	content:P(10,2)",64,0,0,20
 1238               	.global	yackuser
 1240               	yackuser:
 1242 051c 0895      	.LM166:
 1243               	.LFBB18:
 1244               	/* prologue: function */
 1245               	/* frame size = 0 */
 1247               	.LM167:
 1248               		cpi r24,lo8(1)
 1249               		brne .L110
 1251               	.LM168:
 1252               		cpi r22,lo8(1)
 1253               		brne .L111
 1255               	.LM169:
 1256               		ldi r24,lo8(user1)
 1257               		ldi r25,hi8(user1)
 1258               		rcall __eerd_word_tn85
 1259               		rjmp .L116
 1260               	.L111:
 1262               	.LM170:
 1263               		cpi r22,lo8(2)
 1264               		brne .L113
 1266               	.LM171:
 1267               		ldi r24,lo8(user2)
 1268               		ldi r25,hi8(user2)
 1269               		rcall __eerd_word_tn85
 1270               	.L116:
 1271               		movw r18,r24
 1272               		rjmp .L112
 1273               	.L110:
 1275 051e 8130      	.LM172:
 1276 0520 01F4      		cpi r24,lo8(2)
 1277               		brne .L113
 1279 0522 6130      	.LM173:
 1280 0524 01F4      		cpi r22,lo8(1)
 1281               		brne .L114
 1283 0526 80E0      	.LM174:
 1284 0528 90E0      		ldi r24,lo8(user1)
 1285 052a 00D0      		ldi r25,hi8(user1)
 1286 052c 00C0      		rjmp .L117
 1287               	.L114:
 1289               	.LM175:
 1290 052e 6230      		cpi r22,lo8(2)
 1291 0530 01F4      		brne .L113
 1293               	.LM176:
 1294 0532 80E0      		ldi r24,lo8(user2)
 1295 0534 90E0      		ldi r25,hi8(user2)
 1296 0536 00D0      	.L117:
 1297               		movw r22,r20
 1298 0538 9C01      		rcall __eewr_word_tn85
 1299 053a 00C0      	.L113:
 1300               		ldi r18,lo8(0)
 1301               		ldi r19,hi8(0)
 1302               	.L112:
 1304 053e 01F4      	.LM177:
 1305               		movw r24,r18
 1306               	/* epilogue start */
 1307 0540 6130      		ret
 1309               	.Lscope18:
 1311 0544 80E0      	.global	yacksave
 1313 0548 00C0      	yacksave:
 1315               	.LM178:
 1316               	.LFBB19:
 1317 054a 6230      	/* prologue: function */
 1318 054c 01F4      	/* frame size = 0 */
 1320               	.LM179:
 1321 054e 80E0      		lds r24,volflags
 1322 0550 90E0      		sbrs r24,2
 1323               		rjmp .L120
 1325 0554 00D0      	.LM180:
 1326               		ldi r24,lo8(magic)
 1327 0556 20E0      		ldi r25,hi8(magic)
 1328 0558 30E0      		ldi r22,lo8(-91)
 1329               		rcall __eewr_byte_tn85
 1331               	.LM181:
 1332 055a C901      		lds r22,ctcvalue
 1333               		lds r23,(ctcvalue)+1
 1334 055c 0895      		ldi r24,lo8(ctcstor)
 1335               		ldi r25,hi8(ctcstor)
 1336               		rcall __eewr_word_tn85
 1338               	.LM182:
 1339               		ldi r24,lo8(wpmstor)
 1340               		ldi r25,hi8(wpmstor)
 1341               		lds r22,wpm
 1342               		rcall __eewr_byte_tn85
 1344               	.LM183:
 1345               		ldi r24,lo8(flagstor)
 1346               		ldi r25,hi8(flagstor)
 1347               		lds r22,yackflags
 1348 055e 8091 0000 		rcall __eewr_byte_tn85
 1350 0564 00C0      	.LM184:
 1351               		ldi r24,lo8(fwstor)
 1352               		ldi r25,hi8(fwstor)
 1353 0566 80E0      		lds r22,farnsworth
 1354 0568 90E0      		rcall __eewr_byte_tn85
 1356 056c 00D0      	.LM185:
 1357               		lds r24,volflags
 1358               		andi r24,lo8(-5)
 1359 056e 6091 0000 		sts volflags,r24
 1360 0572 7091 0000 	.L120:
 1361 0576 80E0      		ret
 1363 057a 00D0      	.Lscope19:
 1366 057c 80E0      	.global	yackctrlkey
 1368 0580 6091 0000 	yackctrlkey:
 1370               	.LM186:
 1371               	.LFBB20:
 1372 0586 80E0      		push r16
 1373 0588 90E0      		push r17
 1374 058a 6091 0000 	/* prologue: function */
 1375 058e 00D0      	/* frame size = 0 */
 1376               		mov r16,r24
 1378 0590 80E0      	.LM187:
 1379 0592 90E0      		lds r17,volflags
 1381 0598 00D0      	.LM188:
 1382               		sbic 54-32,2
 1383               		rjmp .L122
 1385 059e 8B7F      	.LM189:
 1386 05a0 8093 0000 		ori r17,lo8(8)
 1388 05a4 0895      	.LM190:
 1389               		ldi r24,lo8(1)
 1390               		rcall yackinhibit
 1391               	.LBB35:
 1392               	.LBB36:
 1393               	.LBB37:
 1394               	.LBB38:
 1396               	.Ltext1:
 1398               	.LM191:
 1399 05a6 0F93      		ldi r24,lo8(12500)
 1400 05a8 1F93      		ldi r25,hi8(12500)
 1401               	/* #APP */
 1402               	 ;  105 "d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h" 1
 1403 05aa 082F      		1: sbiw r24,1
 1404               		brne 1b
 1405               	 ;  0 "" 2
 1406 05ac 1091 0000 	/* #NOAPP */
 1407               		rjmp .L130
 1408               	.L125:
 1409 05b0 B299      	.LBE38:
 1410 05b2 00C0      	.LBE37:
 1411               	.LBE36:
 1412               	.LBE35:
 1414               	.Ltext2:
 1416 05b6 81E0      	.LM192:
 1417 05b8 00D0      		sbic 54-32,3
 1418               		rjmp .L124
 1420               	.LM193:
 1421               		ldi r24,lo8(2)
 1422               		ldi r22,lo8(0)
 1423               		rcall yackspeed
   1:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** /* Copyright (c) 2002, Marek Michalkiewicz
   2:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****    Copyright (c) 2007 Joerg Wunsch
   3:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****    All rights reserved.
   4:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
   5:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****    Redistribution and use in source and binary forms, with or without
   6:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****    modification, are permitted provided that the following conditions are met:
   7:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
   8:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****    * Redistributions of source code must retain the above copyright
   9:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****      notice, this list of conditions and the following disclaimer.
  10:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  11:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****    * Redistributions in binary form must reproduce the above copyright
  12:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****      notice, this list of conditions and the following disclaimer in
  13:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****      the documentation and/or other materials provided with the
  14:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****      distribution.
  15:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  16:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****    * Neither the name of the copyright holders nor the names of
  17:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****      contributors may be used to endorse or promote products derived
  18:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****      from this software without specific prior written permission.
  19:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  20:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****   POSSIBILITY OF SUCH DAMAGE. */
  31:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  32:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** /* $Id: delay_basic.h,v 1.1 2007/05/13 21:23:20 joerg_wunsch Exp $ */
  33:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  34:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** #ifndef _UTIL_DELAY_BASIC_H_
  35:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** #define _UTIL_DELAY_BASIC_H_ 1
  36:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  37:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** #include <inttypes.h>
  38:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  39:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** /** \file */
  40:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** /** \defgroup util_delay_basic <util/delay_basic.h>: Basic busy-wait delay loops
  41:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     \code
  42:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     #include <util/delay_basic.h>
  43:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     \endcode
  44:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  45:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     The functions in this header file implement simple delay loops
  46:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     that perform a busy-waiting.  They are typically used to
  47:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     facilitate short delays in the program execution.  They are
  48:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     implemented as count-down loops with a well-known CPU cycle
  49:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     count per loop iteration.  As such, no other processing can
  50:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     occur simultaneously.  It should be kept in mind that the
  51:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     functions described here do not disable interrupts.
  52:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  53:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     In general, for long delays, the use of hardware timers is
  54:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     much preferrable, as they free the CPU, and allow for
  55:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     concurrent processing of other events while the timer is
  56:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     running.  However, in particular for very short delays, the
  57:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     overhead of setting up a hardware timer is too much compared
  58:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     to the overall delay time.
  59:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  60:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     Two inline functions are provided for the actual delay algorithms.
  61:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  62:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** */
  63:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  64:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** #if !defined(__DOXYGEN__)
  65:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** static inline void _delay_loop_1(uint8_t __count) __attribute__((always_inline));
  66:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** static inline void _delay_loop_2(uint16_t __count) __attribute__((always_inline));
  67:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** #endif
  68:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  69:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** /** \ingroup util_delay_basic
  70:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  71:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     Delay loop using an 8-bit counter \c __count, so up to 256
  72:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     iterations are possible.  (The value 256 would have to be passed
  73:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     as 0.)  The loop executes three CPU cycles per iteration, not
  74:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     including the overhead the compiler needs to setup the counter
  75:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     register.
  76:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  77:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     Thus, at a CPU speed of 1 MHz, delays of up to 768 microseconds
  78:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     can be achieved.
  79:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** */
  80:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** void
  81:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** _delay_loop_1(uint8_t __count)
  82:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** {
  83:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 	__asm__ volatile (
  84:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 		"1: dec %0" "\n\t"
  85:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 		"brne 1b"
  86:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 		: "=r" (__count)
  87:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 		: "0" (__count)
  88:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 	);
  89:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** }
  90:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  91:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** /** \ingroup util_delay_basic
  92:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  93:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     Delay loop using a 16-bit counter \c __count, so up to 65536
  94:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     iterations are possible.  (The value 65536 would have to be
  95:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     passed as 0.)  The loop executes four CPU cycles per iteration,
  96:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     not including the overhead the compiler requires to setup the
  97:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     counter register pair.
  98:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 
  99:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     Thus, at a CPU speed of 1 MHz, delays of up to about 262.1
 100:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****     milliseconds can be achieved.
 101:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h ****  */
 102:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** void
 103:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** _delay_loop_2(uint16_t __count)
 104:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** {
 105:d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h **** 	__asm__ volatile (
 1424               		ldi r22,lo8(0)
 1425               		rcall yackspeed
 1427 05bc 90E3      	.LM197:
 1428               		andi r17,lo8(-9)
 1429               	.L130:
 1431 05c0 01F4      	.LM198:
 1432               		sbis 54-32,2
 1433               		rjmp .L125
 1434 05c2 00C0      	.LBB39:
 1435               	.LBB40:
 1436               	.LBB41:
 1437               	.LBB42:
 1439               	.Ltext3:
 1441               	.LM199:
 1442               		ldi r24,lo8(12500)
 1443               		ldi r25,hi8(12500)
 1444 05c4 B399      	/* #APP */
 1445 05c6 00C0      	 ;  105 "d:/applications/winavr/lib/gcc/../../avr/include/util/delay_basic.h" 1
 1446               		1: sbiw r24,1
 1447               		brne 1b
 1448 05c8 82E0      	 ;  0 "" 2
 1449 05ca 60E0      	/* #NOAPP */
 1450 05cc 00D0      	.LBE42:
 1451               	.LBE41:
 1452               	.LBE40:
 1453 05ce 177F      	.LBE39:
 1455               	.Ltext4:
 1457 05d0 B499      	.LM200:
 1458 05d2 00C0      		rcall yacksave
 1459               	.L122:
 1461 05d4 81E0      	.LM201:
 1462 05d6 60E0      		sts volflags,r17
 1464               	.LM202:
 1465               		cpi r16,lo8(1)
 1466 05da 177F      		brne .L126
 1468               	.LM203:
 1469               		mov r24,r17
 1470 05dc B29B      		andi r24,lo8(-9)
 1471 05de 00C0      		sts volflags,r24
 1472               	.L126:
 1473               		mov r24,r17
 1474               		ldi r25,lo8(0)
 1475               		ldi r20,3
 1476               	1:	lsr r25
 1477               		ror r24
 1478               		dec r20
 1479               		brne 1b
 1481 05e2 90E3      	.LM204:
 1482               		andi r24,lo8(1)
 1483               	/* epilogue start */
 1484 05e4 0197      		pop r17
 1485 05e6 01F4      		pop r16
 1486               		ret
 1491               	.Lscope20:
 1494               	.global	yackchar
 1496 05e8 00D0      	yackchar:
 1498               	.LM205:
 1499               	.LFBB21:
 1500 05ea 1093 0000 		push r17
 1501               	/* prologue: function */
 1502               	/* frame size = 0 */
 1503 05ee 0130      		mov r18,r24
 1505               	.LM206:
 1506               		subi r24,lo8(-(-48))
 1507 05f2 812F      		cpi r24,lo8(10)
 1508 05f4 877F      		brlo .L132
 1509 05f6 8093 0000 		ldi r17,lo8(-128)
 1510               		rjmp .L133
 1511 05fa 812F      	.L132:
 1512 05fc 90E0      	.LBB43:
 1514 0600 9695      	.LM207:
 1515 0602 8795      		mov r30,r18
 1516 0604 4A95      		ldi r31,lo8(0)
 1517 0606 01F4      		subi r30,lo8(-(morse-48))
 1518               		sbci r31,hi8(-(morse-48))
 1519               	/* #APP */
 1520 0608 8170      	 ;  799 "yack.c" 1
 1521               		lpm r17, Z
 1522 060a 1F91      		
 1523 060c 0F91      	 ;  0 "" 2
 1524 060e 0895      	/* #NOAPP */
 1525               	.L133:
 1526               	.LBE43:
 1528               	.LM208:
 1529               		mov r24,r18
 1530               		subi r24,lo8(-(-97))
 1531               		cpi r24,lo8(26)
 1532               		brsh .L134
 1533               	.LBB44:
 1535               	.LM209:
 1536               		mov r30,r18
 1537               		ldi r31,lo8(0)
 1538 0610 1F93      		subi r30,lo8(-(morse-87))
 1539               		sbci r31,hi8(-(morse-87))
 1540               	/* #APP */
 1541 0612 282F      	 ;  802 "yack.c" 1
 1542               		lpm r17, Z
 1543               		
 1544 0614 8053      	 ;  0 "" 2
 1545 0616 8A30      	/* #NOAPP */
 1546 0618 00F0      	.L134:
 1547 061a 10E8      	.LBE44:
 1549               	.LM210:
 1550               		mov r24,r18
 1551               		subi r24,lo8(-(-65))
 1552               		cpi r24,lo8(26)
 1553 061e E22F      		brsh .L135
 1554 0620 F0E0      	.LBB45:
 1556 0624 F040      	.LM211:
 1557               		mov r30,r18
 1558               		ldi r31,lo8(0)
 1559 0626 1491      		subi r30,lo8(-(morse-55))
 1560               		sbci r31,hi8(-(morse-55))
 1561               	/* #APP */
 1562               	 ;  805 "yack.c" 1
 1563               		lpm r17, Z
 1564               		
 1565               	 ;  0 "" 2
 1566               	/* #NOAPP */
 1567 0628 822F      	.L135:
 1568 062a 8156      		ldi r24,lo8(0)
 1569 062c 8A31      		ldi r25,hi8(0)
 1570 062e 00F4      	.L137:
 1571               	.LBE45:
 1572               	.LBB46:
 1574 0630 E22F      	.LM212:
 1575 0632 F0E0      		movw r30,r24
 1576 0634 E050      		subi r30,lo8(-(spechar))
 1577 0636 F040      		sbci r31,hi8(-(spechar))
 1578               	/* #APP */
 1579               	 ;  811 "yack.c" 1
 1580 0638 1491      		lpm r30, Z
 1581               		
 1582               	 ;  0 "" 2
 1583               	/* #NOAPP */
 1584               	.LBE46:
 1585               		cp r18,r30
 1586               		brne .L136
 1587               	.LBB47:
 1589 063c 8154      	.LM213:
 1590 063e 8A31      		movw r30,r24
 1591 0640 00F4      		subi r30,lo8(-(morse+36))
 1592               		sbci r31,hi8(-(morse+36))
 1593               	/* #APP */
 1594               	 ;  812 "yack.c" 1
 1595 0642 E22F      		lpm r17, Z
 1596 0644 F0E0      		
 1597 0646 E050      	 ;  0 "" 2
 1598 0648 F040      	/* #NOAPP */
 1599               	.L136:
 1600               		adiw r24,1
 1601 064a 1491      	.LBE47:
 1603               	.LM214:
 1604               		cpi r24,24
 1605               		cpc r25,__zero_reg__
 1606 064c 80E0      		brne .L137
 1608               	.LM215:
 1609               		cpi r18,lo8(32)
 1610               		brne .L145
 1612               	.LM216:
 1613 0650 FC01      		ldi r24,lo8(4)
 1614 0652 E050      		rcall yackdelay
 1615 0654 F040      		rjmp .L143
 1616               	.L142:
 1618 0656 E491      	.LM217:
 1619               		ldi r24,lo8(0)
 1620               		rcall yackctrlkey
 1621               		tst r24
 1622               		brne .L143
 1624 065a 01F4      	.LM218:
 1625               		sbrs r17,7
 1626               		rjmp .L140
 1628 065c FC01      	.LM219:
 1629 065e E050      		ldi r24,lo8(2)
 1630 0660 F040      		rjmp .L146
 1631               	.L140:
 1633 0662 1491      	.LM220:
 1634               		ldi r24,lo8(1)
 1635               	.L146:
 1636               		rcall yackplay
 1638 0664 0196      	.LM221:
 1639               		ldi r24,lo8(1)
 1640               		rcall yackdelay
 1642 0666 8831      	.LM222:
 1643 0668 9105      		lsl r17
 1644 066a 01F4      	.L145:
 1646               	.LM223:
 1647 066c 2032      		cpi r17,lo8(-128)
 1648 066e 01F4      		brne .L142
 1650               	.LM224:
 1651 0670 84E0      		ldi r24,lo8(2)
 1652 0672 00D0      		rcall yackdelay
 1654               	.LM225:
 1655               		rcall yackfarns
 1656               	.L143:
 1657 0676 80E0      	/* epilogue start */
 1659 067a 8823      	.LM226:
 1660 067c 01F4      		pop r17
 1661               		ret
 1669               	.Lscope21:
 1673               	.global	yackmessage
 1675               	yackmessage:
 1677 068a 81E0      	.LM227:
 1678 068c 00D0      	.LFBB22:
 1679               		push r12
 1680               		push r13
 1681 068e 110F      		push r14
 1682               		push r15
 1683               		push r16
 1684               		push r17
 1685 0690 1038      		push r29
 1686 0692 01F4      		push r28
 1687               		in r28,__SP_L__
 1688               		in r29,__SP_H__
 1689 0694 82E0      		subi r28,lo8(-(-100))
 1690 0696 00D0      		sbci r29,hi8(-(-100))
 1691               		in __tmp_reg__,__SREG__
 1692               		cli
 1693 0698 00D0      		out __SP_H__,r29
 1694               		out __SREG__,__tmp_reg__
 1695               		out __SP_L__,r28
 1696               	/* prologue: function */
 1697               	/* frame size = 100 */
 1698 069a 1F91      		mov r16,r22
 1700               	.LM228:
 1701               		cpi r24,lo8(1)
 1702               		breq .+2
 1703               		rjmp .L148
 1704               		ldi r22,lo8(1000)
 1705               		mov r14,r22
 1706               		ldi r22,hi8(1000)
 1707               		mov r15,r22
 1708               		ldi r17,lo8(0)
 1710               	.LM229:
 1711               		movw r12,r28
 1712               		sec
 1713               		adc r12,__zero_reg__
 1714               		adc r13,__zero_reg__
 1715               	.L153:
 1717 069e CF92      	.LM230:
 1718 06a0 DF92      		ldi r24,lo8(1)
 1719 06a2 EF92      		rcall yackctrlkey
 1720 06a4 FF92      		tst r24
 1721 06a6 0F93      		breq .+2
 1722 06a8 1F93      		rjmp .L164
 1724 06ac CF93      	.LM231:
 1725 06ae CDB7      		ldi r24,lo8(1)
 1726 06b0 DEB7      		rcall yackiambic
 1727 06b2 C456      		tst r24
 1728 06b4 D040      		brne .L150
 1730 06b8 F894      	.LM232:
 1731 06ba DEBF      		sec
 1732 06bc 0FBE      		sbc r14,__zero_reg__
 1733 06be CDBF      		sbc r15,__zero_reg__
 1734               		rjmp .L151
 1735               	.L150:
 1737               	.LM233:
 1738               		movw r30,r12
 1739 06c2 8130      		add r30,r17
 1740 06c4 01F0      		adc r31,__zero_reg__
 1741 06c6 00C0      		st Z,r24
 1742 06c8 68EE      		subi r17,lo8(-(1))
 1743 06ca E62E      		ldi r21,lo8(1000)
 1744 06cc 63E0      		mov r14,r21
 1745 06ce F62E      		ldi r21,hi8(1000)
 1746 06d0 10E0      		mov r15,r21
 1747               	.L151:
 1749 06d2 6E01      	.LM234:
 1750 06d4 0894      		cpi r17,lo8(100)
 1751 06d6 C11C      		brlo .L165
 1753               	.LM235:
 1754               		rcall yackerror
 1755               		ldi r17,lo8(0)
 1756 06da 81E0      	.L165:
 1757 06dc 00D0      	.LBB48:
 1758 06de 8823      	.LBB49:
 1760 06e2 00C0      	.LM236:
 1761               		in __tmp_reg__,88-32
 1762               		sbrs __tmp_reg__,6
 1763 06e4 81E0      		rjmp .L165
 1765 06e8 8823      	.LM237:
 1766 06ea 01F4      		in r24,88-32
 1767               		ori r24,lo8(64)
 1768               		out 88-32,r24
 1769 06ec 0894      	.LBE49:
 1770 06ee E108      	.LBE48:
 1772 06f2 00C0      	.LM238:
 1773               		cp r14,__zero_reg__
 1774               		cpc r15,__zero_reg__
 1775               		brne .L153
 1777 06f6 E10F      	.LM239:
 1778 06f8 F11D      		tst r17
 1779 06fa 8083      		breq .L154
 1781 06fe 58EE      	.LM240:
 1782 0700 E52E      		subi r17,lo8(-(-1))
 1783 0702 53E0      		movw r24,r28
 1784 0704 F52E      		adiw r24,1
 1785               		movw r30,r24
 1786               		add r30,r17
 1787               		adc r31,__zero_reg__
 1788 0706 1436      		st Z,__zero_reg__
 1790               	.LM241:
 1791               		cpi r16,lo8(1)
 1792 070a 00D0      		brne .L155
 1794               	.LM242:
 1795               		ldi r22,lo8(eebuffer1)
 1796               		ldi r23,hi8(eebuffer1)
 1797               		rjmp .L169
 1798               	.L155:
 1800 0710 06FE      	.LM243:
 1801 0712 00C0      		cpi r16,lo8(2)
 1802               		brne .L156
 1804 0714 88B7      	.LM244:
 1805 0716 8064      		ldi r22,lo8(eebuffer2)
 1806 0718 88BF      		ldi r23,hi8(eebuffer2)
 1807               	.L169:
 1808               		ldi r20,lo8(100)
 1809               		ldi r21,hi8(100)
 1810               		rcall __eewr_block_tn85
 1811 071a E114      		rjmp .L164
 1812 071c F104      	.L156:
 1814               	.LM245:
 1815               		cpi r16,lo8(3)
 1816 0720 1123      		brne .L157
 1818               	.LM246:
 1819               		ldi r22,lo8(eebuffer3)
 1820 0724 1150      		ldi r23,hi8(eebuffer3)
 1821 0726 CE01      		rjmp .L169
 1822 0728 0196      	.L157:
 1824 072c E10F      	.LM247:
 1825 072e F11D      		cpi r16,lo8(4)
 1826 0730 1082      		brne .L164
 1828               	.LM248:
 1829 0732 0130      		ldi r22,lo8(eebuffer4)
 1830 0734 01F4      		ldi r23,hi8(eebuffer4)
 1831               		rjmp .L169
 1832               	.L154:
 1834 0738 70E0      	.LM249:
 1835 073a 00C0      		rcall yackerror
 1836               		rjmp .L164
 1837               	.L148:
 1839 073c 0230      	.LM250:
 1840 073e 01F4      		cpi r24,lo8(2)
 1841               		brne .L164
 1843 0740 60E0      	.LM251:
 1844 0742 70E0      		cpi r22,lo8(1)
 1845               		brne .L158
 1847 0746 50E0      	.LM252:
 1848 0748 00D0      		movw r24,r28
 1849 074a 00C0      		adiw r24,1
 1850               		ldi r22,lo8(eebuffer1)
 1851               		ldi r23,hi8(eebuffer1)
 1852               		rjmp .L168
 1853 074c 0330      	.L158:
 1855               	.LM253:
 1856               		cpi r22,lo8(2)
 1857 0750 60E0      		brne .L160
 1859 0754 00C0      	.LM254:
 1860               		movw r24,r28
 1861               		adiw r24,1
 1862               		ldi r22,lo8(eebuffer2)
 1863 0756 0430      		ldi r23,hi8(eebuffer2)
 1864 0758 01F4      		rjmp .L168
 1865               	.L160:
 1867 075a 60E0      	.LM255:
 1868 075c 70E0      		cpi r22,lo8(3)
 1869 075e 00C0      		brne .L161
 1871               	.LM256:
 1872               		movw r24,r28
 1873 0760 00D0      		adiw r24,1
 1874 0762 00C0      		ldi r22,lo8(eebuffer3)
 1875               		ldi r23,hi8(eebuffer3)
 1876               		rjmp .L168
 1877               	.L161:
 1879 0766 01F4      	.LM257:
 1880               		cpi r22,lo8(4)
 1881               		brne .L159
 1883 076a 01F4      	.LM258:
 1884               		movw r24,r28
 1885               		adiw r24,1
 1886 076c CE01      		ldi r22,lo8(eebuffer4)
 1887 076e 0196      		ldi r23,hi8(eebuffer4)
 1888 0770 60E0      	.L168:
 1889 0772 70E0      		ldi r20,lo8(100)
 1890 0774 00C0      		ldi r21,hi8(100)
 1891               		rcall __eerd_block_tn85
 1892               	.L159:
 1893               		ldi r17,lo8(0)
 1895 0778 01F4      	.LM259:
 1896               		movw r14,r28
 1897               		sec
 1898 077a CE01      		adc r14,__zero_reg__
 1899 077c 0196      		adc r15,__zero_reg__
 1900 077e 60E0      		rjmp .L162
 1901 0780 70E0      	.L163:
 1903               	.LM260:
 1904               		ldi r24,lo8(0)
 1905               		rcall yackctrlkey
 1906 0784 6330      		tst r24
 1907 0786 01F4      		brne .L164
 1909               	.LM261:
 1910 0788 CE01      		mov r24,r16
 1911 078a 0196      		rcall yackchar
 1913 078e 70E0      	.LM262:
 1914 0790 00C0      		subi r17,lo8(-(1))
 1915               	.L162:
 1916               		movw r30,r14
 1917               		add r30,r17
 1918 0792 6430      		adc r31,__zero_reg__
 1919 0794 01F4      		ld r16,Z
 1920               		tst r16
 1921               		brne .L163
 1922 0796 CE01      	.L164:
 1923 0798 0196      	/* epilogue start */
 1925 079c 70E0      	.LM263:
 1926               		subi r28,lo8(-(100))
 1927 079e 44E6      		sbci r29,hi8(-(100))
 1928 07a0 50E0      		in __tmp_reg__,__SREG__
 1929 07a2 00D0      		cli
 1930               		out __SP_H__,r29
 1931 07a4 10E0      		out __SREG__,__tmp_reg__
 1932               		out __SP_L__,r28
 1933               		pop r28
 1934 07a6 7E01      		pop r29
 1935 07a8 0894      		pop r17
 1936 07aa E11C      		pop r16
 1937 07ac F11C      		pop r15
 1938 07ae 00C0      		pop r14
 1939               		pop r13
 1940               		pop r12
 1941               		ret
 1950               	.Lscope22:
 1953               	.global	yacknumber
 1955 07c0 E10F      	yacknumber:
 1957 07c4 0081      	.LM264:
 1958 07c6 0023      	.LFBB23:
 1959 07c8 01F4      		push r14
 1960               		push r15
 1961               		push r17
 1962               		push r29
 1963               		push r28
 1964 07ca CC59      		rcall .
 1965 07cc DF4F      		rcall .
 1966 07ce 0FB6      		push __tmp_reg__
 1967 07d0 F894      		in r28,__SP_L__
 1968 07d2 DEBF      		in r29,__SP_H__
 1969 07d4 0FBE      	/* prologue: function */
 1970 07d6 CDBF      	/* frame size = 5 */
 1971 07d8 CF91      		movw r18,r24
 1973 07dc 1F91      	.LM265:
 1974 07de 0F91      		ldi r17,lo8(0)
 1976 07e2 EF90      	.LM266:
 1977 07e4 DF90      		movw r14,r28
 1978 07e6 CF90      		sec
 1979 07e8 0895      		adc r14,__zero_reg__
 1980               		adc r15,__zero_reg__
 1981               		rjmp .L171
 1982               	.L172:
 1983               		movw r30,r14
 1984               		add r30,r17
 1985               		adc r31,__zero_reg__
 1986               		movw r24,r18
 1987               		ldi r22,lo8(10)
 1988               		ldi r23,hi8(10)
 1989               		rcall __udivmodhi4
 1990               		subi r24,lo8(-(48))
 1991               		st Z,r24
 1992               		subi r17,lo8(-(1))
 1994               	.LM267:
 1995               		movw r24,r18
 1996               		ldi r22,lo8(10)
 1997 07ea EF92      		ldi r23,hi8(10)
 1998 07ec FF92      		rcall __udivmodhi4
 1999 07ee 1F93      		movw r18,r22
 2000 07f0 DF93      	.L171:
 2002 07f4 00D0      	.LM268:
 2003 07f6 00D0      		cp r18,__zero_reg__
 2004 07f8 0F92      		cpc r19,__zero_reg__
 2005 07fa CDB7      		brne .L172
 2006 07fc DEB7      		rjmp .L179
 2007               	.L175:
 2009 07fe 9C01      	.LM269:
 2010               		ldi r24,lo8(1)
 2011               		rcall yackctrlkey
 2012 0800 10E0      		tst r24
 2013               		brne .L174
 2015 0802 7E01      	.LM270:
 2016 0804 0894      		subi r17,lo8(-(-1))
 2017 0806 E11C      		movw r30,r14
 2018 0808 F11C      		add r30,r17
 2019 080a 00C0      		adc r31,__zero_reg__
 2020               		ld r24,Z
 2021 080c F701      		rcall yackchar
 2022 080e E10F      		rjmp .L178
 2023 0810 F11D      	.L179:
 2024 0812 C901      		movw r14,r28
 2025 0814 6AE0      		sec
 2026 0816 70E0      		adc r14,__zero_reg__
 2027 0818 00D0      		adc r15,__zero_reg__
 2028 081a 805D      	.L178:
 2030 081e 1F5F      	.LM271:
 2031               		tst r17
 2032               		brne .L175
 2033 0820 C901      	.L174:
 2035 0824 70E0      	.LM272:
 2036 0826 00D0      		ldi r24,lo8(32)
 2037 0828 9B01      		rcall yackchar
 2038               	/* epilogue start */
 2040               	.LM273:
 2041 082a 2115      		pop __tmp_reg__
 2042 082c 3105      		pop __tmp_reg__
 2043 082e 01F4      		pop __tmp_reg__
 2044 0830 00C0      		pop __tmp_reg__
 2045               		pop __tmp_reg__
 2046               		pop r28
 2047               		pop r29
 2048 0832 81E0      		pop r17
 2049 0834 00D0      		pop r15
 2050 0836 8823      		pop r14
 2051 0838 01F4      		ret
 2057 0840 F11D      	.Lscope23:
 2060 0846 00C0      	.global	yackstring
 2062 0848 7E01      	yackstring:
 2064 084c E11C      	.LM274:
 2065 084e F11C      	.LFBB24:
 2066               		push r17
 2067               		push r28
 2068               		push r29
 2069 0850 1123      	/* prologue: function */
 2070 0852 01F4      	/* frame size = 0 */
 2071               		movw r28,r24
 2072               		rjmp .L181
 2073               	.L183:
 2075 0856 00D0      	.LM275:
 2076               		mov r24,r17
 2077               		rcall yackchar
 2078               	.L181:
 2079 0858 0F90      		movw r30,r28
 2080 085a 0F90      	.LBB50:
 2082 085e 0F90      	.LM276:
 2083 0860 0F90      		adiw r28,1
 2084 0862 CF91      	/* #APP */
 2085 0864 DF91      	 ;  857 "yack.c" 1
 2086 0866 1F91      		lpm r17, Z
 2087 0868 FF90      		
 2088 086a EF90      	 ;  0 "" 2
 2089 086c 0895      	/* #NOAPP */
 2090               	.LBE50:
 2091               		tst r17
 2092               		breq .L184
 2093               		ldi r24,lo8(1)
 2094               		rcall yackctrlkey
 2095               		tst r24
 2096               		breq .L183
 2097               	.L184:
 2098               	/* epilogue start */
 2100               	.LM277:
 2101               		pop r29
 2102               		pop r28
 2103               		pop r17
 2104 086e 1F93      		ret
 2110 0876 00C0      	.Lscope24:
 2112               	.global	yacktune
 2114 0878 812F      	yacktune:
 2116               	.LM278:
 2117 087c FE01      	.LFBB25:
 2118               		push r28
 2119               		push r29
 2120               	/* prologue: function */
 2121 087e 2196      	/* frame size = 0 */
 2123               	.LM279:
 2124 0880 1491      		ldi r24,lo8(2)
 2125               		rcall key
 2126               		ldi r28,lo8(4000)
 2127               		ldi r29,hi8(4000)
 2128               		rjmp .L186
 2129 0882 1123      	.L189:
 2131 0886 81E0      	.LM280:
 2132 0888 00D0      		sbiw r28,1
 2133 088a 8823      	.L187:
 2134 088c 01F0      	.LBB51:
 2135               	.LBB52:
 2137               	.LM281:
 2138               		in __tmp_reg__,88-32
 2139 088e DF91      		sbrs __tmp_reg__,6
 2140 0890 CF91      		rjmp .L187
 2142 0894 0895      	.LM282:
 2143               		in r24,88-32
 2144               		ori r24,lo8(64)
 2145               		out 88-32,r24
 2146               	.LBE52:
 2147               	.LBE51:
 2149               	.LM283:
 2150               		sbiw r28,0
 2151               		breq .L188
 2152               	.L186:
 2153               		sbis 54-32,3
 2154               		rjmp .L188
 2155               		sbis 54-32,4
 2156 0896 CF93      		rjmp .L188
 2157 0898 DF93      		ldi r24,lo8(1)
 2158               		rcall yackctrlkey
 2159               		tst r24
 2160               		breq .L189
 2161               	.L188:
 2163 089c 00D0      	.LM284:
 2164 089e C0EA      		ldi r24,lo8(1)
 2165 08a0 DFE0      		rcall key
 2166 08a2 00C0      	/* epilogue start */
 2168               	.LM285:
 2169               		pop r29
 2170 08a4 2197      		pop r28
 2171               		ret
 2176 08a6 08B6      	.Lscope25:
 2178 08aa 00C0      	.global	yackreset
 2180               	yackreset:
 2182 08ae 8064      	.LM286:
 2183 08b0 88BF      	.LFBB26:
 2184               	/* prologue: function */
 2185               	/* frame size = 0 */
 2187               	.LM287:
 2188 08b2 2097      		ldi r24,lo8(77)
 2189 08b4 01F0      		ldi r25,hi8(77)
 2190               		sts (ctcvalue)+1,r25
 2191 08b6 B39B      		sts ctcvalue,r24
 2193 08ba B49B      	.LM288:
 2194 08bc 00C0      		ldi r24,lo8(15)
 2195 08be 81E0      		sts wpm,r24
 2197 08c2 8823      	.LM289:
 2198 08c4 01F0      		ldi r24,lo8(16)
 2199               		ldi r25,hi8(16)
 2200               		sts (wpmcnt)+1,r25
 2201               		sts wpmcnt,r24
 2203 08c8 00D0      	.LM290:
 2204               		sts farnsworth,__zero_reg__
 2206               	.LM291:
 2207 08ca DF91      		ldi r24,lo8(52)
 2208 08cc CF91      		sts yackflags,r24
 2210               	.LM292:
 2211               		lds r24,volflags
 2212               		ori r24,lo8(4)
 2213               		sts volflags,r24
 2215               	.LM293:
 2216               		rcall yacksave
 2217               	/* epilogue start */
 2219               	.LM294:
 2220               		ret
 2222               	.Lscope26:
 2224               	.global	yackinit
 2226 08d0 8DE4      	yackinit:
 2228 08d4 9093 0000 	.LM295:
 2229 08d8 8093 0000 	.LFBB27:
 2230               	/* prologue: function */
 2231               	/* frame size = 0 */
 2233 08de 8093 0000 	.LM296:
 2234               		sbi 55-32,0
 2236 08e2 80E1      	.LM297:
 2237 08e4 90E0      		sbi 55-32,1
 2239 08ea 8093 0000 	.LM298:
 2240               		sbi 56-32,3
 2242 08ee 1092 0000 	.LM299:
 2243               		sbi 56-32,4
 2245 08f2 84E3      	.LM300:
 2246 08f4 8093 0000 		sbi 56-32,2
 2248               	.LM301:
 2249 08f8 8091 0000 		ldi r24,lo8(magic)
 2250 08fc 8460      		ldi r25,hi8(magic)
 2251 08fe 8093 0000 		rcall __eerd_byte_tn85
 2253               	.LM302:
 2254 0902 00D0      		cpi r24,lo8(-91)
 2255               		brne .L195
 2257               	.LM303:
 2258 0904 0895      		ldi r24,lo8(ctcstor)
 2259               		ldi r25,hi8(ctcstor)
 2260               		rcall __eerd_word_tn85
 2261               		sts (ctcvalue)+1,r25
 2262               		sts ctcvalue,r24
 2264               	.LM304:
 2265               		ldi r24,lo8(wpmstor)
 2266               		ldi r25,hi8(wpmstor)
 2267               		rcall __eerd_byte_tn85
 2268               		mov r22,r24
 2269               		sts wpm,r24
 2271               	.LM305:
 2272 0906 B89A      		ldi r24,lo8(240)
 2273               		ldi r25,hi8(240)
 2274               		ldi r23,lo8(0)
 2275 0908 B99A      		rcall __divmodhi4
 2276               		sts (wpmcnt)+1,r23
 2277               		sts wpmcnt,r22
 2279               	.LM306:
 2280               		ldi r24,lo8(fwstor)
 2281 090c C49A      		ldi r25,hi8(fwstor)
 2282               		rcall __eerd_byte_tn85
 2283               		sts farnsworth,r24
 2285               	.LM307:
 2286               		ldi r24,lo8(flagstor)
 2287 0910 80E0      		ldi r25,hi8(flagstor)
 2288 0912 90E0      		rcall __eerd_byte_tn85
 2289 0914 00D0      		sts yackflags,r24
 2290               		rjmp .L196
 2291               	.L195:
 2293 0918 01F4      	.LM308:
 2294               		rcall yackreset
 2295               	.L196:
 2297 091c 90E0      	.LM309:
 2298 091e 00D0      		ldi r24,lo8(0)
 2299 0920 9093 0000 		rcall yackinhibit
 2301               	.LM310:
 2302               		in r24,53-32
 2303 0928 80E0      		ori r24,lo8(28)
 2304 092a 90E0      		out 53-32,r24
 2306 092e 682F      	.LM311:
 2307 0930 8093 0000 		in r24,91-32
 2308               		ori r24,lo8(32)
 2309               		out 91-32,r24
 2311 0936 90E0      	.LM312:
 2312 0938 70E0      		ldi r24,lo8(78)
 2313 093a 00D0      		out 77-32,r24
 2315 0940 6093 0000 	.LM313:
 2316               		in r24,80-32
 2317               		ori r24,lo8(-121)
 2318 0944 80E0      		out 80-32,r24
 2320 0948 00D0      	.LM314:
 2321 094a 8093 0000 		ldi r24,lo8(1)
 2322               		out 78-32,r24
 2323               	/* epilogue start */
 2325 0950 90E0      	.LM315:
 2326 0952 00D0      		ret
 2328 0958 00C0      	.Lscope27:
 2329               	.global	magic
 2330               		.section	.eeprom,"aw",@progbits
 2333               	magic:
 2334               		.byte	-91
 2335               	.global	flagstor
 2338               	flagstor:
 2339               		.byte	52
 2340 0960 85B3      	.global	ctcstor
 2343               	ctcstor:
 2344               		.word	77
 2345 0966 8BB7      	.global	wpmstor
 2348               	wpmstor:
 2349               		.byte	15
 2350 096c 8EE4      	.global	fwstor
 2353               	fwstor:
 2354 0970 80B7      		.skip 1,0
 2355 0972 8768      	.global	user1
 2358               	user1:
 2359 0976 81E0      		.skip 2,0
 2360 0978 8EBD      	.global	user2
 2363               	user2:
 2364 097a 0895      		.skip 2,0
 2365               	.global	eebuffer1
 2368               	eebuffer1:
 2369               		.string	"message 1"
 2370               		.skip 90,0
 2371               	.global	eebuffer2
 2374               	eebuffer2:
 2375               		.string	"message 2"
 2376               		.skip 90,0
 2377 0001 34        	.global	eebuffer3
 2380               	eebuffer3:
 2381               		.string	"message 3"
 2382 0002 4D00      		.skip 90,0
 2383               	.global	eebuffer4
 2386               	eebuffer4:
 2387 0004 0F        		.string	"message 4"
 2388               		.skip 90,0
 2389               	.global	morse
 2390               		.section	.progmem.data,"a",@progbits
 2393               	morse:
 2394               		.byte	-4
 2395               		.byte	124
 2396               		.byte	60
 2397 0006 0000      		.byte	28
 2398               		.byte	12
 2399               		.byte	4
 2400               		.byte	-124
 2401               		.byte	-60
 2402 0008 0000      		.byte	-28
 2403               		.byte	-12
 2404               		.byte	96
 2405               		.byte	-120
 2406               		.byte	-88
 2407 000a 6D65 7373 		.byte	-112
 2407      6167 6520 
 2407      3100 
 2408 0014 0000 0000 		.byte	64
 2408      0000 0000 
 2408      0000 0000 
 2408      0000 0000 
 2408      0000 0000 
 2409               		.byte	40
 2410               		.byte	-48
 2411               		.byte	8
 2412               		.byte	32
 2413 006e 6D65 7373 		.byte	120
 2413      6167 6520 
 2413      3200 
 2414 0078 0000 0000 		.byte	-80
 2414      0000 0000 
 2414      0000 0000 
 2414      0000 0000 
 2414      0000 0000 
 2415               		.byte	72
 2416               		.byte	-32
 2417               		.byte	-96
 2418               		.byte	-16
 2419 00d2 6D65 7373 		.byte	104
 2419      6167 6520 
 2419      3300 
 2420 00dc 0000 0000 		.byte	-40
 2420      0000 0000 
 2420      0000 0000 
 2420      0000 0000 
 2420      0000 0000 
 2421               		.byte	80
 2422               		.byte	16
 2423               		.byte	-64
 2424               		.byte	48
 2425 0136 6D65 7373 		.byte	24
 2425      6167 6520 
 2425      3400 
 2426 0140 0000 0000 		.byte	112
 2426      0000 0000 
 2426      0000 0000 
 2426      0000 0000 
 2426      0000 0000 
 2427               		.byte	-104
 2428               		.byte	-72
 2429               		.byte	-56
 2430               		.byte	50
 2431               		.byte	86
 2432 0000 FC        		.byte	-108
 2433 0001 7C        		.byte	-24
 2434 0002 3C        		.byte	-50
 2435 0003 1C        		.byte	-30
 2436 0004 0C        		.byte	-86
 2437 0005 04        		.byte	74
 2438 0006 84        		.byte	19
 2439 0007 C4        		.byte	122
 2440 0008 E4        		.byte	-76
 2441 0009 F4        		.byte	-74
 2442 000a 60        		.byte	-122
 2443 000b 88        		.byte	106
 2444 000c A8        		.byte	54
 2445 000d 90        		.byte	82
 2446 000e 40        		.byte	-116
 2447 000f 28        		.byte	22
 2448 0010 D0        		.byte	84
 2449 0011 08        		.byte	-117
 2450 0012 20        		.byte	68
 2451 0013 78        		.byte	-84
 2452 0014 B0        		.byte	20
 2453 0015 48        		.byte	88
 2454 0016 E0        	.global	spechar
 2457 0019 68        	spechar:
 2458 001a D8        		.ascii	"?./!,:;~$^()-@_|=#+*%&<>"
 2459 001b 50        		.lcomm volflags,1
 2460 001c 10        		.lcomm ultimem.1874,1
 2461 001d C0        		.lcomm iwgflag.1873,1
 2462 001e 30        		.lcomm bcntr.1872,1
 2463 001f 18        		.lcomm buffer.1871,1
 2464 0020 70        		.lcomm lastsymbol.1870,1
 2465 0021 98        		.lcomm timer.1869,2
 2466 0022 B8        		.lcomm fsms.1868,1
 2467 0023 C8        		.lcomm shdntimer.1529,4
 2468 0024 32        		.lcomm yackflags,1
 2469 0025 56        		.lcomm ctcvalue,2
 2470 0026 94        		.lcomm wpmcnt,2
 2471 0027 E8        		.lcomm wpm,1
 2472 0028 CE        		.lcomm farnsworth,1
 2500               		.text
 2502               	.Letext0:
 2503               	.global __do_clear_bss
 2504               	...
DEFINED SYMBOLS
                            *ABS*:00000000 yack.c
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2      *ABS*:0000003f __SREG__
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:3      *ABS*:0000003e __SP_H__
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:4      *ABS*:0000003d __SP_L__
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:5      *ABS*:00000034 __CCP__
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:6      *ABS*:00000000 __tmp_reg__
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:7      *ABS*:00000001 __zero_reg__
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:98     .text:00000000 __vector_2
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:123    .text:00000014 yackpower
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2504   .bss:00000009 shdntimer.1529
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:224    .text:00000092 yackwpm
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2508   .bss:00000012 wpm
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:241    .text:0000009a yackbeat
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:268    .text:000000a8 yackpitch
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2506   .bss:0000000e ctcvalue
                             .bss:00000000 volflags
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:340    .text:0000010c yackmode
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2505   .bss:0000000d yackflags
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:367    .text:00000124 yackflag
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:387    .text:0000012c yacktoggle
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:412    .text:00000142 key
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:501    .text:00000196 yackinhibit
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:537    .text:000001bc yackdelay
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2507   .bss:00000010 wpmcnt
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:587    .text:000001e2 yackfarns
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2509   .bss:00000013 farnsworth
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:627    .text:00000200 yackplay
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:674    .text:00000224 yackerror
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:717    .text:0000023e yackspeed
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:820    .text:000002ba keylatch
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:874    .text:000002f2 yackiambic
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2502   .bss:00000006 timer.1869
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2498   .bss:00000002 iwgflag.1873
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2503   .bss:00000008 fsms.1868
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2501   .bss:00000005 lastsymbol.1870
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2497   .bss:00000001 ultimem.1874
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2499   .bss:00000003 bcntr.1872
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2500   .bss:00000004 buffer.1871
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2431   .progmem.data:00000000 morse
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2495   .progmem.data:0000003c spechar
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:1267   .text:0000051e yackuser
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2396   .eeprom:00000006 user1
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2401   .eeprom:00000008 user2
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:1340   .text:0000055e yacksave
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2371   .eeprom:00000000 magic
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2381   .eeprom:00000002 ctcstor
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2386   .eeprom:00000004 wpmstor
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2376   .eeprom:00000001 flagstor
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2391   .eeprom:00000005 fwstor
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:1395   .text:000005a6 yackctrlkey
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:1534   .text:00000610 yackchar
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:1713   .text:0000069e yackmessage
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2406   .eeprom:0000000a eebuffer1
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2412   .eeprom:0000006e eebuffer2
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2418   .eeprom:000000d2 eebuffer3
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2424   .eeprom:00000136 eebuffer4
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:1993   .text:000007ea yacknumber
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2100   .text:0000086e yackstring
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2152   .text:00000896 yacktune
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2218   .text:000008d0 yackreset
C:\Users\Don\AppData\Local\Temp/ccmNMTqW.s:2264   .text:00000906 yackinit

UNDEFINED SYMBOLS
__divmodhi4
__mulhi3
__eerd_word_tn85
__eewr_word_tn85
__eewr_byte_tn85
__eewr_block_tn85
__eerd_block_tn85
__udivmodhi4
__eerd_byte_tn85
__do_clear_bss