GKOS Keyboard Mockup

I spent some time this week mocking up the GKOS keyboard using some clay. I have the Cherry MX "Black" switches now and will need to make PCBs for each set of  the three switch groups. The mock up taught me that I need some thickness between the fingers and thumbs for it to feel natural and comfortable. Another discovery is that I believe I build can build this using aluminum "L" channel and PCB material to bolt it together. I may even be able to make it folding!

QRSS with Si5351

As I mentioned in my previous post, I have been experimenting with the Adafruit Si5351A Breakout Board and today I thought I would do some frequency stability tests using the QRSS tool Spectran. This tool will enable me to see variation in frequency with sub-hertz resolution.

Using the NT7S Library I setup the following in the loop() section of the Arduino code

Code Snippet

As you can see, all I am doing is setting the frequency to 7.083.000 Mhz (in the 40 Meter band), then after 10 seconds, I set the frequency to 7.083.001 Mhz which is just 1 Hz higher for 5 seconds and repeat. The plot below using Spectran is showing the clock board being received by my FT-817 transceiver with my dipole antenna. The bread board was in the house about 20-30 feet from the antenna with just a 4 inch piece of wire as it's antenna. From left to right, I had been running it for over 10 minutes then I powered it down for about 2 minutes and then powered it back up. When it powered up again, it was about 5 Hz higher than before being shutdown, then after about 5 minutes it was back to where it was before I powered down (pretty cool!). The full width of the plot is 10 minutes and shows less than a 1 Hz variation over that period (again, very cool!).

I would say that this board with a bare Arduino chip would be a great option for a QRSS beacon module as well as the other uses we have discussed. The more I use the Si5351, the more I like it.

Si5351 Clock Module

I ordered a couple of the Adafruit Si5351 Clock Modules that arrived this week, and quickly soldered up the header and plugged it into a breadboard.




I first tried the Adafruit library and verified its ability to generate multiple output clocks, however it is a bit crude compared the NT7S Library. To use his Library I did find I needed to use the latest Arduino IDE for his example sketch to compile. After that it was very easy to generate any frequency in the HF range.

This module will be useful in many projects. People are using them in place of the standard DDS modules. In fact M0XPD as released an awesome dual VFO sketch with LCD display and rotary encoder.

GKOS Keyboard for Arduino

I built up a 6 switch keypad for use with the Arduino GKOS keyboard Library . I used small surface mount switches and super glued them to a PCB with a three foot ribbon cable.




This worked OK but it is hard to do key presses with more than 3 key chords with these switches. I will need to rebuild the keyboard using something like Cherry mechanical keyboard switches. With the minimal practice I have had with GKOS it seems like it is learn-able and usable with the help of a keyboard layout graphic. I would place this graphic on the side of the keyboard facing the user.

The Arduino Library provided by the Gkos_library is excellent and implements the full GKOS chord set. I did have a few issues getting it up and running and needed to make some quick updates to the library and the example code since it was developed a few years back. Here is the modified example code I used:

1:  /* Test your Gkos with the Serial Monitor of the Arduino IDE  
2:  This is a simple test to check that your GKOS keypad is  
3:  working, by showing on serial monitor the text you type.  
4:  */  
5:  #include <Gkos.h>  
6:   char* gEntry = "";   
7:  // Initialize Gkos library with pin numbers for keys A to F.  
8:  // Digital pins 14...19 are the same as analog pins 0...5  
9:   Gkos gkos(14, 15, 16, 17, 18, 19);  
10:  void setup(){  
11:   Serial.begin(9600); // Set up Serial library at 9600 bps.  
12:   // Use the Arduino SDE Serial Monitor to view the output!   
13:  }  
14:  void loop(){  
15:   gEntry = gkos.entry(); // Will return empty immediately if no entry  
16:   if (gEntry != 0){gPrint();}  
17:   // Add your other code here  
18:  }  
19:  void gPrint(){ // Convert commands depending on your application  
20:   if (strcmp(gEntry, "_Enter") == 0){  
21:     //Serial.println("");  
22:     Serial.write(10); Serial.write(13); return;  
23:   }  
24:   if (strcmp(gEntry, "_BS") == 0){  
25:     Serial.write(8); return;  
26:   }  
27:   if (strcmp(gEntry, "_Del") == 0){  
28:     Serial.write(127); return;  
29:   }  
30:   if (strcmp(gEntry, "_Tab") == 0){  
31:     Serial.write(9); return;  
32:   }  
33:   // Default   
34:   Serial.print(gEntry);  
35:  }  

Here is a link to the modified Library files to replace the existing ones:

Modified Library Files

The next step is to built a better keyboard and perhaps make it a little ergonomic. I am thinking of something in the shape of a standard game pad with the three switches on each side of the wedge operated by your index, middle, and ring fingers.

Arduino Hellschreiber Keyboard

I am looking at keyboard options to use with the Arduino Hellschreiber communicator. I would like something small and portable. There are mini QWERTY keyboards out there, however the Arduino will not support a USB keyboard directly. If the keyboard is downward comparable with the PS2 standard there is library to support that method. The PS2 library is large and will take up most of the Arduino memory though. This made me look at alternate keyboard designs. The alternate designs I have reviewed have significantly fewer keys than the familiar QWERTY keyboard. These methods are mostly based on a Chorded Keyboard. You have fewer keys but you need to press multiple keys at once to produce the different characters. I have now reviewed several of these methods using a very nice application called Autohotkey which is open source and free. Using this application and user submitted scripts I have tried out the following methods:

• T9 - Text on a numeric pad like the old cellphone method
• Frogpad (like) - A reduced size one handed method
• Thumbscript - Another numeric pad method
• ASETIOP - A two handed 10 key method
• Braille - A two handed 8 key method
• 7KAT - A 7 Key Alternate Typing method

Some of the above could not be fully tested due to limitations of my keyboard. Not all keyboards can support pressing 4 or more keys at the same time.

The last method evaluated was GKOS. I could not find a Autohotkey script for it but one could be adapted from the Braille script, however it does require up to 6 keys to be presses at the same time so it would be limited with my keyboard. There is also a program EXE available from the GKOS site that fully implements the method using either keys on your keyboard or the numeric pad that I did experiment with to better understand GKOS. In addition the site also has links to building your own keyboard using 6 switches and an Arduino library!

Since there is an Arduino library, I plan to wire up a 6 key pad and fully test it. This 6 key method seems neat, however it will depend on how quickly it can be learned and if I can obtain a decent typing speed.

I like the idea of this minimal 6 key pad to use on a portable system but it still may not be practical and I will fall back to either a PS2 keyboard or a QWERTY keyboard built from discrete buttons and shift resisters using the Arduino function ShiftIn.