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:

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.

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: