Posts by achim 9876

from machine import SPI, Pin
from utime import sleep

import tt24
import tt32
from ili934xnew import ILI9341, color565

# SPI-Konfiguration für den AD9833 (Signal-Generator)
spi_ad9833 = SPI(0, baudrate=100000, polarity=1, phase=1, sck=Pin(2), mosi=Pin(3))
cs_ad9833 = Pin(1, Pin.OUT, value=1)  # Chip Select für AD9833
cs_mcp41010 = Pin(5, Pin.OUT, value=1)  # Chip Select für MCP41010

# SPI Angaben für das Display
WIDTH, HEIGHT = 320, 240
BACKGROUND_COLOUR = color565(67, 167, 255)
TEXT_COLOUR = color565(0, 0, 0)
RED_COLOUR = color565(255, 0, 0)  # Rote Farbe

# Wellenform- und Frequenzeinstellungen
frequency = 500  # Standardfrequenz in Hz
min_freq = 20  # Minimalfrequenz in Hz
max_freq = 20000  # Maximalfrequenz in Hz
#waveform = "sinus"  # Wellenform sinus dreieck rechteck
waveform = "dreieck"  # Wellenform sinus dreieck rechteck
#waveform = "rechteck"  # Wellenform sinus dreieck rechteck
volume = 215  # Lautstärke für MCP41010 von 0-255

# Funktion zum Senden eines 16-Bit-Worts an den AD9833
def send_ad9833_command(command):
    cs_ad9833.value(0)  # Chip Select auf Low, um Kommunikation zu starten
    spi_ad9833.write(bytearray([(command >> 8) & 0xFF, command & 0xFF]))  # 16-Bit-Befehl senden
    cs_ad9833.value(1)  # Chip Select auf High, um Kommunikation zu beenden

# Funktion zum Einstellen der Frequenz am AD9833
def set_ad9833_frequency(frequency):
    reference_frequency = 25_000_000  # Referenzfrequenz des AD9833 in Hz (hier 25 MHz)
    multiplier = 2**28  # Konstante für den AD9833
    freq_word = int((frequency * multiplier) / reference_frequency)  # Frequenzberechnung

    freq_lsb = freq_word & 0x3FFF  # Untere 14 Bits
    freq_msb = (freq_word >> 14) & 0x3FFF  # Obere 14 Bits

    # Frequenz auf das Register 0 schreiben
    send_ad9833_command(0x4000 | freq_lsb)  # LSB der Frequenz
    send_ad9833_command(0x4000 | freq_msb)  # MSB der Frequenz

# Funktion zum Stoppen des AD9833 (Reset als Stopp)
def reset_ad9833():
    send_ad9833_command(0x2100)  # Vollständiger Reset des AD9833 (Reset aktivieren)

# Funktion zum Umschalten der Wellenform
def set_ad9833_waveform(waveform_type):
    if waveform_type == "sinus":
        send_ad9833_command(0x2000)  # Sinuswelle aktivieren
    elif waveform_type == "dreieck":
        send_ad9833_command(0x2002)  # Dreieckwelle aktivieren
    elif waveform_type == "rechteck":
        send_ad9833_command(0x2028)  # Rechteckwelle aktivieren
    else:
        print("Unbekannter Wellentyp")

# Funktion zum Einstellen des MCP41010 Digital-Potentiometers
def set_mcp41010(poti):
    cs_mcp41010.value(0)  # Chip Select auf Low, um Kommunikation zu starten
    spi_ad9833.write(bytearray([0x11, poti]))  # 16-Bit-Befehl senden
    cs_mcp41010.value(1)  # Chip Select auf High, um Kommunikation zu beenden

# Hauptprogramm
def main():
    # SPI Angaben für das Display
    spi = SPI(1, baudrate=40_000_000, sck=Pin(14), mosi=Pin(11))
    display = ILI9341(spi, dc=Pin(15), cs=Pin(13), rst=Pin(12), w=WIDTH, h=HEIGHT, r=3)

    # Display löschen und Hintergrund zeichnen
    display.erase()
    display.fill_rectangle(0, 0, WIDTH, HEIGHT, BACKGROUND_COLOUR)
    display.set_color(TEXT_COLOUR, BACKGROUND_COLOUR)
    display.set_font(tt32)
    display.set_pos(30, 10)
    display.write("AD9833 :")
    display.set_font(tt24)

    # Frequenz, min/max und Wellenform am Anfang setzen
    set_ad9833_frequency(frequency)
    set_ad9833_waveform(waveform)
    set_mcp41010(volume)  # Lautstärke einstellen

    # Initiale Werte für die Anzeige
    while True:
        # Display aktualisieren
        display.set_color(TEXT_COLOUR, BACKGROUND_COLOUR)
        display.set_pos(10, 50)
        display.write("Frequenz:                 ")
        display.set_color(RED_COLOUR, BACKGROUND_COLOUR)  # Setze Textfarbe auf Rot
        display.set_pos(150, 50)  # Werte um 10 nach rechts verschoben
        display.write(f"{frequency} Hz")

        display.set_color(TEXT_COLOUR, BACKGROUND_COLOUR)
        display.set_pos(10, 80)
        display.write("Min:                      ")
        display.set_color(RED_COLOUR, BACKGROUND_COLOUR)
        display.set_pos(150, 80)  # Werte um 10 nach rechts verschoben
        display.write(f"{min_freq} Hz")

        display.set_color(TEXT_COLOUR, BACKGROUND_COLOUR)
        display.set_pos(10, 110)
        display.write("Max:                      ")
        display.set_color(RED_COLOUR, BACKGROUND_COLOUR)
        display.set_pos(150, 110)  # Werte um 10 nach rechts verschoben
        display.write(f"{max_freq} Hz")

        display.set_color(TEXT_COLOUR, BACKGROUND_COLOUR)
        display.set_pos(10, 140)
        display.write("Wellenform:               ")
        display.set_color(RED_COLOUR, BACKGROUND_COLOUR)
        display.set_pos(150, 140)  # Werte um 10 nach rechts verschoben
        display.write(waveform)

        display.set_color(TEXT_COLOUR, BACKGROUND_COLOUR)
        display.set_pos(10, 170)
        display.write("Lautstaerke:              ")
        display.set_color(RED_COLOUR, BACKGROUND_COLOUR)
        display.set_pos(150, 170)  # Werte um 10 nach rechts verschoben
        display.write(f"{volume}")

        sleep(1)  # Beispielhafte Pause von 1 Sekunde

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        reset_ad9833()  # AD9833 zurücksetzen bei Tastendruck

from machine import SPI, Pin
from utime import sleep

# Variablen zu Beginn des Programms festlegen
MIN_FREQ = 20       # Minimalfrequenz in Hz
MAX_FREQ = 20000    # Maximalfrequenz in Hz
FREQUENCY = 1500    # Startfrequenz in Hz
#WAVEFORM = "sinus"  # Startwellenform
#WAVEFORM = "dreieck"  # Startwellenform
WAVEFORM = "rechteck"  # Startwellenform

# SPI-Konfiguration für den AD9833 (Signal-Generator)
spi_ad9833 = SPI(0, baudrate=100000, polarity=1, phase=1, sck=Pin(2), mosi=Pin(3))

cs_ad9833 = Pin(1, Pin.OUT, value=1)  # Chip Select für AD9833, auf High initialisieren
cs_mcp41010 = Pin(22, Pin.OUT, value=1)  # Chip Select für MCP41010

# Dummy-Write ohne ein aktives Chip Select
spi_ad9833.write(bytes([int(0xAA)]))

# Funktion zum Senden eines 16-Bit-Worts an den AD9833
def send_ad9833_command(command):
    print(f"Sende Befehl: {hex(command)}")  # Debug-Ausgabe für den gesendeten Befehl
    cs_ad9833.value(0)  # Chip Select auf Low, um Kommunikation zu starten
    spi_ad9833.write(bytearray([(command >> 8) & 0xFF, command & 0xFF]))  # 16-Bit-Befehl senden
    cs_ad9833.value(1)  # Chip Select auf High, um Kommunikation zu beenden

# Funktion zum Einstellen der Frequenz am AD9833
def set_ad9833_frequency(frequency):
    frequency = max(MIN_FREQ, min(frequency, MAX_FREQ))  # Frequenzbegrenzung
    reference_frequency = 25_000_000  # Referenzfrequenz des AD9833 in Hz (hier 25 MHz)
    multiplier = 2**28  # Konstante für den AD9833
    freq_word = int((frequency * multiplier) / reference_frequency)  # Frequenzberechnung
    print(f"Berechneter Frequenzwert (freq_word): {freq_word} (0x{freq_word:X})")  # Debug-Ausgabe für freq_word

    freq_lsb = freq_word & 0x3FFF  # Untere 14 Bits
    freq_msb = (freq_word >> 14) & 0x3FFF  # Obere 14 Bits

    # Debugging-Ausgaben für die berechneten Werte
    print(f"LSB: {freq_lsb} (0x{freq_lsb:X}), MSB: {freq_msb} (0x{freq_msb:X})")

    # Frequenz auf das Register 0 schreiben
    send_ad9833_command(0x4000 | freq_lsb)  # LSB der Frequenz
    send_ad9833_command(0x4000 | freq_msb)  # MSB der Frequenz

# Funktion zum Umschalten der Wellenform
def set_ad9833_waveform(waveform_type):
    if waveform_type == "sinus":
        send_ad9833_command(0x2000)  # Sinuswelle aktivieren
    elif waveform_type == "dreieck":
        send_ad9833_command(0x2002)  # Dreieckwelle aktivieren
    elif waveform_type == "rechteck":
        send_ad9833_command(0x2028)  # Rechteckwelle aktivieren (MSB/2-Modus)
    else:
        print("Unbekannter Wellentyp")

def set_mcp41010(poti):
    print(f"Sende an MCP41010: {hex(poti)}")  # Debug-Ausgabe für den gesendeten Befehl
    cs_mcp41010.value(0)  # Chip Select auf Low, um Kommunikation zu starten
    spi_ad9833.write(bytearray([0x11, poti]))  # 16-Bit-Befehl senden
    cs_mcp41010.value(1)  # Chip Select auf High, um Kommunikation zu beenden

# Funktion zum Stoppen des AD9833 (Reset als Stopp)
def reset_ad9833():
    send_ad9833_command(0x2100)  # Vollständiger Reset des AD9833 (Reset aktivieren)
    print("AD9833 wurde zurückgesetzt und gestoppt.")

# Hauptprogramm
def main():
    set_ad9833_frequency(FREQUENCY)  # Startfrequenz einstellen
    set_ad9833_waveform(WAVEFORM)     # Startwellenform einstellen
    set_mcp41010(215)  # Poti auf 215 setzen (0 bis 255)
    
    try:
        while True:
            pass  # Endlosschleife, da der AD9833 kontinuierlich arbeitet
    except KeyboardInterrupt:
        reset_ad9833()  # AD9833 zurücksetzen bei Tastendruck

if __name__ == "__main__":
    main()

from machine import Pin
import time

# Pin-Zuweisungen für den AD9833
FSY = Pin(1, Pin.OUT)   # Chip Select für AD9833
SCK = Pin(2, Pin.OUT)   # Clock für AD9833 (manuell)
SDATA = Pin(3, Pin.OUT) # Datenleitung für AD9833 (manuell)

# Funktion zum Senden eines 16-Bit-Befehls an den AD9833
def send_command(cmd):
    FSY.value(0)  # Chip Select aktivieren (Low)
    
    for i in range(16):  # Sende jedes Bit (MSB zuerst)
        bit = (cmd >> (15 - i)) & 1
        SDATA.value(bit)  # Datenleitung setzen
        SCK.value(1)  # Clock High
        time.sleep_us(10)  # Kurze Verzögerung
        SCK.value(0)  # Clock Low

    FSY.value(1)  # Chip Select deaktivieren (High)

# Funktion zum Ändern der Frequenz
def set_frequency(freq_hz):
    # Berechnung des Frequenzworts für die gewünschte Frequenz
    freq_word = int(freq_hz * (2**28) / 25000000)
    
    # Frequenzregister in zwei Schritten laden (LSB und MSB)
    send_command(0x2100)  # B28 = 1, RESET = 1 (Frequenzregister wird neu geschrieben)
    send_command(0x4000 | (freq_word & 0x3FFF))  # LSB
    send_command(0x4000 | (freq_word >> 14))     # MSB
    
    # Aktivierung der Ausgabe und Deaktivierung des RESET-Bits
    send_command(0x2000)  # RESET = 0, B28 = 1 (Aktiviert die Ausgabe)

# Funktion, um den AD9833 in den Sleep-Modus zu versetzen (Ausgabe stoppen)
def stop_ad9833():
    send_command(0x2000 | 0x28)  # SLEEP1 = 1 (DAC off), SLEEP12 = 0 (Clock still running)

# Funktion zum Software-Reset des AD9833
def reset_ad9833():
    send_command(0x2100)  # B28 = 1, RESET = 1 (Vollständiger Reset)

# Hauptprogramm
def main():
    set_frequency(1000)  # Startet mit 1 kHz Sinuswelle
    
    try:
        while True:
            # Teste eine neue Frequenz nach ein paar Sekunden
            time.sleep(5)
            set_frequency(1500)  # Ändert die Frequenz auf 1.5 kHz
            time.sleep(5)
            set_frequency(2000)  # Ändert die Frequenz auf 2 kHz
    except KeyboardInterrupt:
        stop_ad9833()  # AD9833 stoppen (Sleep-Modus aktivieren)
        reset_ad9833()  # AD9833 zurücksetzen

if __name__ == "__main__":
    main()

from machine import Pin, SPI
import time

# Pins für MCP41010
CS = Pin(5, Pin.OUT)
CLK = Pin(2, Pin.OUT)
DAT = Pin(3, Pin.OUT)
FSY = Pin(1, Pin.OUT)

# Setup SPI für MCP41010 (8-bit Mode, max. 10 MHz)
spi = SPI(0, baudrate=1000000, polarity=0, phase=0, sck=CLK, mosi=DAT)

# AD9833 Setup
AD_CS = Pin(1, Pin.OUT)

# MCP41010: Funktion zum Einstellen des Widerstands
def set_resistance(value):
    CS.value(0)
    spi.write(bytearray([0x11, value]))  # 0x11 ist das Kommando für Potentiometer 1, value ist der Widerstandswert
    CS.value(1)

# AD9833: Funktion zum Senden eines Befehls
def send_command(cmd):
    AD_CS.value(0)
    spi.write(bytearray([cmd >> 8, cmd & 0xFF]))  # 16-Bit Befehl senden
    AD_CS.value(1)

# AD9833 initialisieren und Frequenz auf 1kHz setzen
def init_ad9833():
    # Reset AD9833
    send_command(0x2100)  # B28 = 1, RESET = 1
    
    # Frequenz einstellen (1 kHz bei 25 MHz Taktquelle)
    freq = 1000
    freq_word = int(freq * (2**28) / 25000000)
    
    # Frequenzregister einstellen
    send_command(0x4000 | (freq_word & 0x3FFF))  # LSB
    send_command(0x4000 | (freq_word >> 14))     # MSB
    
    # Modus Sinuswelle, Reset entfernen
    send_command(0x2000)  # B28 = 1, RESET = 0 Sinus 2000 Rechteck 2028
    
# Hauptprogramm
def main():
    init_ad9833()  # Setze die Frequenz auf 1 kHz
    set_resistance(128)  # Setze den Widerstand des MCP41010 auf Mittelwert (0-255)

    while True:
        time.sleep(1)  # Einfach laufen lassen

if __name__ == "__main__":
    main()

from machine import SPI, Pin
from utime import sleep

# SPI-Konfiguration für den AD9833 (Signal-Generator)
spi_ad9833 = SPI(0, baudrate=100000, polarity=0, phase=1, sck=Pin(2), mosi=Pin(3))
cs_ad9833 = Pin(1, Pin.OUT, value=1)  # Chip Select für AD9833, auf High initialisieren

# Funktion zum Senden eines 16-Bit-Worts an den AD9833
def send_ad9833_command(command):
    print(f"Sende Befehl: {hex(command)}")  # Debug-Ausgabe für den gesendeten Befehl
    cs_ad9833.value(0)  # Chip Select auf Low, um Kommunikation zu starten
    spi_ad9833.write(bytearray([(command >> 8) & 0xFF, command & 0xFF]))  # 16-Bit-Befehl senden
    cs_ad9833.value(1)  # Chip Select auf High, um Kommunikation zu beenden
    sleep(0.01)  # Kleine Verzögerung für Stabilität

# Funktion zum Einstellen der Frequenz am AD9833
def set_ad9833_frequency(frequency):
    reference_frequency = 25_000_000  # Referenzfrequenz des AD9833 in Hz (hier 25 MHz)
    multiplier = 2**28  # Konstante für den AD9833
    freq_word = int((frequency * multiplier) / reference_frequency)  # Frequenzberechnung
    print(f"Berechneter Frequenzwert (freq_word): {freq_word} (0x{freq_word:X})")  # Debug-Ausgabe für freq_word

    freq_lsb = freq_word & 0x3FFF  # Untere 14 Bits
    freq_msb = (freq_word >> 14) & 0x3FFF  # Obere 14 Bits

    # Debugging-Ausgaben für die berechneten Werte
    print(f"LSB: {freq_lsb} (0x{freq_lsb:X}), MSB: {freq_msb} (0x{freq_msb:X})")

    # Reset des AD9833
    send_ad9833_command(0x2100)  # Reset aktivieren

    # Frequenz auf das Register 0 schreiben
    send_ad9833_command(0x4000 | freq_lsb)  # LSB der Frequenz
    send_ad9833_command(0x4000 | freq_msb)  # MSB der Frequenz

# Funktion zum Umschalten der Wellenform
def set_ad9833_waveform(waveform_type):
    if waveform_type == "sinus":
        send_ad9833_command(0x2000)  # Sinuswelle aktivieren
    elif waveform_type == "dreieck":
        send_ad9833_command(0x2002)  # Dreieckwelle aktivieren
    elif waveform_type == "rechteck":
        send_ad9833_command(0x2028)  # Rechteckwelle aktivieren (MSB/2-Modus)
    else:
        print("Unbekannter Wellentyp")

# Hauptprogramm
def main():
    set_ad9833_frequency(400)  # 400 Hz einstellen

    # Wellenform auswählen: sinus, dreieck, rechteck
    set_ad9833_waveform("sinus")  # Ändere "sinus" auf "dreieck" oder "rechteck" zum Testen der anderen Wellenformen

    while True:
        pass  # Endlosschleife, da der AD9833 kontinuierlich arbeitet

if __name__ == "__main__":
    main()

from machine import SPI, Pin
from utime import sleep

# SPI-Konfiguration für den AD9833 (Signal-Generator)
# SCK = Pin 2, MOSI = Pin 3, Baudrate auf 100 kHz eingestellt
spi_ad9833 = SPI(0, baudrate=100000, polarity=0, phase=1, sck=Pin(2), mosi=Pin(3))
cs_ad9833 = Pin(1, Pin.OUT)  # Chip Select für AD9833, gesteuert über Pin 1

# Funktion zum Senden eines 16-Bit-Kommandos an den AD9833
def send_ad9833_command(command):
    # Wählt den AD9833 aus, um die Kommunikation zu starten
    cs_ad9833.value(0)  # CS auf Low setzen
    
    # Sendet das 16-Bit-Kommando (wird in zwei 8-Bit-Teilen übertragen)
    spi_ad9833.write(bytearray([(command >> 8) & 0xFF, command & 0xFF]))
    
    # Beendet die Kommunikation
    cs_ad9833.value(1)  # CS auf High setzen
    
    # Kleine Verzögerung, um die Stabilität zu gewährleisten
    sleep(0.01)

# Funktion zum Einstellen der Frequenz am AD9833
def set_ad9833_frequency(frequency):
    # Berechnung des 28-Bit-Frequenzworts basierend auf der Referenzfrequenz von 25 MHz
    # (2^28 = 268435456 Schritte über 25 MHz)
    freq_word = int(frequency * (2**28) / 25_000_000)  # Frequenzwort berechnen
    
    # Aufteilen des Frequenzworts in zwei 14-Bit-Werte (LSB und MSB)
    freq_lsb = freq_word & 0x3FFF  # Untere 14 Bits des Frequenzworts
    freq_msb = (freq_word >> 14) & 0x3FFF  # Obere 14 Bits des Frequenzworts

    # Setzt den AD9833 in den Reset-Modus (um Einstellungen vorzunehmen)
    send_ad9833_command(0x2100)  # Reset aktivieren

    # Schreiben des Frequenzworts in Register 0
    # Der Befehl 0x4000 gibt an, dass das LSB zuerst gesendet wird
    send_ad9833_command(0x4000 | freq_lsb)  # Sende LSB der Frequenz
    send_ad9833_command(0x4000 | freq_msb)  # Sende MSB der Frequenz

    # Aktiviert die Sinus-Ausgabe und hebt den Reset auf
    send_ad9833_command(0x2000)  # Reset deaktivieren und Sinusausgabe starten

# Hauptprogramm
def main():
    # Setzt die Ausgangsfrequenz auf 400 Hz
    set_ad9833_frequency(400)
    
    # Dauerschleife, da der AD9833 kontinuierlich die Frequenz ausgibt, sobald er konfiguriert wurde
    while True:
        pass

if __name__ == "__main__":
    main()