What is on this page:

The software was updated on 7 November, 2000.  Go here for more details.

This page gives a brief overview of the internal workings of the source code, as well as some of the (il)logic behind its design and implementation.  Links to the source code are also provided.

A .HEX file also included for those who do not have a C compiler but wish to program their own processor.

A few words about the source code:

The source code for this is written in a combination of assembly and C (using the CCS PICC compiler.)  I have used this compiler for several years now and have found that, once mastered, can produce very efficient code that rivals hand-tweaked assembly- but, when faced with the need for optimum speed and compactness, I will sometimes insert assembly.  This code, however, wasn't excessively tweaked:  It has been written more for readability than efficiency as appropriate.

As mentioned above, it is compiled with the CCS "PCW" C compiler (their web page may be found at ccsinfo.com) but even if you don't have the compiler, the source code should provide insight as to how it all works.

There are TWO versions of the source code -  Version 1.0x (discussed below) and Version 2.0x (discussed here):

• Version 1.0 is the original code:  This code demonstrates generation of varicode as well as two different methods of producing modulated PSK31.  It is limited, however, to simply repeating a message coded in EEPROM at the time the device was programmed.
• Version 2.0 contains all of the functionality of the original 1.0 code but adds the ability of control via a 1200 baud serial port if pin PB5 is grounded.  Several of the added features are:
• Loading of up to 47 byte long messages into RAM.  This message may be optionally followed by the contents of the EEPROM.  This is useful when used for telemetry that requires both changeable (the datum being sent) as well as "fixed" text, such as callsign.
• Loading of the EEPROM message via the serial port.  This may be done with a host computer or even with a "dumb" terminal.  This completely eliminates the need to have a programmer to change the PIC's EEPROM message.
• Two levels of transmitter keying control:  The PTT_OUT (pin PB0) line may be used to key a power amplifier stage during transmissions.  An additional KEY_OSC line (pin PB1) may be commanded to an ON state via the serial port prior to message transmission in order to give time for an oscillator to stabilize.  These provisions allow minimization of power drain during battery-powered operation.
• Provisions are made for a "Heartbeat" indicator.  An LED may be connected as a diagnostic tool, allowing troubleshooting of the system's transmission and serial interfaces.  This LED may be disabled via the serial port to minimize power consuption.
• A serially-initiated "EEPROM Beacon Mode" that repeatedly sends the EEPROM contents.  Since the bit that controls this mode is stored in EEPROM, selection of this mode is "remembered" even upon powerdown of the PIC.  Additionally, this mode lends itself well to a periodic beacon transmission with the simple addition of a timer such as a 555.  The PIC may also be taken out of the "beacon" mode via the serial port.
• Of course, there is the "Version 1.00 Emulation Mode" that is enabled simply by leaving pin RB5 disconnected.
• Again, version 2.0 is discussed here.

The source code for the PIC-based PSK31 transmitter controller consists of two source code files:  The main body of the source code, and a header file called "varicode.h" that contains the bit patterns for the varicode words.  The "varicode.h" file is the same for the two version  Note that only bytes 0-127 are supported in this implementation (but it would be very easy to expand that to the full 256 byte set if one accepted the penalty of additional ROM usage.)

As with most any C program, one declares variables near the top of the code:  This is no different.  As a quick note, "byte" variables are the same as "unsigned char" which are the same is "char" variables (i.e. there are no signed variables) while "bit" and "short" (both identical) represent a single bit of memory.  In the case of either bits or bytes, either RAM or Program registers (the same thing on the PIC...) may be represented.  In addition to definitions, various constants, masks, and hardware settings.

Also defined are tables containing the modulation waveforms.  In this case, there are two tables:  sintbl (really a "cosine" table) holds half a cosine wave and the pw_sine contains one entire cycle of a cosine waveform.

FSK31 operation:

At this point, it is worth mentioning that pin B3 outputs the current phase of the varicode.  While the original purpose of this signal was for debugging, it was left intact in the event one wished to generate the BPSK modulation envelope by another means (i.e. not using the PWM routine, etc.)  It is also useful for generating FSK31, as this signal need only be applied to a frequency-shift network.  An example of such an application may be found here.  This signal is present in both the  "Balanced Modulator" and "AM" modes.

The Interrupt Service Routine (ISR):

The ISR is invoked at a precise 1 KHz rate (using a 3.579545 MHz NTSC colorburst crystal) and is fine-tuned with a few NOPs.  The first order of business is to reset the ISR's hardware timer.  The next part of the ISR generates the PWM voltage.

The PWM value (which may vary from 1 to 99) is copied, and an "inverse" is calculated.  The total routine consists of (more or less) 100 "loops."  The voltage is proportional to the value held by "PWM" and is generated thusly:

The PWM output pin (PWM_OUT) is normally in a HI-Z state.  When the first portion of the PWM routine is entered, this pin is set high to charge the capacitor on the output pin.  An assembly-language loop counts "PWM" times (for a short delay.)  After this delay has finished, the PWM_OUT pin is set to low to discharge the capacitor as the next loop executes "100-PWM" times.  After this is done, the PWM output is reset to a HI-Z state.  At the finish, the capacitor contains a voltage that is proportional to the value in the PWM variable.  Note that the PWM value is preserved so that it may be re-used on the next pass through the ISR.

After the PWM is generated, a counter keeps track to see if 32 ISR cycles have elapsed (1 bit period.)  If so, it resets the "send_ok" variable to indicate to the driver routines that the current bit is done and that the next bit may be generated.

The next routines generate the PWM data.  The first one generates PWM data for the "Balanced Modulator" method and is activated by grounding pin PB4 (the OUT_MODE pin.)  This routine works as follows:

If the bit in OUT_BIT is 1, the counter sinptr is incremented (unless it is already at a maximum count of 31.)  Conversely, if the bit is 0, the sinptr counter is decremented (unless it is already zero.)  Note that OUT_BIT has already been NRZ-I encoded by the bitsend() function and does not directly reflect a 0 or 1 bit in the varicode character.

If the OUT_MODE pin is left open, the pullup resistor on the 16x84 causes a logic HIGH and the "AM" mode is selected.  It works by looking at the varicode bit to be sent (a copy of which is kept in the mbit_send variable.) If it is a 1, then there is to be no phase shift.  If it is a 0, then the sinptr pointer is cleared to point to the beginning of the PW_SINE table and the mbit_send variable is set to a 1 to indicate that the current bit is being processed (and that we shouldn't try to process it again...)  Once the counter is cleared, it begins counting up and obtaining the PWM values for the ISR.  Once the value hits 31, the modulation sequence is finished (for that bit) and the lookup is halted.  The phase shift output in the AM mode is presented on pin B2 and this is produced by simply toggling the bit as the counter progresses through the PW_SINE table.  Note that the "flip" occurs at the 19th entry in the table instead of exactly at the "bottom" of the waveform:  This is done because the R/C filtering causes a bit of a delay that must be compensated.

Why this sequence of events?  When the ISR is entered, the first priority is to add fine-tuning delays and update counters to prepare the hardware for the next ISR call.  The PWM routine is then called, followed lastly by generating the PWM data for the next call.  If it were not done in this sequence, the varying times of the individual portions of the ISR would cause some phase modulation of the generated waveforms and/or inaccuracies in timing.

The "main()" function:

Skipping down to the bottom of the source code, there is the main() function.  After the hardware is intialized, an endless loop is entered.  The first order of business is to generate a message "preamble" consisting of 81 "zeros" (phase shifts) to cause a program like PSK31SBW to display an accurate intermod reading.

After the preamble, the EEPROM message is started.  This message may use all 64 bytes of EEPROM memory, or it can be shorter, terminated (and thus repeated) by a 0xff signifying end-of-message.

After the character to be sent is retrieved from the EEPROM, it is sent to the lookup_varichar() function where the varicode word is indexed and retreived.  A flag is now set indicating that "character sending" is in progress and the sendbit() function is invoked.  This function shifts out the current varicode bit and determines if this was the last bit of the varicode word, or if there other varicode bits to be sent.  The processor then calls the bitsend() function and waits either for the current bit to be completed, or does the NRZ-M conversion of the current bit and interfaces with the ISR.

The source code:

First, the fine print:

This source code copyright 1999/2000 by Clint Turner.  It may be freely used for non-commercial purposes on provision that credit is given to the source.  There are no warranties expressed or implied.  Suitability of this source code and its application is to be determined by the user.  Federal law prohibits use of this product in a manner inconsistant with its labeling. Not all options available on all models.  Batteries not included.  Do not taunt "Happy Fun Ball."  Your mileage may vary.  Substantial penalties for early withdrawl of funds.  Past performance should not be construed as a guarantee of future performance.

As of 7 November, 2000, the source code was updated to version 1.01 (file name:   psk31e3.*)  In this version, a minor bug was fixed that prevented the 81 zeroes (the "warble") from being sent between message repeats when the EEPROM message was exactly 64 bytes.  Also, the "sine" tables were fixed, greatly improving intermod reports.

Now, here are the source code files:

psk31e3.c The actual version 1.01 source code in C and assembly using the CCS PIC C compiler
varicode.h A header file containing the PSK31 varicode

And here is a compiled .HEX file intended for the 16C84 or 16F84:

psk31e3.hex  A HEX file suitable for importing into MPLAB (available from the Microchip website at www.microchip.com) and burning into the processor.

WARNING:  You will want to customize the message to suit your tastes.  As provided, the following text will be sent:

Your message goes here. It may contain up to 64 characters

Not very exciting, huh...  Read below to find out to make it say what you want it to say.

Conclusion:

Hopefully, between source code documentation and this description, you can make some sense out of it all.  A few things to note, in case you didn't read the above very carefully (or if I just confused you:)

• The "balanced modulator" mode or the "AM" mode may be selected by grounding or leaving open pin PB4 (respectively.)  In either mode, the OUT_BIT pin (PB3) will carry a logic-level signal that is the PSK31 code which could be applied directly to an XOR gate (as might be done in the case of a LowFER transmitter.)  Note that in the AM mode (and only in the AM mode) the OUT_PHASE pin (PB2) will carry this same information, but it will be delayed to be coincident with the lowest modulation voltage.  The logic level on this pin is undefined when in the "balanced modulator" mode.
• Pin PB3 of the PIC outputs a logic level that contains information on the current phase being transmitted.  If FSK31 operation is desired this signal may be applied directly to a frequency-shift circuit.  An example is given here.
• If a different filter is used (replacing the R/C filter) for the PWM output, the "threshold" for the bit-flipping of the OUT_PHASE pin (PB2) will have to be changed to compensate for the filter delay.  I will shortly be re-designing the transmitter with this change and will make the appropriate adjustments at that time.
• If a different crystal is used for the PICs clock, the ISR timing will have to be completely recalculated and readjusted.  You are on your own to do this, but if you do, let me know and I'll document the changes here.
• To customize your beacon message, simply put it in the EEPROM.  This may be done either in the source code (if you have the compiler) or in the programmer's software.  In the case of MPLAB, for instance, the EEPROM memory can be directly edited and your own message may be inserted.  Remember that only ASCII codes 0-127 are supported with the source code supplied.  If your message doesn't contain exactly 64 bytes (completely filling the EEPROM) then remember to terminate it with a 0xff.

Return to the PSK MedFER page

Any comments or questions?  Send an email!