Jump to content

rolfdegen

Members
  • Posts

    457
  • Joined

  • Last visited

  • Days Won

    14

Posts posted by rolfdegen

  1. Hallo Thorsten

     

    Die Granularsynthese ist schon sehr interessant. Hab dazu ein tolles Programm Namens "GranuLab" gefunden (Real-time control over time-stretching and pitch of a sound.).  Eine ähnliche Synthes baue ich vielleicht in den Nachfolger meines Synths ein (WAVE 2). Dieser wird einen leistungsstärkeren Prozessor besitzen und damit für solche Syntheseberechnungen besser geeignet sein als mein jetziger Xmega Chip mit 8Bit und 32MHz :smile:

     

    Es ist auf jeden Fall schon erstaunlich, was man aus dem Xmega an Leistung alles rauskizzeln kann. 

     

    In dem Sinne auf ein interessantes und schönes neue Jahr 2014. 

     

    Gruß Rolf

  2. Hallo zusammen..

    In den Elektronik-Scene scheint momentan viel los zu sein. Da tanzt der Bär wie man im Volksmund so sacht. Die "Alten" und "Jungen" haben wieder mehr Lust bekommen etwas selber zu machen und zu basteln. Das liegt vermutlich darin Begründet, dass die Elektronikbauteile durch den Import aus Fernost sehr preiswert geworden sind und zum anderen, dass die Hersteller kostenlose oder preiswerte Entwicklungswerkzeuge zur Verfügung stellen und die Communities im Netz besser unterstützen. Zum Beispiel sei genannt die Firma ATMEL mit ihrem kostenlosen Entwicklungumgebung (IDE) "Atmel Studio" und das Forum "AVRFreaks". Ich selber arbeite seit zwei Jahren mit Atmel Studio. Meine bevorzugten Communities sind "www.mikrocontroller.net", "www.avrfreaks.net", "Mutable Instruments" und das MidiBox Forum.


    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.

    Mellotron
    Mellotron.jpg



    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.

    Loop Funktion
    Loop_01.jpg



    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. 

    Bis zum nächsten mal und lieben Gruß. Rolf 
  3. Hallo zusammen..

    Ich wünsche allen meinen Lesern und den Machern des MidiBox Forums ein schönes und fröhliches Weihnachtsfest. Last euch reich beschenken und seit nicht traurig, wenn ihr wiedermal ein Paar Socken von Tante Hildegard geschenkt bekommt, oder ein neues Topfset vom lieben Ehemann. Freut euch trotzdem, es ist schließlich Weihnachten smile.gif 

    Um die Zeit zur Bescherung zu überbrücken hier noch ein schönes musikalisches Weihnachtsvideo. Viel Spaß und Frohe Weihnacht holy-willi.gif 

    A Synthesizer for Christmas von Ambar Navarro
    http://vimeo.com/81973720



    Lieben Gruß aus Wuppertal. Rolf 

  4. 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.

    Wave-Editor
    WaveEditor.jpg

    Youtube: 




    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 5. 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 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 
  5. Hallo Thorsten

     

    Erst einmal vielen Danke für die guten Infos. Ist wirklich interessant was sich in Bezug auf die STM32 MCUs dieses Jahr so getan hat. Das sah letztes Jahr bei meinen ersten Gehversuchen mit dem STM32F4 Discovery Board noch etwas mager aus. Wenn ich mein Synth Project in den nächsten Wochen abgeschlossen habe, plane ich eine verbesserte 2.Version. Das Kind hat auch schon einen Namen.. "WAVE 2". Vielleicht mit einem STM32. Schaun wir mal .. :smile:

     

    Ãœbrigens bin ich gerade dabei, die Loop-Funktion für die Wavesamples in meinem Synth zu programmieren. Gute Ideen und Anregung für die Umsetzung verschaffe ich mir aus dem Bedienungshandbuch des PPG Waveterm A  und einigen Demos auf Youtube.

     

    PPG WAVETERM A 2.2

     

     Schon geil die Sounds  :smile:  Die Loopfunktion funktionier bei mir ähnlich. Nur mit dem einzigen Unterschied das ich statt 64KByte ganze 1Mbyte Samplespeicher habe, dazu noch 2x VCF's (OTA13700) und 2x VCA's (OTA13700).  

     

    Gruß Rolf

  6. Hallo Thorsten

     

    Interessehalber hatte ich mir vor einigen Monaten das sehr preiswerte STM32F4DISCOVERY Evaluation Board gekauft und ein wenig damit experimentiert (siehe Link unten) Leider sind die wirklich guten Entwicklungstools dafür etwas teuer. Ich programmiere gerne mit ATMEL Studio. Es hat viele Vorteile wzB leichte Bedienung, keine Codegrößenbeschränkung und ist Freeware. Es ist mir schon bewusst, das die ATMEL MCU's nicht zu den schnellsten ihrer Gattung zählen. Aber Geschwindigkeit ist halt nicht alles was zählt. Die ATMEL MCU's haben ihren Vorteil in der Menge der angebotenen internen Peripherie und sowie einen großen Funktionsumfang. Im Vergleich dazu sieht so ein schneller STM32F4 etwas alt aus.

     

    Link: Meine ersten Erfahrungen mit dem STM32F4DISCOVERY Evaluation Board

     

    Gruß Rolf   

  7. Hallöchen..

    Ach das Internet.. man wird immer wieder abgelenkt von so vielen interessanten Dingen im Netz. Wie zB auf der Website von Tolaemon. Er hat letztes Jahr ein sehr interessantes Development Board auf seiner Website vorgestellt. Es handelt sich dabei um ein speziell Board mit der Bezeichnung "Synth core B" für Synthesizer Entwickler. Auf dem Board sitzt u.a. ein AVR 32Bit Prozessor mit der Bezeichnung AVR3 AT32UC3A-512. Dieser Prozessor zeichnet sich besonders damit aus, das eine internen DSP Einheit besitzt, sowie einem 16Bit Stereo BitStream DAC.

    ATMEL AVR3 AT32UC3A-512
    AT32UC3A0512.jpg

    Hier einige Daten des Boards:
    - Atmel AVR32 AT32UC3A-512, an audio focused 32-bit MCU with DSP features, 512KB of program flash and 64KB internal SRAM
    - 32MB external SDRAM
    - FTDI serial to USB port ( FT232RL FTDI )
    - MIDI interface ( with MIDI IN, MIDI OUT, AND MIDI THRU )
    - RS-232 debug channel
    - Host-Device USB port
    - 2 SD cards slots
    - LCD interface
    - 7 ADCs connectors for potentiometers ( more can be used using switching techniques )
    - 40 I/O bus lines ( with USART, SPI ... ) to interface other audio processors or peripherals
    - Line out - headphones preamplifier for the audio bitstream DAC

    Der Preis müsste so bei 100 Euro liegen.

    Development Board "Synth core B"
    CoreB.jpg

    Ich überlege gerade, ob das vielleicht etwas für mein nächstes Projekt wäre. Ich plane fürs nächste Jahr bzw. wenn mein Synthesizer fertig ist, eine neue und verbesserte Version. Schaun wir mal.. smile.gif 

    Liebe Grüße aus Wuppertal. Rolf 

     

     

    Nachtrag: Leider gibt es eine schlechte Nachrichten. Das betrifft das "Synth core B" Development Board von Tolaemon. Aufgrund einer Anfrage teilte mir Tolaemon mit, das er das Board nur für den persönlichen Gebrauch entwickelt hat. Um es als Open-Source-Projekt zu veröffentlichen, müsste er eine Menge an Dokumentation erstellen und viel Zeit, die er leider nicht hat, in die Support-Arbeit stecken.


    Er verwies auf andere interessante Board wzB. dem Raspberry Pi oder Beaggle. Die haben auch viele I / O-Optionen wie sein Board und haben eine leistungsfähige CPU mit viel Open-Source-Code.

    Schade..



    Hallöchen liebe "Old School" Fans der Elektronischen Musik

    Heute gibts speziell für euch was auf die Ohren (siehe Unten). Derzeit programmiere ich an einem Wafefile Management in meinem Synth. Ich habe eine Menge von freien Wavefiles im Internet gefunden und auch vieles für meinen Synth selber aufgenommen. Ein kleines Problem in meinem Synthesizer war die Wiedergabegeschwindigkeit von zwei Soundkanäle gleichzeitig aus dem 1 MByte SRAM. Aus diesem Grund habe ich einige Routinen in Assembler umschreiben müssen. Alle Wavefiles in meinem Synthesizer haben momentan eine Abtastrate von 8Bit/16KHz. Ich überlege, auf 16bit (bzw 12Bit für die DAC Ausgabe) zu gehen, das erzeugt weniger Rauschen. Obwohl die Sounds  8-Bit "Old School" klingen und das Rauschen dem Sound etwas besonderes verleiht smile.gif 

    Aber jetzt habe ich eine Synthesizer und Waveplayer in einem Gerät und es macht tierischen Spaß damit rum zu experimentieren.

    Soundcload.png
    Hier wieder einige Soundbeispiele aus meinem Synth: https://soundcloud.com/rolfdegen/wavedemo-01

    Gruß aus Wuppertal 

  8. Fast zwei Jahre Entwicklungszeit, viel Wissen, viel dazu gelernt, einige Fehlentscheidungen und vieles mehr und ich bin immer noch nicht fertig.. puhhhhhhhhhhhhh.

     

     

    SynthCol.jpg

     

     

     

    Aber es macht immer noch tierischen Spaß :smile:

     

    Gruß Rolf

  9. Hallo Thomas_H

     

    Ich habe mich bewusst für die etwas aufwendigere Filterschaltung mit OTA's entschieden. Im Vergleich zu den SC-Filtern hat man mit der OTA Filterschaltung mehr Manipulationsmöglichkeiten, eine bessere Signalqualität, einen günstigeren Bauteil Preis, sowie einen einfachen Nachbau. Die SC-Filter haben leider die Eigenschaft, das sie im unteren Frequenzbereich Aliasinggeräusche produzieren. Dies wird durch die Taktfrequenz des Filters verursacht. Sieh bzw höre dir mal das Youtube Video an, dann verstehst du was ich meine.

     

     

    SC-Filter Youtube:

     

     

     

    Gruß Rolf

  10. Hallo Imp,

    danke für den Tip. Das mit dem Offset-Wert ist eine gute Idee.

     

    Ich hoffe ihr habt Halloween gut überstanden und wurdet nicht von Sumpfmonstern oder schleimigen Scheusalen massakriert wink.gif 

    In der Zwischenzeit musste ich ein kleines Problem im AVR Synthesizer lösen. Da der Programmcode immer größere und länger wird, musste ich Teile davon aus Geschwindigkeitsgründen in Assembler schreiben. Das betrifft zum Beispiel den Programmcode für die AD-Wandlung in der Scope-Funktion. Diesen hatte ich ursprünglich in eine der vielen Timer Interrupt Routine als C-Code implementiert. Auf der Scope-Page sahen die gesampelten Signale vom Filterausgang allerdings etwas verzerrt aus (Bild 2). Der Grund dafür war, das die Timer Interrupt Routine für die AD-Wandlung durch andere Interrupt Routinen mit höherer Priorität wzB für die Soundausgabe oder Enveloop-Timer ständig unterbrochen wurde. Das hatte zur Folge, dass die AD-Abtastungen nicht mehr kontinuierlich zu einem festen Zeitpunkt statt fand (rot markiert), sondern die Abtastungen in zufälligen Zeitabschnitten erfolgten (grün markiert). Die Abtastungen wurden in einen 151 Byte großen Buffer geschrieben und alle 255 Millisekunden auf den LCD Screen angezeigt.

    Bild 1: AD-Wandlung

    AD_Abtastung.png

     

    Bild 2: Verzerrte Darstellung eines Sinus Signals im AVR-Synthesizer

    AD_Wandlung_01.png

     

    Bild 2: Richtige Darstellung eines Sinus Signals im AVR-Synthesizer
    AD_Wandlung_02.png

     

     

    Die Lösung
    Um die Unterbrechungen während der AD-Wandlung zu vermeiden, habe ich kurzum die AD-Wandler Funktion in die Interrupt Routine für die Soundausgabe implementiert. Diese Interrupt Routine hat die höchste Priorität und ist wegen der notwendigen Geschwindigkeit in Assembler geschrieben (siehe Code Beispiel).

    Am Anfang der ADC Routine wird die Timebase-Einstellung für das Scope berechnet. Danach folgt die Abfrage der Trigger-Einstellung fürs Scope (auto, off, Level) sowie das Schreiber der AD-Werte in den 151 Byte großen Buffer. Die AD-Werte im Buffer werden in einer anderen Timer-Routine alle 255 Millisekunden ausgelesen und auf den LCD-Screen geschrieben.

     

    //-------------------------------------------------------------------------
    // ADC (Scope Funktion)
    //-------------------------------------------------------------------------
    Scope_TimeBase:
    lds   r18, timebase_reg                ; load scope timebase_register
    lds   r19, timebase_level            ; set scope timebase_level
    clc
    adc   r18,r19
    sts   timebase_reg, r18                
    brcc  Osc1_Switch
    
    temp    = 18
    temp1   = 19                        ; scope trigger function
    LDS  temp, adc_trigger                ; test adc_trigger
    CPI  temp, 99                        ; if adc_trigger = 99 cancel adc convert
    BREQ Osc1_Switch                    ; and jump to osc1 calc
    
    CPI temp, 1                            ; test adc_trigger
    BREQ adc_conv                        ; if adc_trigger = 1 run adc convert
    
    lds  temp, adc_trigger_level        ; test adc_trigger_level
    cpi  temp, 0                        ; if adc_trigger_level = 0 run adc convert
    brne Osc1_Switch                    ; if not than cancel adc convert
    
    adc_conv:                            ; buffer function
    LDI  ZL, lo8(adc_buffer)            ; load buffer start_Adr  
    LDI  ZH, hi8(adc_buffer)
    LDS  temp, (adc_wr_pointer)            ; set adr_pointer for buffer
    ADD  ZL, temp
    LDI  temp, 0
    ADC  ZH, temp
    lds  temp,ADCA_CH0RES                ; load adc value
    ldi  temp1,255                        ; sync phase for screen plot
    sub  temp1,temp
    ST   Z, temp1                        ; and store to buffer
    LDS  temp, adc_wr_pointer            ; inc buffer_adr
    inc  temp
    CPI  temp, 151                        ; if buffer_adr < 151
    BRNE adc_loop                        ; than jump to adc_loop
    LDI  temp, 99                        ; set adc_trigger = 99
    sts  adc_trigger, temp                ; 
    ldi  temp, 0                        ; load 0 for adc_wr_pointer                                    
    
    adc_loop:
    sts  adc_wr_pointer, temp            ; set buffer adr_wr_pointer
    lds  temp, ADCA_CH0_CTRL 
    ori  temp, (1<<ADC_CH_START_bp)        ; start new ad converting
    sts   ADCA_CH0_CTRL, temp 
    
    //-------------------------------------------------------------------------
    // Osc1 switch
    //-------------------------------------------------------------------------
    Osc1_Switch:

    Gruß Rolf 

  11. 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

    Env_Pic1.png

     

    Bild 2: Modulations Matrix

    Picture%202.jpg

     

    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. 

     

    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 

  12. Hallöchen..

    Wie gesagt, die Ressourcen des XMega Prozessors (Xmega128AU) in meinem DIY Synth sind sehr knapp. Man vergisst schnell, das es sich nur um eine 8Bit CPU handelt, die sehr viele 16Bit und 32Bit Berechnungen für die Audioausgabe und Filtersteuerung durchführen muss. Nebenbei muss auch noch das Display, die Encoder, Tasten und die SD-Card bedient werden.

    In meinem nächsten Synthesizer Projekt werde ich vermutlich auf einen leistungsstärkeren Prozessor umsteigen, so das auch mehrere Stimmen möglich sind. Die ganzen Erfahrungen und Erkenntnisse aus meinem ersten Synthesizer Projekt kann ich dann leichter und schneller in dem neuen Projekt umsetzen.

    Habe jetzt für beide Oszillatoren eine FM-Modulation, Ring-Modulation und eine Pulsweitenmodulation (0-100%) für alle Wellenformen integriert. Ferner ist ein Bitcrush-Funktion (Bit-Reduzierung) hinzugekommen. Damit kann die Bitauflösung der DAC Ausgänge für beider Oszillatoren von 1-12Bit eingestellt werden. Ein Soundbeispiel habe ich auf Soundcload hochgeladen (siehe unten).

    PWM-Funktion in meinem Synth
    PwmBitcrush.jpg

    Bitcrushing 12Bit
    Bitcrush_12Bit.jpg

    Bitcrushing 2Bit
    Butcrush_2Bit.jpg


    Soundbeispiel ab 0:15: Bitcrushing 2Bit

    Gruß Rolf

  13. Hallo

     

    Mein Synthesizer hat 2 Digitale Oszillatoren, 2DAC-Ausgänge, 2 VCA's und 2 VCF's, 3 LFO's, 2 Env's für VCF und VCA. Ferner ist eine Oszilloskopfunktion intergriert. Die zwei Filter können Parallel oder in Serie geschaltet werden. Das bedeutet ein Filter für den Linken Audiokanal (DAC1) und ein Filter für den Rechten Audiokanal (DAC2). Durch die zwei DOC's kann der Synth auch 2stimmig polyphon gespielt werden. Osc1 und Osc2 besitzen eine interne Lautstärke- und Panoramafunktion.

     

    Ferner ist es möglich die beiden Filter in Serie zu schalten zB als 24dB Hoch- oder Tiefpass. Dafür wird der Eingang von Filter2 auf den Ausgang von Filter1 geschaltet. Der Ausgang von Filter2 geht dann parallel auf den Eingang von VCA1 und VCA2.

     

    Eine Erweiterung auf mehr als zwei Stimmen ist mit dem verwendeten 8Bit Mikrocontroller (ATXmega128AU) kaum durchfürbar, da die noch freien Resoucen für andere Funktionen wzB VCA- und Filteransteuerung, LFO's, ENV's, Displayansteurerung und Encoder Abfrage benötigt werden. Das alles muß quasi zeitgleich erfolgen.

     

    Einen externer Audioeingang ist geplant sowie das laden und abspielen von Wellenformen aus einem 1MByte großen SDRAM.

  14. Hallo Freunde der elektronischen Musik..

    Ich bin mit der Konstruktion des MultiFilter mehr als zufrieden und die ersten selbst programmierten Sounds haben auch schon ihren Platz bzw Soundnr. auf der SD Karte gefunden.

    Mich interessierte am MultiFilter auch die Frequenzgänge bei verschiedenen Filter-Einstellungen. Am besten testet man das mit einem Rauschgenerator der weißes Rauschen erzeugt und einer FFT Analyse (englisch Fast Fourier Transform). Das Ganze hört sich komplizierter an als es ist. Das Audio Programm Audacity (Freeware) hat alles was man dazu benötigt. Das Weiße Rauschen erzeugt man im Menüpunkt "Erzeugen". Anschließend kann das Weiße Rauschen über die Soundkarte und den Filtereingang wiedergegeben werden und gleichzeitig über den Filterausgang am Audioeingang der Soundkarte wieder aufgenommen werden.
    Um eine FFT Analyse zu starten, klickt man dann auf den Menüpunkt "Analyse" und startet die Frequenzanalyse.

    Für den Filtertest hatte ich zuerst meinen Digitalen Rauschgenerator im AVR Synth benutzt. Dieser liefert Aufgrund der niedrigen Samplerate von 40KHz aber kein Weißes Rauschen (Konstante Amplituden im ganzen Frequenzbereich) sonder nur ein farbiges Rauschen (Verringerung der Amplituden mit steigender Frequenz/ siehe Bild 2).
    Auf die Schnelle habe ich dann einen kleinen Rauschgenerator mit einem Transistor und Operationsverstärker zusammen gelötet um meine Messung durchzuführen (siehe Bild 1). Das Ergebnis seht ihr unten.


    Bild 1: Analoger Rauschgenerator

    Noise_Generator.PNG

     

     

    Bild 2: FFT Analyse Digitaler Rauschgenerator im AVR Syntheziser

    Digital_Noise_Generator.PNG

     

     

    Bilder: FFT Analyse verschiedener Filtereinstellungen im AVR-Synthesizer

    Analys_LP_12dB.PNG

    Analys_HP_12dB.PNG

    Analys_BP_12dB.PNG

    Analys_LP_24dB.PNG

    Analys_HP%2BHP_01.PNG

    Analys_HP%2BHP_02.PNG

    Analys_HP%2BHP_03.PNG

     

     

     

     

    Gruß Rolf

  15. Hallo ich schon wieder wink.gif 

    Habe Gestern Abend die Routinen für das Abspeichern von neuen Sounds fertig gestellt. Heute konnte ich dann einige Demosound für den neuen MultiFilter in meinem AVR Synthesizer programmieren.


    Demo Sound MultiFilter

     

    Hier noch ein Youtube Video von Dr Dieter Doepfer auf der Namm Show 2013. Dr. Doepfer verkauft neue Module u.a. den A132-1 zweifacher linear VCA with high-end VCA-Baustein (SSM2164) oder den A-171-2 Voltage Controlled Slew Processor/Generator. Das ist ein Multifunktionsmodul zum Erzeugen und Bearbeiten von Steuerspannungen und Audiosignalen nach Art eines Funktionsgenerators. LFO, Hüllkurvengenerator, Slew Limiter... die Möglichkeiten sind vielfältig.

     

    Dr Dieter Doepfer auf der Namm Show 2013

     

    Gruß Rolf

  16. Hallo Ihr Lieben.. smile.gif 

    Der Sommer neigt sich so langsam dem Ende entgegen und hier in Wuppertal ist es gerade mal 15 Grad warm. Ich vermisse den Sommer, obwohl ich nicht in Urlaub fahren konnte. Aber das Ganze hat auch seine positiven Seiten und so bastel ich mal wieder fleißig an meinem Synth herum.

    Der Stereo Filter ist jetzt fertig und zusammen mit der umschaltbaren Filter Matrix ist daraus ein interessantes Klangstellwerk geworden. Jeder Filter verfügt über separate Einstellung für: Cutoff, Resonanz, Filter FM und VCA.

    Folgende Filterkombinationen sind einstellbar:
     

    • 2pol LP (stereo)
      2pol HP (stereo)
      2pol BP (stereo)
      4pol LP (mono)
      4pol HP (mono)
      2pol LP + 2pol HP (mono)
      2pol LP + 2pol BP (mono)
      2pol HP + 2pol BP (mono)




    Bild 1: TransFilter Channel 1

    TransFilter_12.png

     

     

    Bild 2: FilterMatrix

    FilterMatrix_12.png

     

    In kürze stell ich für euch auf Youtube ein paar Demo Sounds zur Verfügung.

    Bis dahin lieben Gruß. Rolf 

  17. Hallöchen..

     

    Hier meine Filter Demo mit zwei Kanälen

     

    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.

  18. Hallöchen..

     

    Habe mit großartiger Unterstützung von Andre (tubeohm.com) nun einen neuen Audio-Filter für meinen Synth gebaut. Dieser ist noch nicht ganz fertig. Der zweite Kanal fehlt leider noch. Im Vergleich zum alten Filter mit den SSM2044 IC klingt der neue Filter im Bass- und Hochtonbereich sehr ausgewogen.


    Auf Youtube gibts eine neue Filter Demo. Zur Zeit noch einkanalig. An dem 2.Kanal wird noch gearbeitet. Der Multi Filter bestehend aus LP/BP/HP/FM besitzt eine Flankensteilheit von 12dB. Die Sounds kommen direkt vom AVR Synthi. Es werden keine Effektgeräte benutzt.

     

    Youtube Filter Demo

     

    Viel Spaß beim anhören. Lieben Gruß Rolf 

  19. Hallöchen..

    Kleine Änderung im Plan. Der Andre von TubeOhm.com hat mir netterweise einen Filterentwurf zur Verfügung gestellt. Bauteile habe ich bei Reichelt schon bestellt und sollten Anfang der Woche bei mir sein. Freu mich schon aufs zusammenlöten und ausprobieren.

    Bis dahin wünsche ich euch ein schönes Wochenende. Gruß Rolf 

  20. Ja das ist das gleiche Filter-Konzept wie im Shruth Synthesizer. Ich will jetzt erst einmal einen SMR4 Filter aus dem Ambika-Synth von Oliver zusammenlöten und damit ein wenig experimentieren. Es handelt sich hierbei um einen 4pol LowPass Filter. Die Schaltung will ich später etwas abändern, so das eventuell auch Low- und Bandpass Funktionen möglich werden. Zusätzlich soll es eine Frequenzmodulation der Filter-Cutoff geben. Dafür wird der Oszillatorausgang mit dem Steuereingang für die Filter-Cutoff verbunden. 

     

    Bild: SMR4 Filter im Ambika Synthesizer von Oliver Gillert

    MSR4_Filter.jpg

  21. Hallöchen..

    Nach einer kleineren Lötaktion auf meinem Synthesizer Mainboard sitzen die beiden SSM2044 Filter IC jetzt in Fassungen. Das Vertauschen beider Filter Chips gegeneinander hat meine Vermutung bestätigt, das ein Filter Chip defekt ist, weil das störende Plop-Geräusch jetzt auf dem anderen Audiokanal zu hören war. Da ich sowieso vorhabe die beiden Filterschaltung durch eine andere zu ersetzen, stellt das kein größeres Problem für mich dar. Einen neuen Filter Chip werde ich mir nicht mehr kaufen.

    Bild: Filter IC's SSM2044 in Fassungen

    Filter_IC.jpg

     

     

    In Bezug auf eine neue Filterschaltung für meinen Synthesizer hatte ich Heute ein sehr interessantes und langes Telefonat mit Andre Laska geführt. Andre (übrigens ein sehr netter Mensch smile.gif ) habe ich im mutable intruments forum kennengelernt. Er hat denLadder-Filter für den Shruthi- und Ambika-Synthesizer von Oliver Gillert entwickelt. Gleichzeitig ist er der Betreiber der Website tubeohm.com und beschäftigt sich u.a. mit der Entwicklung von VSTI-Synthesizern.

    Wir haben sehr lange über viele Dinge in der analogen Filtertechnik geredet. In den nächsten Tage werde ich versuchen, einige Vorschläge von Andre für eine neue Filterschaltung in meinem Synthesizer umzusetzen. 

    Bis dahin lieben Gruß und noch schöne Sommertage


    Rolf 

  22. Hallöchen..

    Höre gerade chillige Musik und hab gute Laune. Falls es jemanden interessiert "1.FM Chillout Lounge Radio" und "Antenne Bayer Chillout" sind so meine Favoriten smile.gif 
    Ich höre die Sender gern beim programmieren. Dann bekommt man noch mehr Ansporn und Lust wenn man geile Synth-Klänge hört. In Win8 gibts dafür ne tolle App namens "Audials Radio".

    Auf Youtube habe ich noch ein hoch interessantes Video über den "ROCKET" Synthesizer von der Firma Waldorf gefunden. Dort diskutieren Musiker und Techniker über den kleinen ROCKET. Man erfährt so einiges über den kleinen Winzling zB was an Technik in ihm steckt und was er so alles kann.


    Bild: Der kleine "ROCKET"

    rocket_topview-intro.jpg

     

     

    Um die Wartezeit auf das SRAM aus China zu überbrücken, programmiere ich momentan die VCA-Page in meinem AVR-Synthesizer. Oszillator1+2 und der Noise-Generator bekommen endlich Lautstärke- und Panorama-Funktionen. Ein Teil dieser Funktionen ist in C geschrieben und ein anderer in Assembler. Ist leider noch nicht ganz fertig, aber ich mach gleich mal ein Foto um zu zeigen, wies hinterher auf dem Display aussehen wird.
     

     

    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.


    VCA Page mit Osc- und Noise-Volume

     

     

    VCA_Vol_01.jpg

     

     

    VCA Page mit Osc- und Noise-Balance

    VCA_Bal_01.jpg

     

    Softwaretechnisch ware es nicht ganz leicht (zumindes für mich wink.gif ) 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).

    Abfrage der Encoder für Volume and Balance in der Menüsteuerung

    // osc1 level
            if (enc2_status == 1)        // 1= encoder value change / 0= not change
            {
                int8_t balance_temp;
                balance_temp = osc1_balance *2;
                osc1_value = enc2_value;
                lcd_moveto_xy(23,12);print_8bit_numbers2(osc1_value,0);    // print osc1 level
                if (balance_temp == 0)
                {
                    osc1_value1 = osc1_value;
                    osc1_value2 = osc1_value1;
                }
                if (balance_temp > 0)
                {
                    osc1_value2 = 127*osc1_value/127;
                    osc1_value1 = ((127 - balance_temp) *osc1_value/127);
                    
                }
                if (balance_temp < 0)
                {
                    uint8_t temp_balance1;
                    temp_balance1 = balance_temp* -1;        // make unsigned
                    osc1_value2 = ((127 - temp_balance1 + 1) *osc1_value/127);
                    osc1_value1 = 127*osc1_value/127;
                }
            }
    
    // change osc1 balance
                if (enc2_status == 1)            // 1= encoder value change / 0= not change
                {
                    if (enc2_value >= 64)
                    {
                        osc1_balance = enc2_value -64;
                    }
                    else
                    {
                        osc1_balance = 64- enc2_value;
                        osc1_balance = osc1_balance* -1;
                    }
                    
                    int8_t balance_temp;
                    balance_temp = osc1_balance * 2;
                    
                    uint8_t sym_pos;
                    if (balance_temp == 0)
                    {
                        osc1_value1 = osc1_value;
                        osc1_value2 = osc1_value;
        
                    }
                    if (balance_temp > 0)
                    {
                        osc1_value2 = (127*(osc1_value)/127);
                        osc1_value1 = ((127 - balance_temp) *(osc1_value)/127);                    
                    }
                    if (balance_temp < 0)
                    {
                        uint8_t temp_balance1;
                        temp_balance1 = balance_temp* -1;
                        osc1_value2 = ((127 - temp_balance1 + 1) *(osc1_value)/127);
                        osc1_value1 = (127*(osc1_value)/127);
                    }
                }

     

    Assembler-Routine für Volume und Balance

    //-----------------------------------------------------------------------
      // save osc1+2 values
      //
      osc1_temp = 20
      osc2_temp = 21
      mov  osc1_temp, chanalA_0
      mov  osc2_temp, chanalB_0
        
      //-----------------------------------------------------------------------
      // osc1 level
      //
      LDS   R18, osc1_value1 
      MUL   R18, osc1_temp                ; mul R18*temp_osc1 result in R0+R1
      MOVW  R18, R0                        ; result in r0/r1 mov to r18/r19
      // div 127
      ANDI R18, 0xF0                    ; clr Low-Nibble from R18
      SWAP R18                            ; SWAP High-Nibble to Low-Nibble
      LSR  R18                            ; 3x shift right
      LSR  R18
      LSR  R18
      LSL  R19                            ; R19 1x shift left
      ADD  R18, R19                        ; ADD R18+R19
      // set osc1 value to chanal_A
      mov chanalA_0,R18
      mov chanalA_1,R19
    
      //-----------------------------------------------------------------------
      // osc1 balance
      //
      LDS   R18, osc1_value2
      MUL   R18, osc1_temp
      MOVW  R18, R0
      // div 127
      ANDI R18, 0xF0                    ; clr Low-Nibble from R18
      SWAP R18                            ; SWAP High-Nibble to Low-Nibble
      LSR  R18                            ; 3x shift right
      LSR  R18
      LSR  R18
      LSL  R19                            ; R19 1x shift left
      ADD  R18, R19                        ; ADD R18+R19
      // set osc1 balance value to chanal_B
      mov  chanalB_0,R18
      mov  chanalB_1,R19
    
      //-----------------------------------------------------------------------
      // osc2 level
      //
      LDS   R18, osc2_value1 
      MUL   R18, osc2_temp                ; mul R18+R19 result in R0+R1
      MOVW  R18, R0                        ; move result to r18+r19
      // div 127
      ANDI R18, 0xF0                    ; clr Low-Nibble from R18
      SWAP R18                            ; SWAP High-Nibble to Low-Nibble
      LSR  R18                            ; 3x shift right
      LSR  R18
      LSR  R18
      LSL  R19                            ; R19 1x shift left
      ADD  R18, R19                        ; ADD R18+R19
      // set osc2 value to chanal_A
      ADD chanalA_0,R18
      ADC chanalA_1,R19
    
      //-----------------------------------------------------------------------
      // osc2 balance
      //
      LDS   R18, osc2_value2
      MUL   R18, osc2_temp
      MOVW  R18, R0
      // div 127
      ANDI R18, 0xF0                    ; clr Low-Nibble from R18
      SWAP R18                            ; SWAP High-Nibble to Low-Nibble
      LSR  R18                            ; 3x shift right
      LSR  R18
      LSR  R18
      LSL  R19                            ; R19 1x shift left
      ADD  R18, R19                        ; ADD R18+R19
      // set oc2 balance to chanal_B
      ADD  chanalB_0,R18
      ADC  chanalB_1,R19
    
     //===============================================================
     // noise generator
     //===============================================================
     noise_gen:
      LDS   PhaseA0, noise+0            ; load noise register
      LDS    PhaseA1, noise+1            ;
      LDS    PhaseA2, noise+2            ;
      BST   PhaseA0, 4                  ; Bit 4  (0:4) laden
      BLD   R30, 0                      ;                                 
      BST   PhaseA2, 7                  ; Bit 23 (2:7) laden
      BLD   R31, 0                      ;                       
      EOR   R30, R31                    ; XOR der beiden Bits
      ROR   R30                         ; in Carry shiften
      ROL   PhaseA0                     ; Buffer links schieben mit Carry
      ROL   PhaseA1                     ;                                   
      ROL   PhaseA2                     ;                                   
      STS    noise+0, PhaseA0            ; save noise register
      STS    noise+1, PhaseA1            ;
      STS    noise+2, PhaseA2            ;
    
      // set noise level left and balance
      temp_noise  = 20                    ; temp-register R20
      MOV   temp_noise, PhaseA1            ; save noise to R20 
      LDS   R18, noise_value1 
      MUL   R18, temp_noise                ; mul R18+R19 result in R0+R1
      MOVW  R18, R0                        ; move result to r18+r19
      // div 127
      ANDI R18, 0xF0                    ; clr Low-Nibble from R18
      SWAP R18                            ; SWAP High-Nibble to Low-Nibble
      LSR  R18                            ; 3x shift right
      LSR  R18
      LSR  R18
      LSL  R19                            ; R19 1x shift left
      ADD  R18, R19                        ; ADD R18+R19
      // add noise chanal_A
      ADD  chanalA_0,R18
      ADC  chanalA_1,R19
    
      // set noise lefel right and balance
      LDS   R18, noise_value2
      MOV   R19, temp_noise                ; load noise
      MUL   R18, R19
      MOVW  R18, R0
      // div 127
      ANDI R18, 0xF0                    ; clr Low-Nibble from R18
      SWAP R18                            ; SWAP High-Nibble to Low-Nibble
      LSR  R18                            ; 3x shift right
      LSR  R18
      LSR  R18
      LSL  R19                            ; R19 1x shift left
      ADD  R18, R19                        ; ADD R18+R19
      // add noise chanal_B
      ADD  chanalB_0,R18
      ADC  chanalB_1,R19
    
      //-----------------------------------------------------------------------
      // Chanal Output
      chan_out:
      // convert Chanal_A to 12Bit
      LSL chanalA_0
      ROL chanalA_1
      LSL chanalA_0
      ROL chanalA_1
      LSL chanalA_0
      ROL chanalA_1
    
      // convert Chanal_B to 12Bit
      LSL chanalB_0
      ROL chanalB_1
      LSL chanalB_0
      ROL chanalB_1
      LSL chanalB_0
      ROL chanalB_1
    
      // send chanal_A value to DACA
      STS   0x0318, chanalA_0          ; 2   L-Byte to DAC-Register DACAL
      STS   0x0319, chanalA_1          ; 2   H-Byte to DAC Register DACAH
    
      // send chanal_B value to DACB
      STS   0x0338, chanalB_0          ; 2   L-Byte to DAC-Register DACBL
      STS   0x0339, chanalB_1          ; 2   H-Byte to DAC Register DAcBH

    Für Verbesserungsvorschläge bin ich sehr empfänglich smile.gif Besonders in der Assembler-Routine. Vielleicht kann man die in Bezug auf Geschwindigkeit noch etwas optimieren. 



    Lieben Gruß Rolf 

     

     

    Hallo zusammen..

    Ich habe gerade festgestellt, das einer meiner beiden Filter IC's SS2044 in meinem Synthesizer nicht richtig funktioniert. Am Filter-Ausgang ist ein kleiner Gleichspannungsoffset vorhanden. Dieser ändert sich mit der Höhe der Cutoff-Steuerspannung am CV-Eingang (Pin 13) des Filter-IC's (siehe Bild1+2). Ein Entkopplungskondensator am Audioeingang und Audioausgang des Filters (Pin 1+3) hat nicht geholfen. Auch der Offsetabgleich mit einem Trimmer (P2) am Filter IC Pin 15 hatte keinen Erfolg. Da der nachgeschaltete VCA das Filtersignal zusätzlich verstärkt, treten bei der Ansteuertung des Filters über den Filter-Enveloop hörbare Plop-Geräusche auf. Das macht sich besonders bei schnellen Enveloop-Kurven bemerkbar. Der zweite Filter-Kanal ist identisch aufgebaut und hat keinen Gleichspannungsoffset am Ausgang. Vermutlich ist das erste Filter-IC defekt, da ich alle Bauteile und die Verdrahtung am Filter-IC mehrfach überprüft habe und keinen Fehler feststellen konnte. 

    Bild 1: Filter-Kanal A mit Gleichspannungsoffset am Ausgang (Pin 3)

     

     

    DC_Offset_01.jpg

     

    Bild 2: Filter-Kanal B ohne Gleichspannungsoffset

    DC_Offset_02.jpg

     

    Bild 3: Schaltung eines Filter-Kanals im AVR-Synthesizer

    VCA_02.jpg

     

    Der verwendete Filterbaustein SSM2044 wird leider nicht mehr hergestellt und ist nur noch über ebay ab einen Preis von 12 Euro zu bekommen . Aus diesem Grund überlege ich, ob es für die Zukunft und für einen Nachbau nicht besser wäre, die Filterschaltung, bestehend aus zwei Kanälen, mit anderen Bauteilen komplett neu zu gestalte. Ein sehr interessantes Filter-Konzept zum Nachbau hat die deutsche Firma tubeohm.com auf ihrer Website vorgestellt. Der sogenannte "Ladder Filter" ist zwar für den Shruthi- und Ambika-Synthesizer von Mutable Instrument entwickelt worden, aber vielleicht mit ein paar Änderungen in der Schaltung auch für meinen Synthesizer nutzbar. Auf der Website von Mutable Instruments gibt es auch noch andere Filter-Schaltungen die nicht weniger interessant sind. Dort findet man auch Klangbeispiele von den verschiedenen Filterschaltungen.

    Youtube: "Ladder Filter"

     

    Im Moment weis ich noch nicht so recht was ich machen soll. Aber fürs Erste werde ich den bequemen Weg gehen und mir einen neuen SSM2044 über ebay kaufen smile.gif

×
×
  • Create New...