We ordered the electronics for the guitar from SparkFun Electronics and Digi-Key. When the project is over, I plan to add up the total cost and post a bill of materials. I suspect it will total to around $100.

Today we tested out the 4.3″ touchpad from SparkFun using an Arduino. I have just finished setting up an ATmega328P on a breadboard and got a basic blink program running. The final product will be running on a plain AVR without the Arduino libraries/bootloader.

One problem I ran into using my FTDI programmer was the clock rate. A fresh ATmega328P comes running at 1 MHz, significantly lower than the default 16 MHz on Arduino-prepared ATmegas. As a result, I kept getting errors like this:

david@second:~$ avrdude -c ftdi -p atmega168 -P ft0
avrdude: BitBang OK 
avrdude: pin assign miso 1 sck 3 mosi 0 reset 4
avrdude: drain OK 
 
 ft245r:  bitclk 230400 -> ft baud 115200
avrdude: ft245r_program_enable: failed
avrdude: initialization failed, rc=-1
         Double check connections and try again, or use -F to override
         this check.
 
 
avrdude done.  Thank you.

Eventually I found AVRDUDE’s -B option. It adjusts the clock rate that’s fed into the SCK pin on the AVR. I found that a value of -B 76800 works well, but if you’re running into this problem, I recommend starting with -B 1 and going up until it stops working. To be explicit, this is the command that I found works:

david@second:~$ avrdude -c ftdi -p atmega168 -P ft0 -B 76800

#!/usr/bin/env python
import cairo
import pygame
import math
 
size = 400, 400
 
# Initialize pygame with 32-bit colors. This setting stores the pixels
# in the format 0x00rrggbb.
pygame.init()
screen = pygame.display.set_mode(size, 0, 32)
 
# Get a reference to the memory block storing the pixel data.
pixels = pygame.surfarray.pixels2d(screen)
 
# Set up a Cairo surface using the same memory block and the same pixel
# format (Cairo's RGB24 format means that the pixels are stored as
# 0x00rrggbb; i.e. only 24 bits are used and the upper 16 are 0).
cairo_surface = cairo.ImageSurface.create_for_data(
	pixels.data, cairo.FORMAT_RGB24, size[0], size[1])
 
# Draw a white circle to the screen using pygame.
radius = int(min(size)/2*0.7)
pos = [int(a/2) for a in size]
pygame.draw.circle(screen, (255,255,255), pos, radius)
 
# Draw a smaller black circle to the screen using Cairo.
context = cairo.Context(cairo_surface)
context.set_source_rgb(0, 0, 0)
context.arc(size[0]/2, size[1]/2, min(size)/2*0.5, 0, 2*math.pi)
context.fill()
 
# Flip the changes into view.
pygame.display.flip()
 
# Wait for the user to quit.
while pygame.QUIT not in [e.type for e in pygame.event.get()]:
	pass

Tested on Python 2.6.4, pycairo 1.8.6, Cairo 1.8.8, pygame 1.8.1, numpy 1.3.0.

Now open up avrdude.conf in a text editor. Add this entry by the other programmers:

# FTDI basic breakout
programmer
  id = "ftdi";
  desc = "FTDI Basic Breakout";
  type = ft245r;
  miso = 1; # RxD
  sck = 3; # CTS
  mosi = 0; # TxD
  reset = 4; # DTR
;

Now you can attach your FTDI Breakout to the target AVR like this:
FTDI -> MCU (ATmega168 PDIP pin)
DTR -> RESET (1)
RXI -> MISO (18)
TXO -> MOSI (17)
5V -> VCC (7 & 20)
CTS -> SCK (19)
GND -> GND (8 & 22)

With the 3×2 ICSP header on the Arduino, that would look like this:

        +----------------+
[RXI]--o| 1 MISO   +5V 2 |o--[5V]
[CTS]--o| 3 SCK   MOSI 4 |o--[TXO]
[DTR]--o| 5 RESET  GND 6 |o--[GND]
        +----------------+

Note that may need to supply the AVR with an external oscillator or clock source. For virgin ATmega168s, you won’t need to (because it initially uses the internal oscillator), but you’ll need an external crystal oscillator if you’re using one that came out of an Arduino.

From there you can use AVRDUDE like normal using the `-c ftdi` switch. For example, to read fuse bytes:

sudo ./avrdude -C avrdude.conf -c ftdi -p m168 -P ft0 -U hfuse:r:-:h -U lfuse:r:-:h -U efuse:r:-:h

Edit 2010-04-18:

I just found out that new AVRs need to have the clock rate adjusted before this will work. This is because AVRs come with the internal clock set to 1 MHz (actually, 8 MHz with the CKDIV8 fuse bit set) instead of the Arduino default 16 MHz. This can be done with AVRDUDE’s -B option. This option determines what clock is fed into the AVR’s SCK pin. I recommend starting with a value of -B 1 and working your way up to a reasonable clock speed. Here is the adjusted command for new AVRs:

sudo ./avrdude -C avrdude.conf -c ftdi -p m168 -P ft0 -U hfuse:r:-:h -U lfuse:r:-:h -U efuse:r:-:h -B 1

————————–

Description: This is an adaptation of the work by Kimio Kosaka, Nate Phillips, and Massimo. It allows you to use AVRDUDE with an FTDI chip (like the one on the Arduino boards or SparkFun’s FTDI Basic Breakout). This can be useful if you manage to brick your Arduino and you have no programmer.

—————————

If you’re on Ubuntu or Debian, install the prerequisites with:

sudo apt-get install patch build-essential libreadline-dev libncurses-dev libusb-dev
sudo apt-get build-dep avrdude avrdude-doc

—

Start by grabbing a copy of AVRDUDE 5.8, untarring it in the directory, and switching to that directory:

wget http://download.savannah.gnu.org/releases-noredirect/avrdude/avrdude-5.8.tar.gz
tar xzf avrdude-5.8.tar.gz
cd avrdude-5.8

—

Now get a copy of the FTDI bitbang patch files:

for i in 8 7 6 5 4 3 2 1 0; do wget -O patch-$i.diff http://savannah.nongnu.org/patch/download.php?file_id=1851$i; done

—

Apply the patches:

for file in patch-*.diff; do patch -p0 < $file; done

—

Also get a copy of the FTDI driver. For 32-bit:

wget http://www.ftdichip.com/Drivers/D2XX/Linux/libftd2xx0.4.16.tar.gz

For 64-bit:

wget http://www.ftdichip.com/Drivers/D2XX/Linux/libftd2xx0.4.16_x86_64.tar.gz

—

Extract the FTDI driver and copy over the needed files:

tar xzf libftd2xx*.tar.gz
cp libftd2xx*/static_lib/* .
cp libftd2xx*/*.h .
cp libftd2xx*/*.cfg .

—

Generate your makefile:

./configure

—

Open Makefile in a text editor and perform the following operations:

1. Find the line CFLAGS = -g -O2 and replace it with CFLAGS = -g -O2 -DHAVE_LIBUSB -DSUPPORT_FT245R.
2. Find the line LIBS = -lreadline -lncurses -ltermcap and replace it with LIBS = -lreadline -lncurses -ltermcap ./libftd2xx.a.0.4.16 -lrt.

—

Now to actually compile it:

make

—

From here, you can follow the instructions at http://www.geocities.jp/arduino_diecimila/bootloader/index_old_en.html starting at step 5. Note that you’ll need to modify the commands a little bit. Instead of:

avrdude -c diecimila -P ft0 -p m168

you should write:

sudo ./avrdude -C avrdude.conf -c duemilanove -P ft0 -p m168

(Note: you can still use it on a Diecimila, just specify the programmer as `-c duemilanove` and it should work.)

If you’d like to use SparkFun’s FTDI Basic Breakout as a programmer, try these instructions.

I noticed that the TMS320F2809 examples accessed GPIOs by bits rather than as 32-bit ints. For example, it’s possible to set a GPIO like this on the TMS320F280x:

GpioDataRegs.GPADAT.bit.GPIO12 = 1; // Sets GPIO12 to high.

Normally when working with AVRs, I would set bits like this:

PORTB |= (1<<PB3); // Sets port b, bit 3 to high.

After a bit of tinkering, I came up with this (for AVRs):

portb.bit.b3 = HIGH; // Sets port b, bit 3 to high.

I personally think it looks a bit cleaner, so I’ll probably be using it in the future. If you’re interested in trying it out, you can download a full example here: bitfields.zip.

Side note: It is also possible to access GPIOs as 32-bit ints on the TMS320F280x like this:

GpioDataRegs.GPADAT.all |= (1<<12); // Sets GPIO12 to high.

Edit: Looks like I’m not alone.

• All variables are represented in italics except in the diagrams and Python code.
• Vectors are shown in bold except in the diagrams and Python code.
• The notation |a| is used to represent the length of a vector named a.

Introduction to the problem

Start by defining a few points (vectors from the world origin):

Now, from these points, you can easily calculate two useful values, the segment vector, seg_v (from seg_a to seg_b) and the position of circ_pos relative to seg_a, pt_v.

seg_v = seg_b – seg_a

pt_v = circ_pos – seg_a

Closest point to the circle’s center on the segment

The next step is to find the closest point to the circle’s center on the segment (labeled “closest” on the diagram). To do this, we must project pt_v onto seg_v:

To project on vector onto another, take the dot product of the vector and the unit vector of the projection target. That is:

Note that this dot product returns a scalar value (the length of proj_v), not a vector.

–

We now need to take a small break from the main goal and look into a special case: the ends of the segment. If |proj_v| is less than 0 or greater than |seg_v|, the closest point to circ_pos on the segment will be one of the segment’s endpoints. That is:
if |proj_v| < 0: closest = seg_a
if |proj_v| > |seg_v|: closest = seg_b

–

Next, calculate the actual proj_v vector, rather than just its length (|proj_v|). To do this, simply multiply by the seg_v unit vector:

The only thing left to do is to convert this into world coordinates (rather than coordinates relative to seg_a) to get the closest point:

closest = seg_a + proj_v

Checking for a intersection

Now that we’ve calculated the closest point on the segment (the variable “closest“), we can check if the circle and segment intersect. To do this, first find the vector from closest to circ_pos:

dist_v = circ_pos – closest

If the length of this vector is less than the circle’s radius, the circle and segment are intersecting:
if |dist_v| < circ_rad: They are intersecting
else: They are not intersecting

Collision response

A useful bit of data in collision response is the amount of overlap between two shapes and the direction a shape must be moved in order to resolve the collision. This can be represented as a vector that points in the same direction as dist_v whose length is equal to the difference between circ_rad and |dist_v|.

Python implementation

Here is a Python implementation of everything in this post. For the sake of clarity, I avoided optimizations. vec is assumed to be a fully implemented 2d vector class.

def closest_point_on_seg(seg_a, seg_b, circ_pos):
	seg_v = seg_b - seg_a
	pt_v = circ_pos - seg_a
	if seg_v.len() <= 0:
		raise ValueError, "Invalid segment length"
	seg_v_unit = seg_v / seg_v.len()
	proj = pt_v.dot(seg_v_unit)
	if proj <= 0:
		return seg_a.copy()
	if proj >= seg_v.len():
		return seg_b.copy()
	proj_v = seg_v_unit * proj
	closest = proj_v + seg_a
	return closest
 
def segment_circle(seg_a, seg_b, circ_pos, circ_rad):
	closest = closest_point_on_seg(seg_a, seg_b, circ_pos)
	dist_v = circ_pos - closest
	if dist_v.len() > circ_rad:
		return vec(0, 0)
	if dist_v.len() <= 0:
		raise ValueError, "Circle's center is exactly on segment"
	offset = dist_v / dist_v.len() * (circ_rad - dist_v.len())
	return offset

Similar algorithms

Collisions involving stadiums (a type of rounded rectangle) can be calculated in a similar manner. A stadium is essentially a line segment with a radius.

A stadium-point collision is the same as a segment-circle collision with a circle whose radius is equal to the stadium’s radius.

A stadium-circle collision is the same as a segment-circle collision with a circle whose radius is equal to the sum of the original circle’s radius and the stadium’s radius.

Download

segment_circle.zip – An implementation in Python and Cython.

Conclusion

If you find this post useful or have any questions, please leave a comment.

Try it: http://doswa.com/projects/animate/
Download it: http://doswa.com/projects/animate/animate.zip

http://trac.sagemath.org/sage_trac/ticket/1483 inspired me to make this, since the sagenb.org server doesn’t have ImageMagick installed.

Read the README file to instructions on setting it up on Ubuntu. Note that you must first install python-notify through apt-get for this to work correctly.

Download PHPNotify

If the function name notify() conflicts with any of your functions, you can change it on lines 2 and 3 of prepend.php

This is a Python implementation of the RK4 numerical integrator that works with differential functions of all orders. That is, any function in the form F(x, y, y’, y”, …, ).

If you’re new to numerical integration or even RK4 integration, please read my other post first. It’s easier to understand because it’s a less generalized function.

def rk4(t0, h, s0, f):
	"""RK4 implementation.
	t = current value of the independent variable
	h = amount to increase the independent variable (step size)
	s0 = initial state as a list. ex.: [initial_position, initial_velocity]
	f = function(state, t) to integrate"""
	r = range(len(s0))
	s1 = s0 + [f(t0, s0)]
	s2 = [s0[i] + 0.5*s1[i+1]*h for i in r]
	s2 += [f(t0+0.5*h, s2)]
	s3 = [s0[i] + 0.5*s2[i+1]*h for i in r]
	s3 += [f(t0+0.5*h, s3)]
	s4 = [s0[i] + s3[i+1]*h for i in r]
	s4 += [f(t0+h, s4)]
	return t+h, [s0[i] + (s1[i+1] + 2*(s2[i+1]+s3[i+1]) + s4[i+1])*h/6.0 for i in r]

An example usage of this function is:

def damped_spring_accel(t, state):
	x = state[0]
	v = state[1]
	stiffness = 1
	damping = 0.005
	return -stiffness*x - damping*v
 
t = 0
h = 1/40.0
s = [50, 5]
 
while t<100:
	t, s = rk4(t, h, s, damped_spring_accel)
print "Final state: t=%.2f x=%.2f v=%.2f"%(t,s[0],s[1])

On a side note, I recently found out about Sage (sagemath.org and sagenb.org). Its plotting capabilities and convenient mathematical notation are especially useful. Plus, it uses Python!