Well not all Kickstarters are successful, but that doesn’t mean that the gcode03 script I have been working on isn’t a success. I have decided to share the script with everyone for free. If you feel so inclined, hit the donate button and help me out. Any issues please leave a comment on the gcode03 page.

For the past few months I have been working on and off on a ULP script that would allow for double sided PCBs on my home CNC machine. The script is 95% finished and I have been using it for a while. I recently ran into an issue where my older 5.x license of Eagle PCB was causing problems with the latest 7.x version of Eagle. Because of this I am trying to Kickstart an upgrade of my Eagle license in return for access to my ULP script that allows for double sided PCBs on a CNC, as well as allowing for non-square shapes.

One really nice thing about having a CNC to make PCBs at home is the ability to whip up a quick adapter board in one night. Tonight I needed two adapters for a 5.5mm barrel jack, one to go to wires and one that can plug into a breadboard. Eagle allows you to make a board without a schematic which is exactly what I needed, just draw some traces on copper and route it out on the CNC. I used 40-60 mil traces and slapped on random switches I had laying around and an LED with resistor. The boards came out to be about 1.75″x0.4″ and routed perfectly with a 0.8mm router bit. I uploaded a zip with the Eagle board files and G-Code for anyone else who wants them.

Lately I’ve been moving between 3 different locations and have been trying to do contracting work related to PIC processors. It was really frustrating to have all my development tools and components only at my home office when I was away so much. The solution was to add what I needed to one portable kit to take from location to location. My first attempt was a small plastic toolbox, but that was quickly filled and always seemed to be a mess. Next I tried a plastic shoebox from home depot for $0.99. This worked well since I could see everything that was in it, however it was a pain to carry around since there was no handle and it didn’t fit into a bag nicely. The solution I came up with was a plastic parts bin with moveable seperator walls, like you can find a Harbor Freight or Home Depot. With the movable walls, you can really cram a lot of stuff into them, I was impressed with everything that I got into the bin.

3 pencils

1 pen

6 DIP PIC micocontrollers

1 DIP EEPROM

1 character LCD

Double sided tape

Wire cutters

Spade cutters

Plyers

hobby knife

super glue

velcro squares

23 row breadboard

Bus pirate

Bus pirate cable

Tweezers

2 Antistatic bags

Electrical tape

Alligator clip wires

Jumper wires

3×2 programming wire

Micro USB phone cable

A to B USB cable

Voltmeter

5 PIC Microcontroller dev boards

2 Prototype backboard

1 9v packboard

2 crystals

USB to serial adapter

Serial adapter cable

Serial adapter

4G USB drive

Mini philips screwdriver

Mini flat blade screwdriver

Medium dual head screwdriver

PICkit3

2 Mini USB cable

FTDI TTL serial cable

4 port Mini USB hub

AC USB adapter

AC 12v adapter

USB to 5.5mm barrel jack connector

9v battery to 5.5mm barrel jack

2 Barrel jack breakout boards

Electrical parts

Jumper wire

Misc pots

Misc caps,

Buttons

LEDs

Misc resistors

Regulators

Header

N-chan FETs

Misc diodes

Solder

Barrel jacks

While the box does close and latch, I use two fabric hook and loop straps to make sure it stays closed. The unit is really compact and fits in any backpack or side bag. I do have a breadboard I take with me as well and I think I found a small plastic picture box that can hold that so I don’t crush components when it is in a bag. Here are some pictures too

I regularly need to see how much time an embedded Linux box is spending idle, so I can determine what impact performance improvement fixes have on the system over time. Since ‘w’ is pretty much useless I use the following one-liner to parse the /proc/uptime

I like making videos and I like talking about / teaching embedded systems, so it should be no surprise there have been a few video tutorials on this site in the past. I’m starting to get the bug again and want to post something that people working with embedded microcontrollers want, but I’m not totally sure what to show. This lead to an opportunity, rather than try and guess what people want, I’m going to ask you the people what you want to see! Here are the details:

Post a comment here telling me what you want to see in a tutorial video

Well let me tell you, ffmpeg sucks at getting people up to speed. Yeah it’s great they have a few examples on how to use the API, but their makefile is dependent on pkg-config, so it is totally useless for a cross compilation, you would have to add the libs path to your build machine, which is dumb. Not to mention the libraries they use in the example makefile are missing library references required for the example, leading to a TON of missing symbol errors! Well after a bunch of searching I found one or two references to people who got the examples built which lead to the commands to build the damn thing on my machine. This post is for everyone wanting to get started with the ffmpeg API and so I don’t loose it! Enjoy

The -I and -L paths should be to your ffmpeg build, mine was obviously /home/s1axter/projects/ffmpeg_sources/ffmpeg_build/

This is the first post in a series on getting down into the bits of a Raspberry Pi Linux installation. It assumes familiarity with the Linux build process, gcc, make, apt-get, ssh, etc.

Lately I have been thinking about a project that would require a beefy embedded system, one with embedded Linux, fast, and lots of storage. It turns out the RaspberryPi has all the requirements for this project, and I have one laying around, so I figured I would pull it out and get a full development toolchain started to see what the little Pi could do. This project might require a Linux driver module, so for that I need to compile the kernel and modules too. All steps were done on an Xubuntu 12.10 32-bit machine with the Ubuntu GCC/binutils/make packages installed.

Image

The first step was getting an image running. I tried a few and the Arch Linux image is prefect for an embedded project, it doesn’t contain all the X crap by default, it boots in ~10 seconds (thanks to systemd) and the stock image only takes up about 450Mb on a flash drive, leaving lots of space. Here is the image (I used the version from Nov 2013), here is how to make an SD card.

Toolchain

The next step was to get a cross compiler toolchain build. I have seen a lot of posts that say “do an apt-get install gcc-arm-linux-xxxxx on Debian”, that’s all well and good if like relying on Debian, I would like full control over my toolchain, and I don’t want to have to export tons of bash variables for tool locations. Fortunately, there is an awesome application called crosstool-ng that makes downloading and building a custom compiler and tools a breeze. I followed this post successfully and put the output directory of the cross compiler binaries within my home directory, this way the ARM compiler isn’t system wide and I can move it where I want it. I did have to install some packages “sudo apt-get install gperf texinfo gawk libtool automake libncurses5-dev”. The test application compiled without issue and a quick SSH got me “Hello world” on the Pi command line.

Kernel

Rebuilding the kernel and modules seemed a little daunting, but actually it’s pretty easy once you do it. These two references (PDF and elinux) were good for understanding the process. The kernel for the Raspberry Pi is build from a central git repo, so you just need to clone the repo and you have the whole kernel source all patched and ready to go.

The Arch Linux build has a handy feature enabled, it outputs the kernel config for the running kernel in the /proc directory, which means if you use this config as the base for your config, all the settings match the current kernel, which you know works. Copy the file /proc/config.gz from your Pi, uncompress it to ‘.config’ in the root of your kernel source and it will be read by menuconfig, can’t get easier than that!

Now, because I compiled the toolchain into a local home directory I need to pass the path to it for each call to make. This isn’t that bad because I plan on making scripts that build the kernel and modules whenever I need them. Here is an example of how to run menuconfig and the final make:

The kernel make builds both the kernel and the modules for that version of the kernel. You have to copy over both the new kernel and the kernel modules since you can’t use the old modules that exist on the Pi. Again, rather than export a bash variable like the elinux source says I pass the module folder path in the make command.

After these build steps use sftp or some other means to get the modules and firmware directories in the ‘modules/lib/’ folder into the ‘/lib’ folder on the Pi. The kernel new image is ‘arch/arm/boot/Image’ from the kernel source folder and needs to replace /boot/kernel.img on the Pi (Make a backup, just incase). I used scp/sftp, so I logged into the Pi and did a ‘sync‘ command to make sure everything was written to the SD card and then ‘reboot’. I might have been lucky but the Pi came back up and my kernel went from 3.10.18 to 3.10.25!

So I got a GoPro this Christmas for skiing. Yesterday I took some footage on the mountain, including some time lapse shots which I wanted to stitch together to make a sped-up video. I’ve used ffmpeg a bunch, so I knew it could do the job. There isn’t much to making a movie from the images, and the following command works pretty good. The only tricky part was the GoPro doesn’t start all timelapses at G0020001.JPG, mine was at G0020069.JPG. The timelapse setting was one picture every 0.5 sec and the output is 10 fps. The GoPro still are also 4000×3000, so I convert them to 1920×1080 to match the video frame size, this adds a little distortion but still looks pretty good.