Difference between revisions of "Adafruit: 2-Axis Thumb Joystick"

From eLinux.org
Jump to: navigation, search
(Inputs and Outputs)
m
 
(40 intermediate revisions by 4 users not shown)
Line 1: Line 1:
[[Category:ECE497]]
+
[[Category:ECE497]] [[Category:Adafruit]]
  
 +
<pre style="color:red">
 +
Moravec
 +
Overview: 2
 +
Wiring:  2
 +
Code:    2
 +
git/Compiles with make: 2  gcc works
 +
Demo:    2
 +
Total:    10
 +
Comments: Looks good.
 +
</pre>
 +
 +
<pre style="color:red">
 +
Yue
 +
Overview: 2
 +
Wiring:  2
 +
Code:    2
 +
git/Compiles with make: 1  Added git after first grading
 +
Demo:    2
 +
Total:    9
 +
Comments: Looks good.
 +
</pre>
 +
 +
[[File:2axisthumbstick_MED.jpg]]
 
== Overview ==
 
== Overview ==
  
The Adafruit: 2-Axis Thumb Joystick uses 2 10 kOhm pots which are adjusted by moving the joystick. The joystick and development board can be purchased from [https://www.adafruit.com/products/512]. The joystick is simplistic enough that Adafruit does not provide a datasheet.
+
The Adafruit: 2-Axis Thumb Joystick uses 2 10 k&Omega; pots which are adjusted by moving the joystick. The joystick and development board can be purchased from the [https://www.adafruit.com/products/512 Adafruit Website]. The joystick is simplistic enough that Adafruit does not provide a datasheet.
  
 
From the Manufactorer:
 
From the Manufactorer:
Line 12: Line 35:
 
The Adafruit joystick takes a supply voltage (Vs) of up to 5V. The analog outputs have a direct correlation to the resistance observed by the analog joystick. At the resting position, the resistance in both axis is at its middle resistance or 5k. At either extreme of the range of motion, there is either enough resistance for the analog inputs to register a 0 or so little resistance that the supply line to the analog input looks open.
 
The Adafruit joystick takes a supply voltage (Vs) of up to 5V. The analog outputs have a direct correlation to the resistance observed by the analog joystick. At the resting position, the resistance in both axis is at its middle resistance or 5k. At either extreme of the range of motion, there is either enough resistance for the analog inputs to register a 0 or so little resistance that the supply line to the analog input looks open.
  
== Bone Usage ==
+
== BeagleBone Usage ==
 +
 
 +
The BeagleBone can support up to 8 analog inputs and has the ability to supply an analog 1.8 V voltage and an analog ground. I have connected my beagle as shown after soldering the joystick and some wires to the dev board:
 +
 
 +
[[File:BeagleBone_Adafruit_2axis_Joystick_mmoravec.jpg|300px]]
 +
 
 +
 
 +
 
 +
The pinout is as shown:
 +
 
 +
[[File:Bone_P9_pinout.jpg|300px]]
 +
 
 +
 
 +
 
 +
Pins 36 and 38 I have wired to the 0-1.8V analog inputs. I have wired VCC to the Beagle's 1.8V analog VCC output(pin 32). The ground wire from the joystick is wired to the analog ground on the beagle(pin 34). The select GPIO signal I have routed to the GPIO_7 pin(pin 42).
 +
 
 +
I have written a small program which displays the x-Axis and y-Axis positions in the terminal. It can be found in a git repository [http://github.com/mmoravec/Adafruit_Joystick_Utility here].
 +
 
 +
Using this configuration one can take the analog inputs with the GPIO selector and do about anything that requires two axises of movement and a selection knob. If you need some help interfacing with the analog ports or the GPIO ports, check out Dr. Yoder's succinct exercise at [http://elinux.org/EBC_Exercise_10_Flashing_an_LED Analog and GPIO Info]
 +
 
 +
Enjoy!
 +
 
 +
 
 +
== Control a 8x8 LED Matrix With The Joystick ==
 +
 
 +
Now we have the joystick as an input, and we can do something interesting if there's an output part. This is a mini project about using the joysick to control a 8x8 LED matrix.
 +
 
 +
The details about the LED matrix can be found here: [https://www.adafruit.com/products/871 Mini 8x8 LED Matrix w/I2C - Yellow]
 +
The LED matrix has an i2c port. Wire up the LED matrix to the Beagle Bone by attaching the Vdd to the 3.3V + bus, the GND to the - bus, SDA to SDA (pin 20), and SCLK to SCLK (pin 19). The joystick can be wired up as described above. Here is a picture of the hardware configuration.
 +
 
 +
[[File:IMG wireup.JPG|500px]]
 +
 
 +
 
 +
Our main goal is to create a bright dot on the LED matrix and use the joystick to move it.
 +
<pre>
 +
static __u16 dot_bmp[] = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 +
pos = 0x80;
 +
 
 +
if(analog_value_x >= 4000 && row < 7) {
 +
row ++;
 +
dot_bmp[row] = pos;
 +
dot_bmp[row - 1] = 0x00;
 +
}
 +
if(analog_value_x <= 1000 && row > 0) {
 +
row --;
 +
dot_bmp[row] = pos;
 +
dot_bmp[row + 1] = 0x00;
 +
}
 +
if(analog_value_y >= 4000 && pos < 0x80) {
 +
pos = pos << 1;
 +
dot_bmp[row] = pos;
 +
}
 +
if(analog_value_y <= 1000 && pos > 0x01) {
 +
pos = pos >> 1;
 +
dot_bmp[row] = pos;
 +
}
 +
</pre>
 +
This is how we move the dot around: First, we create a bmp array whose first element is 0x80, which means only the dot on the right-down corner should be bright. 'analog_value_x' and 'analogy_value_y' are the two variables we set up to represent the voltage of x-axis and y-axis analog-in. 'pos' represents the position of the bright dot in the row. If 'analog_value_x' changes significantly and the bright dot does not reach the boundary of the 8x8 matrix, we should light up the dot next to it and turn off the dot itself.
 +
 
 +
<pre>
 +
for(i = 0; i < 8; i ++)
 +
block[i] = (bright_bmp[i] & 0xfe) >>1 | (bright_bmp[i] & 0x01) << 7;
 +
 
 +
res = i2c_smbus_write_i2c_block_data(file, daddress, 16, (__u8 *)block);
 +
</pre>
 +
For some reason the display is rotated one column, so after pre-unrotating the data, we can write the block data through the i2c bus. Thus, a dot can be lighten up on the matrix and can be moved as the way we want.
 +
 
 +
[[File:DOT MATRIX.JPG|500px]]
 +
 
 +
Next, we would like to make use of the button on the joystick. This is our objective: when pushing the button down, an interrupt is triggered and a frown face is presented on the LED matrix. Then if we move the dot across the face, it can be changed to a smile face.
 +
 
 +
According to the instructions on the joystick, the SEL shorts to ground when pressed. So the first important thing to do is to change gpio0_7 to pull-up mode. So that the interrupt can work correctly. Instructions about setting the interrupt can be found [http://elinux.org/EBC_Exercise_11_gpio_Polling_and_Interrupts here].
 +
 
 +
In the interrupt, we set the smile face as the 'hidden_bmp', the frown_face as the 'bright_bmp', and set up a 'trace_bmp' to record the LEDs that the dot has passed. The LEDs we should light up is the LEDs in the bright_bmp that the dot hasn't passed, the LEDs in the hidden_bmp that the dot has already passed, and the dot itself.
 +
<pre>
 +
trace_bmp[row] = trace_bmp[row] | dot_bmp[row];
 +
for(i = 0; i < 8; i ++)
 +
bright_bmp[i] = (bright_bmp[i] & ~trace_bmp[i]) | (hidden_bmp[i] & trace_bmp[i]) | dot_bmp[i];
 +
</pre>
 +
 
 +
[[File:FROWN MATRIX.JPG|500px]] [[File:SMILE MATRIX.JPG|500px]]
 +
 
 +
We've reached our goal! Try to change the graphs and have fun!
 +
 
 +
 
 +
The main codes are listed as below. And all the resources including the header files can be found on [https://github.com/Astroricks/Beagle-Project/tree/master/Miniproject02 Github:Astroricks].
 +
<pre>
 +
/*****************************************************
 +
Project Name: Joystick controlled 8x8 LED Matrix
 +
Author: Yue Zhang
 +
Date: 10/10/2012
 +
*****************************************************/
 +
 
 +
#include <errno.h>
 +
#include <string.h>
 +
#include <stdio.h>
 +
#include <stdlib.h>
 +
#include <unistd.h>
 +
#include <fcntl.h>
 +
#include <poll.h>
 +
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
 +
#include "i2c-dev.h"
 +
#include "i2cbusses.h"
 +
#include "gpio.h"
 +
 
 +
 
 +
/****************************************************************
 +
* Constants
 +
****************************************************************/
 +
 +
#define SYSFS_GPIO_DIR "/sys/class/gpio"
 +
#define POLL_TIMEOUT (100) /* 0.1 seconds */
 +
#define MAX_BUF 64
 +
 
 +
/****************************************************************
 +
* Global variables
 +
****************************************************************/
 +
int keepgoing = 1; // Set to 0 when ctrl-c is pressed
 +
 
 +
/****************************************************************
 +
* signal_handler
 +
****************************************************************/
 +
// Callback called when SIGINT is sent to the process (Ctrl-C)
 +
void signal_handler(int sig)
 +
{
 +
printf( "Ctrl-C pressed, cleaning up and exiting..\n" );
 +
keepgoing = 0;
 +
}
 +
 
 +
 
 +
 
 +
/****************************************************************
 +
* analog_in
 +
****************************************************************/
 +
int analog_in(char *ain)
 +
{
 +
FILE *fp;
 +
char ainPath[MAX_BUF];
 +
char ainVal[MAX_BUF];
 +
 +
snprintf(ainPath, sizeof ainPath, "/sys/devices/platform/omap/tsc/%s", ain);
 +
 
 +
if((fp = fopen(ainPath, "r")) == NULL){
 +
printf("Can't open this pin, %s\n", ain);
 +
return 1;
 +
}
 +
 
 +
fgets(ainVal, MAX_BUF, fp);
 +
 
 +
fclose(fp);
 +
return atoi(ainVal);
 +
}
 +
 
 +
/****************************************************************
 +
* Check
 +
****************************************************************/
 +
static void help(void) __attribute__ ((noreturn));
 +
 
 +
static void help(void)
 +
{
 +
fprintf(stderr, "Usage: my2cset (hardwired to bus 3, address 0x70)\n");
 +
exit(1);
 +
}
 +
 
 +
static int check_funcs(int file, int size)
 +
{
 +
unsigned long funcs;
 +
 
 +
/* check adapter functionality */
 +
if (ioctl(file, I2C_FUNCS, &funcs) < 0) {
 +
fprintf(stderr, "Error: Could not get the adapter "
 +
"functionality matrix: %s\n", strerror(errno));
 +
return -1;
 +
}
 +
 
 +
switch (size) {
 +
case I2C_SMBUS_BYTE:
 +
if (!(funcs & I2C_FUNC_SMBUS_WRITE_BYTE)) {
 +
fprintf(stderr, MISSING_FUNC_FMT, "SMBus send byte");
 +
return -1;
 +
}
 +
break;
 +
 
 +
case I2C_SMBUS_BYTE_DATA:
 +
if (!(funcs & I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) {
 +
fprintf(stderr, MISSING_FUNC_FMT, "SMBus write byte");
 +
return -1;
 +
}
 +
break;
 +
 
 +
case I2C_SMBUS_WORD_DATA:
 +
if (!(funcs & I2C_FUNC_SMBUS_WRITE_WORD_DATA)) {
 +
fprintf(stderr, MISSING_FUNC_FMT, "SMBus write word");
 +
return -1;
 +
}
 +
break;
 +
 
 +
case I2C_SMBUS_BLOCK_DATA:
 +
if (!(funcs & I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)) {
 +
fprintf(stderr, MISSING_FUNC_FMT, "SMBus block write");
 +
return -1;
 +
}
 +
break;
 +
case I2C_SMBUS_I2C_BLOCK_DATA:
 +
if (!(funcs & I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) {
 +
fprintf(stderr, MISSING_FUNC_FMT, "I2C block write");
 +
return -1;
 +
}
 +
break;
 +
}
 +
 
 +
return 0;
 +
}
 +
 
 +
 
 +
/****************************************************************
 +
* Main
 +
****************************************************************/
 +
int main(int argc, char *argv[])
 +
{
 +
struct pollfd fdset[1];
 +
int nfds = 1;
 +
int gpio_button_fd, ain_pin_x, ain_pin_y, timeout;
 +
char *buf[MAX_BUF];
 +
char ainx[MAX_BUF], ainy[MAX_BUF];
 +
unsigned int gpio_button;
 +
float analog_value_x = 0, analog_value_y = 0;
 +
int res, i2cbus, address, size, file;
 +
int value, daddress;
 +
char filename[20];
 +
int force = 0, readback = 1;
 +
__u16 block[I2C_SMBUS_BLOCK_MAX], hidden_bmp[I2C_SMBUS_BLOCK_MAX], bright_bmp[I2C_SMBUS_BLOCK_MAX], trace_bmp[I2C_SMBUS_BLOCK_MAX];
 +
int row = 0, pos = 0x80;
 +
int i, n = 0;
 +
 +
static __u16 dot_bmp[] = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 +
static __u16 smile_bmp[] = {0x3C, 0x42, 0x95, 0xA1, 0xA1, 0x95, 0x42, 0x3C};
 +
static __u16 frown_bmp[] = {0x3C, 0x42, 0xA5, 0x91, 0x91, 0xA5, 0x42, 0x3C};
 +
 
 +
 
 +
// Set the signal callback for Ctrl-C
 +
signal(SIGINT, signal_handler);
 +
 +
// Get the pin values
 +
gpio_button = 7;
 +
ain_pin_x = 6;
 +
ain_pin_y = 4;
 +
 
 +
// Set gpio0_7 to be pullup
 +
gpio_pullup();
 +
 
 +
// Set the gpio_button to be input and set its working pattern
 +
gpio_export(gpio_button);
 +
gpio_set_dir(gpio_button, 0);
 +
gpio_set_edge(gpio_button, "falling");  // Can be rising, falling or both
 +
gpio_button_fd = gpio_fd_open(gpio_button);
 +
 
 +
// Set up analog-in
 +
snprintf(ainx, sizeof ainx, "ain%d", ain_pin_x);
 +
snprintf(ainy, sizeof ainy, "ain%d", ain_pin_y);
 +
 +
// Set time out
 +
timeout = POLL_TIMEOUT;
 +
 +
// Set up i2c
 +
i2cbus = lookup_i2c_bus("3");
 +
printf("i2cbus = %d\n", i2cbus);
 +
if (i2cbus < 0)
 +
help();
 +
 
 +
address = parse_i2c_address("0x70");
 +
printf("address = 0x%2x\n", address);
 +
if (address < 0)
 +
help();
 +
 
 +
size = I2C_SMBUS_BYTE;
 +
 
 +
daddress = 0x21;
 +
if (daddress < 0 || daddress > 0xff) {
 +
fprintf(stderr, "Error: Data address invalid!\n");
 +
help();
 +
}
 +
 
 +
file = open_i2c_dev(i2cbus, filename, sizeof(filename), 0);
 +
printf("file = %d\n", file);
 +
if (file < 0
 +
|| check_funcs(file, size)
 +
|| set_slave_addr(file, address, force))
 +
exit(1);
 +
 
 +
 
 +
daddress = 0x21; // Start oscillator
 +
printf("writing: 0x%02x\n", daddress);
 +
res = i2c_smbus_write_byte(file, daddress);
 +
 
 +
daddress = 0x81; // Display on, blinking off
 +
printf("writing: 0x%02x\n", daddress);
 +
res = i2c_smbus_write_byte(file, daddress);
 +
 
 +
 
 +
daddress = 0xe7; // Full brightness
 +
printf("writing: 0x%02x\n", daddress);
 +
res = i2c_smbus_write_byte(file, daddress);
 +
 
 +
daddress = 0x00; // Start writing to address 0
 +
printf("writing: 0x%02x\n", daddress);
 +
res = i2c_smbus_write_byte(file, daddress);
 +
 
 +
 
 +
while (keepgoing) {
 +
memset((void*)fdset, 0, sizeof(fdset));
 +
 
 +
fdset[0].fd = gpio_button_fd;
 +
fdset[0].events = POLLPRI;
 +
 
 +
analog_value_x = analog_in(ainx);
 +
analog_value_y = analog_in(ainy);
 +
 
 +
 +
poll(fdset, nfds, timeout);
 +
 
 +
 
 +
if(analog_value_x >= 4000 && row < 7) {
 +
row ++;
 +
dot_bmp[row] = pos;
 +
dot_bmp[row - 1] = 0x00;
 +
}
 +
if(analog_value_x <= 1000 && row > 0) {
 +
row --;
 +
dot_bmp[row] = pos;
 +
dot_bmp[row + 1] = 0x00;
 +
}
 +
if(analog_value_y >= 4000 && pos < 0x80) {
 +
pos = pos << 1;
 +
dot_bmp[row] = pos;
 +
}
 +
if(analog_value_y <= 1000 && pos > 0x01) {
 +
pos = pos >> 1;
 +
dot_bmp[row] = pos;
 +
}
 +
 +
// The LEDs we should light up is the LEDs in the bright_bmp that the dot hasn't passed, the LEDs in the hidden_bmp that the dot has already passed, and the dot itself. 
 +
trace_bmp[row] = trace_bmp[row] | dot_bmp[row];
 +
for(i = 0; i < 8; i ++)
 +
bright_bmp[i] = (bright_bmp[i] & ~trace_bmp[i]) | (hidden_bmp[i] & trace_bmp[i]) | dot_bmp[i];
 +
 
 +
// For some reason the display is rotated one column, so pre-unrotate the data.
 +
for(i = 0; i < 8; i ++)
 +
block[i] = (bright_bmp[i] & 0xfe) >>1 | (bright_bmp[i] & 0x01) << 7;
 +
 
 +
res = i2c_smbus_write_i2c_block_data(file, daddress, 16, (__u8 *)block);
 +
 
 +
 
 +
// Button interrupt
 +
if (fdset[0].revents & POLLPRI) {
 +
lseek(fdset[0].fd, 0, SEEK_SET);  // Read from the start of the file
 +
read(fdset[0].fd, buf, MAX_BUF);
 +
switch(n){
 +
case(0): // Initialize in the initial interrupt.
 +
for(i = 0; i < 8; i ++) {
 +
hidden_bmp[i] = 0x00;
 +
bright_bmp[i] = 0x00;
 +
trace_bmp[i] = 0x00;
 +
}
 +
break;
 +
default:
 +
for(i = 0; i < 8; i ++)
 +
block[i] = (frown_bmp[i]&0xfe) >>1 | (frown_bmp[i]&0x01) << 7;
 +
res = i2c_smbus_write_i2c_block_data(file, daddress, 16, (__u8 *)block);
 +
sleep(1);
 +
for(i = 0; i < 8; i ++) {
 +
hidden_bmp[i] = smile_bmp[i];
 +
bright_bmp[i] = frown_bmp[i];
 +
trace_bmp[i] = 0x00;
 +
}
 +
break;
 +
}
 +
n++;
 +
}
 +
 +
 
 +
fflush(stdout);
 +
}
 +
 
 +
gpio_fd_close(gpio_button_fd);
 +
return 0;
  
Because the ADXL335 has analog outputs, data can be read into the Bone via the analog input pins. The ADXL335 can be supplied either with the 1.8 V output on Pin 32 of P9, or with the standard 3.3 V supply.
 
  
''Note: ''The maximum voltage for the Bone analog input is 1.8 V, so if the 3.3 V supply is chosen to power the ADXL335, a voltage divider must be used to reduce the output voltages to under 1.8 V. Two 10kOhm resistors have been used successfully for this purpose in the past.
+
exit(0);
 +
}
 +
</pre>

Latest revision as of 18:31, 14 November 2012


Moravec
Overview: 2
Wiring:   2
Code:     2
git/Compiles with make: 2  gcc works
Demo:     2
Total:    10
Comments: Looks good.
Yue
Overview: 2
Wiring:   2
Code:     2
git/Compiles with make: 1  Added git after first grading
Demo:     2
Total:    9
Comments: Looks good.

2axisthumbstick MED.jpg

Overview

The Adafruit: 2-Axis Thumb Joystick uses 2 10 kΩ pots which are adjusted by moving the joystick. The joystick and development board can be purchased from the Adafruit Website. The joystick is simplistic enough that Adafruit does not provide a datasheet.

From the Manufactorer: This mini-kit makes it easy to mount a PSP/Xbox-like thumb joystick to your project. The thumbstick is an analog joystick - more accurate and sensitive than just 'directional' joysticks - with a 'press in to select' button. Since it's analog, you'll need to analog reading pins on your microcontroller to determine X and Y. Having an extra digital input will let you read the switch.

Inputs and Outputs

The Adafruit joystick takes a supply voltage (Vs) of up to 5V. The analog outputs have a direct correlation to the resistance observed by the analog joystick. At the resting position, the resistance in both axis is at its middle resistance or 5k. At either extreme of the range of motion, there is either enough resistance for the analog inputs to register a 0 or so little resistance that the supply line to the analog input looks open.

BeagleBone Usage

The BeagleBone can support up to 8 analog inputs and has the ability to supply an analog 1.8 V voltage and an analog ground. I have connected my beagle as shown after soldering the joystick and some wires to the dev board:

BeagleBone Adafruit 2axis Joystick mmoravec.jpg


The pinout is as shown:

Bone P9 pinout.jpg


Pins 36 and 38 I have wired to the 0-1.8V analog inputs. I have wired VCC to the Beagle's 1.8V analog VCC output(pin 32). The ground wire from the joystick is wired to the analog ground on the beagle(pin 34). The select GPIO signal I have routed to the GPIO_7 pin(pin 42).

I have written a small program which displays the x-Axis and y-Axis positions in the terminal. It can be found in a git repository here.

Using this configuration one can take the analog inputs with the GPIO selector and do about anything that requires two axises of movement and a selection knob. If you need some help interfacing with the analog ports or the GPIO ports, check out Dr. Yoder's succinct exercise at Analog and GPIO Info

Enjoy!


Control a 8x8 LED Matrix With The Joystick

Now we have the joystick as an input, and we can do something interesting if there's an output part. This is a mini project about using the joysick to control a 8x8 LED matrix.

The details about the LED matrix can be found here: Mini 8x8 LED Matrix w/I2C - Yellow The LED matrix has an i2c port. Wire up the LED matrix to the Beagle Bone by attaching the Vdd to the 3.3V + bus, the GND to the - bus, SDA to SDA (pin 20), and SCLK to SCLK (pin 19). The joystick can be wired up as described above. Here is a picture of the hardware configuration.

IMG wireup.JPG


Our main goal is to create a bright dot on the LED matrix and use the joystick to move it.

static __u16 dot_bmp[] = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
pos = 0x80;

if(analog_value_x >= 4000 && row < 7) {
	row ++;
	dot_bmp[row] = pos;
	dot_bmp[row - 1] = 0x00;
}
if(analog_value_x <= 1000 && row > 0) {
	row --;
	dot_bmp[row] = pos;
	dot_bmp[row + 1] = 0x00;
}
if(analog_value_y >= 4000 && pos < 0x80) {
	pos = pos << 1;			
	dot_bmp[row] = pos;
}
if(analog_value_y <= 1000 && pos > 0x01) {
	pos = pos >> 1;			
	dot_bmp[row] = pos;
}

This is how we move the dot around: First, we create a bmp array whose first element is 0x80, which means only the dot on the right-down corner should be bright. 'analog_value_x' and 'analogy_value_y' are the two variables we set up to represent the voltage of x-axis and y-axis analog-in. 'pos' represents the position of the bright dot in the row. If 'analog_value_x' changes significantly and the bright dot does not reach the boundary of the 8x8 matrix, we should light up the dot next to it and turn off the dot itself.

for(i = 0; i < 8; i ++)
	block[i] = (bright_bmp[i] & 0xfe) >>1 | (bright_bmp[i] & 0x01) << 7;

res = i2c_smbus_write_i2c_block_data(file, daddress, 16, (__u8 *)block);

For some reason the display is rotated one column, so after pre-unrotating the data, we can write the block data through the i2c bus. Thus, a dot can be lighten up on the matrix and can be moved as the way we want.

DOT MATRIX.JPG

Next, we would like to make use of the button on the joystick. This is our objective: when pushing the button down, an interrupt is triggered and a frown face is presented on the LED matrix. Then if we move the dot across the face, it can be changed to a smile face.

According to the instructions on the joystick, the SEL shorts to ground when pressed. So the first important thing to do is to change gpio0_7 to pull-up mode. So that the interrupt can work correctly. Instructions about setting the interrupt can be found here.

In the interrupt, we set the smile face as the 'hidden_bmp', the frown_face as the 'bright_bmp', and set up a 'trace_bmp' to record the LEDs that the dot has passed. The LEDs we should light up is the LEDs in the bright_bmp that the dot hasn't passed, the LEDs in the hidden_bmp that the dot has already passed, and the dot itself.

trace_bmp[row] = trace_bmp[row] | dot_bmp[row];
		for(i = 0; i < 8; i ++)		
			bright_bmp[i] = (bright_bmp[i] & ~trace_bmp[i]) | (hidden_bmp[i] & trace_bmp[i]) | dot_bmp[i];

FROWN MATRIX.JPG SMILE MATRIX.JPG

We've reached our goal! Try to change the graphs and have fun!


The main codes are listed as below. And all the resources including the header files can be found on Github:Astroricks.

/*****************************************************
Project Name: Joystick controlled 8x8 LED Matrix
Author: Yue Zhang
Date: 10/10/2012
*****************************************************/

#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>	// Defines signal-handling functions (i.e. trap Ctrl-C)
#include "i2c-dev.h"
#include "i2cbusses.h"
#include "gpio.h"


/****************************************************************
 * Constants
****************************************************************/
 
#define SYSFS_GPIO_DIR "/sys/class/gpio"
#define POLL_TIMEOUT (100) /* 0.1 seconds */
#define MAX_BUF 64

/****************************************************************
 * Global variables
 ****************************************************************/
int keepgoing = 1;	// Set to 0 when ctrl-c is pressed

/****************************************************************
 * signal_handler
 ****************************************************************/
// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
	printf( "Ctrl-C pressed, cleaning up and exiting..\n" );
	keepgoing = 0;
}



/****************************************************************
* analog_in
****************************************************************/
int analog_in(char *ain)
{
	FILE *fp;
	char ainPath[MAX_BUF];
	char ainVal[MAX_BUF];
	
	snprintf(ainPath, sizeof ainPath, "/sys/devices/platform/omap/tsc/%s", ain);

	if((fp = fopen(ainPath, "r")) == NULL){
	printf("Can't open this pin, %s\n", ain);
	return 1;
	}

	fgets(ainVal, MAX_BUF, fp);

	fclose(fp);
	return atoi(ainVal);		
}

/****************************************************************
* Check
****************************************************************/
static void help(void) __attribute__ ((noreturn));

static void help(void)
{
	fprintf(stderr, "Usage: my2cset (hardwired to bus 3, address 0x70)\n");
	exit(1);
}

static int check_funcs(int file, int size)
{
	unsigned long funcs;

	/* check adapter functionality */
	if (ioctl(file, I2C_FUNCS, &funcs) < 0) {
		fprintf(stderr, "Error: Could not get the adapter "
			"functionality matrix: %s\n", strerror(errno));
		return -1;
	}

	switch (size) {
	case I2C_SMBUS_BYTE:
		if (!(funcs & I2C_FUNC_SMBUS_WRITE_BYTE)) {
			fprintf(stderr, MISSING_FUNC_FMT, "SMBus send byte");
			return -1;
		}
		break;

	case I2C_SMBUS_BYTE_DATA:
		if (!(funcs & I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) {
			fprintf(stderr, MISSING_FUNC_FMT, "SMBus write byte");
			return -1;
		}
		break;

	case I2C_SMBUS_WORD_DATA:
		if (!(funcs & I2C_FUNC_SMBUS_WRITE_WORD_DATA)) {
			fprintf(stderr, MISSING_FUNC_FMT, "SMBus write word");
			return -1;
		}
		break;

	case I2C_SMBUS_BLOCK_DATA:
		if (!(funcs & I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)) {
			fprintf(stderr, MISSING_FUNC_FMT, "SMBus block write");
			return -1;
		}
		break;
	case I2C_SMBUS_I2C_BLOCK_DATA:
		if (!(funcs & I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) {
			fprintf(stderr, MISSING_FUNC_FMT, "I2C block write");
			return -1;
		}
		break;
	}

	return 0;
}


/****************************************************************
* Main
****************************************************************/
int main(int argc, char *argv[])
{
	struct pollfd fdset[1];
	int nfds = 1;
	int gpio_button_fd, ain_pin_x, ain_pin_y, timeout;
	char *buf[MAX_BUF];
	char ainx[MAX_BUF], ainy[MAX_BUF];
	unsigned int gpio_button;
	float analog_value_x = 0, analog_value_y = 0;
	int res, i2cbus, address, size, file;
	int value, daddress;
	char filename[20];
	int force = 0, readback = 1;
	__u16 block[I2C_SMBUS_BLOCK_MAX], hidden_bmp[I2C_SMBUS_BLOCK_MAX], bright_bmp[I2C_SMBUS_BLOCK_MAX], trace_bmp[I2C_SMBUS_BLOCK_MAX];
	int row = 0, pos = 0x80;
	int i, n = 0;
	
	static __u16 dot_bmp[] = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
	static __u16 smile_bmp[] = {0x3C, 0x42, 0x95, 0xA1, 0xA1, 0x95, 0x42, 0x3C};
	static __u16 frown_bmp[] = {0x3C, 0x42, 0xA5, 0x91, 0x91, 0xA5, 0x42, 0x3C};


	// Set the signal callback for Ctrl-C
	signal(SIGINT, signal_handler);
	
	// Get the pin values
	gpio_button = 7;
	ain_pin_x = 6;
	ain_pin_y = 4;

	// Set gpio0_7 to be pullup
	gpio_pullup();

	// Set the gpio_button to be input and set its working pattern	
	gpio_export(gpio_button);
	gpio_set_dir(gpio_button, 0);
	gpio_set_edge(gpio_button, "falling");  // Can be rising, falling or both
	gpio_button_fd = gpio_fd_open(gpio_button);

	// Set up analog-in
	snprintf(ainx, sizeof ainx, "ain%d", ain_pin_x);
	snprintf(ainy, sizeof ainy, "ain%d", ain_pin_y);
 
	// Set time out
	timeout = POLL_TIMEOUT;
 
	// Set up i2c
	i2cbus = lookup_i2c_bus("3");
	printf("i2cbus = %d\n", i2cbus);
	if (i2cbus < 0)
		help();

	address = parse_i2c_address("0x70");
	printf("address = 0x%2x\n", address);
	if (address < 0)
		help();

	size = I2C_SMBUS_BYTE;

	daddress = 0x21;
	if (daddress < 0 || daddress > 0xff) {
		fprintf(stderr, "Error: Data address invalid!\n");
		help();
	}

	file = open_i2c_dev(i2cbus, filename, sizeof(filename), 0);
	printf("file = %d\n", file);
	if (file < 0
	 || check_funcs(file, size)
	 || set_slave_addr(file, address, force))
		exit(1);


		daddress = 0x21;	// Start oscillator
		printf("writing: 0x%02x\n", daddress);
		res = i2c_smbus_write_byte(file, daddress);

		daddress = 0x81;	// Display on, blinking off
		printf("writing: 0x%02x\n", daddress);
		res = i2c_smbus_write_byte(file, daddress);


		daddress = 0xe7;	// Full brightness
		printf("writing: 0x%02x\n", daddress);
		res = i2c_smbus_write_byte(file, daddress);

		daddress = 0x00;	// Start writing to address 0
		printf("writing: 0x%02x\n", daddress);
		res = i2c_smbus_write_byte(file, daddress);


	while (keepgoing) {
		memset((void*)fdset, 0, sizeof(fdset));

		fdset[0].fd = gpio_button_fd;
		fdset[0].events = POLLPRI;

		analog_value_x = analog_in(ainx);
		analog_value_y = analog_in(ainy);

		
		poll(fdset, nfds, timeout);		


		if(analog_value_x >= 4000 && row < 7) {
			row ++;
			dot_bmp[row] = pos;
			dot_bmp[row - 1] = 0x00;
		}
		if(analog_value_x <= 1000 && row > 0) {
			row --;
			dot_bmp[row] = pos;
			dot_bmp[row + 1] = 0x00;
		}
		if(analog_value_y >= 4000 && pos < 0x80) {
			pos = pos << 1;			
			dot_bmp[row] = pos;
		}
		if(analog_value_y <= 1000 && pos > 0x01) {
			pos = pos >> 1;			
			dot_bmp[row] = pos;
		}
		
		// The LEDs we should light up is the LEDs in the bright_bmp that the dot hasn't passed, the LEDs in the hidden_bmp that the dot has already passed, and the dot itself.  
		trace_bmp[row] = trace_bmp[row] | dot_bmp[row];
		for(i = 0; i < 8; i ++)		
			bright_bmp[i] = (bright_bmp[i] & ~trace_bmp[i]) | (hidden_bmp[i] & trace_bmp[i]) | dot_bmp[i];

		// For some reason the display is rotated one column, so pre-unrotate the data.
		for(i = 0; i < 8; i ++)
			block[i] = (bright_bmp[i] & 0xfe) >>1 | (bright_bmp[i] & 0x01) << 7;

		res = i2c_smbus_write_i2c_block_data(file, daddress, 16, (__u8 *)block);


		// Button interrupt
		if (fdset[0].revents & POLLPRI) {
			lseek(fdset[0].fd, 0, SEEK_SET);  // Read from the start of the file
			read(fdset[0].fd, buf, MAX_BUF);						
			switch(n){
				case(0):		// Initialize in the initial interrupt.
					for(i = 0; i < 8; i ++) {
						hidden_bmp[i] = 0x00;
						bright_bmp[i] = 0x00;
						trace_bmp[i] = 0x00;
					}	 
					break;		
				default:
					for(i = 0; i < 8; i ++) 
						block[i] = (frown_bmp[i]&0xfe) >>1 | (frown_bmp[i]&0x01) << 7;					
					res = i2c_smbus_write_i2c_block_data(file, daddress, 16, (__u8 *)block);
					sleep(1);
					for(i = 0; i < 8; i ++) {
						hidden_bmp[i] = smile_bmp[i];
						bright_bmp[i] = frown_bmp[i];
						trace_bmp[i] = 0x00;
					}	
					break;
			}			
			n++;
		}
		

		fflush(stdout);
	}

	gpio_fd_close(gpio_button_fd);
	return 0;


	exit(0);
}