Motospeed CK62 – DO NOT BUY THIS KEYBOARD

I recently had the misfortune of buying the Motospeed CK62 (available on Aliexpress). It cost me 50 USD at the time of buying and was supposed to be my gateway in to the exotic world of 60% keyboards.

Looking at the features (Mechanical keyboard, RGB lighting, Bluetooth etc), this keyboard seems almost too good to be true. However, there’s one thing missing in this keyboard, COMMON SENSE!

Let me explain how 60% keyboards normally work. To save space and reduce the number of keys on the keyboard (~60 instead of 104), many of the keys serve multiple functions via what is known as Layers which can be activated by pressing a special modifier key called the function key (Fn key).

For example, it is normal in 60% keyboards to do away with the function keys and just have a row of keys for numbers. The function keys are on another “Layer” and to access them you press the Fn + 1. Similarly to access the up arrow key in a pinch, you press the Fn + W key.

That’s how most 60% keyboards do it. This one however only allows access to the other layers by toggling them. How you ask? BY PRESSING THE FN+1 KEYS AND HOLDING FOR 5 SECONDS!!!

To toggle it back, you press the keys and hold them again FOR 5 SECONDS!!! This renders the keyboard absolutely useless for pretty much all purposes. I don’t know who designed the firmware on this keyboard, but I bet there’s a special place in hell for people like her/him.

If you want to try a 60% budget mechanical keyboard, I would recommend the Anne Pro 2. It is a bit more expensive but isn’t made by Satan himself. It has very good reviews on Youtube as well.

tl;dr – DO NOT BUY THE MOTOSPEED CK62.

PS: The CK61 isn’t as bad as the CK62 as in it toggles the layers as soon as you press the combinations, but it’s still a bad user experience as it only allows for toggling. It doesn’t allow you to simply use the modifier key to switch the layers. I would not recommend the motospeed CK61 either.

Google App Engine – running on a remote linux box (VPS)

So, you’ve been working on a Google App Engine project on your VPS and for some reason, when you type the following command:

dev_appserver.py <projectfolder>

it works, but when you try to access it in your browser from the client machine (your personal PC or laptop from where you’ve ssh’d into), it doesn’t work or gives you a “Connection Timed Out” error.

There are 2 things you need to check when this happens:

1. IPTables – check whether you’ve opened up the port on which the local app server is working on
2. App Server host name and port settings

For IPTables, you just need to make sure the correct rules are set. Since my app server will be running on port 8080, I had to check to see if that port was open or not. The ports can be checked with the following command:

 sudo iptables -nvL –line-numbers

If you don’t see port 8080 opened on the INPUT list, you’ll need to open it.

IPTables works from top to bottom. So, usually, the last entry is to reject everything that doesn’t fit. So, you might need to add the rule in between and for this we use the -I argument. For example, if I want to make this rule the 4th entry in my INPUT list (I have 5 rules), this can be done with the following command:

sudo iptables -I INPUT 4 -p tcp –dport 8080 -j ACCEPT

This should fix the iptables part of things.

Next, we need to fix the app server host and port values. By default app engine server runs on localhost and port 8080. Let’s change that to work with the external IP address of the Linux box and fix it to port 8080:

dev_appserver.py <projectfolder> –host myserver.com –port 8080

And now, if you visit myserver.com, it should work!

KiCAD – Creating a custom component with the same name as an existing component

Short Answer – change the name to be unique!

Long Answer – I was creating my own version of the 74HC595 shift register in KiCad and named it exactly that. When adding it to my own library, and using it in my schema, it kept showing me the stock version. So the fix to this was to right-click on the name in the component editor and change it to something else – “MY74HC595” and save. Hey presto! Problem solved 🙂

AVR Programmer pin configuration and AVRDude and Atmel Studio

Programmer Pin Diagram and Configuration

This post is more for me to remember and access easily in the future since I’ve spent a considerable amount of time doing this (for the second time!).

I have 2 AVR programmers and after a lot of trial and error, I realised that the pinout is different for each of them. Also, the datasheets for both the programmers are hopelessly unclear and show the pinout for the pins on the programmer. When you plug in a ribbon cable and turn it around to face you, the pin configuration becomes a mirror image and it’s quite taxing on the brain to correlate the pin config from the board to the cable. Hence the images below for reference!

OpenVPN on OpenVZ on a VPS – Internet routing

I wanted to route my internet through the VPS using my Windows 7 laptop. It took me more than a day to get this set up. So putting it down here as a reference for the future. My guess is that this is probably something that only a first-time user of VPS will encounter. The other times, you would have been forced to learn it and you don’t have to go through the difficulty again. Once you know how to do it, it will probably take you 20mins end to end.

But anyways, long story short, this is what you need to know:

• OpenVPN configuration – I am not kidding, definitely go through this page. It will take around 20-30 mins, but that’s the best way to do it. Otherwise you’ll keep wondering whether the issue lies with OpenVPN or with something else
• IPTables configuration – A good tutorial that will really get you started on the hows and whats. Read it carefully, you’ll need it.

Here’s how I did it. I’m setting up VPN to route my Internet traffic through the VPS server. We’ll break it down step by step.

Part 4 – Getting started with a 128×64 Graphics LCD Display – Pin configuration

In the previous part, we saw how to instruction set works and how the different pins fit together to make the GLCD work. In this part, we’ll pick a particular microcontroller and try to work out how to configure the pins.

The JHD12864E works in a parallel mode. By parallel, I mean that the data is passed in one shot which is by the data pins D0-D7 on the display. There are other GLCDs which pass data in serial i.e. one instruction at a time. In this case, we don’t need so many pins but there will be other considerations that we will need to … uh … consider.

Part 7 – Getting started with a 128×64 Graphics LCD Display – Porting an image to a 128×64 monochrome display

Now that you’ve got the GLCD up and running and probably tried a few things, you’d like to put a picture of your cat on the display and see if he/she can recognise it right? It’s okay, you can admit it, I’m not judging.

This can be broken down into 2 steps:

1. Convert an existing image into a 1-bit black or white bitmap (BMP) image

2. Convert the bitmap from the previous step into an array for use with your microcontroller

Step 1 – Convert an existing image into a 1-bit black or white bitmap (BMP) image

Part 3 – Getting started with a 128×64 Graphics LCD Display – Passing instructions

This part explains how to pass instructions/commands to the GLCD. On a high level, these are the steps:

1. Select the GLCD half-section
2. Put the Enable Pin LOW
3. Put RS, RW and Data pins HIGH or LOW based on your command
4. Put the Enable Pin HIGH
5. Wait 2 milliseconds
6. Put the Enable Pin LOW
7. Wait 2 milliseconds
8. GLCD responds

And you’re done! Easy-peasy!

Well, not quite. Let’s look into each of these steps in a little more detail. Here’s an image from the last part for quick reference:

Part 2 – Getting started with a 128×64 Graphics LCD Display – Screen resolution and locating pixels

The GLCD has a 128×64 resolution. This equals about 8192 individual pixels that you can control as you wish. But how is this done? Let’s see how we reach a particular pixel on the screen.

The LCD screen is actually divided into 2 halves with one KS0108 IC for each half. Each KS0108 IC has the ability to control 64×64 pixels, so both of them side-by-side should be able to give you the complete resolution of 128×64. So, by choosing which one of the two ICs, you can narrow your pixel down to one of the two halves.

Next, each half containing 64×64 pixels has an addressing scheme using the Y address and X address as follows. Lets start with the columns. Each half has 64 columns numbered from 0 to 63. Straightforward enough, not too much to get confused about, each column is addressed using the Y address which ranges from 0 to 63.

Part 1 – Getting started with a 128×64 Graphics LCD Display – JHD12864E (KS0108 family)

The GLCD (Graphics LCD) display that I’ll be using in this series is the JHD12864E. Here’s a picture of what it looks like (image stolen from http://extremeelectronics.co.in):

It’s a fairly standard 128×64 pixels display with a backlight. The part number aside, what really matters is the IC driver that is used in this display. The datasheet shows (more on this in a few mins) that it uses the S6B0108 display driver. After looking around on the net, I realised that this is similar to the KS0108 family display driver. So the general method of operation should be similar to the KS0108 but with a few minor differences here and there.