ax's blog

Arduino 0017 Makefile

ax — Wed, 14 Oct 2009 19:01:03 -0500

I'm helping Hans with shift brite based project for a musician. He gave me a ring of Shift Brite LEDs with an arduino attached. Normally I prefer to work in vim and using makefiles instead of using an IDE. The Arduino software 0017 shipped with a makefile that gives instructions about how to modify it to work for your project but that still doesn't work.

After a little hunting around and some work I got a working, though not ideal makefile. It currently doesn't rebuild your project after you've saved a new source file if you just do : make upload
You have to type make and then make upload.. OH WELL!

Below is my Makefile and also the .diff so you can see exactly what changed.

# Arduino 0015 Makefile # Arduino adaptation by mellis, eighthave, oli.keller, # alex norman [with help from http://code.google.com/p/arduino/issues/detail?id=65#c5] # # This makefile allows you to build sketches from the command line # without the Arduino environment (or Java). # # Detailed instructions for using the makefile: # # 1. Copy this file into the folder with your sketch. There should be a # file with the same name as the folder and with the extension .pde # (e.g. foo.pde in the foo/ folder). # # 2. Modify the line containg "INSTALL_DIR" to point to the directory that # contains the Arduino installation (for example, under Mac OS X, this # might be /Applications/arduino-0012). # # 3. Modify the line containing "PORT" to refer to the filename # representing the USB or serial connection to your Arduino board # (e.g. PORT = /dev/tty.USB0). If the exact name of this file # changes, you can use * as a wildcard (e.g. PORT = /dev/tty.usb*). # # 4. Set the line containing "MCU" to match your board's processor. # Older one's are atmega8 based, newer ones like Arduino Mini, Bluetooth # or Diecimila have the atmega168. If you're using a LilyPad Arduino, # change F_CPU to 8000000. # # 5. At the command line, change to the directory containing your # program's file and the makefile. # # 6. Type "make" and press enter to compile/verify your program. # # 7. Type "make upload", reset your Arduino board, and press enter to # upload your program to the Arduino board. # # $Id$


TARGET = $(notdir $(CURDIR))

INSTALL_DIR = /usr/local/src/arduino-0017/

PORT = /dev/ttyUSB*

UPLOAD_RATE = 19200

AVRDUDE_PROGRAMMER = stk500v1

MCU = atmega168

F_CPU = 16000000
############################################################################

# Below here nothing should be changed...
ARDUINO = $(INSTALL_DIR)/hardware/cores/arduino

#AVR_TOOLS_PATH = $(INSTALL_DIR)/hardware/tools/avr/bin

AVR_TOOLS_PATH = /usr/bin/

SRC =  $(ARDUINO)/pins_arduino.c $(ARDUINO)/wiring.c \

$(ARDUINO)/wiring_analog.c $(ARDUINO)/wiring_digital.c \

$(ARDUINO)/wiring_pulse.c \

$(ARDUINO)/wiring_shift.c $(ARDUINO)/WInterrupts.c

CXXSRC = $(ARDUINO)/HardwareSerial.cpp $(ARDUINO)/WMath.cpp \

$(ARDUINO)/Print.cpp

FORMAT = ihex
# Name of this Makefile (used for "make depend").

MAKEFILE = Makefile
# Debugging format.

# Native formats for AVR-GCC's -g are stabs [default], or dwarf-2.

# AVR (extended) COFF requires stabs, plus an avr-objcopy run.

DEBUG = stabs
OPT = s
# Place -D or -U options here

CDEFS = -DF_CPU=$(F_CPU)

CXXDEFS = -DF_CPU=$(F_CPU)
# Place -I options here

CINCS = -I$(ARDUINO)

CXXINCS = -I$(ARDUINO)
# Compiler flag to set the C Standard level.

# c89   - "ANSI" C

# gnu89 - c89 plus GCC extensions

# c99   - ISO C99 standard (not yet fully implemented)

# gnu99 - c99 plus GCC extensions

CSTANDARD = -std=gnu99

CDEBUG = -g$(DEBUG)

CWARN = -Wall -Wstrict-prototypes

CTUNING = -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums

#CEXTRA = -Wa,-adhlns=$(<:.c=.lst)
CFLAGS = $(CDEBUG) $(CDEFS) $(CINCS) -O$(OPT) $(CWARN) $(CSTANDARD) $(CEXTRA)

CXXFLAGS = $(CDEFS) $(CINCS) -O$(OPT)

#ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs

LDFLAGS = -lm
# Programming support using avrdude. Settings and variables.

AVRDUDE_PORT = $(PORT)

AVRDUDE_WRITE_FLASH = -U flash:w:applet/$(TARGET).hex

AVRDUDE_FLAGS = -V -F \

-p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER) \

-b $(UPLOAD_RATE)
# Program settings

CC = $(AVR_TOOLS_PATH)/avr-gcc

CXX = $(AVR_TOOLS_PATH)/avr-g++

OBJCOPY = $(AVR_TOOLS_PATH)/avr-objcopy

OBJDUMP = $(AVR_TOOLS_PATH)/avr-objdump

AR  = $(AVR_TOOLS_PATH)/avr-ar

SIZE = $(AVR_TOOLS_PATH)/avr-size

NM = $(AVR_TOOLS_PATH)/avr-nm

AVRDUDE = $(AVR_TOOLS_PATH)/avrdude

REMOVE = rm -f

MV = mv -f
# Define all object files.

OBJ = $(SRC:.c=.o) $(CXXSRC:.cpp=.o) $(ASRC:.S=.o) 
# Define all listing files.

LST = $(ASRC:.S=.lst) $(CXXSRC:.cpp=.lst) $(SRC:.c=.lst)
# Combine all necessary flags and optional flags.

# Add target processor to flags.

ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS)

ALL_CXXFLAGS = -mmcu=$(MCU) -I. $(CXXFLAGS)

ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
# Default target.

all: applet_files build sizeafter
build: elf hex 
applet_files: $(TARGET).pde

	# Here is the "preprocessing".

	# It creates a .cpp file based with the same name as the .pde file.

	# On top of the new .cpp file comes the WProgram.h header.

	# At the end there is a generic main() function attached.

	# Then the .cpp file will be compiled. Errors during compile will

	# refer to this new, automatically generated, file.

	# Not the original .pde file you actually edit...

	test -d applet || mkdir applet

	echo '#include "WProgram.h"' > applet/$(TARGET).cpp

	cat $(TARGET).pde >> applet/$(TARGET).cpp

	cat $(ARDUINO)/main.cxx >> applet/$(TARGET).cpp
elf: applet/$(TARGET).elf

hex: applet/$(TARGET).hex

eep: applet/$(TARGET).eep

lss: applet/$(TARGET).lss

sym: applet/$(TARGET).sym
# Program the device.

upload: applet/$(TARGET).hex

	$(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH)
	# Display size of file.

HEXSIZE = $(SIZE) --target=$(FORMAT) applet/$(TARGET).hex

ELFSIZE = $(SIZE)  applet/$(TARGET).elf

sizebefore:

	@if [ -f applet/$(TARGET).elf ]; then echo; echo $(MSG_SIZE_BEFORE); $(HEXSIZE); echo; fi
sizeafter:

	@if [ -f applet/$(TARGET).elf ]; then echo; echo $(MSG_SIZE_AFTER); $(HEXSIZE); echo; fi
# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.

COFFCONVERT=$(OBJCOPY) --debugging \

--change-section-address .data-0x800000 \

--change-section-address .bss-0x800000 \

--change-section-address .noinit-0x800000 \

--change-section-address .eeprom-0x810000 
coff: applet/$(TARGET).elf

	$(COFFCONVERT) -O coff-avr applet/$(TARGET).elf $(TARGET).cof
extcoff: $(TARGET).elf

	$(COFFCONVERT) -O coff-ext-avr applet/$(TARGET).elf $(TARGET).cof
.SUFFIXES: .elf .hex .eep .lss .sym
.elf.hex:

	$(OBJCOPY) -O $(FORMAT) -R .eeprom $< $@
.elf.eep:

	-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \

	--change-section-lma .eeprom=0 -O $(FORMAT) $< $@
# Create extended listing file from ELF output file.

.elf.lss:

	$(OBJDUMP) -h -S $< > $@
# Create a symbol table from ELF output file.

.elf.sym:

	$(NM) -n $< > $@
	# Link: create ELF output file from library.

applet/$(TARGET).elf: $(TARGET).pde applet/core.a

	$(CC) $(ALL_CFLAGS) -o $@ applet/$(TARGET).cpp -L. applet/core.a $(LDFLAGS)
applet/core.a: $(OBJ)

	@for i in $(OBJ); do echo $(AR) rcs applet/core.a $$i; $(AR) rcs applet/core.a $$i; done
# Compile: create object files from C++ source files.

.cpp.o:

	$(CXX) -c $(ALL_CXXFLAGS) $< -o $@ 
# Compile: create object files from C source files.

.c.o:

	$(CC) -c $(ALL_CFLAGS) $< -o $@ 
# Compile: create assembler files from C source files.

.c.s:

	$(CC) -S $(ALL_CFLAGS) $< -o $@
# Assemble: create object files from assembler source files.

.S.o:

	$(CC) -c $(ALL_ASFLAGS) $< -o $@
# Automatic dependencies

%.d: %.c

	$(CC) -M $(ALL_CFLAGS) $< | sed "s;$(notdir $*).o:;$*.o $*.d:;" > $@
%.d: %.cpp

	$(CXX) -M $(ALL_CXXFLAGS) $< | sed "s;$(notdir $*).o:;$*.o $*.d:;" > $@
# Target: clean project.

clean:

	$(REMOVE) applet/$(TARGET).hex applet/$(TARGET).eep applet/$(TARGET).cof applet/$(TARGET).elf \

	applet/$(TARGET).map applet/$(TARGET).sym applet/$(TARGET).lss applet/core.a \

	$(OBJ) $(LST) $(SRC:.c=.s) $(SRC:.c=.d) $(CXXSRC:.cpp=.s) $(CXXSRC:.cpp=.d)
.PHONY:	all build elf hex eep lss sym program coff extcoff clean applet_files sizebefore sizeafter

------------------------------------------------------------ Makefile.diff

--- Makefile-original 2009-10-14 16:21:02.000000000 -0700 +++ Makefile 2009-10-14 16:57:30.000000000 -0700 @@ -1,5 +1,6 @@ # Arduino 0015 Makefile -# Arduino adaptation by mellis, eighthave, oli.keller +# Arduino adaptation by mellis, eighthave, oli.keller, +# alex norman [with help from http://code.google.com/p/arduino/issues/detail?id=65#c5] # # This makefile allows you to build sketches from the command line # without the Arduino environment (or Java). @@ -35,8 +36,8 @@ # $Id$


 TARGET = $(notdir $(CURDIR))

-INSTALL_DIR = ../../..

-PORT = /dev/tty.usb*

+INSTALL_DIR = /usr/local/src/arduino-0017/

+PORT = /dev/ttyUSB*

 UPLOAD_RATE = 19200

 AVRDUDE_PROGRAMMER = stk500v1

 MCU = atmega168

@@ -46,10 +47,11 @@

 # Below here nothing should be changed...
 ARDUINO = $(INSTALL_DIR)/hardware/cores/arduino

-AVR_TOOLS_PATH = $(INSTALL_DIR)/hardware/tools/avr/bin

+#AVR_TOOLS_PATH = $(INSTALL_DIR)/hardware/tools/avr/bin

+AVR_TOOLS_PATH = /usr/bin/

 SRC =  $(ARDUINO)/pins_arduino.c $(ARDUINO)/wiring.c \

 $(ARDUINO)/wiring_analog.c $(ARDUINO)/wiring_digital.c \

-$(ARDUINO)/wiring_pulse.c $(ARDUINO)/wiring_serial.c \

+$(ARDUINO)/wiring_pulse.c \

 $(ARDUINO)/wiring_shift.c $(ARDUINO)/WInterrupts.c

 CXXSRC = $(ARDUINO)/HardwareSerial.cpp $(ARDUINO)/WMath.cpp \

 $(ARDUINO)/Print.cpp

@@ -94,7 +96,7 @@

 # Programming support using avrdude. Settings and variables.

 AVRDUDE_PORT = $(PORT)

 AVRDUDE_WRITE_FLASH = -U flash:w:applet/$(TARGET).hex

-AVRDUDE_FLAGS = -V -F -C $(INSTALL_DIR)/hardware/tools/avr/etc/avrdude.conf \

+AVRDUDE_FLAGS = -V -F \

 -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER) \

 -b $(UPLOAD_RATE)
@@ -239,5 +241,3 @@
 .PHONY:	all build elf hex eep lss sym program coff extcoff clean applet_files sizebefore sizeafter
-include $(SRC:.c=.d)

-include $(CXXSRC:.cpp=.d)

PCB Panellizing in the GIMP

ax — Fri, 03 Apr 2009 13:56:45 -0500

While I'm not happy using proprietary software for making PCBs, I have yet to find an adequate FLOSS solution for creating PCBs. But once I have created the PCB, I use The GIMP, which is free software, to layout my PCBs on a page to print, so I can actually transfer them to Copper and etch them.

I've broken this information into 3 sections:

Export from Eagle
The GIMP
Final Remarks

Export from Eagle

Export the Bottom

First you have to select what you want to print. Use the eagle "display" tool to select.

For the Bottom I select:

Bottom
Pads
Vias
Dimension

For the Top I simply swap "Bottom" with "Top".

The bottom display selection:

What you should see in the board view:

When you have selected what you want to print, go to File -> Print and then press the "Printer.." button. Select "print to file" and give it a location "/tmp/bottom.ps" in my case. You should see something simmilar to the image below:

Click "OK" and then you should return to the main print dialog (shown below). I select "Solid" and "Black" in the styles setting. Hit "OK" to actually print to the file.

Export the Top

Repeat for the top of the board.. Note the difference in the style selection.

The top display selection:

What you should see in the board view:

Print -> Printer... just as you did for the bottom. Print to file, give it a new file, "/tmp/top.ps" in my case, "OK".

For the top of the board you want to also select "Mirror" in the style selection before you print. Click "OK" to actually print to the file.

The GIMP

Import Images

Open the GIMP and open one of the post script or pdf files that you exported from Eagle.

You should see an import dialog like the one below, I use 300 dpi and strong anti aliasing.

Once you click "Import" you should see your image full sized, in my case I started with the top layer.

We want to get rid of the text at the bottom of the page. Select the text with the box select tool, hit delete (not backspace) to erase the text [if you don't have delete you can always just use the bucket fill tool and fill with white. The image below shows the selection you make.

Then Select the whole page [Select All]. In the main menu go to Image -> Autocrop Image. You should see something like the image below [just our PCB layout, nothing else around it].

The next steps are optional. I like to place text on my top layer. Make it white, make it big, and put it on the black part [ground plane].

As the top layer will actually be mirrored when you iron it onto your copper, you'll want to flip the text. Select the text layer in the Layer Window [Windows -> Layers], go to Layer -> Transform -> Flip Horizontally.

Repeat this import [without the text] for the bottom layer.

Layout On A Full Page

Create a New File [File -> New -> US-Letter (300ppi) [or use the advanced options for a different size/resolution.. but use the same resolution as you used to import your top and bottom layers].

Add guides so that you can line up your imported PCB images on this larger page. Place the mouse on the ruler, press the mouse button and drag a guide onto the image. Make both a vertical and horizontal guide:

Go to one of your import images [the bottom in this case], select all, and copy. Then go to the new image, paste.

Select the pasted layer in the Layer window, right click [on Linux at least], and make the pasted layer a 'new layer'. I usually rename the layer too ["bottom" in this case (not shown here)].

Line the layer up with the guides.

Create another guide under it, slightly offset. Then copy and paste your other PCB layer [top in this case] just as you did with the previous layer (select all, copy, paste, new layer, lineup).

When I have text on a PCB layer, I usually flatten the image before I copy it to the larger layout [Image -> flatten image]. This way there is only 1 new layer resulting from the copy/paste operation.

I usually like to rotate one of the layers 180 degrees so that when I fold the page I can get them to line up [I'll do the top here].

Select Layer in Layer window, then in the main window select Layer -> Transform -> Rotate 180 degrees.

If you want to add duplicate copies of your PCB, add another guide to the right, slightly offset from the edge of your images, Go to the Layer window, duplicate both your layers and move them to line up with the new guide.

I like to create a new layer under all of these layers [in Layer window right click -> New Layer.. then drag it below your top and bottom layers]. Then, with that new layer selected, use the box select tool to select an area around your pasted layers [but not too big so we don't waste a lot of ink when printing].

Finally use the bucket fill to fill that area with black [will just show black around your pasted layers].

Print!

Now we're ready to print. I usually print to PDF so that I can take the image and print it elsewhere. But if you want to print directly from the GIMP you can still follow the same directions, just select a printer instead of print to file.

Select File -> Print. Then I select "Print To File" and select the location to print (usually /tmp/output.pdf for me).

As we've created a full page sized image and sizing is important, we want to make sure that the GIMP doesn't mess with our dimensions (by default it actually does).

Go to the "Image Settings" tab, select the "Ignore Page Margins" box. Then increase the width/height so that it is the same as the sizing you originally selected for this full image [8.5 x 11 inches in my case].

Finally select "Print" to actually print the full page layout [to a file in my case]. Then, you're DONE!

Final Remarks

If you only want to do one copy of your PCB you could place the top and bottom PCB layers side by side instead of above and below each other as I've done here.

If you want to add cutting guides you can easily do that with the pen tool along the guides you've created. I didn't need them in my case because my PCB layers have a white section on the edge, so I just created the black background to guide my cutting.

After doing the editing of the top and bottom PCB layers, as well as the Full page, I save them as .xcf files [GIMP's image format], just in case I want to edit them again later.

Oberheim DX sound module

ax — Thu, 22 Jan 2009 18:35:47 -0600

A few months ago Emily, the woman I have been dating for a while, bought an Oberheim DX drum machine. She actually got it from another dork bot member here, Hans. Anyways, this drum machine stores its sounds on eeproms. It is made so that you can replace these eeproms to get different sounds, and some people have installed ZIF sockets to make them really easily replaceable. Emily talked about wanting to be able to put her own sounds into the drum machine.. and I thought that it wouldn't be so hard.

I imagined a few things: expanding the number of prerecorded sounds to choose from, playing a sequence of sounds in a loop, playing a random sound from a set of sounds [to add a 'humanness' to the machine], doing synthesis, gating an input sound, and finally, and more difficult with a little micro-controller, recording a sound live and playing it back, triggered by the drum machine.

She went away for a week+ during the holidays and I borrowed her drum machine, saying I wanted to work on some tracks with it. I had been scheming to make a module that would allow her to expand the number of sounds on it, as well as do some basic synthesis. The initial module was going to have a 1 megabyte i2c memory to store sounds, and an Atmega16 to simulate an eeprom... After doing some initial development I realized that the i2c memory wouldn't be fast enough as the drum machine wants samples at about 20K per second [the sampling rate is somewhat adjustable with a pot on the back of the drum machine]. So for the first module I ended up just doing some synthesis [right now I just have noise, a square wave, and a square wave which decays in frequency]. I also stored one pre-recorded sound in program memory, the tr-909 clap. It is displayed at the top of this page. The PCB, made with the help of feurig, is displayed here:

I still have to build a little interface for controlling the synthesis parameters, selecting which sound to play, but it is already quite nice.

I realized that my tr-707 drum machine must store sounds in a very similar way [after taking it apart], so I might end up including this sort of stuff in my own drum machine.

Soon I plan to experiment with some AVR chips which have expandable ram so I can have access to more sounds more quickly. I also got some SPI eeprom which should allow for quicker access than the i2c memory, so I could probably stream sounds directly from the eeprom.

In the mean time David Frech gave me a bunch of 256K byte flash memories. I made first solo PCB, shown below, which adapts the original eeprom pins to this larger memory, with some control to select the higher bits, which lets the hardware read from the eeprom and the user select which memory offset [sound] to use for the upper bits. These flash memories can store 32 sounds [the DX sounds are 8K, 8 bits (ulaw), at 20khz]. Images of the top and bottom of the PCB [2 of them actually], are below.

Benito with i2c and USB midi

ax — Fri, 17 Oct 2008 17:58:42 -0500

I grabbed two of those 36 key keypad boards from Paul at the last dork bot, he grabbed them out of those POS boxes [with the big LCDs that he has posted info about]. I wanted to get them working with the Benito and also wanted work with i2c a little [as I have a bunch of these 8bit i2c i/o expanders]. The keypad has 20 i/o pins so the Benito cannot use it directly anyways.. though 12 bits of shift registering would probably be better... but either way, I wanted to use what I had + i2c.

If you didn't know, the Bentio doesn't have hardware supported i2c, so I used Peter Fleury's i2cmaster code [slightly modified to have 100khz i2c with the bentio's 8Mhz clock] which does i2c in software [assembly]. My modified code is in the tar file below, all I had to do was modify a delay routine so that the timing would be correct with this clock and for 100khz i2c (if you're doing 400khz i2c on the benito there is no need to change this code).

Here is a photo of the setup:

http://dorkbotpdx.org/files/images/benito-i2c-midi-buttons.jpg

Here is a screen grab of #dorkbotpdx and amidi printing out info from this USB midi device (not ALL that exciting):

http://dorkbotpdx.org/files/images/benito-i2c-midi-buttons-screengrab.pn...

Here is a link to the code:

http://x37v.info/code/benito-i2c-midi-buttons.tar.gz

midi on the avr

ax — Mon, 09 Jun 2008 17:36:00 -0500

I've posted some of the code I've been using for midi on an avr chip [atmega16]. It should work on other avr chips with little or no modification. I'd love it if others would test it out and and contribute.

I've included a little bit of info and some example code here: http://x37v.info/projects/microcontroller/avr-midi/

"It provides convenient functions for both sending and receiving most (if not all) of the message types specified by the midi spec. It also provides a function for making sure that one can safely send midi data during a midi merge. Finally it provides functions to pack and unpack 8 bit bytes into/out of 7 bit midi bytes, allowing for users to send and receive large chunks of data in system exclusive (SYSEX) messages. "

Soon I'll be posting a sysex based boot-loader I've written using this code.

Hopefully this code is useful to some of the nerds around here :)

-Alex