www.youtube.com/watch?v=kVAlNAf-2P8

Downloads:

• gametable.tar.gz

www.youtube.com/watch?v=yv6CJdWgSJo

The bluetooth module can be used to bootload the AVR and to transfer images. Now I’m thinking of writing a VLC extension to stream video data to the table

And here the gif animation:

• surematrix_animation.tar.gz (the Arduino PDE)
• pyconvert.tar.gz (the python script for converting images)

www.youtube.com/watch?v=x7-wtJGhpzE

www.youtube.com/watch?v=0Bu621bRCZ8

www.youtube.com/watch?v=gubQbWLMAnI

Displaying a 64x64 pixel animation exported from a GIF Animation with a custom python script.

UPDATE: After some optimization in the animation loading, the set pixel functions and the display refresh function the Arduino is able to display about 50 frames per second when displaying a 96x64 monocolor animation from flash memory.

www.youtube.com/watch?v=kXHrMa2NvqM

The displays are connected to the Arduino to share the row select pins (A,B,C and D) and the control lines EN, CLK & LATCH. The serial lines R1,R2,G1,G2 have their dedicated pins. So there are 19 pins needed out of possible 20 (not counting the reset pins as I/O). As the displays are loaded in 16 rows a 64bit some transformation has to be done while loading the display. This limits the update rate hard. A possible way to improve the frame rate is moving the transformation to the function setting the pixels. Or maybe changing the connection scheme to common R1,R2,G1,G2 with separate EN & LATCH for each display which would result in 15 I/O pins needed but maybe suffer from slower update rate. As the display modules are chainable it is possible to connect them in series and load the 16 rows with 192bits each and using only 11  pins, but reducing the frame rate again. Since the ATMega328 cannot achieve high enough frame rates at any connection scheme I would suggest using the chained way.

www.youtube.com/watch?v=twW3xie_QBo

Download PDE:

• surematrix.pde

• foam rubber as carrier for the LED’s
• 10mm diffuse RGB LED’s (I used those sold here: http://evilmadscience.com/partsmenu/89-led )
• silver wire
• insulating tape
• solder iron

First mark the spot where you want to add the LED’s on the foam rubber using some pen. I spaced them 20mm apart and printed some guides on a sheet of paper that i fixed on the rubber and pushed the LED’s through. After that I assembled one column and bended the R,G and B cathodes by 90 degree, shorted them at the next LED (using this one can only space the LED’s by the max. pin length) and solder the pins to next LED. So I proceeded all the way down. I did not cut the wires of the last LED, those I used to connect to the circuit board. After that I but some insulating tape on the connection to ovoid short circuits. After that I used the silver wire to connect the common anodes in a row. DONE !

What you get when combining those is a via USB controllable dotmatrix display. The PC related programming I did in Python using libusb and the python binding called pyusb. So the program should be cross platform compatible! Also python allows one to extend the functionality(e.g. checking for new mail, usb notifications of any type…) very easy.

Video after the break.

www.youtube.com/watch?v=6VcidXvYe6A

Download:

• usbmatrix

The circuit uses 74HC595 shift registers with output latch. Each shiftregister interfaces one color + one shiftreg for the matrix rows. The interfaces uses 6 I/O lines for faster speed and easier interfacing. An AVR running at 8MHz can update the matrix with 8 brightness levels displaying nice fading colors patterns or colored text (or both). The sample program creates fading color patterns using a sine table. For smoother display a double buffer was implemented.

Download: rgbmatrix.c

The Network Time Protocol (NTP) is described in RFC958.

The protocol defines 48 Bytes of data and splits up into some control bytes and four 64bit timestamp. Each timestamp is the number of seconds to UTC since Jan. 1st 1900. Basically the NTP server receives the timestamp of the local requester, exchanges the adress fields, fills in it’s timestamp and sends the packet back. With the 4 timestamp fields routing delay and therefor absolute time errors can be reduced to a minima.

Simon also provides a port of the UIP TCP/IP Stack from Adam Dunkes including a sample web-server application. Also a simple framework for implementing additional applications was added by Simon. This NTP Clock implementation uses that framework. To get this port running correct for UDP applications some changes have to be made to the original code.

Find the following in file main.c and add the below:
[source:c]
int i= UIP_CONNS;
while (i)
{
i–;
uip_periodic(i);
if (uip_len > 0)
{
uip_arp_out();
Enc28j60Transmit(uip_buf, uip_len);
}
}

/* ++ begin added by Tobias Floery */
i = UIP_UDP_CONNS;
while (i)
{
i–;
uip_udp_periodic(i);
if (uip_len > 0)
{
uip_arp_out();
Enc28j60Transmit(uip_buf, uip_len);
}
}
/* ++ end */
[/source]

Navigate to folder Net -> uip and add the following line to uip_UdpAppHub.h:
[source:c]
#include “../UdpApps/ntpD.h”
[/source]
and then change uip_UdpAppHub.c to:
[source:c]
void uip_UdpAppHubCall(void)
{
switch (uip_udp_conn->lport)
{
case (HTONS(PORT_NTPD)):
NtpDCall((ntpMsg *)uip_appdata, uip_datalen());
break;
}

}

void uip_UdpAppHubInit(void)
{
NtpDInit();
}
[/source]

With this the TCP/IP Stack and the framework now knows how to pass and handle our data.
Under the direcory net create a new one called UdpApps (like the TcpApps folder).
Add the following two files to this directory:
ntpD.h:
[source:c]
/*
* Implements RFC958 – Network Time Protocol (NTP)
*
* Author: Tobias Floery
* Email: tobias.floery@cable.vol.at
* Homepage: http://tobiscorner.floery.net
*
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see .

Copyright 2008 Tobias Floery
* */

#ifndef NTPD_H_
#define NTPD_H_

#include
#include

#define PORT_NTPD 123
// hour offset from utc
#define UTC_OFFSET +1
// update interval in seconds
#define NTP_UPDATE 3600

typedef struct t_ntpMsg {
uint8_t status;
uint8_t type;
uint16_t precision;

uint32_t est_error;
uint32_t est_driftrate;
uint32_t ref_clk_ident;

uint32_t ref_timestamp_i;
uint32_t ref_timestamp_f;
uint32_t orig_timestamp_i;
uint32_t orig_timestamp_f;
uint32_t rx_timestamp_i;
uint32_t rx_timestamp_f;
uint8_t tx_timestamp_i[4];
uint32_t tx_timestamp_f;

} ntpMsg;

void incTime();
void NtpDInit();
void NtpDCall(ntpMsg *msg, uint16_t len);
unsigned char *getTime();
void sendNTPRequest();

#endif /*NTP_H_*/
[/source]

ntpD.c
[source:c]
/*
* Implements RFC958 – Network Time Protocol (NTP)
*
* Author: Tobias Floery
* Email: tobias.floery@cable.vol.at
* Homepage: http://tobiscorner.floery.net
*
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see .

Copyright 2008 Tobias Floery
* */

#include “ntpD.h”
#include “../uip/uip.h”

static struct uip_udp_conn *ntp_conn = NULL;
static unsigned char time_req = 0;

volatile uint32_t time = 0;
uint8_t timeStr[10]={0};

void sendNTPRequest() {
ntpMsg *m = (ntpMsg *)uip_appdata;

m->status=0xE3;
m->type = 0×00;
m->precision = 0xFA04;
m->est_error = 0×00000100;
m->est_driftrate = 0;
m->ref_clk_ident = 0;

m->ref_timestamp_i = 0;
m->ref_timestamp_f = 0;
m->orig_timestamp_i = 0;
m->orig_timestamp_f = 0;
m->rx_timestamp_i = 0;
m->rx_timestamp_f = 0;
//m->tx_timestamp_i = 0;
m->tx_timestamp_i[0]=0;
m->tx_timestamp_i[1]=0;
m->tx_timestamp_i[2]=0;
m->tx_timestamp_i[3]=0;
m->tx_timestamp_f = 0;
uip_udp_send(48);
}

void NtpDInit()
{
uip_ipaddr_t ntp_server;
uip_ipaddr(ntp_server, 192, 168, 1, 2);

if(ntp_conn != NULL) {
uip_udp_remove(ntp_conn);
}

ntp_conn = uip_udp_new(&ntp_server, HTONS(PORT_NTPD));

if (ntp_conn == NULL) {
time = 0xAA;
return;
} else {
uip_udp_bind(ntp_conn, HTONS(PORT_NTPD));
}
time_req = 0;
time = 0;
}

void NtpDCall(ntpMsg *msg, uint16_t len)
{
if (uip_poll()) {
if (time_req == 0 || time < = 100) {
sendNTPRequest();
time_req++;
}
}

if(uip_newdata()) {
time = msg->tx_timestamp_i[0];
time = time < < 8;
time += msg->tx_timestamp_i[1];
time = time < < 8;
time += msg->tx_timestamp_i[2];
time = time < < 8;
time += msg->tx_timestamp_i[3];
}
}

void incTime() {
if (time%NTP_UPDATE==0) time_req = 0;
time++;
}

unsigned char *getTime() {
uint32_t tmp;
unsigned char hour, min, sec;

tmp = time;

sec = tmp%60;
tmp = tmp/60;
min = tmp%60;
tmp = tmp/60;
hour = tmp%24 + (UTC_OFFSET);

timeStr[0] = ’0′+hour/10;
timeStr[1] = ’0′+hour%10;
timeStr[2] = ‘:’;
timeStr[3] = ’0′+min/10;
timeStr[4] = ’0′+min%10;
timeStr[5] = ‘:’;
timeStr[6] = ’0′+sec/10;
timeStr[7] = ’0′+sec%10;
timeStr[8] = 0;

return timeStr;
}

[/source]
Find the changed files and the NTP code in the ZIP archive below.

Download here: uwebsrv-changed

The circuit is build with an AVR ATTiny2313 a UDN2982 high side and a ULN2803 low side driver/switch

The LED Module is powered with 18-20V to give a brighter display. The forward volatge of a single segment is about 13V. 13V + voltage loss at the switches (worst case 2V + 1.6V) is about 16.6V. I used 39Ohm resistors for the segments and so 16.6V + 39Ohm x 0.08A = 19.72V. Because of multiplexing 4 modules to get an avarage current of 20mA per segment the current has to be four times higher ( 20mA x 4 = 80mA ). The dots on the modules have a lower forward voltage resulting in a higher limiting resistor: (16.6V – 3.6V – 3.6V) / 80mA = 120Ohms.

Part List:

• some High Power LED’s
• thermal pads (thermally conductive, electrically insulating, double coated tape)
• alu L profile
• wires
• costant current driver matching your LED’s

Step1: align the number of LED’s your LED driver can handle equaly spaced on the profile. drill a hole at each end of the profile, so you can put the wires through.

Step2: cut the thermal pads to the size of the leds and tape them onto the leds. after that tape the leds onto the profile.

Step3: connect the LED’s in series

Step4: I used double coated tape to mount the driver on the LED’s side. make a knot in each wire before putting them though the holes, so you can use the wires to mount the lamp to the ceiling.

I’m now trying to connect a T6963 based LCD. This failed because of the speed of the external bus. So I searched the linux code and found the initialization in sbmips.c under linux/arch/mips32/bcm47xxx/sbmips.c.

I copied the code to my module and build a function to slow down the speed:

static void extif_slowDown()  {
ulong hz,ns,tmp;
extifregs_t *eir;

if ((hz = sb_clock(sbh)) == 0)
hz = 100000000;
ns = 1000000000 / hz;

if ((eir = sb_setcore(sbh, SB_EXTIF, 0))) {
tmp = CEIL(1, ns) < < FW_W3_SHIFT;
tmp = tmp | (CEIL(1,ns) << FW_W2_SHIFT);
tmp = tmp | (CEIL(200, ns) << FW_W1_SHIFT);
tmp = tmp | CEIL(240, ns);
W_REG(&eir->prog_waitcount, tmp);
}
}

I had no clue what those parameters are for. For a first test the old values where doubled. Using a oscilloscope I could figure out 2 values:

W3 = 40ns W2 = 40ns W1 = 100ns W0 = 200ns	W3 = 100ns W2 = 40ns W1 = 100ns W0 = 200ns	W3 = 40ns W2 = 100ns W1 = 100ns W0 = 200ns

The upper signal is the /CS line and the lower the /WR line. As you can see W3 defines the time from /WR high to /CS high, while W2 defines the time from /CS low to /RD low. What W1 and W0 are for I can only guess. The total low time of /CS increases with W0 but for W1 I coudn’t find a change (maybe it’s a timing value for reading from the interface).

I’m now playing with the timing parameters and looking what the LCD will display. Sometimes I can ge something on it and sometimes not. I think I got the writing timing correct but reading to check the status bits is not in time…

First . Here are the steps:

1. Assemble the lamp but leave the paper shield down
2. Remove the contacts from the bulb’s holder:
   
3. Now open the holder
   
4. Build the powerRGB circuit on a PCB that fits the inner of th mounting:
   
5. Solder some power supply cables to the PCB and pull them though the mounting down to the lamps base and put the PCB into the holder:
   
6. So thats it. Now reassemble the lamp with shield and connect a propper power supply to the board.
7. The most important step: Re-Design the Box:
   
8. Here some Images under Day-Light conditions:
   
9. And when darkening the room:
   
10. Enjoy your FÄRGRANN

The heart of this small FM Modulator is a tuneable voltage controlled oscillator (VCO) from Maxim-IC called MAX2606. This VCO operates from 70MHz to 150MHz and has a up to -8dBm differential output amplifier.

Note: in many countries it’s not allowed to broadcast in the UKW (normal Radio) frequency bands!! So use this at your own risk!

The schematic:

The audioFM project is based on schematics found in the Internet and from Elektor Magazine!

Q1 to Q3 are N-Channel HEXFet Mosfet’s with logic level drive and a RDSon at about 50mOhms. R1 to R3 are at about 2k2, R4 to R6 at about 15k and R7 to R9 depend on the LED used and VCC. If you use FET’s with higher RDSon you have to consider RDS in your calculation!

Rx = (Vcc-Vf)/Im – RDSon

[Vcc: Volatge of power supply, Vf: Vorward Voltage of the Diode, Im: Max current of LED]

The software for the AVR is the same as for tinyRGB.

• lcd4wl Sourcecode
• kmod-lcd4wl_2430-brcm-1_mipsel.ipk

Usage:

To install the precompiled module download the ipk above and install it:

ipkg install kmod-lcd4wl_2430-brcm-1_mipsel.ipk

Then insert the module:

insmod lcd4wl

Using dmesg should show you what to do next.

mknod /dev/lcd c xxx 0
… where xxx is the major number of your device

After creating the device entry you can access your LCD with:

echo “Hello OpenWRT\n\rShow me if it’s working” > /dev/lcd

for writing to the LCD or

cat /dev/lcd

to read from the LCD.

Here the supported command:

• \n: Puts the cursor to the next line, on the same position
• \r: Sets Cursor to the start of the current line
• \i: Clear Display
• \h: Move Cursor home
• \dx: Set Display Status (x=0: off, x=1 on)
• \cx: set Cursor (x=0 off, x=1 on)
• \bx: set Blink (x=0 off, x=1 on)
• \xx: Display shift (x=0 off, x=1 on)
• \yx: Shift Direction (x=0 right, x=1 left)
• \ax: Cursor increment (x=0 off, x=1 on)
• \sx: Cursor shift (x=0 off, x=1 on)

So I conected the /CS line to the display’s Enable Pin. Moved R/W from A2 to A1 and adjusted my driver. I connected the display, loaded the module and …. nothing!

So I started my PC Scope Software, connected CH1 to /CS line and GND and … HARDWARE NOT FOUND. So I realized the fancy red led was dark and I checked the LPT-cable and the power connection. Hmm shouldn’t the red led on the power plug be on? Wow the transformer of the power plug din’t survive the night (btw. it was me going out not the power plug …). So I opened up a box and searched for a replacement power supply. Found an adjustable switching regulator and connected. The Software begann calibrating and reported: Calibration failed!

O.k. maybe the oscilloscope doesn’t like the switching power supply because of all this spikes and so…

But now back to topic: Why did the LCD stay blank… Maybe the bus interface is somehow to fast for that little display (but it worked with using 3 address lines). Is the Enable signaling correct? I will try using an inverter…

So I soldered a standard NPN inverted using a 2n3904 and 2 resistors connected everything, reloaded the kernel module and … nothing! Hmm it would be good having a working oscilloscope…

After that I think I’m gonna use the other solution…

Ext IF	#	LCD	#
D0	1	D0	7
D1	2	D1	8
D2	3	D2	9
D3	4	D3	10
D4	5	D4	11
D5	6	D5	12
D6	7	D6	13
D7	8	D7	14
A0	9	RS	4
A1	10	E	6
A2	11	RW	5
A3	12	–
+5V	13	VDD	2
/CS	14	–
/RD	15	–
/WR	16	–
/INT	17	–
GND	18	VSS	1
		Vo (contrast)	3

Vo … connect a 10k poti between VDD and GND and the wiper to Vo.

For a better bus interface I have to look on the function of the /CS line in more detail so that the LCD doesn’t get disturbed by misc. data.
To get some data onto the display I modified diag.c the kernel module that is used by OpenWRT to set the Router’s LEDs and to fetch some keys. diag.c can be found in: /location_where_you_unziped_openwrt/target/linux/packages/diag/src/. I added a own /proc entry called extif. And so I was able to display data that way:

echo “iHello OpenWRT ” > /proc/diag/extif

The “i” is only there to tell the module to initialize the display first.

My Module

Next step will be that i write a module on my own that handels everything –> Read here more about the module…

The pinout:

----------
> D0  D1 |
| D2  D3 |
| D4  D5 |
| D6  D7 |
| A0  A1 |
| A2  A3 |
|+5V /CS |
|/RD /WR |
|INT GND |
| NC  NC |
----------

where:
D0 - D7: are the data lines
A0 - A3: are the address lines
+5V: +5V Supply Voltage
/CS: chip select (active low)
/RD: read strobe (avtice low)
/WR: write strobe (active low)
INT: Interrupt input
GND: Signal Ground
NC: Not connected

Note: all signals are 3.3V signals!

But adding a UART

EXT_IF -> UART -> uC -> Display & Keys

is somehow stupid. Because it could look like that:

EXT_IF -> Display & Keys

So I started reading though the kernel sources and found the UART initialisation process in sbmips.c somewhere in the arch/mips/bcm9….. directory. But the function that where used like sb_gpioin didn’t leed me to success.

So i had a look at gpio.c (same directory as above). This is a kernel module for accessing GPIO (general purpose input output). Here the sb_gpioin and so functions were used again. I tried to hack some new lines there but, let us go to the next try:

kmod-diag: OpenWRT comes with a small module that is used to turn on/off the LED’s and to fetch some keypresses. While reading the source (diag.c) I realized the function: set_led_extif.

volatile u8 *addr = (volatile u8 *) KSEG1ADDR(EXTIF_UART) + (led->gpio & ~GPIO_TYPE_MASK);

The adress of the external interface is between 0xBF800000 and 0xBF80000F. Only the low nibble (the 0×0-0xF) will be seen at the external interface on address lines A0-A3.

volatile u8 *addr = (volatile u8 *) KSEG1ADDR(EXTIF_UART) + (address & 0x0F);

Where address is the low nibble. Using the pointer *addr data can be read and written.

*addr = 0xFF; // write 0xFF
data = *addr; // read data

So that’s the trick.

But what do /WR, /RD and /CS do?

/WR: The slash (“/”) before the signals name tells you that the signal is active low. This means if a write transfer is handled by the bus this signals changes from HIGH to LOW before the transmission and changes back to HIGH after the transmission.

/RD: Same as above but signals that it’s a read instead of a write operation.

/CS: This signal goes low whenever an address between 0xBF800000 and 0xBF80000F is read or written. This additional signal is necassary do differ between for example 0xBF80000A and 0x2AD3456A (because only the last nibble the “A” would be seen on the address lines A0-A3).

After you flashed the new firmware and successfully managed to establish a secure connection to your router you can beginn with installing some extra stuff. But before installing it’s a good advise to enable the HDD first so you can install some packages there (Internal Flash in only 4MB). Good Documents about that step are availabe here.
Now install some extra packages:

• samba – for filesharing with windows
• mpd – the music player daemon
• kmod-soundcore_2.4.30-brcm-2_mipsel.ipk (download here)
• kmod-usb-audio_2.4.30-brcm-2_mipsel.ipk (download here)
• what else do you need?

So now get yourself a cheap usb soundstick. I bought mine for about 12$ in a local electronic store. The stick uses the C-Media chipset (CM108) which is fully supported and working

For mpd setup have a look at /etc/mpd.conf (self-explaining config file). To get a Client for your host system naviagte to MPD Clients.

I have modified the NAS-Device to have a small but powerfull mp3 player. One thing that I could improve is: To start/stop playing a host-platform must be up and running to control mpd. That must change! So I started thinking of attaching a LCD-Display and some keys….

Connector Pin out:

V_ADP V_ADP V_ADP V_ADP Reserved RS232 DCD RS232 RxD RS232 TxD RS232 DTR GND RS232 DSR RS232 RTS RS232 CTS RS232 RING GND (NC) No Connect USB Detect NC USB – UDC + NC USB – UDC - GND

How to find the pin-numbers?

All you need is a DVM with Resistance Measurement and a small copper wire (with un isolated ends). The rest is precise work. To get the correct pin i used my digicam to photograph the wire, zoomed into the picture on my display and counted if the wire is placed correct. Then with the DVM you can find the corresponding pin on the other side.

The Protocol definition can be found here: http://iserverd.khstu.ru/oscar/

At the moment myJCQ supports only plain messages and a simple contactlist. For more information about the Releases see the Downloads section.

Version 0.6alpha:

+ improvements for the network communication
+ Contactlist changed it’s tree view
+ Username update from Database (when name equals uin)
+ changed message passing between some components

Version 0.5:

NEW: Documentation for Communicator added

NEW: The GUI has completly changed to a nice Swing GUI.

Screenshots:

Downloads:

• myJCQ 0.6

The Terminal is build with an ATMega8 and a 640x240px GLCD. The Terminal can be used as a RS232 debugger.The Display Routines are from Holger Klabunde. Have a look at his Webpage: http://www.holger-klabunde.de/

The Keyboard routines are based on the ATMEL Application Note AVR313 and written by V. Brajer.

The ascii logo has been generated using this online ascii-generator.

Downloads:

• avrTer Sourcecode

avrDotmatrix – Is a 5×7 LED Matrix Display controlled by a ATMega8 to display scrolling text, time or temperatures. The pattern is generated with multiplexing the 5 matrix columns and setting the correct row bits.

This projects is still in development and i’m gonna add a temperature sensor (LM75), a I2C EEProm and maybe a IR receiver for transmitting texts to the display wireless.

Downloads:

• Sample Video
• avrDotmatrix Sourcecode

The TSL 1401 linear sensor array consists of a 128×1 array of photodiodes. The pixel measures 63.5um (H) by 55.5 um (W) with 63.5 um center to center spacing.

The Interface:
The interface is very simple, not as complicated as interfacing “bigger” CCD Linear Sensors.

All you need is to generate two Signals (Clk & Si):

The Source Code:

The CLK signal is generated within a loop that counts for every pixel. The ADC then samples each output before the next clock edge is generated. The data are then transmitted to the PC via the AVR’s UART.

The analog output signal A0 is amplified to near the ADC’s reference voltage to use the complete conversation range. I’ve used a rail-to-rail amplifier (CA3130) for this.

The PC Interface – Viewing the data with VB.NET:

To dispaly the data I’ve written a small VB.net application that allows you to modify the integration time, measure distances in mm or mil. The red line is the mean value. The 50 next to the OFF-Buton means that the data are updated every 50ms.

Downloads:

• avrCCD AVR SourceCode
• avrCCD VB.NET SourceCode

The Author:

• Ing. Igor Cesko
• E-Mail: cesko@internet.sk
• WWW: http://www.cesko.host.sk

About IgorPlug:

I’ve tried the IgorPlug USB-RS232 Converter on an ATMega8 running with 12MHz for better USB Timing. As reference I used the information on Igor’s Homepage and the Application Note from ATMEL.

Features:

• 800 Byte FIFO Buffer
• Baudrates from 300 to 115200
• Databits: 5,6,7,8; Stopbits: 1,2; Parity: none, even, odd, mark, space
• Three 8-bit I/O Ports
• Direct Interface to internal EEProm
• eventually possibility to use ATmega8 peripherals (not yet implemented)
• Possibility to add own function

See my IgorPlug:

Just connected everything on the fly and IT WAS WORKING! I plugged in the USB Cable to my WinXP Computer and it detected the IgorPlug Device. Next i started to write my own userfunction.

Step1:

I wrote a function that should be able to switch on and off the red LED you can see on the pictures.

DoUserFunction3:
lds temp0,InputBufferBegin+4 ;first parameter Lo into temp0
;lds temp1,InputBufferBegin+5 ;first parameter Hi into temp1
;lds temp2,InputBufferBegin+6 ;second parameter Lo into temp2
;lds temp3,InputBufferBegin+7 ;second parameter Hi into temp3
;lds ACC,InputBufferBegin+8 ;number of requested bytes from USB host (computer) into ACC

;Here add your own code:

out PORTC,temp0

mov ZL,temp0 ;will be sending value of RAM – from address stored in temp0 (first parameter Lo of function)
mov ZH,temp1 ;will be sending value of RAM – from address stored in temp1 (first parameter Hi of function)
inc RAMread ;RAMread=1 – reading from RAM
ldi temp0,255 ;send max number of bytes – 255 bytes are maximum
rjmp ComposeEndXXXDescriptor ;a prepare data

Add the Userfunction above line 1218:

;—————— END: This is template how to write own function —————-

To tell IgorPlug to call the function go to line: 1159 where it looks like:

NoDoUserFunction0:
cpi temp1,USER_FNC_NUMBER+1 ;
brne NoDoUserFunction1
rjmp DoUserFunction1 ;execute of user function1
NoDoUserFunction1:
cpi temp1,USER_FNC_NUMBER+2 ;
brne NoDoUserFunction2
rjmp DoUserFunction2 ;execute of user function1
NoDoUserFunction2:

rjmp ZeroDATA1Answer ;if that it was something unknown, then prepare zero answer

And change it to:

NoDoUserFunction0:
cpi temp1,USER_FNC_NUMBER+1 ;
brne NoDoUserFunction1
rjmp DoUserFunction1 ;execute of user function1
NoDoUserFunction1:
cpi temp1,USER_FNC_NUMBER+2 ;
brne NoDoUserFunction2
rjmp DoUserFunction2 ;execute of user function1
NoDoUserFunction2:
cpi temp1,USER_FNC_NUMBER+3 ;
brne NoDoUserFunction3
rjmp DoUserFunction3 ;execute of user function1
NoDoUserFunction3:

rjmp ZeroDATA1Answer ;if that it was something unknown, then prepare zero answer

Step2:

To get access to the Userfunction i had to manipulate the IgorPlug DLL. Because of my poor Delphi knowledge i “copy and paste” an other function and changed the function adress.

Step3:

Igor provides the declaration of his DLL for VB. To get them working with VB.NET i had to modify them and to add my UserFunction.

Step4:

Now i was able to use IgorPlug + my own Function from VB.NET! GREAT

The AD9833 is a programmable waveform generator capable of producing sine, triangular and square wave output signals up to 12.5 MHz (clocked with 25MHz).

The Interface Boards contains all basic components the DDS Chips needs to run. If you compare the component count with that of a MAX038 circuit you will see, that there are less here.

In the top-corner of the board you find the power connector (“Key Lock”). Next to it the BNC Connector for the Output signal. The 3-pin connector for the serial interface is located at the bottom of the Board. For a first basic test of operation connect the serial interface to your computers parallel port and use the software provided by Analog Devices (the schematic for the parallel port connection can be found in the AD9833 Datasheet. You can connect the pins directly without the use of the 74HC744 8bit Latch).

Connecting the AD9833/AD5932 to a ATMEL AVR:

comming soon, work in progress.

The AD5932:

The AD5932 can be seen as the next generation of the AD9833. The max. Outputfrequency has been doubled and additional Pins have been added. The AD5932 can produce sine, triangular and square waves from 0 to 25MHz with 28bit resolution.

Creating a programmable Gain Amplifier (PGA):

The get a full functional waveform generator some analog parts to adjust Amplitude and Offset are required. This is the really tricky part of the project. If’ve started with two OPAMPS and a Digipoti to get a PGA (I haven’t tested my circuit by now). At the moment i’m thinking of using the VCA810 from TI, some OPAMPS and maybe a Digipoti or an voltage output DAC.

Downloads / Schematics:

AD9833 Interface Board:

AD5932 Board with PGA:

SPI -> PGA Interface:

tinyRGB uses an ATMEL Attiny15L (8pin uC) to control a standard RGB Led.

R1 is a pullup Resistor for Reset generation (should be about 10k).
R3 to R5 depend on the LED you are using. You can calculate the resistor as followed:

Rx = (Vcc-Vf)/Im

[Vcc: Volatge of power supply, Vf: Vorward Voltage of the Diode, Im: Max current of LED or AVR pin (20mA)]

If you want to control power LED’s read here: powerRGB.

The software is written in Assembler (avra under Linux, should be compatible to AVR Studio). Timer0 is used to generate interrupts at about 30kHz. This interrupts are used to build a 8bit PWM. Timer1 is used to change the color pattern.

Downloads:

• tinyRGB Sourcecode and HEX File
• NEW RGB LED – Sourcecode for ATTiny45 from Robert Ibener