Hello AVR friends
The second episode of my AVR synthesizer project in CC2 TV is online.
First Episode in Youtube: https:https://www.youtube.com/watch?v=8MZyrBaEf94
Second Episode in Youtube: https://www.youtube.com/watch?v=tl1SMwQXm7o
My WebBlog in english: http://mutable-instruments.net/forum/discussion/2504/shruthi-synthesizer-and-my-wave-1/p1
My WebBlog in german: http://www.cczwei-forum.de/cc2/thread.php?threadid=5878&threadview=0&hilight=&hilightuser=0&page=1
Have fun for show. Rolf
Works in time on my Synth:
In time i development an GPU for the Frontpannel. The old circuit its a long way of 8Bit parallel datas to LCD on the frontpannel. I had sometimes data errors on the LCD.
The new circuit on the frontpannel has an GPU Chip (ATmega328). The master processor (ATxmega128) on the mainboard sends short text and graphics commands via SPI Interface to the slave processor (ATmega328P) on the Frontpannel. The Slave processor calculates the 16Bit graphicdatas and send to LCD. The Master Prozessor have now more time for onather thinks.
Greetings from germany. Rolf
Mainboard and Frontpannel of my Synthesizer
Old mainboard without frontpannel GPU
New Frontpannel with GPU
Hardware Synthesizer Frontpannel
Greetings from Germany. Rolf
Hallo AVR friends
Currently I'm working on the serial communication interface (SPI) between the Master Prozessor ATxmega128 on the motherboard and the Slave Processor ATmega328 on frontpannel.
The data transfer works via the serial SPI interface with 500KHz clock frequency. For the datatransfer, I use a small protocol its same control of Edip displays form electronic assembly.
Small Protokoll
SPI-Interface
A small example of the datatransfer between two processors. The main processor (Master) informs the processor on the Frontpannel (Slave) that he should draw a horizontal line. The following data is transferred for this:
1. Byte = (DC1) communication start
2. Byte = (number) number of data
3. Byte = (Command) LCD command for drawing a line
4. Byte = (X1_L) low Byte X1 (max 320 pixel)
5. Byte = (X1_H) high Byte
6. Byte = (Y1) Y1 bytes (max 240 pixel)
7. Byte = (Len_L) low Byte Line length
8. Byte = (Len_H) high Byte
9. Byte = (collor_l) low Byte 16Bit color
10. Byte = (collor_h) high Byte
11. Byte = (bcc) checksum
Once all bytes are transferred to the Slave Prozessor (ATmega328) in Frontpannel, then checks the checksum of this. If it is OK, it sends an acknowledge byte back to the main processor and transfers the data in its receive buffer. If the checksum is incorrect, the entire command sequence is sent from the main processor again.
During the ATmega328 processor in Frontpannel busy is a line to draw, has the main processor time to other things to'll take care sound output, envelope control of the filter and VCA among others.
If the data buffer in Salve Prozessor full, than send via "Buffer" Line high Level to the Master Prozessor. The Master wait for low line and send the next datas.
Greetings Rolf
Nice work Rolf.
I've been meaning to build a sound module myself but somehow never have the time.
Oh .. I love to develop something myself :)
Hallo AVR Friends
For my development with Master and Slave Processor in my Synth, I use two ATMEL STUDIO IDEs and twoAVRISP MK2 programming adapters. The first IDE runs on my Main PC and the second IDE runs on my laptop and control this via Remotedesktop Connection under Win7 on my Main PC.
Its work fine and I do not have forever changing the programming adapter :)
Info: Running two ATMEL Studio 6.2 apps and two programmers on my Main PC is not funktion. There is often a busy problem with the programmers in ATMEL STUDIO 6.2. I have two compatible Programmers AVRISP MK2 and MIAMEX ALL AVR.
Pic: two ATMEL STUDIO IDE on my Main PC
Example: Master (ATxmega128) and Slave(ATmega328) data transfer via SPI (500kHz)
init SPI Master
//*************************************************************************
// init SPI Master
//*************************************************************************
void init_spi_frontpannel(void)
{
// init SPI-Port
PORTC.DIRSET = (1 << SPI_MOSI) | (1 << SPI_SCK) | (1<<SPI_SS);
// SPI-Clock 500kHz
SPIC.CTRL = SPI_MODE_0_gc | SPI_PRESCALER_DIV64_gc | (1<< SPI_ENABLE_bp) | (1<< SPI_MASTER_bp);// | (1<< SPI_CLK2X_bp); // SPI Double Speed
SPIC.INTCTRL = SPI_INTLVL_OFF_gc; // SPI-Interrupt disabled
} init SPI Slave
//-------------------------------------------------------------------------
// init SPI Slave
//-------------------------------------------------------------------------
void spi_init_slave (void)
{
DDRB = 0b00010011; // SPI Port
SPCR = (1<<SPE) | (1<<SPIE); //Enable SPI
}
Master send SPI datas
//*************************************************************************
// draw h_line
//*************************************************************************
void draw_hline(uint16_t x1, uint8_t y1, uint16_t l1, uint8_t color_l, uint8_t color_h)
{
char buffer[8];
buffer[0] = H_Line; // command draw h_line
buffer[1] = x1; // x1 low Byte
buffer[2] = (x1 >> 8); // x1 high Byte
buffer[3] = y1; // y1
buffer[4] = l1; // len low Byte
buffer[5] = (l1 >> 8); // len high Byte
buffer[6] = color_l; // color low Byte
buffer[7] = color_h; // color high Byte
lcd_send_data(buffer,8); // send datas
}
//*************************************************************************
// send SPI Data to Slave Prozessor
//*************************************************************************
void lcd_send_data(uint8_t small_buffer[50], uint8_t small_len)
{
uint8_t data;
uint8_t bcc;
start_send:
while (PORTC.IN & (1 << PIN0_bp)){Led1_on;} // wait Buffer Overflow
data = SPIC_DATA; // clear spi data register
// send DC1 -----------------------------------------------------------
SPI4_SS_clr; // set SPI_SS low
SPIC.DATA = small_DC1; // send DC1
bcc = small_DC1; // add check sum
while(!(SPIC.STATUS & (1 << SPI_IF_bp))){} // wait until transmission complete
data = SPIC.DATA; // clr spi data register
SPI4_SS_set;
// send data len ------------------------------------------------------
SPI4_SS_clr; // set SPI_SS low
SPIC.DATA = small_len; // send small_len
bcc += small_len; // add check sum
while(!(SPIC.STATUS & (1 << SPI_IF_bp))){} // wait until transmission complete
data = SPIC.DATA; // clr spi data register
SPI4_SS_set;
// send datas ---------------------------------------------------------
for(uint8_t i = 0; i < small_len; i++) // Send data from small_buffer
{
SPI4_SS_clr; // set SPI_SS low
SPIC.DATA = (small_buffer[i]);
bcc += small_buffer[i];
while(!(SPIC.STATUS & (1 << SPI_IF_bp))){} // wait until transmission complete
data = SPIC.DATA; // clr spi data register
SPI4_SS_set;
}
// send bcc checksum --------------------------------------------------
SPI4_SS_clr; // set SPI_SS low
SPIC.DATA = bcc; // send bcc check sum
while(!(SPIC.STATUS & (1 << SPI_IF_bp))){} // wait until transmission complete
data = SPIC.DATA; // clr spi data register
SPI4_SS_set;
// send dummy for ACK -------------------------------------------------
_delay_us(25); // wait min. 19usec befor receive ACK
SPI4_SS_clr; // set SPI_SS low
SPIC.DATA = 0x00; // send dummy byte
while(!(SPIC.STATUS & (1 << SPI_IF_bp))){} // wait until transmission complete
data = SPIC.DATA; // clr spi data register
SPI4_SS_set;
// check ACK Error ----------------------------------------------------
if ((data != small_ACK)) // transmission error
{
_delay_ms(15);
goto start_send;
}
Led1_off;
}
Slave receives SPI datas
//*************************************************************************
// read SPI Data from Master Prozessor (ATxmega128)
//*************************************************************************
ISR(SPI_STC_vect)
{
volatile uint8_t data;
// clear receive buffer -----------------------------------------------
data = SPDR; // load spi data register
// read DC1 -----------------------------------------------------------
if (small.count == 0) // datablock position its begin ?
{
if (data == small_DC1) // check DC1
{
small.count++; // datablock counter++
small.bcc = small_DC1; // add bcc check sum
}
}
// read data len ------------------------------------------------------
else if (small.count == 1) // check datablock position
{
small.len = data; // load data len
small.count++; // datablock counter++
small.bcc += small.len; // add bcc check sum
}
// read datas ---------------------------------------------------------
else if (small.count > 1) // if datablock_counter > 1
{
if (small.count > (small.len +1)) // if end of datas ?
{
small.bcc = small.bcc % 256; // calc check sum
if (small.bcc != data) // if check sum false
{ // than
//Led_on; // error led on
small.count = 0; // clr datablock_counter
_delay_ms(200);
SPDR = 0x15; // send NACK
while(!(SPSR & (1<<SPIF))); // wait until transmission complete
data = SPDR; // clr spi data register
}
else // if data_block end than copy into send_buffer
{ // time to ACK is 12usec
// test send_buffer overflow
if (buffer.fill >= Buffer_Size - SMALL_Buffer_Size)
{
Led_on;
set_OVF; // set OVF Port PB0
SPDR = small_OVF; // send OVF Error
while(!(SPSR & (1<<SPIF))); // wait until transmission complete
data = SPDR; // clr spi data register
small.count = 0; // clr data counter
}
else
{
//Led_on; // Error Led off
SPDR = small_ACK; // send ACK
while(!(SPSR & (1<<SPIF))); // wait until transmission complete
data = SPDR; // clr spi data register
small.count = 0; // clr data counter
// copy databloack in send_buffer
for (uint16_t i = 0; i < small.len; i++)
{
buffer.data[buffer.write] = small.data[i];
buffer.write++;
buffer.fill++;
if (buffer.write >= Buffer_Size)
{
buffer.write = 0;
}
}
}
}
}
else
{
small.data[small.count-2] = data; // copy data into datablock buffer
small.bcc += data;
small.count++;
}
}
}
//*************************************************************************
// read lcd buffer
//*************************************************************************
rd_lcd_buffer(void)
{
uint8_t datax = buffer.data[buffer.read];
buffer.read++;
if (buffer.read >= Buffer_Size)
{
buffer.read = 0;
}
cli();
buffer.fill--; // buffer fill status
sei();
return datax;
}
//*************************************************************************
// send data to lcd
//*************************************************************************
void lcd_send_data(void)
{
//Led_on;
uint8_t command = rd_lcd_buffer(); // read lcd command
// draw horizontal line -----------------------------------------------
if (command == H_Line)
{
uint8_t x1_l = rd_lcd_buffer(); // x1 low byte
uint8_t x1_h = rd_lcd_buffer(); // x1 high byte
uint8_t y1 = rd_lcd_buffer(); // y1
uint8_t l1_l = rd_lcd_buffer(); // Len low byte
uint8_t l1_h = rd_lcd_buffer(); // Len high byte
uint8_t color_l = rd_lcd_buffer(); // color low byte
uint8_t color_h = rd_lcd_buffer(); // color high byte
uint16_t x1 = ((x1_h << 8) | x1_l); // convert x1 in 16Bit
uint16_t l1 = ((l1_h << 8) | l1_l); // convert l1 in 16Bit
draw_hline(x1,y1,l1,color_l, color_h); // draw horizontal line
}
My Work at this time:
I changing my program code for all menu-pages in my synth which its drawing in the new slave processor.
Some menu pages:
Best Rolf
Hallo..
I have to optimize my envelope code in my synth. Thanks Pichenettes from Mutable Instrument ( http://mutable-instruments.net/f...)
The code computes linear segments that go from 0 to 65535. Then it uses a lookup table and scale / offset them to rebuild the full envelope.
Update Envelope in timer-interrupt 1msec.
And if you’re wondering about the advantages of this method…
C Code for avr-gcc
//----------------------------------------------------------------
// Variable
//----------------------------------------------------------------
uint16_t phase_;
uint16_t phase_increment;
uint16_t ramp_start_;
uint16_t ramp_end_;
uint8_t ramp_a_;
uint8_t ramp_b_;
uint16_t value_;
//-----------------------------------------------------------------
// Envelope Phase
//-----------------------------------------------------------------
if (adsr1_phase == ATTACK)
{
// load 7Bit attack_value1 from encoder (0-127) and convert to 16Bit phase_increment
phase_increment = pgm_read_word (&(lut_res_env_portamento_increments[attack_value1]));
ramp_start_ = 0;
ramp_end_ = 65535;
ramp_a_ = 0;
ramp_b_ = 255;
envelope();
}
else if (adsr1_phase == DECAY)
{
// load 7Bit decay_value1 from encoder (0-127) and convert to 16Bit phase_increment
phase_increment = pgm_read_word (&(lut_res_env_portamento_increments[decay_value1]));
// load 7Bit sustain level from encoder (0-127) and convert in 16Bit for ramp_start
ramp_start_ = pgm_read_word (&(sustain_level[sustain_value1]));
ramp_end_ = 65535;
ramp_a_ = 255;
ramp_b_ = 0;
envelope();
release_level = value_;
}
else if (adsr1_phase == RELEASE)
{
// load 7Bit release_value1 from encoder (0-127) and convert to 16Bit phase_increment
phase_increment = pgm_read_word (&(lut_res_env_portamento_increments[relaese_value1]));
ramp_start_ = 0;
ramp_end_ = release_level;
ramp_a_ = 255;
ramp_b_ = 0;
envelope();
}
if (midi_gate_flag == 0)
{
if (adsr1_phase < 3)
{
adsr1_phase = RELEASE;
phase_ = 0;
}
}
//-------------------------------------------------------------------------
// Envelope
//-------------------------------------------------------------------------
void envelope(void)
{
// increment 16Bit env_ramp
phase_ += phase_increment;
// check end of envelope phase
if (phase_ < phase_increment)
{
// set next envelope phase
adsr1_phase ++;
phase_ = 0;
}
else
{
// interpolate 8Bit env_expo table with 16Bit phase_
uint8_t step = InterpolateSample(wav_res_env_expo, phase_);
// calc 16Bit envelope value
uint16_t ramp_expo = U8MixU16(ramp_a_, ramp_b_, step);
value_ = ramp_start_ + ((uint32_t)(ramp_end_ - ramp_start_) * ramp_expo >> 16);
// set envelope_out
adsr1_out = value_;
}
}
//---------------------------------------------------------------------------
// inline function and tables
//---------------------------------------------------------------------------
static inline uint8_t InterpolateSample(
//const uint8_t* table, uint16_t phase) {
const uint8_t table[], uint16_t phase) {
uint8_t result;
uint8_t work;
asm(
"movw r30, %A2" "\n\t" // copy base address to r30:r31
"add r30, %B3" "\n\t" // increment table address by phaseH
"adc r31, r1" "\n\t" // just carry
"mov %1, %A3" "\n\t" // move phaseL to working register
"lpm %0, z+" "\n\t" // load sample[n]
"lpm r1, z+" "\n\t" // load sample[n+1]
"mul %1, r1" "\n\t" // multiply second sample by phaseL
"movw r30, r0" "\n\t" // result to accumulator
"com %1" "\n\t" // 255 - phaseL -> phaseL
"mul %1, %0" "\n\t" // multiply first sample by phaseL
"add r30, r0" "\n\t" // accumulate L
"adc r31, r1" "\n\t" // accumulate H
"eor r1, r1" "\n\t" // reset r1 after multiplication
"mov %0, r31" "\n\t" // use sum H as output
: "=r" (result), "=r" (work)
: "r" (table), "r" (phase)
: "r30", "r31"
);
return result;
}
static inline uint16_t U8MixU16(uint8_t a, uint8_t b, uint8_t balance) {
uint16_t result;
asm(
"mul %3, %2" "\n\t" // b * balance
"movw %A0, r0" "\n\t" // to sum
"com %2" "\n\t" // 255 - balance
"mul %1, %2" "\n\t" // a * (255 - balance)
"com %2" "\n\t" // reset balance to its previous value
"add %A0, r0" "\n\t" // add to sum L
"adc %B0, r1" "\n\t" // add to sum H
"eor r1, r1" "\n\t" // reset r1 after multiplication
: "&=r" (result)
: "a" (a), "a" (balance), "a" (b)
);
return result;
}
//-------------------------------------------------------------------------
// Attack increments 16Bit
//-------------------------------------------------------------------------
const uint16_t lut_res_env_portamento_increments[] PROGMEM = {
65535, 18904, 16416, 14304, 12504, 10968, 9647, 8509,
7525, 6672, 5931, 5285, 4719, 4224, 3788, 3405,
3066, 2766, 2500, 2264, 2053, 1865, 1697, 1546,
1411, 1290, 1180, 1082, 993, 912, 839, 773,
713, 658, 608, 562, 521, 483, 448, 416,
387, 360, 335, 313, 292, 272, 255, 238,
223, 209, 196, 184, 172, 162, 152, 143,
135, 127, 119, 113, 106, 100, 95, 90,
85, 80, 76, 72, 68, 64, 61, 58,
55, 52, 50, 47, 45, 43, 41, 39,
37, 35, 33, 32, 30, 29, 28, 26,
25, 24, 23, 22, 21, 20, 19, 18,
18, 17, 16, 16, 15, 14, 14, 13,
13, 12, 12, 11, 11, 10, 10, 9,
9, 9, 8, 7, 7, 6, 6, 5,
5, 4, 4, 3, 3, 2, 2, 1
};
const uint8_t wav_res_env_expo[] PROGMEM = {
0, 4, 9, 14, 19, 23, 28, 32,
37, 41, 45, 49, 53, 57, 61, 65,
68, 72, 76, 79, 83, 86, 89, 92,
96, 99, 102, 105, 108, 111, 113, 116,
119, 121, 124, 127, 129, 132, 134, 136,
139, 141, 143, 145, 148, 150, 152, 154,
156, 158, 160, 161, 163, 165, 167, 169,
170, 172, 174, 175, 177, 178, 180, 181,
183, 184, 186, 187, 188, 190, 191, 192,
193, 195, 196, 197, 198, 199, 200, 201,
202, 203, 205, 206, 206, 207, 208, 209,
210, 211, 212, 213, 214, 215, 215, 216,
217, 218, 218, 219, 220, 221, 221, 222,
223, 223, 224, 225, 225, 226, 226, 227,
227, 228, 229, 229, 230, 230, 231, 231,
232, 232, 233, 233, 233, 234, 234, 235,
235, 236, 236, 236, 237, 237, 238, 238,
238, 239, 239, 239, 240, 240, 240, 241,
241, 241, 241, 242, 242, 242, 243, 243,
243, 243, 244, 244, 244, 244, 245, 245,
245, 245, 245, 246, 246, 246, 246, 246,
247, 247, 247, 247, 247, 248, 248, 248,
248, 248, 248, 248, 249, 249, 249, 249,
249, 249, 249, 250, 250, 250, 250, 250,
250, 250, 250, 251, 251, 251, 251, 251,
251, 251, 251, 251, 251, 252, 252, 252,
252, 252, 252, 252, 252, 252, 252, 252,
252, 253, 253, 253, 253, 253, 253, 253,
253, 253, 253, 253, 253, 253, 253, 253,
253, 254, 254, 254, 254, 254, 254, 254,
254, 254, 254, 254, 254, 254, 254, 254,
254, 254, 254, 254, 254, 254, 254, 255,
255
};
//-------------------------------------------------------------------------
// Sustain level 16Bit
//-------------------------------------------------------------------------
const uint16_t sustain_level[] PROGMEM = {
1, 11, 33, 65, 106, 157, 218, 287,
366, 454, 550, 655, 769, 891, 1022, 1162,
1310, 1466, 1630, 1803, 1984, 2173, 2370, 2576,
2789, 3011, 3240, 3477, 3723, 3976, 4237, 4506,
4783, 5068, 5360, 5660, 5968, 6284, 6607, 6938,
7277, 7623, 7977, 8338, 8707, 9084, 9468, 9860,
10259, 10666, 11080, 11502, 11931, 12367, 12811, 13263,
13722, 14188, 14661, 15142, 15630, 16126, 16629, 17139,
17657, 18181, 18713, 19253, 19799, 20353, 20914, 21483,
22058, 22641, 23231, 23828, 24432, 25043, 25662, 26288,
26920, 27560, 28207, 28862, 29523, 30191, 30867, 31549,
32239, 32935, 33639, 34350, 35068, 35792, 36524, 37263,
38009, 38762, 39522, 40288, 41062, 41843, 42631, 43425,
44227, 45036, 45851, 46674, 47503, 48339, 49182, 50033,
50889, 51753, 52624, 53502, 54386, 55278, 56176, 57081,
57993, 58912, 59837, 60770, 61709, 62655, 63608, 65535
};
My new envelope on Youtube: https://www.youtube.com/watch?v=...
Greetings from germany. Rolf
Hello there and good evening..
I believe that the sounds from DE: Generator I are very interesting not to hide need compared to other synths, although my box makes only 8bit.
Today I have loaded a 580KByte choral sample and played with Step Sequencer in my synth.
In the normal state, the waveform oscillator is retriggered with every midi note and sample playing of the beginn again (Sound Example Part 1). You can switch off the trigger function (RETRIG) and the waveform Oscillator run free and played a different sample area (Sound Example Part 2). The sound is thus varied and less static. This works very well only with pad sounds.
Sound-File in my Synth
Sound example: Soundcloud
1.Part: retrigger waveform oscillator
2.Part: free run waveform oscillator
Best. Rolf
Hello Friends
This week I’m working on the modulation matrix again and am having problems :(
The sources have numbers and are stored this in 1st column from modulation array.
Nr.1 = LFO1
Nr.2 = LFO2
Nr.3 = LFO3
Nr.4 = ENV1
...and more
The destination have numbers and are stored this in 2st column from modulation array.
Nr.1 = VCA gain
Nr.2 = VCF cutoff
Nr.3 = Osc1
Nr.4 = Osc2
...and more
The amount values stored in 3st column from modulation array.
For calc the modulation I want to load the sources-values from source-numbers in the source_array
for (slot = 0; slot < 6; slot++)
{
source_nr = (slot_array[slot][0]);
if (source_nr == 1){source_array[slot][lfo1_value;}
if (source_nr == 2){source_array[slot][lfo2_value;}
if (source_nr == 3){source_array[slot][lfo3_value;}
if (source_nr == 4){source_array[slot][env1_value;}
...and more
}
Is there a better solution ?
Modulationsmatrix in my synth
Best Rolf
Hallo..
This is an idea from pichenettes from mutable forum:
First of all, copy all your sources in an array.
sources[ 0 ] = lfo_1_value;
sources[ 1 ] = lfo_2_value;
sources[ 2 ] = lfo_3_value;
sources[ 3 ] = lfo_4_value;
sources[ 4 ] = env_1_value;
// and so on…
And prepare a destination array with the “base” value of each parameter times 64 (assuming the maximum modulation amount is 64 and the minimum -64).
I suggest you to use a “wide” signed type for source and destination, like int32_t.
destination[ 0 ] = base_cutoff_value << 6;
destination[ 1 ] = base_resonance_value << 6;
The << 6 is necessary because the “base” value of the parameter edited in the UI has a maximum contribution (equivalent to a modulation amount of 64).
Then go through all your modulation matrix slots:
for (slot = 0; slot < NUMBER_OF_SLOTS; slot++)
{
uint8_t source_number = slot_array[ slot ][ 0 ]; uint8_t destination_number = slot_array[ slot ][ 1 ]; int8_t amount = (int8_t)(slot_array[ slot ][ 2 ]); destination[ destination_number ] += sources[ source_number ] * amount;
}
Finally, clip all values and divide them by 64
for (i = 0; i < NUMBER_OF_DESTINATIONS; i++) {
destination[ i ] >>= 6; if (destination[ i ] < 0) destination[ i ] = 0; if (destination[ i ] > MAX_VALUE) destination[ i ] = MAX_VALUE;
}
Comment: it’s not a super good idea to store the modulation matrix in an untyped array. What about using a struct instead:
typedef struct { uint8_t source_index; uint8_t destination_index; int8_t amount; // -64 minimum, 64 maximum
} ModMatrixEntry;
Then declare ModMatrixEntry slots6;
Hallo Friends :)
Things I’m working on at the time…
For “DE:generator” I changed the circuit for the sample input (see Pic). For low noise, we have an external reference voltage source used LM336. The ADC input operates in 8Bit Single-ended measurement in unsigned mode. For this we need an half offset voltage on ADC input. This is adjust with resistor R101. The resistor R103 protects the ADC input from high levels of audio signals. In addition, the processor has protection diodes in adc input. C 105 is optional.
Audio example from my Synth: https://soundcloud.com/rolfdegen...
Audio Input in my DIY Synthesizer
For sample recording i have implement some modes: Threshold, NoteOn and Key
Sample Menu in my Synthesizer
Youtube: https://www.youtube.com/watch?v=2Vn8oYqZZrc
Greetings from Germany. Rolf
Hello everybody..
For better sample recording, I have connected the ADC input in Xmega processor as a differential input. The ADCis sampling in Xmega processor with 12bit and a sampling rate of 44.1KHz. Internally, the 12-bit value is reduced to 8bit and written into 1MByte large sample RAM. The OpAmp IC 15c + 15d makes a fifferential audio signal for the ADC input.
Pic: Filter and Sample input
This is the init code for the 12Bit adc in the xmega128a1 prozessor:
// 12Bit / differencial mode / ext.VRef 2.5V PortA0 / Prescaler 64 / positive Input PortA3 / negative Input PortA1 ADCA.CTRLB = ADC_RESOLUTION_12BIT_gc | ADC_FREERUN_bm; ADCA.REFCTRL = ADC_REFSEL_AREFA_gc; ADCA.PRESCALER = ADC_PRESCALER_DIV64_gc; ADCA.CH0.CTRL = ADC_CH_INPUTMODE_DIFF_gc; ADCA.CH0.MUXCTRL |= ADC_CH_MUXPOS_PIN3_gc | ADC_CH_MUXNEG_PIN1_gc; ADCA.INTFLAGS = 0x00; ADCA.CTRLA = ADC_ENABLE_bm; // ADC enabled
For audio recording (sampling) I have implemented a Noise Shaper function.
The ADC input works with a resolution of 12 bits. For internal sample calculations I have
downsampling from 12 to 8 bits (4 * right shifting). But quit audio signals it has loud noise .
The Noise Shaper moves this noise in a higher frequency range, so you hear the noise not so loud.
Program code:
//*************************************************************************
// Test noise-sharping 12Bit 44.1KHz
//*************************************************************************
int16_t quant_error = 0;
ISR TCC0_OVF_vect {
int16_t sample_x = ADCA_CH0RES;
int16_t sample_16 = sample_x * 12;
sample_16 += quant_error;
if (sample_16 < -32768){sample_16 = 32768;}
else if (sample_16 > 32767){sample_16 = 32767;}
int8_t sample_8 = sample_16 >> 8;
quant_error = sample_16 – ((int16_t)(sample_8) << 8);
// simple 12Bit to 8Bit convert function with shift right and big noise floor
// convert 12Bit into 8Bit uint16_t sample_16 = ADCA_CH0RES; uint8_t sample_8 = sample_16 >> 4;
// DAC out
DACA.CH0DATAH = sample_8;
DACB.CH0DATAH = sample_8;
}To demonstrate this I have added some sound samples.Respectively without and with the noise shaper function.
Most clearly we hear it in sound 3 +4. The piano sounds are very quiet and you can here a loud noise floor from 8Bit resolution.
Sound 1 without NS: https://drive.google.com/file/d/...
Sound 2 with NS: https://drive.google.com/file/d/...
Sound 3 without NS: https://drive.google.com/file/d/...
Sound 4 with NS: https://drive.google.com/file/d/...
Sound 5 without NS: https://drive.google.com/file/d/...
Sound 6 with NS: https://drive.google.com/file/d/...
Greetings from germany. Rolf
Hello friends..
I have worked a lot on my DIY Synthesizer Project. This is the PCB Layout from DE-GENERATOR.
There are four boards. CPU board with ATMEL Xmega128A1 and 1 MByte Sample RAM.
Stereo filter board with 12dB LP / HP / BP. The filter board is interchangeable with another filter.
Motherboard with power supply and external connectors for Midi and Audio. And the panel board
with LCD display, buttons and encoders. The encoders have a blue LED lighting.
You can read more in my blog: http://mutable-instruments.net/f...
Greetings from germany. Rolf
This is a Programcode for an 24Bit Random- and Noisegenerator with LowPass filter in my Synthesizer. For quick calculation I use inline assembler.
// 24Bit Noise generator with LP-Filter ---------------------------------------------------
// global var
__uint24 noise_x = 0xB400;
uint8_t noise_8;
uint8-t lp_noise;
ISR(TCC0_OVF_vect) // Timer interrupt 44.1 KHz
{
noise_8 = noise_generator(); // call noise function. 8Bit result in noise_8
lp_noise = U8Mix(lp_noise,noise_8,filter_value); // noise filter. 8Bit result in lp_noise
DACA.CH0DATAH = lp_noise; // DAC out
}
static inline noise_generator() {
asm(
"lds r18, noise_x" "\n\t"
"lds r19, noise_x+1" "\n\t"
"lds r20, noise_x+2" "\n\t"
"bst r18, 4" "\n\t"
"bld r30, 0" "\n\t"
"bst r20, 7" "\n\t"
"bld r31, 0" "\n\t"
"eor r30, r31" "\n\t"
"ror r30" "\n\t"
"rol r18" "\n\t"
"rol r19" "\n\t"
"rol r20" "\n\t"
"sts noise_x, r18" "\n\t"
"sts noise_x+1, r19" "\n\t"
"sts noise_x+2, r20" "\n\t"
);
return;
}
static inline uint8_t U8Mix(uint8_t lp_noise, uint8_t noise_8, uint8_t filter_value) {
uint16_t sum;
asm(
"mul %3, %2" "\n\t" // noise_8 * filter_value
"movw %A0, r0" "\n\t" // to sum
"com %2" "\n\t" // 255 - filter_value
"mul %1, %2" "\n\t" // lp_noise * (255 - filter_value)
"com %2" "\n\t" // reset filter_value to its previous value
"add %A0, r0" "\n\t" // add to sum L
"adc %B0, r1" "\n\t" // add to sum H
"eor r1, r1" "\n\t" // reset r1 after multiplication
: "&=r" (sum)
: "a" (lp_noise), "a" (filter_value), "a" (noise_8)
);
return sum >> 8;
}
Greetings from germany. Rolf
Hello .. me again
Monday just is always busy and for me too in the development workshop.
To its “unlimited” way of sound production to increase the DE GENERATOR yet, the 128 fixed waveforms can now be downloaded as a waveform bank of the SD card. Overall, there is a possibility to 128 * 100 Waveforms and 128 * 100 Sample files to access. A waveform bank consists of 128 individual 256-byte waveforms. This can make on a PC with an audio editor (Audacity) and copied to the SD card. On the Oscillator page you can access waveform banks and sample-file banks. An editing of the waveform bank is currently not provided in DE-GENERATOR.
With mode switch you can selection of waveform or sample-file.
Pics: WAVEFORM and Sample-File selection
Waveform selection
Wavefile selection
Hey. What am I doing..
I’m currently working on a few Midi function for DE: GENERATOR. A little function is a Midi note management (Note Stack).
The notestack does the following: When I play a MIDI note, which marks number is stored at position 1 in NoteStack and played the sound of the synthesizer. Now.. I let release the note, then the note is deleted from the note stack and the tone is muted. Simple..
But now we press two notes successively. Almost happened: Firstly the 1.Note is stored at position 1 in NoteStack and played the tone. After that 2.Note is press is stored at 2.place in notestack and played the tone for the 2.Note. Now there are two notes on the NoteStack. The 1.Note at place 1 and 2.Note at place 2. Do I now 2.Note release, the 2.Note is cleared on 2nd place in the notestack and synthesizer is played the tone for the 1.Note.
Same is happened when the 1.Note is released and the 2.Note is still played. Thereby the 1.Note is then deleted at No. 1 in the note stack and moved the 2.Note place. 1 The tone for the 2.Note is played without interruption. A total of 16 notes will be managed in the notestack.
Code example in 2.pic
Greetings Rolf
uint8_t NoteStack_pool[10];
uint8_t NoteStack_ptr = 0;
uint8_t NoteStack_size = 10;
//-------------------------------------------------------------------------
// NoteOn
//-------------------------------------------------------------------------
void midi_NoteOn(void)
{
uint8_t midi_note_temp = midi_data[0]; // load midi_note
if (NoteStack_ptr < NoteStack_size)
{
midi_note = midi_note_temp;
NoteStack_pool[NoteStack_ptr] = midi_note; // write current note into notestack_pool
NoteStack_ptr++;
midi_sync_flag = 1; // start envelopes
}
}
//-------------------------------------------------------------------------
// NoteOff
//-------------------------------------------------------------------------
void midi_NoteOff(void)
{
// load current note
uint8_t midi_note_temp = midi_data[0];
uint8_t last;
// search current note into notestack_pool
for (uint8_t i = 0; i < NoteStack_size; i++)
{
if (NoteStack_pool[i] == midi_note_temp)
{
// clear current note into notestack_pool
NoteStack_pool[i] = 0xFF;
NoteStack_ptr--;
last = i;
// sort notes into notestack_pool
for (last; last < NoteStack_size;last++)
{
NoteStack_pool[last] = NoteStack_pool[last+1];
}
// playing previous note
if (NoteStack_ptr > 0)
{
last = NoteStack_ptr-1;
midi_note = NoteStack_pool[last];
frequency_tune();
}
else
{
// stop envelope if no note into notestack_pool
midi_gate_flag = 0;
}
break;
}
}
}
Hey ..
Today the CPU boards for the DE:GENERATOR arrived from China. We have ordered 10 pieces for test. Now we go to the SMD soldering. Let’s see if we are making it ?
Pic: CPU PCB for DE:GENERATOR
Greetings from germany. Rolf
Hello everybody..
Now we plan the motherboard for the DE:GENERATOR. On the motherboard (see picture) implements the power supply, midi interface, VCA, Fx (delay circuit) and audio input / output. The Filter- and CPU-board are inserted later on the motherboard contacts. Some SMD components implement on the CPU board, it is delivered soldered and tested by us.
The audio input is not finished yet. We are considering to integrate a microphone amplifier ?. Then Andre will start with the layouts.
Hallo zusammen..
Für den DE:GENERATOR planen wir jetzt das Motherboard. Auf dem Motherboard (siehe Bild) sitzt die Spannungsversorgung, Midi Schnittstelle, VCA, Fx (Delay Schaltung) und Audio Ein/Ausgang. Das Filter- und CPU-Board werden später auf das Motherboard gesteckt. Da auf dem CPU-Board einige SMD Bauteile sitzen, wird sie von uns gelötet und getestet ausgeliefert. Jetzt gibt es noch ein paar Details zu klären, die den externen Audio Eingang auf dem Motherboard betreffen. Dann wird Andre mit dem Layouten beginnen.
Pic 1: DE:GENERATOR Motherboard
Pic 2: Audio Input on the Motherboard
The audio signal can be routed to Filter input or Sample input. Is the Sample input selected and you recording an Audio signal than be must switch the Filter input to mute. If not and you have seleced the monitor function on sampling page you have an feedback signal.
Greetings from germany. Rolf
Memory management in DE: GENERATOR
Hi everybody. Today I will tell you something about memory management in DE:GENERATOR. As you probably already know, has the DE: GENERATOR a 1MByte large sample memory. This is connected via the EBI memory interface with the ATxmega processor. There a loaded sample file is stored, and one each waveform bank for oscillator. 1 + 2. A small memory size is for representation of the waveform on the display. The 8KByte largeSRAM in Xmega processor would be much too small for the large sample files and the operating system of DE:GENERATOR approx 5KByte of SRAM for data and variables.
Pic: Sample storage
The first two 4K memory blocks are reserved for the bandlimited waveforms of Osc1+2. The next memory block is for one sample file. At the SRAM end are 512 user-waveforms stored for the oscillators. Each oscillator can select one user waveform ore the sample file. An administration of diffrent sample files for both oscillators is not provided at the time..
Until next time. Greeting Rolf
Die Speicherverwaltung im DE:GENERATOR
Hallöchen zusammen. Heute will ich euch etwas über Speicherverwaltung im DE:GENERATOR erzählen. Wie ihr vermutlich schon wisst, besitzt der DE:GENERATOR einen 1MByte großen Sample Speicher. Dieser ist über das EBI-Speicherinterface mit dem ATxmega Prozessor verbunden. Dort wird ein geladenes Sample-File gespeichert und jeweils eine Wellenform-Bank für Oszillator 1+2. Ein kleiner Teil des Speichers wird noch für die Darstellung der Wellenform auf dem Display benötigt. Das 8KByte große SRAM im Xmega Prozessor wäre für die großen Sample-Files viel zu klein. Außerdem benötigt das Betriebsystem des DE:GENERATOR ca. 5KByte des SRAM’s für Daten und Variablen.
Bild: Sample-Speicher
Die ersten beiden 4K Speicherblöcke sind für Bandlimitierte Wellenformen von Osc1+2 reserviert. Danach folgt der Speicherblock für das Sample-File. Im hinteren Teil des Speichers werden die geladenen Wellenform-Bänke von Oszillator 1+2 gespeichert. Jeder Oszillator kann dadurch unabhängig auf eine eigene Wellenform-Bank zugreifen oder auf das geladene Sample-File. Eine Verwaltung von zwei Sample-Files für beide Oszillatoren ist zur Zeit nicht vorgesehen und hätte den Nachteil, dass sich der Speicherplatz dafür halbieren würde.
Bis zum nächsten Mal. Gruß Rolf
PIC: Sample-RAM
PIC: CPU_Board
PIC: CPU PCB
PIC: Waveform selection on the OSC-Page
PIC: Sample-File selection on the Osc Page
Greetings from germany. Rolf
This is a very cool project, thanks for sharing!
Hi friends… The CPU board of DE:GENERATOR is ready soldered. We have a small electronics company found that can us solder the boards.
I trying yesterday mayself and takes about an hour for the complete soldering. Now.. i develop a small test adapter with an TFT display for
the cpu-pcb and program some test routines.
Image: CPU PCB from DE:GENERATOR
Hi friends..
This is the final version of power supply in my synthesizer.
Power supply +12V, +8V, -8V, +5V, +3.3 V
The Motherboard comes today. Now we can test it in combination with the CPU board .
Motherboard from Degenerator
Soldering the motherboard..
Soldering the Filterboard..
The filterboard is still in development. Its a two channel 12dB LB/BP/HP filter
Greetings from Germany. Rolf
The three LFO LEDs are driven in PWM-Mode on the 74HC595 chip.
Video link: https://www.youtube.com/watch?v=bMUaGmoW2oY&feature=youtu.be
Hallo…
I have try with a 64Byte sample buffer. Now.. i can here a little glitch sound (870usec) from first note in the buffer (see pic). I think its not good result.
But… I have another idea! In another post I discuss with pichenettes over mute bytes (128) in the audio buffer if the vca gain < 2.
Now..my new idea: If I delete the sample Buffer after the release phase of a note, then should not the old notes in sample buffer ? I will try this…
Hello friends..
I solved the problem for the CV outputs. My mistake was that: I have calculated the note frequency in the envelope task. This was too late and the buffer has old rendering values.
My result:
Every 1msec (interrupt task) i check midi_ events and calc note freuenzy for the oscillators
Every 25usec (interrupt task) i read buffer values and send to dac outputs.
Pic: yellow is Midi data and blue audio output
Hi friends..
In my 1 year old 70MHz Siglent scope SDS1072CML is the backlight broken. Well I have warranty and have changed it with little more money into a 100MHz scope SDS1102CML +. The Plus version has some improvements larger TFT resolution 800 × 480, a redesign of the controls, LAN interface and more memory for the recording function, and more memory for the recording function. Its a very nice Low-Budget sope :))
PS: The violet color of the second channel is too dark. In my old Scope the color was light blue and better seen
Here is a small impression of my synthesizer..
Video 1: https://www.youtube.com/watch?v=...
Video 2: https://www.youtube.com/watch?v=...
The sound quality is not as good as I recording with my smartphone.
Hey friens
Today.. I’ll tell you a little bit of buffer size and CPU resources
In Degenerator is much expected as real-time calculation of two oscillators, sampling, 3 LFO’s, 2 Envelopes, Modulation Matrix, Graphical User Interface, Oscilloscope function and more. The processor resources from my “fast” ATMEL MCU (32MHz Xmega128A1) are unfortunately very scarce and I had to search for intelligent solutions to make everything work quickly and shorter. For later development we may need more CPU power, the replacement of the CPU board is designed for a board with a powerful ARM processor or similar.
The calculation routine for the oscillators (Pic 2 violet) requires 41% of the entire computing power in XmegaMCU. All 25 usec are two oscillator values (yellow) sent from a buffer to the two DAC outputs on Xmega. This will take about 1 usec and corresponds to a sample rate of 40KHz. Since it would be not efficient the oscillator values all 25usec recalculate (I did it before). Now.. I use a doublebuffer function to calculate and save values for the oscillator. In a 25usec timer interrupt read oscillator values from buffer and sent to the DAC. Theory is simple but it is a bit complicated to program. The buffer is actually two double buffer with 80 bytes for both oscillators. I illustrate the operation of the doublebuffer function for one oscillator.
Image 1: Doublebuffer
Function mode of doublebuffer
Image 1: The closed circuit illustrates the sequence, as in a constant repetition after the second buffer again, the first follows. Each buffer holds here 40 samples, corresponding to a latency of 1 ms. As this 1ms arise is easy to understand. When starting playback, the cursor is at the point marked. 0 Since the start of the reproduction of the first buffer has been playing the software copies the data first into the second buffer. Imagine (in slow motion), as the pointer moves clockwise. At a sample rate of 40 kHz, 40 samples are processed in only 1 ms. When the pointer reaches the boundary between the buffers (position 1) an interrupt is triggered, and the software calculates the next 40 samples and stores them in the (now processed) first buffer. The second buffer will be played at the end (position 0) an interrupt is triggered, Sampels be calculated again and copied into the second buffer .. The whole buffer repeats itself endlessly.
Figure 2: Time interval of the buffer function
Yellow: 25 microseconds interval for sample output to the DAC (approximately 1usec)
Violet: 1 ms interval for the calculation of 80 samples (approximately 412usec)
In the next post the topic buffer and Midi goes latency
The buffer is swap every millisecond in the dac output routine (pic 2 violet curve).
If 2x40 bytes have been sent toDAC (yello curve) an interrupt (middle priority) is triggered for filling buffer.
The fill time is 421 ms. The filling of the buffers is completed before a new trigger comes :)
An example of oscillator with triangle:
//*************************************************************************
// OscRender: TRIANG
//*************************************************************************
void OscRender_TRIANG(uint8_t osc_nr)
{
uint8_t block_size = 40;
uint8_t parameter;
uint8_t *buffer; // pointer name
uint8_t i = 0;
if (osc_nr == 0)
{
parameter = Osc.prm_value[0];
if (Voice.buffer_nr == 0)
{
buffer = Voice.Buffer2a;
}
else {buffer = Voice.Buffer1a;}
}
else
{
parameter = Osc.prm_value[1];
if (Voice.buffer_nr == 0)
{
buffer = Voice.Buffer2b;
}
else {buffer = Voice.Buffer1b;}
}
while (block_size--)
{
// update Phase
Osc.phase[osc_nr] += Osc.phase_increment[osc_nr];
// Osc sync
if (osc_nr == 0){Osc12.syncbuffer[i] = Osc.phase[osc_nr] < Osc.phase_increment[osc_nr] ? 1:0;}
else{if (Osc.op_value == OP_SYNC){if (Osc12.syncbuffer[i]) Osc.phase[osc_nr] = 0;}}
uint16_t phase_integral = Osc.phase[osc_nr] >> 8;
uint8_t tri = phase_integral >> 7;
uint8_t v = phase_integral & 0x8000 ? tri : ~tri;
if (v < parameter) { // fold triangle
v = (parameter << 1) - v;
}
// write sample in current buffer
buffer[i] = ~v;
i++;
}
}
//*************************************************************************
// Timer0 Interrupt: Audio_Out Task 40KHz/25usec (highest priority)
//*************************************************************************
ISR(TCC0_OVF_vect)
{
// stop global interrupt
cli();
// read samples from buffers ------------------------------------------
if (Audio.buffer_nr == 0)
{
DACA.CH0DATAH = Audio.Buffer1a[Audio.buf_read];
DACB.CH0DATAH = Audio.Buffer1b[Audio.buf_read];
}
else
{
DACA.CH0DATAH = Audio.Buffer2a[Audio.buf_read];
DACB.CH0DATAH = Audio.Buffer2b[Audio.buf_read];
}
// inc buffer and change buffer_nr ------------------------------------
Audio.buf_read++;
if (Audio.buf_read >= 40)
{
Audio.buf_read = 0;
// toggle buffer_nr
Audio.buffer_nr = !Audio.buffer_nr;
// set buffer_fill interrupt
TCE1.INTCTRLA = 0b00000010;
}
// set global interrupt
sei();
}
Best wishes from Germany. Rolf
Hallo friends :)
I have change the “optimize” in Atmel Studio 7 from -OS to -O1. The result is a faster code and little more program size. Processor utilization is about 31%
Pic 1: rendering 2x40 osc values and fill buffer in 514 usec with optimize -OS
Pic 2: rendering 2x40 osc values and fill buffer in 308 usec with optimize -O1
yello: 25 microseconds interval for read two samples from buffer and send to the DACs
violet: rendering 2x40 oscillator values and fill buffer
Its very nice :)))
Hi friends..
I have made a little Video of oscillator time for rendering and buffer.
Max time for rendering and save to buffer is 352 usec.
Youtube: https://www.youtube.com/watch?v=...
Regards from germany. Rolf
A second on Cliff's wow and another thank you.
For later development we may need more CPU power, ......
Now.. I use a doublebuffer function to calculate and save values for the oscillator.
Did you evaluate use of DMA?
There is some arbitration through the data bus matrix; that may or may not have an effect.
CPU board schematic :
Do you operate an Atmel-ICE on that?
If yes, your posts' signature, plus the data from a 'winver', would be an excellent post in
https://www.avrfreaks.net/forum/atmel-ice-known-good-computer-and-os
May your copy of Windows 10 Home stay functional for you.
fyi, the following is a very recent creation :
AVR42788: SD Card Bootloader for XMEGA A1U
(file size: 296KB, 11 pages, revision A, updated: 10/2016)This application note describes how to implement SD card bootloader on XMEGA A1U Xplained Pro and how to use it.
via
Some constructive comments; if you are displeased with these comments, let me know.
D5's tolerance may be within the tolerance for the 12Vdc supply.
A common low noise power supply is a 12Vdc automotive battery that's trickle charged; in that case D5 will be hot.
A possible failure case is to somehow connect a 19Vdc notebook PC power adapter to K2.
Recommend re-evaluating D5's breakdown voltage and power dissipation limit.
Recommend a PPTC to limit current after K2 not to prevent circuit destruction but to prevent smoke and/or fire (hazardous substances, safety hazard).
Sometimes a 12Vdc supply is current-limited; sometimes it is not especially as a cheap (iow low quality) AC/DC SMPS degrades then fails in certain ways.
Sometimes one inadvertently creates an accident by dropping a conductor into a powered circuit (a lesson I learned while debugging).
A TE PolyZen is a PPTC plus a zener diode but those are surface mount; a "large" PPTC and a "large" zener diode would be an alternate.
A 1117-type is a follow-on to 7805; a 1117 can withstand some mal-operation.
Did a search at a distributor on replacements for a LM1117; the ST L4940 caught my attention.
The L4940 has good PSRR, is more rugged than a LM1117, and comes in TO-220.
http://www.st.com/content/st_com/en/products/power-management/linear-voltage-regulators/low-dropout-ldo-linear-regulators/ultra-low-dropout-ldo-regulators/l4940.html
Was not impressed with the information in its datasheet.
There are alternatives but I do not have a recommendation.
Likely does not matter if you are not hearing too much noise via the XMEGA DACs.
That can be in a through-hole package instead of a SMD package.
Those are not defects 
You have a good design for it obviously functions well.
Hallo gchapman,
I do not know that DMA would be faster because I send only 2 bytes every 25usec to the DACs ??
Hallo gchapman
I'm programming with an old USB ISP programmer "AVRISP MK2".
Thanks for your tip with sd card and bootloader. It is planned for later.
Hallo gchapman
Thanks for the tips for the power supply. I will consider it in the next version of mainboard pcb :))
Hello..
For samples an 1MB external SRAM is available in the Degenerator. The SRAM is divided into different block sizes. The first memory block (982KB) is reserved for two sample files. The free space for a sample to be loaded decreases depending on the size of the sample being loaded first. The 2nd and 3rd memory blocks are provided for two 32KB waveform banks for oscillator 1 and oscillator 2. When switching to a different waveform bank, the data is loaded from the SD card into the SRAM. The fourth memory block serves as a buffer for the graphic representation of the sample file.
Pic 1: 1MB XRAM in the Degnerator
Pic 2: Osc menu page
This never ceases to amaze me. How are you doing for code space and internal RAM use?
Hi mojo-chan..
Used Flash and Ram in my synthesizer project:
Program Memory Usage : 93808 bytes 67,4 % Full
Data Memory Usage : 4924 bytes 8,6 % Full
Impressively compact code to!
Hello..
In order to bridge the wait for the degenerator, I have uploaded a few current demo sounds from the degenerator on soundcloud.de. The sounds consist of different samples, which are played back via oscillator 1 + 2. LFO1 modulates the delay panorama and osc2. Have fun listening.
Link to sound: https://soundcloud.com/rolf-dege...
Hallo .. halla
My good friend Andre from Oer-Erkenschwick is currently developing the PCB layout for the
Pannelboard. Next week Monday before the holiday is again a team meeting. It will
Predominantly around the housing design and the filter card used. Furthermore, a few
Little things were discussed and the second prototype tested. I for my part have the final
Schematic for the Pannelboard drawn and program still at some trifles rum. To the
In conclusion, the degenerator is still a boot loader to get current firmware via SD card
to load.
Image: Degenerator Pannelboard
Hello..
In order to bridge the wait for the degenerator, I have uploaded a few current demo sounds from the degenerator on soundcloud.de.
The sounds consist of different samples, which are played back via oscillator 1 + 2. LFO1 modulates the delay panorama and osc2.
Have fun listening: https://soundcloud.com/rolf-dege...
Hallo .. halla
My good friend Andre from Oer-Erkenschwick is currently developing the PCB layout for the
Pannelboard. Next week Monday before the holiday is again a team meeting. It will
Predominantly around the housing design and the filter card used. Furthermore, a few
Little things were discussed and the second prototype tested. I for my part have the final
Schematic for the Pannelboard drawn and program still at some trifles rum. To the
In conclusion, the degenerator is still a boot loader to get current firmware via SD card
to load.
Image: Degenerator Pannelboard
I’m still working on the software. For example, the cut and loop function for samples.
By the way, the 8Bit samples in combination with the fixed oscillator waveforms sound totally cool.
Here is a small example: Oscillator1 plays a chorus sample and oscillator2 a sinusoidal waveform with slight frequency offset.
Echo effect also comes from the degenerator. Soundcloud: Choir from Degenerator
Pics: Osc1: choir-samplel and Osc2: spezial sine-waveform
The first 3D case designe of DEGENERATOR...
Wow, sounds very cool!
What a tremendous project!
The case looks awesome!
JC
Hello..
Now .. our filterboard for the DEGENERATOR is now ready. Before it next week to the
Production goes to China, I must still check it today. Then the pannelboard and
Filterboard ordered together. I hope the boards Christmas under the Christmas tree lie smile
To the filterboard: The filter is designed as a two-channel 12dB tifpass / highpass / bandpass filter.
It has an input for the DAC output of the CPU and an external input for one
Audio source.
Filterboard from DEGENERATOR
Greetings from germany. Rolf
Triple WoW!
You and your project are great!
Thank you for sharing it.
Several questions:
1- What are the part number of T9 and T10? as others 2N3906?
2- It's a filter but you've used DIP components. why? wouldn't that be better to use SMD components? it makes your beautiful project more compact and I heared SMD components are better to minimize the effect of noise.
3- Not sure but is the polarity of c10 correct?
4- You have drawn polygon and I think we always connect it to GND. here are the reasons why we do it:
https://en.wikipedia.org/wiki/Ground_plane#Printed_circuit_boards
Now if we assume that e.g. TL072CN has a GND and you have connected it to the GND. (right?) AFA I see you've connected all of the pins of the device to traces, then polygon is not connected to anywhere? is it float?(good word to call it?) am I seeing it correctly? or you've used something like "Star Ground"? although I see nothing about "star Ground" or anything else at your schematic. if you've left the polygon float, why did you do it?
Sorry if my questions are soo primary
Hi Raving Lunatic...
Answer to your questions:
1. T9 and T10 are 2N3904
2. All circuit boards in DE-GENERATOR designed for self-assembly whitout CPU-Board!
3. C10 is not right in old drawing
4. I do not understand what you mean ???
Greetings from germany. Rolf
The PCBs for Filter and Pannelboard have now arrived from China. Now we will solder the PCBs and test them.
Have just looked how many code lines I've already typed for the DE-GENERATOR. Altogether there are already 22460 lines.
Had never been in the 80s as a listing in a computer magazine fit. And if, then you would have had a lot of fun with the
typing and the error search ;)
Code-Listing vom DE-GENERATOR
Greetings Rolf
It's done...
Just before the year change, I can announce that the DE-GENERATOR or the electronics ready
And everything works. The next days and weeks we will still be at the housing and at the Software.
DE-GENERATOR
DE-GENERATOR Prototyp
Hi Raving Lunatic...
...
Just tried to find out what do you mean "Raving Lunatic"? by googling it but didn't find anything.
...4. I do not understand what you mean ???
...
Thank you for answer
I meant have you connected the "Polygon Pour" on your board to anywhere? e.g. GND
Ok, Thank you
But why didn't you connect the "Polygon Pour" to the GND?
A little sound test with sequencer in DE-GENERATOR
https://soundcloud.com/rolf-dege...
Greetings from germany. Rolf
My Lab… The place where DE-GENERATOR was born :)
The first impressions of the DE-GENERATOR
DE-GENERATOR on youtube: https://www.youtube.com/watch?v=...
Hallo again…
There are news again. The second filter board for the DE-GENERATOR is ready.
Its a stereophonic 4-pole Mision filter with the following characteristics:
* Lowpass 6dB * Lowpass 12dB * Lowpass 18dB * Lowpass 24dB * Bandpass 12dB * Highpass 12dB * Lowpass + Highpass 12dB
Pic1: SMR4 Filter from DE-GENERATOR
Pic2: Filter circuit
Pic3: Filter in DE-GENERATOR
Sound test of new Filter: https://www.facebook.com/tubeohm...
The DE-GENERATOR is almost finished
Zum Vergleich noch einmal die alte Elektronik
Arpeggio function
Video: https://www.youtube.com/watch?v=cGDQK6JMPtc&feature=youtu.be
Link: https://soundcloud.com/rolfdegen/shruthidegeneratorinarp2
Greetings from Germany Rolf
The Case..
Big pic: Großes Bild
Big pic: Großes Bild
Big pic: https://plus.google.com/photos/114442997...=CMn31ZGBwbr7Aw
Big Pic: https://plus.google.com/photos/114442997...=CMn31ZGBwbr7Aw
Big pic: https://plus.google.com/photos/114442997...=CMn31ZGBwbr7Aw
Big pic: https://plus.google.com/photos/114442997...=CMn31ZGBwbr7Aw
Big pic: https://plus.google.com/photos/114442997...=CMn31ZGBwbr7Aw
Greetings Rolf
More sounds from DE-GENERATOR...
Video
https://www.facebook.com/tubeohm.tubeohm...89964794421397/
Greetings Rolf
De-Generator changings . Hi Guys , here are news from never ending De-Generator Story. We , Rolf and me realize that the Display we use is – bad . Simply bad but it will be more and more expensive . So i buy a new one from Buydisplay.com and this one works ‘ FANTASTIC ‘ very good quality , good contrast – not to compare with the old one !!! This TFT makes fun . Now the >> BUT !!! Shit is that it is not pin kompatible with the old one . Means that we must make a new Pannel board PCB . The contoller is also not the same . Rolf writes a new driver . Not a big problem .
Than , the new display takes more current and i can’t split the current to digital and LED . All works simply with 3.3 Volt .
Yesterday i measure the temperatue of the LM 7805 with the normal heatsink we use – and in the closed case . 67 degree on 19 degree room temperature – much too hot . Actual i take another heatsink , L-profile 20x20x60 mm. Now the temperature is 55 degree . on 21 degree room temperature !! think this is acceptable. Oh man ey – but – we are now short before end . Stepper and ARP works , Sampling and sample-editor also . Filter is also OK.
This year is definitiv the year of the DE-GENERATOR release.
Panelboard from DE-GENERATOR
Power circuit from DE-GENERATOR
New TFT Display ER-TFTM032-3
Big picture: https://plus.google.com/photos/p...
Code examble for TFT Display
//*************************************************************************
// set xy for TFT (ILI9341 or SSD1289)
//*************************************************************************
void TFT_set_xy(uint16_t x1, uint8_t y1, uint16_t x2, uint8_t y2)
{
// SSD1289 ------------------------------------------------------------
TFT_write_com_data(0x44,(y2 << 8) + y1);
TFT_write_com_data(0x45,x1);
TFT_write_com_data(0x46,x2);
TFT_write_com_data(0x4e,y1);
TFT_write_com_data(0x4f,x1);
TFT_write_com(0x22);
// ILI9341 -----------------------------------------------------------
TFT_write_com(0x2a);
TFT_write_data(x1);
TFT_write_data(x2);
TFT_write_com(0x2b);
TFT_write_data(y1);
TFT_write_data(y2);
TFT_write_com(0x2c);
}
//*************************************************************************
// write command and data (SSD1289)
//*************************************************************************
void TFT_write_com_data(uint8_t addr, uint16_t num)
{
// set Com-Register
LCD_CLR_RS;
// write Addr-Register
VPORT0.OUT = addr;
// WR-Puls
CLR_WR;
SET_WR;
// Set Data-Register
LCD_SET_RS;
// send 16Bit Data
VPORT0.OUT = num >> 8;
SET_LE;
CLR_LE;
VPORT0.OUT = num;
// WR-Puls
CLR_WR;
SET_WR;
}
//*************************************************************************
// write command TFT
//*************************************************************************
void TFT_write_com(uint8_t data)
{
// set Com-Register
LCD_CLR_RS;
// write Addr-Register
VPORT0.OUT = data;
CLR_WR;
SET_WR;
}
//*************************************************************************
// write 16 Bit Data TFT
//*************************************************************************
void TFT_write_data(uint16_t data)
{
// set Data-Register
LCD_SET_RS;
// set high Byte to LCD Port
VPORT0.OUT = data >> 8;
SET_LE;
CLR_LE;
// set low byte to LCD Port
VPORT0.OUT = data;
// wr-puls
CLR_WR;
SET_WR;
}
Greets Rolf from germany :)
Hello dear friends..
I still working diligently. The new TFT display has compared to the old one
Display unfortunately no external connection for the LED background lighting. This is about the
3.3Volt Power supply on the display hardwired. This, however, led to a higher one
Load the 7805 voltage regulator on the motherboard and listen to temperatures in the
Device (> 64C). The heat sink of the 7805 was cooked in a closed cabinet. From this
The 7805 is replaced by a switching regulator.
We have used a DCDC converter TRACO TSR 1-2450. He is not cheap, but has one
High efficiency of 94%. The switching frequency of the converter is 500KHz. An integrated
Filter provides a low output ripple and noise of 50mVp-p. The max. output current is at 1A.
Figure 1: Motherboard with Traco TSR 1-2450 DCDC converter
New Power circuit with Traco 1-2450
More favorable is the R-78W5.0-0.5 from RECOM. The efficiency and output ripple is almost the same.
However, the switching frequency is somewhat lower compared to the Traco controller and is included
330KHz. The max. Output current is 500mA.
In my little toy box I still had a Traco TSR 1-2450 which I immediately in the DE-
ENERATOR. The housing temperature was now below 30C. Ripple and noise at the audio-
Output was less than 5 mVp-p. Since the traco controller is not quite cheap (about 4.42 at Völkner)
We will try the somewhat favorable regulator of RECOM times.
Figure 2: Ripple and noise at the audio output with Traco TSR 1-2450
Greeting Rolf
Temperature measurement with ATxmega
Hello. In the DE-GENERATOR is known as an ATxmega128A1AU (older version) resp
ATxmega128A1U (newer version). Both processors have an internal one at home
Temperature sensor. This sensor can be read out via the ADC registers in the ATxmega.
I have used this to determine how high the approximate housing-
Temperature in the DE-GENERATOR. After a few "complicated" calculations the Tempe-
In the system menu in degrees Celsius.
Figure 1: System menu & ATxmega CPU on the CPU board
Code example from DE-GENERATOR
//*************************************************************************
// init temperature sensor in CPU
//*************************************************************************
void init_temp_sensor(void)
{
// init ADC for CPU temperature measurement ---------------------------
ADCA.CTRLB = ADC_CONMODE_bm | ADC_RESOLUTION_12BIT_gc | ADC_FREERUN_bm;
ADCA.REFCTRL = ADC_REFSEL_INT1V_gc | ADC_TEMPREF_bm;
ADCA.EVCTRL = ADC_SWEEP_0_gc;
ADCA.PRESCALER = ADC_PRESCALER_DIV512_gc;
ADCA.CAL = ADCon.temp_calval;
ADCA.CH0.CTRL = ADC_CH_GAIN_1X_gc | ADC_CH_INPUTMODE_INTERNAL_gc;
ADCA.CH0.MUXCTRL = ADC_CH_MUXINT_TEMP_gc;
ADCA.CTRLA = ADC_ENABLE_bm;
ADCA.CH0.CTRL = ADC_CH_START_bm;
}
//*************************************************************************
// read adc calibrate values
//*************************************************************************
void read_ADC_calval(void)
{
#define ADCACAL0_offset 0x20 // read ADC Calibration Byte 0
#define ADCACAL1_offset 0x21 // read ADC Calibration Byte 1
#define TempCAL0_offset 0x2E // read Temp.Sensor Calibration Byte 0
#define TempCAL1_offset 0x2F // read Temp.Sensor Calibration Byte 1
uint8_t cal_l = read_calibration_byte(PROD_SIGNATURES_START+ADCACAL0_offset);
uint8_t cal_h = read_calibration_byte(PROD_SIGNATURES_START+ADCACAL1_offset);
ADCon.calval = (cal_h << 8) | cal_l;
cal_l = read_calibration_byte(PROD_SIGNATURES_START+TempCAL0_offset);
cal_h = read_calibration_byte(PROD_SIGNATURES_START+TempCAL1_offset);
ADCon.temp_calval = (cal_h << 8) | cal_l;
}
uint8_t read_calibration_byte( uint8_t index )
{
uint8_t result;
/* Load the NVM Command register to read the calibration row. */
NVM_CMD = NVM_CMD_READ_CALIB_ROW_gc;
result = pgm_read_byte(index);
/* Clean up NVM Command register. */
NVM_CMD = NVM_CMD_NO_OPERATION_gc;
return( result );
}
//*********************************************************************
// read case temperature
//*********************************************************************
uint8_t read_temperature(void)
{
uint8_t temp_offset = 15; // CPU temperature offset
uint16_t result_ = ADCA.CH0RES;
uint16_t calval_ = (uint32_t)(ADCon.temp_calval-200)*2048/(4096-200);
uint8_t temperature = (((uint32_t)358*result_)/calval_) - (273+temp_offset);
return ( temperature);
}Initially, the ADC is initialized and the calibration bytes for the temperature sensor are set.
This is followed by the interrogation of the 12-bit wide sensor data in the ADC data register and the
In degrees Celsius. Since the processor actually only measures its core temperature, I have
In my calculation an offset value (-15 degrees) is taken into account and then calculate the approximate enclosure temperature.
Man or woman should note that the first temperature value after the start of the ADC is not a valid measured
value and belongs in the trash ;)
Greeting Rolf
Hi AVR friends..
This is a temperature curve of Atmel Sensor. The real temperature from sensor is 15 degrees too high. But under 50 degrees the measurement is linear.
In my calculation I consider an offset value (CPU temperature offset). This is good enough for the temperature measurement in my synthesizer case. It will not be warmer than 50 degrees.. I hope
uint8_t read_temperature(void)
{
uint8_t temp_offset = 15; // CPU temperature offset
uint16_t result_ = ADCA.CH0RES;
uint16_t calval_ = (uint32_t)(ADCon.temp_calval-200)*2048/(4096-200);
uint8_t temperature = (((uint32_t)358*result_)/calval_) - (273+temp_offset);
return ( temperature);
}
How many of these are you selling by the way?
Not yet sold.. Its a prototyp. The development work is soon finished :)
Hello..
The Xmega128 processors have different temperature characteristics. I have here two CPU-Board with different Xmega MCUs. One with an older typ ATxmega128A1-AU and other with a new ATXMEGA128A1U-AU.
The correction value for the temperature (temp_offset) for older ATxmega128A1-AU is -18 degree and for new ATxmega128A1U-AU is -2 degree. The accuracy of the measured for both processors is + - 1 degrees.
Since we only use the newer type (this is cheaper) I have set the offset value in the Software to a fixed value of 2.
CPU board for the DE-GENERATOR
The Xmega128 processors have different temperature characteristics. I have here two CPU-Board with different Xmega MCUs. One with an older typ ATxmega128A1-AU and other with a new ATXMEGA128A1U-AU.The correction value for the temperature (temp_offset) for older ATxmega128A1-AU is -18 degree and for new ATxmega128A1U-AU is -2 degree. The accuracy of the measured for both processors is + - 1 degrees.
Since we only use the newer type (this is cheaper) I have set the offset value in the Software to a fixed value of 2.
What exactly do you mean by that? Is that after you corrected with the data in the production signature row, or is that wrong? I seem to recall some parts had zeros written in to the calibration values.
