Generating CW from GPIO

Question

I'm working on a project whereby I want to use the Pi to send some morse code (CW) over FM by feeding the CW signal into the mic input of a handheld radio I've stripped down.

The idea stems from this website where the chap is using a PIC based solution to generate some hard coded CW and feed into the mic input of the rig. I built one of these and downloaded his code and it works great.

Instead of using a PIC, can I use the Pi? I have some basic code to send logical 1's and 0's to the GPIO pin, actually the code I've doctored from various sites detailing how to send RTTY in C, but essentially its about switching the pin on / off at the right times. I dont get how the PIC itself generates audio. When i've tried putting the GPIO pin connected to the mic input, I'm not getting anything. I didnt really expect to, but I cant even make out any discernable changes in voltage.

Am I barking up the wrong tree? Any pointers appreciated.

Answer 1

You're actually pretty close at this point. The problem is that Morse code works on the basis of a carrier wave. That is to say a tone is either generated or not. While this is similar to binary on/off logic, the latter is actually simply a case of on or off of a static signal. It's the difference between generating ___----___--__ and generating ___-^_-___-^__.

The way the guy you linked does this is by turning the pin on and off very rapidly when transmitting so that a square wave approximates the sine wave a normal Morse code transmitter would use. This is different from simply turning the pin on and off. What you get as a result is a tone generated that sounds a bit more jagged than normal, but is a tone. His code uses a 1 millisecond delay, so you get an approximate frequency of 1000 Hz out. It should be possible to implement this on the Pi, but keep in mind that the Pi isn't real-time so it may hiss and stutter a little bit. It should still be understandable.

The guy's code for transmit a dah looks like this:

dah     MOVLW       01      ;   subroutine to do dah
        MOVWF       2E
agn3dah MOVLW       dahlen
        SUBWF       2E,W
        BTFSC       03,0
        GOTO        enddah
        BSF         06,1    ;   turn on pin B1
        MOVLW       01
        MOVWF       30
        CALL        time    ;   wait 1 millisecond
        BCF         06,1    ;   turn off pin B1
        MOVLW       01
        MOVWF       30
        CALL        time    ;   wait 1 millisecond
        MOVF        2E,W
        INCF        2E,F
        GOTO        agn3dah ;   loop up to do it again.
enddah  MOVLW       3C      ;   add a small delay
        MOVWF       30
        CALL        time    ;   wait 1 millisecond
        RETLW       00

That's a horrible mess of assembly, but it translate to something roughly like this in Python:

import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(27, GPIO.OUT)
GPIO.output(27, GPIO.LOW)

def dah():
    for i in range(1, 99):
        GPIO.output(27, GPIO.HIGH)
        time.sleep(0.001)
        GPIO.output(27, GPIO.LOW)
        time.sleep(0.001)
    time.sleep(0.001)

The other approach would be to use something like a buzzer connected to the GPIO pin.