gamaral – Software Engineer

PICOPi

Tue, 19 Jul 2016 22:34:32 -0700

PICO-8 console and stand-alone cartridge firmware distributed in an SD card image for the Raspberry Pi.

Update

Sat Aug 6 12:43:42 PDT 2016

I sacrificed an extra second or two in boot time for ease of deployment. No more having to flash an SD cards. You can simply unzip the contents of the PICOPi archive onto a FAT32 formated SD card.

What is it?

PICO-8 is a fantasy console for making, sharing and playing tiny games and
other computer programs. When you turn it on, the machine greets you with a
shell for typing in Lua commands and provides simple built-in tools for
creating your own cartridges.

I fell in love this this little virtual console from day one. It catered perfectly to my 8-bit/16-bit graphic and C64 nostalgia.

PICO-8 on the MinnowBoard

Some time ago, I made a similar image for the Minnowboard since there was no PICO-8 build for ARM at the time:

Soon after Zep released a build for Raspbian and all was good – except for the fact that as an embedded engineer, using Raspbian for this purpose made my skin crawl.

I wanted something that I could just pop in and play some games with in my hotel room, without needing to fiddle around with a full blown desktop, or worry about power cutting out and possibly corrupting the OS.

I was sure I could do better, so I found myself with some free time and I made my own OS image for the PICO-8 on the Raspberry Pi…

I specially wanted to (optionally) be super wasteful and use a single SD card per cartridge (which you can totally do and it’s great). I mean, can you imagine the tiny labels printed on the SD card? I sure can!

PICOPi

Features

Boots directly to the ‘splorer’ or directly to a console (when not in stand-alone cartridge mode).
Corruption resistant.
Crazy-fast boot time.
HDMI audio output on by default.
Keymaps supported.
Nothing on screen but PICO-8.
Raspberry Pi will do a clean shutdown when PICO-8 does.
X-Box controller support (tested).

Download

Raspberry Pi

Tested on Model A, A+, B, B+, CM, Zero.

http://dl.guillermoamaral.com/picopi/picopi-rpi1.zip

Raspberry Pi 2

Tested on Model B

http://dl.guillermoamaral.com/picopi/picopi-rpi2.zip

Raspberry Pi 3

I currently don’t own one – so no image. Feel free to send me a board if you have any spares. :-)

Setup

Format your SD card with a single FAT32 partition.
Unzip the PICOPi onto the SD card.
Unzip the PICO-8 archive (from Lexaloffle) onto the SD card (more information in the PICO-8 section below).

Linux SD Card Setup

Mac OS X SD Card Setup

Windows SD Card Setup

PICO-8

PICO-8 is not free in any sense of the word.

At the moment of writing it will set you back 15 USD for a lot of games which includes PICO-8.

Download the Raspberry-Pi(ARM) archive, expand it in the first partition of the SD card that’s it. It Should Just Work.

Your first partition should look something like this afterwards:

bcm2708-rpi-b.dtb
bcm2708-rpi-b-plus.dtb
bcm2708-rpi-cm.dtb
bootcode.bin
config.txt
fixup.dat
start.elf
pico.pi
pico-8/ <----

Stand-alone Cartridge Mode

Download your favorite cartridge from the PICO-8 website, rename it to rom.p8 or rom.p8.png and place it in the boot partition.

Your first partition should look something like this:

bcm2708-rpi-b-plus.dtb
bcm2708-rpi-b.dtb
bcm2708-rpi-cm.dtb
bootcode.bin
config.txt
fixup.dat
rom.p8.png <----
start.elf
pico-pi
pico-8/

When the Raspberry Pi board boots, it will automatically load the cartrige file and run it.

Configuration

Offline Carts

Download your favorite carts from the PICO-8 website and copy them into the pico-8/carts directory on the SD Card. If the carts directory doesn’t exist, feel free to create it.

Keyboard Layout

If you wish to switch keyboard layout, you will need to modify the following line in config.txt

keymap=us

The usual standard Linux system keymaps are available; Valid keymap names include:

* azerty
* dvorak
* es
* fr
* us

Disable Splorer

It’s possible to boot directly to the console instead of ‘splorer’. To do so, comment out, remove or set the following line in config.txt to off:

splorer=on

Canon DSLR WiFi Remote

Fri, 15 Jan 2016 06:00:00 -0800

Make your own WiFi DSLR Remote!

Part 2 of the video is now available.

Having a tripod with you is not always all you need in order to take sharp, good looking pictures. Sometimes in low light conditions, your hand pressing down on the shutter trigger can make the image come out blurry.

So why not mix the power of the ESP8266 with a convenience of a shutter control? That way you could take photos while you’re chilling watching Netflix.

Check out the video to find out how you can make it happen!

Canon E3

You will need to get your hands on a 2.5 mm Stero Mini Plug like the SP-2501; When plugged into the camera, the tip and the ring will be pulled high. The ESP8266 module will need to drive each of them down to common ground in order to trigger the shutter and/or focus respectively.

Schematic

As you can see in the schematic below, the GPIO2 and GPIO0 in the ESP8266 ESP-01 v2 module will be used to drive the two lines low. The board can be powered through a USB port, a USB charger or even a battery pack.

The circuit is very simple so I’ll leave it up to you, the reader, to adjust it to fit your needs. :)

Code

The code for this project is hosted along with the schematics and gerbers on GitHub.

https://github.com/gamaral/canon-wifimote

Board

I shared the board I made on OSHPark, if you plan on using my design as-is, here’s the URL:

https://oshpark.com/shared_projects/4nVf0mTo

Components

1x 10uF POL capacitor
1x 2x4 pin header
1x Micro USB-B connector
1x ESP8266 ESP-01 v2
1x IFX8117ME V33
1x SP-2501 2.5 mm Stereo Plug
3x 10k Resistors (0603)

Flux Capacitor Notification Light Hack

Wed, 11 Feb 2015 23:00:00 -0800

I modded my Flux Capacitor USB Charger and turned it into an instant notification widget.

It can now be controlled through WiFi, which comes in handy when I get pinged on IRC or get important email.

Hack

I replaced the resistor used to power the flux circuit with a 3v3 SMD regulator that fit the resistor’s footprint. The regulator now powers both the flux circuit IC and the ESP8266 module.

GPIO2 and GPIO0 in the ESP8266 module are used to toggle the flux circuit and keep state respectively. Using custom firmware, GPIO2 is pulled low for half a second when we need to toggle the flux circuit. This is accomplished by connecting to the ESP module via TCP and sending one of the following commands:

TIME CIRCUIT ON TIME CIRCUIT OFF

When the flux circuit fluxes, the cathode-side of the LEDs is pulled low; I hoked up GPIO0 to the cathode of one of the LEDs and made it interrupt on falling edge. When the interrupt is triggered I set the internal state to fluxing, an internal timer is restarted every time the LED is turned on. When the time circuit is turned off, the timer expires and sets the state back to off.

Just in case it wasn’t obvious, we need to know if the time circuit is ON or OFF so that we don’t toggle it OFF when we want it to be ON by mistake.

Components

Xeno-GC Clone Mini

Mon, 14 Oct 2013 12:43:00 -0700

Since I wasn’t satisfied with how I laid out it’s big bother, I decided to redo the board, the Xeno-GC Clone Mini is the end result. It’s about the size of a quarter dollar and twice as sexy. Check out the images above and see for yourself.

Make your own!

The mini model, like it’s big brother, uses 0805 SMD components. No rework station or solder paste required; Just a standard soldering iron and some whiskey (Ok, the whiskey is optional).

Parts

2x 100nF 0805 ceramic capacitors.
2x 1kΩ 0805 resistors.
2x 330Ω 0805 resistors.
1x 100Ω 0805 resistor.
1x Red 0805 LED.
1x Green 0805 LED.
1x Atmel AVR ATmega8L 32-pin TQFP.

Schematic

Order

You can order your boards directly from OSH Park. If you have any questions, feel free to email me. Now go get your homebrew on!

ITEAD Studio Vs. OSH Park - Raspberry Pi PSU PCBs

Sat, 05 Oct 2013 21:16:00 -0700

So is it worth it ordering from China based ITeadStudio versus tried and tested OSH Park? Watch the video and find out!

I’ll be giving away some Raspberry Pi PSU PCBs, subscribe and/or comment on YouTube for a chance to win your own!

It works!

Click here to watch it in action!

Make your own Raspberry Pi - PSU

Mon, 23 Sep 2013 14:05:02 -0700

Here’s the Raspberry Pi R3 PCB TH (Through-Hole) model fully populated.

The R3 board is shared on OSH Park which means you can order your own boards which you can assemble yourself!

Components

All parts are fairly common, specially the passives. Here are a few suppliers for the parts you may have a hard time finding.

ATTiny85

SparkFun: COM-09378 Mouser: 556-ATTINY85-20PU

Programming

You will need a way to program the ATTiny, I suggest getting yourself an Atmel AVR mkII, a Pocket AVR Programmer or if you already own an Arduino you can make an ArduinoISP.

LD33V

SparkFun: COM-00526 Mouser: 511-LD1117V33

TIP125

Mouser: 511-TIP125

PN2222

Adafruit: 756 Mouser: 512-PN2222ABU

Resources

OSH Park: http://oshpark.com/shared_projects/MmabtNcO

Raspberry Pi GPIO using plain C and SysFS

Sun, 04 Aug 2013 02:49:00 -0700

I recently gave a talk on the Raspberry Pi during which I mentioned using the GPIO sysfs interface instead of something like the WiringPi library, I was asked if I could provide a small example… I can.

Example

I’m about to unleash the electronic world’s version of the “Hello World!” program, a blinking LED. Remember, this example requires no special libraries since it uses the sysfs interface.

blink.c

/* blink.c
 *
 * Raspberry Pi GPIO example using sysfs interface.
 * Guillermo A. Amaral B. <g@maral.me>
 *
 * This program blinks GPIO 4 (P1-07) while reading GPIO 24 (P1_18).
 */

#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define IN   0
#define OUT  1

#define LOW  0
#define HIGH 1

#define PIN  24 /* P1-18 */
#define POUT 4  /* P1-07 */

static int GPIOExport(int pin);
static int GPIOUnexport(int pin);
static int GPIODirection(int pin, int dir);
static int GPIORead(int pin);
static int GPIOWrite(int pin, int value);

int
main(int argc, char *argv[])
{
    int repeat = 9;

    /*
     * Enable GPIO pins
     */
    if (-1 == GPIOExport(POUT) || -1 == GPIOExport(PIN))
	return(1);

    /*
     * Set GPIO directions
     */
    if (-1 == GPIODirection(POUT, OUT) || -1 == GPIODirection(PIN, IN))
	return(2);

    do {
	/*
	 * Write GPIO value
	 */
	if (-1 == GPIOWrite(POUT, repeat % 2))
	    return(3);

	/*
	 * Read GPIO value
	 */
	printf("I'm reading %d in GPIO %d\n", GPIORead(PIN), PIN);

	usleep(500 * 1000);
    }
    while (repeat--);

    /*
     * Disable GPIO pins
     */
    if (-1 == GPIOUnexport(POUT) || -1 == GPIOUnexport(PIN))
	return(4);

    return(0);
}

int
GPIOExport(int pin)
{
#define BUFFER_MAX 3
    char buffer[BUFFER_MAX];
    ssize_t bytes_written;
    int fd;

    fd = open("/sys/class/gpio/export", O_WRONLY);
    if (-1 == fd) {
	fprintf(stderr, "Failed to open export for writing!\n");
	return(-1);
    }

    bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pin);
    write(fd, buffer, bytes_written);
    close(fd);
    return(0);
}

int
GPIOUnexport(int pin)
{
    char buffer[BUFFER_MAX];
    ssize_t bytes_written;
    int fd;

    fd = open("/sys/class/gpio/unexport", O_WRONLY);
    if (-1 == fd) {
	fprintf(stderr, "Failed to open unexport for writing!\n");
	return(-1);
    }

    bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pin);
    write(fd, buffer, bytes_written);
    close(fd);
    return(0);
}

int
GPIODirection(int pin, int dir)
{
    static const char s_directions_str[]  = "in\0out";

#define DIRECTION_MAX 35
    char path[DIRECTION_MAX];
    int fd;

    snprintf(path, DIRECTION_MAX, "/sys/class/gpio/gpio%d/direction", pin);
    fd = open(path, O_WRONLY);
    if (-1 == fd) {
	fprintf(stderr, "Failed to open gpio direction for writing!\n");
	return(-1);
    }

    if (-1 == write(fd, &s_directions_str[IN == dir ? 0 : 3], IN == dir ? 2 : 3)) {
	fprintf(stderr, "Failed to set direction!\n");
	return(-1);
    }

    close(fd);
    return(0);
}

int
GPIORead(int pin)
{
#define VALUE_MAX 30
    char path[VALUE_MAX];
    char value_str[3];
    int fd;

    snprintf(path, VALUE_MAX, "/sys/class/gpio/gpio%d/value", pin);
    fd = open(path, O_RDONLY);
    if (-1 == fd) {
	fprintf(stderr, "Failed to open gpio value for reading!\n");
	return(-1);
    }

    if (-1 == read(fd, value_str, 3)) {
	fprintf(stderr, "Failed to read value!\n");
	return(-1);
    }

    close(fd);

    return(atoi(value_str));
}

int
GPIOWrite(int pin, int value)
{
    static const char s_values_str[] = "01";

    char path[VALUE_MAX];
    int fd;

    snprintf(path, VALUE_MAX, "/sys/class/gpio/gpio%d/value", pin);
    fd = open(path, O_WRONLY);
    if (-1 == fd) {
	fprintf(stderr, "Failed to open gpio value for writing!\n");
	return(-1);
    }

    if (1 != write(fd, &s_values_str[LOW == value ? 0 : 1], 1)) {
	fprintf(stderr, "Failed to write value!\n");
	return(-1);
    }

    close(fd);
    return(0);
}

You can download the source by clicking here.

Marshmallow Entertainment System

Sun, 11 Nov 2012 22:58:00 -0800

Back when I was a kid, I decided I wanted to make my own game console. Granted I also wanted to be an astronaut and the first man on Mars, but I had to draw the line somewhere.

Marshmallow Game Engine started as a way for me to keep my cross-platform game engine chops up during my spare time (not that I have that much spare time mind you). But with the advent of both powerful and affordable hardware like the Raspberry Pi, I started looking into creating my own game console again, and I have to admit, I’m very excited.

MES

Thanks to the wonderful Raspberry Pi, I’m finally able to create an affordable DIY console kit for my game engine.

The following are some common components in game consoles, I’ll go through the list so you can get an idea of how the end product will work.

Controllers & Ports

Luckily the RPI has a couple of built in USB ports. A simple USB port hub or something like the Mayflash Wii classic controller pro to PC which can handle two controllers per USB slot can be used to add more ports when needed.

Not all USB controllers will be supported, but I will target the most common ones in the beginning, user submitted mappings will soon follow.

Media Slot

Since I’m planning on having mainly downloadable content, an optical media drive or cartage slot would not make much sense (fun as it may be). I might add external USB storage support.

Enclosure

No definitive case design yet. I’m considering laser cut PCB.

Operating System

Since speed and boot time are very high priority when it comes to game consoles, I decided to build my own distro. It’s lean, mean and comes in one single flavor, COUGAR.

You can see it boot here, don’t look away or you might not see it boot up at all.

http://www.youtube.com/watch?v=4Fjfqz6FxC8

I found that on some LCD displays, screen settling takes longer than the actual system boot, which is pretty awesome. The game engine waits for the screen to be ready before it continues running, this applies for first boot and for video output switching (HDMI <=> Composite).

Game Engine

I’m using my own game engine which is still under heavy development, I’m trying to get people interested in helping out with port maintenance (specially the Windows and MacOS X ports). If you’re interested please contact me.

Try it out!

If you want to try out the demo, just follow the instructions below:

wget http://downloads.marshmallow.me/sdcard.img.xz
xz -d sdcard.img.xz
sudo dd if=sdcard.img of=/dev/**YOUR-DEV-NODE**

After it’s done, insert the sdcard in your Raspberry Pi and plug it in!

Notes

You will need to have a keyboard handy since the odds you have a supported gamepad/joystick is pretty thin (donations welcome!).

F1 - restarts the demo
ESC - kills the demo
SPACE - Jumps
LEFT - Move left
RIGHT - Move right
LSHIFT - Run

Thanks for your interest in my project, please feel free to leave comments or suggestions below.

Also, I’m usually around on IRC #marshmallow_h @ freenode

Marshmallow PandaBoard

Fri, 24 Aug 2012 01:53:40 -0700

As tasty as it might sound, it seems to not be a nutritious partnership, at least not yet.

Performance ranges from 60 fps to 40 fps at times, I’m fairly sure I can tweak it to work faster since the PandaBoard has far more processing power than the Raspberry Pi, but I’m just not sure about it’s GLES2 implementation.

I’m using PowerVR SGX OMAP4 with the X11-EGL driver, maybe the extra layer is slowing it down, I’m not sure. I tried running marshmallow as a fullscreen window and as the window manager itself, but performance didn’t improve much.

On the bright side, input hot-plug works like a charm, native builds are fast and it has a considerably shorter boot time compared to the Raspberry Pi.

Raspberry Pi + Linux uinput + Marshmallow Game Engine

Sat, 04 Aug 2012 20:02:49 -0700

I recently added uinput support to Marshmallow Game Engine, allowing me to received input events on the Raspberry Pi. Also, You can now select which input source you want to use at compile time (evdev, x11, etc).

If you’re interested in watching that in action, you’ve come to the right place. :)