An einer Dokumentation solls nicht scheitern. Sind immerhin schon 12 Blog-Seiten im CC2-Forum mit vielen Informationen die das Thema Synthesizebau und Softwareentwicklung betreffen. Das Ganze könnte sogar für ein Buch ausreichen. Mal schaun was da noch kommen wird. Auf jeden Fall steckt noch eine Menge an Arbeit für die Software drin. Gruß Rolf PS: Bald wirds wieder ein paar "verrückte" Demo-Sounds geben, die ich beim experimentieren mit dem Synth zufällig erzeugt habe. Aber dieses mal in Stereo :)
Rolf Degen schrieb: > Sind immerhin schon 12 > Blog-Seiten im CC2-Forum mit vielen Informationen die das Thema > Synthesizebau und Softwareentwicklung betreffen. Ja, war schon drauf ;-). Rolf Degen schrieb: > Auf jeden > Fall steckt noch eine Menge an Arbeit für die Software drin. Darum lass ich Dich erst mal in Ruhe machen :-P. Vielleicht kann man, wenn das Projekt fundierte Kenntnisse abwirft, mal über die Hardware schauen. Ich denke, dass man den Controller gegen einen neueren XMEGA tauschen sollte und zu den Wandlern / Schnittstellen hätte ich auch noch die eine oder andere Idee. Rolf Degen schrieb: > Bald wirds wieder ein paar "verrückte" Demo-Sounds geben, die ich > beim experimentieren mit dem Synth zufällig erzeugt habe. Aber dieses > mal in Stereo :) Freu mich drauf!
Hallöchen.. Es gibt wieder was neues rund um den AVR-Synthi zu berichten Ich habe das DCO-Menü etwas verändert und hoffe das es jetzt etwas übersichtlicher ist (Bild 1). Die Tune-Funktion für die Oszillatoren wird einen eignen Menü-Seite bekommen. Bild 1: DCO-Menü im AVR-Synthi Bild 2: Auswahl der Wellenform im DCO-Menü Da es ja zwei Oszillatoren im AVR-Synthi gibt, kann man für beide auch auch unterschiedlichen Wellenformen auswählen. Drückt man auf den Button "Wave", dann öffnet sich ein weiters Menüfenster, in dem man die Wellenform für den Oszillator mit dem Encoder oder Bargraph auswählen kann. Die ausgewählte Wellenform wird zusätlich auf dem Display dargestellt (Bild 2). Im neuen DCO-Menü kann für jeden Oszillator auch die Lautstärke von 0-127 eingestellt werden. Ferner können die beiden Oszillatoren entweder als Mono-Summe auf beide DA-Wandler Ausgänge geschaltet werden, oder getrennt auf die zwei DA-Wandler Kanäle für Links und Rechts (Stereo). Heute werde ich auch ein Youtube-Video mit den ersten Stereo-Demo Sounds vom AVR-Synthi hochladen und hier verlinken. So.. hier ist das angekündigte Youtube-Video mit den Stereo Demo Sounds vom AVR-Synthi: http://www.youtube.com/watch?v=B1hQOvVLosQ Bis dann.. Lieben Gruß Rolf
Ich habe bemerkt das der Stereo Demosound im Youtube-Video ein paar Störungen hat. Warscheinlich durch die Videokomprimierung verursacht. Deshalb habe ich den Demosound noch einmal als MP3-File mit 320kBit Auflösung auf SoundCloud hochgeladen. Stereo Demosound https://soundcloud.com/rolfdegen/avr-synthesizer-wave-1-stereo Gruß Rolf
Hallo zusammen Auf der Suche nach einer einfachen und praktischen Speicherlösung für die Wavefiles und Soundparameter in meinem AVR-Synth, bin ich auf das ALFAT-Modul von der Firma GHI-Electronics gestoßen. Bild 1: ALFAT-Modul von GHI-Electronics Mit dem ALFAT-Modul können Daten über die SPI-Schnittstelle des Xmega-Prozessors auf oder von SD & MMC-Karten und USB-Speicher-Laufwerke geladen werden. Die maximale Datenübertragungsgeschwindigkeit wird vom Hersteller mit bis zu 4MBytes pro Sekunde angegeben. ALFAT-Konzep Ein FAT-Dateisystem für eine SD-Card oder USB-Stick benötig auf einem Mikrocontroller wzB dem ATXmega große Ressourcen. Der SoC-Prozessor auf dem ALFAT-Modul ermöglicht einen schnellen und einfachen Speicherzugriff per UART, SPI oder I2C-Schnittstelle und entlastet dadurch den ATXmega-Prozessor im AVR-Synthi. Das ALFAT-Modul unterstützt lange Dateinamen und ist von Microsoft für den gewerb-lichen Einsatz lizensiert. Bild 2: ALFAT-Konzept Einige Features * Built-in 2-port USB Host controller. * FAT16 and FAT32 File system. * No limits on media size, file size or file/folder count. * LFN (Long File Name), licensed by Microsoft. * Friendly user interface through UART,SPI or I2C. * Programmable UART baud-rate. * Up to 8 simultaneous file access. * SD/SDHC card support, no 2GB limit. GHI electronics is an SD association member. *High speed 4-bit SD card interface. * Up to 4000 KBytes/sec file access speed SD cards/USB. * Single 3.3V power source. Gruß Rolf
Hallo Ich habe jetzt das "ALFAT OEM Board" an den AVR-Synthesizer angeschlossen und die ersten Funktionen programmiert wzB die Initialisierung und Formatieren einer SDCARD oder das Auslesen der RealClockTime. Mit dem Auslesen der RCT hatte ich am Anfang allerdings ein Problem, weil der spezielle Uhren-Quarz auf dem ALFAT-Board nicht bestückt war (Absicht oder nicht ?). Ich hatte noch einen in meiner Krabbelkiste und habe diesen auf das Board gelötet. Danach klappte alles einwandfrei. Bild 1: AVR-Synthesizer mit ALFAT OEM Board Das ALFAT-Board benötigt eine Versorgungsspannung von +5V. Intern wird die Spannung für die SDCARD auf 3.3 Volt gewandelt. Die beiden USB-Buchsen liegen an +5Volt . Da das ALFAT-Board die +5 Versorgungs- spannungschiene vom Netzteil etwas mehr belastet, habe ich die Glättungs-Elkos von 470µF auf 2200µF erhöht. Durch die größere Belastung auf der +5Volt Schiene wurde jetzt der Festspannungsregler 7805 etwas heiss. Aus diesem Grund habe ich ihm einen kleinen Kühlkörper spendiert. Die Tage werde ich die Routinen für das Speichern und Laden von Wellenformen programmieren und als Anwendungs- beispiel hier posten. Ich denke, das ist vielleicht auch für andere Anwendungen wzB Datenlooger oder so interessant. Bis dahin lieben Gruß Rolf
Hallo ihr Lieben.. Nach längerer Abwesenheit wegen Krankheit melde ich mich Heute wieder zurück. Ich muss mich leider noch etwas erholen und aus diesem Grund gibt es noch nichts Neues zu berichten. Ich hoffe, das ich bald wieder gesund bin und etwas mehr Zeit habe, um an meinem Projekt weiter zu arbeiten. Aber im Moment hat mir der Arzt viel Bewegung verschrieben und da bleibt leider nicht so viel Zeit für die Computerarbeit. Aber ich versuche trotzdem immer mal wieder etwas zu berichten, damit es hier nicht zu langweilig für euch wird. Bis dahin bleibt gesund und viel Spaß beim stöber hier im Forum. Lieben Gruß Rolf Nachtrag: Gerade im shruthi-Forum (http://www.mutable-instruments.net/forum/) gelesen und vielleicht interessant für euch.. In der Ausgabe 1/2013 "c't Hardware Hacks" (http://shop.heise.de/katalog/ct-hardware-hacks-1-2013) wird der Bau eines "Mini-Synthesizer" mit einem ATMEL-Chip beschrieben. Gruß Rolf
Hallo ihr Lieben.. Gibt wieder einiges neues zu berichten auf meiner Blockseite im CC2-Forum. Da gehts um neue Boards, Soundkarten und Umbau, Cubase und ASIO-Latenz und Drehencoder. Wenn Ihr Lust habt, dann schaut doch einfach mal hier vorbei: http://www.cczwei-forum.de/cc2/thread.php?postid=80909#post80909 Gruß Rolf
Hallo zusammen Ich möchte euch den ersten Gehäuse-Entwurf für mein Synthesizer "WAVE 1" vorstellen. Die Idee stammt von Wolfgang (alias Wiesolator) aus dem CC2-Forum. Grundlage ist ein Alugehäuse der Firma BOPLA (Bild 2). Die gelbe Frontplatte lasse ich von der Firma Schaeffer herstellen. Die zwei Gehäuseseitenteile werden aus Holz sein. Die Idee für die zusätzlichen Regler (Edit) hatte Wolfgang. Für Live-Aktionen können die Regler mit einer Funktion belegt werden. Was in dem Entwurf noch fehlt, sind Volume-Regler für den Kopfhöreranschluss und SD-Card Beschriftung (oben). Gruß Rolf
Hallo zusammen.. Hier eine kleine Vorstellung meiner MiniScope-Funktion im AVR-Synthesizer: Youtube-Video: http://www.youtube.com/watch?v=4O1XCRsIUDQ
Hallo Mein Scope im AVR-Synthesizer besitzt jetzt eine TimeBase- und Trigger-Funktion Youtube-Video: Scope-Funktion: http://www.youtube.com/watch?v=B0ticWx_BFo Gruß Rolf
Hallo ihr da.. Hab mal wieder etwas an meinem Synth gebastelt bzw programmiert und herausgekommen ist eine neue Menü-Seite für die Modulation-Matrix (Bild 1). Links kann man eine Modulations-Quelle zB LFO1 auswählen und Rechts sieht man dann die Modulations Ziele für LFO1 mit den eingestellten Depth-Werten. Da es sich beim "WAVE 1" um einen "Echten" Stereo Synthesizer handelt, gibt es für den linken und rechten Kanal getrennte Modulations-Ziele zB VCF1 und VCF2. Einige Modulations-Ziele wzB PAN, FM and Noisgenerator fehlen allerdings noch. Bild 1: Modulations-Matrix im AVR-Synthesizer Meine Projekt-Seite: http://www.cczwei-forum.de/cc2/thread.php?threadid=5878&threadview=0&hilight=&hilightuser=0&page=15 Mein Youtube-Kanal: http://www.youtube.com/user/rolfdegen1806 Grüße Rolf
Hallo ihr Lieben.. Heute Morgen will ich wie gewohnt etwas an meinem Synthesizer Projekt arbeiten und starte dafür Atmel Studio 6.1. Morgens hat man ja meistens die beste Phase für gute Ideen und Gedanken. Aber dann erlebe ich eine Überraschung die mich echt umgehauen hat. Beim compilieren meines Projekt-Files zeigt mit Atmel Studio plötzlich 7791 Fehler an. Ups.. was ist das denn ?? Gewohnt bin ich ja ab und zu so ein paar blöde Syntax-Fehler die man so aus Flüchtigkeit beim programmieren macht wzB das vergessen einer Geschweiften Klammer am Ende einer Funktion, oder oft ein vergessenes Semikolon am Ende einer Anweisung. Aber 7791 Fehler. Ne.. das is doch a bissel viel Nach langem Suchen und vielem hin und her wollte ich schon aufgeben und da kam mir der Zufall zur Hilfe. Im ASF Wizard von Atmel Studio 6.1 kann man die ASF-Module Version upgraden. Der Eintrag stand bei mir auf 3.5.0. Ich habe ihn auf die letzte Version 3.9.1 gestellt und konnte mein Projekt jetzt ohne Fehler compilieren. Bild 1: Atmel Studio 6.1 ASF Wizard Wieso der Fehler Heute Morgen aufgetreten ist und nicht schon Gestern Nacht, als ich das letzte mal mein Projekt compeliert habe, das bleibt mir ein Rätsel. Auf jeden Fall bin ich froh das es wieder funktioniert. Mein Fazit: Ich mach jetzt jeden Tag ein Backup auf einer externen Festplatte. Gruß Rolf
ATMEL-Studio ist immer für Überraschungen gut. Mein Kollege flucht auch öfter. Da ich in ASM programmiere, bleibe ich weitgehend verschont ;-). Manchmal ist Fortschritt nicht auf Anhieb zu verstehen...
Hallo Knut Schön von dir zu hören. Mit der Zeit hat man ja so seine Erfahrungen mit ATMEL STUDIO gemacht und kann damit umgehen. Mein Projekt ist mittlerweile schon sehr groß geworden. Bin gerade dabei, das ATMEL Xplained-Board (http://www.watterott.com/de/Atmel-UC3-A3-Xplained-AT32UC3A3-XPLD) durch ein Breakout-Board mit einem ATXmega128A1 (http://mikrocontroller-praxis.de/de/Development-Tools/AVR-Mikrocontroller-Module/XMega100-Breakout.html) zu ersetzen, damit ein Nachbau günstiger wird. Auf dem Xplained-Board gabs viele Dinge die ich für mein Synthesizer-Projekt nicht benötigte und einige Ports waren nicht zugänglich. Dies ist mit dem Xmega Breakout-Board jetzt kein Problem mehr. Ein preisgünstiges SD/MICRO-SD CARD BREAKOUT MODULE (http://mikrocontroller-praxis.de/de/Development-Tools/SD/MICRO-SD-CARD/SD/MICRO-SD-CARD-BREAKOUT-MODULE.html) habe ich ebenfalls bestellt. Hatte davor eine teures SDCARD-Modul von ALFAT (https://www.ghielectronics.com/catalog/product/337) mit USB geplant. Aber das ist mit über 50,- Euro doch sehr teuer. Das Display teure Touch-Display wurde ebenfalls ersetzt gegen ein preisgünstiges DOGXL160 Display. Damit wird der Synth im Nachbau etwas günstiger. Überlege noch wegen den verwendeten Filter-IC SSM2044, ob ich diese nicht gegen eine günstige Filterschaltung mit OTAS vom Typ LM13700 ersetzen soll. Aber vorerst bleib ich bei den SSM2044. Gruß Rolf
Einen wunderschönen, sonnigen und guten Montag Morgen wünsch ich Euch allen :) Hier ein paar Bildchen von meinem Synth-Gehäuse. Bin gerade dabei das Frontpanel für die Frontplatte zu löten. Aber sieht schon nicht schlecht aus find ich.. :) Bilder: AVR-Synthesizer Gehäuse Gruß Rolf
Hallo again.. ich schon wieder smile Damit man einen kleinen Eindruck gewinnt, wie der Synthesizer später einmal aussehen wird, hab ich mal eine Fotomontage gemacht. Ist mir nicht so gut gelungen, bin aber auch kein "gut bezahlter" Grafiker smile Bild 1: Synthesizer "WAVE 1"
Hallo Für den Xmega-Prozessor in meinem Synthesizer plane ich noch eine Speichererweiterung von 512KByte SRAM. Das SRAM gibt es als Breakout Board auf eBay schon ab 7,99 US $. Dann hätte ich die Möglichkeit, beim Systemstart die Soundparameter und großen Wellenform Dateien von der SDCard in das SRAM zu laden. Angebunden wird das SRAM an den EBI-Bus (Port H-K) des Xmega. Mit dem Xmega kann ich wesentlich schneller auf Wellenform Daten und Soundparameter zugreifen als über die SDCard. Die SDCARD dient dann lediglich als externer Datenspeicher. Bild 1: IS62WV51216BLL SRAM Board Bild 2: EBI Port Xmega
Hallöchen.. Ich habe gerade festgestellt, das auf dem bestellten SRAM-Board (IS62WV51216BLL SRAM Board) ein 16Bit SRAM sitzt und nicht wie gedacht um ein 8Bit Typ. Das freut mich doch sehr, da es insgesammt 1MByte Speicherplatz sind. Wow.. smile Die Adressierung mit dem Xmega ist allerdings etwas tricki. Um das SRAM zu adressieren sind zwei Stück 8-BIT D-LATCH Typ 74HC573 für die Bereitstellung der höheren Adressleitungen von A8-A18 notwendig. Zusätzlich ist für die vollen 16Bit Nutzung des SRAMs eine freie Adressleitungen (zB A19) notwendig, die auf den "LB" Anschluss (LowerByte) und über einen Inverter an "UB" Anschluss SRAM zu legen ist. Bild 1: Xmega EBI-Interface Bild 2: SRAM IS62WV51216BLL-55TLI Gruß Rolf
Hallo ihr Lieben.. Die VCA-Page in meinem Synth ist jetzt fertig (siehe Bilder). Mit der Taste "Function" kann man auf der VCA-Page zwischen den Einstellungen für die Lautstärke und Balance umschalten. Die rechteckigen Symbole für Osc und Noise werden entsprechend der Balance-Einstellung wie bei einem analogen Fader nach oben oder unten verschoben. Softwaretechnisch ware es nicht ganz leicht (zumindes für mich Augenzwinkern ) die Volume- und Balance-Funktionen für Oszillator und Rauschgenerator umzusetzen. Ein Teil der Funktionen (Berechnung Lautstärkeverhältnis Linker und Rechter Audiokanal) wurde in der Menüsteuerung, die komplett in C geschrieben ist, umgesetzt (siehe C-Code). Ein anderer Teil dieser Funktion wurde in die Assembler Routinen für die Soundausgabe integriert (siehe unten). Im Anhang zwei Bilder von der VCA-Page und Code-Beispiel. Gruß Rolf
Hallöchen.. Habe mit großartiger Unterstützung von Andre (tubeohm.com) nun einen neuen Stereo Audio-Filter für meinen Synth gebaut. Im Vergleich zum alten Filter mit den SSM2044 IC klingt der neue Filter im Bass- und Hochtonbereich sehr ausgewogen. Hier meine Stereo Filter Demo: http://www.youtube.com/watch?v=fyGdspVTL8c Was noch fehlt ist die Auswahl von verschiedenen Filterkombinationen zB. LP+LP zu einem 4pol LP Filter mit 24dB pro Oktave (mono) oder HP+HP, LP+HP oder BP+BP. Bild 1: Stereo Filter Hardware Bild 2: Vorläufiges Schaltbild eines Filterkanals Gruß Rolf
Happy Halloween :) Noch rechtzeitig zu Halloween hier ein paar Geistersounds aus meinem AVR Synthesizer. Dank der neuen Modulation Matrix in meinem Synth, sind ein paar irre Sounds entstanden. Viel Spaß beim anhören. https://soundcloud.com/rolfdegen/halloween-sound
Hallo zusammen.. Es hat sich wieder was getan in meinem Synthesizer. Die Envelope Pages haben eine Realtime-Anzeiger für den Verlauf der Hüllkurve (ADSR) erhalten. Die Anzeige (kleines schwarzes Fenster) befindet sich oben Rechts und ist mit Env gekennzeichnet. Wird zB eine Noten Taste am Keyboard gedrückt, erscheint der Verlauf der ADSR-Hüllkurve vom AMP Env in Echtzeit in dem kleinen schwarzen Fenster. Bild 1: Hüllkurvenverlauf Die Modulations Matrix ist fast fertig. Mit "Source" wird der Modulator zB LFO1 ausgewählt. Mit "Destin." (Destination) das Modulations Ziel zB Osc1. Mit "Depth" wird die Modulationhöhe eingestellt. Um eine bessere Übersicht über die zur Zeit aktiven Modulatoren zu haben, habe ich diese mit einem Stern Symbol gekennzeichnet. Nicht aktive Mudulatoren haben keinen Stern. Die Verknüpfung der Modulatoren mit dem Ziel erfolgt immer additativ. Wenn zB LFO1 und LFO3 auf das gleiche Modulationziel zB Osc1 geschaltet werden, wirkt die Summe beider Modulationssignale auf den Modulationseingang von Osc1. Bild 2: Modulations Matrix Der Synthesizer besitzt jetzt außer dem AMP Env und Filter Env noch zwei weitere freie Envelope Generatoren (Env3+4). Diese besitzen eine eigene Menü-Page mit den gleichen Parametereinstellungen wie der AMP Env und Filter Env und sind für Modulationszwecke vorgesehen. Gruß Rolf
Hallo Leute Ich habe Probleme mit EBI Interface auf meinem ATxmega128A1 (siehe Bild). Ich verwende ein 512KB SRAM und einen ATMEL Xmega128A1 (Rev H) im EBI-Modus. Die höheren Adress-Bits A16-18 an Port H funktionieren nicht korrekt. Die Adressbits A0-A15 funktionieren ohne Problem. Das Speichern und Lesen von 64KB SRAM Daten ist kein Problem. Aber oberhalb des 64KB Adressraums werden die Adressleitungen A16-A18 (CS0-CS2) vom EBI Interface nicht richtig angesteuert. Die Adressleitungen A16-A18 sind bei jedem Schreibsignal (WR-Signal low aktive) immer auf high Pegel. Bild 1: SRAM Anbindung an Xmega128A1 Bild 2: EBI-Port Konfiguration Mein Code:
1 | //----------------------------------------------------
|
2 | // init extern 512KB SRAM
|
3 | // ---------------------------------------------------
|
4 | void init_sram(void) |
5 | {
|
6 | // Set signals which are active-low to high value
|
7 | PORTH.OUT = 0xFF; |
8 | |
9 | // Configure bus pins as outputs(except for data lines). */
|
10 | PORTH.DIR = 0xFF; |
11 | PORTK.DIR = 0xFF; |
12 | |
13 | // init EBI 3PORT/AL1/CS3 (A16-19)
|
14 | EBI.CTRL |= EBI_SRMODE_ALE1_gc; |
15 | EBI.CTRL |= EBI_IFMODE_3PORT_gc; |
16 | |
17 | EBI.CS3.CTRLA |= EBI_CS_MODE_SRAM_gc; |
18 | EBI.CS3.CTRLA |= EBI_CS_ASIZE_16M_gc; |
19 | EBI.CS3.BASEADDR = 0x00; |
20 | EBI.CS3.CTRLB |= EBI_CS_SRWS_2CLK_gc; // EBI time |
21 | }
|
22 | |
23 | //----------------------------------------------------
|
24 | // write sram
|
25 | // ---------------------------------------------------
|
26 | void wr_sram(void) |
27 | {
|
28 | uint32_t start_adr = 0x4000; // init Startadr. over 16KB SRAM space in Xmega128A1 |
29 | uint8_t data = 0; |
30 | for (uint32_t i = 0; i < 0x80000; i++) |
31 | {
|
32 | hugemem_write8(start_adr + i, data); |
33 | data++; |
34 | }
|
35 | }
|
Im Voraus vielen Dank für eure Hilfe. Schöne Grüße aus Wuppertal. Rolf
Hallo liebe Mitleser.. Mit Hilfe des ATMEL Support Team konnte ich mein Problem jetzt lösen. Leider funktioniert der schnellere EBI-Mode mit nur einem Adresslatch im ATxmega128A1-AU nicht. Diese Version des Prozessor ist leider schon etwas älter und Fehler wurden nur noch in den neuen Version wzB dem ATxmega128A1U behoben. Das U in der Bezeichnung steht für ein zusätzliches USB-Interface im Prozessor. Um die Kompatibilität und die Verwendung beide Prozessoren im Synthesizer zu gewährleisten, habe ich einen EBI-Mode mit zwei Adresslatch für das SRAM ausgewählt. Dieser funktioniert mit beiden Prozessoren fehlerfrei, ist aber im Zugriff auf das SRAM um 2 Takte langsamer (siehe EBI-Timing). Bild 1: EBI Interface mit zwei Adresslatch Bild 2: EBI Timing Um die Ansteuerung des 512KB SRAM zu testen, habe ich ein Beispiel (EBI SRAM Example - STK600 ATxmega128A1) aus dem ATMEL Studio 6.1 geladen. Das ATMEL AVR STK600 ist ein Starter-Kit und Entwicklungs-System für AVR 8-Bit bis 32-Bit ATMEL Mikrocontroller. Das Beispiele funktioniert aber auch mit einem ATxmega ohne Entwicklungsboard. Wichtig ist dann aber, das der Prozessortakt beim Systemstart richtig eingestellt wird (siehe init_clock im Beispiel Code). Bild 3: SRAM Example Project from ASF Beispiel Code für 512KB SRAM:
1 | /*
|
2 | * Include header files for all drivers that have been imported from
|
3 | * Atmel Software Framework (ASF).
|
4 | */
|
5 | #include <asf.h> |
6 | #include <hugemem.h> |
7 | #include <ebi.h> |
8 | |
9 | //*************************************************************************
|
10 | //
|
11 | // init CPU Clock 32Mhz (ext. Clock 16MHz)
|
12 | //
|
13 | //*************************************************************************
|
14 | void init_clock(void) |
15 | {
|
16 | |
17 | // set startuptime for extern Crystal Oscillator
|
18 | OSC_XOSCCTRL = OSC_XOSCSEL_XTAL_16KCLK_gc | OSC_FRQRANGE_12TO16_gc; |
19 | |
20 | // enable ext. 16MHz Crystal Oscillator
|
21 | OSC.CTRL = OSC_XOSCEN_bm; |
22 | |
23 | // wait oscillator is stable
|
24 | while(!(OSC.STATUS & OSC_XOSCRDY_bm)); |
25 | |
26 | // set PLL 16MHz * 2
|
27 | OSC.PLLCTRL = OSC_PLLSRC_XOSC_gc | 0x02; |
28 | |
29 | // enable PLL
|
30 | OSC.CTRL |= OSC_PLLEN_bm; |
31 | |
32 | // wait PLL is stable
|
33 | while(!(OSC.STATUS & OSC_PLLRDY_bm)); |
34 | |
35 | // protect I/O register
|
36 | CCP = CCP_IOREG_gc; |
37 | |
38 | // enable PLL-Clock
|
39 | CLK.CTRL = CLK_SCLKSEL_PLL_gc; |
40 | }
|
41 | |
42 | |
43 | static struct ebi_cs_config cs_config; |
44 | |
45 | //-------------------------
|
46 | // init EBI for 512KB SRAM
|
47 | //-------------------------
|
48 | void init_sram(void) |
49 | {
|
50 | // Set signals which are active-low to high value
|
51 | PORTH.OUT = 0xFF; |
52 | |
53 | // Configure bus pins as outputs(except for data lines). */
|
54 | PORTH.DIR = 0xFF; |
55 | PORTK.DIR = 0xFF; |
56 | |
57 | ebi_setup_port(18, 2, 0, EBI_PORT_SRAM | EBI_PORT_3PORT |
58 | | EBI_PORT_CS0); |
59 | ebi_cs_set_mode(&cs_config, EBI_CS_MODE_SRAM_gc); |
60 | ebi_cs_set_address_size(&cs_config, EBI_CS_ASPACE_512KB_gc); |
61 | ebi_cs_set_base_address(&cs_config, BOARD_EBI_SRAM_BASE); |
62 | ebi_cs_set_sram_wait_states(&cs_config, EBI_CS_SRWS_1CLK_gc); |
63 | ebi_cs_write_config(3, &cs_config); |
64 | ebi_enable_cs(3, &cs_config); |
65 | }
|
66 | |
67 | //----------------------------------------------------
|
68 | // write sram
|
69 | // ---------------------------------------------------
|
70 | void wr_sram(void) |
71 | {
|
72 | hugemem_ptr_t p; |
73 | uint32_t base = BOARD_EBI_SRAM_BASE; |
74 | uint_fast8_t data = 0; |
75 | uint32_t offset = 0x00; |
76 | p=(hugemem_ptr_t)((uint32_t)base + offset); |
77 | |
78 | for (uint32_t i = 0; i < 0x80000; i++) |
79 | {
|
80 | if (i== 0x12345) |
81 | {
|
82 | hugemem_write8(p+i, 0x55); |
83 | }
|
84 | else
|
85 | {
|
86 | hugemem_write8(p+i, data); |
87 | |
88 | }
|
89 | data++; |
90 | }
|
91 | }
|
92 | |
93 | //----------------------------------------------------
|
94 | // write sram
|
95 | // ---------------------------------------------------
|
96 | void rd_sram(void) |
97 | {
|
98 | hugemem_ptr_t p; |
99 | uint32_t base = BOARD_EBI_SRAM_BASE; |
100 | uint_fast8_t data1 = 0; |
101 | uint_fast8_t data2 = 0; |
102 | uint32_t offset = 0x00; |
103 | p=(hugemem_ptr_t)((uint32_t)base + offset); |
104 | |
105 | for (uint32_t i = 0; i < 0x80000; i++) |
106 | {
|
107 | data1 = hugemem_read8(p+i); |
108 | if (i==0x12345) |
109 | {
|
110 | if (data1 != 0x55) |
111 | {
|
112 | Led1_on; |
113 | }
|
114 | }
|
115 | |
116 | else
|
117 | {
|
118 | if (data1 != data2) |
119 | {
|
120 | Led1_on; |
121 | }
|
122 | |
123 | }
|
124 | data2++; |
125 | |
126 | }
|
127 | }
|
conf_board.h:
1 | /**
|
2 | * \file
|
3 | *
|
4 | * \brief User board configuration template
|
5 | *
|
6 | */
|
7 | |
8 | #ifndef CONF_BOARD_H
|
9 | #define CONF_BOARD_H
|
10 | |
11 | |
12 | //! State that huge memory access (beyond 64k RAM) should be enabled
|
13 | #define CONFIG_HAVE_HUGEMEM
|
14 | |
15 | //! Base address of SRAM on board
|
16 | #define BOARD_EBI_SRAM_BASE 0x800000UL
|
17 | |
18 | //! Size of SRAM on board, given in bytes: 1 Mb / 128 kB
|
19 | #define BOARD_EBI_SRAM_SIZE 0x80000UL
|
20 | |
21 | #endif // CONF_BOARD_H
|
PS: Empfehlenswert ist es, bei Neuentwicklungen den neusten ATxmega128A1U Chip zu verwenden, da der alte ATxmega128A1 einige Bugs hat. Leider sitzt auf vielen der angeboten Xmega Developementboards noch der alte ATxmega128A1-AU drauf. Gruß Rolf
Hallöchen.. Es geht langsam vorran. Momentan habe ich wieder etwas mehr Zeit für mein Projekt. Das 512KB große SRAM soll als Wellenformspeicher im Synthesizer dienen. Da das SRAM einen 16Bit breiten Datenbus besitzt und das Speicher-Interface (EBI) des Xmegas nur einen 8Bit Datenbus hat, kann man eigentlich nur die Hälfte der SRAM Kapazität mit den Datenleitung von D0-D7 nutzen. Aber mit einer kleinen Trickschaltung lässt sich auch die andere Hälfte nutzen. Dafür besitzt das SRAM zwei Anschlüsse mit der Bezeichnung "LB" (Lower-Byte) und "UB" (Upper-Byte). Wird "LB" auf Low Pegel geschaltet, dann werden die Ein- oder Ausgänge für das Lower-Byte auf die Datenleitung D0-D7 geschaltet. Die Datenleitung D8-D15 wird zum gleichen Zeitpunkt hochohmig. Das gleiche geschieht mit dem "UB" Anschluss. Wird "UB" low, dann wird D8-D15 auf die Datenleitungen geschaltet und D0-D7 sind hochohmig. Durch diese Art der Ansteuerung kann man problemlos die Datenleitungen D0-D7 und D8-D15 am SRAM parallel schalten. Für die Umschaltung von Lower-Byte auf Upper-Byte sorgt die Adressleitung A19 am Pin 16 von IC4 und das Nandgatter IC5. Im Adressbereich von 0x00000 - 0x7FFFF (0 - 524.287) wird jetzt das Lower-Byte im SRAM benutzt und im Adressbereich von 0x80000 - 0xFFFFF (524.288 - 1.048.575) das Upper-Byte. Damit ergibt sich eine Speicherkapazität von 2*512KB = 1MByte. Bild 1: 512KB-SRAM am Xmega Bild 2: SRAM Pinout Bild 3: SRAM Funktionsblock Bild 4: 512x16 SRAM Steckboard Das SRAM gibts in SMD Bauform aufgelötet auf einem Steckboard mit einer Power-LED für knapp 6,- Euro plus Versand bei Waveshare Electronics oder ebay: http://www.wvshare.com/product/IS62WV51216BLL-SRAM-Board.htm Gruß Rolf
Hallöchen.. Hier eine kleine Klangkostprobe aus meinem Synthesizer: https://soundcloud.com/rolfdegen/wavedemo-01 Die Wavesounds habe ich in Audacity monophon aufgenommen und als RAW-File im 8Bit/16KHz Format exportiert. Über die SDCard habe dann das Wavefile in meinem Synth eingelesen. Die Zwei Oszillatoren habe ich gegeneinander etwas verstimmt um einen räumlichen Klang zu erzeugen. Die Sounds werden noch ohne Loops abgespielt, da ich diese Funktion zur Zeit programmiere. Gruß Rolf
Hallöchen.. Obwohl Weihnachten vor der Tür steht und noch so viele Dinge zu tun sind (wir wollen am 24. eine kleine Weihnachtsparty geben), habe ich noch etwas Zeit gefunden an meinem Synthesizer zu arbeiten. Wie in meinem letzten Beitrag schon erzählt, programmiere ich gerade an einem simplen Wave Editor in meinem Synthesizer. Zur Zeit können nur Loop-Punkte für die Wiedergabe der Wavefiles gesetzt werden. Später werden noch mehr Funktionen folgen. Man glaubt gar nicht, wieviel Entwicklungsarbeit hinter so simplen Funktionen wie zB einer Cursorsteuerung für ein Grafikdisplay stecken und die Auswahl eines Loop-Pointers für die Wellenform. Es reicht leider nicht aus, eine einfach senkrechte Linie für den Cursor auf dem Display zu zeichnen. Bevor das geschieht, muss als erstes der Bildschirmhintergrund gerettet werden, damit beim späteren Ändern der Cursorposition der alte Hintergrund (Wellenform) wieder restauriert werden kann. Bild: Wave-Editor Youtube:http://www.youtube.com/watch?v=DceCkckwcMI&feature=youtu.be Viel Gedankenschweiß hat mich auch die Zoom-Funktion für die Darstellung der Wellenform gekostet. Wenn man bei einer kleineren Auflösung der Wellenform zB nur jeden 10.Sample darstellt, dann enstehen große Lücken in der Amplitudenabbildung der Wellenform und somit auch eine fehlerhafte Darstellung auf dem Display. Das könnte man sicherlich in "Hoher Mathematik" lösen, aber Rechenzeit auf dem Xmega-Prozessor ist kostbar. Also habe ich nach einer anderen Lösung gesucht. Nach etlichen Überlegungen und viel Gedankenschweiß bin ich mit Hilfe von "Audacity" (Audioeditor) auf eine annehmbare Lösung gestoßen. Mal angenommen der 1.Sample hätte einen Amplitudenwert von 10, der 2. von 255, der 10. von 18. Dann würde bei einer Sampleabtastung von nur jedem 10.Samplewert der 2. Wert (255) mit der höchten Amplitude und der Rest bis 10 fehlen. Also liegt es doch nahe, aus der Gruppe von den 10 Samples nur diesen zu nehmen, der die höchsten Amplitude hat. Und genau das ist die Lösung. Die Abbildung entspricht jetzt einer Hüllkurve dieser Wellenform. Gruß Rolf
:
Bearbeitet durch User
@Rolf Sehr schön gemacht. Sieht ja mittlerweile sehr ansehnlich aus dein Synthesizer. Schick schick. Aber wieso musst du vorher den Bildschirm sichern beim Cursorverschieben ? Wenn du doch eine invertierte vertikale Linie zeichnest und vor dem verschieben bzw bevor du deine Darstellung und/oder den Cursor änderst einfach die vertikale Linie erneut invertieren hast du doch wieder den Ausgangsbildschirm nur ohne Cursor Linie, oder ? Das mit der höchsten Amplitude bzw dem 'zusammenfassen' von Samples hab ich auch mal so gemacht. Geht ganz gut und erspart einem jede Menge Rechenzeit. Gerade wenn man 'nur' auf einem AVR hantiert muß man ja so einige Kniffe parat haben damit sich das ganze a) noch halbwegs bedienen lässt und b) der AVR nicht nur mit der Darstellung ausgelastet ist, sondern seine 'Hauptaufgaben' auch noch wahrnehmen kann. Weiter so, und schonmal nen frohes Fest und viel Spaß noch beim Basteln :-)
Hallo Rene Schön von dir zu hören :) Das DOGXL 160-7 Display besitzt leider keinen internen Speicher. Aus diesem Grund muss ich die Pixel, die der Cursor überschreibt, für eine spätere Wiederherstellung vorher sichern. Gruß Rolf und Frohes Fest
:
Bearbeitet durch User
Wünsche Allen ein schönes Weihnachtsfest und guten Rutsch ins neue Jahr. Ein großes Dankeschön auch an die Macher und Admins des mikrocontroller Forums :)
Die Loop Funktion im Synthesizer Mein Synthesizer ist jetzt mit einem 1MByte großen Wellenform Ram ausgestattet. Dadurch lassen sich auch sehr große Samples abspielen. Aber nur das einfache Abspielen eines Samples im Synthesizer und die Steuerung der Abspielgeschwindigkeit (Tonhöhe) wäre musikalisch gesehen etwas zu langweilig. Aus diesem Grund hat man das "Loopen" erfunden. Es handelt sich dabei um das wiederholte Abspielen eines bestimmten Sample Bereiches. Als es noch keine Sample-Player gab, hat man ein an beiden Enden zusammengeklebtes Stück eines Tonbandes genommen und wiederholt abgespielt. Eine ähnliche Technik ist im Jahre 1963 im Mellotron, dem Vorläufer des modernen Samplers angewendet worden. Die Loop-Funktion für die Samples habe ich in einer Unterseite des Osc-Menüs integriert und kann über die Funktionstaste am Synthesizer aufgerufen werden. Ob ein Menü eine Unterseiten besitzt, sieht man an einem kleinen eingeblendeten Symbol (Fensterrahmen mit Pfeil) oben rechts neben der Seitennummer. An einer Funktion zum Laden verschiedener Wellenform-Files wird noch gearbeitet. Um die Bedienung für die Loop Einstellung zu vereinfachen, habe ich die Cursorsteuerung über drei Encoder realisiert. Mit dem 1. Encoder steuer man den Cursor über die Wellenform. Befindet sich der Cursor jeweils am linken oder rechten Rand, dann wird automatisch der Wellenformauschnitt verschoben. Der 2. Encoder ist für die Zoom Funktion zuständig. Gezoomt wird immer an der aktuellen Cursor Position und in Bildschirmmitte. Mit dem 3. und 4. Encoder lässt sich der Loop-Anfang (LoopA) und das Loop-Ende (LoopB) einstellen. Zur Veranschaulichung habe ich ein Video auf Youtube hochgeladen. Youtube: http://www.youtube.com/watch?v=Y-alU-4saMI Bis zum nächsten mal und lieben Gruß. Rolf
Hallo zusammen. Ich wünsche allen ein schönes und interessantes neues Jahr 2014 Zur Zeit arbeite ich an einer Soundverwaltung für meinen Synthesizer. Für die Datenspeicherung benutze ich eine handelsübliche 4Giga Byte große SDCard, auf der maximal 12800 Sounds verwaltet werden können. Von der SD Karte werden alle Soundparameter, Wellenformen und Samples in den Synthesizer geladen.Es ist schon erstaunlich, wenn man die Synthesizer und Sampler aus den 80er Jahren mit der heutigen Technologie vergleicht. Das Laden von Wellenformen und Samples dauerte damals je nach Datengröße schon mal etwas länger und nebenbei hatte man noch Zeit für eine Tasse Kaffee (siehe Video). Bevorzugte und preiswerte Speichermedien für die Synthis und Sampler waren damals 5.25 Zoll oder 3.5 Zoll Disketten. Die größeren und teuren Systeme hatte sogar schon Festplatten mit einer "sagenhaften" Kapazität von 10MByte. Die heutige Speichertechnologie ist im Vergleich dazu in astronomischer Größe gewachsen und auch wesentlich schneller und einfacher in ihrer Handhabung geworden. Eine Speichergröße von 64Giga Byte auf einer winzigen SD Karte wäre zur damaligen Zeit undenkbar gewesen. Bild 1: PPG WAVETERM aus den 80er Jahren Youtube: http://www.youtube.com/watch?v=q88NovUIPQM Ich habe versucht, das Laden und Abspeichern von Sounddateien in meinem Synthesizer etwas zu vereinfachen. Dafür habe ich eine einfache Datenstruktur mit drei Hauptordnern auf der SD Karte entwickelt (siehe Bild). Im Ordner "Sound" befinden sich 100 Sound Bänk. Jede Soundbank enthält die Klangparameter für 128 Sounds. Pro Sound sind 256 Byte für die Klangparameter reserviert, das macht insgesamt pro Soundbank also 256*128 = 32KByte an Daten. Der Ordner "WAVE" beinhaltet alle Wellenformen für die Klangsynthese wzB Sinus, Rechteck, Sägezähn uvm. Der Ordner "Sample" beinhaltet, wie der Name schon sagt, alle ladbaren Samples. Maximal können in 100 Sample Bänken mit jeweils 128 Samples verwaltet werden. Das gleiche gilt natürlich auch für den Wellenform Ordner. Wellenformen und Samples können in der jetzigen Softwareversion im Synthesizer nur geladen werden. Erstellen kann man diese aber ohne große Probleme mit dem Audioeditor "Audacity" unter Windows und auf die SD Karte kopieren. So ist dem Klangbastler kaum eine Grenze gesetzt. Bild 2: Datenstruktur auf der SD Karte für meinen Synthesizer (Kleiner Fehler in der Zeichnung: sollten 100 statt 99 Bänke sein). Bild 3-4: Datei Menü in meinem Synthesizer Bild 5: SD Karte Interface in meinem Synthesizer Wave1Disk.jpg Wer sich näher mit der Benutzung einer SD Karte für ein eigenes Projekt mit einem Mikrocontroller wzB ATmega oder Arduino beschäftigen möchte hier ein paar nützliche Links: http://www.ulrichradig.de/home/index.php/avr/mmc-sd http://www.mikrocontroller.net/articles/AVR_FAT32 http://arduino.cc/de/Reference/SDCardNotes Bis zum nächsten Mal und lieben Gruß. Rolf
Hallöchen.. GIF-Format hochladen. Siehe Bildformate. Text: Zur Zeit wird mal wieder viel gelötet, gezeichnet und es werden Stücklisten geschrieben. Eine kleine Änderung gibts in der VCA Schaltung. Diese hat eine Lautstärkeregelung bekommen. Bild1: VCA Schaltung mit Lautstärkeregelung Die Stromversorgung für den Synth wurde ebenfalls etwas abgeändert und auf "Low cost" getrimmt. Ein AC-Netzteil mit 9 Volt/1000mA wird benötigt. Bild2: Stromversorgung für den Synth Ich bin gerade dabei das endgültige Layout für meinen Synthesizers auf einer Lochrasterplatte zu löten und dann ein PCB Board zu entwerfen. Dabei spielt die Positionierung der Bauteile eine wichtige Rolle. Die Platine habe ich in zwei Hälften unterteilt. Auf der linken Seite ist der ganze Analoge Teil wzB Stromversorung und der analoge Multimode Filter untergebracht. Auf der rechten Seite der komplette Digitalteil wzB Prozessor, Ram und SD-Karte. Das soll den Störeinfluss der Digitalschaltung auf die analoge Filterschaltung vermindern. Die Position des SD-Karteneinschubs habe ich zwecks besserer Bedienbarkeit nach vorne an die Gerätefront verlegt. Bild3-7: Prototyp Synthesizer "WAVE 1" Die Filterschaltung ist noch nicht ganz bestückt. Im Moment arbeite ich daran. Bis zum nächsten mal. Lieben Gruß aus Wuppertal smile
:
Bearbeitet durch User
Hallo ihr Lieben.. Die vergangenen Tage hatte ich im Mutable Intruments Forum viele Ideen und Anregungen für die Filterschaltung in meinem Synthesizer erhalten. Da war u.a. auch die Rede von einer Distortion Schaltung (Verzerrer) oder einer Delay Schaltung für Echo und Hall. Beides sehr interessante Dinge, die den Filter auf jeden Fall noch interessanter machen könnten. Die Distortion Schaltung habe ich dank zur Verfügung stehender Bauteil schnell aufgebaut und getestet. Für die Delay Schaltung ist der Schaltungsaufwand etwas größer. Ich musste erst ein spezielles Bauteil, einen PT2399, bestellen. Bei dem PT2399 handelt es sich um einen Audio Prozessor mit Echo Funktionen. Der Stückpreis liegt bei 1,50€. Bild 1: Filter Schaltung mit Distortion Funktionsbeschreibung Distortion Schaltung Das Eingangssignal wird über den Spannungsteiler R30 und R31 an den OTA geführt. Der Operationsverstärker IC 5B und die beiden Transistoren sind als Spannungsbegrenzer (Limitter) geschaltet und begrenzen die maximale Ausgangsspannung des Operationsverstärkers auf ca 1.0 Volt (VPP). IC 5C hat die Aufgabe das Signal zu verstärken. Über den Trimmer R28b wird die Ausgangsspannung am Operationverstärker IC 5B so eingestellt, das im Ruhezustand (Steuereingang 0V) das Ausgangssignal unterhalb der Spannungsbegenzung von 1.0 Volt liegt. Über den Steuereingang an R28 kann jetzt die Verstärkung im OTA IC3B bzw die Verzerrung am Ausgang stufenlos geregelt werden und. Bild 2-4: Signalkurven Distortion (unterer Oscilloskop Kanal ohne Distortion) Sound Demo Distortion: https://soundcloud.com/rolfdegen/distortion Youtube Video Sparta Delay: http://www.youtube.com/watch?v=hjWpkibWL3k#t=78 Gruß Rolf
Hallöchen.. Gestern habe ich meine bestellten Bauteile im Briefkasten gefunden. Schnell die Delay Schaltung aufgebaut und getestet. Das Ergebnis gibts auf Soundcloud :) Bild 1: Delay Schaltung für meinen Synthesizer Delay Demo: https://soundcloud.com/rolfdegen/sample-with-delay-from-my-diy
Lieber Rolf, ich danke Dir sehr, dass Du uns an Deinen Erfolgen teilhaben lässt! Ich habe vor 25 Jahren ähnliches versucht, bin aber bei weitem nicht so weit gekommen. Damals wusste ich einfach noch zu wenig. Die Möglichkeit zum Austausch mit anderen Gleichgesinnten war gleich null. Description The MAXIM MAX260/MAX261/MAX262 CMOS dual second-order universal switched-capacitor active filters allow microprocessor control of precise filter functions. No external components are required for a variety of bandpass, lowpass, highpass, notch, and allpass configurations. Each device contains two second-order filter sections that place center frequency, Q, and filter operating mode under programmed control. Mit dem MAX260 hatte ich es probiert. Schon damals habe ich von Klängen geträumt, wie Du sie jetzt erzeugen kannst.
Hier das Innenleben des PT2399 Delay Chip und mein MCU Board vom Synthesizer. Bildquelle von Wolfgang aus dem CC2 Forum alias Wiesolator. Gruß Rolf
:
Bearbeitet durch User
Zur Zeit arbeite ich noch ein wenig an dem Filter im Synthesizer. Die Delay Schaltung hat jetzt einen Panorama Regler erhalten. Es wird zusätzlich noch einen analogen Stereoeingang für den Filter geben. So lassen sich dann auch externe Audiosignale über den Filter und das Delay dazu mischen. Die Distortion Schaltung mußte aus Platzmangel für die Delay Schaltung weichen. Kleine Klangkostprobe aud Soundcloud: https://soundcloud.com/rolfdegen/delay-sound-08 Gruß Rolf
:
Bearbeitet durch User
Hallöchen.. Hier gibts schon vorab die ganzen Schaltpläne für mein Synthesizer Projekt. Kann man sich als Eagle oder JPG File herunterladen. Download: https://onedrive.live.com/?cid=ebf4191b1e6970c0&id=EBF4191B1E6970C0%212280&ithint=file,.rar Gruß Rolf
Hallöchen.. Es gibt wieder viel Neues von meinem DIY Synthesizer zu berichten. Ich bin gerade dabei einen Programmabschnitt zu programmieren, der es ermöglicht, eine 16Bit WAVE-Datei von der SD Karte in den Synthesizer zu laden und dann als 8Bit Sample abzuspielen. Eigentlich ist eine WAVE-Datei ganz simpel aufgebaut. Am Anfang der WAVE-Datei ist ein Haeder bestehend aus 44 Byte, in dem z.B. das Format, Bitbreite und Samplerate gespeichert sind. Diese Header-Daten werden vom Synthesizer im Moment noch ignoriert. Nach den Header-Daten folgen die eigentlichen Sample-Daten. Diese sind bei einer 8Bit Wave-Datei vorzeichenlos (unsigned). Bei 16Bit bestehen sie aus 2Byte mit Vorzeichen. Das erste Byte ist das Low-Byte gefolgt vom High-Byte mit Vorzeichen. Um aus den 16Bit jetzt ein Vorzeichenloses Byte für den Synthesizer zu generieren reicht es aus, das Low-Byte einfach fallen zu lassen und das High-Byte mit 128 zu addieren. Das WAVE Format (Bild 1).
1 | // set folder ---------------------------------------------------------
|
2 | uint8_t error_status = 0; |
3 | ffcd(""); |
4 | ffcd("SAMPLE");ffcd(foldername); |
5 | |
6 | // open file ----------------------------------------------------------
|
7 | if( MMC_FILE_OPENED == ffopen(sample_name,'r')) |
8 | {
|
9 | uint32_t file_len = file.length; |
10 | // set baseaddress sram
|
11 | hugemem_ptr_t p; |
12 | uint32_t base = BOARD_EBI_SRAM_BASE; // 0x800000UL |
13 | uint_fast8_t data = 0; |
14 | uint32_t offset = 0x00000; |
15 | p=(hugemem_ptr_t)((uint32_t)base + offset); |
16 | uint8_t sample; |
17 | |
18 | // load WAVE-File 16Bit signed Little-endian / Low-byte first -----
|
19 | // Sample-Bank 01-99
|
20 | |
21 | // skip Header from WAVE-File
|
22 | for (uint8_t i = 0; i < 44; i++) |
23 | {
|
24 | sample = ffread(); |
25 | }
|
26 | |
27 | file_len = ((file_len - 44) / 2); |
28 | |
29 | |
30 | for (uint32_t i = 0; i < file_len; i++) |
31 | {
|
32 | sample = ffread(); // load L-Byte and ignore |
33 | sample = ffread(); // load H-Byte |
34 | sample = sample + 128; // convert in unsigned 8Bit |
35 | hugemem_write8(p+i, sample); // write Sample in SRAM |
36 | }
|
Gruß Rolf
Bisher war es in meinem Synthesizer nur möglich Wave-Dateien in Mono zu laden. Ich möchte dieses Wochenende nutzen, um auch Stereo Dateien in meinen Synth zu laden. Ferner möchte ich die Auflösung von 8Bit auf 12Bit erhöhen. Das entspricht der maximalen Auflösung der DA-Wandler im Xmega Chip. Im Header einer Wave-Datei sind zB. auf Adresse 0x16 die Informationen über die Anzahl der Kanäle gespeichert. Bei Mono hat die Adresse 0x16 den Wert 1 und bei Stereo den Wert 2. Bedeutung der Daten im Riff Header (Bild 1) Aus dem Mutable-Forum (http://mutable-instruments.net/forum/) habe ich einen guten Tip erhalten, wie ich das 8Bit Rauschen (Quantisierungsfehler) bei der DA-Wandlung per Software etwas reduzieren kann. Diese Funktion nennt sich "noise shaping" und verschiebt das Bitrauschen bei leisen Pegeln in einen höheren Frequenzbereich, so das es vom Ohr nicht mehr so laut wahrgenommen wird (siehe Bild). Frequenzgang 8Bit Rauschen (Bild 2)
1 | // skip Header from WAVE-File
|
2 | for (uint8_t i = 0; i < 44; i++) |
3 | {
|
4 | sample = ffread(); |
5 | }
|
6 | |
7 | // calculate data length
|
8 | file_len = ((file_len - 44) / 2); |
9 | |
10 | uint8_t quantization_error; |
11 | int16_t signed_sample_16; |
12 | uint8_t sample_l; |
13 | uint8_t sample_h; |
14 | |
15 | for (uint32_t i = 0; i < file_len; i++) |
16 | {
|
17 | // load 16Bit sample-data
|
18 | sample_l = ffread(); // load L-Byte |
19 | sample_h = ffread(); // load H-Byte |
20 | |
21 | // convert to signed 16Bit
|
22 | signed_sample_16 = (((int16_t)sample_h)<<8 | sample_l); |
23 | |
24 | // calculate data for noise-shaping
|
25 | int32_t sample_16 = (int32_t)(signed_sample_16); |
26 | sample_16 += quantization_error; |
27 | if (sample_16 < -32768){sample_16 = 32768;} |
28 | else if (sample_16 > 32767){sample_16 = 32767;} |
29 | int8_t sample_8 = sample_16 >> 8; |
30 | quantization_error = sample_16 - ((int32_t)(sample_8) << 8); |
31 | |
32 | // convert to unsigned 8Bit
|
33 | sample_8 = sample_8 + 128; |
34 | |
35 | // write to 1MByte SRAM
|
36 | hugemem_write8(p+i, sample_8); |
37 | }
|
Hier ein kleines Soundbeispiel für die Rauschreduzierung mit und ohne Noise Shaping: https://soundcloud.com/rolf-degen/noise-shaping-2 Gruß Rolf 1.Sample mit Noise Shaping und 2.Sample ohne Noise Shaping
Hallöchen.. Um die Kosten für einen Bausatz zu senken, will ich mal schaun ob ein anderes LC-Display wzB das SSD1289 von sainsmart am Synth funktioniert. Es handelt sich hierbei um ein 3.2" großes Farb LCD das mit einen Straßenpreis von 7-15 Euro fast überall erhältlich ist. SainSmart 3.2" Color LCD 320x240 Pixel (Bild 1) Aber hier mein erster Entwurf für das GUI mit dem neuen Display. Da es nur im 16Bit Modus angesteuert werden kann, musste ich die Portleitungen auf dem MCU-Board etwas umbelegen. Das Display wird jetzt über einen 16Bit Datenbus angesteuert, was den Vorteil hat, das es wesentlich schneller die Grafik aufbaut als beim alten Display. Erster GUI Entwurf auf dem LCD (Bild 2) Schaltbild vom MCU Board (Bild 3) Im Anhang die C-Routinen zum Ansteuern des SainSmart 3.2" LCD (SSD1289). Gruß Rolf
:
Bearbeitet durch User
Hallöchen.. Eine kleines Problem das vlt. mit ein wenig Mathematik (ohne Fließkomma) gelöst werden kann ? Ich möchte die 128 Positionen der weiße Markierung auf dem Encoder-Drehknopf berechnen und auf dem LCD neu zeichnen. Ohne Berechnung würde eine Wertetabelle für jede der 128 Positionen des Drehknopfes für die X- und Y-Position wertvollen Speicherplatz verschwenden. Vielleicht gibts ja eine mathematische Lösung. Weiße Markierung auf dem Drehknopf (Bild 1) Ich habs mal wieder geschafft Dank Oliver vom "Mutable Forum" (http://mutable-instruments.net/). Wie bei vielen komplizierten Dingen hat mich das ein wenig Ehrgeiz und Gedankenschweiß gekostet ;) Im Anhang der C-Code, Sinus Tabelle und die Bitmap vom Knopf. Kleines Youtube Video mit der Knop Demo: https://www.youtube.com/watch?v=hqgHXLH7daI&feature=youtu.be
:
Bearbeitet durch User
Ein roter Knopf in Aktion Youtube: https://www.youtube.com/watch?v=Juv843YsqZY&feature=youtu.be Gruß Rolf
Hallöchen.. Kleiner Zwischenstand meiner Entwicklungsarbeit am Synth. Hab gerade die LFO1-Menu Page neue entworfen. Mit dem Regler "Wave" kann man jetzt eine LFO Wellenform selektieren. Bild: LFO1 Menu Page Gruß Rolf
Hallo Rolf, komme auf diese Info aufgrund deines Betrags vom 26.01.2013 bzgl. der Verwendung des "ALFAT OEM Board". Am 10.07.2013 informierst du uns allerdings darüber, das Board jetzt doch nicht mehr verwenden zu wollen weil zu teuer für dein Projekt. Vorher hattest du geschrieben, bereits erste SW für das o.a. Board erstellt zu haben. Da ich ggf. das ALFAT Produkt für eine Logger-Funktionalität an einem sehr kleinen uC nutzen will, wäre mir mit deiner "alten" SW evtl. im ersten Schritt weitergeholfen. Soll ich dir ein PN schreiben oder wie komme ich an deine "alte" SW ran? Nochwas: Dein (neuer) Downloadlink vom 01.06.2014 (ondrive Link) schein nicht (mehr?) zu funktionieren. Gruss
Hallo Erich Für das ALFAT SD Board habe ich leider keinen Quellcode mehr gefunden. Hab den vermutlich gelöscht als ich mich entschieden habe, die SD Karte direkt am XMega Prozessor zu betreiben. Bei ALFAT gibts aber Code Beispiele zum Download: https://www.ghielectronics.com/downloads/ALFAT/ALFAT_SoC_Processor_User_Manual.pdf Hab dir mal Code Beispiele von ALFAT hochgeladen. Code-Beispiele: https://onedrive.live.com/?cid=EBF4191B1E6970C0&id=EBF4191B1E6970C0%212594 Gruß Rolf
Hallöchen.. Bei der Ansteuerung des neuen LCD ist mir aufgefallen, das man die Übetragungsgeschwindigkeit mit der die Daten vom Xmega Prozessor zum LCD gesendet werden noch optimieren kann. Jeder Port des ATxmega kann als virtuelles Portregister konfiguriert werden. Hat man einen virtuellen Port konfiguriert, können bei diesem die selben Pinkonfigurationen wie bei normalen Ports vorgenommen werden. Insgesamt stellt der Xmega 4 dieser Register zur Verfügung. Durch die Verwendung eines virtuellen Ports erfolgt die Übertragen eines Datenbytes innerhalb eines Taktzyklus von 32nsec bei 32MHz Systemtakt. Ein Standart Portzugriff dauert im Vergleich dazu doppelt so lang also 64nsec. Virtuelle Port Konfiguration
1 | // Standart Zugriff auf PortA benötigt 2 Taktzyklen
|
2 | PORTA.DIR = 0xFF; // Datenrichtung auf Ausgang |
3 | PORTA.OUT = 0xFF; // PortA auf hight |
4 | |
5 | // Virtueller Zugriff auf VPORT0 (PortA) (benötigt 1 Taktzyklus)
|
6 | PORTCFG.VPCTRLA |= PORTCFG_VP0MAP_PORTA_gc; // lege PortA auf Virtuellen VPort0 |
7 | VPORT0.DIR |= 0xFF; // Datenrichtung auf Ausgang |
8 | VPORT0.OUT = 0xFF; // VPort0 auf hight |
Eine weitere Möglichkeit die Übertragungsgeschwindigkeit zu erhöhen ist die, den Prozessortakt des Xmega von 32MHz auf 48MHz zu erhöhen. Der Xmega arbeitet dann zwar außerhalb seiner Herstellerspezifikation, aber das scheint den Xmega Prozessor nicht weiter zu stören, denn er zeigte in meinen ganzen Tests keine Ausfallerscheinung. Erhöhte Temperatur konnte ich auch nicht feststellen. Werde den 48MHz Takt aber noch einmal bei einer anderen Produktcharge des Xmegas testen, bevor ich das implementiere. Xmega Takteinstellung 48MHz (ext. 16MHz Quarz)
1 | void init_clock(void) |
2 | {
|
3 | // set startuptime for extern Crystal Oscillator
|
4 | OSC_XOSCCTRL = OSC_XOSCSEL_XTAL_16KCLK_gc | OSC_FRQRANGE_12TO16_gc; |
5 | |
6 | // enable ext. 16MHz Crystal Oscillator
|
7 | OSC.CTRL |= OSC_XOSCEN_bm; |
8 | |
9 | // wait oscillator is stable
|
10 | while(!(OSC.STATUS & OSC_XOSCRDY_bm)); |
11 | |
12 | // set PLL 16MHz * 2
|
13 | OSC.PLLCTRL = OSC_PLLSRC_XOSC_gc | 0x03; // 0x02 = 32MHz, 0x03 = 48MHz |
14 | |
15 | // enable PLL
|
16 | OSC.CTRL |= OSC_PLLEN_bm; |
17 | |
18 | // wait PLL is stable
|
19 | while(!(OSC.STATUS & OSC_PLLRDY_bm)); |
20 | |
21 | // protect I/O register
|
22 | CCP = CCP_IOREG_gc; |
23 | |
24 | // enable PLL-Clock
|
25 | CLK.CTRL = CLK_SCLKSEL_PLL_gc; |
26 | |
27 | // Peripheral Clock output: Disabled
|
28 | PORTCFG.CLKEVOUT=(PORTCFG.CLKEVOUT & (~PORTCFG_CLKOUT_gm)) | |
29 | PORTCFG_CLKOUT_OFF_gc; |
30 | }
|
Gruß Rolf
:
Bearbeitet durch User
Hallo.. Ich bräuchte mal einen Tip. Wie kann ich das Phasen Jitter (siehe Bild ca. 3Khz) in meinem Synthesizer verringern. Für die Klangerzeugung benutze ich die DDS Synthese. Das Phasen Jitter beträgt in allen erzeugten Frequenzen 25usec. Das entspricht genau der Abtastrate im Synthesizer. Code Beispiel DDS-Synthese in meinem Synth
1 | //————————————————————————————————————-
|
2 | // load phase register all 25usec (40KHz Sample Frequence)
|
3 | //————————————————————————————————————-
|
4 | LoadPhaccu1: |
5 | LDS phakku0, phaccu1+0 ; (R26) load 32Bit Phaseaccu |
6 | LDS phakku1, phaccu1+1 ; (R27) |
7 | LDS phakku2, phaccu1+2 ; (R28) |
8 | LDS phakku3, phaccu1+3 ; (R29) |
9 | |
10 | //————————————————————————————————————-
|
11 | // Load 256 Byte Sample from 1MB XRAM Addr. 0x0000
|
12 | //————————————————————————————————————-
|
13 | Osc1Sample: |
14 | MOV R30, phakku3 // set XRAM address (is H-Byte Address from Phaseaccu) |
15 | LDI R31, 0x00 |
16 | LDI R21, 0x00 |
17 | LDI R22, 0x80 // load AddressOffset 0x80 (is necessary for addressing the XRAMs in xmega) |
18 | ADD R21, R22 // add |
19 | OUT 0x3B, R21 // set XRAM Address to EBI Port |
20 | LD R1, Z // load 8Bit Sample from XRAM in R16 |
21 | OUT 0x3B, R1 // special EBI command |
22 | |
23 | //————————————————————————————————————-
|
24 | // inc Phaseaccu OSC1 (32Bit)
|
25 | // ————————————————————————————————————
|
26 | LDS pha_inc0, phaccu_stepsize1+0 ; load 24 Bit PhaseIncrement |
27 | LDS pha_inc1, phaccu_stepsize1+1 |
28 | LDS pha_inc2, phaccu_stepsize1+2 |
29 | |
30 | ADD phakku0, pha_inc0 ; add PhaseIncrement |
31 | ADC phakku1, pha_inc1 |
32 | ADC phakku2, pha_inc2 |
33 | LDI R2, 0x00 |
34 | ADC phakku3, R2 |
35 | |
36 | //————————————————————————————————————-
|
37 | // save Phaseaccu
|
38 | // ————————————————————————————————————
|
39 | STS phaccu1+0, phakku0 ; save Phaseaccu |
40 | STS phaccu1+1, phakku1 |
41 | STS phaccu1+2, phakku2 |
42 | STS phaccu1+3, phakku3 |
43 | |
44 | //————————————————————————————————————-
|
45 | // Other functions for sound calculation (sample is present in r1)
|
46 | // ————————————————————————————————————
|
47 | ...
|
Interessantes Problem. Ich habe für meinen Rechteckgeneratoren für die AY-3-8910 Emulatoren eine Art Interpolation eingebaut. Dadurch hört sich der Rechteck schon viel besser an. Ohne Interpolation stört das Jitter schon stark, besonders bei höheren Frequenzen. Dieses Verfahren habe ich z.B. hier verwendet: http://www.youtube.com/watch?v=8IbIF8ySEHA&list=UU4Awd2MW09pjAJPmH1fSTgw& oder hier: http://www.youtube.com/watch?feature=player_detailpage&list=UU4Awd2MW09pjAJPmH1fSTgw&v=pL8v8zhmBoA Man muss bedenken, dass man eigentlich nicht wirklich ein Rechtecksignal hören kann da dass Ohr sozusagen ein Tiefpass ist. (und der NF-Verstärker natürlich auch) Man muss also ein Tiefpassgefiltertes Rechtecksignal erzeugen. Dann hat sich auch das Jitterproblem erledigt. Das ist die 'bandlimited square wave generation'. Habe ich bisher noch nicht angewendet. Aber schonmal eingearbeitet ;)
:
Bearbeitet durch User
Danke für die Info. Ich versuche mal die Interpolation in den Assembler Code einzubinden. Bandlimited Wellenformen habe ich schon implimentiert. Klingen auch ganz gut. Der Jitter ist mein Hauptproblem. Gruß Rolf
Hallo Steffen Das ist mein ASM Code Beispiel nach einer Idee von Oliver aus dem Mutable Forum:
1 | //-------------------------------------------------------------------------
|
2 | // Load Sample Osc1 from 1MB XRAM Addr. 0x0000
|
3 | //-------------------------------------------------------------------------
|
4 | Osc1Sample: |
5 | mov r30, phakku3 // load H-Byte Phaseaccu (is same Address vor XRAM) |
6 | ldi r31, 0x00 |
7 | ldi r21, 0x00 |
8 | ldi r22, 0x80 // load Adress Offset (XRAM) |
9 | add r21, r22 // and add with XRAM Offset Address in R18 |
10 | out 0x3b, r21 // set XRAM Address to EBI Port |
11 | ld r16, Z // load first Sample from XRAM |
12 | ld r17, Z+ // load secound Sample from XRAM |
13 | out 0x3B, r1 // special EBI command |
14 | |
15 | mov r0, r16 |
16 | mov r1, r17 |
17 | |
18 | // oliver
|
19 | mul phakku2, r1 // mul L-Byte Phakku mit r1 |
20 | movw R30, r0 |
21 | com phakku2 |
22 | mul phakku2, r0 |
23 | add r30, r0 |
24 | adc r31, r1 |
25 | eor r1, r1 |
Das 16Bit Ergebnis soll in R30+31 stehn. Leider funktionierts irgendwie nicht. Die Routine gibt nur Müll aus. Im Anhang die Interpolationsroutine von Oliver
1 | static inline uint8_t InterpolateSampleRam( |
2 | const uint8_t* table, |
3 | uint16_t phase) { |
4 | uint8_t result; |
5 | uint8_t work; |
6 | asm( |
7 | "movw r30, %A2" "\n\t" // copy base address to r30:r31 |
8 | "add r30, %B3" "\n\t" // increment table address by phaseH |
9 | "adc r31, r1" "\n\t" // just carry |
10 | "mov %1, %A3" "\n\t" // move phaseL to working register |
11 | "ld %0, z+" "\n\t" // load sample[n] |
12 | "ld r1, z+" "\n\t" // load sample[n+1] |
13 | |
14 | "mul %1, r1" "\n\t" // multiply second sample by phaseL |
15 | "movw r30, r0" "\n\t" // result to accumulator |
16 | "com %1" "\n\t" // 255 - phaseL -> phaseL |
17 | "mul %1, %0" "\n\t" // multiply first sample by phaseL |
18 | "add r30, r0" "\n\t" // accumulate L |
19 | "adc r31, r1" "\n\t" // accumulate H |
20 | "eor r1, r1" "\n\t" // reset r1 after multiplication |
21 | "mov %0, r31" "\n\t" // use sum H as output |
22 | : "=r" (result), "=r" (work) |
23 | : "r" (table), "r" (phase) |
24 | : "r30", "r31" |
25 | );
|
26 | return result; |
Gruß Rolf
:
Bearbeitet durch User
Meine Interpolation ist für die direkte Erzeugung einer Rechteckschwingung gedacht. Also ohne Wavetable. Es ist einfach nur ein Register (v). Das höchstwertige oder ein höheres Bit (hier &H1000000) gibt das Rechtecksignal an. Es wird je nach Freq immer ein bestimmter Wert (incr) addiert. Durch die Interpolation werden die Flanken "weicher" da diese zwischen den 2 Rechteckamplituden liegen. Warum dein Code nicht funktioniert kann ich nicht sagen, das musst du selber rausfinden (kenne AVR nicht besonders gut). In vb.net mache ich das so:
1 | vtmp = v + incr |
2 | If v And &H1000000 Then |
3 | sample = 1 |
4 | Else |
5 | sample = -1 |
6 | End If |
7 | |
8 | If (v Xor vtmp) And &H1000000 Then ' edge changed |
9 | c = 1 - 2 * (vtmp And &HFFFFFF) / incr |
10 | sample = sample * c |
11 | End If |
Rolf Degen schrieb: > Eine weitere Möglichkeit die Übertragungsgeschwindigkeit zu erhöhen ist > die, den Prozessortakt des Xmega von 32MHz auf 48MHz zu erhöhen. Der > Xmega arbeitet dann zwar außerhalb seiner Herstellerspezifikation, aber > das scheint den Xmega Prozessor nicht weiter zu stören, denn er zeigte > in meinen ganzen Tests keine Ausfallerscheinung. Erhöhte Temperatur > konnte ich auch nicht feststellen. Werde den 48MHz Takt aber noch einmal > bei einer anderen Produktcharge des Xmegas testen, bevor ich das > implementiere. Das funktioniert nur mit den uralten XMEGA_A1, Revision G und früher, sowie dann wieder mit den A1U und den anderen USB-XMEGAs. Revision H des A1 lief bei mir nur bis 40Mhz, dann war Schluss. Hatte ich damals mit meinem SD-Karten-Wave-Recorder getestet.
Hallo Knut Die Übertrakung war nur so eine Idee, die bei meinem Alten Xmega128A1 auch funktioniert. Wollte nur mal wissen, ob andere Komponenten das so mitmachen. Die SD Karte SD Karten (4GB Class4) hatten keine Probleme beim Lesen. Schreibfunktion konnte ich nicht testen.Fürs LCD waren die Ansteuersignale schon zu kurz. Aber wie gesagt, war nur so ein Test :) Gruß Rolf
Hallöchen.. Das Beispiel Programm funktioniert. Um zwei Bytes für die Interpolation hintereinander zu laden kann man gewöhnlich Z+ (ld first_sample, Z+) für die Adressierung des nächsten Samples benutzen. Dann würde aber die Adresse 0x100 am XRAM (externes 1MByte SRAM) anliegen und nicht 0x001. Aus diesem Grund wird die Adresse des Phasenaccu inc und erneut in das Adressregister für das XRAM geschrieben.
1 | //-------------------------------------------------------------------------
|
2 | // Load 1.Sample from 1MB XRAM Addr. (sample size is 256 Byte)
|
3 | //-------------------------------------------------------------------------
|
4 | sample1 = 16 |
5 | |
6 | mov r30, phakku2 // load Phaseaccu (is same Address vor XRAM) |
7 | ldi r31, 0x00 |
8 | ldi r21, 0x00 |
9 | ldi r22, 0x80 // load Adress Offset (XRAM) |
10 | add r21, r22 // and add with XRAM Offset Address in R18 |
11 | out 0x3b, r21 // set XRAM Address to EBI Port |
12 | ld sample1, Z // load Sample from XRAM |
13 | out 0x3B, r1 // special EBI command |
14 | |
15 | //-------------------------------------------------------------------------
|
16 | // Load 2.Sample from 1MB XRAM Addr.+1
|
17 | //-------------------------------------------------------------------------
|
18 | sample2 = 17 |
19 | inc r30 // inc Phaseaccu |
20 | out 0x3b, r21 // set XRAM Address to EBI Port |
21 | ld sample2, Z // load Sample from XRAM |
22 | out 0x3B, r1 // special EBI command |
23 | |
24 | //-------------------------------------------------------------------------
|
25 | // Interpolation
|
26 | //-------------------------------------------------------------------------
|
27 | mul phakku1, sample2 |
28 | movw R30, r0 |
29 | com phakku1 |
30 | mul phakku1, sample1 |
31 | add r30, r0 |
32 | adc r31, r1 |
33 | eor r1, r1 |
34 | mov sample1, r31 // 8Bit Result in sample1 |
Gruß Rolf
:
Bearbeitet durch User
Beispiel im Bild für die Interpolation in meinem Synth. Obere Signalkuve ist interpoliert und die untere nicht. Youtube: https://www.youtube.com/watch?v=L_BU1DcWZU8&feature=youtu.be Das Ergebnis hört sich schon viel besser an :) Für die Wellenformen Rechteck und Sägezahn werde ich Bandlimited Waves verwenden. Gruß Rolf
:
Bearbeitet durch User
Hallöli.. oder so :nihao: Ich hoffe euch allen gehts gut. Der Name "DIYWA" für meinen Synthesizer gefällt mir. Die ersten drei Buchstaben "DIY" für Do It Yourself und "WA" für Wave. Klingt auch irgendwie cool :supi: Heute habe ich mich etwas mit der Grafik für das TFT Display beschäftigt. Für die Wellenformdarstellung bzw Scope-Funktion wollte ich dicke Linien zeichnen. Die Standart Liniebreite von einem Pixel kann man bei größerer Entfernung nicht mehr genau erkennen. Zuerst hatte ich versucht, zwei Linien mit einer Verschiebung von einem Pixel in X und Y Richtung zu zeichnen. Mit dem Ergebnis war ich aber nicht sonderlich zufrieden. Die beiden Linien liefen an manchen Stellen etwas auseinander (Bild 1). Dann kam mir aber der richtige Gedanke. Ich hatte mal gelesen, das Grafikkarten im PC Dreiecke benutzen um Geometrische Formen oder andere Dinge zu zeichnen. Also habe ich meine Routine fürs Zeichenen einer dicken Linie etwas abgeändert. Statt nur einen Pixel an der X- und Y-Koordinate zu zeichnen habe ich drei Pixel mit einem Verstatz von +1 Pixel an die X- und Y-Koordinate gezeichnet. Bild 1: Linie mit 2 Pixel 1. Pixel auf X und Y 2. Pixel auf X+1 und Y+1 Bild 2: Linie mit drei Pixel 1. Pixel auf X und Y 2. Pixel auf X+1 und Y 3. Pixel auf X und Y+1 Gruß Rolf
Hallo Leute von Heute smile Ich verwende das 3.2' TFT von SainSmart mit SSD1289 in meinem Synthesizer Projekt. Die Ansteuerung und Initialisierung sowie Grafik und Textausgabe funktionieren mit der Eingebunden Library wunderbar und problemlos. Jetz möchte ich aber ein digitalisiertes Audio-Signal als Wellenform in einem Gitterraster wie zB auf einem Oszilloskop darstellen. Der Display-Controller SSD1289 bietet dafür die Möglichkeit zwei Windowsbereiche zu definieren und irgendwie übereinander zu legen (Picture in Picture Mode). Das 1.Windows wäre dann mein Raster und das 2.Windows wäre meine digitalisierte Audio-Wellenform. Leider schaffe ich es nicht, beide Windows übereinander zu legen und gleichzeitig darzustellen. Hab diverse Register-Settings ausprobiert, aber keine funktionierte. Bild 1: Register-Settings im SSD1289 Controller Im Bild 1 ein Auszug aus dem Manuel des Controllers SSD1289 in Bezug auf den Picture in Picture Modus. Vielleicht hat jemand eine Idee. Bild 2: MiniScope im "DIYWA 1" Aktuell verwende ich einen Windowsbereich im Ram des Displays. Darin werden Raster und Wellenform immer wieder neu gezeichnet was viel Zeit kostet (siehe Video). Youtube: https://www.youtube.com/watch?v=cNkAbWzbGfE&feature=youtu.be Vielen Dank für Eure Hilfe. Gruß Rolf
Es gibt einen neuen DIY Synthesizer namens "Groovesizer TB2". The TB2 is a 4 note paraphonic wavetable synth with (digital) filter, envelope and LFO. In addition to the built-in wave shapes (sine, triangle, saw, square, noise), additional wave shapes can be loaded from SD card. For sound generation, it makes use of the two 12-bit DACs built into the Due’s ATSAM3X8E processor (output is mono in the current configuration, but stereo operation is also possible). The TB2 will be available in kit form (ETA December 2014). Bild 1: Der "Groovesizer" Youtube: https://www.youtube.com/watch?v=8N2JAbtbiMk&feature=youtube_gdata_player Gruß Rolf
Hallo ihr Lieben.. Habe heute die Envelope Menüseiten fertig gestellt. Rechts ist ein kleines Fenster in dem in Echtzeit die Envelope Kurve gezeichnet wird, wenn eine Midi-Note empfangen wird. Bild 1: Envelope Page Grüße Rolf
Hallo Freunde.. Mich beschäftigt schon seit längerer Zeit ein Problem mit dem digitalen ADSR Generator in meinem Synthesizer. Wenn ich in meinem monophonen Synthesizer zwei Midi-Noten sehr schnell hintereinander spiele ohne dabei die Release Phase der 1.Note abzuwarten, dann ensteht ein störendes Klick Geräusche zwischen den beiden Noten (siehe roter Kreis Bild 1). Mein ADSR-Generator funktioniert nach folgenden Regeln. Wenn ich eine Keyboard Taste drücke dann startet der ADSR bei einem Level von Null. Drücke ich während der ADSR-Phasen eine zweite Taste, dann startet der ADSR wieder bei einem Level von Null. Bild 1: Signalverlauf von zwei Noten die kurz hintereinander angespielt werden Um das zu vermeiden, könnte man den ADSR-Generator retriggern und den neuen Attack-Level auf den auf den letzten Wert des ADSR vor der Retriggerung setzen. Das wird zB. beim ADSR-Modul A-140 von der Firma Doepfer gemacht (siehe Bild 2). Bild 2: ADSR-Modul A-140 Ich hab den Code in der ADSR Envelope Routine etwas abgeändert. Jetzt wird der aktuelle ADSR-Wert der 1.Note als neuer Startwert für den ADSR der 2.Note benutzt. Im Bild kann man den Hüllkurvenverlauf der beiden Noten gut erkennen. Bild 3: Ergebnis der Änderung: Keine Klick Geräusch zwischen zwei Noten Ein Problem gibts aber noch. Wenn der DDS Phasengenerator beim Starten der Samples auf Null zurückgesetzt wird um den Sample ab Anfang abzuspielen, dann gibts wieder Klick Geräusche zwischen zwei Noten. Mal schaun wie ich das lösen kann :( Grüße aus Wuppertal. Rolf
Hallöchen.. Kleines Update für die Dateiverwaltung. Es werden jetzt alle WAV-Dateien im 8/12/16/24 Bit Format geladen. Angezeigt wird der Dateiname mit maximal 8 Zeichen sowie die Auflösung und die Dateigröße. Eine Datumsanzeige ist für später geplant. Bild: WAV-Samples im Datei Explorer Zur Zeit verbessere ich die Programmabläufe im inneren Kern des Synthis. Man nennt das im Fachjargon auch statemachine (Zustandsautomat). Vereinfacht dargestellt sieht die "Statemachine" im Synthi dann so aus wie im Bild 2. Um Programmablaufpläne zu zeichnen gibts hier eine schöne Freeware namens Diagram Designer Download: http://www.fosshub.com/Diagram-Designer.html Gruß Rolf
:
Bearbeitet durch User
Hallo.. Ich bin gerade am überlegen, wie ich eine Wellenform Grafik zB mit einer horizontalen Länge von 402 Pixel auf ein 320 Pixel breites Grafik LCD verkleinern kann, so das es auf das ganzen Breite passt. Lösungsansatz 1 Ich teile die Anzahl Wellenform Pixel / Anzahl LCD Pixel = 1,25 Geht aber nicht ganz auf, da nur jeder 2.Pixel gezeichnet wird verwirrt (siehe Bild) Lösungsansatz 2 Auf dem LCD bleiben noch 82 Pixel frei. Um diesen Platz auszunutzen teile ich die 402 Pixel / 82 = 4 und zeichne jeden 4.Bildpunkt der Wellenform Grafik zweimal ?
Aus dem mutable-instruments Forum kam mal wieder die rettende Idee. PS: Oliver du bist der Größte smile Nach seiner Idee konnte ich das Problem dann so lösen:
1 | // draw wave-file ————————————————————-
|
2 | |
3 | uint32_t source = 0; |
4 | uint32_t increment = (uint32_t)(file_lenght << 8)/310; |
5 | |
6 | for (uint16_t i = 4; i < 315; i++) |
7 | {
|
8 | uint8_t sample = hugemem_read8(p + (source >> 8)); // p = xram startadr |
9 | |
10 | sample = sample >>1; |
11 | source += increment; |
12 | uint16_t x0 = i; |
13 | uint8_t y0 = 94; // middle position of screen |
14 | |
15 | if (sample > 64) |
16 | { y0 = 94-(sample – 64); sample = sample – 64;} |
17 | else
|
18 | {y0 = 94; sample = 64 – sample;} |
19 | |
20 | vline(x0, y0, sample, color_orange); // plot sample on screen |
21 | }
|
Das Resultat seht ihr auf dem Bild. LG Rolf
Zur Zeit programmiere ich die Cursor und Loop-Funktionen für das neue Display neu. Wegen der höheren Auflösung müssen alle Routinen geändert werden. Bei dieser Gelegenheit miste ich auch alte und langsame Routinen aus. Ein kleiner Trick wurde verwendet, um den Cursor schnell über die Wellform zu bewegen. Ein 610 Byte großer Buffer im externen SRAM des Synthesizers dient als Zwischenspeicher für 310 vertikale Linienkoordinaten. Aus den 310 vertikalen Lienen Koordinaten berechne ich die aktuelle Wellenformdarstellung aus dem Soundspeicher . Beim Trüberfahren und verlassen des Cursor wird die vertikale Linie wieder neu gezeichnet (restauriert). Somit ist kein kompletter Bildspeicher für jeden Pixel notwendig und das Neuzeichnen funktioniert dadurch sehr schnell.
Hallöchen miteinander.. Es gibt wieder was neues für die Ohren. Aber dieses mal nicht von mir, sondern von Johannes Taelman. Er hat einen sehr interessanten Synthesizer auf Basis eines ARM Cortex-M4 Chips entwickelt und diesen möchte ich euch nun vorstellen. Der Axoloti Synthesizer ist eine Mischung aus Hard- und Software. Am PC werden die verschiedenen Klangmodule wie bei einem Modularen Synthesizer mit dem Axoloti-Patcher zusammengebaut und vernetzt. Per USB wird das Programm in den Speicher des Synthesizers übertragen und kann per Midi gespielt werden. Das interessante dabei ist, das vor der Übertragung der Patch am PC in Realtime vorgehört werden kann Youtube: https://www.youtube.com/watch?v=i22_KoAqmpI#t=24 Axoloti-Website: http://axoloti.be/ Axoloti-Patcher: https://www.youtube.com/watch?v=d7Xv99v1RwI Gruß Rolf
Hallöchen.. Heute habe ich die zwei neuen Ersatz XMega100 Breakout Boards bekommen und die Stiftleisten angelötet. Zum Ausprobieren habe ich diese in den Stecksockel auf dem Motherboard vom Synthesizer gesteckt und mit ATMEL-Studio geflasht. Die beiden Breakout Boards funktionieren fehlerfrei. Jetzt kann ich ohne Risiko den Xmega Prozessor 10.000 mal umprogrammieren (flashen) ohne das ich Angst haben muss, das ein Bit nicht mehr funktioniert smile Bild: XMega100 Breakout Board Zur Zeit arbeite ich noch an der Zoom-Funktion für die Anzeige der Wellenform und den Loop-Points. Ich hoffe das ich das dieses Wochenende endlich hin bekomme. Lieben Gruß aus Wuppertal. Rolf
Hallo liebe Freunde der Musik... Vom Elektor Magazin soll es in der Januar und Februar Ausgabe einen neuen Synthesizer Bausatz geben. Der "J2B Synthesizer" besitzt auch wie der Axoloti Synthesizer einen 32-Bit ARM Cortex- M3 Prozessor für die Klangerzeugung. Die Inspiration für die Entwicklung des J²B SYNTHESIZER kam durch den 8-Bit Synthesizer ATmegatron von Paul Soulsby (http://soulsbysynths.com/). Hier einige Daten: Monophonic 9-bit synthesizer 32 waveforms + user defined 15 filter types 2 envelope generators LFO with 16 waveforms 15-pattern arpeggiator 16 patch memories 6 live controls MIDI Patch saving/loading over MIDI NXP LPC1347 32-bit ARM Cortex-M3 microcontroller 2 output channels Open Source & Open Hardware design Den J²B SYNTHESIZER kann man sich auf Youtube auch anhören: https://www.youtube.com/watch?v=rwNBSdC3ZqA#t=16 Gruß Rolf
:
Bearbeitet durch User
Hallöchen.. Gestern habe ich die Bauteile für meinen Shruthi Synthesizer bekommen. Da ich zu den ungeduldigen Menschen zähle, habe ich eine Nachtschicht eingelegt und den Shruthi zusammen gelötet. So in den frühen Morgenstunden wäre ich fast mit dem Lötkolben in der Hand eingeschlafen und bin dann doch ins Bett gegangen.. Augenzwinkern Bild1: Mein Shruthi Synthesizer Dank der guten Dokumentation und Lötanleitung auf der Mutable Instrument Website ist der Shruthi sehr einfach und leicht zu löten und schnell zusammenzubauen. Beim Bestellen der Bauteile sollte man beachten, das es unterschiedliche Stücklisten für verschieden Lieferanten wzB Mouser oder Reichelt gibt. Ich habe mich für Reichelt entschieden, da dieser Lieferant kostengünstiger ist. Ein kleines Problem gabs bei der Bestellung der Tasten. Die Original Tasten gabs bei Reichelt nicht und ich musste dafür andere Tasten nehmen. Bei Mouser bekommt man die Original Tasten und die anderen Bauteile problemlos geliefert. Stückliste Reichelt: https://secure.reichelt.de/index.html?&ACTION=20&LA=5010&AWKID=1026199&PROVID=2084 Stückliste Mouser: https://www.mouser.de/ProjectManager/ProjectDetail.aspx?AccessID=dcda87764c Dank meiner langjährigen Lötkünste war der Shruthi schnell zusammengelötet und betriebsbereit. Beim Flashen der aktuellen Firmware über ATMEL STUDIO hatte ich ein kleines Problem. Die Voreinstellung für die PDI Clock-Rate von 1MHz für den Mikrocontroller ATmega644P muss im Menü auf 125KHz herunter gesetzt werden, da sonst der ATmega644P nicht erkannt wird.. Gruß Rolf
Hallöchen So.. am Wochenende hab ich mal wieder fleißig am Synth programmiert und den Step Sequenzer integriert. Er ist noch nich ganz fertig, aber schon lauffähig smile Noten Symbol: Ausgewählte Midi-Note von 0-127 H ist die Notendauer V ist die Lautstäke der Note und wird durch einen blauen Balken angezeigt Roter Punkt bedeutet das der Step aktiv ist. Grau bedeutet ausgeschaltet Später wirds noch eine Reset und Skip Funktion für jeden Step geben. Bild1: Der Step Sequenzer im "Degenerator" Das Ganze kann man sich auf Youtube ansehen und anhören. Der Ton kommt von der Webcam und ist leider nicht so prickelnd :( Youtube: https://www.youtube.com/watch?v=pIb-1a0dA6I&list=UUXQSpP0qn5MXSkyDo6PZ4Cw Gruß Rolf
:
Bearbeitet durch User
Hallo, beobachte schon seit längerer Zeit dein Projekt in div. Foren. Gratulation dazu! Ich selbst habe, nach dem Bau eines 4-stimmigen AVR-hybrid Synth, auch ein neues Projekt am Laufen. Vielleicht interessieren dich die ein oder anderen Eckdaten: Quasi drei "Module" bzw. Platinen: "Klangerzeuger" ist ein PIC32MX250xx, der auf 68MHZ getaktet ist. Clou an diesem PIC: I2S! D.h. ich habe zwei 16 Bit DAC's daran gehängt (PT8211-S) und komme somit auf 4 analoge Einzelausgänge. Des weiteren hängt noch ein 8-fach 8-bit DAC daran (LTC1665) womit ich die analogen Filter ansteuern kann. Als Klangquelle nehme ich 16-bit Wavetables mit jeweils 1024 steps (hörbarer Unterschied zu den 128ern, v.a. bei tiefen Frequenzen!). Normale Wavetables (Waldorf Blofeld) können auch importiert werden. Direkt mit dem PIC ist das Quad-analog Filterboard verbunden. Basis ist der VCA-Chip SSM2164 (LP/HP/BP). Ähnliches Design wie beim Shruti. Die dritte Ebene ist die "Steuerzentrale": Da verwende ich einen leaflabs maple mini clone um 3-4 Euro (STM32F103CB). Der hat einen USB_MIDI Stack, d.h. er wird über USB als Midi Interface erkannt. An dem hängt die notwendige Peripherie wie: (touch)TFT, OLED, Encoders, Buttons, SPI-Flash-ROM (64M-bit/8M-byte Winbond W25Q64) für Patches und Wavetables, "echtes" MIDI,... somit ist der PIC komplett frei für die Klangerzeugung. Verbindung STM32 zu PIC erfolgt über I2C, d.h. es werden nur die notwendigen Steuerbefehle übermittelt. Kostenpunkt für einen Synth (ohne Case!): weit unter 100 Euro. Die Platinen lass ich mir in China über dirty cheap PCB`s fertigen (10STK 10x10cm 2-layer um 20 Euro, Versandkostenfrei), da ich seit meinem 8-bit Projekt keinen Bock mehr auf through-hole habe und nur noch SMD verwende ;) Entwicklung wird jedoch noch etliche Monate dauern, aber im Prinzip funktioniert alles schon am Breadboard bzw. mit meine Proto-Modulen. LG Matthias
:
Bearbeitet durch User
Hallo Matthias Mit viel "Neid" habe ich deinen Bericht gelesen ;) Das wird mit Sicherheit ein sehr guter Synthi werden. Hab auch schon überlegt ob ich auch auf einen leistungsstärkeren ARM Controller setzen soll. Aber da fehlt mir einiges an Wissen und gute Systemtools wzB eine Entwicklungsumgebung. Ich programmiere meinen Synth mit ATMEL-Studio 6.2 in C und Assembler und versuche aus dem verwendeten ATmega128 alles an Ressourcen herauszuholen was möglich ist. Die Arbeitsaufteilung auf mehrere Prozessoren macht schon Sinn. So sind dann auch mehrere Stimmen möglich. Mein Synth hat leider nur eine Stimme aber dafür in Stereo. Ich verwende die zwei DAC-Ausgänge im ATmega128 für Oszillator 1+2, 2x Analoge VCA's LM13700, 2x Analoge 12db Filter LM13700 (LP,HP,BP), einen Delay-Channel mit PT2399 Chip. Die CV-Steuerung erfolgt durch die 10 PWM-Ausgänge des ATmegas. Die 128 festen Wellenformen (128x 256Byte) werden jetzt beim Systemstart von der SD Karte ans Ende des 1MByte großen SRAM-Speichers geladen. Der User kann dadurch eigene Wellenformen mit einem Wave-Editor erzeugen und diese ins SRAM laden. Der Rest steht dem Sample-File zur Verfügung. Um das Aliasing bei den tiefen Frequenzen etwas zu minimieren mach ich eine Interpolation von zwei Samples. Ein Code-Beispiel aus meinem synth ist im Anhang gelistet. Vielleicht kannst du ja gebrauchen. Zur Zeit arbeite ich noch viel an der Software. Habs ja nicht gelernt und tuh mich da halt etwas schwer. Aber wie sagt man so schön.. Mühsam nährt sich das Eichhörnchen :)
:
Bearbeitet durch User
Soviel "Neid" brauchst du nicht zu haben, bin ja selbst nur ein "Pfuscher" und hab mir sowohl das "analoge Wissen" als auch die rudimentären C++ Kenntnisse in den letzten Jahren beigebracht (gut, hab auch schon früher am Atari 800 und dann am ST geklopft) ;) Wegen Entwicklungsumgebung: Verwende sowohl für den PIC32 als auch für den STM32 "Arduino Derivate" (wobei ich an der STM32-Arduino Portierung auch beteiligt bin). D.h. Der Code ist - im großen und ganzen - recht austauschbar. Vorteil dabei ist, dass ich sehr viel dadurch aus diversen Foren/Blogs "zusammenkopieren" konnte. So ist z.B. die Phasenregulierung der Oszillatioren aus einem ehemaligen Arduino AVR Code enstanden. Genauso habe ich etliche Libraries recht einfach portieren können, zB die exzellente MIDI Library hat auf Anhieb geklappt. Ich selbst fand den Übergang von AVR zu ARM nicht so schwierig, hab mit einem Tiva-C begonnen, der ein sehr gutes Datenblatt besitzt. Nachteil beider "32-Bitter" die ich jetzt verwende: Beide haben keine FPU, das wäre für unsere Zwecke das non-plus-ultra. Der Vorteil des V2164/SSM2164 gegenüber dem LM13x00 ist, dass der CV Eingang exp. ist, d.h. man erspart sich das lästige 2 Transistoren lin-exp-Spielchen, das noch dazu temperaturunbeständig ist. D.h. man erspart sich bei den billigeren LM's kaum etwas. (auf Ali gibt es die SSM2164 um 2 Euro pro Stück - ohne Gewähr! :) ) Auslagerung auf mehrere uC's ist für mich kein Thema, bei den (dumping)Preisen. Blöderweise gibt es nicht "den" perfekten uC (Ergänzung: noch(!) nicht, es kommt im Juni der PIC32MZxxxEF raus: mind. 200MHZ,2048kb SRAM, true random generators, 4x I2S= 8 Stimmen...) : Der PIC32 kann zwar I2S, dafür hat er nur 5 (oder 6?) PWM Kanäle, der STM32 umgekehrt. Interessant wäre eine "echte" SRAM Anbindung mit eben 1MB+ wie bei dir, dafür fehlen mir die Kenntnisse, bzw. die Pin's. Da bleiben mir "nur" die 32kb SRAM im PIC und die 20kb im STM32 übrig. Ist aber genug für die klassische Morphing Wavetable von Waldorf: 16Bit, 64 Wellenformen zu 128 Schritten = 16kB, da bleiben 16KB für den "Rest" im PIC. Genauer gesagt: 4 Stimmen zu je(!) OSC1 (morphing Wavetable od. 1024 steps) OSC2 (1024 steps standard Wavetable) 2-3 LFO's 2-3 ADSR's natürlich hat jede Stimme die gleiche Wavetable Konfiguration, geht sich anders auch nicht aus.
Ich bin mal gespannt auf die ersten Klänge aus deinem Synth :) Zur Zeit arbeite ich noch an der Mudlationmatrix. Am 23.April gehts dann mit dem Prototype ins TV Studio. Der CC2 hat mich eingeladen um den Synth vorzustellen. Hoffe es funktioniert alles bis dahin. Ein Gehäuse muss ich auch noch machen. Halt noch viel Arbeit.. Gruß Rolf
Hallöchen.. Der "DE:GENERATOR" ist ready for sounding..
:
Bearbeitet durch User
Der Studiobesuch beim CC2 Hallo liebe Freunde.. Der Studiobesuch beim CC2 war sehr interessant und eine große Freude für mich. Endlich konnte ich den "Urgesteinen" des damaligen WDR Computer Clubs Wolfgang Back und Wolfgang Rudolph leibhaftig die Hände schütteln. Der Heinz war dieses mal leider nicht dabei. Es ist sehr interessant zu beobachten mit welcher Routine und Gelassenheit und vor allem mit wieviel Humor die beiden Wolfgänge eine TV Sendung machen. Und ich live dabei und mittendrin.. wow. Von Lampenfieber vor den drei Kameras war bei mir keine Spur mehr als ich mit Wolfgang Rudolph ins Gespräch kam und von den Anfängen meiner Entwicklung am Synthesizer erzählte. Techniker unter sich.. da sind 15 Minuten nix. Die Minuten flogen im Eiltempo an mir vorbei und ich hätte noch Stunden vom Synthesizer, Elektronischer Musik u.a. Dingen erzählen können. Aber da war noch Stefan Krister und der wollte etwas über den 3D Druck erzählen. Dem wollte ich nicht die Show stehlen smile Hab mal ein paar Fotos aus dem Studio von NRW TV geschossen um zu "beweisen" das ich wirklich da war Augenzwinkern Fotos CC2 Studiobesuch
Hallo.. Diese Woche arbeite ich noch einmal am Frontpannel. Wegen der ca. 20cm langen 8Bit Datenleitungen vom Prozessorport zum Display kommt es gelegentlich zu Störungen auf dem Display. Die Daten werden mit einer Geschwindigkeit von 16Mhz übertragen. Ich habe mir überlegt für die Display-Ansteuerung einen eignen ATmega328P Prozessor auf dem Frontpannel einzusetzen. Dadurch werden die Datenleitung zum Display sehr kurz und Störungen bei der Datenübertragung vermieden. Die Datenübertragung vom ATxmega128 Hauptprozessor zum Display-Prozessor erfolgt dann über den schnellen I2C Bus der Prozessoren. Noch ein Vorteil hätte diese Änderung. Der Hauptprozessor würde mit der aufwendigen Berechnung für Lienen, Rechtecken und Textzeichen auf dem Display entlastet werden. Das würden dann der Display-Prozessor übernehmen. Die Abfrage der Taster und Encoder könnte der Display Prozessor ebenfalls übernehmen. Bild: Altes Prozessorboard und Frantpannel So.. dann mal ran an die Arbeit. Bauteile sind schon bestellt smile Gruß Rolf
für solche Dinge (Auslagerung von Displays...) eignen sich hervorragend die kleinen "Arduino mini clones" auf ebay und aliexpress. Upload mit FTDI oder anderem USB-serial converter. Kostenpunkt: ca. 2 Euro Stück (Versandkostenfrei). (Sorry, kann keinen Link posten, da alles was ich versuche mit der Meldung: Der Beitrag scheint Spam zu enthalten: nicht abzuschicken ist ((A)ffilate, (t)inyurl). Toll gelöst, admins, Hut ab!) Letzter Versuch: (Klammern entfernen) http://(t)iny(url).com/mhd9449 Hab auch erfolgreich die "Kleinen" mit nur 3.3V "befeuert" (dürfte mit 16MHZ kein Problem sein, wenn auch außerhalb der Specs) -> spart bei TFT's die 5V/3.3V Konvertierung. Obwohl ich gerade bei Displayansteuerung die maple mini clones (ab 3.5 STK) empfehlen würde, aber da müsstest du dich in ARM/STM32 einarbeiten. Liebe Grüße Matthias
Hallo zusammen ! Auf Youtube sind die zwei TV-Folgen über meinen Synthesizer im CC2 Channel zu sehen. 1.Folge: https://www.youtube.com/watch?v=8MZyrBaEf94 2.Folge: https://www.youtube.com/watch?v=tl1SMwQXm7o Viel Spaß beim ansehen. :) Gruß Rolf
Hallo zusammen! Es gibt wieder viel neues zu berichten. In den vergangenen Wochen habe ich an der Modulationsmatrix gearbeitet und den Envelope Generator (ADSR) verbessert. Bild 1: Modulationsmatrix Mögliche Modulationsquellen LFO1 LFO2 ENV1 ENV2 Velocity Mod.Wheel Pitch Wheel Randomgenerator Noise Sequenzer Mögliche Modulationsziele Osc1 Osc2 Osc1+Osc2 VCA-Gain VCF Cutoff Resonance Osc-Pan VCA-Pan Fx-Pan LFO1 LFO2 Die Menü Page für die Modulationsmatrix ist bereits fertig (siehe Bild). Über den Cursor kann einer von 20 sogenannten Modulations-Slots ausgewählt werden. Über die Regler "Source" und "Destination" werden die Modulationsquelle und das Ziel bestimmt. Mit "Amount" wird die Modulationsstärke eingestellt. Jetzt muss ich das Ganze "nur noch" in eine kleine Formel packen und berechnen. Hilfe ich brauch einen Mathematiker holy-willi Envelope Generator Die alten Routinen für den Envelope Generator benötigten viel Rechenzeit durch Divisionen und hatten Rundungsfehler. Angeregt durch den Envelope Generator im Shruthi Synthesizer und die großartige Unterstützung von Oliver aus dem Mutable Forum habe ich den Quellcode für meinen Synthesizer angepasst. Dieser besteht im wesentlichen aus einem 16Bit Counter und einer kleinen Tabelle um die Lineare Kurvenform in eine Exponentiale Kurve zu konvertieren. Die "wav_res_env_expo" Tabelle kann auch gegen eine andere Kurvenform ausgetauscht werden. Dadurch ergeben sich sehr interessante Envelope Verläufe. Ferner sind auch mehr als nur vier Envelope-Phasen (ADSR) möglich. Mutabel Instrument Forum: http://mutable-instruments.net/forum/discussion/2504/shruthi-synthesizer-and-my-wave-1/p16 C-Code: Envelope Generator (ADSR)
1 | //----------------------------------------------------------------
|
2 | // Variable
|
3 | //----------------------------------------------------------------
|
4 | |
5 | uint16_t phase_; |
6 | uint16_t phase_increment; |
7 | uint16_t ramp_start_; |
8 | uint16_t ramp_end_; |
9 | uint8_t ramp_a_; |
10 | uint8_t ramp_b_; |
11 | uint16_t value_; |
12 | |
13 | |
14 | // init envelope
|
15 | adsr1_phase = ATTACK; |
16 | adsr2_phase = ATTACK; |
17 | phase_ = 0; |
18 | |
19 | //-------------------------------------------------------------------------
|
20 | // Envelope function
|
21 | //-------------------------------------------------------------------------
|
22 | void envelope(void) |
23 | {
|
24 | // increment 16Bit env_ramp
|
25 | phase_ += phase_increment; |
26 | |
27 | // check end of attack phase
|
28 | if (phase_ < phase_increment) |
29 | {
|
30 | // set next envelope phase
|
31 | adsr1_phase ++; |
32 | phase_ = 0; |
33 | }
|
34 | else
|
35 | {
|
36 | // interpolate 8Bit env_expo table with 16Bit phase_
|
37 | uint8_t step = InterpolateSample(wav_res_env_expo, phase_); |
38 | // calc 16Bit envelope value
|
39 | uint16_t ramp_expo = U8MixU16(ramp_a_, ramp_b_, step); |
40 | value_ = ramp_start_ + ((uint32_t)(ramp_end_ - ramp_start_) * ramp_expo >> 16); |
41 | }
|
42 | }
|
43 | |
44 | //-------------------------------------------------------------------------
|
45 | // Envelope Phase
|
46 | //-------------------------------------------------------------------------
|
47 | void env_routine(void) |
48 | {
|
49 | // Midi Sync ----------------------------------------------------------
|
50 | if (midi_sync_flag == 1) |
51 | {
|
52 | midi_sync_flag = 0; |
53 | midi_gate_flag = 1; |
54 | |
55 | // init envelope
|
56 | adsr1_phase = ATTACK; |
57 | adsr2_phase = ATTACK; |
58 | phase_ = 0; |
59 | |
60 | // ReTrigger Osc
|
61 | if (wavebank1 > 0 && Osc1_ReTrig == 1) |
62 | {
|
63 | phaccu1 = 0; |
64 | phaccu2 = 0; |
65 | }
|
66 | |
67 | // set Note Frequency
|
68 | frequency_tune(); // set note-frequency to osc1+2 |
69 | loop_end_flag1 = 0; |
70 | loop_end_flag2 = 0; |
71 | |
72 | // LFO Trigger
|
73 | lfo1_run = 1; |
74 | if (lfo1_trig == 1) |
75 | {
|
76 | lfo1_phaccu = 0; |
77 | }
|
78 | lfo2_run = 1; |
79 | if (lfo2_trig == 1) |
80 | {
|
81 | lfo2_phaccu = 0; |
82 | }
|
83 | }
|
84 | |
85 | // Env 1 (VCA) --------------------------------------------------------
|
86 | if (adsr1_phase == ATTACK) |
87 | {
|
88 | // load 7Bit attack_value1 from encoder (0-127) and convert to 16Bit phase_increment
|
89 | phase_increment = pgm_read_word (&(lut_res_env_portamento_increments[attack_value1])); |
90 | ramp_start_ = 0; |
91 | ramp_end_ = 65535; |
92 | ramp_a_ = 0; |
93 | ramp_b_ = 255; |
94 | |
95 | envelope(); |
96 | adsr1_out = value_; |
97 | release_level = value_; |
98 | }
|
99 | else if (adsr1_phase == DECAY) |
100 | {
|
101 | // load 7Bit decay_value1 from encoder (0-127) and convert to 16Bit phase_increment
|
102 | phase_increment = pgm_read_word (&(lut_res_env_portamento_increments[decay_value1])); |
103 | |
104 | // load 7Bit sustain level from encoder (0-127) and convert to 16Bit phase_increment
|
105 | ramp_start_ = pgm_read_word (&(sustain_rates[sustain_value1])); |
106 | ramp_end_ = 65535; |
107 | ramp_a_ = 255; |
108 | ramp_b_ = 0; |
109 | |
110 | envelope(); |
111 | adsr1_out = value_; |
112 | release_level = value_; |
113 | }
|
114 | |
115 | else if (adsr1_phase == RELEASE) |
116 | {
|
117 | // load 7Bit decay_value1 from encoder (0-127) and convert to 16Bit phase_increment
|
118 | phase_increment = pgm_read_word (&(lut_res_env_portamento_increments[relaese_value1])); |
119 | ramp_start_ = 0; |
120 | ramp_end_ = release_level; |
121 | ramp_a_ = 255; |
122 | ramp_b_ = 0; |
123 | |
124 | envelope(); |
125 | adsr1_out = value_; |
126 | }
|
127 | |
128 | if (midi_gate_flag == 0) |
129 | {
|
130 | if (adsr1_phase < 3) |
131 | {
|
132 | adsr1_phase = RELEASE; |
133 | phase_ = 0; |
134 | }
|
135 | }
|
136 | |
137 | // Env2 (VCF) ---------------------------------------------------------
|
138 | |
139 | //---------------------------------------------------------------------------
|
140 | // inline function and tables
|
141 | //---------------------------------------------------------------------------
|
142 | |
143 | static inline uint8_t InterpolateSample( |
144 | //const uint8_t* table, uint16_t phase) {
|
145 | const uint8_t table[], uint16_t phase) { |
146 | uint8_t result; |
147 | uint8_t work; |
148 | asm( |
149 | "movw r30, %A2" "\n\t" // copy base address to r30:r31 |
150 | "add r30, %B3" "\n\t" // increment table address by phaseH |
151 | "adc r31, r1" "\n\t" // just carry |
152 | "mov %1, %A3" "\n\t" // move phaseL to working register |
153 | "lpm %0, z+" "\n\t" // load sample[n] |
154 | "lpm r1, z+" "\n\t" // load sample[n+1] |
155 | "mul %1, r1" "\n\t" // multiply second sample by phaseL |
156 | "movw r30, r0" "\n\t" // result to accumulator |
157 | "com %1" "\n\t" // 255 - phaseL -> phaseL |
158 | "mul %1, %0" "\n\t" // multiply first sample by phaseL |
159 | "add r30, r0" "\n\t" // accumulate L |
160 | "adc r31, r1" "\n\t" // accumulate H |
161 | "eor r1, r1" "\n\t" // reset r1 after multiplication |
162 | "mov %0, r31" "\n\t" // use sum H as output |
163 | : "=r" (result), "=r" (work) |
164 | : "r" (table), "r" (phase) |
165 | : "r30", "r31" |
166 | );
|
167 | return result; |
168 | }
|
169 | |
170 | static inline uint16_t U8MixU16(uint8_t a, uint8_t b, uint8_t balance) { |
171 | uint16_t result; |
172 | asm( |
173 | "mul %3, %2" "\n\t" // b * balance |
174 | "movw %A0, r0" "\n\t" // to sum |
175 | "com %2" "\n\t" // 255 - balance |
176 | "mul %1, %2" "\n\t" // a * (255 - balance) |
177 | "com %2" "\n\t" // reset balance to its previous value |
178 | "add %A0, r0" "\n\t" // add to sum L |
179 | "adc %B0, r1" "\n\t" // add to sum H |
180 | "eor r1, r1" "\n\t" // reset r1 after multiplication |
181 | : "&=r" (result) |
182 | : "a" (a), "a" (balance), "a" (b) |
183 | );
|
184 | return result; |
185 | }
|
186 | |
187 | |
188 | //-------------------------------------------------------------------------
|
189 | // Attack increments 16Bit
|
190 | //-------------------------------------------------------------------------
|
191 | const uint16_t lut_res_env_portamento_increments[] PROGMEM = { |
192 | |
193 | 65535, 18904, 16416, 14304, 12504, 10968, 9647, 8509, |
194 | 7525, 6672, 5931, 5285, 4719, 4224, 3788, 3405, |
195 | 3066, 2766, 2500, 2264, 2053, 1865, 1697, 1546, |
196 | 1411, 1290, 1180, 1082, 993, 912, 839, 773, |
197 | 713, 658, 608, 562, 521, 483, 448, 416, |
198 | 387, 360, 335, 313, 292, 272, 255, 238, |
199 | 223, 209, 196, 184, 172, 162, 152, 143, |
200 | 135, 127, 119, 113, 106, 100, 95, 90, |
201 | 85, 80, 76, 72, 68, 64, 61, 58, |
202 | 55, 52, 50, 47, 45, 43, 41, 39, |
203 | 37, 35, 33, 32, 30, 29, 28, 26, |
204 | 25, 24, 23, 22, 21, 20, 19, 18, |
205 | 18, 17, 16, 16, 15, 14, 14, 13, |
206 | 13, 12, 12, 11, 11, 10, 10, 9, |
207 | 9, 9, 8, 7, 7, 6, 6, 5, |
208 | 5, 4, 4, 3, 3, 2, 2, 1 |
209 | };
|
210 | |
211 | const uint8_t wav_res_env_expo[] PROGMEM = { |
212 | 0, 4, 9, 14, 19, 23, 28, 32, |
213 | 37, 41, 45, 49, 53, 57, 61, 65, |
214 | 68, 72, 76, 79, 83, 86, 89, 92, |
215 | 96, 99, 102, 105, 108, 111, 113, 116, |
216 | 119, 121, 124, 127, 129, 132, 134, 136, |
217 | 139, 141, 143, 145, 148, 150, 152, 154, |
218 | 156, 158, 160, 161, 163, 165, 167, 169, |
219 | 170, 172, 174, 175, 177, 178, 180, 181, |
220 | 183, 184, 186, 187, 188, 190, 191, 192, |
221 | 193, 195, 196, 197, 198, 199, 200, 201, |
222 | 202, 203, 205, 206, 206, 207, 208, 209, |
223 | 210, 211, 212, 213, 214, 215, 215, 216, |
224 | 217, 218, 218, 219, 220, 221, 221, 222, |
225 | 223, 223, 224, 225, 225, 226, 226, 227, |
226 | 227, 228, 229, 229, 230, 230, 231, 231, |
227 | 232, 232, 233, 233, 233, 234, 234, 235, |
228 | 235, 236, 236, 236, 237, 237, 238, 238, |
229 | 238, 239, 239, 239, 240, 240, 240, 241, |
230 | 241, 241, 241, 242, 242, 242, 243, 243, |
231 | 243, 243, 244, 244, 244, 244, 245, 245, |
232 | 245, 245, 245, 246, 246, 246, 246, 246, |
233 | 247, 247, 247, 247, 247, 248, 248, 248, |
234 | 248, 248, 248, 248, 249, 249, 249, 249, |
235 | 249, 249, 249, 250, 250, 250, 250, 250, |
236 | 250, 250, 250, 251, 251, 251, 251, 251, |
237 | 251, 251, 251, 251, 251, 252, 252, 252, |
238 | 252, 252, 252, 252, 252, 252, 252, 252, |
239 | 252, 253, 253, 253, 253, 253, 253, 253, |
240 | 253, 253, 253, 253, 253, 253, 253, 253, |
241 | 253, 254, 254, 254, 254, 254, 254, 254, |
242 | 254, 254, 254, 254, 254, 254, 254, 254, |
243 | 254, 254, 254, 254, 254, 254, 254, 255, |
244 | 255
|
245 | };
|
246 | |
247 | //-------------------------------------------------------------------------
|
248 | // Sustain level 16Bit
|
249 | //-------------------------------------------------------------------------
|
250 | const uint16_t sustain_level[] PROGMEM = { |
251 | 1, 11, 33, 65, 106, 157, 218, 287, |
252 | 366, 454, 550, 655, 769, 891, 1022, 1162, |
253 | 1310, 1466, 1630, 1803, 1984, 2173, 2370, 2576, |
254 | 2789, 3011, 3240, 3477, 3723, 3976, 4237, 4506, |
255 | 4783, 5068, 5360, 5660, 5968, 6284, 6607, 6938, |
256 | 7277, 7623, 7977, 8338, 8707, 9084, 9468, 9860, |
257 | 10259, 10666, 11080, 11502, 11931, 12367, 12811, 13263, |
258 | 13722, 14188, 14661, 15142, 15630, 16126, 16629, 17139, |
259 | 17657, 18181, 18713, 19253, 19799, 20353, 20914, 21483, |
260 | 22058, 22641, 23231, 23828, 24432, 25043, 25662, 26288, |
261 | 26920, 27560, 28207, 28862, 29523, 30191, 30867, 31549, |
262 | 32239, 32935, 33639, 34350, 35068, 35792, 36524, 37263, |
263 | 38009, 38762, 39522, 40288, 41062, 41843, 42631, 43425, |
264 | 44227, 45036, 45851, 46674, 47503, 48339, 49182, 50033, |
265 | 50889, 51753, 52624, 53502, 54386, 55278, 56176, 57081, |
266 | 57993, 58912, 59837, 60770, 61709, 62655, 63608, 65535 |
267 | };
|
Link: https://www.youtube.com/watch?v=2nDW_XA8oTU Gruß Rolf
:
Bearbeitet durch User
Hallöchen und guten Abend smile Ich glaube das die Sounds vom DE:Generator sehr interessant sind ich mich nicht verstecken muss im Vergleich zu anderen Synthis, obwohl meine Kiste nur 8Bit macht. Testweise habe ich heute einen 580KByte großen Chor-Sample geladen und über den eigebauten Stepsequenzer abgespielt. Im normalen Fall wird der Wellenform Oszillator bei jeder Tastenanschlag retriggert und beginnt das Abspielen des Samples von vorne (Sound Beispiel 1.Teil). Ich habe diese Funktion über einen Switch (ReTrig) abschaltbar gemacht, so dass der Wellenform Oscillator im Loop läuft und bei jedem Tastenanschlag ein anderer Wellformabschnitt vom Sample gespielt wird (Sound Beispiel 2.Teil). Der Sound klingt dadurch abwechslungsreicher und weniger statisch. Das funktioniert allerdings nur bei Flächensounds sehr gut. Sound Beispiel 1.Teil Note trigger Waveform Oszillator 2.Teil: free rum Waveform Oszillator Soundcloud: https://soundcloud.com/rolfdegen/osc-re-trigger Gruß Rolf
Hallöchen.. Mit Neo und Morpheus war ich heute in der Matrix und tauche gleich wieder ein ebueb Kleiner Scherz. Wer den Film Matrix nicht kennt hier zur Film Info: http://de.matrix.wikia.com/wiki/Matrix_Wiki Diese Woche arbeite ich wieder an der Modulationsmatrix. Keine leichte Sache unglücklich Aber Dank einiger Tips aus dem Mutable Forum will ich das mit Hilfe eines Zweidimensionale Daten Arrays versuchen umzusetzen. Zweidimensionale Daten Arrays: http://www.c-howto.de/tutorial-arrays-felder-zweidimensional.html Bild1: Modulationsmatrix im DE:Generator Wie man auf dem Bild erkennen kann, besteht das Daten Array aus 6 Reihen (Slots) mit jeweils 3 Datenfeldern (Source, Destination, Amount). Der Zugriff auf ein Datenelement in der Modulationsmatrix erfolgt mit einem Zeilen- und Spaltenindex. Unter C sieht das zB dann so aus:
1 | amount = (slot_array[2][2]); // load lfo1 amount |
Die Berechnung eines Modulationsknoten besteht im wesentlichen aus der Multiplikation von Source- und Destination-Werten. Um die Berechnungen schnell auszuführen, habe ich Inline-Assembler Routinen verwendet. Mit Inline-Assembler kann man kleine optimierte Assembler Routinen direkt in den C-Code einbetten.
1 | // LFO1 => VCF Modulation --------------------------------------------
|
2 | temp_cv = U16ShiftRight4(Env2.value_); // convert 16Bit Envelope to 12Bit PWM-Control for Filter-Cutoff |
3 | amount2 = (slot_array[2][2]) << 1; // load lfo1 amount *2 |
4 | modul2 = lfo1_out * amount2 >> 8; |
5 | temp_cv = U16U8MulShift8(temp_cv,(255-modul2)); |
6 | |
7 | // set Filter Cutoff --------------------
|
8 | CV_VCF_Cha1 = temp_cv; |
9 | CV_VCF_Cha2 = temp_cv; |
10 | |
11 | |
12 | |
13 | // Inline-Assembler Routinen (avr-gcc) ------------------
|
14 | static inline uint16_t U16ShiftRight4(uint16_t a) { |
15 | uint16_t result; |
16 | asm( |
17 | "movw %A0, %A1" "\n\t" |
18 | "lsr %B0" "\n\t" |
19 | "ror %A0" "\n\t" |
20 | "lsr %B0" "\n\t" |
21 | "ror %A0" "\n\t" |
22 | "lsr %B0" "\n\t" |
23 | "ror %A0" "\n\t" |
24 | "lsr %B0" "\n\t" |
25 | "ror %A0" "\n\t" |
26 | : "=r" (result) |
27 | : "a" (a) |
28 | );
|
29 | return result; |
30 | }
|
31 | |
32 | static inline uint16_t U16U8MulShift8(uint16_t a, uint8_t b) |
33 | {
|
34 | uint16_t result; |
35 | asm( |
36 | "eor %B0, %B0" "\n\t" |
37 | "mul %A1, %A2" "\n\t" |
38 | "mov %A0, r1" "\n\t" |
39 | "mul %B1, %A2" "\n\t" |
40 | "add %A0, r0" "\n\t" |
41 | "adc %B0, r1" "\n\t" |
42 | "eor r1, r1" "\n\t" |
43 | : "=&r" (result) |
44 | : "a" (a), "a" (b) |
45 | );
|
46 | return result; |
47 | }
|
Die Schwierigkeit in der Programmierung besteht jetzt darin, die einzelnen Modulationsknoten in der Matrix zusammen zu führen. Daran arbeite ich jetzt... Bis bald und eine schöne Wochen wünscht euch der Rolf aus Wuppertal :)
Hallo again.. Da ich zur Zeit an der Modulationsmatrix arbeite, habe ich spaßeshalber mal einen Filter Sweep Test mit dem Shruthi Synthesizer (mit Polivoks Filter) und dem DE:Generator gemacht. Filter Sweep Test auf Youtube: https://www.youtube.com/watch?v=2RPmd5Tvcns Deutlich sind die Abstufungen im Filter Sweep vom Shruthi Synthesizer zu hören. Das kommt durch die 8Bit Auflösung der Filter Steuerspannung. Im DE:Generator hat die Steuerspannung eine 12Bit Auflösung. Abstufungen sind kaum zu hören. In der Modulationsmatrix kann bereits der VCA und VCF mit den LFO's und Envelope Generatoren moduliert werden. Der Rest folgt.. Falls sich jemand vorab für den C Code interessiert. Den gibts im Anhang und ohne Gewähr Augenzwinkern Gruß Rolf
Hallöchen zusammen.. Es gibt wieder viel Neues zu berichten u.a. Ich habe die Eingangsschaltung für den Analog Digital Wandler etwas verbessert. Als erstes habe ich die interne Referenzspannungsquelle im Xmega durch einen LM336-Z2.5 ersetzt. Der LM336 erzeugt eine positive Referenzspannung von 2.5 Volt. Über den Port-Eingang PA0 wird die Referenzspannung dem Xmega zugeführt. Da ich den ADC-Eingang im sogenannten Single-ended Mode betreibe, benötigt dieser am Eingang eine positive Offset Spannung von 1.25 Volt die ich über den Spannungsteiler aus R100, R101 und R102 einstelle. Die Kondensatoren C101, C104 und C105 verringern hochfrequente Störanteile. Der Widerstand R103 dient als Strombegrenzer für den ADC-Eingang bei zu hohen Eingangsspannungen die bei Übersteuerung am Audio-Eingang auftreten können. Interne Schutzdioden im ADC-Eingang des Xmega schützen zusätzlich. Die Störgeräusche sind jetzt minimal. Der ADC im Xmega arbeitet mit einer Samplerate von 40KHz. Ein steilflankiger Tiefpassfilter ist dadurch nicht mehr notwendig. Für einen 8Bit Sampler ist der Klang erstaunlich gut. Hab mal ein Hörbeispiel auf Soundcloud hochgeladen. Soundcloud Sample Demo: https://soundcloud.com/rolfdegen/sample-demo-02 Bild: ADC-Input am Xmega Mehr Infos über den DE:generator hier: http://www.cczwei-forum.de/cc2/thread.php?threadid=5878&threadview=0&hilight=&hilightuser=0&page=24 Gruß Rolf
Mit welcher Spannung betreibst Du den OpAmp? Da der Schaltplan ohne die Versorgungspins abgebildet ist, kann man hier nur raten?
Hallo Knut Die Versorgungsspannung für den analogen Schaltungsteil im Synthesizer ist +8V -8V Bild: Stromversorgung Initialisierung des ADC im Xmega
1 | // 8Bit / unsigned mode / ext.VRef 2.5V / Prescaler 256 / singleended / input PortA Pin3
|
2 | ADCA.CTRLB = ADC_RESOLUTION_8BIT_gc; |
3 | ADCA.REFCTRL = ADC_REFSEL_AREFA_gc; |
4 | ADCA.PRESCALER = ADC_PRESCALER_DIV256_gc; |
5 | ADCA.CH0.CTRL = ADC_CH_INPUTMODE_SINGLEENDED_gc; |
6 | ADCA.CH0.MUXCTRL = ADC_CH_MUXPOS_PIN3_gc; |
7 | ADCA.INTFLAGS = 0x03; // set intflags |
8 | ADCA.CTRLA = ADC_ENABLE_bm; // ADC enabled |
Gruß Rolf
:
Bearbeitet durch User
Lieber Rolf, wirklich bemerkenswert, was du mit dem AVR anstellst, Hut ab! Bzgl. Shruti Filter: Soweit ich mich erinnern kann, hat der ja einen extra expo Schaltkreis für die Cutoff, eigenartig, dass hier noch die Steps zu hören sind und du mit den 12 Bits klar im Vorteil bist. Vielleicht tritt dieses Phänomen nur mit dem Polivoks Board auf? Das 8-Bit Sample ist auch ein Traum, kaum zu glauben wenn man es nicht weiß! Mutable Instruments ist eine meiner Hauptinspirationsquellen, insb. was Filterdesign anbelangt: Habe mir z.B. für mein 4-LP dual Filter (10x10cm) so ziemlich viel vom Ambika Synth abgeschaut (http://mutable-instruments.net/ambika/build/voicecards ---> 4-pole voicecard), das ganze in KiCad "nachgemalt", erweitert (incl. PT8211 16-bit I2S DAC) und bei dirtypcbs in Auftrag gegeben, bin schon gespannt, ob meine Platine dann funktionieren wird. Für 25 USD für 10STK Platinen echt ein Schnäppchen (wenn man 6-8 Wochen Zeit hat...) Habe die Platine auch öffentlich gestellt, würde ich aber noch nicht bestellen, da ich sie erst testen muss: http://dirtypcbs.com/view.php?share=10898&accesskey=96ae3ff6362e41d344ac5ff96a73fc62 Ich bin übrigens gespannt, ob du jemals auf ARM umsteigen wirst oder wäre das zuwenig Herausforderung für dich? :)
Ahh, OK. Sonst hätte ich einen anderen OV als den guten alten 072 vorgeschlagen, so Rail2Rail Zeugs. Ich dachte, der Synth wäre mobil, also mit Akku/Batterien... Allerdings hätte ich den Signed mode des ADC verwendet, da unsigned single ended meist etwas bugbehaftet ist. Es sei denn, Du rechnest intern auch ohne Vorzeichen.
@Matthias Danke. Für die Filter und VCA Ansteuerung verwende ich eine 12Bit PWM im Xmega. Der Shruthi macht das mit 8Bit. Deshalb die hörbaren Abstufungen im Shruthi. Ein guter Freund (Andre von der Firma TubeOhm) hat mir beim Filterdesigne sehr geholfen. Für die 1.Version des Filters im "DE:generators" haben wir uns für eine 12dB Variante mit OTAS vom Typ LM13700 entschieden. Die Stereo Filterplatine wird aber austauschbar sein, so das jeder auf seinen Geschmack kommen dürfte. Düfte für dich dann ganz interessant sein. ARM Prozessoren sind sehr preisgünstig, schnell und haben 32 Bit. Auf jeden Fall werde ich bei den nächsten Projekten mal schaun ob ich die benutze. Ein 16Bit DIY Sampler wäre etwas tolles. Mir fehlt halt noch der Überblick auch was die Entwicklungstools und Programmierung angeht. @Knut Batterie Betrieb ist kaum machbar, weil der Stromverbrauch zu hoch ist. Ich habe intern 4 Spannungen mit +3.3V , +5V, +8V , -8V und eine Leistungsaufnahme von ca. 6 Watt. Den ADC betreibe ich im Single-ended Mode ohne Vorzeichen. Der Sample wird in 8Bit ohne Vorzeichen im 1MByte Ram mit einer Abtastrate von 40KHz gespeichert. Jeder DCO kann auf diesen Sample getrennt zugreifen. Dadurch sind schöne Effekte wzB Phasing o.ä. möglich. Zur Zeit programmiere ich eine Aussteuerungsanzeige mit Speicherung des letzen Spitzenwertes, für die Aufnahme von Samples (Bild). Ist aber noch nicht ganz fertig. Gruß Rolf
Falls du Interesse an ARM's in Zukunft hast, kontaktiere mich bitte, hab mich da schon reingearbeitet (speziell punkto Audio). Ich bin selbst am Projekt stm32duino (STM32F103 bzw. auch in Zukunft die STm32F4 bis F7) beteiligt. Programmierung geht einfach über die Arduino IDE (mit allen Macken und Vorteilen) aber low level ist ebenso möglich. Developer Boards mit I2s (STM32F103RET bzw. VET haben 72Mhz, 256-512Kb Flash bzw. 48-64kb RAM) gibt es auf aliexpress für unter 10 Euro (zahlte für ein gutes RET board gerade mal 6 Euro!) Für alle STM32F103 gibt es eigene Bootloader, so Code Upload ist über die USB-Schnittstelle der Boards möglich. Den Bootloader bekommt man mit einem einfachen USB-Serial Adapter gebrannt bzw. mit einem ST-Link Adapter (~3 Euro) Soviel habe ich schon geschafft (bin selbst erst recht am Anfang): "echtes" MIDI-USB: d.h. dev board wird über USB als Midi Device erkannt. (Übertragung inkl. Midi Clock,Sysex, etc.. funktioniert!) Ansteuerung eines spottbilligen PT8211 16-bit DAC's über I2s mittels DMA: Da die größeren STM32's über drei SPI besitzen, wo 2 davon als I2s verwendet werden können sind praktisch insg. 4 individuelle Outputs möglich! Hab mir sogar einen Code geschrieben, wo ich "on the fly" Waldorf Blofeld Wavetable (auch die Multiwavetables!) direkt über MIDI in den STM32 bekomme. So kann folgendes mit nur einem STM32 gemacht werden (ist mein Projekt): 4 individuelle Outputs (jeweils 2 Multiwavetable Oszillatoren pro Stimme inkl. FM/AM...) massenhaft LFO's, ADSR's wenn beide I2s Schnittstellen für DAC's verwendet werden, bleibt noch SPI1 übrig: Ansteuerung eines TFT's (SPI ILI9341 TFT Modul (weit unter 10 Euro) mit DMA support in unserer Library), SPI-Flash (die Winbond mit 2-4MB), SPI octal(!) DAC's wie LTC1665 (8-bit...) oder LTC1660 (10-bit) Encoders, Buttons, Potis USB-Midi Serial-Midi massenhaft Timer und PWM's Nachteil der STM32F103 Serie: Keine FPU (ist ein Cortex M3), d.h. fix point maths notwendig (wie beim AVR ;) ) Falls es dich interessiert, schau dir mal unser Forum an: http://www.stm32duino.com/index.php
:
Bearbeitet durch User
So.. Aussteuerungsanzeige fast fertig. Fehlt noch das Abspeichern des Spitzenwertes für 1-2 Sekunden :) Youtube: https://www.youtube.com/watch?v=dQZtQsm15a0&feature=youtu.be Gruß Rolf
Hallo Freunde der Musik.. Für die Sample Aufnahme habe ich einige neue Funktionen integriert u.a auch Threshold. Die Aufnahme kann durch einen Tastendruck am Synthesizer sowie durch ein Midi Note ausgelöst werden. Mit Threshold startet die Aufnahme ab einem bestimmten Signal Pegel (siehe Video). Bild: Sample Aufnahmefunktion Youtube: https://www.youtube.com/watch?v=2Vn8oYqZZrc Gruß Rolf
Hallo zusammen.. Zur Zeit arbeite ich an der Optimierung der MiniScope Funktion in meinem Synth. Ziel der Optimierung ist das schnelle Zeichnen von Wellenform Kurven auf dem SainSmart TFT 3.2 Allerdings habe ich bei der LCD Orientierung im Landscape Mode noch ein kleines Problem. Bei schnellen Schreibvorgängen im Landscape Mode kommt es zum flackern des LCDs. Das liegt vermutlich an den vertauschten XY Koodinaten und dem Überlauf der Schreibregister 0x4E und 0x4F im LCD-Controller. Die Störungen sind sehr deutlich im Video beim Zeichnen von nicht gefüllten Kreisen zu sehen. Youtube SainSmart TFT 3.2: https://youtu.be/T4p6Wr_8Pcc SSD1289 Lib: http://www.rinkydinkelectronics.com/library.php?id=51 Gruß Rolf
:
Bearbeitet durch User
Kann mir kaum vorstellen, dass ein AVR einen Displaycontroller überfordern kann. Möglicherweise sind in der UTFT Library längere Waitsteps notwendig? Meine Idee wäre wieder einmal recht unorthodox: Maple mini über China ordern (3.5Euro) und das komplette TFT auf den Mini auslagern. Würde den AVR enorm entlasten und du hättest Platz für mehr Features. Abgesehen geht beim STM32 + TFT die Post ab (von wegen Geschwindigkeit). BTW: Bei meinem Synthprojekt habe ich nun komplett (aus Performance and Usabilitygründen) auf ein TFT verzichtet und gegen a) ein großes 128x64 LCD und b) gegen ein 0.96 OLED ausgetauscht Interfacetest hier ---> https://www.youtube.com/watch?v=TVV4jb7tQec&feature=youtu.be maple mini + ILI9341 (DMA mode + hardware scrolling) DEMO: https://www.youtube.com/watch?v=bv_LYtYQCmk LG Matthias
:
Bearbeitet durch User
Hi Mathias Danke für deine Tips. Dein DIY Synth schaut recht interessant aus. Gibt es eventuell mehr Infos darüber. Die Probleme mit dem Display hab ich jetzt behoben. Lag an einer fehlerhaften Berechnung des Window Address Area für das GDDRAM im Display. Gruß Rolf
Ich habe mir jetzt für ca. 9 Euro ein kleines 2.2" TFT gekauft (siehe Link). Das soll als Anzeige für ein kleines MiniScope im 19" Synthesizer Einschub dienen. Zum ersten Mal werde ich das Projekt mit einem kleinen ARM Prozessor entwickeln. Muss mal schaun welcher ARM Prozessor dafür geeignet ist. Link: https://www.roboter-bausatz.de/29/2-2-tft-lcd-modul Gruß Rolf
Super, dass du die Probleme behoben hast! Ich gebe es ja ehrlich zu, dass ich mir nicht so ganz vorstellen kann, dass ein AVR soviel leistet, aber du beweist ja eindeutig das Gegenteil! (Gebe auch zu, dass du mit Sicherheit der bessere Programmierer bist, deswegen würde es mich ja so interessieren, was du mit einem STM32 anstellen könntest!) Es gibt ein paar Infos zu meinem Synth im STM32duino Forum. Am besten von hinten nach vorne lesen, in der Mitte ist sehr viel Gerede bezüglich RTOS und DMA (eher weniger spannend). Fakt ist, dass das Projekt gerade ein bisschen pausiert, da ich ein neues "Spielzeug" (sprich 3d-Drucker) habe, mit dem ich auch ein ordentliches Case bauen will. http://stm32duino.com/viewtopic.php?f=19&t=533&start=40 Liebe Grüße Matthias
Ha, da war auf einmal noch ein Beitrag und: BINGO! Das ist ein ILI9341 TFT, dies läuft unter SPI mit DMA Unterstützung hervorragend mit unserer Arduino IDE Adaption für STM32. Sogar mit einem kleinen Mini Clone wunderbare Leistung mit wenig Kabeln! Hier ein Link zu einem Mini Clone (die BAITE bevorzuge ich sowieso): 5 Stück "Vorteilspackung" um fulminante 3.74 Euro pro Stück (Versandkostenfrei) http://www.aliexpress.com/item/5PCS-LOT-leaflabs-Leaf-maple-mini-ARM-STM32-compatibility/1400682373.html?spm=2114.01020208.3.13.ZyJwFm&ws_ab_test=searchweb201556_2_79_78_77_91_80_61,searchweb201644_5,searchweb201560_9 Unser ganzes Forum kauft beim BAITE Aliexpress-Shop mit höchster Zufriedenheit!
:
Bearbeitet durch User
Hallo Matthias.. Mich würde brennend interessieren, wie du deine Programme für den ST Prozessor entwickelst. Ich habe mal vor zwei Jahren mit der Coocox IDE etwas programmiert. Aber das wars auch schon, weil ich an meinem Synthesizer Projekt weiter arbeiten musste. Habe mir für das MiniScope Projekt auf ST Basis schon das kleine 2.2" TFT und bei Reichelt ein Nucleo-Entwicklerboard für die STM32 F4-Serie bestellt. Hab aber noch keine Ahnung, welche freie Entwicklungsumgebung ich benutzen sollte. Vieleicht kannst du mir ein paar Tips geben. Gruß Rolf
:
Bearbeitet durch User
Lieber Rolf, du wirst lachen, ich verwende die Arduino API! www.stm32duino.com ist die Projektseite, die (als Nachfolgeprojekt von Leaflabs Maple) sich die Aufgabe gestellt hat. STM32 Prozessoren mit der Arduino API zum Laufen zu bekommen. Ich bin seit Entstehung mit dabei beim Projekt und habe etliche Libraries konvertiert (bzw. das NucleoF103 Board adaptiert). Wirklich gut unterstützt wird z.Z. nur die Reihe STM32F103xxx (dafür die komplette Palette und mit allen(!) Features). F4 ist in Entwicklung, wird aber noch ewig dauern, da wir von leafmaple auf HAL umsteigen müssen (bin dabei nicht/kaum involviert, da ich kein F4 Board habe). Witz an der Sache: Wenn du oben genannten Mini Clone bestellst, brauchst du sonst nichts dazu, ist alles "on board". Programmiert wird über Serial USB hat auch einen eigenen Bootloader (Wir haben Bootloader für alle STM32F103xxx MCU's) Dein Nucleo Board kannst du übrigens herrvorragend als ST-Link verwenden - auch für andere STM32 MCU's! edit: Bezüglich Nucleo F4: Da gibt es doch einige Fortschritte: http://stm32duino.com/viewforum.php?f=39&sid=a235ddc603a62e90905de2a6666bd775
:
Bearbeitet durch User
Hallo So.. ich hab mir jetzt zwei Nucleo Kits bei Reichelt bestellt. Das NUCLEO F411RE mit einem STM32F411RET6 Prozessor und das NUCLEO F103RB mit einem STM32F103RBT6 Prozessor. Werde mit beiden Board ein wenig rumspielen um die ARM Prozessoren ein wenig kennen zu lernen. Bin gespannt.. Zum Synth Project. Zur Zeit arbeite ich an der Edit Funktion für die Samples. Danach folgt die komplette Midi Implementierung, so das auch eine CC Steuerung über Midi möglich ist. Gruß Rolf
:
Bearbeitet durch User
Hallöchen.. Falls ihr euch fragt, was ich gerade mache... Ich verbessere gerade das Datei System auf der 4GB SD Karte meines Synthesizers. Dazu gehört das abspeichern oder löschen von Samples und Presets. Das hört sich jetzt nicht gerade kompliziert an, aber die Arbeit steckt mal wieder in den Details. Die Abbildung zeigt die Ordner Stuktur auf der SD Karte. Auf der SD Karte gibt es drei Ordner mit der Bezeichnung PRESET, SAMPLE und SYSTEM. Im Ordner 'Preset' sind die gesamten Sound Parameter, UserWave-Table und ggf das Sample-File für den Sound abgespeichert. Der Ordner 'SAMPLE' beinhaltet die gesamte Sample Library. Hier kann man Samples laden, speichern oder löschen, ohne eine Beeinflussung auf die Preset Sounds. Dadurch kann man z.B. die komplette Sample Library auf der SD Karte ändern oder austauschen, ohne Gefahr zu gehen, dass sich die Preset Sounds verändern. Falls ein Preset ein Sample-File besitzt, wird dieses immer im Preset Ordner mit abgespeichert. Im Ordner 'SYSTEM' befinden sich System relevante Daten wzB Bilder, Sequenzer-Daten, USERWAVE-Table und die aktuelle Midi CC Tabelle. Die USERWAVE-Table besteht aus 128 festen Wellenformen mit 256 Byte Größe und kann beliebig ausgetauscht werden. Damit stehen dem Benutzer unendlich viele Möglichkeiten der Soundgestaltung zur Verfügung. Gruß Rolf
:
Bearbeitet durch User
Hoh hoh hoh.. Bald ist Weihnachten und die Leute kaufen wie verrückt. Ich auch großes Grinsen Zum DE:GENERATOR: Hab die 1.Menü Seite jetzt komplett überarbeitet. Zu jedem Sound Programm werden jetzt die Datei Größe und Wellenform (Sample-File oder Wellenform) angezeigt. Das laden eines Sound Programms funktioniert jetzt doppelt so schnell wie vorher. Damit man beim Suchen eines Sounds in anderen Sound Bänken die Orientierung nicht verliert, wird das aktuelle (geladene) Sound Programm grau markiert und unterm MiniScope nochmal angezeigt. Bild: Menüseite 'Sound Program' Gruß Rolf
Hallöchen.. Die Zeit rast dahin und man hat das Gefühl, nicht mehr viel Zeit zu haben, für die Dinge die man noch machen will. So gehts mir im Moment. Am DE:GENERATOR gibt es einige Änderungen. Um die Bedienung zu vereinfachen sind jetzt 8 Taster vorhanden. Zusätzlich gibts auf dem Front Panel zwei Potis. Diese können für Modulationszwecke frei programmiert werden. Damit das Ganze noch etwas bunter wird, gibts für die Kontrolle der LFO's jetzt drei LED-Lampen. Geplant ist noch die Beleuchtung der DATA Encoder mit blauen LED's. Gruß Rolf
Ho ho ho.. Ich wünsch euch allen ein schönes und gemütliches Weihnachtsfest. Ich habe testweise mal einen Encoder mit den blauen LED's bestückt. Wenn jetzt noch die Löcher in der Frontplatte etwas größer gemacht werden, so das Knopf das Loch nur knapp abdeckt, sollte etwas blaues Licht an den Seiten austreten. Hier mal zwei Pics.. Bild: LED Beleuchtung für Encoder Gruß Rolf
So.. die "Weihnachstbeleuchtung" ist jetzt komplett ;) Bild: LED Beleuchtung der Encoder Jetzt wird noch ein wenig an der Soundengine gearbeitet um die Bedienung zu verbessern. Gruß Rolf
Hi Rolf! Für deine Weihnachtsbeleuchtung würden sich doch hervorragend diese hier eignen: http://www.aliexpress.com/item/20xBrand-New-Transmittance-6mm-15-64-Shaft-Diameter-Plastic-light-emitting-Encoder-knobs-free-shipping-10000403/530833535.html Gibt es auch in leicht abgwandelten Versionen: http://www.aliexpress.com/wholesale?catId=0&initiative_id=SB_20151227085820&SearchText=Plastic+light-emitting+Encoder+
Hallo Matthias. Danke für den Hinweis. Der Knopf sieht interessant aus.
Knöpfe sind nur ein bisschen größer als die "normalen" (lt. meiner Schätzung sollte es bei deinem Aufbau kein Problem ergeben). Verwende diese selbst bei meinem Synth -> die vom ersten Link kann ich bedenkenlos empfehlen, wurden einzeln verpackt (bzw eingewickelt) verschickt und sind 1A für den Preis. Natürlich würden diese sich auch für einen LED Kranz eignen, aber das tu ich mir mit Lochraster sicher nicht an :)
Was ich zur Zeit mache.. Ich arbeite noch ein wenig an der Loop-Funktion (siehe Bild). Gruß Rolf
Hallo zusammen.. Ich hoffe Ihr seit alle gut ins neue Jahr gerutscht und habt keinen Kater bekommen. Wenn ich an die Bowle denke... man die war so lecker holy-willi Mein Kollege Andre war in den letzten Tagen auch sehr fleißig und hat die ersten Platinen und Gehäuse Entwürfe gezeichnet. Wegen der besseren Abstimmung untereinander, habe ich beschlossen, die ganzen Schaltpläne von Eagle nach Target 3001 zu importieren. Andre entwirft mit Target 3001 dann die Platinen für den DE:GENERATOR. Target 3001 gibts auch als Freeware von distrelec mit der Einschränkung auf maximal 700 Pins. Hier der Link: http://www.distrelec.de/de/cad-freeware/...ice_cadfreeware 1.Bild: Gehäuse Entwurf DE:GENERATOR 2.Bild: Hardwareaufbau
:
Bearbeitet durch User
Hallöchen.. So ein Digi Scope ist doch eine feine Sache wie ich finde. Es hilft doch sehr bei der Fehlersuche ebueb Die Tage hatte ich ein Problem mit einem Encoder. Bei der Dateneingabe hatte ich öffters Zahlensprünge. Ich dachte zuerst an ein Problem in meiner Software, weil diese immer wieder weiterentwickelt und geändert wird. Aber Test brachten mich nicht weiter. Die Encoder und Tasten werden im DE-GENERATOR alle 500msec abgefragt. Das ist auch für eine schnelle Umdrehung der Encoder schnell genug. Das Problem musste also an der Hardware liegen. Hab dann mein Digi Scope "angeschmissen" und mal an die Kontakte des Encoders angeschlossen. Und siehe da.. viele nette Impulsefolgen und noch viel mehr. Das auf dem Bildschirm sah so gar nicht nach einem Gray-Code von einem Encoder aus. Die beste Software kann dieses Prellen nicht beseitigen. 1.Bild: Ich hab dann einen neuen Encoder eingelötet und alles funktioniert jetzt fehlerfrei. 2.Bild: Signalverlauf am alten Encoder. Man sieht deutlich wie die Signalflanken prellen Gruß Rolf
Hallöchen.. Ich hab den externen Audio-Eingang im DE-GENERATOR etwas abgeändert. Man hat jetzt die Möglichkeit das Stereosignal am Eingang als Summensignal zu sampeln. Ferner ist das Eingangssignal auch auf die Filtereingänge geschalten. Für die MiniScope-Funktion wird der Stereoausgang auf den gleichen ADC-Eingang geschaltet. Das spart Bauteile und Platz auf der Platine. Bild: Stereo Eingang im DE-Generator Gruß Rolf
Hallo zusammen.. Damit das Sampeln von Audio-Signalen noch etwas störungsfreier funktioniert, habe ich den ADC-Eingang im Xmega Prozessor als Differenzial-Eingang beschaltet. Der ADC im Xmega Prozessor sampelt mit 12Bit und einer Abtastrate von 44.1KHz. Intern wird der 12Bit Wert dann auf 8Bit herunter gerechnet und ins 1MByte große Sample-Ram geschrieben. Der Operationsverstärker IC 15c+15d erzeugen aus dem Audio-Signal ein Differenzsignal für den ADC-Eingang. ATMEL Notes ADC im Xmega128A1: http://www.atmel.com/images/atmel-8032-using-the-atmel-avr-xmega-adc_application-note_avr1300.pdf Bild: ADC mit Differenzial-Eingang Initialisierung des ADC im Xmega128A1 Prozessor
1 | // 12Bit / differencial mode / ext.VRef 2.5V PortA0 / Prescaler 64 / positive Input PortA3 / negative Input PortA1
|
2 | ADCA.CTRLB = ADC_RESOLUTION_12BIT_gc | ADC_FREERUN_bm; |
3 | ADCA.REFCTRL = ADC_REFSEL_AREFA_gc; |
4 | ADCA.PRESCALER = ADC_PRESCALER_DIV64_gc; |
5 | ADCA.CH0.CTRL = ADC_CH_INPUTMODE_DIFF_gc; |
6 | ADCA.CH0.MUXCTRL |= ADC_CH_MUXPOS_PIN3_gc | ADC_CH_MUXNEG_PIN1_gc; |
7 | ADCA.INTFLAGS = 0x00; |
8 | ADCA.CTRLA = ADC_ENABLE_bm; // ADC enabled |
Gruß Rolf
Hallöchen.. Im DE:GENERATOR habe ich für die Sample Aufnahme eine Noise Shaper Function integriert. Der ADC-Eingang arbeitet mit einer Auflösung von 12 Bit. Für die weitere Bearbeitung werden die Samples im DE:GENERATOR auf 8Bit herunter gerechnet. Beim normalen Herunterrechnen von 12 auf 8Bit (4* rechts Shiften) entsteht bei leisen Signalen ein sehr störendes pumpartiges Rauschen. Der Noise Shaper verschiebt dieses Rauschen in einen höheren Frequenzbereich, so dass unser Ohr das Rauschen als weniger störend wahrnimmt. Programmcode
1 | //*************************************************************************
|
2 | // Test noise-sharping 12Bit 44.1KHz
|
3 | //*************************************************************************
|
4 | ISR(TCC0_OVF_vect) |
5 | {
|
6 | |
7 | // Noise Shaper function
|
8 | int16_t sample_x = ADCA_CH0RES; |
9 | int16_t sample_16 = sample_x * 12; |
10 | sample_16 += quant_error; |
11 | if (sample_16 < -32768){sample_16 = 32768;} |
12 | else if (sample_16 > 32767){sample_16 = 32767;} |
13 | int8_t sample_8 = sample_16 >> 8; |
14 | quant_error = sample_16 - ((int16_t)(sample_8) << 8); |
15 | |
16 | /* convert 12Bit into 8Bit
|
17 | uint16_t sample_16 = ADCA_CH0RES;
|
18 | uint8_t sample_8 = sample_16 >> 4;
|
19 | */
|
20 | |
21 | // DAC out
|
22 | DACA.CH0DATAH = sample_8; |
23 | DACB.CH0DATAH = sample_8; |
24 | |
25 | }
|
Um das zu demonstrieren habe ich ein paar Klangbeispiele aufgenommen. Jeweils ohne und mit der Noise Shaper Funktion. Am deutlichsten hört man es bei Sound 3+4. Ohne Noise Shaper versinkt das Piano quasi im 8Bit Rauschen. "Sound 1 without NS": https://drive.google.com/file/d/0BxbpDqwYdkvER2RMM2lyRkRFWFE/view?usp=sharing "Sound 2 with NS": https://drive.google.com/file/d/0BxbpDqwYdkvEVFVZZDdQTDhrdlk/view?usp=sharing "Sound 3 without NS": https://drive.google.com/file/d/0BxbpDqwYdkvEN3ZRMVVxbWRJeWc/view?usp=sharing "Sound 4 with NS": https://drive.google.com/file/d/0BxbpDqwYdkvEa1pReEhOTGdIR2M/view?usp=sharing "Sound 5 without NS": https://drive.google.com/file/d/0BxbpDqwYdkvEREF2WkV4YWEyY00/view?usp=sharing "Sound 6 with NS": https://drive.google.com/file/d/0BxbpDqwYdkvEZXZwdGJTaVN4S00/view?usp=sharing Gruß Rolf
:
Bearbeitet durch User
Von Andre gibts eine nächste Beta fürs DE:GENERATOR Gehäuse Bild Gehäuse Entwurf Beta15
Hallöchen.. Es gab einen kleiner Fehler im Programmcode vom NoiseShaper
1 | //*************************************************************************
|
2 | // Test noise-sharping 12Bit 44.1KHz
|
3 | //*************************************************************************
|
4 | ISR(TCC0_OVF_vect) |
5 | {
|
6 | |
7 | // Noise Shaper function
|
8 | int16_t sample_x = ADCA_CH0RES; |
9 | int16_t sample_16 = sample_x * 16; // alt int16_t sample_16 = sample_x * 12; |
10 | sample_16 += quant_error; |
11 | if (sample_16 < -32768){sample_16 = 32768;} |
12 | else if (sample_16 > 32767){sample_16 = 32767;} |
13 | int8_t sample_8 = sample_16 >> 8; |
14 | quant_error = sample_16 - ((int16_t)(sample_8) << 8); |
15 | |
16 | /* convert 12Bit into 8Bit
|
17 | uint16_t sample_16 = ADCA_CH0RES;
|
18 | uint8_t sample_8 = sample_16 >> 4;
|
19 | */
|
20 | |
21 | // DAC out
|
22 | DACA.CH0DATAH = sample_8; |
23 | DACB.CH0DATAH = sample_8; |
24 | |
25 | }
|
Hallo zusammen.. Der Schaltplan für das Frontpanel ist jetzt fertig. Insgesamt gibt es jetzt 13 Tasten, fünf Drehimpulsgeber und 3 Potis. Für die indirekte Beleuchtung der Drehimpulsgeber und Potis sorgen 32 LED's. Für spezielle Statusinformationen wzB Midi-Empfang und laufende LFO gibt es noch zusätzliche rote LED's. Die LED-Farbe kann aber bei der Bausatzbestellung selber ausgewählt werden. Das LCD-Display wird über einen 8Bit breiten Datenbus vom Xmega Prozessor angesteuert. Mit dem Latch IC1a werden die oberen Adress- und Datenleitungen DB8-DB15 für das LCD erzeugt. Die LED-Hintergrundbeleuchtung liegt über R67 1.5 Ohm direkt an der Versorgungsspannung von +3.3 Volt. Die Drehimpulsgeber und Tasten werden mit Hilfe eines Schieberigster IC3a, IC4a und IC5a über die SPI-Schnittstelle am Xmega Prozessor abgefragt. Über die gleiche SPI-Schnittstelle steuert das Schieberegister IC6a die roten Status LED's an. Pot1+2 sind über zwei ADC-Eingänge am XMega verbunden und werden jede Millisekunde abgefragt. In der Modulationsmatrix kann diesen Potis ein oder auch mehrere Modulationsziele zugewiesen werden. Das Volum-Poti ist ein Stereo-Poti und steuert die Lautstärke am Audioausgang. Bild 1: Schaltplan Frontpanel Bild 2: Schaltplan Prozessor Board Link Bild 1: https://photos.google.com/share/AF1QipOzxUJT_nnlkRyNHtbHf85fpViZE3womQwTsWFHssgqgSv8d8l3uQEc8k6EdGwLtw?key=azhUOEVrblRYVkI2dnF2M0lZWTJyOXhHX1F5Zlpn Link Bild 2: https://photos.google.com/share/AF1QipOx4YGPVw4SKU2MrA6VtxQln3-C_vUnRaZQTQRoKlPJn6UWMzaTNaybrb1q-jFiBg?key=eWhkT0tGTENYdndxc3FXWjBTcFJISTIyWkM0U21n Gruß Rolf
Rolf D. schrieb: > Das LCD-Display So so, das LCD-Display .... .... oder auch die sogenannte "LCD-Display-Anzeige"
@Doitschlehra Ja.. eigentlich müsste es LC-Display heißen. Aber die meisten Kollegen sagen auch LCD-Display ;) Hallöchen.. Andre aus unserem Team hat den ersten Entwurf für die Prozessor-Platine gemacht. Da die Platine mit einigen SMD-Bauteile bestückt ist und wir den Kunden diese Lötarbeit nicht zumuten wollen, werden wir diese selber löten und getestet ausliefern. Der Preis steht noch nicht fest. Bild: Prozessor Board im DE-GENERATOR Gruß Rolf
:
Bearbeitet durch User
Hallo ihr Lieben! Da die Entwicklung der Platinen noch etwas andauert, habe ich die Zeit genutzt und an der Verbesserung der Menüoberfläche gearbeitet. Damit man die Menüseiten besser unterscheiden kann, haben diese jetzt farbige Frames, die nach Funktionsgruppen sortiert sind. So haben zum Beispiel die Menüseiten für den Oszillator alle einen blauen Frame und die LFO's einen grünen Frame. Bild 1: Die Menüseite für den Filter wurde auch überarbeitet. Entsprechend der eingestellten Filterfunktion wird der Frequenzverlauf und die Resonanz als grafische Filterkurve dargestellt. Ein kleines Scope Fenster auf der rechten Seite zeigt die Wellenform des Filterausganges in Echtzeit an. Bild 2: Das MiniScope hat jetzt eine bessere Triggerfunktion erhalten. Der Triggerlevel kann jetzt auch auf negative Amplitudenwerte eingestellt werden. Auf der linken Seite zeigt ein kleiner gelber Pfeil auf den eingestellten Pegel. Wird der Triggerlevel auf 0 eingestellt, ist die Triggerfunktion ausgeschaltet. Als nächstes steht die Oszillator Engine auf dem Programm. Ich will das Bedienkonzept etwas vereinfachen. Dadurch wird die ganze Sachen dann etwas überschaubarer. Bis zum nächten Post und ein schönes Wochenende. Gruß Rolf
Hallöchen.. Andre hat das CPU-Board jetzt fertig entwickelt. Ich muss es jetzt auf Fehler überprüfen und wenn alles gut ist werden diese Woche die ersten Platinen in China bestellt. Bin gespannt.. Die zwei Pfostenleisten K3 und K4 verbinden das CPU-Board über zwei Flachbandkabel mit dem Bedienpanel für die LCD-Anzeige, Tasten und Encoder. Die restlichen Pfostenleisten sind mit dem Motherboard verbunden und zuständig für Stromversorgung, Audio- und Steuerleitungen. Die zwei 8 poligen Pfostenleisten auf der linken Seite des CPU-Boards sogen für einen sicheren und festen Halt der SD Karte Buchse. Bild 1-3: DE-GENERATOR CPU-Board Gruß Rolf
:
Bearbeitet durch User
Hallo.. ich schon wieder Augenzwinkern Um den DE-GENERATOR in seiner "unbegrenzten" Möglichkeit der Klangerzeugung noch zu steigern, können jetzt die 128 festen Wellenformen als Wellenform Bank von der SD Karte geladen werden. Insgesamt besteht dann die Möglichkeit auf 128*100 Waveforms und 128*100 Sample-Files zu zugreifen . Eine Wellenform Bank besteht aus 128 einzelnen 256 Byte großen Wellenformen. Diese können zB am PC mit einem Audioeditor (Audacity) hergestellt und auf die SD Karte kopiert werden. Im Oszillator Menu kann dann der Benutzer auf die verschiedenen Wellenform Bänke und Sample-File Bänke zugreifen. Eine Editierung der Wellenform Bank ist im DE-GENERATOR momentan noch nicht vorgesehen. Mit dem Mode Schalter kann zwischen der Auswahl von Wellenform oder Sample-File umgeschaltet werden. Bilder: Auswahl von Waveforms und Sample-Files Gruß Rolf
Hallöchen. Was ich zur Zeit mache.. nix Augenzwinkern Das war gelogen. Ich arbeite zur Zeit an ein paar Midi-Routinen für den DE:GENERATOR. Bei einer Routine handelt es sich um eine kleine Midi Noten Verwaltung (NoteStack). Der NoteStack macht folgendes: Wenn ich eine Midi Note spiele, wird die Noten Nummer auf Platz 1 im NoteStack gespeichert und der Ton vom Synthesizer gespielt. Lasse ich die Taste wieder los, so wird die Note im NoteStack gelöscht und der Ton wird ausgeschaltet. Simpel.. Jetzt drücken wir aber zwei Noten. Fast passiert: Zuerst wird die 1.Note auf Platz 1 im NoteStack gespeichert und der Ton gespielt. Danach wird die 2.Note auf Platz 2 im NoteStack gespeichert und der Ton für die 2.Note gespielt. Damit befinden sich jetzt zwei Noten im NoteStack. Die 1.Note auf Platz 1 und die 2.Note auf Platz 2. Lasse ich jetzt die 2.Note los, so wird im Stack die 2.Note auf Platz 2 gelöscht und der Ton für die 1.Note gespielt. Änliches passiert wenn die 1.Note losgelassen wird und die 2.Note noch gespielt wird. Dadurch wird dann die 1.Note auf Platz 1 im NoteStack gelöscht und die 2.Note auf Platz 1 verschoben. Der Ton für die 2.Note wird ohne Unterbrechung weiter gespielt. Insgesamt können 16 Noten im NoteStack verwaltet werden. Bild: NoteStack Schema C-Code Beispiel
1 | uint8_t NoteStack_pool[10]; |
2 | uint8_t NoteStack_ptr = 0; |
3 | uint8_t NoteStack_size = 10; |
4 | |
5 | //-------------------------------------------------------------------------
|
6 | // NoteOn
|
7 | //-------------------------------------------------------------------------
|
8 | void midi_NoteOn(void) |
9 | {
|
10 | uint8_t midi_note_temp = midi_data[0]; // load midi_note |
11 | |
12 | if (NoteStack_ptr < NoteStack_size) |
13 | {
|
14 | midi_note = midi_note_temp; |
15 | NoteStack_pool[NoteStack_ptr] = midi_note; // write current note into notestack_pool |
16 | NoteStack_ptr++; |
17 | midi_sync_flag = 1; // start envelopes |
18 | }
|
19 | }
|
20 | |
21 | |
22 | //-------------------------------------------------------------------------
|
23 | // NoteOff
|
24 | //-------------------------------------------------------------------------
|
25 | void midi_NoteOff(void) |
26 | {
|
27 | // load current note
|
28 | uint8_t midi_note_temp = midi_data[0]; |
29 | uint8_t last; |
30 | |
31 | // search current note into notestack_pool
|
32 | for (uint8_t i = 0; i < NoteStack_size; i++) |
33 | {
|
34 | if (NoteStack_pool[i] == midi_note_temp) |
35 | {
|
36 | // clear current note into notestack_pool
|
37 | NoteStack_pool[i] = 0xFF; |
38 | NoteStack_ptr--; |
39 | last = i; |
40 | |
41 | // sort notes into notestack_pool
|
42 | for (last; last < NoteStack_size;last++) |
43 | {
|
44 | NoteStack_pool[last] = NoteStack_pool[last+1]; |
45 | }
|
46 | |
47 | // playing previous note
|
48 | if (NoteStack_ptr > 0) |
49 | {
|
50 | last = NoteStack_ptr-1; |
51 | midi_note = NoteStack_pool[last]; |
52 | frequency_tune(); |
53 | }
|
54 | else
|
55 | {
|
56 | // stop envelope if no note into notestack_pool
|
57 | midi_gate_flag = 0; |
58 | }
|
59 | break; |
60 | }
|
61 | }
|
62 | }
|
Gruß Rolf
Hallöchen.. Heute sind die CPU Platinen für den DE:GENERATOR aus China eingetroffen. Wir haben insgesamt 10 Stück bestellt. Jetzt gehts ans SMD löten. Bin gespannt ob wir's hinbekommen. Bilder: CPU Platine für den DE:GENERATOR
Wir planen 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. Das Audiosignal kann Filtereingang oder Sampleeingang geroutet werden. Um eine Rückkopplung bei der Sampleaufnahme mit eingeschalteter Monitorfunktion zu vermeiden, muss der Filtereingang stumm schalten werden. Bild: DE:GENERATOR Motherboard und externer Audio-Input Gruß Rolf
:
Bearbeitet durch User
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 schon 5KByte im SRAM für Systemdaten und Variablen. 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 Sample-Speicher
Hallöchen.. Live aus Wuppertal Zur Zeit bin ich leider nicht in Berlin auf der SUPERBOOTH 16 sondern in Wuppertal und arbeite an den letzten Feinheiten für den DE:GENERATOR. Mein Kollege Andre Laska aus Oer Erkenschwick ist als Vertreter unseres DE:GENERATOR Teams vor Ort und schaut sich mal um was die Konkurrenz so treibt. Aus Kostengründen haben wir uns entschieden, keinen Stand zu mieten. Herr Schneider als Geschäftsführer und Mitorganisator der SUPERBOOTH 16 hatte uns freundlicherweise noch ein Plätzchen freigehalten. Aber vielleicht klappt's ja dann beim nächsten Mal.. Für alle Liebhaber der Elektronischen Musik und der Musikelektronik ist die SUPERBOOTH das Highlight des Jahres in Berlin. Ein Tag wäre viel zu kurz um die Vielfalt der Technik und die ganzen Möglichkeiten der Elektronischen Musik zu zeigen und zu hören. Aus diesem Grund findet die SUPERBOOTH ab Heute volle drei Tagen lang statt. Das gebotene Programm ist reichhaltig. Von Gesprächskonzerten, Workshops, Klanginstallationen bis zu DIY Workshops wird viel geboten. Namhafte Aussteller wzB Dieter Doepfer, Steinberg, Yamaha, Waldorf Musik uvm sind vor Ort. Für "Stubenhocker" wie mich Augenzwinkern oder Leute die keine Möglichkeit haben nach Berlin zu fahren, gibt auf der SUPERBOOTH Website die Möglichkeit per Livstream dabei zu sein. Link SUPERBOOTH Livestream: https://www.superbooth.com/de/ Bild: SUPERBOOTH 16 in Berlin Bis dahin liebe Grüße aus Wuppertal. Rolf
Hallöchen.. Zur Abwechslung habe ich am DE:GENERATOR mal wieder etwas rumgeschraubt bzw etwas rumgelötet. Die Schaltung für den externen Audioeingang und Mikrovonverstärker wurden optimiert. Ferner ist eine Audio-Clipping Schaltung für den ADC-Eingang integriert worden. Schaltungsbeschreibung Für die Oszilloskop Funktion im DE:GENERATOR wird das Ausgangssignal beider VCAs auf den Operationsverstärker IC15a geführt. Dieser summiert das Signal und führt es anschließend auf den Eingang von IC14a das hier als Signal-Umschalter für den ADC Eingang dient. Über den Trimmer R73 wird der maximale Pegel für den ADC-Eingang eingestellt. Um Übersteuerungen am ADC-Eingang zu begrenzen, ist eine Clipping-Schaltung mit IC16a realisiert worden. Die Transistoren T1 und T2 begrenzen das Ausgangssignal von IC16a auf ca. 1.2 Volt. Anschließend wird das Signal mit IC16b noch etwas verstärkt um die volle Dynamik des ADC auszunutzen. Um die systembedingten Störungen in der Sample Aufnahme zu verringern, ist der ADC-Eingang als Differenzial Eingang geschaltet. Mit IC16c wird das Signal negiert und an den negativen ADC-Eingang geführt. Für eine weitere Verbesserung der Aufnahme sorgt eine externe Referenzspannungsquelle mit IC17. Der Komperatoreingang am Xmega Prozessor dient als externe Trigger-Eingang für die Oszilloskop-Funktion. Für den Mikrofonverstärker habe ich einen rauscharmen Operationsverstärker vom Typ NE5532 genommen. Laut Datenblatt liegt das Rauschen bei 5nV/Hz. Als Schaltungsvariante habe ich einen Nichtinvertierenden Operationsverstärker mit hohem Eingangswiderstand und 100 facher Verstärkung benutzt. Der hohe Eingangswiderstand hat den Vorteil, dass bei Anschluss von hochohmigen Mikrofonen die Ausgangsspannung des Mikrofons nicht zusammenbricht. Im DE:GENERATOR verwende ich ein preisgünstiges Elektret Mikrofon mit einer Ausgangsimpedanz von 2.2 KOhm. Der Widerstand R92 versorgt das Elektret Mikrofon mit der notwendigen positiven Versorgungsspannung. Der externe Audio-Eingang gelangt über das als Summierer geschaltet IC15d an den Signal-Umschalter IC14a und von da an den ADC-Eingang. Ferner kann das externe Audio-Signal auch auf den Filter-Eingang geschaltet werden. Bei Sample-Aufnahmen wird der Filter-Eingang durch IC14a gesperrt bzw an GND gelegt um eine Signalrückkoplung zu vermeiden. Auf aufwendige Aliasing-Filter am ADC-Eingang wurde hier verzichtet, da die Samplerate mit 44,1kHz sehr hoch ist und die Aufnahmen trotz fehlender Aliasing-Filter gut klingen. Externer Audioeingang im DE.GENERATOR Gruß Rolf
Hallo zusammen.. Die CPU-Platine für den DE:GENERATOR ist fertig gelötet. Wir habe eine kleine Elektronik Firma gefunden, die uns die Platinen kostengünstig löten kann. Somit entfällt das zeitaufwendige Löten der SMD-Bauteile. Ich habe es Gestern selber versucht und ca. eine Stunde für die komplette Bestücken und das Löten benötigt. Ich baue jetzt einen kleinen Testadapter mit einem TFT-Display und programmiere ein paar Testroutinen. Dann muss das gute Teil nur noch funktionieren und ich wäre happy ebueb Der nächste Arbeitsschritt ist das Layouten des Motherboards. Diese Platine wird etwas aufwendiger sein und doppelt so groß werden wie die CPU-Platine. Gruß Rolf
Hallo zusammen.. Gestern traf ich mich mit dem Kollegen Andre aus Oer-Erkenschwick. Er brachte zwei fertig bestückte Muster Platine des CPU-Boards zum testen mit. Um die CPU Platinen zu testen, habe ich einen kleinen Testadapter mit LED's und Display gebaut (siehe Bild). Der Test überprüft alle Port-Leitungen der CPU mittels LED. Um das Display zu testen, wird ein Bild von der SD-Karte geladen und an das Display übertragen. Zum Schluss wird das 1MByte große SRAM überprüft. Bei dem Test für die Port-Leitunge viel mir auf, dass 4 Port-Leitungen (PB4 - PB7) nicht richtig funktionierten. Schuld war die JTAG Funktion im Xmega Prozessor. Diese ist ab Werk eingeschaltet und muss per Umprogrammierung der Fuses ausgeschaltet werden (siehe Bild). Damit stehen die 4 Port-Leitung zur freien Verfügung. Lieben Gruß aus Wuppertal. Rolf
Hallo ihr Lieben.. Die Tage hat mich etwas schockiert... aber nur ein wenig Augenzwinkern Unsere holländischen Kollegen von Tasty Chips Electronics bauen seit geraumer Zeit auch an einem Synthesizer namens ST4 und haben damit eine erfolgreiche Kickstarter Kampagne absolviert. Nicht das ich neidisch bin, weil einige Dinge am ST4 zufällig ähnlich aussehen wie am DE:GENERATOR und die Kollegen schon viel weiter sind als wir... Nein ich finde es immer wieder gut, dass es in der Synthi Scene kreative und kluge Menschen gibt von denen man positiv überrascht wird und viel lernen kann ebueb Bild 1: ST4 Synthesizer von Tasty Chips So auch die Sache mit den externen Netzteilen. Tasty Chips Electronics beschreibt auf der eigenen Website, dass sie ihr AC-Steckernetzteil für den ST4 Synthesizer nicht mehr in die EU importieren dürfen. Daraufhin mussten sie die Stromversorgung für ihren ST4 Synthesizer redesignen um ein Schaltnetzteil zu verwenden . Das wollte ich jetzt aber genauer wissen, denn ich verwende für den DE:GENERATOR auch ein AC-Steckernetzteil. Auf der Suche nach der entsprechenden EG-Richtlinien wurde ich in der "Netzteil-Verordnung (EG) Nr. 278/2009: Vorgaben zur Leistungsaufnahme und Effizienz" fündig. Mit der Verordnung zur sogenannten Ökodesign-Richtlinie begrenzt die Europäische Kommission die Leistungsaufnahme von elektrisch betriebenen Geräten für private Haushalte. Die Leistungsaufnahme muss im vermeintlichen „Aus“-Zustand auf 0,5 bis 1 Watt sinken. Dadurch soll elektrischer Energie eingespart werden, die ungefähr dem jährlichen Landesverbrauch von 129.400 kWh in Schweden entspricht. Hier ausführliche Informationen zum nachlesen: http://www.it-recht-kanzlei.de/externe-n...richtlinie.html Für unseren DE:GENERATOR verwenden wir auch ein AC-Steckernetzteil. Es ist leider nicht möglich, das AC-Steckernetzteil gegen ein DC-Schaltnetzteil auszutauschen, da im DE:GENERATOR einige Baugruppen eine negative Versorgungsspannung benötigen. Da mein Kollege Andre mit der Entwicklung des Motherboards noch nicht begonnen hat, hab ich mich sofort auf meinen Hosenboden gesetzt und die Stromversorgung im DE:GENERATOR geändert. Die Stromversorgung soll jetzt über ein handelsübliches 12 Volt DC-Schaltnetzteil erfolgen. Im DE:GENERATOR werden drei Spannungen benötigt. Zum einen eine 3.3 Volt Spannung für das CPU-Board und +8 Volt/ -8Volt für die VCA's und das Filter-Board. Die -12V Spannung wird durch zwei parallel geschaltete TL1054 IC's erzeugt. Der TL1054 arbeitet nach dem Prinzip einer Ladungspumpe und ist in meiner Schaltung als Spannungs-Inverter geschaltet. Der TL1054 liefert an seinem Ausgang maximal 100mA Strom. Da wir für die negative Versorgungsspannung einen Strom von maximal 150mA benötigen, müssen zwei TL1054 parallel geschaltet werden. Bei einer Belastung von 150mA sinkt die Ausgangsspannung am TL1054 auf ca. -10,8 Volt was für den 7908 aber noch ausreicht um stabile -8 Volt zu erzeugen. Bild 2: Neue Spannungsversorgung im DE:GENERATOR Bild 3: Alte Spannungsversorgung im DE:GENERATOR Bild 4+5: Neue -12V Spannungsversorgung Was mir in der Schaltung noch nicht ganz gefällt, ist der hohe Energieverlust am LM1086 Spannungsregler. Dieser verheizt ca. 2 Watt und muss über einen kleinen Kühlkörper gekühlt werden. Das könnte man eventuell mit einem kleinen Schaltregler wzB dem LM2574 oder LM2575 verbessern. Ich werde das mal ausprobieren. Ein "grüner Engel" ist mir dann bestimmt sicher holy-willi Liebe Grüße aus dem sonnigen Wuppertal. Rolf
:
Bearbeitet durch User
Hallo an einem sonnigen Sonntag in Wuppertal smile Hier die Schaltungsvariante mit einem Schaltregler LM2575 für die 3.3 Volt Spannungsversorgung. Ich will hoffen das der LC-Filter (L3 und C7) die 52KHz Schaltfrequenz am Ausgang des Schaltreglers soweit unterdrückt, dass es keinen Störeinfluss auf den ADC-Eingang und DAC-Ausgang im Xmega Prozessor gibt. Diode D3 und D5 dienen als Verpolungs- und Überspannungsschutz. Bild: Stromversorgung mit Schaltregler LM2575 Durch den Schaltregler verringert sich die Verlustleistung um ca. 2.6 Watt. Eventuell kann ich sogar auf einen Kühlkörper am LM2575 verzichtet und ein 12V DC-Netzteil mit weniger Leistung anstatt 1000mA eines mit 600mA verwenden. Ferner reduziert das ein wenig die Kosten des Bausatzes. Bauteile sind jetzt bei Reichelt bestellt und dann wird wieder gebastelt. Gruß Rolf
Hallöchen.. Schaltung klappt. Hatte noch einen LM2574 in meiner Bastelkiste liegen. Der LM2574 ist der kleine Bruder vom LM2575 und kann nur 0.5A Strom. Der Rippel am 3.3 Volt Ausgang liegt unter 20mV und ist weder am ADC noch am DAC des Xmega Prozessors hörbar. Der kleine LM2574 muss jetzt 200mA auf der 3.3 Volt Spannungschiene liefern und wird dabei nur handwarm. Aus Kostengründen nehmen wir aber den leistungsstärkeren LM2575. Dieser ist etwas billiger und kann 1A. Die Gesamtstromaufnahme des DE:GENERATOR's liegt jetzt bei 12V/375mA. In der alten Schaltung lag er noch bei 470mA. Die aktuelle Leistungsmessung am Netzteil ist 5.6 Watt. Damit ist die Stromversorgung im DE:GENERATOR optimal gelöst. Es gibt keine heißen Bauteile mehr und klobige Kühlkörper die wertvollen Platz auf der Platine verschwenden. Die Europäische und Internationale Gemeinschaft kann sich jetzt über ein Energieeffizentes Musikinstrument freuen ebueb Gruß Rolf
Hier ist die Final Version meiner Netzteilschaltung im DE:GENERATOR. Ich habe noch ein paar Filterspulen an den Eingängen der Schaltregler integriert um die hochfrequenten Störungen auf der +12V Versorgungsleitung zu verringern. Bild: Netzteilversorung im DE:GENERATOR Gruß Rolf
Hallo Audiomann Leider gibts noch keine komplette Sound Bibliothek. Auf soundcloud kann man sich aber schon einiges anhören. Sound Beispiele auf Soundcloud: https://soundcloud.com/rolfdegen/sound-xxl https://soundcloud.com/rolfdegen/wave-sounds-from-my-diy-synth-diywa https://soundcloud.com/rolfdegen/wavedemo-01 https://soundcloud.com/rolfdegen/wavesound-from-my-new-1mbyte https://soundcloud.com/rolfdegen/halloween-sound https://soundcloud.com/rolfdegen/avr-synthesizer-wave-1-stereo Abropo Sounds: Für die Final Version des DE:GENERATORS wird es vermutlich noch einen besseren Stereo Multimode Filter geben. Gruß Rolf
Das Thema Stromversorgung im DEGENERATOR ist leider noch nicht ganz abgeschlossen. Da der LT1054 Baustein doch recht teuer ist, habe ich mich dazu entschlossen, eine andere Variante mit zwei Schaltreglern vom Typ LM2596 auszuprobieren. Die Schaltregler arbeiten mit einer höheren Schaltfrequenz von 150KHz und benötigen kleineren Spulen. Für die beiden LM2596 gibts bei Reichelt noch einen günstigen Vergleichtypen mit der Bezeichnung P3596. Diesen habe ich gleich mitbestellt und werde die Schaltung mit beiden Typen mal testen. Ferne besitzen beide Schaltregler eine Verzögerungsschaltung für die Strombegrenzung beim Einschalten an Pin 5 (on/off). Am negativen Schaltregler IC X4 sorgt die Diode D8 dafür, das der Ausgang im Einschaltmoment nicht positiv wird. Bild: Stromversorgung mit zwei Schaltreglern Gruß Rolf
Hallöchen.. Leider gibts auch in der Elektronikentwicklung Probleme die erst später auffallen. So auch bei der Entwicklung der Netzteilversorgung in meinem Synthesizer. Ich musste die Schaltung mit einer Unterspannungserkennung (Undervoltage Lockout) erweitern, da mein kleines 12V DC-Steckernetzteil (Reichelt SNT 1000 12V Goobay) mit dem hohen Einschaltstrom der Schaltregler nicht klar kam und jedesmal die Spannung im Einschaltmoment zusammengebrochen ist. Bemerkt hatte ich den Fehler, als ich das stromlose Steckernetzteil mit dem Synthesizer verbunden hatte und es dann über die Steckdosenleiste eingeschaltet habe. Vorher war das Steckernetzteil schon in Betrieb und ich hatte nur den DC-Stecker vom Netzteil mit dem Synthesizer verbunden. In der geänderten Schaltung (Bild 1) startet der Schaltregler erst, wenn die Versorgungsspannung vom Steckernetzteil auf über 11 Volt angestiegen ist. Es funktioniert jetzt fehlerfrei mit allen 12V Steckernetzteilen die ich hier so rumliegen habe smile Für die Unterspannungserkennung sorgen Transistor T1 und die Z-Diode D10. Solange die Versorgungsspannung unter 11 Volt liegt sperrt Transistor T1 und der ON/OFF Pin5 des Schaltreglers liegt auf high Potential. Steigt die Versorgungsspannung über 11 Volt wird T1 leitend und schaltet den ON/OFF Pin des Schaltregler auf low Potential womit der Schaltregler seine Arbeit aufnimmt (kann man sehr gut in Bild 3 sehen). Die negative Ausgangsspannung von Schaltregler X4 wird durch die Widerstände R1, R2 und R5 auf -10,6V bestimmt. Für den dahinterliegenden Festspannungsregler 7908 sollte diese Spannung ausreichend sein um eine stabile -8V Spannung auch bei höherer Belastung zu liefern. Aus Kosten- und Platzgründen auf dem Motherboard haben wir uns entschlossen die +5 Volt und +3.3V Versorgung über zwei Festspannungsregler zu machen. Bild 1: DEGENERATOR Power supply Bild 2: Spannungsverlauf gelb: Spannungsverlauf 12V DC-Netzteil blau: -10,6V Spannungsverlauf am Eingang Festspannungsregler 7908 Bild 3: Undervoltage Lockout on P3596 gelb: Spannungsverlauf 12V DC-Netzteil blau: Schaltsignal an Pin2 von P3596 Gruß Rolf
:
Bearbeitet durch User
Ups.. kleiner Fehler im Schaltplan. Die Diode D9 ist verpolt gezeichnet und lässt so keinen Strom zum Schaltregler X4 fließen ebueb Hier die Korrektur. Bild 1: DEGENERATOR Power supply Gruß Rolf
Hab mal den Strom in der Schaltung gemessen (siehe Bild). Gruß Rolf
Hallöchen.. Alle guten Dinge sind 3... So auch mit der Stromversorgung im Degenerator. Man sollte erst den Schaltplan zeichnen und dann nach diesem Plan löten. Dann würden Fehler in der Zeichnung direkt auffallen und nicht hinterher. So gibts jetzt die 3.Korrektur Augenzwinkern PS: Das hätte dann aber auch Nachteile... wzB ein Nichtfunktionieren der Schaltung oder vielleicht einen Kurzschluss oder sogar den Tod von Bauteilen geschockt Bild: Degenerator Power Supply In der letzten Schaltung sind die Widerstände R1, R2 und R5 vertauscht gezeichnet. Zusätzlich wird laut Herstelle in der Adjustable Output Version des Schaltreglers X4 ab einer Ausgangsspannung von 10V ein kleiner Kondensator C18 für eine bessere Stabilität der Regelschleife empfohlen. Da der Schaltreglers X4 an seinem Ausgang zukünftig mit nur wenige 100mA belastet wird, habe ich die Kondensatoren C7 u. C15 von 470uF auf 220uF verringert. Das mindert den Einschaltstrom fürs Netzteil und garantiert dennoch eine stabile -8V Spannungversorgung. Gruß Rolf
In der Netzteilschaltung muss ich doch die Dioden vom Typ 1N5818 nehmen (D3, D7, D8, D11). In der Zeichnung hatte ich die 1N5822 geplant, die hat aber eine UF von 0,525 Volt. Am Schaltregler lägen dann weniger als 11V an und das könnte fürs Einschalten des Schaltreglers etwas knapp werden. Die kleinere 1N5818 hat eine UF von 0,33V und einen Spitzenstrom von 25A. Für den Einschaltmoment sollte der Dioden-Spitzenstrom von der 1N5818 groß genug sein. Momentan benutze ich diese Diode in der Schaltung und es funktioniert problemlos. PS: Das war jetzt aber wirklich die letzte Korrektur. Hoffe ich ;) Gruß Rolf
Hallöchen miteinander! Soeben hat mir Andre die ersten Entwürfe vom Motherboard Designe des Degenerators geschickt. Oben rechts neben der Netzteilbuchse befindet sich der Schaltregler P3596 für die negative Betriebspannung. Darunter die Bauteile für die Spannungsüberwachung des Schaltregler. Diese Bauteile werden ein wenig vom CPU-Board überdeckt. Rechts neben dem Schaltregler befinden sich die 4 Festspannungsregler für die Betriebsspannung von +3.3V +5V +8V -8V Für den +5V Regler wird es einen Kühlkörper geben. Oben rechts neben den Festspannungsreglern sind die Midi-Buchsen und die Audio-Buchsen geplant. Auf der Freifläche werden VCA und Effekt-Schaltung platziert. Bild: DEGENERATOR Motherboard Gruß Rolf
:
Bearbeitet durch User
Es geht voran... Andre ist am layouten und ich programmiere noch :) Wenn nichts dazwischen kommt, ist das Motherboard in ein bis zwei Wochen fertig und kann in China bestellt werden. Die Bilder zeigen die Stromversorgung mit +3.3V +5V +8V -8V +12V. Es wird eine Masse-Fläche geben, die von den Festspannungsreglern LV33, 7805, 7808, 7908, zu den einzelnen Baugruppen führt. Der 7805 besitz einen Kühlkörper. Gruß Rolf
:
Bearbeitet durch User
Hallo Es geht schnell voran großes Grinsen Unter dem Filterboard befindet sich der VCA. Die Leitungen zum Filterboard sind dadurch sehr kurz und weniger störanfällig. Oben rechts befindet sich der Audioausgang. Darunter der Steckkontakt K4. An diesem wird das Lautstärke-Poti auf der Frontplatte verbunden. Ferner befinden sich oben die Midi-Buchsen und der obligatorische Optokoppler. Audioinput und Delay Schaltung fehlen noch. Bild1: Degenerator Motherboard PCB Ach.. hab noch etwas vergessen. In Bezug auf die Wiederauferstehung der Synthesizer Chips von Curtis gibts auf Muso talk einen interessanten Video Beitrag. It moves quickly ! Pic1: Degenerator Motherboard PCB Oh ..'ve forgotten something. With the resurrection of the Synthesizer chip from Curtis gives an interesting video on Muso Talk. Muso Talk Link: http://www.musotalk.de/video/synthi-talk-curtis-chips-are-back-weitere-news/ Gruß Rolf
:
Bearbeitet durch User