Almos thtere maybe?

Working with arbitrary goertzel's
eh different printf
2026-06-21 18:29:28 +00:00 · 2024-07-13 01:49:39 -07:00 · 2024-07-13 01:19:46 -07:00 · 2024-07-12 02:02:41 -07:00 · 2024-07-12 01:54:24 -07:00 · 2024-07-11 02:07:41 -07:00
20 changed files with 5525 additions and 106 deletions
@@ -91,17 +91,13 @@ SOFTWARE.
 	Calculated to use the 19.75th harmonic @ 27.08571429MHz, but ideal found at 27.08643MHz
 */

-#define Q 1800
+#define Q 1000

-
-// For Quadrature - use 30
-// For nonquadrature use 40.
-
-#define PWM_PERIOD (40-1) //For 27MHz
+#define PWM_PERIOD (28-1) //For 27.000500MHz
 //#define QUADRATURE
 //#define TIGHT_OUT
 //#define DUMPBUFF
-#define PWM_OUTPUT 1
+#define PWM_OUTPUT 7

 //#define PWM_PERIOD (32-1)
 //#define QUADRATURE
@@ -124,12 +120,13 @@ void SetupADC()
 	// Set up single conversion on chl 7
 	ADC1->RSQR1 = 0;
 	ADC1->RSQR2 = 0;
-	ADC1->RSQR3 = 7;	// 0-9 for 8 ext inputs and two internals
+	ADC1->RSQR3 = 6;	// 0-9 for 8 ext inputs and two internals  /// 7 or 6 means one of the ADC inputs.

 	// Not using injection group.

-	// PD4 is analog input chl 7
+	// PD4 is analog input chl 7 + 6
 	GPIOD->CFGLR &= ~(0xf<<(4*4));	// CNF = 00: Analog, MODE = 00: Input
+	GPIOD->CFGLR &= ~(0xf<<(4*6));	// CNF = 00: Analog, MODE = 00: Input

 	// Sampling time for channels. Careful: This has PID tuning implications.
 	// Note that with 3 and 3,the full loop (and injection) runs at 138kHz.
@@ -281,14 +278,16 @@ void InnerLoop()
 		    int s = 1<<( ( 32 - __builtin_clz(is) )/2);
    		s = (s + is/s)/2;

-
 #ifdef TIGHT_OUT
-			printf( "%d\n", s );
+			printf( "%d\n", is );
 #elif defined( PWM_OUTPUT )
-			int tv = (s>>PWM_OUTPUT) + (PWM_PERIOD/2);
+
+
+			int tv = (i>>PWM_OUTPUT) + (PWM_PERIOD/2);
 			if( tv < 0 ) tv = 0;
 			if( tv >= PWM_PERIOD ) tv = PWM_PERIOD-1;
-			TIM1->CH3CVR = tv;
+
+			TIM1->CH4CVR = tv;
 #else

 			printf( "%8d I:%7d Q:%7d [%d %d %d %d] / %d\n",s, i ,q, adc_buffer[0], adc_buffer[1], adc_buffer[2], adc_buffer[3], (int)(SysTick->CNT - tstart) );
@@ -1,92 +0,0 @@
-<!DOCTYPE html>
-<HTML>
-<HEAD>
-<SCRIPT>
-
-
-function DrawSpan( colspan, freq, target, docolor )
-{
-	var fdist = Math.abs( freq - target );
-	fdist = Math.pow( fdist, 0.5 ) * 500;
-//	if( fdist > 255 ) fdist = 255;
-	let ret = "<TD COLSPAN=" + colspan + ' ';
-	if( docolor ) ret += 'STYLE="background-color:rgb(' + fdist + ',' + (511-fdist) + ',0)";';
-	ret += '>' + freq.toFixed(6) + "</TD>";
-	return ret;
-}
-
-function computeTable()
-{
-	const max_harmonics = 28|0;
-	const min_harmonics = 1|0;
-	let xtal = Number(document.getElementById("crystalmhz").value );
-	let target = Number(document.getElementById("targetmhz").value );
-	let contents = "<TABLE BORDER=1>";
-
-	contents += '<TR><TH>d\\h</div></TH>';
-	for( let h = 0|min_harmonics; h <= max_harmonics; h++ )
-	{
-		contents += "<TH COLSPAN=2>" + h + "</TH>";
-	}
-	contents += "</TR>";
-	
-
-	for( let n = 0|28; n <= 66; n++ )
-	{
-		for( let mode = 0; mode < 4; mode++ )
-		{
-			contents += "<TR>";
-			if( mode == 0 )
-				contents += "<TD ROWSPAN=4>" + n + "</TD>";
-			for( let h = 0|min_harmonics; h <= max_harmonics; h++ )
-			{
-				let freq = ( xtal / n );
-				if( mode == 0 )
-					contents += DrawSpan( 2, freq * h, target, false );
-				else if( mode == 1 )
-					contents += DrawSpan( 2, freq * (h-.25), target, true );
-				else if( mode == 2 )
-					contents += DrawSpan( 2, freq * (h+.25), target, true );
-				else if( mode == 3 )
-					contents += DrawSpan( 2, freq * (h+0.5), target, true );
-
-			}
-			contents += "</TD>";
-		}
-	}
-	contents += "</TABLE>";
-	document.getElementById( "TABLE" ).innerHTML = contents;
-}
-
-</SCRIPT>
-</HEAD>
-<BODY>
-
-<p>Tool for computing tuning to specific frequencies by use of direct ADC reading at specific timer-controlled rate to "tune" to specific frequencies either by quadrature or differential.</p>
-<TABLE>
-<TR><TD>Crystal MHz</TD><TD><INPUT ID=crystalmhz VALUE=48></TD></TR>
-<TR><TD>Target MHz</TD><TD><INPUT ID=targetmhz VALUE=27.1></TD></TR>
-<TR><TD COLSPAN=2><INPUT TYPE=SUBMIT ONCLICK="computeTable()"></TD></TR>
-</TABLE>
-
-<TABLE>
-<TR><TD>Quadrature:</TD></TR>
-<TR><TD>I = + + - -</TD></TR>
-<TR><TD>Q = + - - +</TD></TR>
-<TR><TD>Differntial:</TD></TR>
-<TR><TD>V = + - + -</TD></TR>
-<TR><TD>You choose the mode you operate in, either Quadrature or differential</TD></TR>
-</TABLE>
-
-<p> Table shows: </P>
-<TABLE BORDER=1>
-<TR><TD>Sample Frequency Harmonic</TD></TR>
-<TR><TD>Lower Quadrature Frequency</TD></TR>
-<TR><TD>Upper Quadrature Frequency</TD></TR>
-<TR><TD>Differential Frequency</TD></TR>
-</TABLE>
-
-<DIV ID=TABLE></DIV>
-
-</BODY>
-</HTML>
@@ -0,0 +1,551 @@
+/**
+
+MIT-like-non-ai-license
+
+Copyright (c) 2024 Charles Lohr "CNLohr"
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the two following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+In addition the following restrictions apply:
+
+1. The Software and any modifications made to it may not be used for the
+purpose of training or improving machine learning algorithms, including but not
+limited to artificial intelligence, natural language processing, or data
+mining. This condition applies to any derivatives, modifications, or updates
+based on the Software code. Any usage of the Software in an AI-training dataset
+is considered a breach of this License.
+
+2. The Software may not be included in any dataset used for training or
+improving machine learning algorithms, including but not limited to artificial
+intelligence, natural language processing, or data mining.
+
+
+3. Any person or organization found to be in violation of these restrictions
+will be subject to legal action and may be held liable for any damages
+resulting from such use.
+
+If any term is unenforcable, other terms remain in-force.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+**/
+
+
+// NOT LORA!!!
+
+// Transmit a sweep on 97.7MHz
+#define FM_TRANSMITTER_SWEEP
+
+// Nothing = Transmit a 315MHz signal.
+
+// XXX WARNING: Something is wrong with this - 
+//  The output isn't perfectly time aligned
+//  And as such there are extra images in weird places.
+//  TODO: Investigate the DMA+SPI Port jankyness.
+#include "ch32v003fun.h"
+#include <stdio.h>
+#include <string.h>
+
+#include "LoRa-SDR-Code.h"
+
+#ifdef LORAWAN
+#include "lorawan_simple.h"
+#endif
+
+#define DMA_SIZE_WORDS 128
+
+#define SENDBUFF_WORDS (DMA_SIZE_WORDS*2)
+uint8_t sendbuff[SENDBUFF_WORDS];
+
+// Bits are shifted out MSBit first, then to LSBit
+
+
+#define MAX_BYTES 25
+#define MAX_SYMBOLS (MAX_BYTES*2+16)
+
+// Our table is bespoke for the specific SF.
+#define CHIPSSPREAD CHIRPLENGTH_WORDS// QUARTER_CHIRP_LENGTH_WORDS (TODO: Use the quater value elsewhere in the code)
+#define MARK_FROM_SF0 (1<<SF_NUMBER) // SF7
+
+#define PREAMBLE_CHIRPS 10
+#define CODEWORD_LENGTH 2
+
+uint32_t quadsetcount;
+int16_t quadsets[MAX_SYMBOLS*4+PREAMBLE_CHIRPS*4+9+CODEWORD_LENGTH*4];
+int runningcount_bits = 0;
+volatile int fxcycle;
+volatile int quadsetplace = -1;
+volatile uint32_t temp;
+
+#if 0
+
+int16_t * AddChirp( int16_t * qso, int offset, int verneer )
+{
+	offset = offset * CHIPSSPREAD / (MARK_FROM_SF0);
+	offset += verneer;
+	*(qso++) = (CHIPSSPREAD * 0 / 4 + offset + CHIPSSPREAD ) % CHIPSSPREAD;
+	*(qso++) = (CHIPSSPREAD * 1 / 4 + offset + CHIPSSPREAD ) % CHIPSSPREAD;
+	*(qso++) = (CHIPSSPREAD * 2 / 4 + offset + CHIPSSPREAD ) % CHIPSSPREAD;
+	*(qso++) = (CHIPSSPREAD * 3 / 4 + offset + CHIPSSPREAD ) % CHIPSSPREAD;
+	return qso;
+}
+
+// This IRQ is called periodically to fill the output buffer that is shifted to SPI
+void DMA1_Channel3_IRQHandler( void ) __attribute__((interrupt)) __attribute__((section(".srodata")));
+void DMA1_Channel3_IRQHandler( void ) 
+{
+	//GPIOD->BSHR = 1;	 // Turn on GPIOD0 for profiling
+
+	// Backup flags.
+	volatile int intfr = DMA1->INTFR;
+	do
+	{
+		// Clear all possible flags.
+		DMA1->INTFCR = DMA1_IT_GL3;
+
+
+		//int place = DMA1_Channel3->CNTR;
+		// CNTR says that there are THIS MANY bytes left in the transfer.
+		// So a high CNTR value indicates a very early place in the buffer.
+
+		uint16_t * sb = 0;
+
+		temp++;
+
+		if( intfr & DMA1_IT_HT3 )
+		{
+			sb = sendbuff;
+		}
+		else if( intfr & DMA1_IT_TC3 )
+		{
+			sb = sendbuff + SENDBUFF_WORDS/2;
+		}
+
+		if( sb )
+		{
+			if( quadsetplace < 0 )
+			{
+				// Abort Send
+				memset( sb, 0, SENDBUFF_WORDS*2/2 );
+				DMA1_Channel3->CFGR &= ~DMA_CFGR1_EN;
+				goto complete;
+			}
+
+			fxcycle += DMA_SIZE_WORDS;
+			if( fxcycle == NUM_DMAS_PER_QUARTER_CHIRP*DMA_SIZE_WORDS )
+			{
+				fxcycle = 0;
+				// Advance to next quarter word.
+				quadsetplace++;
+
+				if( quadsetplace > quadsetcount )
+				{
+#ifdef TEST_TONE
+					quadsetplace = 0;
+#else
+					quadsetplace = -1;
+#endif
+					memset( sb, 0, SENDBUFF_WORDS*2/2 );
+					goto complete;
+				}
+			}
+
+			int symbol = quadsets[quadsetplace]; // Actually 0...CHIRPLENGTHWORDS
+
+			const uint16_t * tsb = 0;
+
+			// Select down- or up-chirp.
+			if( symbol < 0 )
+			{
+				int word = fxcycle - symbol - 1;
+				if( word >= CHIRPLENGTH_WORDS ) word -= CHIRPLENGTH_WORDS;
+				word++;
+				tsb = (&chirpbuff[word+REVERSE_START_OFFSET_BYTES/4]);
+			}
+			else
+			{
+				int word = fxcycle + symbol;
+				if( word >= CHIRPLENGTH_WORDS ) word -= CHIRPLENGTH_WORDS;
+				tsb = (&chirpbuff[word]);
+			}
+
+			// I tried using the DMA to do the copy - but that didn't work for some reason.
+			//while( DMA1_Channel5->CFGR & 1 );
+//			DMA1_Channel5->CNTR = DMA_SIZE_WORDS/2;
+//			DMA1_Channel5->MADDR = (uint32_t)tsb;
+//			DMA1_Channel5->PADDR = (uint32_t)sb;
+//			DMA1_Channel5->CFGR |= DMA_CFGR1_EN;
+
+			int cpy = DMA_SIZE_WORDS/2;
+#ifdef TEST_TONE
+	// Test tone
+	memset( sb, 0xaa, cpy*2 );
+#else
+#if DMA_SIZE_WORDS_DIVISIBLE_BY_FOUR == 0
+			#error need divisibiltiy by 2.
+#else
+			//while( cpy-- ) { *(sb++) = wordo; }
+			// Guarantee aligned access.
+			uint32_t * sbw = (uint32_t*)(((uint32_t)sb)&~3);
+			uint32_t * tsbw = (uint32_t*)(((uint32_t)tsb)&~3);
+			//while( cpy-- ) { *(sbw++) = *(tsbw++); }
+
+			// Align the data copy if needed
+			if( cpy & 1 )
+			{
+				*(sbw++) = *(tsbw++);
+			}
+			cpy /= 2; // Doubled up per loop
+			asm volatile("\
+1:\
+c.lw a3, 0(%[from])\n\
+c.lw a4, 4(%[from])\n\
+c.addi %[from], 8\n\
+c.addi %[cpy], -1\n\
+c.sw a3, 0(%[to])\n\
+c.sw a4, 4(%[to])\n\
+c.addi %[to], 8\n\
+c.bnez %[cpy], 1b\n\
+" : [cpy]"+r"(cpy), [from]"+r"(tsbw), [to]"+r"(sbw) : : "a3", "a4", "memory");
+#endif
+#endif
+		}
+
+complete:
+		intfr = DMA1->INTFR;
+	} while( intfr );
+
+	//GPIOD->BSHR = 1<<16; // Turn off GPIOD0 for profiling
+}
+#endif
+
+
+
+void LoopFunction()  __attribute__((section(".srodata")));
+void LoopFunction()
+{
+	uint8_t * start = (uint8_t*)DMA1_Channel5->MADDR;
+	uint8_t * end = (uint8_t*)((uint32_t)DMA1_Channel5->MADDR + SENDBUFF_WORDS);
+	uint8_t * here = start+ 8;
+	uint32_t targ = 2000;
+	uint32_t running = 0;
+	uint8_t * tail = end - DMA1_Channel5->CNTR;
+	uint32_t * cntr = DMA1_Channel5->CNTR;
+	uint32_t temp = 0;
+	uint32_t temp2 = 0;
+
+	asm volatile("\n\
+	li %[targ], 2000\n\
+genloop:\n\
+	lw %[temp], 0(%[cntr])\n\
+	sub %[tail], %[end], %[temp]\n\
+	beq %[here], %[tail], genloop\n\
+innerloop:\
+	li %[temp], 17\n\
+	blt %[running], %[targ], noskip\n\
+	li %[temp], 18\n\
+	sub %[running], %[running], %[targ]\n\
+noskip:\n\
+	sb %[temp], 0(%[here])\n\
+	addi %[here], %[here], 1\n\
+	bne %[here], %[end], skipreset\n\
+	add %[here], x0, %[start]\n\
+skipreset:\n\
+	bne %[here], %[tail], innerloop\n\
+	j genloop\n\
+" : [here]"+r"(here) :
+	[start]"r"(start),
+	[end]"r"(end),
+	[targ]"r"(targ),
+	[running]"r"(running),
+	[tail]"r"(tail),
+	[cntr]"r"(cntr),
+	[temp]"r"(temp),
+	[temp2]"r"(temp2) );
+
+/*
+	while(1)
+	{
+		int targ_f = 2000; //(frameno & 511)*9 + 1700;
+		int run_f = 0;
+		uint8_t * tail = end - DMA1_Channel5->CNTR;
+
+		while( here != tail )
+		{
+			int setf = 17;
+			if( run_f > targ_f )
+			{
+				setf = 18;
+				run_f -= targ_f;
+			}
+			run_f += setf*32;
+
+			*here = setf;
+
+			here++;
+		}
+*/
+/*
+		for( j = 0; j < sizeof( sendbuff ); j++ )
+		{
+			int setf = 10;
+			if( run_f > targ_f )
+			{
+				setf = 9;
+				run_f -= targ_f;
+			}
+			run_f += setf*32;
+			
+			sendbuff[j] = setf;
+		}
+*/
+}
+void LoopFunction2() __attribute__((aligned(256))) __attribute__((section(".srodata"))) __attribute__ ((noinline));
+
+__attribute__((section(".sdata"))) __attribute__((aligned(256))) const uint32_t tablef[] = {
+		0x06060606,
+		0x06060607,
+		0x06070607,
+		0x07070706,
+		0x07070707,
+		0x07070708,
+		0x07080708,
+		0x08080807,
+		0x08080808, 
+		0x08080809, 
+		0x08090809, 
+		0x09090908, 
+		0x09090909, 
+		0x0909090a, 
+		0x090a090a, 
+		0x0a0a0a09, 
+		0x0a0a0a0a,  // Below this line is unstable - i.e. sometimes there are missing DMA transfers.
+		0x0a0a0a0b, 
+		0x0a0b0a0b, 
+		0x0b0b0b0a, 
+		0x0b0b0b0b, 
+		0x0b0b0b0c, 
+		0x0b0c0b0c, 
+		0x0c0c0c0b, 
+		0x0c0c0c0c,
+		0x0c0c0c0d, 
+		0x0c0d0c0d, 
+		0x0d0d0d0c, 
+		0x0d0d0d0d,
+		0x0d0d0d0e, 
+		0x0d0e0d0e, 
+		0x0e0e0e0d,
+		0x0e0e0e0e, 
+		0x0e0e0e0f, 
+		0x0e0f0e0f, 
+		0x0f0f0f0e,
+		0x0f0f0f0f, 
+		0x0f0f0f10, 
+		0x0f100f10, 
+		0x1010100f,
+		0x10101010, 
+		0x10101011, 
+		0x10111011, 
+		0x11111110,
+	};
+
+void LoopFunction2()
+{
+
+	uint32_t * start = (uint8_t*)DMA1_Channel5->MADDR;
+	uint32_t * end = (uint8_t*)((uint32_t)DMA1_Channel5->MADDR + SENDBUFF_WORDS);
+	uint32_t * here = start;
+
+	int run_f = 0;
+
+	volatile uint32_t * cntrptr = &DMA1_Channel5->CNTR;
+
+	while(1)
+	{
+		//uint32_t * tail = 0xfffffffc & (uintptr_t)(((uint8_t*)end) - *cntrptr);
+		//if( tail == end ) tail--;
+		uint32_t * tail = ((SENDBUFF_WORDS-1) & (0xfffffffc)) & (uintptr_t)(((uint8_t*)start) + SENDBUFF_WORDS - *cntrptr);
+
+		while( here != tail )
+		{
+#ifdef FM_TRANSMITTER_SWEEP
+			// 97.7MHz FM Station
+			int notein = (SysTick->CNT>>3)&0x1fff;
+			if( notein > 0xfff ) notein = 0x2000-notein;
+			uint32_t cp = (notein)+0x20000;
+#else
+			// 315MHz
+			uint32_t cp = 0x1bfc3;
+#endif
+			*(here++) = tablef[run_f>>12];
+			run_f &= (1<<12)-1;
+			run_f += cp;
+			if( here == end )
+				here = start;
+		}
+	}
+
+}
+
+
+int main()
+{
+	SystemInit();
+
+	funGpioInitAll();
+
+	// Set a wait state (1 = normal <= 48MHz)
+	FLASH->ACTLR = 1;
+
+// MCO for testing.
+//	funPinMode( PA8, GPIO_CFGLR_OUT_50Mhz_AF_PP );	RCC->CFGR0 |= RCC_CFGR0_MCO_PLL;
+
+//	printf( "Switching to HSE\n" );
+	Delay_Ms( 10 );
+
+	// Disable clock security system.
+	RCC->CTLR &= ~RCC_CSSON;
+
+	// Enable external crystal
+	RCC->CTLR |= RCC_HSEON;
+
+	// XXX NOTE: This is only used if you have a clock, not an oscillator.
+//	RCC->CTLR |= RCC_HSEBYP;
+
+	// Set System Clock Source to be 0.
+	RCC->CFGR0 = (RCC->CFGR0 & ~RCC_SW) | 0;
+
+	// Disable PLL
+	RCC->CTLR &= ~RCC_PLLON;
+
+	// Switch to HSE
+	RCC->CFGR0 |= RCC_PLLSRC;
+
+	// Enable PLL
+	RCC->CTLR |= RCC_PLLON;
+
+	// Wait for HSE to become ready.
+	while( !( RCC->CTLR & RCC_HSERDY) );
+	while( !( RCC->CTLR & RCC_PLLRDY) );
+
+	RCC->CFGR0 |= RCC_SW_1; //  Switch system clock to PLL
+//	printf( "HSE Switched\n" );
+	Delay_Ms( 10 );
+	RCC->CTLR &= ~RCC_HSION;
+	Delay_Ms( 10 );
+	//printf( "HSI Off [%08lx %08lx]\n", RCC->CTLR, RCC->CFGR0 ); HSI Off [03035180 0001000a]
+
+	RCC->APB2PCENR |= 	RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOC |
+						RCC_APB2Periph_TIM1;
+
+	RCC->AHBPCENR |= RCC_AHBPeriph_DMA1;
+
+	funPinMode( PC3, GPIO_CFGLR_OUT_50Mhz_AF_PP ); // T1C3 on PC3
+
+	RCC->APB2PRSTR |= RCC_APB2Periph_TIM1;
+	RCC->APB2PRSTR &= ~RCC_APB2Periph_TIM1;
+
+
+	// Prescaler 
+	TIM1->PSC = 0x0000;
+	
+	// Auto Reload - sets period
+	TIM1->ATRLR = 17;
+	
+	// Reload immediately
+	TIM1->SWEVGR |= TIM_UG;
+	
+	// Enable CH1N output, positive pol
+	TIM1->CCER |= TIM_CC3E;
+	TIM1->CCER |= TIM_CC1E;
+	
+	// Compare 3 = for output
+	// Modes:
+	//  0, 1, 2: Nothing
+	//  3: Flip
+	//  4, 5: Nothing
+	//  6: "Fast PWM mode 1"
+	//  7: Flipping (Further out)
+#ifdef FM_TRANSMITTER_SWEEP
+	TIM1->CHCTLR2 =  TIM_OC3M_0 | TIM_OC3M_1 | TIM_OC3PE | TIM_OC3FE;
+#else
+	TIM1->CHCTLR2 =  TIM_OC3M_2 | TIM_OC3M_1 | TIM_OC3PE | TIM_OC3FE;
+#endif
+
+	// Compare 1 = for triggering
+	TIM1->CHCTLR1 = TIM_OC1M_2 | TIM_OC1M_1 | TIM_OC1FE;
+	
+	// Set the Capture Compare Register value to 50% initially
+	TIM1->CH3CVR = 4;  // ACTUALLY Ignored typically it seems.
+	TIM1->CH1CVR = 0; // This triggers DMA.
+	
+	// Enable TIM1 outputs
+	TIM1->BDTR |= TIM_MOE;
+	
+	// Enable TIM1
+	TIM1->CTLR1 |= TIM_CEN;
+
+	TIM1->DMAINTENR = TIM_TDE | TIM_UDE; // Outputs DMA1_Channel5
+
+#if 0
+	// Another try - use TIM2 to trigger DMA?
+	RCC->APB1PCENR |= RCC_APB1Periph_TIM2;
+	RCC->APB1PRSTR |= RCC_APB1Periph_TIM2;
+	RCC->APB1PRSTR &= ~RCC_APB1Periph_TIM2;
+
+	TIM2->PSC = 0x0000;
+	TIM2->ATRLR = 37;
+	TIM2->SWEVGR |= TIM_UG;
+	TIM2->BDTR |= TIM_MOE;
+	TIM2->CHCTLR1 = TIM_OC1M_2 | TIM_OC1M_1 | TIM_OC1FE;
+	TIM2->DMAINTENR |= TIM_UDE | TIM_TDE | TIM_TDE | TIM_CC1DE;
+	TIM2->CTLR1 |= TIM_CEN;
+	// TIM2_UP = DMA Channel 2.
+#endif
+
+	DMA1_Channel5->PADDR = (uint32_t)&TIM1->CH3CVR;
+	DMA1_Channel5->MADDR = (uint32_t)sendbuff;
+	DMA1_Channel5->CNTR  = 0;// sizeof( bufferset )/2; // Number of unique copies.  (Don't start, yet!)
+	DMA1_Channel5->CFGR  =
+		DMA_M2M_Disable |		 
+		DMA_Priority_VeryHigh |
+		DMA_PeripheralDataSize_HalfWord |
+		DMA_MemoryDataSize_Byte |
+		DMA_MemoryInc_Enable |
+		DMA_Mode_Circular | // OR DMA_Mode_Circular or DMA_Mode_Normal
+		DMA_DIR_PeripheralDST |
+		0;
+		//DMA_IT_TC | DMA_IT_HT; // Transmission Complete + Half Empty Interrupts. 
+
+//	NVIC_EnableIRQ( DMA1_Channel3_IRQn );
+
+		int j;
+		for( j = 0; j < sizeof( sendbuff ); j++ )
+		{
+			sendbuff[j] = 12;
+		}
+
+
+	// Enter critical section.
+	DMA1_Channel5->MADDR = (uint32_t)sendbuff;
+	DMA1_Channel5->CNTR = SENDBUFF_WORDS; // Number of unique uint16_t entries.
+	DMA1_Channel5->CFGR |= DMA_CFGR1_EN;
+
+
+	LoopFunction2();
+}
+
@@ -0,0 +1,15 @@
+all : flash
+
+TARGET:=adcfft
+TARGET_MCU:=CH32V203G6U6
+TARGET_MCU_PACKAGE:=CH32V203G6U6
+CH32V003FUN:=../ch32v003fun/ch32v003fun
+
+EXTRA_CFLAGS:=-Wno-unused-function -I../../lib -I../lib
+
+include ../ch32v003fun/ch32v003fun/ch32v003fun.mk
+
+flash : cv_flash
+clean : cv_clean
+	rm -rf rf_data_gen chirpbuff.dat chirpbuff.h chirpbuffinfo.h
+
@@ -0,0 +1,4 @@
+# Example with an FFT for quickly figuring out where on the spectrum to look.
+
+ * Display on PB8/PB9 for SCL/SDA
+ * Analog is on PA7
@@ -0,0 +1,486 @@
+/**
+
+MIT-like-non-ai-license
+
+Copyright (c) 2024 Charles Lohr "CNLohr"
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the two following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+In addition the following restrictions apply:
+
+1. The Software and any modifications made to it may not be used for the
+purpose of training or improving machine learning algorithms, including but not
+limited to artificial intelligence, natural language processing, or data
+mining. This condition applies to any derivatives, modifications, or updates
+based on the Software code. Any usage of the Software in an AI-training dataset
+is considered a breach of this License.
+
+2. The Software may not be included in any dataset used for training or
+improving machine learning algorithms, including but not limited to artificial
+intelligence, natural language processing, or data mining.
+
+
+3. Any person or organization found to be in violation of these restrictions
+will be subject to legal action and may be held liable for any damages
+resulting from such use.
+
+If any term is unenforcable, other terms remain in-force.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+**/
+
+// NOT LORA!!! -- but experimenting with the possibility of rx.
+
+// SETUP INSTRUCTIONS:
+//   (1) `make` in the optionbytes folder to configure `RESET` correctly.
+//   (2) Create a tone (if using the funprog, ../ch32v003fun/minichlink/minichlink -X ECLK 1:235:189:9:3 for 27.48387097MHz
+//   (2) or, for 24.387096762MHz -  ../ch32v003fun/minichlink/minichlink -X ECLK 1:150:49:8:3
+
+/* More notes
+
+ * Minimum sample time with DMA = fCPU / 28 (5.14MHz)
+
+*/
+
+
+#include "ch32v003fun.h"
+#include <stdio.h>
+
+#define SH1107_128x128
+#define SSD1306_REMAP_I2C
+#include "ssd1306_i2c.h"
+#include "ssd1306.h"
+
+#define FIX_FFT_IMPLEMENTATION
+#include "fix_fft.h"
+
+/* General note:
+*/
+
+#define Q 256
+
+#define TARGET_BIN 51
+
+#define PWM_PERIOD (31-1) //For 27.0MHz, use 36MHz if quadrature -- It appears to be good for *244 in the table?  WHY 26MHz???!?!!?
+
+#define ADC_BUFFSIZE 512
+volatile uint16_t adc_buffer[ADC_BUFFSIZE];
+
+void SetupADC()
+{
+	// XXX TODO -look into PGA
+	// XXX TODO - Look into tag-teaming the ADCs
+
+	// PA7 is analog input chl 7
+	GPIOA->CFGLR &= ~(0xf<<(4*7));	// CNF = 00: Analog, MODE = 00: Input
+	
+	// ADC CLK is chained off of APB2.
+
+	// Reset the ADC to init all regs
+	RCC->APB2PRSTR |= RCC_APB2Periph_ADC1;
+	RCC->APB2PRSTR &= ~RCC_APB2Periph_ADC1;
+
+	// ADCCLK = 12 MHz => RCC_ADCPRE divide by 4
+	RCC->CFGR0 &= ~RCC_ADCPRE;  // Clear out the bis in case they were set
+	RCC->CFGR0 |= RCC_ADCPRE_DIV2; // Fastest possible (divide-by-2) NOTE: This is OUTSIDE the specified value in the datasheet.
+
+	// Set up single conversion on chl 7
+	ADC1->RSQR1 = 0;
+	ADC1->RSQR2 = 0;
+	ADC1->RSQR3 = 7;	// 0-9 for 8 ext inputs and two internals
+
+	// Not using injection group.
+
+	// Sampling time for channels. Careful: This has PID tuning implications.
+	// Note that with 3 and 3,the full loop (and injection) runs at 138kHz.
+	ADC1->SAMPTR2 = (0<<(3*7)); 
+
+	// Turn on ADC and set rule group to sw trig
+	// 0 = Use TRGO event for Timer 1 to fire ADC rule.
+	ADC1->CTLR2 = ADC_ADON | ADC_EXTTRIG | ADC_DMA; 
+
+	// Reset calibration
+	ADC1->CTLR2 |= ADC_RSTCAL;
+	while(ADC1->CTLR2 & ADC_RSTCAL);
+
+	// Calibrate ADC
+	ADC1->CTLR2 |= ADC_CAL;
+	while(ADC1->CTLR2 & ADC_CAL);
+
+	// ADC_SCAN: Allow scanning.
+	ADC1->CTLR1 = /*ADC_Pga_64 | */ADC_SCAN;
+
+
+	// Turn on DMA
+	RCC->AHBPCENR |= RCC_AHBPeriph_DMA1;
+
+	//DMA1_Channel1 is for ADC
+	DMA1_Channel1->PADDR = (uint32_t)&ADC1->RDATAR;
+	DMA1_Channel1->MADDR = (uint32_t)adc_buffer;
+	DMA1_Channel1->CNTR  = ADC_BUFFSIZE;
+	DMA1_Channel1->CFGR  =
+		DMA_M2M_Disable |		 
+		DMA_Priority_VeryHigh |
+		DMA_MemoryDataSize_HalfWord |
+		DMA_PeripheralDataSize_HalfWord |
+		DMA_MemoryInc_Enable |
+		DMA_Mode_Circular |
+		DMA_DIR_PeripheralSRC;
+
+	// Turn on DMA channel 1
+	DMA1_Channel1->CFGR |= DMA_CFGR1_EN;
+	
+	// Enable continuous conversion and DMA
+	ADC1->CTLR2 |= ADC_DMA; // | ADC_CONT;
+
+	// start conversion
+	ADC1->CTLR2 |= ADC_SWSTART;// | ADC_CONT;
+
+}
+
+static void SetupTimer1()
+{
+	// Enable Timer 1
+	RCC->APB2PRSTR |= RCC_APB2Periph_TIM1;
+	RCC->APB2PRSTR &= ~RCC_APB2Periph_TIM1;
+
+	TIM1->PSC = 0;  // Prescalar to 0x0000 (so, 48MHz base clock)
+	TIM1->ATRLR = PWM_PERIOD;
+
+#ifdef PWM_OUTPUT
+	// PA10 = T1CH3.
+	GPIOA->CFGHR &= ~(0xf<<(4*2));
+	GPIOA->CFGHR |= (GPIO_Speed_10MHz | GPIO_CNF_OUT_PP_AF)<<(4*2);
+
+	TIM1->CCER = TIM_CC3E | TIM_CC3P;
+	TIM1->CHCTLR2 = TIM_OC3M_2 | TIM_OC3M_1;
+	TIM1->CH3CVR = 5;  // Actual duty cycle (Off to begin with)
+#endif
+
+	TIM1->CCER = TIM_CC1E;
+	TIM1->CHCTLR1 = TIM_OC1M_2 | TIM_OC1M_1;
+	TIM1->CH1CVR = 1;
+
+	// Setup TRGO to trigger for ADC (NOTE: Not on the 203! TIM1_TRGO is only connected to injection)
+	//TIM1->CTLR2 = TIM_MMS_1;
+
+	// Enable TIM1 outputs
+	TIM1->BDTR = TIM_MOE;
+	TIM1->CTLR1 = TIM_CEN;
+}
+
+
+void InnerLoop() __attribute__((noreturn));
+
+
+void InnerLoop()
+{
+	//int i = 0;
+	//int q = 0;
+	int tpl = 0;
+
+	// Timer goes backwards when we are moving forwards.
+	volatile uint16_t * adc_buffer_end = 0;
+	volatile uint16_t * adc_buffer_top = adc_buffer + ADC_BUFFSIZE;
+	volatile uint16_t * adc = adc_buffer;
+
+	int frcnt = 0;
+
+	int tstart = 0;
+
+	int16_t shadowbuff[Q+16];
+
+	int shadowplace = 0;
+	#define SCALEUP 6
+	#define SHADOWSTORE(X) shadowbuff[frcnt+X] = t;
+
+	while( 1 )
+	{
+		tpl = ADC_BUFFSIZE - DMA1_Channel1->CNTR; // Warning, sometimes this is == to the base, or == 0 (i.e. might be 256, if top is 255)
+
+		tpl += ADC_BUFFSIZE;
+		tpl = (tpl & (ADC_BUFFSIZE-1));
+		if( tpl == ADC_BUFFSIZE ) tpl = 0;
+
+		adc_buffer_end = adc_buffer + ( ( tpl / 4) * 4 );
+//printf( "%3d %4d %d %04x\n", DMA1_Channel1->CNTR, TIM1->CNT, ADC1->RDATAR, ADC1->STATR );
+		while( adc != adc_buffer_end )
+		{
+
+			int32_t t = adc[0]; SHADOWSTORE(0);
+			//i += t; q += t;
+			t = adc[1]; SHADOWSTORE(1);
+			//i -= t; q += t;
+			t = adc[2]; SHADOWSTORE(2);
+			//i -= t; q -= t;
+			t = adc[3]; SHADOWSTORE(3);
+			//i += t; q -= t;
+			adc += 4;
+			frcnt += 4;
+
+			if( adc == adc_buffer_top ) adc = adc_buffer;
+			if( frcnt >= Q ) break;
+		}
+
+
+		if( frcnt >= Q )
+		{
+
+#if 0
+
+#ifdef DUMPBUFF
+		int j;
+		for( j = 0; j < Q; j++ )
+			printf( "%d,%d\n", j, shadowbuff[j] );
+#endif
+#ifdef QUADRATURE
+			int ti = i>>3;
+			int tq = q>>3;
+			int is = (ti*ti + tq*tq)>>8;
+#else
+			int is = i>>2;
+#endif
+		    int s = 1<<( ( 32 - __builtin_clz(is) )/2);
+    		s = (s + is/s)/2;
+
+
+#ifdef TIGHT_OUT
+			printf( "%d\n", s );
+#elif defined( PWM_OUTPUT )
+			int tv = (s>>PWM_OUTPUT) + (PWM_PERIOD/2);
+			if( tv < 0 ) tv = 0;
+			if( tv >= PWM_PERIOD ) tv = PWM_PERIOD-1;
+			TIM1->CH3CVR = tv;
+#else
+
+			printf( "%8d I:%7d Q:%7d [%d %d %d %d] / %d\n",s, i ,q, adc_buffer[0], adc_buffer[1], adc_buffer[2], adc_buffer[3], (int)(SysTick->CNT - tstart) );
+#endif
+			//printf( "%d\n", s );
+#endif
+			int k;
+
+	//		printf( "Data: " );
+			for( k = 0; k < Q; k++ )
+			{
+		//		printf( "%d, ",shadowbuff[k] );
+				shadowbuff[k] = (shadowbuff[k]<<SCALEUP)-32768;
+			}
+			//printf( "\n" );
+
+			int osb = shadowbuff[0];
+			int16_t FSQ[Q] = { 0 };
+			for( k = 0; k < 128; k++ )
+			{
+				ssd1306_drawPixel( k, ((shadowbuff[k+128]-osb)>>(SCALEUP+1))+40, 1 );
+			}
+
+			int16_t imag[Q] = { 0 };
+
+			int r = 
+				fix_fft(shadowbuff, imag, 8, 0);
+
+					//fix_fftr(shadowbuff, 7 /*1<<7 = 128 bins wide*/, 0);
+					//fix_fft(shadowbuff, FSQ, 8 /*1<<7 = 128 bins wide*/, 0);
+
+//			printf( "FFT: 
+//			for( k = 0; k < 128; k++ )
+//			{
+//			}
+
+			int targbin = TARGET_BIN;
+			int targv = 0;
+			int maxbin = 0;
+			int maxbinv = 0;
+
+
+			for( k = 0; k < 128; k++ )
+			{
+/*
+				int s = shadowbuff[k] * shadowbuff[k] + FSQ[k]*FSQ[k];
+				//if( s == 0 ) continue;
+				int x = 1<<( ( 32 - __builtin_clz(s) )/2);
+				x = (x + i/x)/2;
+				x = (x + i/x)/2; //Not really needed.
+*/
+
+				// for real
+				//	int x = shadowbuff[(k>>1) | ((k&64)>>6)];
+				// For faked imag
+
+#if 0
+				int s = shadowbuff[k] * shadowbuff[k] + shadowbuff[255-k]*shadowbuff[255-k];
+				//if( s == 0 ) continue;
+				int x = 1<<( ( 32 - __builtin_clz(s) )/2);
+				x = (x + s/x)/2;
+				x = (x + s/x)/2; //Not really needed.
+				x = (x + s/x)/2; //Not really needed.
+				
+				//x = shadowbuff[ k ];
+				//x = s >> 8;
+
+				x = x >> 2;
+#endif
+
+				int s = shadowbuff[k] * shadowbuff[k] + imag[k]*imag[k];
+				//if( s == 0 ) continue;
+				int x = 1<<( ( 32 - __builtin_clz(s) )/2);
+				x = (x + s/x)/2;
+				x = (x + s/x)/2; //Not really needed.
+				x = (x + s/x)/2; //Not really needed.
+				
+				//x = shadowbuff[ k ];
+				//x = s >> 8;
+
+				//x = x >> 2;
+				if( x > maxbinv && k != 0) { maxbinv = x; maxbin = k; }
+				if( k == targbin ) targv = x;
+
+				x++;
+				if( x < 0 ) x = 0;
+				if( x > 127 ) x = 127;
+				if( x != 0 )
+					ssd1306_drawFastVLine( k, 127-x, x, 1 );
+
+			}
+
+			static int tbhist[128];
+			static int tbhead = 0;
+			tbhist[tbhead++] = targv;
+			if( tbhead == 128 ) tbhead = 0;
+
+			char cts[32];
+			snprintf( cts, sizeof(cts), "%5d%5d@%d", osb, targv, targbin );
+			ssd1306_drawstr( 0, 0, cts, 1 );
+			snprintf( cts, sizeof(cts), "P:%d B%3d/%4d", PWM_PERIOD, maxbin, maxbinv );
+			ssd1306_drawstr( 0, 8, cts, 1 );
+
+			for( k = 0; k < 128; k++ )
+			{
+				ssd1306_drawPixel( k, 105-tbhist[(tbhead-k+256)%128]/2, 1);	
+			}
+
+			memset( shadowbuff, 0, sizeof( shadowbuff ) );
+
+			ssd1306_refresh();
+			ssd1306_setbuf(0);
+
+			frcnt = 0;
+//			i = 0;
+//			q = 0;
+			tpl = ADC_BUFFSIZE - DMA1_Channel1->CNTR;
+			adc = adc_buffer + ( ( tpl / 4) * 4 );
+			tstart = SysTick->CNT;
+		}
+/*
+		Delay_Us( 100 );
+		int end = DMA1_Channel1->CNTR;
+		int v0 = adc_buffer[0];
+		int v1 = adc_buffer[1];
+		int v2 = adc_buffer[2];
+		int v3 = adc_buffer[3];
+		printf( "%d %d %d %d %d\n", (uint8_t)(start-end), v0, v1, v2, v3 );
+*/
+	}
+
+}
+
+int main()
+{
+	SystemInit();
+
+	SysTick->CTLR = (1<<2) | 1; // HCLK
+	Delay_Ms(100);
+
+	printf( "System On\n" );
+
+	RCC->CTLR |= RCC_HSEON;
+	while( ! ( RCC->CTLR & RCC_HSERDY ) );
+
+	RCC->CFGR0 = (RCC->CFGR0 & ~RCC_SW) | RCC_SW_HSE;
+
+	RCC->CTLR &= ~RCC_PLLON;
+
+	// Switch PLL to HSE.
+	RCC->CFGR0 |= RCC_PLLSRC;
+
+	// x18; 8MHz x 18 = 144 MHz
+	RCC->CFGR0 &= ~RCC_PPRE2; // No divisor on APB1/2
+	RCC->CFGR0 &= ~RCC_PPRE1;
+	RCC->CFGR0 |= RCC_PLLMULL_0 | RCC_PLLMULL_1 | RCC_PLLMULL_2 | RCC_PLLMULL_3;
+
+	RCC->CTLR |= RCC_PLLON;
+
+	// Switch to PLL
+	RCC->CFGR0 = (RCC->CFGR0 & ~RCC_SW) | RCC_SW_PLL;
+
+	// Disable HSI
+	RCC->CTLR &= ~(RCC_HSION);
+
+	Delay_Ms(10);
+
+
+	printf( "CTLR: %08x / CFGR0: %08x\n", (RCC->CTLR), (RCC->CFGR0) );
+	RCC->AHBPCENR |= 3; //DMA2EN | DMA1EN
+	RCC->APB2PCENR |= RCC_APB2Periph_TIM1 | RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2 | 0x07; // Enable all GPIO
+	RCC->APB1PCENR |= RCC_APB1Periph_TIM2;
+
+	SetupADC();
+
+	printf( "Setting up OLED.\n" );
+	ssd1306_i2c_setup();
+	uint8_t ret = ssd1306_i2c_init();
+	ssd1306_init();
+	ssd1306_setbuf(0);
+
+#if 0
+	int i = 0;
+	int k = 0;
+	int frame = 0;
+	while( 1)
+	{
+//		ssd1306_drawLine( (frame)%128, (0)%128, (0)%128, (127-frame)%128, 1 );
+		ssd1306_drawstr( frame%128, frame%128, "hello", 1 );
+
+		ssd1306_refresh();
+		ssd1306_setbuf(0);
+		frame++;
+	}
+
+	while(1);
+#endif
+
+#if 0
+	// turn on the op-amp
+	EXTEN->EXTEN_CTR |= EXTEN_OPA_EN;
+
+	// select op-amp pos pin: 0 = PA2, 1 = PD7
+	EXTEN->EXTEN_CTR |= EXTEN_OPA_PSEL;
+
+	// select op-amp neg pin: 0 = PA1, 1 = PD0
+	EXTEN->EXTEN_CTR |= EXTEN_OPA_NSEL;
+#endif
+
+
+	printf( "ADC Setup\n" );
+
+	SetupTimer1();
+
+	printf( "Timer 1 setup\n" );
+
+	InnerLoop();
+}
@@ -0,0 +1,10 @@
+#ifndef _FUNCONFIG_H
+#define _FUNCONFIG_H
+
+#define FUNCONF_USE_DEBUGPRINTF 1
+#define FUNCONF_USE_UARTPRINTF  0
+#define FUNCONF_USE_HSE 1
+#define FUNCONF_SYSTICK_USE_HCLK 1
+
+#endif
+
@@ -0,0 +1,15 @@
+all : flash
+
+TARGET:=adcgoertzel
+TARGET_MCU:=CH32V203G6U6
+TARGET_MCU_PACKAGE:=CH32V203G6U6
+CH32V003FUN:=../ch32v003fun/ch32v003fun
+
+EXTRA_CFLAGS:=-Wno-unused-function -I../../lib -I../lib -I../ch32v003fun/examples_v20x/otg_device -I.
+
+include ../ch32v003fun/ch32v003fun/ch32v003fun.mk
+
+flash : cv_flash
+clean : cv_clean
+	rm -rf rf_data_gen chirpbuff.dat chirpbuff.h chirpbuffinfo.h
+
@@ -0,0 +1,29 @@
+# How to use this
+
+ * Display on PB8/PB9 for SCL/SDA
+ * Analog is on PA7
+
+First, use FFT, then look in the middle for the highest bin @.  This is the # of pixels from the left side of the screen you are.
+
+Then edit ttest.c, 
+
+```
+	g_goertzel_omega_per_sample = (47.0/256) * 3.1415926535*2.0*65536;
+```
+
+where 47.0 in this case is the bin # from the FFT.
+
+Change this, `make test`
+
+Then copy the values:
+const int32_t g_goertzel_omega_per_sample = 75599;
+const int32_t g_goertzel_coefficient = 870257651;
+const int32_t g_goertzel_coefficient_s = 1963246708;
+
+into the top of adcgoertzel.c
+
+
+TODO: TODO: Test HTML values.
+
+TODO: TODO: g_goertzel_omega_per_sample lokos WRONG.
+
@@ -0,0 +1,723 @@
+/**
+
+MIT-like-non-ai-license
+
+Copyright (c) 2024 Charles Lohr "CNLohr"
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the two following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+In addition the following restrictions apply:
+
+1. The Software and any modifications made to it may not be used for the
+purpose of training or improving machine learning algorithms, including but not
+limited to artificial intelligence, natural language processing, or data
+mining. This condition applies to any derivatives, modifications, or updates
+based on the Software code. Any usage of the Software in an AI-training dataset
+is considered a breach of this License.
+
+2. The Software may not be included in any dataset used for training or
+improving machine learning algorithms, including but not limited to artificial
+intelligence, natural language processing, or data mining.
+
+
+3. Any person or organization found to be in violation of these restrictions
+will be subject to legal action and may be held liable for any damages
+resulting from such use.
+
+If any term is unenforcable, other terms remain in-force.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+**/
+
+// NOT LORA!!! -- but experimenting with the possibility of rx.
+
+// SETUP INSTRUCTIONS:
+//   (1) `make` in the optionbytes folder to configure `RESET` correctly.
+//   (2) Create a tone (if using the funprog, ../ch32v003fun/minichlink/minichlink -X ECLK 1:235:189:9:3 for 27.48387097MHz
+//   (2) or, for 24.387096762MHz -  ../ch32v003fun/minichlink/minichlink -X ECLK 1:150:49:8:3
+
+/* More notes
+
+ * Minimum sample time with DMA = fCPU / 28 (5.14MHz)
+
+*/
+
+
+#include "ch32v003fun.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#define SH1107_128x128
+#define SSD1306_REMAP_I2C
+//#define PWM_OUTPUT
+#define ENABLE_OLED
+#define PROFILING_PIN PA0
+
+#include "ssd1306_i2c.h"
+#include "ssd1306.h"
+#include "./usb_config.h"
+#include "../ch32v003fun/examples_v20x/otg_device/otgusb.h"
+
+// Bigger buffer decreases chance of fall-through, but increases the size of each operation.
+#define ADC_BUFFSIZE 512
+
+volatile uint16_t adc_buffer[ADC_BUFFSIZE];
+
+int g_volume_pwm = 127; // 0 - 127 (100%) (but you can go over 100)
+
+#if 0
+int g_pwm_period = (30-1);
+int g_goertzel_buffer = (752);
+int g_exactcompute = (0);
+int32_t g_goertzel_omega_per_sample = 2485087396; // 0.368351 of whole per step / 27.031915MHz
+int32_t g_goertzel_coefficient = -1453756170;
+int32_t g_goertzel_coefficient_s = 1580594514;
+#endif
+
+#if 1
+int g_pwm_period = (30-1);
+int g_goertzel_buffer = (180);
+int g_exactcompute = (0);
+int32_t g_goertzel_omega_per_sample = 5509657063; // 0.816667 of whole per step / 0.880000MHz
+int32_t g_goertzel_coefficient = 873460290;
+int32_t g_goertzel_coefficient_s = -1961823932;
+#endif
+
+#if 0
+int g_pwm_period = (31-1);
+int g_goertzel_buffer = (412);
+int g_exactcompute = (0);
+const int32_t g_goertzel_omega_per_sample = 1670254667; // 0.247573 of whole per step / 1.150016MHz
+const int32_t g_goertzel_coefficient = 32748822;
+const int32_t g_goertzel_coefficient_s = 2147233926;
+#endif
+
+#if 0
+int g_pwm_period = (30-1);
+int g_goertzel_buffer = (576);
+int g_exactcompute = (0);
+int32_t g_goertzel_omega_per_sample = 1264972285; // 0.187500 of whole per step / 90.300000MHz
+int32_t g_goertzel_coefficient = 821806413;
+int32_t g_goertzel_coefficient_s = 1984016189;
+#endif
+
+#if 0
+int g_pwm_period = (30-1);
+int g_goertzel_buffer = (320);
+int g_exactcompute = (0);
+const int32_t g_goertzel_omega_per_sample = 990894956; // 0.146875 of whole per step / 101.505000MHz
+const int32_t g_goertzel_coefficient = 1296126516;
+const int32_t g_goertzel_coefficient_s = 1712233066;
+#endif
+
+#if 0
+int g_pwm_period = (30-1);
+int g_goertzel_buffer = (384);
+int g_exactcompute = (0);
+const int32_t g_goertzel_omega_per_sample = 4251712402; // 0.630208 of whole per step / 27.025000MHz
+const int32_t g_goertzel_coefficient = -1468003291;
+const int32_t g_goertzel_coefficient_s = -1567371161;
+#endif
+
+#if 0
+int g_pwm_period = (30-1);
+int g_goertzel_buffer = (336);
+int g_exactcompute = (0);
+const int32_t g_goertzel_omega_per_sample = 1827182189; // 0.270833 of whole per step / 89.900000MHz
+const int32_t g_goertzel_coefficient = -280302863;
+const int32_t g_goertzel_coefficient_s = 2129111628;
+#endif
+
+
+int intensity_average = 1;
+
+#define LOG_GOERTZEL_LIST 512
+int32_t qibaselogs[LOG_GOERTZEL_LIST];
+volatile int     qibaselogs_head;
+
+void SetupADC()
+{
+	// XXX TODO -look into PGA
+	// XXX TODO - Look into tag-teaming the ADCs
+
+	// PDA is analog input chl 7
+	GPIOA->CFGLR &= ~(0xf<<(4*7));	// CNF = 00: Analog, MODE = 00: Input
+	
+	// ADC CLK is chained off of APB2.
+
+	// Reset the ADC to init all regs
+	RCC->APB2PRSTR |= RCC_APB2Periph_ADC1;
+	RCC->APB2PRSTR &= ~RCC_APB2Periph_ADC1;
+
+	// ADCCLK = 12 MHz => RCC_ADCPRE divide by 4
+	RCC->CFGR0 &= ~RCC_ADCPRE;  // Clear out the bis in case they were set
+	RCC->CFGR0 |= RCC_ADCPRE_DIV2; // Fastest possible (divide-by-2) NOTE: This is OUTSIDE the specified value in the datasheet.
+
+	// Set up single conversion on chl 7
+	ADC1->RSQR1 = 0;
+	ADC1->RSQR2 = 0;
+	ADC1->RSQR3 = 7;	// 0-9 for 8 ext inputs and two internals
+
+	// Not using injection group.
+
+	// Sampling time for channels. Careful: This has PID tuning implications.
+	// Note that with 3 and 3,the full loop (and injection) runs at 138kHz.
+	ADC1->SAMPTR2 = (0<<(3*7)); 
+
+	// Turn on ADC and set rule group to sw trig
+	// 0 = Use TRGO event for Timer 1 to fire ADC rule.
+	ADC1->CTLR2 = ADC_ADON | ADC_EXTTRIG | ADC_DMA; 
+
+	// Reset calibration
+	ADC1->CTLR2 |= ADC_RSTCAL;
+	while(ADC1->CTLR2 & ADC_RSTCAL);
+
+	// Calibrate ADC
+	ADC1->CTLR2 |= ADC_CAL;
+	while(ADC1->CTLR2 & ADC_CAL);
+
+	// ADC_SCAN: Allow scanning.
+	ADC1->CTLR1 = ADC_Pga_64 | ADC_SCAN;
+
+
+	// Turn on DMA
+	RCC->AHBPCENR |= RCC_AHBPeriph_DMA1;
+
+	//DMA1_Channel1 is for ADC
+	DMA1_Channel1->PADDR = (uint32_t)&ADC1->RDATAR;
+	DMA1_Channel1->MADDR = (uint32_t)adc_buffer;
+	DMA1_Channel1->CNTR  = ADC_BUFFSIZE;
+	DMA1_Channel1->CFGR  =
+		DMA_M2M_Disable |		 
+		DMA_Priority_VeryHigh |
+		DMA_MemoryDataSize_HalfWord |
+		DMA_PeripheralDataSize_HalfWord |
+		DMA_MemoryInc_Enable |
+		DMA_Mode_Circular |
+		DMA_DIR_PeripheralSRC;
+
+//	NVIC_SetPriority( DMA1_Channel1_IRQn, 0<<4 ); //We don't need to tweak priority.
+	NVIC_EnableIRQ( DMA1_Channel1_IRQn );
+	DMA1_Channel1->CFGR |= DMA_CFGR1_EN | DMA_IT_TC | DMA_IT_HT; // Transmission Complete + Half Empty Interrupts. 
+
+
+
+
+	// Turn on DMA channel 1
+	DMA1_Channel1->CFGR |= DMA_CFGR1_EN;
+	
+	// Enable continuous conversion and DMA
+	ADC1->CTLR2 |= ADC_DMA; // | ADC_CONT;
+
+	// start conversion
+	ADC1->CTLR2 |= ADC_SWSTART;// | ADC_CONT;
+
+}
+
+static void SetupTimer1()
+{
+	// Enable Timer 1
+	RCC->APB2PRSTR |= RCC_APB2Periph_TIM1;
+	RCC->APB2PRSTR &= ~RCC_APB2Periph_TIM1;
+
+	TIM1->PSC = 0;  // Prescalar to 0x0000 (so, 48MHz base clock)
+	TIM1->ATRLR = g_pwm_period;
+
+#ifdef PWM_OUTPUT
+	// PA9 = T1CH2.
+	funPinMode( PA9, GPIO_CFGLR_OUT_2Mhz_AF_PP );
+
+	TIM1->CCER = TIM_CC2E | TIM_CC2P;
+	TIM1->CHCTLR1 |= TIM_OC2M_2 | TIM_OC2M_1 | TIM_OC2FE;
+	TIM1->CH2CVR = 5;  // Set duty cycle somewhere random.
+
+	// Enable TIM1 outputs
+	TIM1->BDTR |= 0xc000;//TIM_MOE;
+#endif
+
+	TIM1->CCER |= TIM_CC1E;
+	TIM1->CHCTLR1 |= TIM_OC1M_2 | TIM_OC1M_1;
+	TIM1->CH1CVR = 1;
+
+	// Setup TRGO to trigger for ADC (NOTE: Not on the 203! TIM1_TRGO is only connected to injection)
+	//TIM1->CTLR2 = TIM_MMS_1;
+
+	// Enable TIM1 outputs
+	TIM1->BDTR = TIM_MOE;
+	TIM1->CTLR1 = TIM_CEN;
+}
+
+
+void InnerLoop() __attribute__((noreturn));
+
+
+uint32_t tc;
+
+
+volatile uint16_t * adc_tail = adc_buffer;
+
+uint32_t g_goertzel_samples;
+uint32_t g_goertzel_outs;
+int32_t g_goertzel, g_goertzelp, g_goertzelp2;
+int32_t g_goertzelp_store, g_goertzelp2_store;
+
+int32_t g_laststart = 0;
+int32_t g_lastper;
+int32_t g_lastlen;
+uint32_t g_accumulate_over_window;
+
+void DMA1_Channel1_IRQHandler( void ) __attribute__((interrupt));
+void DMA1_Channel1_IRQHandler( void ) 
+{
+	int32_t start = SysTick->CNT;
+#ifdef PROFILING_PIN
+	funDigitalWrite( PROFILING_PIN, 1 );
+#endif
+
+	// Timer goes backwards when we are moving forwards.
+	volatile uint16_t * adc_buffer_end = 0;
+	volatile uint16_t * adc_buffer_top = adc_buffer + ADC_BUFFSIZE;
+
+	int32_t goertzel_coefficient = g_goertzel_coefficient;
+	int32_t goertzelp2 = g_goertzelp2;
+	int32_t goertzelp = g_goertzelp;
+	int32_t goertzel = g_goertzel;
+	int32_t accumulate_over_window = g_accumulate_over_window;
+
+	uint32_t goertzel_samples = g_goertzel_samples;
+	// Backup flags.
+	volatile int intfr = DMA1->INTFR;
+
+	do
+	{
+		// Clear all possible flags.
+		DMA1->INTFCR = DMA1_IT_GL1;
+
+		int tpl = ADC_BUFFSIZE - DMA1_Channel1->CNTR; // Warning, sometimes this is == to the base, or == 0 (i.e. might be 256, if top is 255)
+		tpl += ADC_BUFFSIZE;
+		tpl = (tpl & (ADC_BUFFSIZE-1));
+		if( tpl == ADC_BUFFSIZE ) tpl = 0;
+
+		adc_buffer_end = adc_buffer + ( ( tpl / 4) * 4 );
+
+		#define INFADC 2
+		// Add a tiny bias to the ADC to help keep goertz in range.
+		static int adc_offset = (-2048) << INFADC;
+
+		while( adc_tail != adc_buffer_end )
+		{
+
+			uint32_t t; // 1/2 of 4096, to try to keep our numbers reasonable.
+
+			// Here is where the magic happens.
+
+#if 1
+			#define XSTR(x) #x
+			#define GOERTZELLOOP(idx)  \
+			asm volatile("\n\
+				lhu     %[adcin]," XSTR(idx) "(%[adc_tail])	\n\
+				slli    %[adcin],%[adcin],%[iadc]			/*INFADC = 2*/ \n\
+				add		%[adcin],%[adcin],%[adcoffset]		/*adcin += adcoffset*/ \n\
+				add     %[accumulate_over_window], %[adcin], %[accumulate_over_window]\n \
+				addi    %[goertzelp2],%[goertzelp],0		/*goertzelp2 = goertzelp*/ \n\
+				addi    %[goertzelp], %[goertzel],0			/*goertzelp = goertzel*/ \n\
+				slli    %[goertzel], %[goertzelp], 2		/*prescaling up goertzelp*/\n\
+				mulh    %[goertzel], %[goertzel_coefficient], %[goertzel]\n\
+				sub     %[adcin],%[adcin],%[goertzelp2]		/*adcin -= goertzelp2*/ \n\
+				add     %[goertzel], %[goertzel], %[adcin]	/* mulh = signed * signed + adc */ \n"\
+			: [goertzel]"+r"(goertzel), [goertzelp]"+r"(goertzelp), [goertzelp2]"+r"(goertzelp2), [adcin]"+r"(t), [accumulate_over_window]"+r"(accumulate_over_window) : \
+				[adc_tail]"r"(adc_tail), [adcoffset]"r"(adc_offset), [goertzel_coefficient]"r"(goertzel_coefficient), [iadc]"i"(INFADC) );
+
+			GOERTZELLOOP(0);
+			GOERTZELLOOP(2);
+			GOERTZELLOOP(4);
+			GOERTZELLOOP(6);
+#else
+			t = ((adc_tail[0])<<INFADC)+adc_offset;
+				goertzelp2 = goertzelp;
+				goertzelp = goertzel;
+				goertzel = t + ( ( (((int32_t)(goertzel_coefficient))) * ((((int64_t)goertzelp)<<2)) ) >> 32 ) - goertzelp2;
+
+			t = ((adc_tail[1])<<INFADC)+adc_offset;
+				goertzelp2 = goertzelp;
+				goertzelp = goertzel;
+				goertzel = t + ( ( (((int32_t)(goertzel_coefficient))) * ((((int64_t)goertzelp)<<2)) ) >> 32 ) - goertzelp2;
+
+			t = ((adc_tail[2])<<INFADC)+adc_offset;
+				goertzelp2 = goertzelp;
+				goertzelp = goertzel;
+				goertzel = t + ( ( (((int32_t)(goertzel_coefficient))) * ((((int64_t)goertzelp)<<2)) ) >> 32 ) - goertzelp2;
+
+			t = ((adc_tail[3])<<INFADC)+adc_offset;
+				goertzelp2 = goertzelp;
+				goertzelp = goertzel;
+				goertzel = t + ( ( (((int32_t)(goertzel_coefficient))) * ((((int64_t)goertzelp)<<2)) ) >> 32 ) - goertzelp2;
+#endif
+
+			adc_tail+=4;
+			goertzel_samples+=4;
+			if( adc_tail == adc_buffer_top ) adc_tail = adc_buffer;
+			if( goertzel_samples == g_goertzel_buffer )
+			{
+#ifdef PROFILING_PIN
+	funDigitalWrite( PROFILING_PIN, 0 );
+#endif
+
+				g_goertzelp_store = goertzel;
+				g_goertzelp2_store = goertzelp;
+
+				int32_t zp = g_goertzelp_store;
+				int32_t zp2 = g_goertzelp2_store;
+				int32_t rr = (((int64_t)(g_goertzel_coefficient  ) * (int64_t)zp<<1)>>32) - (zp2);
+				int32_t ri = (((int64_t)(g_goertzel_coefficient_s) * (int64_t)zp<<1)>>32);
+
+				qibaselogs[qibaselogs_head] = ((uint16_t)rr) | (((uint16_t)ri)<<16);
+				qibaselogs_head = ( qibaselogs_head + 1 ) & ((LOG_GOERTZEL_LIST)-1);
+
+				rr>>=2;
+				ri>>=2;
+
+				int s = rr * rr + ri * ri;
+				//int intensity = 1<<( ( 32 - __builtin_clz(s) )/2);
+				#define ABS(x) (((x)<0)?-(x):(x))
+				int intensity = (ABS(rr) + ABS(ri)) * 26100 / 32768; // Found experimentally (Also try to avoid divide-by-zero.
+				if( intensity == 0 )
+					intensity = 1;
+				intensity = (intensity + s/intensity)/2;
+				intensity = (intensity + s/intensity)/2;
+				intensity_average = intensity_average - (intensity_average>>12) + (intensity>>6);
+
+				#ifdef PWM_OUTPUT
+				intensity = intensity * g_volume_pwm * g_pwm_period / (intensity_average>>(10-12));
+				if( intensity >= g_pwm_period-1 ) intensity = g_pwm_period-2;
+				if( intensity < 1 ) intensity = 1;
+				TIM1->CH2CVR = intensity;  // Actual duty cycle (Off to begin with)
+				#endif
+
+				g_goertzel_outs++;
+				goertzel = 0;
+				goertzelp = 0;
+				goertzel_samples = 0;
+
+				// Try to improve bias.
+				adc_offset -= accumulate_over_window / g_goertzel_buffer;
+				accumulate_over_window = 0;
+
+#ifdef PROFILING_PIN
+	funDigitalWrite( PROFILING_PIN, 1 );
+#endif
+
+			}
+		}
+
+		intfr = DMA1->INTFR;
+	} while( intfr & DMA1_IT_GL1 );
+
+	g_goertzelp2 = goertzelp2;
+	g_goertzelp = goertzelp;
+	g_goertzel = goertzel;
+	g_goertzel_samples = goertzel_samples;
+	g_accumulate_over_window = accumulate_over_window;
+
+#ifdef PROFILING_PIN
+	funDigitalWrite( PROFILING_PIN, 0 ); // For profiling
+#endif
+	int32_t end = SysTick->CNT;
+	g_lastper = start - g_laststart;
+	g_laststart = start;
+	g_lastlen = end - start;
+}
+
+static inline uint32_t gets2()
+{
+	uint32_t ret;
+	asm volatile( "mv %[ret], s2" : [ret]"=&r"(ret) );
+	return ret;
+}
+
+
+void InnerLoop()
+{
+	while(1){
+#if 0
+		int adcz = adc_buffer[0];
+		for( k = 0; k < 128; k++ )
+		{
+			int y = adc_buffer[k]-adcz + 64;
+			if( y < 0 ) y = 0;
+			if( y > 127 ) y = 127;
+			ssd1306_drawPixel( k, y, 1 );
+		}
+#endif
+
+		int pxa = 0;
+
+		// Only display half of the list so the other half could
+		// be updated by the ISR.
+		int glread = qibaselogs_head;
+
+		int intensity = 0;
+
+		for( pxa = 0; pxa < LOG_GOERTZEL_LIST; pxa++ )
+		{
+			uint32_t combiq = qibaselogs[glread];
+			glread = ( glread + 1 ) & ( LOG_GOERTZEL_LIST -1 );
+
+			int16_t rr = combiq & 0xffff;
+			int16_t ri = combiq >> 16;
+
+			rr = rr * 512 / (intensity_average);
+			ri = ri * 512 / (intensity_average);
+
+			rr += 64;
+			ri += 64;
+
+			if( rr < 0 ) rr = 0;
+			if( ri < 0 ) ri = 0;
+			if( rr > 127 ) rr = 127;
+			if( ri > 127 ) ri = 127;
+			
+#ifdef ENABLE_OLED
+			ssd1306_drawPixel( rr, ri, 1 );
+#endif
+		}
+
+#ifdef ENABLE_OLED
+		//char cts[32];
+		//snprintf( cts, 32, "%d", intensity_average );
+		//ssd1306_drawstr( 0, 0, cts, 1 );
+
+		ssd1306_refresh();
+		//static int ik = 0;
+		//printf( "%d %08x\n", ik, ssd1306_buffer[ik++] );
+		//if( ik == sizeof(ssd1306_buffer) ) ik = 0;
+
+		ssd1306_setbuf(0);
+
+#else
+		Delay_Ms(17);
+#endif
+		
+//		printf( "%6d %8d %8d - %8d %8d - %8d\n", g_goertzel_outs,g_goertzelp2_store, g_goertzelp_store, rr, ri, x );
+
+//		Delay_Ms(940);
+//printf( "!!!!\n ");
+
+	}
+
+}
+
+int main()
+{
+	SystemInit();
+
+	SysTick->CTLR = (1<<2) | 1; // HCLK
+	Delay_Ms(100);
+
+	RCC->CTLR |= RCC_HSEON;
+	while( ! ( RCC->CTLR & RCC_HSERDY ) );
+
+	RCC->CFGR0 = (RCC->CFGR0 & ~RCC_SW) | RCC_SW_HSE;
+
+	RCC->CTLR &= ~RCC_PLLON;
+
+	// Switch PLL to HSE.
+	RCC->CFGR0 |= RCC_PLLSRC;
+
+	// x18; 8MHz x 18 = 144 MHz
+	RCC->CFGR0 &= ~RCC_PPRE2; // No divisor on APB1/2
+	RCC->CFGR0 &= ~RCC_PPRE1;
+	RCC->CFGR0 |= RCC_PLLMULL_0 | RCC_PLLMULL_1 | RCC_PLLMULL_2 | RCC_PLLMULL_3;
+
+	RCC->CTLR |= RCC_PLLON;
+
+	// Switch to PLL
+	RCC->CFGR0 = (RCC->CFGR0 & ~RCC_SW) | RCC_SW_PLL;
+
+	// Disable HSI
+	RCC->CTLR &= ~(RCC_HSION);
+
+	Delay_Ms(10);
+
+
+	//printf( "CTLR: %08x / CFGR0: %08x\n", (RCC->CTLR), (RCC->CFGR0) );
+	RCC->AHBPCENR |= 3; //DMA2EN | DMA1EN
+	RCC->APB2PCENR |= RCC_APB2Periph_TIM1 | RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2 | 0x07 | RCC_APB2Periph_GPIOA; // Enable all GPIO
+	RCC->APB1PCENR |= RCC_APB1Periph_TIM2;
+
+	SetupADC();
+
+#ifdef ENABLE_OLED
+	ssd1306_i2c_setup();
+	ssd1306_i2c_init();
+
+	if( ssd1306_init() )
+		printf( "Failed to initialize OLED\n" );
+	else
+		printf( "Initialized OLED\n" );
+
+	ssd1306_setbuf(1);
+	ssd1306_refresh();
+#endif
+
+#if 0
+	int i = 0;
+	int k = 0;
+	int frame = 0;
+	while( 1)
+	{
+//		ssd1306_drawLine( (frame)%128, (0)%128, (0)%128, (127-frame)%128, 1 );
+		ssd1306_drawstr( frame%128, frame%128, "hello", 1 );
+
+		ssd1306_refresh();
+		ssd1306_setbuf(0);
+		frame++;
+	}
+
+	while(1);
+#endif
+
+#if 0
+	// turn on the op-amp
+	EXTEN->EXTEN_CTR |= EXTEN_OPA_EN;
+
+	// select op-amp pos pin: 0 = PA2, 1 = PD7
+	EXTEN->EXTEN_CTR |= EXTEN_OPA_PSEL;
+
+	// select op-amp neg pin: 0 = PA1, 1 = PD0
+	EXTEN->EXTEN_CTR |= EXTEN_OPA_NSEL;
+#endif
+
+#ifdef PROFILING_PIN
+	funPinMode( PROFILING_PIN, GPIO_CFGLR_OUT_50Mhz_PP );
+#endif
+
+	SetupTimer1();
+
+	USBOTGSetup();
+
+
+	InnerLoop();
+}
+
+
+
+
+
+uint8_t scratchpad[512];
+int g_isConfigurePacket = 0;
+
+int HandleHidUserSetReportSetup( struct _USBState * ctx, tusb_control_request_t * req )
+{
+	int id = req->wValue & 0xff;
+	g_isConfigurePacket = 0;
+	if( id == 0xaa && req->wLength <= sizeof( scratchpad ) )
+	{
+		ctx->pCtrlPayloadPtr = scratchpad;
+		return req->wLength;
+	}
+	else if( id == 0xac && req->wLength <= sizeof( scratchpad ) )
+	{
+		g_isConfigurePacket = 1;
+		ctx->pCtrlPayloadPtr = scratchpad;
+		return req->wLength;
+	}
+	return 0;
+}
+
+int HandleHidUserGetReportSetup( struct _USBState * ctx, tusb_control_request_t * req )
+{
+	int id = req->wValue & 0xff;
+	if( id == 0xaa )
+	{
+		ctx->pCtrlPayloadPtr = scratchpad;
+		return 255;
+	}
+	else if( id == 0xac )
+	{
+		g_isConfigurePacket = 1;
+		ctx->pCtrlPayloadPtr = scratchpad;
+		return 63;
+	}
+	else if( id == 0xad )
+	{
+		static int last_baselog;
+
+		int samps_to_send = (qibaselogs_head - last_baselog + LOG_GOERTZEL_LIST * 2 - 1) & (LOG_GOERTZEL_LIST-1);
+		if( samps_to_send > 120 ) samps_to_send = 120;
+
+		((uint32_t*)scratchpad)[0] = (intensity_average<<12) | samps_to_send;
+		((uint32_t*)scratchpad)[1] = (g_lastper<<16) | g_lastlen;
+		((uint32_t*)scratchpad)[2] = (0<<16) | (((g_pwm_period+1)*g_goertzel_buffer)); //LSW = 144MHz / X
+
+		int i;
+		for( i = 3; i < samps_to_send + 3; i++ )
+		{
+			last_baselog = (last_baselog+1)&(LOG_GOERTZEL_LIST-1);
+			((uint32_t*)(scratchpad))[i] = ((int32_t*)qibaselogs)[last_baselog];
+		}
+
+		for( ; i < 128; i++ )
+			((uint32_t*)(scratchpad))[i]  = 0;
+			
+
+		ctx->pCtrlPayloadPtr = scratchpad;
+		return 510;
+	}
+	return 0;
+}
+
+void HandleHidUserReportDataOut( struct _USBState * ctx, uint8_t * data, int len )
+{
+}
+
+int HandleHidUserReportDataIn( struct _USBState * ctx, uint8_t * data, int len )
+{
+//	printf( "IN %d %d %08x %08x\n", len, ctx->USBFS_SetupReqLen, data, FSUSBCTX.ENDPOINTS[0] );
+//	memset( data, 0xcc, len );
+	return len;
+}
+
+void HandleHidUserReportOutComplete( struct _USBState * ctx )
+{
+	if( g_isConfigurePacket )
+	{
+
+		uint32_t * configs = (uint32_t*)scratchpad;
+		// Note: configs[0] == 0xac (command type)
+
+		printf( "Is Configure Packet %08x\n", configs[1] );
+
+		int numconfigs = configs[1];
+		if( numconfigs > 0) g_pwm_period = configs[2];
+		if( numconfigs > 1) g_goertzel_buffer = configs[3];
+		if( numconfigs > 2) g_goertzel_omega_per_sample = configs[4]; // 0.816667 of whole per step / 0.880000MHz
+		if( numconfigs > 3) g_goertzel_coefficient = configs[5];
+		if( numconfigs > 4) g_goertzel_coefficient_s = configs[6];
+		if( numconfigs > 5) g_exactcompute = configs[7];
+
+		// Need to reset so we don't blast by.
+		g_goertzel_samples = 0;
+		TIM1->ATRLR = g_pwm_period;
+
+		g_isConfigurePacket = 0;
+	}
+	return;
+}
+
@@ -0,0 +1,11 @@
+#ifndef _FUNCONFIG_H
+#define _FUNCONFIG_H
+
+#define FUNCONF_USE_DEBUGPRINTF 1
+#define FUNCONF_USE_UARTPRINTF  0
+#define FUNCONF_USE_HSE 1
+#define FUNCONF_SYSTICK_USE_HCLK 1
+#define FUNCONF_ENABLE_HPE 0
+
+#endif
+
@@ -0,0 +1,17 @@
+all : test floattest
+
+floattest : floattestt
+	./floattestt
+
+floattestt : floattestt.c
+	gcc -o $@ $^ -lm -g
+
+
+test : ttest
+	./ttest
+
+ttest : ttest.c
+	gcc -o $@ $^ -lm -g
+
+clean :
+	rm -rf *.o ttest *~ floattestt
@@ -0,0 +1,112 @@
+#include <stdio.h>
+#include <math.h>
+#include <stdint.h>
+
+uint32_t g_goertzel_omega_per_sample;
+int32_t g_goertzel_coefficient;
+int32_t g_goertzel_coefficient_s;
+uint32_t g_goertzel_samples;
+uint32_t g_goertzel_outs;
+int32_t g_goertzelp, g_goertzelp2;
+int32_t g_goertzelp_store, g_goertzelp2_store;
+
+int main()
+{
+	//XXX XXX NOTE If you are computing the coefficients, you can plug the value in here.
+	// You can get this number from calculator.html. I've had better luck with "inverse goertzel" numbers.
+	g_goertzel_omega_per_sample = (47.0/256) * 3.1415926535*2.0*(1<<29);
+	g_goertzel_coefficient   = 2 * cos( g_goertzel_omega_per_sample / (double)(1<<29) ) * (1<<30);
+	g_goertzel_coefficient_s = 2 * sin( g_goertzel_omega_per_sample / (double)(1<<29) ) * (1<<30);
+
+
+	const double AomegaPerSample = g_goertzel_omega_per_sample/(double)(1<<29);
+	const int AnumSamples = 256; // enough to go from 0 to 2pi
+	double Acoeff   = 2 * cos( AomegaPerSample ) * 65536;
+	double Acoeff_s = 2 * sin( AomegaPerSample ) * 65536;
+	double Asprev = AomegaPerSample * 65536;
+	double Asprev2 = 0;
+
+	printf( "%d / %d / %d    %f / %f / %f\n", g_goertzel_omega_per_sample, g_goertzel_coefficient, g_goertzel_coefficient_s, Acoeff, Acoeff_s, AomegaPerSample );
+
+
+	g_goertzelp = g_goertzel_omega_per_sample>>(29-16);
+
+	int32_t goertzel_coefficient = g_goertzel_coefficient;
+	int32_t goertzelp2 = g_goertzelp2;
+	int32_t goertzelp = g_goertzelp;
+	uint32_t goertzel_samples = g_goertzel_samples;
+
+	uint32_t adc_tail;
+
+	double As;
+
+	int js = 0;
+	for( js = 0; js < 260/4; js++ )
+	{
+			int32_t t; // 1/2 of 4096, to try to keep our numbers reasonable.
+
+			// Here is where the magic happens.
+			int32_t goertzel;
+
+			#define ITERATION(x)  \
+				t = sin(  AomegaPerSample * (x+js*4) ) * 16384*0; \
+\
+				/* Fixed */ \
+				goertzelp2 = goertzelp; \
+				goertzelp = goertzel; \
+				goertzel = t + ( ( (((int32_t)(goertzel_coefficient))) * ((((int64_t)goertzelp)<<2)) ) >> 32 ) - goertzelp2; \
+\
+				/* Float */ \
+				Asprev2 = Asprev; \
+				Asprev = As; \
+				As = t + ( Acoeff * Asprev ) / 65536.0 - Asprev2; \
+\
+/*printf( "%d,%d,%d,%d\n", ( ( (int64_t)(goertzel_coefficient) * (int64_t)goertzelp ) >> 32 ) , goertzel_coefficient, goertzelp, goertzelp2 ); */ \
+\
+		{\
+		int32_t rr = (((int64_t)(g_goertzel_coefficient  ) * (int64_t)goertzelp<<1)>>32) - (goertzelp2); \
+		int32_t ri = (((int64_t)(g_goertzel_coefficient_s) * (int64_t)goertzelp<<1)>>32); \
+		/*printf( "%3d %10d %10d %10d %10d / %9d %9d %9d * ", js*4+x, rr, ri, goertzelp, goertzelp2, goertzel_coefficient, g_goertzel_omega_per_sample, t );*/ \
+		/*printf( "%4d %10d %10d (%10d %10d) ", js*4+x, goertzelp, goertzelp2, goertzel_coefficient, g_goertzel_coefficient_s );*/ \
+		printf( "%4d %10d %10d (%10d %10d) ", js*4+x, goertzelp, goertzelp2, rr, ri ); \
+\
+		float Apower = Asprev*Asprev + Asprev2*Asprev2 - (Acoeff * Asprev * Asprev2); \
+		double ArR = 0.5 * Acoeff   * Asprev / 65536 - Asprev2; \
+		double ArI = 0.5 * Acoeff_s * Asprev / 65536; \
+		/*printf( "%14.3f, %14.3f (%14.3f %14.3f)\n", Asprev, Asprev2, Acoeff,Acoeff_s );*/ \
+		printf( "%14.3f, %14.3f (%14.3f %14.3f %f)\n", Asprev, Asprev2, ArR, ArI, sqrt( ArR*ArR +ArI*ArI ) ); \
+		}
+
+
+			ITERATION( 0 );
+			ITERATION( 1 );
+			ITERATION( 2 );
+			ITERATION( 3 );
+
+			adc_tail+=4;
+			goertzel_samples+=4;
+//			if( adc_tail == adc_buffer_top ) adc_tail = adc_buffer;
+
+/*			if( goertzel_samples == 128 )
+			{
+				g_goertzelp_store = goertzelp;
+				g_goertzelp2_store = goertzelp2;
+
+				goertzelp = 0;
+				goertzelp2 = 0;
+
+				g_goertzel_outs++;
+				goertzel_samples = 0;
+			}
+*/
+	} 
+
+
+	g_goertzelp2 = goertzelp2;
+	g_goertzelp = goertzelp;
+	g_goertzel_samples = goertzel_samples;
+
+	printf( "Constants:\nconst int32_t g_goertzel_omega_per_sample = %d;\nconst int32_t g_goertzel_coefficient = %d;\nconst int32_t g_goertzel_coefficient_s = %d;\n", g_goertzel_omega_per_sample, g_goertzel_coefficient, g_goertzel_coefficient_s );
+
+}
+
@@ -0,0 +1,157 @@
+#ifndef _USB_CONFIG_H
+#define _USB_CONFIG_H
+
+#include "funconfig.h"
+#include "ch32v003fun.h"
+
+#define FUSB_CONFIG_EPS       2 // Include EP0 in this count
+#define FUSB_SUPPORTS_SLEEP   0
+#define FUSB_HID_INTERFACES   1
+#define FUSB_CURSED_TURBO_DMA 0 // Hacky, but seems fine, shaves 2.5us off filling 64-byte buffers.
+#define FUSB_HID_USER_REPORTS 1
+#define FUSB_IO_PROFILE       1
+#define FUSB_USE_HPE          FUNCONF_ENABLE_HPE
+
+#include "usb_defines.h"
+
+//Taken from http://www.usbmadesimple.co.uk/ums_ms_desc_dev.htm
+static const uint8_t device_descriptor[] = {
+	18, //Length
+	1,  //Type (Device)
+	0x00, 0x02, //Spec
+	0x0, //Device Class
+	0x0, //Device Subclass
+	0x0, //Device Protocol  (000 = use config descriptor)
+	64, //Max packet size for EP0 (This has to be 8 because of the USB Low-Speed Standard)
+	0x09, 0x12, //ID Vendor
+	0x35, 0xd0, //ID Product
+	0x03, 0x00, //ID Rev
+	1, //Manufacturer string
+	2, //Product string
+	3, //Serial string
+	1, //Max number of configurations
+};
+
+static const uint8_t HIDAPIRepDesc[ ] =
+{
+	HID_USAGE_PAGE ( 0xff ), // Vendor-defined page.
+	HID_USAGE      ( 0x00 ),
+	HID_REPORT_SIZE ( 8 ),
+	HID_COLLECTION ( HID_COLLECTION_LOGICAL ),
+		HID_REPORT_COUNT   ( 254 ),
+		HID_REPORT_ID      ( 0xaa )
+		HID_USAGE          ( 0x01 ),
+		HID_FEATURE        ( HID_DATA | HID_VARIABLE | HID_ABSOLUTE ) ,
+		HID_REPORT_COUNT   ( 63 ), // For use with `hidapitester --vidpid 1209/D003 --open --read-feature 171`
+		HID_REPORT_ID      ( 0xab )
+		HID_USAGE          ( 0x01 ),	
+		HID_FEATURE        ( HID_DATA | HID_VARIABLE | HID_ABSOLUTE ) ,
+		HID_REPORT_COUNT   ( 63 ), // For configuring the setup.
+		HID_REPORT_ID      ( 0xac )
+		HID_USAGE          ( 0x01 ),	
+		HID_FEATURE        ( HID_DATA | HID_VARIABLE | HID_ABSOLUTE ) ,
+		HID_REPORT_COUNT_N   ( 510,2 ), // For receiving IQ data on host.
+		HID_REPORT_ID      ( 0xad )
+		HID_USAGE          ( 0x01 ),	
+		HID_FEATURE        ( HID_DATA | HID_VARIABLE | HID_ABSOLUTE ) ,
+	HID_COLLECTION_END,
+};
+
+/* Configuration Descriptor Set */
+static const uint8_t config_descriptor[ ] =
+{
+    /* Configuration Descriptor */
+    0x09,                                                   // bLength
+    0x02,                                                   // bDescriptorType
+    0x22, 0x00,                                             // wTotalLength
+    0x01,                                                   // bNumInterfaces (3)
+    0x01,                                                   // bConfigurationValue
+    0x00,                                                   // iConfiguration
+    0xA0,                                                   // bmAttributes: Bus Powered; Remote Wakeup
+    0x32,                                                   // MaxPower: 100mA
+
+    /* Interface Descriptor (Special) */
+    0x09,                                                   // bLength
+    0x04,                                                   // bDescriptorType
+    0x00,                                                   // bInterfaceNumber
+    0x01,                                                   // bAlternateSetting
+    0x01,                                                   // bNumEndpoints
+    0x03,                                                   // bInterfaceClass
+    0x00,                                                   // bInterfaceSubClass
+    0xff,                                                   // bInterfaceProtocol: OTher
+    0x00,                                                   // iInterface
+
+    /* HID Descriptor (Special) */
+    0x09,                                                   // bLength
+    0x21,                                                   // bDescriptorType
+    0x10, 0x01,                                             // bcdHID
+    0x00,                                                   // bCountryCode
+    0x01,                                                   // bNumDescriptors
+    0x22,                                                   // bDescriptorType
+    sizeof(HIDAPIRepDesc), 0x00,                            // wDescriptorLength
+
+    /* Endpoint Descriptor (Special) */
+    0x07,                                                   // bLength
+    0x05,                                                   // bDescriptorType
+    0x81,                                                   // bEndpointAddress: IN Endpoint 1
+    0x03,                                                   // bmAttributes
+    0x08, 0x00,                                             // wMaxPacketSize
+    0xff,                                                   // bInterval: slow.
+};
+
+
+
+#define STR_MANUFACTURER u"CNLohr"
+#define STR_PRODUCT      u"lolra ch32v203 goertzel test"
+#define STR_SERIAL       u"CUSTOMDEVICE000"
+
+struct usb_string_descriptor_struct {
+	uint8_t bLength;
+	uint8_t bDescriptorType;
+	uint16_t wString[];
+};
+const static struct usb_string_descriptor_struct string0 __attribute__((section(".rodata"))) = {
+	4,
+	3,
+	{0x0409}
+};
+const static struct usb_string_descriptor_struct string1 __attribute__((section(".rodata")))  = {
+	sizeof(STR_MANUFACTURER),
+	3,
+	STR_MANUFACTURER
+};
+const static struct usb_string_descriptor_struct string2 __attribute__((section(".rodata")))  = {
+	sizeof(STR_PRODUCT),
+	3,
+	STR_PRODUCT
+};
+const static struct usb_string_descriptor_struct string3 __attribute__((section(".rodata")))  = {
+	sizeof(STR_SERIAL),
+	3,
+	STR_SERIAL
+};
+
+// This table defines which descriptor data is sent for each specific
+// request from the host (in wValue and wIndex).
+const static struct descriptor_list_struct {
+	uint32_t	lIndexValue;
+	const uint8_t	*addr;
+	uint8_t		length;
+} descriptor_list[] = {
+	{0x00000100, device_descriptor, sizeof(device_descriptor)},
+	{0x00000200, config_descriptor, sizeof(config_descriptor)},
+	// interface number // 2200 for hid descriptors.
+	{0x00002200, HIDAPIRepDesc, sizeof(HIDAPIRepDesc)},
+
+	{0x00002100, config_descriptor + 18, 9 }, // Not sure why, this seems to be useful for Windows + Android.
+
+	{0x00000300, (const uint8_t *)&string0, 4},
+	{0x04090301, (const uint8_t *)&string1, sizeof(STR_MANUFACTURER)},
+	{0x04090302, (const uint8_t *)&string2, sizeof(STR_PRODUCT)},	
+	{0x04090303, (const uint8_t *)&string3, sizeof(STR_SERIAL)}
+};
+#define DESCRIPTOR_LIST_ENTRIES ((sizeof(descriptor_list))/(sizeof(struct descriptor_list_struct)) )
+
+
+#endif
+
@@ -0,0 +1,315 @@
+<!DOCTYPE html>
+<HTML>
+<HEAD>
+<LINK rel="shortcut icon" href="data:image/x-icon;," type="image/x-icon"> 
+<META charset="UTF-8">
+<STYLE>
+body { background-color: Canvas; color: CanvasText; }
+:root { color-scheme: dark; }
+</STYLE>
+
+<SCRIPT src=webhidcontrol.js></SCRIPT>
+
+<SCRIPT>
+function DrawSpan( rowspan, colspan, freq, target, docolor, extrastr = "" )
+{
+	var fdist = Math.abs( freq - target );
+	fdist = Math.pow( fdist, 0.5 ) * 500;
+//	if( fdist > 255 ) fdist = 255;
+	let ret = "<TD COLSPAN=" + colspan + ' ROWSPAN' + rowspan + ' ';
+	if( docolor ) ret += 'STYLE="color:black;background-color:rgb(' + fdist + ',' + (511-fdist) + ',0)";';
+	ret += '>' + extrastr + freq.toFixed(6) + "</TD>";
+	return ret;
+}
+
+function Goertz( n, mhz, fr, brf, exact_compute )
+{
+	let omega = fr * 3.1415926535*2.0;
+	var textarea = document.getElementById("goertzeloutput");
+
+	var g_goertzel_omega_per_sample = Math.round( ( omega*2*(1<<29)) );
+	var g_goertzel_coefficient = Math.round( (2 * Math.cos( omega ) * (1<<30)) );
+	var g_goertzel_coefficient_s = Math.round( (2 * Math.sin( omega ) * (1<<30)) );
+	var g_exactcompute = exact_compute;
+	textarea.value = 
+		"int g_pwm_period = ("+n+"-1);\n" +
+		"int g_exactcompute = ("+exact_compute+");\n" +
+		"int g_goertzel_buffer = ("+brf+");\n" +
+		"int32_t g_goertzel_omega_per_sample = " + g_goertzel_coefficient.toFixed(0) + "; // " + ( omega / (3.1415926535*2.0)).toFixed(6) + " of whole per step / " + mhz.toFixed(6) + "MHz\n" +
+		"int32_t g_goertzel_coefficient = " + g_goertzel_coefficient.toFixed(0) + ";\n" +
+		"int32_t g_goertzel_coefficient_s = " + g_goertzel_coefficient_s.toFixed(0) + ";\n";
+
+	// Highlight its content
+	textarea.select();
+
+	// Copy the highlighted text
+	document.execCommand("copy");
+
+	updateWebHidDeviceWithParameters( [ (n-1)|0, brf|0, g_goertzel_omega_per_sample|0, g_goertzel_coefficient|0, g_goertzel_coefficient_s|0, exact_compute|0 ] );
+}
+
+function computeTable()
+{
+	let xtal = Number(document.getElementById("crystalmhz").value );
+	let target = Number(document.getElementById("targetmhz").value );
+	let quadrature = document.getElementById("QUADRATURE").checked;
+	let goertzels = document.getElementById("GOERTZELS").checked;
+	let goertzel2 = document.getElementById("GOERTZEL2").checked;
+	let quanta = Math.round(Number(document.getElementById("quanta").value));
+	let quantasearch = Math.round(Number(document.getElementById("quantasearch").value));
+ 
+
+	const max_harmonics = 28|0;
+	const min_harmonics = (quadrature?1:0)|0;
+
+	let contents = "";
+
+	if( quadrature )
+	{
+		contents += "<TABLE>" +
+			"<TR><TD>Quadrature:</TD></TR>" +
+			"<TR><TD>I = + + - -</TD></TR>" +
+			"<TR><TD>Q = + - - +</TD></TR>" +
+			"<TR><TD>Differntial:</TD></TR>" +
+			"<TR><TD>V = + - + -</TD></TR>" +
+			"<TR><TD>You choose the mode you operate in, either Quadrature or differential</TD></TR>" +
+			"</TABLE>" +
+			"<p> Table shows: </P>" +
+			"<TABLE BORDER=1>" +
+			"<TR><TD>Sample Frequency Harmonic</TD></TR>" +
+			"<TR><TD>Lower Quadrature Frequency</TD></TR>" +
+			"<TR><TD>Upper Quadrature Frequency</TD></TR>" +
+			"<TR><TD>Differential Frequency</TD></TR>" +
+			"</TABLE>";
+	}
+	else if( goertzels )
+	{
+		contents +=
+			"<TABLE BORDER=1>" +
+			"<TR><TD>Goertzel</TD></TR>" +
+			"<TR><TD>Goertzel (Inverse)</TD></TR>" +
+			"</TABLE><TEXTAREA ROWS=6 COLS=120 ID=goertzeloutput></TEXTAREA>" +
+			"<P>Click on a ordinal offset to create the C code needed for that tuning parameter. Clicking will copy-to-clipboard.</P>" +
+			"<P>N Divisor #30 (row 3) is usually pretty good.  And, try to select things near 0.25 / 0.75, and avoid 0.0, 0.5, and 1.0.</P>" +
+			"<P>Goertzel's mode is for the ch32v203</P>";
+	}
+
+	if( goertzels || quadrature )
+	{
+		contents += "<TABLE BORDER=1>";
+		contents += '<TR><TH>d\\h</div></TH>';
+		for( let h = 0|min_harmonics; h <= max_harmonics; h++ )
+		{
+			contents += "<TH COLSPAN=2>" + h + "</TH>";
+		}
+
+		for( let n = 0|28; n <= 66; n++ )
+		{
+			let freq = ( xtal / n );
+			let goertzelpoint = 0;
+			let goertzelpointinv = 0;
+			let tgoertzelp = 0;
+			let tgoertzelpi = 0;
+			let quantaA = 0;
+			let quantaINV = 0;
+			for( let h = 0|min_harmonics; h <= max_harmonics; h++ )
+			{
+				let base = freq * h;
+				let next = freq * (h+1);
+
+				// Round quanta down to next order-of-4-even
+				for( let tquanta = (quanta&0xffffc) - (quantasearch&0xffffc); tquanta < (quanta&0xffffc) + (quantasearch&0xffffc); tquanta+=4 )
+				{
+					if( target <= next && target >= base )
+					{
+						var t;
+						let tgoertzelpoint = ( target - base ) / ( next - base );
+						tgoertzelpoint = Math.round(tquanta * tgoertzelpoint)/tquanta;
+						if( Math.abs( freq*(h+tgoertzelpoint) - target ) < Math.abs( freq*(h+goertzelpoint) - target ) )
+						{
+							goertzelpoint = tgoertzelpoint;
+							tgoertzelp = h;
+							quantaA = tquanta;
+						}
+
+						let tgoertzelpointinv = (1.0 - ( target - base ) / ( next - base ));
+						tgoertzelpointinv = Math.round(tquanta * tgoertzelpointinv)/tquanta;
+
+						if( Math.abs( freq*(h-tgoertzelpointinv+1) - target ) < Math.abs( freq*(h-goertzelpointinv+1) - target ) )
+						{
+							goertzelpointinv = tgoertzelpointinv;
+							tgoertzelpi = h;
+							quantaINV = tquanta;
+						}
+					}
+				}
+			}
+			contents += "</TR>";
+
+			for( let mode = 0; mode < 4; mode++ )
+			{
+				contents += "<TR>";
+				if( mode == 0 )
+					contents += "<TD ROWSPAN=" + 4 + ">" + n + "</TD>";
+				for( let h = 0|min_harmonics; h <= max_harmonics; h++ )
+				{
+					if( quadrature )
+					{
+						if( mode == 0 )
+							contents += DrawSpan( 1, 2, freq * h, target, false );
+						else if( mode == 1 )
+							contents += DrawSpan( 1, 2, freq * (h-.25), target, true );
+						else if( mode == 2 )
+							contents += DrawSpan( 1, 2, freq * (h+.25), target, true );
+						else if( mode == 3 )
+							contents += DrawSpan( 1, 2, freq * (h+0.5), target, true );
+					}
+					else
+					{
+						if( mode == 0 )
+						{
+							contents += "<TD COLSPAN=2>"
+							if( tgoertzelp == h ) contents += "<SPAN ONCLICK='Goertz(" + n + ", " + freq * (h+goertzelpoint) + ", " + (goertzelpoint) + ", " + quantaA + ", 0)'>↑" + (goertzelpoint).toFixed(6) + "</SPAN>";
+							contents += "</TD>";
+						}
+						else if( mode == 1 )
+						{
+							contents += DrawSpan( 1, 2, freq * (h+goertzelpoint), target, true );
+						}
+						else if( mode == 2 )
+						{
+							contents += "<TD COLSPAN=2>"
+							if( tgoertzelpi == h-1  ) contents += "<SPAN ONCLICK='Goertz(" + n + ", " + freq * (h-goertzelpointinv) + ", " + goertzelpointinv + ", " + quantaINV + ", 0)'>↓" + goertzelpointinv.toFixed(6) + "</SPAN>";
+							contents += "</TD>";
+						}
+						else if( mode == 3 )
+						{
+							contents += DrawSpan( 1, 2, freq * (h-goertzelpointinv), target, true );
+						}
+					}
+				}
+				contents += "</TD>";
+			}
+		}
+		contents += "</TABLE>";
+	}
+	else if( goertzel2 )
+	{
+		contents += "</TABLE><TEXTAREA ROWS=6 COLS=120 ID=goertzeloutput></TEXTAREA><BR>";
+		contents += "<TABLE BORDER=1>";
+		contents += '<TR><TH>d\\h</div></TH>';
+		for( let h = 0|min_harmonics; h <= max_harmonics+1; h++ )
+		{
+			contents += "<TH COLSPAN=1>" + h + "</TH>";
+		}
+
+		for( let n = 0|28; n <= 96; n++ )
+		{
+			let freq = ( xtal / n );
+			let goertzelpoint = 0;
+			let goertzelpointinv = 0;
+			let tgoertzelp = 0;
+			let tgoertzelpi = 0;
+			let quantaA = 0;
+			let quantaINV = 0;
+
+			for( let rid = 0|0; rid < 2|0; rid++ )
+			{
+				contents += "<TR>";
+				for( let h = -2|min_harmonics; h <= max_harmonics; h++ )
+				{
+					let tquanta = (quanta&0xffffc);
+					let base = freq * h;
+					let next = freq * (h+1);
+
+					let tgoertzelpoint = tquanta;
+					tgoertzelpoint = ( target - base ) / ( next - base );
+					tgoertzelpoint = ((tgoertzelpoint%1)+1)%1;
+
+					quantaA = tquanta;
+					tgoertzelp = h;
+					if( h == -2 )
+					{
+						if( rid == 0 )
+						{
+							contents += "<TD COLSPAN=1 ROWSPAN=2>"
+							contents += "<SPAN ONCLICK='Goertz(" + n + ", " + freq * (h+tgoertzelpoint) + ", " + (tgoertzelpoint) + ", " + quantaA + ", 1)'>↑" + n + "</SPAN>";
+							contents += "</TD>"
+						}
+					}
+					else
+					{
+						if( rid == 0 )
+						{
+							contents += DrawSpan( 1, 1, freq * (h+tgoertzelpoint), target, true );
+						}
+						else
+						{
+							contents += DrawSpan( 1, 1, freq * (h-tgoertzelpoint), target, true );
+						}
+					}
+				}
+				contents += "</TR>";
+			}
+
+
+		}
+		contents += "</TABLE>";
+	}
+
+
+	document.getElementById( "TABLE" ).innerHTML = contents;
+}
+
+function onLoad()
+{
+	onLoadWebHidControl();
+}
+</SCRIPT>
+</HEAD>
+<BODY onLoad="onLoad()">
+
+<TABLE WIDTH=100%>
+<TR>
+<TD COLSPAN=3>
+<p>Tool for computing tuning to specific frequencies by use of direct ADC reading at specific timer-controlled rate to "tune" to specific frequencies either by quadrature or differential.</p>
+</TD>
+<TD ROWSPAN=2 VALIGN=TOP WIDTH=100% ID=LiveGraphContainer>
+<CANVAS WIDTH=100% HEIGHT=200 ID=LiveGraph> </CANVAS>
+</TD>
+</TR>
+<TR>
+<TD VALIGN=TOP>
+<TABLE WIDTH=480>
+<TR><TD>Crystal MHz</TD><TD><INPUT ID=crystalmhz VALUE=144></TD></TR>
+<TR><TD>Target MHz</TD><TD><INPUT ID=targetmhz VALUE=27.019360></TD></TR>
+<TR><TD>Quanta</TD><TD><INPUT ID=quanta VALUE=1024> (Goertzel's Only)</TD></TR>
+<TR><TD>Quanta Search Range</TD><TD><INPUT ID=quantasearch VALUE=64> (Goertzel's Only)</TD></TR>
+<TR><TD>Table Type</TD><TD>
+	<INPUT TYPE=RADIO ID=QUADRATURE NAME=computetype>Quadrature</INPUT>
+	<INPUT TYPE=RADIO ID=GOERTZELS NAME=computetype>Goertzels</INPUT>
+	<INPUT TYPE=RADIO ID=GOERTZEL2 NAME=computetype checked>Goertzel (unalign)</INPUT>
+</TD></TR>
+<TR><TD COLSPAN=2><INPUT TYPE=SUBMIT VALUE="Compute" ONCLICK="computeTable()"></TD></TR>
+</TABLE>
+</TD>
+<TD VALIGN=TOP>
+
+Live Control:
+<TABLE><TR>
+<TD><INPUT TYPE=SUBMIT onClick="reqConnect()" VALUE="Open Device" ID=connectButton>
+<INPUT TYPE=SUBMIT onClick="toggleAudio()" VALUE="Play Audio" ID="ToggleAudioButton">
+<INPUT TYPE=SUBMIT onClick="toggleAudioModulation()" VALUE="modulation" ID="ToggleAudioModulationButton">
+<DIV ID=STATUS></DIV></TD>
+</TR></TABLE>
+<DIV ID="StatusPerf"></DIV>
+</TD>
+
+</TD>
+</TR>
+</TABLE>
+
+<DIV ID=TABLE></DIV>
+
+</BODY>
+</HTML>
@@ -0,0 +1,498 @@
+const expectedProductName = "CNLohr lolra ch32v203 goertzel test";
+const filter = { vendorId : 0x1209, productId : 0xd035 };
+let dev = null;
+let loopAbort = false;
+
+const IQHistoryLen = 4096;
+var IQHistoryArray = new Uint32Array(IQHistoryLen);
+var MPHistoryArray = new Float32Array(IQHistoryLen*2);
+var IQHistoryHead = 0|0;
+var lastIntensity = 1.0;
+var lastNumQ = 0;
+var lastTotalTime = 1;
+var lastTimeUsed = 1;
+
+var graphIsClicked = false;
+
+function graphClick( e )
+{
+	if( e.type == "mousedown" ) graphIsClicked = true;
+	if( e.type == "mouseup" ) graphIsClicked = false;
+	return true;
+}
+
+function setStatus( msg )
+{
+	document.getElementById( "STATUS" ).innerHTML = msg;
+	console.log( msg );
+}
+
+function setStatusError( msg )
+{
+	setStatus( "<FONT COLOR=RED>" + msg + "</FONT>" );
+	console.log( msg );
+	console.trace();
+}
+
+function tryConnect()
+{
+	if( !navigator.hid )
+	{
+		return;
+	}
+	
+	if( !dev )
+	{
+		navigator.hid.getDevices().then( (devices) =>
+		{
+			if( devices.length == 0 )
+				setStatusError( "No devices found. Open a device." );
+			else
+				devices.forEach( tryOpen );
+		});
+	}
+}
+
+async function closeDeviceTool()
+{
+	loopAbort = false;
+	setStatusError( "Disconnected" );
+}
+
+var playingAudioProcessor = null;
+var audioContext = null;
+
+var targetModulation = 0;
+var targetGain = 0.0;
+
+function UpdateButtonNames()
+{
+	document.getElementById( "ToggleAudioButton" ).value = ( targetGain > 0.0 ) ? "Stop Audio" : "Start Audio";
+	document.getElementById( "ToggleAudioModulationButton" ).value = ( targetModulation > 0.5 ) ? "FM" : "AM";
+}
+
+async function toggleAudioModulation()
+{
+	if( playingAudioProcessor != null )
+	{
+		var newVal = 1 - targetModulation;
+		targetModulation = newVal;
+	}
+	UpdateButtonNames();
+}
+
+async function toggleAudio()
+{
+	if( playingAudioProcessor == null )
+	{
+		var bypass = '\
+		class PlayingAudioProcessor extends AudioWorkletProcessor {\
+			static get parameterDescriptors() {\
+			  return [\
+			  	{ name: "gain", defaultValue: 0, },\
+			  	{ name: "sampleAdvance", defaultValue: 0.5, },\
+				]\
+			};\
+			constructor() {\
+				super();\
+				this.rbuffer = new Float32Array(8192); \
+				this.rbufferhead = 0|0; \
+				this.rbuffertail = 0|0; \
+				this.sampleplace = 0.0; \
+				this.dcoffset = 0.0; \
+				this.totalsampcount = 0|0; \
+				\
+				this.port.onmessage = (e) => { \
+					for( var i = 0|0; i < e.data.length|0; i++ ) \
+					{ \
+						let n = (this.rbufferhead + (1|0))%(8192|0); \
+						if( n == this.rbuffertail ) \
+						{ \
+							this.rbuffertail = (this.rbuffertail + (1|0))%(8192|0); \
+							console.log( `Overflow` ); \
+						} \
+						var vv = e.data[i]; \
+						this.dcoffset = this.dcoffset * 0.995 + vv * 0.005; \
+						this.rbuffer[this.rbufferhead] = vv - this.dcoffset; \
+						this.rbufferhead = n; \
+					} \
+				}; \
+			}\
+			\
+			process(inputs, outputs, parameters) {\
+				/*console.log( parameters.gain[0] );*/ \
+				/*console.log( this.ingestData );*/ \
+				let len = outputs[0][0].length; \
+				const sa = Math.fround( parameters.sampleAdvance[0] ); /*float*/ \
+				var s = Math.fround( this.sampleplace );      /*float*/ \
+				var tail = this.rbuffertail | 0;              /* int*/  \
+				var tailnext = this.rbuffertail | 0;          /* int*/  \
+				if( tail == this.rbufferhead ) { console.log( "Underflow " ); return true; }\
+				var tsamp = Math.fround( this.rbuffer[tail] ); \
+				var nsamp = Math.fround( this.rbuffer[tailnext] ); \
+				this.totalsampcount += len|0; \
+				for (let b = 0|0; b < len|0; b++) { \
+					s += sa; \
+					var excess = Math.floor( s ) | 0; \
+					if( excess > 0 ) \
+					{ \
+						s -= excess; \
+						tail = ( tail + (excess|0) ) % (8192|0); \
+						tailnext = ( tail + (1|0) ) % (8192|0); \
+						if( tail == this.rbufferhead ) { console.log( "Underflow" ); break; } \
+						tsamp = Math.fround( this.rbuffer[tail] ); \
+						nsamp = Math.fround( this.rbuffer[tailnext] ); \
+					} \
+					var valv = tsamp * (1.0-s) + nsamp * s; \
+					outputs[0][0][b] = valv*parameters.gain[0]; \
+				} \
+				/*console.log( tail + " " + this.rbuffertail + " " + tsamp + " " + nsamp );*/ \
+				this.rbuffertail = tail; \
+				this.sampleplace = s; \
+				return true; \
+			} \
+		} \
+		\
+		registerProcessor("playing-audio-processor", PlayingAudioProcessor);';
+
+		// The following mechanism does not work on Chrome.
+		//	const dataURI = URL.createObjectURL( new Blob([bypass], { type: 'text/javascript', } ) );
+
+
+		// Extremely tricky trick to side-step local file:// CORS issues.
+		// https://stackoverflow.com/a/67125196/2926815
+		// https://stackoverflow.com/a/72180421/2926815
+		let blob = new Blob([bypass], {type: 'application/javascript'});
+		let reader = new FileReader();
+		await reader.readAsDataURL(blob);
+		let dataURI = await new Promise((res) => {
+			reader.onloadend = function () {
+				res(reader.result);
+			}
+		});
+
+		audioContext = new AudioContext();
+
+		await audioContext.audioWorklet.addModule(dataURI);
+
+		playingAudioProcessor = new AudioWorkletNode(
+			audioContext,
+			"playing-audio-processor"
+		);
+		playingAudioProcessor.connect(audioContext.destination);
+		audioContext.resume();
+
+		let gainParam = playingAudioProcessor.parameters.get( "gain" );
+		gainParam.setValueAtTime( 0, audioContext.currentTime );
+	}
+
+	var newVal = 0.1 - targetGain;
+	console.log( "Setting gain to: " + newVal );
+	let gainParam = playingAudioProcessor.parameters.get("gain");
+	gainParam.setValueAtTime( newVal, audioContext.currentTime);
+	targetGain = newVal;
+	document.getElementById( "ToggleAudioButton" ).value = ( newVal > 0.5 ) ? "Stop Audio" : "Start Audio";
+	UpdateButtonNames();
+}
+
+function onLoadWebHidControl()
+{
+	liveGraph = document.getElementById( "LiveGraph" );
+	liveGraph.addEventListener( "mousedown", graphClick );
+	liveGraph.addEventListener( "mouseup", graphClick );
+
+	UpdateButtonNames();
+	setTimeout( sendLoop, 1 );
+
+	if( !navigator.hid )
+	{
+		setStatusError( "Browser does not support HID." );
+		document.getElementById( "connectButton" ).hidden = true;
+	}
+	else
+	{
+		navigator.hid.addEventListener("disconnect", (event) => { if( event.device.productName == expectedProductName ) closeDeviceTool(); } );
+	}
+
+	setTimeout( () => { elapsedOK = true; }, 3000 );
+
+}
+
+function reqConnect()
+{
+	loopAbort = true;
+	const initialization = navigator.hid.requestDevice( { filters: [ filter ] } );
+	initialization.then( gotUSBDevice );
+	initialization.catch( setStatusError );
+}
+
+function gotUSBDevice(result)
+{
+	if( result.length < 1 )
+	{
+		setStatusError( "Error: No devices found" );
+		return;
+	}
+
+	if( result[0].productName != expectedProductName )
+	{
+		setStatusError( "Error: Wrong device name.  Got " + result[0].productName + " Expected " + expectedProductName );
+		return;
+	}
+
+	const thisDev = result[0];
+	
+	tryOpen( thisDev );
+}
+
+function tryOpen( thisDev )
+{
+	thisDev.open().then( ( result ) => {
+		if( result === undefined )
+		{
+			if( dev ) dev.close();
+			loopAbort = false;
+			dev = thisDev;
+			setStatus( "Connected." );
+		}
+		else
+		{
+			setStatusError( "Error: Could not open; " + result );
+		}
+	} ).catch( (e) => setStatusError( "Error: Could not open; " + e ) );
+}
+
+let sendReport = null;
+let receiveReport = null;
+
+async function sendLoopError( e )
+{
+	sendReport = null;
+	receiveReport = null;
+	if( dev ) await dev.close();
+	dev = null;
+	setStatusError( e );
+}
+
+function updateWebHidDeviceWithParameters( paramlist )
+{
+	var i = 0|0;
+	var arraySend = new Uint8Array(63);
+	for( var i = 0|0; i < paramlist.length|0; i++ )
+	{
+		var vv = paramlist[i] | 0;
+		arraySend[i*4+7] = (vv>>0)&0xff;
+		arraySend[i*4+8] = (vv>>8)&0xff;
+		arraySend[i*4+9] = (vv>>16)&0xff;
+		arraySend[i*4+10] = (vv>>24)&0xff;
+	}
+	arraySend[3] = paramlist.length | 0;
+	sendReport = dev.sendFeatureReport( 0xAC, arraySend ).catch( sendLoopError );
+	if( !sendReport ) sendLoopError( "error creating sendFeatureReport" );
+}
+
+FMiirphase = 0.0; /* for FM */
+FMlastphase = 0.0; /* for FM */
+FMphaseout = 0.0; /* for FM */
+
+
+async function sendLoop()
+{
+	const sleep = ms => new Promise(r => setTimeout(r, ms));
+	var frameNo = 0|0;
+	var lastTime = performance.now();
+	let goodCount = 0;
+	let badCount = 0;
+	let kBsecAvg = 0;
+	let xActionSecAvg = 0;
+
+	while( true )
+	{
+		if( dev && !loopAbort )
+		{
+			receiveReport = dev.receiveFeatureReport( 0xAD ).catch( sendLoopError );
+			if( !receiveReport ) sendLoopError( "error creating receiveReport" );
+
+			frameNo++
+
+			const updateStatsPerfPer = 4;
+			if( frameNo % updateStatsPerfPer == 0 )
+			{
+				let thisTime = performance.now();
+				let deltaTime = thisTime - lastTime;
+				let kBsec = (255*1000/1024*updateStatsPerfPer)/(deltaTime);
+				let xActionSec = (2*updateStatsPerfPer*1000)/(deltaTime);
+				kBsecAvg = kBsecAvg * 0.9 + kBsec * 0.1;
+				xActionSecAvg = xActionSecAvg * 0.9 + xActionSec * 0.1;
+
+				document.getElementById( "StatusPerf" ).innerHTML = 
+					(kBsecAvg).toFixed(2) + " kBytes/s<br>" +
+					(xActionSecAvg).toFixed(2)  + "transactions/sec<br>" +
+					"Count: " + goodCount + " / " + badCount;
+				lastTime = thisTime;
+			}
+			else if( frameNo % updateStatsPerfPer == 2 )
+			{
+				const ctx = liveGraph.getContext("2d");
+
+				if( !graphIsClicked )
+				{
+					let liveGraphContainer = document.getElementById( "LiveGraphContainer" );
+					liveGraph.width = liveGraphContainer.clientWidth;
+					liveGraph.style.position = 'absolute';
+
+					ctx.clearRect(0, 0, liveGraph.width, liveGraph.height);
+
+
+					var filledness = lastNumQ * 198 / 120;
+					ctx.fillStyle = "rgb( 240 240 240 )";
+					ctx.fillRect( 2, 2 + 198 - filledness, 18, filledness - 2);
+
+					filledness = ( lastTimeUsed * 1.0 / lastTotalTime ) * 198;
+					ctx.fillStyle = "rgb( 240 240 240 )";
+					ctx.fillRect( 26, 2 + 198 - filledness, 18, filledness - 2 );
+
+					ctx.fillStyle = `rgb( 255 255 255 )`;
+
+					let mulcoeff = 10000.0 / lastIntensity;
+
+					var lot = 1.2;
+					var x = 253;
+					for( var i = (IQHistoryHead-1) & (IQHistoryLen-1); i != IQHistoryHead|0; i = (i - 1 + IQHistoryLen) & (IQHistoryLen-1) )
+					{
+						let power = MPHistoryArray[i*2+0]; //Math.sqrt( real * real + imag * imag ) * mulcoeff;
+						let phase = MPHistoryArray[i*2+1]; //Math.atan2( real, imag ) * 0.159155078*0.5;
+						ctx.fillRect(x,power*120+10,2,2);
+						ctx.fillRect(x,phase*80+110,2,2);
+
+						let v = IQHistoryArray[i];
+						let real = (v >> 16);
+						let imag = (v & 0xffff);
+						if( real > 32767 ) real -= 65536;
+						if( imag > 32767 ) imag -= 65536;
+						real = real * mulcoeff + 100;
+						imag = imag * mulcoeff + 100;
+						if( real < 0 ) real = 0; if( real > 255 ) real = 255;
+						if( imag < 0 ) imag = 0; if( imag > 255 ) imag = 255;
+						x++;
+						if( lot > 0 )
+						{
+							ctx.globalAlpha = lot;
+							ctx.fillRect(real+50,imag,2,2);
+						}
+						ctx.globalAlpha = 1.0;
+						lot -= 0.0015;
+					}
+
+					ctx.strokeStyle = "rgb( 128 128 128 )";
+					ctx.fillStyle = "rgb( 128 0 0 )";
+					ctx.strokeRect( 1, 1, 20, 198 );
+					ctx.strokeRect( 25, 1, 20, 198 );
+					ctx.strokeRect( 49, 1, 200, 198 );
+					ctx.strokeRect( 253, 1, liveGraph.width, 198 );
+				}
+			}
+
+
+			if( sendReport )
+			{
+				await sendReport;
+			}
+			if( receiveReport )
+			{
+				let receiveData = await receiveReport;
+				if( receiveData && receiveData.buffer )
+				{
+					let data = new Uint32Array( receiveData.buffer.slice( 0, 508 ) );
+					let intensity = data[0]>>8;
+					let numq = data[0] & 0xff;
+					let time_total = data[1]>>16;
+					let time_used  = data[1]&0xffff;
+					let sample_divisor  = data[2]&0xffff;
+					let demodbuffer = new Float32Array(numq);
+					let mulcoeff = 100.0 / lastIntensity;
+					for( var i = 0|0; i < numq; i++ )
+					{
+						let vv = IQHistoryArray[IQHistoryHead] = data[i+3];
+						let vi = vv >> 16;
+						let vq = vv & 0xffff;
+						if( vi >= 32768 ) vi = vi-65535;
+						if( vq >= 32768 ) vq = vq-65535;
+						let power = Math.sqrt( vi * vi + vq * vq ) * mulcoeff;
+						let phase = Math.atan2( vi, vq ) * 0.159155078 + 0.5;
+						MPHistoryArray[IQHistoryHead*2+0] = power; //Math.sqrt( real * real + imag * imag ) * mulcoeff;
+						MPHistoryArray[IQHistoryHead*2+1] = phase; //Math.atan2( real, imag ) * 0.159155078*0.5;
+						if( targetModulation == 0 )
+						{ /* AM */
+							demodbuffer[i] = power;
+						}
+						else if( targetModulation == 1 )
+						{ /* FM */
+							var diffphase = phase - FMlastphase;
+							FMlastphase = phase;
+							if( diffphase - FMiirphase < 0.0 ) diffphase += 1.0;
+							if( diffphase - FMiirphase > 1.0 ) diffphase -= 1.0;
+							FMiirphase = FMiirphase * 0.999 + diffphase * 0.001;
+							diffphase -= FMiirphase;
+							if( diffphase > 0.5 ) diffphase -= 1;
+							if( diffphase <-0.5 ) diffphase += 1;
+							var po = FMphaseout = FMphaseout * 0.993 + diffphase;
+							if( po < 0.0 ) po += 1.0;
+							if( po > 1.0 ) po -= 1.0;
+							demodbuffer[i] = po;
+						}
+
+						IQHistoryHead = (IQHistoryHead+1)%IQHistoryLen;
+					}
+					lastIntensity = intensity;
+					lastNumQ = numq;
+					lastTotalTime = time_total;
+					lastTimeUsed = time_used;
+
+					if( audioContext != null && playingAudioProcessor != null )
+					{
+						// TODO: Use crystalmhz
+						let sampleAdvance = (144000000.0/sample_divisor) / audioContext.sampleRate;
+						let sampleAdvanceParam = playingAudioProcessor.parameters.get("sampleAdvance");
+						sampleAdvanceParam.setValueAtTime( sampleAdvance, audioContext.currentTime);
+						playingAudioProcessor.port.postMessage( demodbuffer );
+					}
+					goodCount++;
+				}
+				else
+				{
+					badCount++;
+				}
+			}
+		}
+		else if( loopAbort )
+		{
+			if( dev )
+			{
+				console.log( "Loop Aborting, Dev Closing" );
+				await dev.close();
+				console.log( "Loop Aborting, Dev Closed." );
+				dev = null;
+			}
+			await sleep(100);
+		}
+		else
+		{
+			// Try opening dev.
+			console.log( "Attempting reconnect." );
+			tryConnect();
+			goodCount = 0;
+			badCount = 0;
+			let i = 0|0;
+			for( i = 0; i < 10; i++ )
+			{
+				await sleep(100);
+				if( dev )
+				{
+					//break;
+				}
+			}
+		}
+	}
+}
+
Author	SHA1	Message	Date
cnlohr	84b7b478c0	Almos thtere maybe?	2024-07-13 01:49:39 -07:00
cnlohr	64c8253055	Working with arbitrary goertzel's	2024-07-13 01:19:46 -07:00
cnlohr	7f3ebcc732	eh different printf	2024-07-12 02:02:41 -07:00
cnlohr	e9f97f7757	CB FM working	2024-07-12 01:54:24 -07:00
cnlohr	8cf6fa53a9	Add note for future work	2024-07-11 02:07:41 -07:00
cnlohr	0379e7cb30	Fixup audio - now working with javascript.	2024-07-11 02:04:28 -07:00
cnlohr	5028657d02	Add shim to add sound	2024-07-10 02:29:02 -07:00
cnlohr	21e6aab95c	Tweak HTML	2024-07-09 03:36:03 -07:00
cnlohr	6c7adbdcc2	Making good progress.	2024-07-09 03:18:12 -07:00
cnlohr	edede9d517	Lots of general updates. closing in on a solution	2024-07-09 02:17:18 -07:00
cnlohr	e0d41ca056	Fix a multitude of bugs. Some sillier than others.	2024-07-08 23:52:42 -07:00
cnlohr	d206128b38	Cleanup - only store I/Q samples	2024-07-07 04:00:49 -07:00
cnlohr	0a6e76034f	Progress on goertzel's work in conjunction with web.	2024-07-07 03:44:51 -07:00
cnlohr	4fe9638062	Let's try to get iir goertzel working	2024-07-02 00:38:25 -07:00
cnlohr	0f71fdafe0	Progress so far - giving up for tonight	2024-06-26 02:08:31 -07:00
cnlohr	a8ab17013f	Switch to FM transmitter sweep	2024-06-25 03:14:43 -07:00
cnlohr	41ec379ad6	Update with 27.025MHz receiver too	2024-06-25 02:55:45 -07:00
cnlohr	e0db86d513	update calculator notes	2024-06-25 02:40:43 -07:00
cnlohr	26d8facf2c	Update all files + calculator. Working with FM Stations	2024-06-25 02:39:10 -07:00
cnlohr	25dc0234c0	Update table working with goertzel's	2024-06-24 03:32:34 -07:00
cnlohr	2b75c51cd9	Update calculator to handle goertzel	2024-06-24 02:48:18 -07:00
cnlohr	9f0cc2c50d	Add print for intensity	2024-06-24 01:38:14 -07:00
cnlohr	5067970ec3	Goertzel's works!	2024-06-24 01:20:02 -07:00
cnlohr	64335ae653	Goertzels is working	2024-06-23 23:32:35 -07:00
cnlohr	7052e8c111	Why no math good	2024-06-23 20:58:33 -07:00
cnlohr	70caf8b76a	update with goertzel	2024-06-23 01:11:18 -04:00
cnlohr	17b7d3fdcb	Working FFT	2024-06-23 01:10:57 -04:00
cnlohr	9bbca912a0	Add test fft	2024-06-22 04:58:22 -07:00
cnlohr	696701ffb7	Ok, done for 27MHz	2024-06-22 02:30:55 -07:00
cnlohr	f31cb4595d	Functioning w/ speaker	2024-06-22 02:23:53 -07:00