I have got a couple of questions (in fact not a first ones) for AVR DDS generator I have built:

“that’s all the asm code that I don’t understand.

Could you explain it? Is it possible to do it without inline asm (only in C)?”

I decided to explain this part more deeply. Because it took some time for myself to figure this all out.

First of all what wee have to do… it is to implement simple DDS algorithm. Read about it for example here: http://www.hit.bme.hu/~papay/sci/DDS/start.htm

In few words Direct Digital Synthesis(DDS) is known as Numerically Controlled Oscillator. Simple rule: NCO-based DDS is a point(memory location)-skipping technique (and a constant interpolation of the stored signal) and runs at constant update(clock)-rate. As the DDS output frequency is increased, the number of samples per waveform cycles decreases.

Practically speaking lets have some math. We have clock generator connected to MCU. In my case F_CPU=16000000Hz. This is our Clock In.

Then we have sinewave map stored in rom:

const uint8_t sinewave[] __attribute__ ((section (“.MySection1″)))= //256 values

{0×80,0×83,0×86,0×89,0x8c,0x8f,0×92,…

If we have 256 values of sine wave for single period, then at clock rate 16MHz picking each value from table we would have max sine wave frequency Fsine=16000000/256=64kHz; This would be ok. But what if wee need to have sinewave frequency 1kHz or 1MHz. Then wee need to implement some memory location skipping technique – this is what DDS does.

If we would like to have 128kHz instead of 64kKz we would pick every second sample from sinewave rom map (128 samples). And if we would like to have 32kHz we would have to make a delay after each sample and so on. DDS makes this much easier by having Phase accumulator.

ldi    r31,hi8(sinewave)   ; setup Z pointer hi
ldi    r30,lo8(sinewave)   ; setup Z pointer lo

; clear accumulator

ldi     r29,0x00        ; clear accumulator
ldi     r28,0x00        ; clear accumulator

; setup adder value  to 1 kHz
ldi     r24,tfreq1      ; tfreq1->r24
ldi     r25,tfreq2      ; tfreq2->r25
ldi     r26,tfreq2      ; tfreq2->r26
LOOP1:
add     r28,r24         ; 1
adc     r29,r25         ; 1
adc     r30,r26         ; 1 (Z pointer updated)
lpm                     ; 3 (load for sinewave table)
out     PORTD,r0        ; 1 (out to D port)
rjmp    LOOP1           ; 2 => 9 cycles

During my spare time I am developing the program for AVR controlled DDS generator. I decided to write software using WinAVR tool-set. How far ahead I have moved with this?

I have implemented:

• Menu system;
• Reading previous generator configuration from EEPROM;
• Setting signal mode;
• Storing last generator configuration to EEPROM to be loaded after reset;
• Four types of signal output (square, sawtooth, triangle and sine wave);

Still need to do:

• Ability to change signal frequency;
• Implement other signals (listed bellow);
• Make program clean-up;

Signals in AVR controlled generator:

• 0 – OUT_|¯|_ – square wave(done);
• 1 – OUT|/|/| – sawtooth(done);
• 2 – OUT|\|\| – reverse sawtooth(awaiting);
• 3 – OUT/\/\/\ – triangle(done);
• 4 – OUT~~~~ – sine wave(done);
• 5 – OUT-NOISE – noise signal(awaiting);
• 20 – PWM-OCC – timer output compare mode(awaiting);
• 21 – PWM-SINMDS – sine wave modulated PWM(awaiting);
• 22 – PWMSQSMDS – sine wave modulated PWM. PWM positive, SQ – negative polarity(awaiting);
• 23 – PWM-CMDS – custom PWM. Will be possible to set custom duty cycle(awaiting);

Signal generation

Square, sawtooth, triangle and sine waves are generated by reading values from flash memory. Fragment of sine wave is as follows:

//———————————————–

//signals saved in flash memory

const uint8_t sinewave[] PROGMEM= //256 values

{

0×80,0×83,0×86,0×89,0x8c,0x8f,0×92,0×95,0×98,0x9c,0x9f,0xa2,0xa5,0xa8,0xab,0xae,

0xb0,0xb3,0xb6,0xb9,0xbc,0xbf,0xc1,0xc4,0xc7,0xc9,0xcc,0xce,0xd1,0xd3,0xd5,0xd8,

0xda,0xdc,0xde,0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec,0xed,0xef,0xf0,0xf2,0xf3,0xf5,

0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfc,0xfd,0xfe,0xfe,0xff,0xff,0xff,0xff,0xff,

0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xfe,0xfd,0xfc,0xfc,0xfb,0xfa,0xf9,0xf8,0xf7,

0xf6,0xf5,0xf3,0xf2,0xf0,0xef,0xed,0xec,0xea,0xe8,0xe6,0xe4,0xe2,0xe0,0xde,0xdc,

0xda,0xd8,0xd5,0xd3,0xd1,0xce,0xcc,0xc9,0xc7,0xc4,0xc1,0xbf,0xbc,0xb9,0xb6,0xb3,

0xb0,0xae,0xab,0xa8,0xa5,0xa2,0x9f,0x9c,0×98,0×95,0×92,0x8f,0x8c,0×89,0×86,0×83,

0×80,0x7c,0×79,0×76,0×73,0×70,0x6d,0x6a,0×67,0×63,0×60,0x5d,0x5a,0×57,0×54,0×51,

0x4f,0x4c,0×49,0×46,0×43,0×40,0x3e,0x3b,0×38,0×36,0×33,0×31,0x2e,0x2c,0x2a,0×27,

0×25,0×23,0×21,0x1f,0x1d,0x1b,0×19,0×17,0×15,0×13,0×12,0×10,0x0f,0x0d,0x0c,0x0a,

0×09,0×08,0×07,0×06,0×05,0×04,0×03,0×03,0×02,0×01,0×01,0×00,0×00,0×00,0×00,0×00,

0×00,0×00,0×00,0×00,0×00,0×00,0×01,0×01,0×02,0×03,0×03,0×04,0×05,0×06,0×07,0×08,

0×09,0x0a,0x0c,0x0d,0x0f,0×10,0×12,0×13,0×15,0×17,0×19,0x1b,0x1d,0x1f,0×21,0×23,

0×25,0×27,0x2a,0x2c,0x2e,0×31,0×33,0×36,0×38,0x3b,0x3e,0×40,0×43,0×46,0×49,0x4c,

0x4f,0×51,0×54,0×57,0x5a,0x5d,0×60,0×63,0×67,0x6a,0x6d,0×70,0×73,0×76,0×79,0x7c

};

//———————————————–

The same is with square, sawtooth and triangle. Each wave is stored using 256 value table.

Signal is generated using simple function:

//———————————————–

void signalOUT(const uint8_t *signal)

{

uint8_t i;

i=0;

do

{

PORTD=pgm_read_byte(&signal[i++]);

}while(1);

}

//———————————————–

Using this function the maximum generated signal frequency was 6,25kHz. This means that one signal period consists of 256 values from signal table. Crystal frequency is 16MHz. So for one value from table it requires 16000000/(6250*256)=10 clock cycles.

Changing frequency of those signals should be ease. Just insert inside loop delay function regarding to selected frequency. This I will do later.

I still don’t know is it worse to try increase maximum frequency of signal. Now it is 6,25kHz and takes 10 clock cycles for one byte from 256 to output. If I would reach 5 cycles, that would be double frequency 12,5kHz.

In other hand if greater frequencies are needed there will be possibility to use timer signal generator on output compare mode, but only square waves.

Now I going to focus on implementing what I have planned and then think about optimisation.

Bellow are signal pictures I have got at frequency 6,25kHz(picture quality is poor – I really need to get tripod for my camera):

Square

Sawtooth

Triangle

Sine wave

The source code of current program is here:AVR controlled DDS generator software

Full documentation is on its way.

Standard LCD modules comes with built in Character MAP stored in LCD ROM memory. There is plenty of characters for your needs, but still you may need some special ones like backslashes, or some symbols that are in different languages. For this LCD has a reserved RAM area for storing eight 5×7 dot matrix character patterns.

In the table above this area is in first column with addresses starting from 0 to 7 (from 0b00000000 to 0b00000111). This means, that you can define any type of characters in these 8 fields as you like and use them by calling them by addresses from 0 to 7.

To define one character, you will need to write eight bytes in row to CGRAM memory

For 0 character address (DDRAM=0):

So for the first character creation procedure would be:

Cycle of 8 iterations:

Send command to LCD with CGRAM address from 40h to 47h;

Send bytes to to selected CGRAM address

Because characters are 5×7 dots. You only need to modify first five bits of each byte. Other area fill with zeros(Marked blue in picture).

For other 7 characters the procedure is the same. Continue on next 8 CGRAM addresses 48h-4Fh. the last CGRAM address for eighth character is l 78h.

So you can create an array of 64bytes and write them all at once to CGRAM. Then you can read separate characters using DDRAM addresses from 0 to 7.

Before load your custom character to CGRAM, you need to store these chunks of 8 bytes.

The best way to store is program memory (FLASH).

const uint8_t squareR[] PROGMEM=

{

0b00011110,

0b00000010,

0b00000010,

0b00000010,

0b00000010,

0b00000011,

0b00000000,

0b00000000

};

Construction const uint8_t squareR[] PROGMEM menas that data is stored in FLASH at address squareR. For this to work you must include #include „avr/pgmspace.h“ library.

Then reading from program memory is ease pgm_read_byte(squareR[0] ):

Sending to custom character to LCD would look like:

void LCDdefinechar(const uint8_t *pc,uint8_t char_code){

uint8_t a, pcc;

uint16_t i;

a=(char_code<<3)|0x40;//calculate CGRAM address respectively to DDRAM address

for (i=0; i<8; i++){ //eight bytes for one character

pcc=pgm_read_byte(&pc[i]);//reads byte from program memory

LCDwritebyte(a++,pcc); //writes byte to CGRAM at address a

}

Function LCDwritebyte () is simple. Send command with CGRAM address to LCD and after send a byte.

void LCDwritebyte(uint8_t a, uint8_t pc)

{

LCDsendCommand(a);

LCDsendChar(pc);

}

Displaying first custom character stored in DDRAM address 0 is simple:

LCDsendChar(0);

Realization of functions

LCDsendCommand(a);

LCDsendChar(pc);

Depends on how you connect your LCD. I have developed simple routines for 3-wire LCD connection. You may download them from here:LCD Custom char with WinAVR . This is a part of project AVR controlled generator which is still in development stage.

Lazy evening. I decided to take couple shots of couple generated signals. Without going to deep in to timings I wrote couple algorithms to make sure the signals are generated correctly at all voltage range 0-5V.

First is Sawtooth signal using asm in AVRStudio:

.INCLUDE “m8def.inc”

.DEF tmp = R16 ; Multipurpose register

ldi tmp,0xFF; Set all pins of Port D as output

out DDRD,tmp

sawtooth:

out PORTD,tmp

inc tmp

rjmp sawtooth

This is continuing of thread AVR controlled signal generator. In earlier post 1 layer PCB prototype I described a little about making PCB of this small project. Now few words about soldering and making first test run.

This is my PCB board’s bottom. During soldering I discovered one mistake – ISP headers pins MISO and MOSI were swapped. So I had to do some fixes (the green wire).

Another small problem, I discovered, was that I couldn’t find 20k SMD resistors for my R-2R leader. For this DAC R-2R leader I need 10k and 20k resistors to make DAC work properly. So I decided to make “fun” with my Board and soldered 10k SMD resistors in series to gain 20k:

Looks good isn’t it? At least this is working for me.

Then soldered LCD connector and connected 9V battery (voltage regulator LM7805 does his job to reduce it to 5V).

In this project I connected LCD using 3 wires. I used this test program and it worked.

I will have to adjust LCD routine properties to have better timings (delays), because now code is inefficient and takes too much time to execute.

Next stage will be to connect buttons needed. I think I will put all buttons on separate PCB and fix it to the final box like in “Ultraviolet light source UV-80 for PCB exposure” project.

To be continued…

This is continuing of thread of making AVR controlled signal generator. This section is devoted for 1 layer PCB prototype making using ultraviolet light exposure and etching.

The circuit isn’t very complicated, so I decided to make 1 layer PCB prototype.

I’ve chosen Eagle as PCB designing software. This is very handy software for making hobby circuits. Firs I designed circuit of AVR controlled signal generator:

AVR controlled signal generator Circuit image

When Circuit is designed, then follows PCB tracing. The resulting PCB I got is here:

Not all traces were routed. I will need to connect some places with wires, because there left some traces unrouted.

For PCB making I am using the board already covered with photosensitive layer. You may buy them in the market:

You have to peel the protective layer and expose through the mask:

Masked PCB:

After UV exposure second phase is development. I used Sodium Metasilicate as developer.

Sodium Metasilicate

This is better choice than NaOH. It is less aggressive and it is not critical to temperature or concentration. Add 50g for one liter of water. Temperature of solution should be inrange 18 – 24 degrees of Celsius. Develop about 1 – 2 minutes.

After PCB is developed, then wash with water and dry. Then put in etching solution (Ammonium Persulphate). Add about 200 – 250g for one liter of water. Temperature of etching liquid should be about 40 – 50 degrees of Celsius (instead you can use FeCl₃, but it is very messy chemical) :

After board is finished, clean the board with abrasive or developer. I use acetone as it cleans faster but stinks. Better do it outside the house.

After board is done inspect if there are any interconnections between tracks. In my case there are some because the mask wasn’t printed very well and probably there was a gap between mask and board left during exposure. The best way to do corrections is to use sharp knife or needle.

Then drill the holes and it is ok to solder.

To be continued…

Signal generator is second must have tool after oscilloscope while working with electronics designs. I don’t have any signal generators, so I decided to make one. This gone be simple AVR controlled signal generator. For controlling I’ve chosen Atmega8 microcontroller as this is simplest one of Atmega’s series microcontrollers. It has 8kB flash memory.

This is initial post of project. I have only designed schematic and PCB board. I’ll be adding project progress in further posts.

Little bit about AVR controlled signal generator.

This is going to be stand alone generator coated in 100x60x35mm metal box, the one I’ve found in my drawer. It will be powered from 9V battery (through 7805 voltage regulator). Controlling will be done with series of buttons on box side. And information will be viewed on 2.x16 LCD screen on top of box.

Simplified design of AVR controlled signal generator