Today I was able to complete the first fully working prototype of my keyboard. It has 6 16mm arcade buttons – two each of green, yellow, and red – runs on a 350mAh lithium ion battery, and is completly wireless. It doesn’t even have a wire to charge it since I didn’t have enough space to mount the port in the case.

Build It

Mostly today was a build day. I had most of the code in place, so all that was left was to assemble everything. First I made a template on paper to figure out the placement of the buttons. I wanted to make sure that the arcade buttons were placed far enough apart so that I could fit the power button on the side. After a lot of measuring and some fiddling I settled on the below layout.

To be sure the spacing worked, I placed the buttons directly on the paper. This was the third layout I tried. Also, I originally planned on blue, green, and red buttons. After seeing them lined up, the blue and the green were too similar in color, so I swapped in the yellow buttons for some contrast.

To be absolutely certain, I created a quick mock up a cardboard box. The layout was just right.

To transfer the layout to the case, I taped the pattern to the top and drilled 1/16th holes in the center.

Forstner bits were used to drill out the 16mm holes for the buttons. It took me a little bit to get the hang of drilling the holes. Sometimes the drill caught on the plastic and scratched the surface of the case.

The wires took up more space than I expected. It would have been helpful to daisy chain all of the grounds across a common wire, removing half of the wires needed. Also, the rest of the wires could have been cut much shorter or routed around the edge of the enclosuer, taking up less room.

All of the wires terminate in a breakout FeatherWing.

The fit was tight enough that I didn’t need to mount the feather to the case. The wires held it in place with little to no movement when the bottom was screwed on.

You can see the power button on the side.

Code

With everything assembled it was time to test it out. And it didn’t work. After a little trial and error, I realized that the keyboard would only work if my laptop was plugged into it via USB and I had the Arduino serial monitor plugged in. Looking over my code a bit, I see that I still had a line of code at the very beginning telling the board not to start up unless it detected a serial console. Removing that fixed the first problem.

Next, whenever I pressed the volume down or up buttons for a brief moment, the volume would go all the way to 0 or 100. No in between. It registered as way too many key presses. Adding a small delay at the end of the loop solved this problem.

• Tag on GitHub
• Pull Request on GitHub

Here’s the useful command I used to create the thumbnails for this post: magick mogrify -resize 33% -path ./thumbnails *.jpg.

Today’s progress is a bit misplaced in the “Pi Project” folder. I wound up using my Adafruit Feather 32u4 Bluefruit LE to emulate a keyboard. Since this is exactly what it was designed to do, it really wasn’t that hard. Which means it took me a long time. My goal was to use a Bluefruit LE UART Friend connected to my Raspberry Pi. That was beyond my current skills so I decided to take smaller steps. The Feather has lots of samples doing exactly what I want to do, so I went that route.

The plan is still to go back to the Pi though since my end goal is to make a keyboard that gets updates from the computer it’s connected to and I assume it’d be easiest to do that with a restful API. But that’s for Future Josh to work through.

Working with several tutorials and code samples I was able to create a simple app that sends custom strings of keyboard codes to whatever device is paired.

Code

Below are the highlights of the application. First it declares the commands to send as constants, and then polls for button state and sends corresponding messages.

BLE Commands

Two types of BLE commands are supported, keyboard codes, and control commands. Keyboard codes are sequences of key downs (key ups are inferred by sending either the next code, or by sending a message with no codes). Keyboard codes are sent in a message that is up to 8 bytes long.

• The first byte is a bit mask of any modifiers (shift, alt, etc)
• The second byte is always 00
• Bytes 3 through 8 are the keys to send

For example 08-00-07 is the command for pressing the Windows Key + D. 08 is the left Windows key, and 07 is the letter D (it’s case insensitive, if you want to have an upper case D, then also send shift).

As stated above, up to 6 keys can be sent at once. So to send abc, that would be 00-00-04-05-06. But then this would continue to send c repeatedly since we never sent the key up signal. To do that, just send an empty message with 00-00.

A complete listing of the keys can be found in section 12 here.

The other type of message that I’m sending is a control command. This is used to emulate media buttons like play, stop, and volume control. In my example I use it just for play (which will also pause). Adafruit’s sample code has a listing of some available commands.

Code Logic

Each loop of the main method polls the state of the buttons to determine which messages to send. It also records its state so the next iteration can either send the key up signal in the case of the keyboard codes, or to simply not resend the play command a second time (thereby pausing the music if the button is held down for more than a fraction of a second).

It’s all pretty hard coded now, but the idea is to have it evolve to be more configurable over time.

char CMD_MISSION_CONTROL[] = "01-00-52"; // (Left) Control + Arrow Up
char CMD_APP_WINDOWS[]     = "01-00-51"; // (Left) Control + Arrow Down
char CMD_SHOW_DESKTOP[]    = "08-00-07"; // (Left) Window + D
char CMD_VOLUME_UP[]       = "00-00-80"; // Volume Up
char CMD_VOLUME_DOWN[]     = "00-00-81"; // Volume Down
char CMD_VOLUME_MUTE[]     = "00-00-7F"; // Volume Mute
char CMD_F14[]             = "00-00-69"; // F14
char CMD_KEYS_UP[]         = "00-00";    // No keys held

void loop(void)
{
  int pressed = 0;
  int playPressed = false;
  if ( digitalRead(5) == LOW )
  {
    pressed++;
    printKeyboardCode(CMD_MISSION_CONTROL);
  }
  if ( digitalRead(6) == LOW )
  {
    pressed++;
    printKeyboardCode(CMD_APP_WINDOWS);
  }
  if ( digitalRead(9) == LOW )
  {
    pressed++;
    printKeyboardCode(CMD_SHOW_DESKTOP);
  }
  if ( digitalRead(10) == LOW )
  {
    playPressed = true;
    if (!playButtonPressedLastTime)
    {
      printControlKey("PLAY");
    }
  }
  if ( digitalRead(11) == LOW )
  {
    pressed++;
    printKeyboardCode(CMD_VOLUME_UP);
  }
  if ( digitalRead(12) == LOW )
  {
    pressed++;
    printKeyboardCode(CMD_VOLUME_DOWN);
  }

   if (pressed < 1 && buttonsPressedLastTime > 0){
    // send the key-up command
    printKeyboardCode(CMD_KEYS_UP);
  }

   buttonsPressedLastTime = pressed;
  playButtonPressedLastTime = playPressed;
}

 void printKeyboardCode(char keys[])
{
    ble.print("AT+BleKeyboardCode=");
    ble.println(keys);
}

 void printControlKey(char keys[])
{
    ble.print("AT+BleHidControlKey=");
    ble.println(keys);
}

Wiring

Wiring is pretty simple for this device since it’s essentially made for this use case. I strung together 5 buttons with a common ground, and plugged each of the buttons into the pins 5, 6, 9, 10, 11, and 12. I have a Battery on order, and will wire up that and a power switch once they arrive.

• Code Changes
• Tag in GitHub

I followed a mix of instructions, including Adafruit, and ElectronicWings to start playing with talking to and from my Raspberry Pi over a serial connection from my Windows Surface. I used a TTL cable from Adafruit.

Following are instructions for setting up communication between a Raspberry Pi 3 (not a zero) and a Windows laptop.

Setting up the Pi

First thing to do on the Pi is to turn of shell login via serial port.

1. sudo raspi-config
2. Select “Interfacing Options”
3. Select “Serial”
4. When asked “Would you like a login shell to be accessible over serial?” select no
5. When asked “Would you like the serial port hardware to be enabled?” select yes
6. Reboot the device

Next is to connect the cable to my Pi. My Pi was powered by USB already, so I didn’t connect the red (5v) wire to the Pi. Just hook up the wires up as follows, (or see the picture below).

• Black -> Ground
• White -> TXD
• Green -> RXD

Setting up the Windows Laptop

First step is to install the drivers on my laptop for the cable. I had the older version of the cable, so I needed the Prolific Drivers. There’s also a link to this from the Adafruit tutorial.

Now once the the USB cable is plugged into the laptop it will show up as a new COM port. To figure out which one it is either find it in the Device Manager or use the mode command.

>mode

Status for device COM5:
-----------------------
    Baud:            9600
    Parity:          None
    Data Bits:       8
    Stop Bits:       1
    Timeout:         OFF
    XON/XOFF:        ON
    CTS handshaking: OFF
    DSR handshaking: OFF
    DSR sensitivity: OFF
    DTR circuit:     ON
    RTS circuit:     ON


Status for device CON:
----------------------
    Lines:          32766
    Columns:        112
    Keyboard rate:  31
    Keyboard delay: 1
    Code page:      437

Notice that the mode command will also conveniently print out the baud rate (you’ll need this in the next step). This information is also available from device manager too by going in to the port’s properties.

Open up the serial port in PuTTY, using the COM5 port found above.

Connecting

Back on the Pi find the correct serial port. As I understand it (which is 90% likely to be wrong), on the Raspberry Pi 3, the UART port is going to be ttyS0 and the Bluetooth port (also serial) will be ttyAMA0. ls -l /dev will give you information about the ports.

$ ls -l /dev/serial*
lrwxrwxrwx 1 root root 5 Jun 22 15:12 /dev/serial0 -> ttyS0
lrwxrwxrwx 1 root root 7 Jun 22 15:12 /dev/serial1 -> ttyAMA0

From here echoing out a string in the Pi to /dev/serial0 will have it show up in PuTTY.

$ echo "hello world" > /dev/serial0

This weekend I focused on getting the GB LED in my power button to work. I needed to use an SPI PWM board from Adafruit to control the LED. You can see it working above. When the device is on, the light is green. Hold the button down for 5 seconds and it turns purple, signaling that when you release it the device will power down. When it powers down the light turns (and stays) red.

I have detailed instructions on using the PWM with a Raspberry Pi. A couple of highlights (mistakes) that didn’t make it into the post are worth noting here.

First off, I didn’t do a great job soldering the header pins to the board. I had too much solder on some of the pins, which resulted in a sphere on the end of the board that didn’t make enough contact to keep the pin firmly attached. Which is to say the pins fell out. Next, I realized that I had soldered the header on to the output side of the board, not the input, meaning that it was ready for me to daisy chain on another board… but that I couldn’t use the current board without soldering the other side on. A textbook case of Murphy’s Law.

All of these soldering mistakes meant it was time to break out the soldering iron and fix my mistakes. I resoldered the bad pins, and added another header to the CORRECT side of the board. While I was there I added a male header to expose the voltage pinouts. One convenient mistake I had made weeks ago was soldering a female jumper wire to the voltage pin on my power LED. With the new male header on the board, it was easy to wire this up.

Speaking of wiring, I used some rainbow tape to on the red, green, and blue jumpers coming from the power LED to keep them organized, and then plugged them into my breadboard, connecting them to the PWM board. From there, wiring up the Pi to the board was pretty simple. I used some more rainbow tape to keep those wires in order and make it easy for me to connect and disconnect the board entirely.

Next it was time to dip into Python to integrate the LED to my existing volume controller app. The code can be found in my Day 7 pull request. The majority of went into a dedicated RgbLed class. It doesn’t expose a lot of the features, but enough for now.

Pictures

Here it is fully wired and turned on with the lid off

Here are some quick notes on getting the 12 channel 16-bit PWM driver from Adafruit. (It’s not that different from the 24 channel version) As usual, Adafruit’s documentation was super useful, and they even had a page about getting it to work with the pi.

What is a PWM Driver?

A Pulse Width Modulation driver allows you to either connect a whole bunch of regular LEDs with just a few pins (and the PSI protocol). The 12 channel driver can support 12 LEDs. Additional drivers can be daisy chained on allowing near limitless LEDs. If regular LEDs don’t interest you, you can use 3 channels to drive a single RGB LED (for 4 total per module).

Software Setup

1. Enable SPI. (
   1. Run sudo vim /boot/config.txt
   2. Ensure dtparam=spi=on is uncommented (or add it)
   3. Reboot with sudo reboot
   4. Verify it worked with ls /dev/spi*
2. Python Dependencies
   1. Install python-venv with sudo apt-get install python3-venv
   2. Install pip with sudo apt-get install python3-pip
   3. Create a virtual environment for your project with python3 -m venv pvenv
3. Install Circuit Python on the Pi
   1. Install Circuit Python with pip3 install adafruit-blinka
   2. Install the Adafruit library pip3 install adafruit-circuitpython-tlc59711
   3. Verify everything works by going into the python interpreter and importing the new packages (you shouldn’t get any errors)

       import board
       import busio
       import digitalio
       import adafruit_tlc59711
      

4. Optionally save your imports with pip3 freeze > requirements.txt

Hardware Setup

1. Optionally follow the instructions on Adafruit’s site to solder on headers so the module can be plugged into a breadboard.
2. Optionally solder on headers to the voltage pins on the board. This helps wiring when it’s inconvenient to just wire the LED’s leg directly to power.
3. Wire it up! Use the below table or image. Make sure that you orient the board correctly and that you’re plugging into the input side and not the output side

The table goes from the top down on the pins on the left side of the module. When there are multiple pins to choose from, I have bolded the pin that I used.

After this, plug an RGB LED in to any of the RGB pins on the board with the longest pin going to one of the 12 voltage pins.

Testing it

Fire up a python3 REPL and import everything from above and then start turning on some LEDS:

import board
import busio
import digitalio
import adafruit_tlc59711

spi = busio.SPI(clock=board.SCK, MOSI=board.MOSI)
rgb = adafruit_tlc59711.TLC59711(spi)

# Full Red, Green, or Blue (mix/match as much as you like)
rgb[1] = (65535, 0, 0)
rgb[1] = (0, 65535, 0)
rgb[1] = (0, 0, 65535)

rgb.b1 = 32768
rgb.g1 = 16384
rgb.r1 = 8192

rgb.red_brightness = 10
rgb.green_brightness = 10
rgb.blue_brightness = 10

Today was a simple day. I wired up the on/off button. Pressing it when it’s powered off powers it on. Holding it while it’s on starts a clean shutdown. My next step is to use the LED in the button to provide status (shutting down, on, release to turn off, etc).

I’ve wanted to have a proper IDE environment on my Windows machine that can execute code on my Raspberry Pi. Turns out that there’s a new VS Code extension that purports to do just that. Except if you read the fine print it currently only supports an x86_64 Linux-based OS.

But still, it’s worth keeping an eye on the Remote SSH extension. It’s new as of a few days ago and I expect that they’ll make improvements and allow more environments over time.

In the mean time, I’m trying out SSH FS, which allows you to treat an SSH host as a workspace. By default it treats the host’s entire file structure as your workspace, so make sure you specify a root. It’d be more ideal if you could run commands directly on the host. But you can always just ssh to the host in Code’s terminal.

Once the extension is installed, run the command SSH FS: Edit configuration to add a configuration. Once you’ve configured it (see below), run the command SSH FS: Connect as Workspace folder and select the configured host.

"sshfs.configs": [
  {
    "host": "piz01",
    "label": "piz01 - PiProject",
    "name": "ssh_fs",
    "privateKeyPath": "$HOMEDRIVE$HOMEPATH/.ssh/id_rsa",
    "root": "~/PiProject",
    "username": "pi"
  }
]

Update:

After working with this for a few hours it proved to be unreliable. When it was working it was great, but there were plenty of times when trying to set up the configuration was flaky. This resulted in not always being able to read the configuration which meant that I couldn’t connect.

In the end it was easier to just remote in to the pi and use vim.

I didn’t have a whole lot of time this weekend, but I did make some great progress. I wrote a quick Flask service that used a github project I found to control the volume. After a quick update to the piboard to connect to my Windows laptop. A quick restart of the Pi and it actually worked!

Here’s all the code on github as of this posting.

Not only am I late with this status report for last Sunday. I finished getting everything wired up and cleaned up my desk with 3 minutes to spare before the season premier of Game of Thrones. There was no chance I was going to write up a status report at that point. Since then I’ve done more work so it’s not really a true status for day 4. Let’s call it 4.5.

Software

I decided to shelve any work towards getting the BlueTooth connectivity to work for the time being. I was putting a lot of effort into that without a lot of results. My goal for an MVP is now to get a box that has a volume knob that works. The quickest route without too much throwaway work is a device that makes rest calls to a configured laptop running a webservice that handles the volume control. This will let me concentrate on getting the electronics up and running and the physical box built.

Towards that, the first thing I did was refactor out the SimpleButon and SimpleRotary scripts I had from last week into python classes and use them in a python script that calls a webservice.

With that done, I quickly transferred the proof of concept to a Pi Zero W. Or at least I tried to. For whatever reason, whenever I tried to do a git pull the command line hung. After some googling I tried a last ditch attempt of just updating the OS with

sudo apt-get update
sudo apt-get dist-upgrade

Surprisingly, that actually did the trick. Now my only issue is that I never installed the prereqs on the Zeros. So a few apt-gets later, and I’m back in business.

sudo apt-get -y install python3-rpi.gpio
sudo apt-get -y install python3-venv

Once the code’s running on the Pi, I have to figure out how to get it to run whenever it stats. Some more googling and I find Pi’s documentation on rc.local.

sudo vim /etc/rc.local

Hardware

Coding. Done. Linux administration. Done. Next up is actually making the box.

A few weeks ago I picked up a black plastic enclosure from Tinkersphere. To make it easy to expand in the future, I used the glue backing on the back of an extra mini breadboard to affix it to the bottom of the case. I had to take the power rails off first so it would fit in the slot.

Next, I use Sugru on the bolts of my PiBow case to affix it to case. I used the full assembled case to ensure that there was sufficient space for the bolts, but removed disassembled the case and left only the bottom plate and the bolts while it set. I’m actually pretty surprised it worked so well.

The Sugru is solid enough that it didn’t ooze anywhere it wasn’t supposed to. I kind of want to try the same thing with a glue gun since it’s a little cheaper and easier to have on hand (my Sugru was technically expired…). I just don’t think it’ll work as well.

Now on to the top. I used a 15mm Forstner bit to drill a hole in the top for the power button. Then I used a 16mm bit to widen it because I misread the size on the button.

I used standard drill bits to make a 5/16” hole in the side for the rotary encoder. This time I started with a quarter inch bit on Sunday, and then had to buy the 5/16” bit during the week. It was a perfect fit with the additional 1/16” inch.

I couldn’t figure out how to cleanly get a small hole for the power USB cable in the bottom of the case. I went drilling a hole near the edge and then using my Leatherman to whittle the notch to the desired size. Worked well enough, but it wasn’t as smooth as the other holes.

I needed to get rid of the ridges on the interior side for the encoder to sit flush and extend far enough out. I didn’t have any better ideas so I grabbed a drill bit a little larger than the space between the grooves. I used that to drill out some of the ridges and then went in with the blade of my Leatherman to remove the rest. Next the file on the Leatherman helped smooth out any uneven ridges. Not super pretty, but it worked; the encoder sat flush.

Speaking of the encoder, I was concerned about how I was going to attach the wires to it in reliable way. I didn’t have any better ideas, so I figured now was a good enough time as any to learn how to solder.

Including burning myself (twice), it went much better than I expected. I cut off one end of some jumper wires and soldered them on to the encoder and then button. I was on such a roll I even soldered the head on to a TLC5947 from Adafruit. I plan on using that in my next step to power the RGB light ring on the button.

The button has a RGB LED in it so I color coded the wires. Red for the red channel, green for the green, and blue for the blue. The yellow and orange are for the button itself.

During the week, a heat gun I had ordered arrived so I slipped some plastic shrink around all of my soldered connections and then larger ones to group the wires together a bit.

Thanks to some advice from a friend, I picked up some heat resistant gloves on Amazon and didn’t burn myself with the heat gun at all.

With all the wires soldered in place. I just have to assemble everything again. I screwed in the button, and glued in the encoder. Then I remembered that the encoder had a bolt as well, so I attached that and it was much more secure.

I upgraded the knob on the encoder to a nice metal 1” job from Adafruit. It has a nice feel to it. Just needed a 2mm hex wrench to secure it in place. Which I got today, just in time.

Now that the Sugru has had enough time to set, I reassembled the Pi case . . .

. . . and plugged it into the breadboard.

I had color coordinated the wires for the Pi with the rotary encoder, so it was easy to remember what goes where.

For now, I’m plugging the power button in randomly to the breadboard just so the wires aren’t loose. My next step is to get that bit working.

And voila.

I was surprised by home much I was able to get done in one day. It still doesn’t really do much except call a webservice that just logs that it was called, but it’s a start.

Here’s all the code on github as of this posting.

1. Login (username: pi password: raspberry)
2. Run the wizard: sudo raspi-config
3. Reset password (1)
4. Set hostname (2, N1)
5. Setup Wifi (2, N2)
6. Enable SSH (5, P2)
7. Change timezone (4, I2)
8. (alternate method) Connect to WiFI
   1. Edit the supplicant file:

      sudo vi /etc/wpa_supplicant/wpa_supplicant.conf`
      network={
       ssid="testing"
       psk="testingPassword"
      }
      

   2. Reset the interface and test it

      wpa_cli -i wlan0 reconfigure
      ifconfig wlan0
      

9. Fix keyboard layout
10. sudo vi /etc/defaults/keyboard
11. Set XKBLAYOUT="us"
12. Reboot
13. Verify by typing a "
14. Updates

    sudo apt-get update
    sudo apt-get upgrade
    

15. Install Softwares

    sudo apt-get install vim screen tmux
    sudo update-alternatives --config editor
    

16. Install .Net
17. Generate new SSH host keys (if you are using an image used by another Pi)
18. sudo ssh-keygen -b 4096 -h -f /etc/ssh/ssh_host_rsa_key

I recently bought a Raspberry Pi Zero W. I immediately had problems using it. Here are a couple of useful (and useless) things I tried. Adafruit has a great tutorial on what to do when you think your pi is dead as well.

First I bought another one (they are so cheap) just in case the first was DOA. No dice. Then I tried buying a USB adapter for my mouse and keyboard hoping that it only boots to video if there are input devices (long shot I know, but I was going to need the adapter anyway). Nope. Then I tried dropping an empty file named SSH into my boot directory on the SD card and enabling WiFi through a wpa_supplicant.conf file. I still couldn’t ping the device, let alone SSH in. After that failed I tried using PiBakery to create a new image that had everything baked in. It really wasn’t much different than what I had done. I bought a new SD card hoping it was a compatibility issue. Again, I knew I was going to need one anyway, but it didn’t help.

I was able to verify that it did in fact work by taking out the SD card and plugging it directly into my PC via the USB port (not the charge port, but the port on the left for peripherals). It showed up under Device Manager as BCM2708 Boot. At least I knew it wasn’t full dead yet.

In the end, the issue was that I was trying to connect to my 5GHz network (Pi Zero W’s don’t support that) and that my HDMI cable was busted. The network issue was much easier to diagnose once I had a monitor plugged in.

Putting together the Raspbery Pi Zero W PiBow is really easy if you know how. Even if you don’t, you can figure it out. But it’s easier if you know the order the pieces go together.

Layout the pices

Step 1

Step 2

Step 3

Step 4

Step 5

Step 6

Step 7

Day 3 was a bit of a loss. I spent a few hours (to no avail) trying to figure out what’s wrong with my Pi Zeros. I’m hoping the answer is secretly “nothing” and that my HDMI cable is bad and I’m not configuring the wifi correctly. After that I futzed with some reading about bluetooth and D-Bus. I think D-Bus may not be what I need going forward. Looking further into existing bluetooth libraries for connecting as a keyboard.

To make sure I got progress on something, I spent the last hour and a half of the day learning how to use a rotary encoder. The basic principle is that there are two contacts in quick succession that are connected and disconnected for every notch you rotate the device knob. If you track which contact was connected first, then you know which direction it was turned. The source code is pretty straight forward.

On day 2 I started complaining to a friend that I kept burning out my GPIO ports and that they didn’t work properly. He helpfully suggested that I may not have had the pins plugged in to the correct spots.

After telling him that there was no way that I was plugging the things in wrong since I was using the Adafruit Pi Cobbler, I took a closer look and realized that I had plugged the wrong end of the cable into the Pi. The gray stripe needs to be near the bottom of the board, where the SD card reader is. I then took a Sharpie and labeled the ends of the cable so I don’t make this mistake again in the future. Or at least to make it less likely.

Mystery solved.

Knowing Your Pi

The following commands are useful for getting detailed info about the Pi build. They were found on raspberrypi-spy.co.uk

pinout

> pinout
,--------------------------------.
| oooooooooooooooooooo J8     +====
| 1ooooooooooooooooooo      P | USB
|  Wi                     ooo +====
|  Fi  Pi Model 3B+ V1.3  ooE    |
|        ,----.               +====
| |D|    |SoC |               | USB
| |S|    |    |               +====
| |I|    `----'                  |
|                   |C|     +======
|                   |S|     |   Net
| pwr        |HDMI| |I||A|  +======
`-| |--------|    |----|V|-------'

Revision           : a020d3
SoC                : BCM2837
RAM                : 1024Mb
Storage            : MicroSD
USB ports          : 4 (excluding power)
Ethernet ports     : 1
Wi-fi              : True
Bluetooth          : True
Camera ports (CSI) : 1
Display ports (DSI): 1

J8:
   3V3  (1) (2)  5V
 GPIO2  (3) (4)  5V
 GPIO3  (5) (6)  GND
 GPIO4  (7) (8)  GPIO14
   GND  (9) (10) GPIO15
GPIO17 (11) (12) GPIO18
GPIO27 (13) (14) GND
GPIO22 (15) (16) GPIO23
   3V3 (17) (18) GPIO24
GPIO10 (19) (20) GND
 GPIO9 (21) (22) GPIO25
GPIO11 (23) (24) GPIO8
   GND (25) (26) GPIO7
 GPIO0 (27) (28) GPIO1
 GPIO5 (29) (30) GND
 GPIO6 (31) (32) GPIO12
GPIO13 (33) (34) GND
GPIO19 (35) (36) GPIO16
GPIO26 (37) (38) GPIO20
   GND (39) (40) GPIO21

model

> cat /proc/device-tree/model
Raspberry Pi 3 Model B Plus Rev 1.3pi@pibuttons:~ $

cpuinfo

> cat /proc/cpuinfo
processor       : 0
model name      : ARMv7 Processor rev 4 (v7l)
BogoMIPS        : 38.40
Features        : half thumb fastmult vfp edsp neon vfpv3 tls vfpv4 idiva idivt vfpd32 lpae evtstrm crc32
CPU implementer : 0x41
CPU architecture: 7
CPU variant     : 0x0
CPU part        : 0xd03
CPU revision    : 4

// snip.  It's a 4 core processor,
// so the above is repeated 3 more times

Hardware        : BCM2835
Revision        : a020d3
Serial          : 00000000e296b315

I’ve made some interesting progress in my current poject with my Raspberry Pi.

After following a walkthrough, I was able to connect my Pi to my Windows laptop as if it were a Bluetooth keyboard and forward all keystokes from the Pi’s keyboard to my laptop. In fact, I’m writing this status report on with my Pi’s keyboard on my laptop.

The only issue with the walkthrough is that it’s missing one dependency, before getting started python-gtk2 needs to be installed:

sudo apt install python-gtk2

I’ve made a copy of the sample code in my own repo so I can start to play with it.

Next up is to go through the follow up post and move leverage GPIO (buttons!)

After starting on my Raspberry Pi project, I realized that the Raspberry Pi 2 doesn’t have onboard Bluetooth. I could either buy a Bluetooth dongle or switch to a Raspberry Pi 3. And since I have a Raspberry Pi 3 in my drawer and not a Bluetooth dongle, I decided to start over on my 3. So now I’m taking notes on exactly what I need to do in order to get a Pi up and running.

1. Download the latest version of Raspbian. For this project I elected to have the version with a desktop. Estimated download time is about 10 minutes.
2. Install etcher from an admin shell with cinst -y etcher. Estimated downloaded time is about 2 minutes.
3. Open etcher. If it’s not on your desktop, then hit the start button and type in BalenaEtcher
4. Pick the file you downloaded file from step 1, and flash it to an SD card.
5. Insert SD card into Pi and boot it up. The initial boot takes a little longer than normal.
6. Go through the onscreen Welcome Wizard
   1. Change the password (remember to write it down)
   2. Connect to WiFi. This will also fix the date/time.
   3. Run system updates. This may take
   4. Reboot
7. Fix any mouse lag issues, if they exist
   1. sudo vi /bot/cmdline.txt
   2. Add ` usbhid.mousepoll=0` to the end of the line
   3. Reboot (this can be done while the Updates are being installed)
8. [Optional] Change the host name (this comes in handy if you have multiple Pis and are using RSA keys)
   1. `sudo vi /etc/hostname
   2. Reboot (this can be done while the Updates are being installed)
9. Enable SSH on the Interfaces pane of the Raspberry Pi Configurator (accessible from the Pi menu)
10. Copy public key to the Pi
    1. On the new Pi: mkdir .ssh
    2. On the local machine: scp id_rsa.pub pi@pibuttons:.ssh/
    3. On the new Pi: cat .ssh/id_rsa.pub >> .ssh/authorized_keys

Optional

1. Install vim
   1. sudo apt-get install vim
   2. sudo update-alternatives --config editor
2. Install screen
   1. sudo apt-get install screen
3. Install VS Code - (Full Article)
   1. Install it

       sudo -s
       . <( wget -O - https://code.headmelted.com/installers/apt.sh )
      

   2. Uninstall it and install it again! As of this writintg there’s a known issue with the current build. The easiest workaround is to just install an older version. The last command here tells the system not to upgrade VS Code when you ask it to upgrade other things. ```bash sudo apt-get remove code-oss sudo apt-get install code-oss=1.29.0-1539702286 sudo apt-mark hold code-oss
4. Login to github
   1. Create a personal access token
   2. Configure git with your name, email, and tell it to stop asking for passwords

       git config --global user.name "Josh Quintus"
       git config --global user.email "[email protected]"
       git config --global credential.helper store
      

   3. Do a git push and use the access token as your password. You can forget it from here on out.

Back it up

Now that everything is set up just-so, it’s worth creating a backup so that we don’t have to do all of this ever again.

1. Install Win32 Disk Imager

    choco install -y win32diskimager.portable
   

2. Start up Disk Imager

    Win32DiskImager.exe %HomeDrive%\%HomePath%\Desktop\buttons.img
   

3. There will be two devices that you can pick in the dropdown. Select the one that you can navigate to in Windows Explorer
4. Press the Read button
5. Wait
6. [Optional] Zip it up. This took the file down from about 32GB (the size of the disk) to about 2GB

I want to easily connect to my Raspberry Pi from my Windows machine, specifically from inside my preferred terminal, ConEmu. First we’ll need to set up some SSH Keys on the Pi(although if you’re comfortable keeping your password inside some configuration files, this is actually optional), set them up on the Windows box, and then configure ConEmu and your environment.

Setting up SSH Keys

On your Pi:

1. Run ssh-keygen and follow the prompts, accepting the defaults
2. Save the key file to /home/pi/.ssh/id_rsa (just press enter, as this is the default)
3. Type in your passphrase (you can elect to keep this empty but it means that anyone who gets the private key will be able to log on to your machine. So consider if this is really what you want. For me, I don’t really care if people can log in to my Pi for now, so I’m ok with an empty passphrase
4. Configure sshd
5. sudo vim /etc/ssh/sshd_config and ensure you have these values RSAAuthentication yes PubkeyAuthentication yes PermitEmptyPasswords yes
6. Copy the private key (/home/pi/.ssh/id_rsa) to your Windows machine. You can just SSH in to the Pi using the username and password, cat` the file and copy them from the console. Save it to your home directory.

On your Windows Box

Starting with Windows 8 (I think?), Windows started shipping with a SSH client built in. Which means, as good as it was, there’s no need to download and install PuTTY anymore.

1. Test the connection
2. ssh -i %HomeDrive%%HomePath%\id_rsa pi@raspberrypi
3. You should now be logged in to your Pi

Integrating with ConEmu

For convenience I added the following alias to my cmd init file. It allows me to just type pi at the command line and be logged into my Raspberry Pi immediately.

DOSKEY pi=ssh -i %HOME%\id_rsa pi@raspberrypi

Next I added a task in ConEmu so I can open a new tab directly into the Pi.

1. Open the settings and go to Setup/Tasks (or just press `Alt-Win-T)
2. Press the + button on the bottom left and fill in these values
3. Name (first box): Pi
4. Commands (large box): ssh -i c:\users\joshq\id_rsa pi@raspberrypi
5. Hotkey [Optional]: Alt-P
6. Press Save settings (or just hit the escape key)
7. Try out the shortcut by pressing Alt-P

I’m starting to work on a project on a Raspberry Pi. I’m starting with a Pi 2 that already has an older version of the Pi os installed on it (I don’t even remember what one).

The first issue that I came across was that the Amazon Basics mouse was too slugish. After googling for a bit I came up with the solution that I needed to make an edit to a config file (becuase of course the first thing I needed to do was edit a config file because Linux) and then reboot the system.

sudo vim /boot/cmdline.txt
sudo reboot

Append the following to the end of the line (separated from the last entry with a space).

usbhid.mousepoll=0

In order to loop over all the files in a given directory and run a different command on each of them in zsh:

for file in ~/folder/*; gpg $file