SWHarden.com

The personal website of Scott W Harden

Debut of the AJ4VD QRSS Gator

``` qrss``` ``` obsolete```

I re-wrote the code from the previous entry to do several things. Once of which was to make a gator rather than a fish. It’s more appropriate since I’m planning on housing the transmitter at the University of Florida. To do it, I drew a gator in paint and wrote a python script to convert the image into a series of points. I’ll post it later. One thing to note was that size was a SERIOUS issue. I only have two thousand bytes of code, and every point of that gator was a byte, so it was a memory hog. I helped it dramatically by using repeating segments wherever possible, and some creative math to help out the best I could (i.e., the spines on the back) Here’s what it looks like, and the code below it…

``````#include <avr/io.h>
#include <util/delay.h>

// front top LED - PA0
// inside top LED - PA1
// inside bot LED - PA2
// front bot LED - PA3

unsigned long int t_unit; // units of time
const int tDit = 100;     //units for a dit
const int tDah = 255;     //units for a dah
char fsk;                 // degree of frequency shift to use for CW
char fsk2;                // degree of frequency shift to use for HELL

char light = 0; // which lights are on/off

void delay()
{
_delay_loop_2(t_unit);
}

{
return;
if (light == 0)
{
PORTA |= (1 << PA0);  //on
PORTA |= (1 << PA1);  //on
PORTA &= ~(1 << PA2); //off
PORTA &= ~(1 << PA3); //off
light = 1;
}
else
{
PORTA |= (1 << PA2);  //on
PORTA |= (1 << PA3);  //on
PORTA &= ~(1 << PA0); //off
PORTA &= ~(1 << PA1); //off
light = 0;
}
}

void tick(unsigned long ticks)
{
while (ticks > 0)
{
delay();
delay();
ticks--;
}
}

void pwm_init()
{
//Output on PA6, OC1A pin (ATTiny44a)
OCR1A = 0x00;  //enter the pulse width. We will use 0x00 for now, which is 0 power.
TCCR1A = 0x81; //8-bit, non inverted PWM
TCCR1B = 1;    //start PWM
}

void set(int freq, int dly)
{
OCR1A = freq;
tick(dly);
}

void fish()
{
char mult = 3;

char f2[] = {2, 3, 4, 5, 6, 7, 4, 3, 7, 4, 7, 7, 6, 5, 4, 3, 2, 2, 2, 3, 3, 3, 2, 2, 2, 3, 3, 3, 2, 2, 2, 3, 4, 5, 6, 7, 8, 4, 9, 5, 9, 6, 9, 6, 9, 6, 9, 8, 8, 7, 7, 6, 5, 4, 3, 3, 3, 4, 5, 5};

for (int i = 0; i < sizeof(f2); i++)
{
OCR1A = f2[i] * mult;
tick(20);
OCR1A = 1 * mult;
tick(20);
}

char f3[] = {1, 2, 3, 4, 3, 2};

char offset = 0;
while (offset < 9)
{
for (char j = 0; j < 3; j++)
{
for (char i = 0; i < sizeof(f3); i++)
{
char val = (f3[i] + 5 - offset) * mult;
if (val < mult || val > 10 * mult)
{
val = mult;
}
OCR1A = val;
tick(20);
OCR1A = 1 * mult;
tick(20);
}
}
offset++;
}
}

void id()
{
char f[] = {0, 0, 1, 2, 0, 1, 2, 2, 2, 0, 1, 1, 1, 1, 2, 0, 1, 1, 1, 2, 0, 2, 1, 1, 0, 0};
char i = 0;
while (i < sizeof(f))
{
if (f[i] == 0)
{
OCR1A = 0;
tick(tDah);
}
if (f[i] == 1)
{
OCR1A = fsk;
tick(tDit);
}
if (f[i] == 2)
{
OCR1A = fsk;
tick(tDah);
}
OCR1A = 0;
tick(tDit);
i++;
}
}

void slope()
{
char i = 0;
while (i < 25)
{
OCR1A = 255 - i;
i++;
}
while (i > 0)
{
i--;
OCR1A = 255 - i;
}
}

int main(void)
{
DDRA = 255;
pwm_init();
t_unit = 1000;
fsk = 10;
id(); // set to fast and ID once
//fsk=50;//t_unit = 65536; // set to slow for QRSS
t_unit = 60000;

while (1)
{
;
fish();
id();
}

return 1;
}
``````

Debut of the AJ4VD QRSS Fish

``` python``` ``` qrss``` ``` obsolete```

Finally! After a few years tumbling around in my head, a few months of reading-up on the subject, a few weeks of coding, a few days of bread-boarding, a few hours of building, a few minutes of soldering, and a few seconds of testing I’ve finally done it - I’ve created my first QRSS transmitter! I’ll describe it in more detail once I finalize the design, but for now an awesome working model. It’s all digital, consisting of 2 ICs (an ATTiny44a for the PWM-controlled frequency modulation, and an octal buffer for the pre-amplifier) followed by a simple pi low-pass filter.

My desk is a little messy. I’m hard at work! Actually, I’m thinking of building another desk. I love the glass because I don’t have to worry (as much) about fires. That sounds scary, I know.

This is the transmitter. The box is mostly empty space, but it consists of the circuit, an antenna connection, a variable capacitor for center frequency tuning, and a potentiometer for setting the degree of frequency shift modulation.

__Yeah, that’s a fishy. __Specifically a goldfish (the cracker). It’s made with a single tone, shifting rapidly (0.5 sec) between tones. So cool. Anyway, I’m outta here for now - getting back to the code! I think I’ll try to make a gator next…

Here’s the code that makes the fish. It sends my ID quickly, some fish, then my ID in QRSS speed using PWM.

``````#include <avr/io.h>
#include <util/delay.h>

const int tDit = 270 / 3;
const int tDah = 270;

char fsk;
unsigned long int t_unit;

void delay()
{
_delay_loop_2(t_unit);
}

{
PORTA ^= (1 << 0);
PORTA ^= (1 << 1);
PORTA ^= (1 << 2);
PORTA ^= (1 << 3);
}

void tick(unsigned long ticks)
{
while (ticks > 0)
{
delay();
delay();
ticks--;
}
}

void pwm_init()
{
//Output on PA6, OC1A pin (ATTiny44a)
OCR1A = 0x00;  //enter the pulse width. We will use 0x00 for now, which is 0 power.
TCCR1A = 0x81; //8-bit, non inverted PWM
TCCR1B = 1;    //start PWM
}

void set(int freq, int dly)
{
OCR1A = freq;
tick(dly);
}

void fish()
{
char f[] = {0, 0, 0, 4, 5, 3, 6, 2, 7, 1, 5, 6, 8, 1, 8, 1, 8, 1, 8, 1, 8, 2, 7, 3, 6, 2, 7, 1, 8, 1, 8, 4, 5, 2, 3, 6, 7, 0, 0, 0};
char i = 0;
while (i < sizeof(f))
{
i++;
OCR1A = 255 - f[i] * 15;
tick(20);
}
}

void id()
{
char f[] = {0, 0, 1, 2, 0, 1, 2, 2, 2, 0, 1, 1, 1, 1, 2, 0, 1, 1, 1, 2, 0, 2, 1, 1, 0, 0};
char i = 0;
while (i < sizeof(f))
{
if (f[i] == 0)
{
OCR1A = 255;
tick(tDah);
}
if (f[i] == 1)
{
OCR1A = 255 - fsk;
tick(tDit);
}
if (f[i] == 2)
{
OCR1A = 255 - fsk;
tick(tDah);
}
OCR1A = 255;
tick(tDit);
i++;
}
}

void slope()
{
char i = 0;
while (i < 25)
{
OCR1A = 255 - i;
i++;
}
while (i > 0)
{
i--;
OCR1A = 255 - i;
}
}

int main(void)
{
DDRA = 255;
PORTA ^= (1 << 0);
PORTA ^= (1 << 1);
pwm_init();

t_unit = 2300;
fsk = 50;
id(); // set to fast and ID once

fsk = 50;
t_unit = 65536; // set to slow for QRSS

while (1)
{
id();
for (char i = 0; i < 3; i++)
{
fish();
}
}

return 1;
}
``````

``` circuit``` ``` qrss``` ``` obsolete```

Success! Amid a bunch of academic exams, psycho-motor tests, and other crazy shenanigans my dental school is putting me through, I managed to do something truly productive! I built a simple QRSS transmitter with an ATTiny44A microcontroller clocked by a 7.04 MHz crystal which generates FSK signals and modulates its own frequency by applying potential to a reverse-biased diode at the base of the crystal, the output (CKOUT) of which is amplified by an octal buffer and sent out through an antenna. As it is, no lowpass filtering is implemented, so noisy harmonics are expected. However for ~2\$ of parts this is an effective QRSS transmitter!

I was able to detect these signals VERY strongly at a station ~10 miles from my house. I haven’t yet dropped in a 10.140 MHz crystal and tried to get this thing to transmit in the QRSS band, but when I do I hope to get reports from all over the world! This is what it looks like:

The cool thing about this transmitter (aside from the fact that it’s so cheap to build) is that it will work with almost any crystal (I think below 20 MHz-ish) - just drop it in the slot and go!

Generate LUTs with Python

``` python``` ``` obsolete```

I wrote a script to generate and display LUTs with Python. There has been a lot of heated discussion in the QRSS Knights mailing list as to the use of color maps when representing QRSS data. I’ll make a separate post (perhaps later?) documenting why it’s so critical to use particular mathematically-generated color maps rather than empirical “looks good to me” color selections. Anyway, this is what I came up with:

For my QRSS needs, I desire a colormap which is aesthetically pleasing but can also be quickly reverted to its original (gray-scale) data. I accomplished this by choosing a channel (green in this case) and applying its intensity linearly with respect to the value it represents. Thus, any “final” image can be imported into an editor, split by RGB, and the green channel represents the original data. This allows adjustment of contrast/brightness and even the reassignment of a different colormap, all without losing any data!

ORIGINAL DATA: (that’s the “flying W” and the FSK signal below it is WA5DJJ)

Note that it looks nice, shows weak signals, doesn’t get blown-out by strong signals, and it fully includes the noise floor (utilizing all available data).

This is the Python script I wrote to generate the downloadable LUTs, graphs, and scale bars / keys / legends which are not posted. It requires python, matplotlib, and PIL.

``````import math
import pylab
from PIL import Image

####################### GENERATE RGB VALUES #######################

r,g,b=[],[],[]
name="Blin_Glin_Rlin"
for i in range(256):
if i>128: #LOW HALF
j=128
k=i
else: #HIGH HALF
k=128
j=i
#b.append((math.sin(3.1415926535*j/128.0/2))*256)
#r.append((1+math.sin(3.1415926535*(k-128*2)/128.0/2))*256)
r.append(k*2-255)
g.append(i)
b.append(j*2-1)

if r[-1]<0:r[-1]=0
if g[-1]<0:g[-1]=0
if b[-1]<0:b[-1]=0

if r[-1]>255:b[-1]=255
if g[-1]>255:g[-1]=255
if b[-1]>255:b[-1]=255

####################### SAVE LUT FILE #######################
im = Image.new("RGB",(256*2,10*4))
for x in range(256):
for y in range(10):
pix[x,y] = (r[x],g[x],b[x])
pix[x,y+10] = (r[x],0,0)
pix[x,y+20] = (0,g[x],0)
pix[x,y+30] = (0,0,b[x])
a=(g[x]+g[x]+g[x])/3
pix[256+x,y] = (a,a,a)
pix[256+x,y+10] = (r[x],r[x],r[x])
pix[256+x,y+20] = (g[x],g[x],g[x])
pix[256+x,y+30] = (b[x],b[x],b[x])
#im=im.resize((256/2,40),Image.ANTIALIAS)
im.save(name+"_scale.png")

####################### PLOT IT #######################
pylab.figure(figsize=(8,4))
pylab.grid(alpha=.3)
pylab.title(name)
pylab.xlabel("Data Value")
pylab.ylabel("Color Intensity")
pylab.plot(g,'g-')
pylab.plot(r,'r-')
pylab.plot(b,'b-')
pylab.axis([-10,266,-10,266])
pylab.subplots_adjust(top=0.90, bottom=0.14, left=0.1, right=0.97)
pylab.savefig(name+"_graph.png",dpi=60)
#pylab.show()

####################### SAVE LUT FILE #######################
f=open(name+".lut",'w')
out="IndextRedtGreentBluen"
for i in range(256):
out+=("t%dt%dt%dt%dn"%(i,r[i],g[i],b[i]))
f.write(out)
f.close()
``````

Rachmaninoff's Bookmarklets

What a hodgepodge of topics my life has become. Yeah, dental school has been rough lately (finals week was last week), but I’m hanging in there and trying to be creative nonetheless. I’ve been dabbling in video motion tracking last week, and am contemplating attacking a project involving a lot of video shooting/editing and possibly some 3D work. It must have been almost 10 years since I last used 3D modeling software! I think it was 3D Studio Max back in the day they required a parallel port dongle and I had to spoof the hardware interface with a script so I could use a hacked version [rolls eyes]. I don’t want to give anything away, so I’ll leave it at that.

I unknowingly stumbled into a new realm of web scripting when I searched for a way to skimp on my teacher evaluations. At the end of each course, many of our professors provide a point of extra credit for completing course evaluations. These things are lengthy, as you have to bubble choices (1-5) on about 30 topics per teacher, and some courses have 15+ teachers. It can take half an hour to click every bubble even for a single course, so I wrote a script to do it for me. Tom Hayward mentioned to me after-the-fact that such a script is called a Bookmarklet. It’s basically some fancy JavaScript with all the line breaks removed so it’s a single line, and with all spaces replaced by %20 such that it’s formatted as a URL. This JavaScript can be bookmarked as a URL, and when it’s clicked the script is run. While it seems to me like a blatantly obvious security risk and a terrible idea, it seems to work on most browsers on most OSes. So, in the hope that this script inspires someone else to be creative, I’ll post the source:

``````javascript: var auto = {
fillerup: function () {
var all_inputs = document.getElementsByTagName('input');
var all_selects = document.getElementsByTagName('select');
var all_textareas = document.getElementsByTagName('textarea');

for (var i = 0, max = all_selects.length; i < max; i++) {
var sel = all_selects[i];
if (sel.selectedIndex != -1 && sel.options[sel.selectedIndex].value) { continue; }
var howmany = 1;
if (sel.type == 'select-multiple') {
var howmany = 1 + this.getRand(sel.options.length - 1);
}
for (var j = 0; j < howmany; j++) {
var index = this.getRand(sel.options.length - 1);
sel.options[index].selected = 'selected';
}
}

for (var i = 0, max = all_inputs.length; i < max; i++) {
var inp = all_inputs[i];
var type = inp.getAttribute('type');
if (!type) { type = 'text'; }
if (type == 'radio') {
var to_update = true;
var name = inp.name;
var input_array = inp.form.elements[inp.name];
for (var j = 0; j < input_array.length; j++) {
if (input_array[j].checked) {
to_update = false; continue;
}
}
if (to_update) {
var index = this.getRand(input_array.length - 1);
input_array[index].setAttribute('checked', 'checked');
}
}
}
}
, getRand: function (count) { return count * Math.random()); }
}; auto.fillerup()
``````

My microchips arrived in the mail! I’m so excited. It’s just in time too, I’m about to build my first [hopefully] functional non-bread-boarded single-chip transmitter (with a single-chip preamplifier) QRSS radio beacon -err, manned experimental propagation transmitter. These chips are smaller than the ATTiny2313’s I’m used to working with, and will be so awesome to work with surface-mount size. I wonder if I trust myself to hand-drill a circuit board for such a SMT microchip using copper-plated PC board? Perhaps with a dental drill? ha! Finally a use for that blasted thing.

Work on my single-chip radio transmitter has stalled. On one hand I have almost all the equipment I need at my apartment (boxes of components, a dremel, a drill press, an excellent soldering station, copious amounts of work space, boxes of tools, and many different types of wire), but I have no high-quality radio to receive any transmissions my device makes at the target frequency (10.140 MHz). However, a radio shack filled with many gorgeous radios exists on the other side of town at the top of Shands hospital! Yeah, I could work on the project using a frequency I could measure with my Century 21 direct-conversion radio (14 MHz or 7 MHz), but it doesn’t seem as exciting doing it this way. I fear I’ll build a beautiful 7 MHz transmitter which doesn’t perform at 10 MHz. Tonight I realized I left my prototype transmitter bread-boarded at the station, and here I sit with nothing to work on (hence my writing). I’ve been dabbling in non-productive projects over the last few weeks - I think it’s time for me to wake up, shape up, and get back to working on something significant! With that, I’m outta here. Time to read some datasheets.