From fcbad0a10400dda0d4b36de70341261344226d26 Mon Sep 17 00:00:00 2001
From: Stuart Griffiths <sagriffiths87@gmail.com>
Date: Sun, 14 Feb 2021 17:00:47 +0000
Subject: [PATCH] First bit of coding for the CW decoder done

---
 cw_decoder.py | 103 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 103 insertions(+)
 create mode 100644 cw_decoder.py

diff --git a/cw_decoder.py b/cw_decoder.py
new file mode 100644
index 0000000..c416058
--- /dev/null
+++ b/cw_decoder.py
@@ -0,0 +1,103 @@
+#CW Decoder for Raspberry Pi Pico
+#Written using MicroPython
+#Written by Stuart Griffiths M0SUD in 2021
+#Status: Initial start to determine whether dits and dahs can be determined
+
+#Physical connections:
+#GP26 to mono audio jack hi
+#0V to mono audio jack GND
+
+#Setup functions
+import machine #to read pins
+import utime #to add delays
+
+#Program to Run
+decoder()
+
+#Objects
+
+#Functions
+def decoder():
+    #Overall program doe decoding
+    #set ADC pin
+    adc_pin = 0 #set to pin GP26
+    adc = machine.ADC(adc_pin)
+    #set squelch tolerance
+    tolerance = float(5)
+    #Do a reading
+    squelch = noise(adc) #establish squelch level
+    #check for data to read
+    while True: #loop forever checking for a high signal.
+        data_value_to_check = adc.read_u16() #read data
+        if data_value_to_check >= (squelch + tolerance): #are we beating squelch?
+            #go do some readings
+            data_to_decode = data_in(adc, squelch, tolerance)
+            decoded_data = decode (data_to_decode)
+        #no need for else as this will loop ADC reading to a check
+
+def noise(adc):
+    #Establish a squelch point to ensure noise does not give false positives
+    #determine squelch point
+    noise1 = adc.read_u16()
+    utime.sleep_ms(250) #sleep for 250 ms, selected at random
+    noise2 = adc.read_u16()
+    utime.sleep_ms(250) #sleep for 250 ms, selected at random
+    noise3 = adc.read_u16()
+    utime.sleep_ms(250) #sleep for 250 ms, selected at random
+    noise4 = adc.read_u16()
+    #determine average noise level
+    noise_sum = noise1 + noise2 + noise3 + noise4
+    squelch_level = noise_sum/4 #average determined
+    return squelch_level
+
+def data_in(adc, squelch, tolerance):
+    #Activated when squelch is passed
+    #Read data in, keep reading until hit a 0 for a specific period of time
+    #Remember, already measured a single 'high'
+    data_value_to_check = adc.read_u16() #read data
+    if data_value_to_check < (squelch + tolerance): #are we beating squelch?
+        #we have a glitch
+        break #go back to the hunt for a signal
+    #set up a method of recording number of samples while HIGH
+    high_in = "HH" #records the 2 highs which got us into the function and through glitch test
+    #need to create a string of highs until a low
+    #then add string to a list
+    #if the low is longer than a string of highs then suggests new character
+    charactor = [] #define the list
+    while i < 100: #arbitary number for long low. i = number of lows in a string?
+        #need to keep looping until transmission is over
+        data_value_to_check = adc.read_u16()
+        if data_value_to_check >= (squelch + tolerance): #Is it high?
+            high_in = high_in + "H" #add a high to the list
+            low_in = "H"
+        elif data_value_to_check < (squelch + tolerance) and low_in[0] == "H":
+            #If it is the first low then write string high_in to list charactor
+            charactor.append(high_in)
+            low_in = "L" #write first L to ensure this loop is avoided for next low
+            high_in = "" #reset the high in string
+            i= i+1 #for the loop exit
+        else:
+            #add another low to the string
+            low_in = low_in + "L"
+            #already reset the high in the first low after a high
+    #Now we have recorded a message. Time to decode!
+    return (charactor)
+
+def decode(data_to_decode):
+    #Parse through a list, detemining dits, dahs and new words
+    #go through the list to find lengths of highs and lows
+    for i in range(len(data_to_decode)):
+        data_check = data_to_decode[i] #read the list item
+        if data_check[0] = 'H':
+            #if high, replace the list value with length of H.
+            data_to_decode[i] = "?H" + len(data_check)
+        elif data_check[0] = 'L':
+            #if low, replace the list value with length of L.
+            data_to_decode[i] = "?L" + len(data_check)
+        else:
+            break #break as there is an error in the list
+    #now we know the lengths of the high and low signals, time to decode
+    #pass through again to establish limits
+    #how to calculate a dit and a dah - comparative with some elemement
+    #of change allowable for straight keys
+    return (words)