1               		.file	"spectrumanalyzer.c"
   2               		.arch at90s8515
   3               	__SREG__ = 0x3f
   4               	__SP_H__ = 0x3e
   5               	__SP_L__ = 0x3d
   6               	__tmp_reg__ = 0
   7               	__zero_reg__ = 1
   8               		.global __do_copy_data
   9               		.global __do_clear_bss
  12               		.text
  13               	.Ltext0:
 109               	.global	uartReceiveStringLong
 111               	uartReceiveStringLong:
   1:spectrumanalyzer.c **** /*
   2:spectrumanalyzer.c **** 	Technische Universität Berlin
   3:spectrumanalyzer.c **** 	Fachgebiet Elektronik
   4:spectrumanalyzer.c **** 	
   5:spectrumanalyzer.c **** 	Projekt Elektronik, Gruppe ELE31, WS2003/2004
   6:spectrumanalyzer.c **** 	Einfacher Spektrumanalysator von 0 bis 100 MHZ
   7:spectrumanalyzer.c **** 
   8:spectrumanalyzer.c **** 	Robert Elschner, André Grede, Martin Haller, 
   9:spectrumanalyzer.c ****     Leszek Koschel, Marcus Rose, Steffen Schostan, François Xavier Tchiako
  10:spectrumanalyzer.c **** 	
  11:spectrumanalyzer.c **** 	last changes: 13.02.2004
  12:spectrumanalyzer.c **** 	
  13:spectrumanalyzer.c **** 	spectrumanalyzer.c
  14:spectrumanalyzer.c ****  
  15:spectrumanalyzer.c ****     Firmware für das ATMEL 90S8515 Mikrokontroller-Board
  16:spectrumanalyzer.c **** 	zur Steuerung der Messung eines Leistungsdichtespektrum
  17:spectrumanalyzer.c **** 
  18:spectrumanalyzer.c **** 	Für die Taktfrequenz von 7,3728 MHz 
  19:spectrumanalyzer.c ****     mit 115200 bits/s als Baudrate eingestellt.
  20:spectrumanalyzer.c **** */
  21:spectrumanalyzer.c **** 
  22:spectrumanalyzer.c **** ////// INCLUDES
  23:spectrumanalyzer.c **** #include <avr/io.h>
  24:spectrumanalyzer.c **** #include <avr/interrupt.h>
  25:spectrumanalyzer.c **** #include <avr/signal.h>
  26:spectrumanalyzer.c **** #include <inttypes.h>
  27:spectrumanalyzer.c **** #include <avr/pgmspace.h>
  28:spectrumanalyzer.c **** 
  29:spectrumanalyzer.c **** // UART driver with buffer support from Pascal Stang
  30:spectrumanalyzer.c **** #include "uart.h"
  31:spectrumanalyzer.c **** // Delay routines from Chris Efstathiou
  32:spectrumanalyzer.c **** #include "delay.h"
  33:spectrumanalyzer.c **** // Functions to read values from the 2-channel 8-bit analog-digital-converter
  34:spectrumanalyzer.c **** // MAX1117/MAX1118/MAX1119 via SPI interface
  35:spectrumanalyzer.c **** #include "max1118.h"
  36:spectrumanalyzer.c **** // Functions to set the DDS (AD9851) to given frequencies
  37:spectrumanalyzer.c **** #include "dds.h"
  38:spectrumanalyzer.c **** //////
  39:spectrumanalyzer.c **** 
  40:spectrumanalyzer.c **** 
  41:spectrumanalyzer.c **** //! receives a string with the length len
  42:spectrumanalyzer.c **** void uartReceiveStringLong(char *string, u08 len)
  43:spectrumanalyzer.c **** {
 113               	.LM1:
 114               	/* prologue: frame size=5 */
 115 0000 CF93      		push r28
 116 0002 DF93      		push r29
 117 0004 CDB7      		in r28,__SP_L__
 118 0006 DEB7      		in r29,__SP_H__
 119 0008 2597      		sbiw r28,5
 120 000a 0FB6      		in __tmp_reg__,__SREG__
 121 000c F894      		cli
 122 000e DEBF      		out __SP_H__,r29
 123 0010 0FBE      		out __SREG__,__tmp_reg__
 124 0012 CDBF      		out __SP_L__,r28
 125               	/* prologue end (size=10) */
 126 0014 8983      		std Y+1,r24
 127 0016 9A83      		std Y+2,r25
 128 0018 6B83      		std Y+3,r22
  44:spectrumanalyzer.c ****     u08 i;
  45:spectrumanalyzer.c ****     u08 j;
  46:spectrumanalyzer.c ****     
  47:spectrumanalyzer.c ****     while (uartGetRxBuffer()->datalength<len);
 130               	.LM2:
 131               	.L3:
 132               	.LBB2:
 133 001a 00D0      		rcall uartGetRxBuffer
 134 001c F92F      		mov r31,r25
 135 001e E82F      		mov r30,r24
 136 0020 8B81      		ldd r24,Y+3
 137 0022 282F      		mov r18,r24
 138 0024 3327      		clr r19
 139 0026 8481      		ldd r24,Z+4
 140 0028 9581      		ldd r25,Z+5
 141 002a 8217      		cp r24,r18
 142 002c 9307      		cpc r25,r19
 143 002e A8F3      		brlo .L3
  48:spectrumanalyzer.c ****     for (j=1;j<=3; j++)
 145               	.LM3:
 146 0030 81E0      		ldi r24,lo8(1)
 147 0032 8D83      		std Y+5,r24
 148               	.L6:
 149 0034 8D81      		ldd r24,Y+5
 150 0036 8430      		cpi r24,lo8(4)
 151 0038 08F0      		brlo .L9
 152 003a 1FC0      		rjmp .L2
 153               	.L9:
  49:spectrumanalyzer.c ****         for (i=1; i<=4; i++)
 155               	.LM4:
 156 003c 81E0      		ldi r24,lo8(1)
 157 003e 8C83      		std Y+4,r24
 158               	.L10:
 159 0040 8C81      		ldd r24,Y+4
 160 0042 8530      		cpi r24,lo8(5)
 161 0044 08F0      		brlo .L13
 162 0046 15C0      		rjmp .L8
 163               	.L13:
  50:spectrumanalyzer.c ****         {
  51:spectrumanalyzer.c ****             uartReceiveByte(&string[4*j-i]);
 165               	.LM5:
 166 0048 8D81      		ldd r24,Y+5
 167 004a 9927      		clr r25
 168 004c 282F      		mov r18,r24
 169 004e 392F      		mov r19,r25
 170 0050 220F      		lsl r18
 171 0052 331F      		rol r19
 172 0054 220F      		lsl r18
 173 0056 331F      		rol r19
 174 0058 8C81      		ldd r24,Y+4
 175 005a 9927      		clr r25
 176 005c 281B      		sub r18,r24
 177 005e 390B      		sbc r19,r25
 178 0060 8981      		ldd r24,Y+1
 179 0062 9A81      		ldd r25,Y+2
 180 0064 820F      		add r24,r18
 181 0066 931F      		adc r25,r19
 182 0068 00D0      		rcall uartReceiveByte
 184               	.LM6:
 185 006a 8C81      		ldd r24,Y+4
 186 006c 8F5F      		subi r24,lo8(-(1))
 187 006e 8C83      		std Y+4,r24
 188 0070 E7CF      		rjmp .L10
 190               	.LM7:
 191               	.L8:
 192 0072 8D81      		ldd r24,Y+5
 193 0074 8F5F      		subi r24,lo8(-(1))
 194 0076 8D83      		std Y+5,r24
 195 0078 DDCF      		rjmp .L6
  52:spectrumanalyzer.c ****         }
  53:spectrumanalyzer.c **** }
 197               	.LM8:
 198               	.L2:
 199               	.LBE2:
 200               	/* epilogue: frame size=5 */
 201 007a 2596      		adiw r28,5
 202 007c 0FB6      		in __tmp_reg__,__SREG__
 203 007e F894      		cli
 204 0080 DEBF      		out __SP_H__,r29
 205 0082 0FBE      		out __SREG__,__tmp_reg__
 206 0084 CDBF      		out __SP_L__,r28
 207 0086 DF91      		pop r29
 208 0088 CF91      		pop r28
 209 008a 0895      		ret
 210               	/* epilogue end (size=9) */
 211               	/* function uartReceiveStringLong size 70 (51) */
 217               	.Lscope0:
 221               	.global	main
 223               	main:
  54:spectrumanalyzer.c **** 
  55:spectrumanalyzer.c **** 
  56:spectrumanalyzer.c **** 
  57:spectrumanalyzer.c **** int main () 
  58:spectrumanalyzer.c **** {
 225               	.LM9:
 226               	/* prologue: frame size=36 */
 227 008c C0E0      		ldi r28,lo8(__stack - 36)
 228 008e D0E0      		ldi r29,hi8(__stack - 36)
 229 0090 DEBF      		out __SP_H__,r29
 230 0092 CDBF      		out __SP_L__,r28
 231               	/* prologue end (size=4) */
  59:spectrumanalyzer.c ****     enum {WAIT, GETOPT, SWEEP};
  60:spectrumanalyzer.c ****     u08 status = WAIT;
 233               	.LM10:
 234               	.LBB3:
 235 0094 1982      		std Y+1,__zero_reg__
  61:spectrumanalyzer.c ****     u08 input[12];
  62:spectrumanalyzer.c **** 
  63:spectrumanalyzer.c **** 	u32 freqStart=0; 
 237               	.LM11:
 238 0096 1E86      		std Y+14,__zero_reg__
 239 0098 1F86      		std Y+15,__zero_reg__
 240 009a 188A      		std Y+16,__zero_reg__
 241 009c 198A      		std Y+17,__zero_reg__
  64:spectrumanalyzer.c **** 	u32 freqStop=0; 
 243               	.LM12:
 244 009e 1A8A      		std Y+18,__zero_reg__
 245 00a0 1B8A      		std Y+19,__zero_reg__
 246 00a2 1C8A      		std Y+20,__zero_reg__
 247 00a4 1D8A      		std Y+21,__zero_reg__
  65:spectrumanalyzer.c **** 	u32 freqStep=0; 
 249               	.LM13:
 250 00a6 1E8A      		std Y+22,__zero_reg__
 251 00a8 1F8A      		std Y+23,__zero_reg__
 252 00aa 188E      		std Y+24,__zero_reg__
 253 00ac 198E      		std Y+25,__zero_reg__
  66:spectrumanalyzer.c **** 
  67:spectrumanalyzer.c **** 	u32 freqCurrent = 0;
 255               	.LM14:
 256 00ae 1A8E      		std Y+26,__zero_reg__
 257 00b0 1B8E      		std Y+27,__zero_reg__
 258 00b2 1C8E      		std Y+28,__zero_reg__
 259 00b4 1D8E      		std Y+29,__zero_reg__
  68:spectrumanalyzer.c **** 	u32 counter = 0;
 261               	.LM15:
 262 00b6 1E8E      		std Y+30,__zero_reg__
 263 00b8 1F8E      		std Y+31,__zero_reg__
 264 00ba 18A2      		std Y+32,__zero_reg__
 265 00bc 19A2      		std Y+33,__zero_reg__
  69:spectrumanalyzer.c **** 	u08 firstsweep = FALSE;
 267               	.LM16:
 268 00be 1AA2      		std Y+34,__zero_reg__
  70:spectrumanalyzer.c **** 
  71:spectrumanalyzer.c **** 	////// INITIALIZATION
  72:spectrumanalyzer.c **** 
  73:spectrumanalyzer.c ****     // enable and initialize the uart
  74:spectrumanalyzer.c **** 	uartInit();
 270               	.LM17:
 271 00c0 00D0      		rcall uartInit
  75:spectrumanalyzer.c **** 	// set the uart baud rate
  76:spectrumanalyzer.c **** 	uartSetBaudRate(115200);
 273               	.LM18:
 274 00c2 60E0      		ldi r22,lo8(115200)
 275 00c4 72EC      		ldi r23,hi8(115200)
 276 00c6 81E0      		ldi r24,hlo8(115200)
 277 00c8 90E0      		ldi r25,hhi8(115200)
 278 00ca 00D0      		rcall uartSetBaudRate
  77:spectrumanalyzer.c **** 	// initializes the SPI interface
  78:spectrumanalyzer.c ****     adc_init();
 280               	.LM19:
 281 00cc 00D0      		rcall adc_init
  79:spectrumanalyzer.c ****     // initializes the DDS ports
  80:spectrumanalyzer.c **** 	dds_init();
 283               	.LM20:
 284 00ce 00D0      		rcall dds_init
  81:spectrumanalyzer.c ****     // flush all data out of the receive buffer
  82:spectrumanalyzer.c ****     uartFlushReceiveBuffer();
 286               	.LM21:
 287 00d0 00D0      		rcall uartFlushReceiveBuffer
 288               	.L15:
  83:spectrumanalyzer.c **** 
  84:spectrumanalyzer.c **** 
  85:spectrumanalyzer.c ****     ////// MAIN PROGRAM
  86:spectrumanalyzer.c **** 
  87:spectrumanalyzer.c ****     // endless loop 
  88:spectrumanalyzer.c ****     while (1) {
  89:spectrumanalyzer.c ****         switch (status) 
 290               	.LM22:
 291 00d2 8981      		ldd r24,Y+1
 292 00d4 282F      		mov r18,r24
 293 00d6 3327      		clr r19
 294 00d8 2BA3      		std Y+35,r18
 295 00da 3CA3      		std Y+36,r19
 296 00dc 8BA1      		ldd r24,Y+35
 297 00de 9CA1      		ldd r25,Y+36
 298 00e0 8130      		cpi r24,1
 299 00e2 9105      		cpc r25,__zero_reg__
 300 00e4 B9F0      		breq .L21
 301 00e6 2BA1      		ldd r18,Y+35
 302 00e8 3CA1      		ldd r19,Y+36
 303 00ea 2230      		cpi r18,2
 304 00ec 3105      		cpc r19,__zero_reg__
 305 00ee 2CF4      		brge .L30
 306 00f0 8BA1      		ldd r24,Y+35
 307 00f2 9CA1      		ldd r25,Y+36
 308 00f4 0097      		sbiw r24,0
 309 00f6 39F0      		breq .L19
 310 00f8 9BC0      		rjmp .L18
 311               	.L30:
 312 00fa 2BA1      		ldd r18,Y+35
 313 00fc 3CA1      		ldd r19,Y+36
 314 00fe 2230      		cpi r18,2
 315 0100 3105      		cpc r19,__zero_reg__
 316 0102 E9F1      		breq .L22
 317 0104 95C0      		rjmp .L18
 318               	.L19:
  90:spectrumanalyzer.c ****         {
  91:spectrumanalyzer.c **** 
  92:spectrumanalyzer.c ****             /////////
  93:spectrumanalyzer.c ****             // WAIT - Simply waits ... 
  94:spectrumanalyzer.c ****             case WAIT:       // If is a byte in the serial receive buffer, then
  95:spectrumanalyzer.c ****                              // the status will be set to GETOPT because 
  96:spectrumanalyzer.c ****                              // the MCU have to wait for further options.
  97:spectrumanalyzer.c ****                              if (uartReceiveBufferIsEmpty()==FALSE)
 320               	.LM23:
 321 0106 00D0      		rcall uartReceiveBufferIsEmpty
 322 0108 8823      		tst r24
 323 010a 09F0      		breq .+2
 324 010c 91C0      		rjmp .L18
  98:spectrumanalyzer.c ****                              {
  99:spectrumanalyzer.c ****                                  status = GETOPT;
 326               	.LM24:
 327 010e 81E0      		ldi r24,lo8(1)
 328 0110 8983      		std Y+1,r24
 100:spectrumanalyzer.c ****                              }
 101:spectrumanalyzer.c ****                              break;
 330               	.LM25:
 331 0112 8EC0      		rjmp .L18
 332               	.L21:
 102:spectrumanalyzer.c **** 
 103:spectrumanalyzer.c ****             /////////
 104:spectrumanalyzer.c ****             // GETOPT - Receives the options for one measurement cycle
 105:spectrumanalyzer.c ****             case GETOPT:     // The MCU expects three unsigned longs
 106:spectrumanalyzer.c ****                              // for start, stop and step delta phase values
 107:spectrumanalyzer.c **** 	                         uartReceiveStringLong(input,12);
 334               	.LM26:
 335 0114 8C2F      		mov r24,r28
 336 0116 9D2F      		mov r25,r29
 337 0118 0296      		adiw r24,2
 338 011a 6CE0      		ldi r22,lo8(12)
 339 011c 71DF      		rcall uartReceiveStringLong
 108:spectrumanalyzer.c **** 						
 109:spectrumanalyzer.c **** 							 memcpy(&freqStart,input,sizeof(long));
 341               	.LM27:
 342 011e 8C2F      		mov r24,r28
 343 0120 9D2F      		mov r25,r29
 344 0122 0296      		adiw r24,2
 345 0124 2C2F      		mov r18,r28
 346 0126 3D2F      		mov r19,r29
 347 0128 225F      		subi r18,lo8(-(14))
 348 012a 3F4F      		sbci r19,hi8(-(14))
 349 012c 44E0      		ldi r20,lo8(4)
 350 012e 50E0      		ldi r21,hi8(4)
 351 0130 682F      		mov r22,r24
 352 0132 792F      		mov r23,r25
 353 0134 932F      		mov r25,r19
 354 0136 822F      		mov r24,r18
 355 0138 00D0      		rcall memcpy
 110:spectrumanalyzer.c **** 							 memcpy(&freqStop,(input+4),sizeof(long));
 357               	.LM28:
 358 013a 8C2F      		mov r24,r28
 359 013c 9D2F      		mov r25,r29
 360 013e 0296      		adiw r24,2
 361 0140 0496      		adiw r24,4
 362 0142 2C2F      		mov r18,r28
 363 0144 3D2F      		mov r19,r29
 364 0146 2E5E      		subi r18,lo8(-(18))
 365 0148 3F4F      		sbci r19,hi8(-(18))
 366 014a 44E0      		ldi r20,lo8(4)
 367 014c 50E0      		ldi r21,hi8(4)
 368 014e 682F      		mov r22,r24
 369 0150 792F      		mov r23,r25
 370 0152 932F      		mov r25,r19
 371 0154 822F      		mov r24,r18
 372 0156 00D0      		rcall memcpy
 111:spectrumanalyzer.c **** 							 memcpy(&freqStep,(input+8),sizeof(long));
 374               	.LM29:
 375 0158 8C2F      		mov r24,r28
 376 015a 9D2F      		mov r25,r29
 377 015c 0296      		adiw r24,2
 378 015e 0896      		adiw r24,8
 379 0160 2C2F      		mov r18,r28
 380 0162 3D2F      		mov r19,r29
 381 0164 2A5E      		subi r18,lo8(-(22))
 382 0166 3F4F      		sbci r19,hi8(-(22))
 383 0168 44E0      		ldi r20,lo8(4)
 384 016a 50E0      		ldi r21,hi8(4)
 385 016c 682F      		mov r22,r24
 386 016e 792F      		mov r23,r25
 387 0170 932F      		mov r25,r19
 388 0172 822F      		mov r24,r18
 389 0174 00D0      		rcall memcpy
 112:spectrumanalyzer.c **** 							
 113:spectrumanalyzer.c **** 						     // Clear the receive buffer
 114:spectrumanalyzer.c **** 							 uartFlushReceiveBuffer();
 391               	.LM30:
 392 0176 00D0      		rcall uartFlushReceiveBuffer
 115:spectrumanalyzer.c **** 							
 116:spectrumanalyzer.c ****                              // Sets the status to SWEEP
 117:spectrumanalyzer.c ****                              status = SWEEP;
 394               	.LM31:
 395 0178 82E0      		ldi r24,lo8(2)
 396 017a 8983      		std Y+1,r24
 118:spectrumanalyzer.c ****                              break;
 398               	.LM32:
 399 017c 59C0      		rjmp .L18
 400               	.L22:
 119:spectrumanalyzer.c **** 
 120:spectrumanalyzer.c ****             /////////
 121:spectrumanalyzer.c ****             // SWEEP - Measures the power spectrum density for the preset 
 122:spectrumanalyzer.c ****             // frequency range
 123:spectrumanalyzer.c ****             case SWEEP:      // Puts the DDS in well defined state
 124:spectrumanalyzer.c **** 							 dds_reset();
 402               	.LM33:
 403 017e 00D0      		rcall dds_reset
 125:spectrumanalyzer.c ****                             
 126:spectrumanalyzer.c **** 							 // Does measure until the current frequency has
 127:spectrumanalyzer.c ****                              // reached the stop frequency
 128:spectrumanalyzer.c **** 							 firstsweep = TRUE;
 405               	.LM34:
 406 0180 8FEF      		ldi r24,lo8(-1)
 407 0182 8AA3      		std Y+34,r24
 129:spectrumanalyzer.c **** 							 counter=0;
 409               	.LM35:
 410 0184 1E8E      		std Y+30,__zero_reg__
 411 0186 1F8E      		std Y+31,__zero_reg__
 412 0188 18A2      		std Y+32,__zero_reg__
 413 018a 19A2      		std Y+33,__zero_reg__
 130:spectrumanalyzer.c **** 							 while ((freqCurrent < (freqStop-freqStep)) )
 415               	.LM36:
 416               	.L23:
 417 018c 2A89      		ldd r18,Y+18
 418 018e 3B89      		ldd r19,Y+19
 419 0190 4C89      		ldd r20,Y+20
 420 0192 5D89      		ldd r21,Y+21
 421 0194 8E89      		ldd r24,Y+22
 422 0196 9F89      		ldd r25,Y+23
 423 0198 A88D      		ldd r26,Y+24
 424 019a B98D      		ldd r27,Y+25
 425 019c 281B      		sub r18,r24
 426 019e 390B      		sbc r19,r25
 427 01a0 4A0B      		sbc r20,r26
 428 01a2 5B0B      		sbc r21,r27
 429 01a4 8A8D      		ldd r24,Y+26
 430 01a6 9B8D      		ldd r25,Y+27
 431 01a8 AC8D      		ldd r26,Y+28
 432 01aa BD8D      		ldd r27,Y+29
 433 01ac 8217      		cp r24,r18
 434 01ae 9307      		cpc r25,r19
 435 01b0 A407      		cpc r26,r20
 436 01b2 B507      		cpc r27,r21
 437 01b4 08F0      		brlo .L25
 438 01b6 3BC0      		rjmp .L24
 439               	.L25:
 131:spectrumanalyzer.c **** 							 {
 132:spectrumanalyzer.c **** 								 // Computes the current center frequency with the
 133:spectrumanalyzer.c ****                                  // discrete frequency step and the counter
 134:spectrumanalyzer.c **** 								 freqCurrent=(u32)freqStart + (u32)counter * (u32)freqStep;
 441               	.LM37:
 442 01b8 2E89      		ldd r18,Y+22
 443 01ba 3F89      		ldd r19,Y+23
 444 01bc 488D      		ldd r20,Y+24
 445 01be 598D      		ldd r21,Y+25
 446 01c0 6E8D      		ldd r22,Y+30
 447 01c2 7F8D      		ldd r23,Y+31
 448 01c4 88A1      		ldd r24,Y+32
 449 01c6 99A1      		ldd r25,Y+33
 450 01c8 00D0      		rcall __mulsi3
 451 01ca 262F      		mov r18,r22
 452 01cc 372F      		mov r19,r23
 453 01ce 482F      		mov r20,r24
 454 01d0 592F      		mov r21,r25
 455 01d2 8E85      		ldd r24,Y+14
 456 01d4 9F85      		ldd r25,Y+15
 457 01d6 A889      		ldd r26,Y+16
 458 01d8 B989      		ldd r27,Y+17
 459 01da 820F      		add r24,r18
 460 01dc 931F      		adc r25,r19
 461 01de A41F      		adc r26,r20
 462 01e0 B51F      		adc r27,r21
 463 01e2 8A8F      		std Y+26,r24
 464 01e4 9B8F      		std Y+27,r25
 465 01e6 AC8F      		std Y+28,r26
 466 01e8 BD8F      		std Y+29,r27
 135:spectrumanalyzer.c **** 								 counter++;
 468               	.LM38:
 469 01ea 8E8D      		ldd r24,Y+30
 470 01ec 9F8D      		ldd r25,Y+31
 471 01ee A8A1      		ldd r26,Y+32
 472 01f0 B9A1      		ldd r27,Y+33
 473 01f2 0196      		adiw r24,1
 474 01f4 A11D      		adc r26,__zero_reg__
 475 01f6 B11D      		adc r27,__zero_reg__
 476 01f8 8E8F      		std Y+30,r24
 477 01fa 9F8F      		std Y+31,r25
 478 01fc A8A3      		std Y+32,r26
 479 01fe B9A3      		std Y+33,r27
 136:spectrumanalyzer.c **** 								
 137:spectrumanalyzer.c **** 								 // Sets the variable frequency oscillator (VFO)
 138:spectrumanalyzer.c **** 								 // to the current frequency
 139:spectrumanalyzer.c **** 								 dds_setfrequency(freqCurrent);
 481               	.LM39:
 482 0200 6A8D      		ldd r22,Y+26
 483 0202 7B8D      		ldd r23,Y+27
 484 0204 8C8D      		ldd r24,Y+28
 485 0206 9D8D      		ldd r25,Y+29
 486 0208 00D0      		rcall dds_setfrequency
 140:spectrumanalyzer.c **** 
 141:spectrumanalyzer.c **** 								 // After wait, the measured section was tuned.
 142:spectrumanalyzer.c **** 								 if (firstsweep==FALSE) {
 488               	.LM40:
 489 020a 8AA1      		ldd r24,Y+34
 490 020c 8823      		tst r24
 491 020e 31F4      		brne .L26
 143:spectrumanalyzer.c **** 									 delay_ms(2); 
 493               	.LM41:
 494 0210 68E9      		ldi r22,lo8(2456)
 495 0212 79E0      		ldi r23,hi8(2456)
 496 0214 80E0      		ldi r24,hlo8(2456)
 497 0216 90E0      		ldi r25,hhi8(2456)
 498 0218 00D0      		rcall delay_long
 499 021a 06C0      		rjmp .L27
 500               	.L26:
 144:spectrumanalyzer.c **** 								 } else {
 145:spectrumanalyzer.c **** 									 delay_ms(20); 
 502               	.LM42:
 503 021c 60EF      		ldi r22,lo8(24560)
 504 021e 7FE5      		ldi r23,hi8(24560)
 505 0220 80E0      		ldi r24,hlo8(24560)
 506 0222 90E0      		ldi r25,hhi8(24560)
 507 0224 00D0      		rcall delay_long
 146:spectrumanalyzer.c **** 									 firstsweep=FALSE;
 509               	.LM43:
 510 0226 1AA2      		std Y+34,__zero_reg__
 511               	.L27:
 147:spectrumanalyzer.c **** 								 }
 148:spectrumanalyzer.c ****                             
 149:spectrumanalyzer.c **** 								 // Sends the value from the ADC to the PC
 150:spectrumanalyzer.c ****                                  uartSendByte(adc_read_channel_one());
 513               	.LM44:
 514 0228 00D0      		rcall adc_read_channel_one
 515 022a 00D0      		rcall uartSendByte
 516 022c AFCF      		rjmp .L23
 517               	.L24:
 151:spectrumanalyzer.c **** 				             }
 152:spectrumanalyzer.c **** 
 153:spectrumanalyzer.c **** 							 // After one measurement cycle the status is set
 154:spectrumanalyzer.c ****                              // to WAIT
 155:spectrumanalyzer.c ****                              status = WAIT;
 519               	.LM45:
 520 022e 1982      		std Y+1,__zero_reg__
 521               	.L18:
 156:spectrumanalyzer.c ****                              break;
 157:spectrumanalyzer.c ****         }
 158:spectrumanalyzer.c ****         // The delay is intended for interrupt driven uart. 
 159:spectrumanalyzer.c ****         delay_us(20);
 523               	.LM46:
 524 0230 84E2      		ldi r24,lo8(36)
 525 0232 90E0      		ldi r25,hi8(36)
 526 0234 00D0      		rcall delay_short
 527 0236 4DCF      		rjmp .L15
 160:spectrumanalyzer.c ****     }
 161:spectrumanalyzer.c ****     return (0);
 162:spectrumanalyzer.c **** }
 529               	.LM47:
 530               	.LBE3:
 531               	/* epilogue: frame size=36 */
 532               	/* epilogue: noreturn */
 533               	/* epilogue end (size=0) */
 534               	/* function main size 215 (211) */
 546               	.Lscope1:
 548               		.text
 550               	Letext:
 551               	/* File "spectrumanalyzer.c": code  285 = 0x011d ( 262), prologues  14, epilogues   9 */
DEFINED SYMBOLS
                            *ABS*:00000000 spectrumanalyzer.c
                            *ABS*:0000003f __SREG__
                            *ABS*:0000003e __SP_H__
                            *ABS*:0000003d __SP_L__
                            *ABS*:00000000 __tmp_reg__
                            *ABS*:00000001 __zero_reg__
C:\DOKUME~1\martin\LOKALE~1\Temp/cc88aaaa.s:111    .text:00000000 uartReceiveStringLong
C:\DOKUME~1\martin\LOKALE~1\Temp/cc88aaaa.s:223    .text:0000008c main
C:\DOKUME~1\martin\LOKALE~1\Temp/cc88aaaa.s:550    .text:00000238 Letext

UNDEFINED SYMBOLS
__do_copy_data
__do_clear_bss
uartGetRxBuffer
uartReceiveByte
__stack
uartInit
uartSetBaudRate
adc_init
dds_init
uartFlushReceiveBuffer
uartReceiveBufferIsEmpty
memcpy
dds_reset
__mulsi3
dds_setfrequency
delay_long
adc_read_channel_one
uartSendByte
delay_short