Category Archives: Quicky

IMG_2609_small

Xeno-GC Clone Mini

Xeno-GC Clone Mini

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.

Order

You can order your boards directly from (OSH Park)[http://oshpark.com/shared_projects/XDNLoePV]. If you have any questions, feel free to email me. Now go get your homebrew on!

RPi-PSU R2

Make your own Raspberry Pi – PSU [R2]

I received my Raspberry Pi PSU Revision 2 PCBs in the mail last week and I got a chance to populate and test them during the weekend.

The R2 board is shared on OSH Park which means you can order your own boards and assemble for yourself.

Components

Here’s the board, fully populated and with all the parts values highlighted.

RPi-PSU R2 - 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

2N2222A

Mouser: 511-2N2222A Digi-Key: 497-2598-ND

OBSOLITE R3 replaces this component with the 2N3904 and PN2222

Resources

OSH Park: http://oshpark.com/shared_projects/clqtxZaD Video: http://youtu.be/xgsn7Mpjh7g

Marshmallow on the Raspberry Pi

Raspberry Pi GPIO’s using plain C and SysFS

Talk

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
/* 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.

Raspberry Pi - Power Button Assembly (Front)

Marshmallow Raspberry Pi Power Button – PCB [PROTOTYPE]

First demo PCB board, single-side with 3 jumpers. It’s freshly exposed and ready for drilling. I used a copper board I had laying around, it was a bit scuffed so excuse the pockmarks.

I’ll expose the double-sided version later this week, after I hit the electronics store.

The rpi-pwrbtn repository on GitHub includes the double sided board schem and the MCU code: https://github.com/gamaral/rpi-pwrbtn