Moin Raspyy123,
was kommt denn raus??
73 de Bernd
255 0xff 0b11111111
255 0xff 0b11111111
Moin Raspyy123,
was kommt denn raus??
73 de Bernd
255 0xff 0b11111111
255 0xff 0b11111111
Display MoreMoin Raspyy123,
so, nachdem ich acht mal erlegt worden bin...
Ausgehend von deb Code aus Beitrag #60
In Zeile 28: Write ist WR-Nicht. Du hast da aber eine 1 dort stehen. Nee, dein Kommentar ist nur falsch.
Die Zeilen 45 und 53 sind überflüssig.
Lass bitte mal die Zeilen 71 bis Ende weg. Konzentriere dich, bitte, erstmal auf eine Adresse. Hier sind kleine Schritte erforderlich. Wir müssen sicher stellen, das die Read und Write-Funktionen sicher funktionieren.
Setze das Register 0x000 auf 0xbd und lies es aus. Leseergebnis muss passen!!
Dann lies bitte das Register 0x02 aus. Das soll, nach einem Neustart den Wert 0x10 haben.
Dann sehen wir weiter.
73 de Bernd
Moin Bernd666,
leider funktioniert das auch nicht..mir gehen auch so langsam die Ideen aus:(
Moin Raspyy123,
du hast also nur def print_content(ad0, ad1, cont): neu geschrieben?
Ergebnis: es stimmt die Ausgabe nicht mehr.
Wie hast du denn vorher die Read-Funktion aufgerufen. Kannst du das noch posten, oder ist es weg?
73 de Bernd
nein, auch die wirte und read content FUnktion...anbei der komplette Code:
from tkinter import *
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
# Define GPIO pins
SCLK = 23 # M6, Pin:8
MISO = 21 # M4, Pin:6 (SDO at ADAR1000)
MOSI = 19 # M5, Pin:4 (SDIO at ADAR1000)
CSB = 24 # M3, Pin:2
# setup GPIO Pins
GPIO.setup(SCLK, GPIO.OUT) # Serial Clock Input
GPIO.setup(MISO, GPIO.IN) # Serial Data input
GPIO.setup(MOSI, GPIO.OUT) # Serial Data Output
GPIO.setup(CSB, GPIO.OUT) # Serial Port Enable Input (active low)
# Initialize everything to zero
GPIO.output(SCLK, GPIO.LOW)
GPIO.output(MOSI, GPIO.LOW)
GPIO.output(CSB, GPIO.HIGH)
# Function to send a 8 bit data MSB first
def write_SPI(send_byte):
for i in range(0, 8):
GPIO.output(MOSI, (send_byte << i) & 0x80) # 1000 0000
GPIO.output(SCLK, GPIO.HIGH) # steigende Flanke
GPIO.output(SCLK, GPIO.LOW) # fallende Flanke
def read_SPI(send_byte):
byte_read = 0
for i in range(0, 8):
GPIO.output(SCLK, GPIO.HIGH)
GPIO.output(MOSI, (send_byte << i) & 0x80) # 1000 0000
bit_read = GPIO.input(MISO) # bit einlesen
GPIO.output(SCLK, GPIO.LOW) # fallende Flanke
byte_read = (byte_read << 1) | bit_read # Byte zusammenbauen
return(byte_read) #
def print_content(ad0, ad1, cont):
GPIO.output(CSB, GPIO.HIGH) # Slave darf wieder schlafen
GPIO.output(CSB, GPIO.LOW) # Slave aktivieren
result_SPI=read_SPI(ad0)
result_SPI=read_SPI(ad1)
result_SPI=read_SPI(cont)
GPIO.output(CSB, GPIO.HIGH)
print((result_SPI), hex(result_SPI), bin(result_SPI))
GPIO.output(CSB, GPIO.HIGH) # Slave darf wieder schlafen
time.sleep(0.5)
def write_content(ad0, ad1, cont):
GPIO.output(SCLK, GPIO.LOW) # Takt sicher auf Low legen
GPIO.output(CSB, GPIO.LOW) # Slave aktivieren
write_SPI(ad0) # 0000 0000 - Adresse high
write_SPI(ad1) # 0000 0000 - Adresse low
write_SPI(cont)
#result_SPI=read_SPI(cont)
GPIO.output(CSB, GPIO.HIGH)
for i in range(1):
#0x000BD
write_content(0x00, 0x00, 0xBD)
print_content(0x10, 0x00, 0x00)
#0x40110
write_content(0x04, 0x01, 0x10)
print_content(0x14, 0x01, 0x10)
Display More
Ausgabe ist:
>>> %Run ADARnew
189 0xbd 0b10111101
255 0xff 0b11111111
>>>
Moin Raspyy123,
poste, bitte, dein Code von dieser Funktion.
Falls ich Bezeichnungen von Python falsch nutze, liegt es daran das ich in Python nicht programmieren kann. Ich kann es nur einigermassen lesen.
73 de Bernd
Moin Bernd,
def read_SPI(send_byte):
byte_read = 0
for i in range(0, 8):
GPIO.output(SCLK, GPIO.HIGH)
GPIO.output(MOSI, (send_byte << i) & 0x80) # 1000 0000
bit_read = GPIO.input(MISO) # bit einlesen
GPIO.output(SCLK, GPIO.LOW) # fallende Flanke
byte_read = (byte_read << 1) | bit_read # Byte zusammenbauen
Das ist die Funktion...
# Function to send a 8 bit data MSB first
def write_SPI(send_byte):
for i in range(0, 8):
GPIO.output(MOSI, (send_byte << i) & 0x80) # 1000 0000
GPIO.output(SCLK, GPIO.HIGH) # steigende Flanke
GPIO.output(SCLK, GPIO.LOW) # fallende Flanke
def read_SPI(send_byte):
byte_read = 0
for i in range(0, 8):
GPIO.output(SCLK, GPIO.HIGH)
GPIO.output(MOSI, (send_byte << i) & 0x80) # 1000 0000
bit_read = GPIO.input(MISO) # bit einlesen
GPIO.output(SCLK, GPIO.LOW) # fallende Flanke
byte_read = (byte_read << 1) | bit_read # Byte zusammenbauen
return(byte_read) #
def print_content(ad0, ad1, cont):
GPIO.output(CSB, GPIO.HIGH) # Slave darf wieder schlafen
GPIO.output(CSB, GPIO.LOW) # Slave aktivieren
result_SPI=read_SPI(ad0)
#print((result_SPI), hex(result_SPI), bin(result_SPI))
result_SPI=read_SPI(ad1)
#print((result_SPI), hex(result_SPI), bin(result_SPI))
#result_SPI=read_SPI(0x00)
result_SPI=read_SPI(cont)
print((result_SPI), hex(result_SPI), bin(result_SPI))
GPIO.output(CSB, GPIO.HIGH) # Slave darf wieder schlafen
time.sleep(0.5)
def write_content(ad0, ad1, cont):
GPIO.output(SCLK, GPIO.LOW) # Takt sicher auf Low legen
GPIO.output(CSB, GPIO.LOW) # Slave aktivieren
write_SPI(ad0) # 0000 0000 - Adresse high
write_SPI(ad1) # 0000 0000 - Adresse low
write_SPI(cont)
for i in range(1):
#0x000BD
write_content(0x00, 0x00, 0xBD)
print_content(0x10, 0x00, 0x00)
#0x40110
write_content(0x04, 0x01, 0x10)
print_content(0x14, 0x01, 0x10)
Display More
ich hab jetzt die write_content und print_content-FUnktionen geschrieben. Leider ist die Ausgabe bei Veränderung der Adressen falsch...Siehe Ausgabe:
>>> %Run ADARnew
189 0xbd 0b10111101
255 0xff 0b11111111
Habt ihr eine Idee, wie man korrekt andere Adressen übermitteln kann?
Vielen Dank! Sehr guter Tipp
der aktuelle COde:
def write_SPI(send_byte):
for i in range(0, 8):
GPIO.output(MOSI, (send_byte << i) & 0x80) # 1000 0000
GPIO.output(SCLK, GPIO.HIGH) # steigende Flanke
GPIO.output(SCLK, GPIO.LOW) # fallende Flanke
def read_SPI(send_byte):
byte_read = 0
for i in range(0, 8):
GPIO.output(SCLK, GPIO.HIGH)
GPIO.output(MOSI, (send_byte << i) & 0x80) # 1000 0000
bit_read = GPIO.input(MISO) # bit einlesen
GPIO.output(SCLK, GPIO.LOW) # fallende Flanke
byte_read = (byte_read << 1) | bit_read # Byte zusammenbauen
return(byte_read)
for i in range(1):
GPIO.output(SCLK, GPIO.LOW) # Takt sicher auf Low legen
GPIO.output(CSB, GPIO.LOW) # Slave aktivieren
write_SPI(0x00) # 0000 0000 - Adresse high
write_SPI(0x00) # 0000 0000 - Adresse low
write_SPI(0xBD) # 1011 1101 - Command "RESET"
GPIO.output(CSB, GPIO.HIGH) # Slave darf wieder schlafen
print('test') # Debugausgabe
GPIO.output(CSB, GPIO.LOW) # Slave aktivieren
result_SPI=read_SPI(0x10)
print((result_SPI), hex(result_SPI), bin(result_SPI))
result_SPI=read_SPI(0x00)
print((result_SPI), hex(result_SPI), bin(result_SPI))
result_SPI=read_SPI(0x00)
print((result_SPI), hex(result_SPI), bin(result_SPI))
result_SPI=read_SPI(0x00)
print((result_SPI), hex(result_SPI), bin(result_SPI))
#print(read_SPI(0x00))
result_SPI=read_SPI(0x00)
print((result_SPI), hex(result_SPI), bin(result_SPI))
result_SPI=read_SPI(0x00)
print((result_SPI), hex(result_SPI), bin(result_SPI))
result_SPI=read_SPI(0x00)
print((result_SPI), hex(result_SPI), bin(result_SPI))
result_SPI=read_SPI(0x00)
print((result_SPI), hex(result_SPI), bin(result_SPI))
result_SPI=read_SPI(0x00)
print((result_SPI), hex(result_SPI), bin(result_SPI))
result_SPI=read_SPI(0x00)
print((result_SPI), hex(result_SPI), bin(result_SPI))
result_SPI=read_SPI(0x00)
print((result_SPI), hex(result_SPI), bin(result_SPI))
GPIO.output(CSB, GPIO.HIGH) # Slave darf wieder schlafen
time.sleep(0.5) # kurze Wartezeit, halbe Sekunde
Display More
Ausgabe:
>>> %Run test.py
test
255 0xff 0b11111111
255 0xff 0b11111111
189 0xbd 0b10111101
0 0x0 0b0
16 0x10 0b10000
1 0x1 0b1
0 0x0 0b0
20 0x14 0b10100
0 0x0 0b0
0 0x0 0b0
0 0x0 0b0
>>>
def read_SPI(send_byte):
byte_read = 0
for i in range(0, 8):
GPIO.output(SCLK, GPIO.HIGH)
GPIO.output(MOSI, (send_byte << i) & 0x80) # 1000 0000
bit_read = GPIO.input(MISO) # bit einlesen
GPIO.output(SCLK, GPIO.LOW) # fallende Flanke
byte_read = (byte_read << 1) | bit_read # Byte zusammenbauen
return(byte_read)
soo mit folgendem Code erhalte ich jetzt die Ausgabe:
255
255
189
9
16
1
0
20
0
0
0
das ist schon mal besser, 189 entspricht ja "BD"
Moin Raspyy123,
mhm, das Lesen der Miso-Ltg könnte, vom Timing her, ein wenig knapp sein.
Kannst du das mal, testweise, tauschen?
Um meine Neugier zu befriedigen: Welchen RPi, mit welchem OS setzt du ein. Und ist der Adar1000 als Evulations Board vorhanden?
73 de Bernd
Moin Bernd666, ich habe die Zeilen vertauscht.. Ausgabe ist:
>>> %Run
test
255
255
222
128
136
128
128
138
128
128
128
Zu deiner Frage. Ich habe den Raspby 3B und das Eval Board zum ADAR1000 habe ich auch..Nur habe ich zur Zeit keinen Logic Analyzer um Tests duchzuführen
Es könnte sein, das beim Zusammensetzen der empfangen Bytes ein Fehler ist.
122 (dezimal) = 0x7A = 0111 1010
Wenn ich das nun um 1 bit nach rechts schiebe un das höchste bit 1 setzte kommt
1011 1101 = 0XBD
Willst du den Fehler selbst suchen oder soll ich dir helfen? Er liegt auf jeden Fall beim Zusammenbauen des Byte
def read_SPI(send_byte):
byte_read = 0
for i in range(0, 8):
GPIO.output(SCLK, GPIO.HIGH)
GPIO.output(MOSI, (send_byte << i) & 0x80) # 1000 0000
GPIO.output(SCLK, GPIO.LOW) # fallende Flanke
bit_read = GPIO.input(MISO) # bit einlesen
# bit_read = GPIO.input(MISO) # bit einlesen
# GPIO.output(SCLK, GPIO.LOW) # fallende Flanke
byte_read = (byte_read << 1) | bit_read # Byte zusammenbauen
return(byte_read)
Display More
ich schaue grad auf die Funktionsdefinition von "read_SPI"...kann man da standardmäßig vor der Rückgabe von Byte_read das byte nach rechts verschiebt und das erste Bit auf 1 setzt.?
Das heißt:
vielen Dank erst einmal für Eure Hilfe! Ich habe in der Zwischenzeit versucht Eure Tipps umzusetzen...Ich habe den Code von bombom übernommen. Dieser funktioniert soweit ganz gut...der Chip reagiert..
for i in range(1):
GPIO.output(SCLK, GPIO.LOW) # Takt sicher auf Low legen
GPIO.output(CSB, GPIO.LOW) # Slave aktivieren
write_SPI(0x00) # 0000 0000 - Adresse high
write_SPI(0x00) # 0000 0000 - Adresse low
write_SPI(0xBD) # 1011 1101 - Command "RESET"
GPIO.output(CSB, GPIO.HIGH) # Slave darf wieder schlafen
print('test') # Debugausgabe
GPIO.output(CSB, GPIO.LOW) # Slave aktivieren
print(read_SPI(0x10)) # 1000 0000 - Adresse high
print(read_SPI(0x00)) # 0000 0000 - Adresse low
print(read_SPI(0x00))
print(read_SPI(0x00))
print(read_SPI(0x00))
print(read_SPI(0x00))
print(read_SPI(0x00))
print(read_SPI(0x00))
print(read_SPI(0x00))
print(read_SPI(0x00))
print(read_SPI(0x00))
GPIO.output(CSB, GPIO.HIGH) # Slave darf wieder schlafen
time.sleep(0.5) # kurze Wartezeit, halbe Sekunde
Display More
Als Ausgabe erhalte ich :
>>>%Run test.py
test
255
255
122
0
32
2
0
40
0
0
0
meine Frage:
Warum erhalte ich nicht die Ausgabe "BD"? Ich habe diesen Content am Anfang an die Adresse 0x000 reingeschrieben.
Wieso kommen bei den ersten Ausgaben "255" raus?
Moin Raspyy123,
ich will mich nicht einmischen!
Aber, weil ich mitlese, eine Frage: Wo steht in dem Datenblatt was nach einem Reset ausgegeben wird?? Oder warum erwartest du "21"??
73 de Bernd
Hallo Bernd666, ich habe nicht "21" erwartet...die Zahl 21 war die tatsächliche Ausgabe...Ich habe die "BD" erwartet, also den Content der Adresse..
Aus dem Datenblatt Seite 7 Figure 4. Timing Diagram for Serial Port Interface Register Read siehst, dass du 24 bit lesen musst.
richtig, das habe ich auch bei der Read-Funktion schon angepasst....aber an der Ausgabe ändert sich nichts
Display MoreOh Mann, muss man dir Alles aus der Nase ziehen?
Was stellen die verschiedenen Pegel dar?
DO(5) -> SCLK
DO(0) -> CSB
DO(2) -> MOSI
DO(1) -> MISO
Ist das richtig?
CSB low activ? Ist das richtig?
Wo ist der Code?
sorry, das ist richtig
der Code:
# Define GPIO pins
SCLK = 23 # M6, Pin:8
MISO = 21 # M4, Pin:6 (SDO at ADAR1000)
MOSI = 19 # M5, Pin:4 (SDIO at ADAR1000)
CSB = 24 # M3, Pin:2
# setup IO bits
GPIO.setup(SCLK, GPIO.OUT) # Serial Clock Input
GPIO.setup(MISO, GPIO.IN) # Serial Data input
GPIO.setup(MOSI, GPIO.OUT) # Serial Data Output
GPIO.setup(CSB, GPIO.OUT) # Serial Port Enable Input (active low)
# Initialize everything to zero
GPIO.output(SCLK, False)
GPIO.output(MOSI, False)
GPIO.output(CSB, True)
# Function to send a pulse to GPIO pin
def pulseHigh(pin):
GPIO.output(pin, False)
GPIO.output(pin, True)
GPIO.output(pin, True)
GPIO.output(pin, False)
return
# Function to send a 16 bit address plus data byte to ADAR1000 module
def transfer(value):
GPIO.output(SCLK, GPIO.LOW)
GPIO.output(CSB, GPIO.LOW)
for i in range(0,24):
if(value & 0x800000)!=0:
GPIO.output(MOSI, GPIO.HIGH)
else:
GPIO.output(MOSI, GPIO.LOW)
pulseHigh(SCLK)
value=value<<1
GPIO.output(CSB, GPIO.HIGH)
# Read Function
def read(value):
GPIO.output(CSB, GPIO.HIGH)
for i in range(0,16):
if(value & 0x8000)!=0:
GPIO.output(MOSI, GPIO.LOW)
else:
GPIO.output(MOSI, GPIO.HIGH)
GPIO.output(SCLK, GPIO.HIGH)
print (GPIO.input(21))
GPIO.output(SCLK, GPIO.LOW)
value=value<<1
GPIO.output(CSB, GPIO.LOW)
# Define ADAR1000 commands
RESET = 0x000BD
while True:
transfer(RESET) #0x000BD
print('test')
read(0x000) #print: BD
Display More
Display MoreFehlereingrenzung (nach jeder Zeile testen, ob es eine Änderung gibt und welche):
Ersetze in Zeile 9 "21" mit "MISO"
Vertausche Zeile 9 mit 10
Vertausche Zeile 9 (SCLK - low) mit Zeile 8 (SCLK - high)
Du hast geschrieben, dass du einen Logikanalysator hast. Schliesse die Pin CSB, SCLK, MOSI und MISO an. Welche Pegel siehst du an MISO. Wann werden neue Pegel an MISO im Abhänigkeit von steigender/fallender Flanke von SCLK angezeigt. Ändert sich etwas wenn CSB "low activ" ist?
Erzeuge dir das jeweils zu sendende bit. (ich weiss jetzt nicht ob das richtig ist, schau bitte selbst nach der richtigen Syntax, für bit-Operationen)
Codebyte_read = 0 for i in range (0, 8): bit_write = (byte_write << i) & 0x80 ## Hier bitte richtige Syntax ergänzen ## Es kommt auch darauf an ob du LSB oder MSB hast GPIO.output(MOSI, bit_write) GPIO.output(SCLK, GPIO.HIGH) bit_read = GPIO.input(MISO) GPIO.output(SCLK, GPIO.LOW) byte_read = (byte_read << 1) | bit_read print (i, bit_write, bit_read, byte_read) ## Hier Formatierung der Ausgabe anpassen
Lass dir im Programm auch "i", "bit_write" und "bit_read" mit ausgeben.
Allgemein: Sei fantasievoll und rechne mit allen möglichen Fehlern, schliesse nichts aus. Zerlege grosse Sache in kleine Häppchen. Mach mit dem 2. Schritt erst weiter, wenn der erste Schritt funktioniert, z.B. siehst du am Analysator den Wechsel von SCLK und MOSI, dann erst Auswertung von MISO. Stimmen die Stifte in der Leiste mit den GPIO-Nummer überein?
Vielen dank...komischerweise ändert sich nichts, wenn ich etwas am Code veränder...Die Ausgabe bleibt stets "1"....anbei das Bild vom Logic Analyzer...das passt ja mit dem Data Sheet soweit überein...
Dann werde ich mich weiterhin auf Fehlersuche begeben...trotzdem Danke!
Hallo,
wenn der Baustein SPI hat, dann nimm doch ein Modul wie spidev für die Kommunikation statt das low-Level selber zu coden.
Gruß, noisefloor
Hallo, ich habe bereits so viel Arbeit reingesteckt und möchte verstehen, wo der Fehler nun liegt....ich denke, dass es ein kleiner Denkfehler sein muss, da ich das Timing mit dem Logic Analyzer ja überprüft habe..
ich habe das korrigiert...und bekomme jetzt aus Ausgabe "1"
def read(value):
GPIO.output(CSB, GPIO.HIGH)
for i in range(0,16):
if(value & 0x8000)!=0:
GPIO.output(MOSI, GPIO.LOW)
else:
GPIO.output(MOSI,GPIO.HIGH)
GPIO.output(SCLK, GPIO.HIGH)
print(GPIO.input(21))
GPIO.output(SCLK, GPIO.LOW)
value=value<<1
GPIO.output(CSB, GPIO.LOW)
Display More
Es muss wohl ein andere Fehler vorhanden sein....
Hallo bombom,
vielen Dank für deine Rückmeldung. Ich habe mal den Code erweitert und habe versucht den Inhalt der Adresse auszugeben (siehe die letzten Zeilen):
# Function to send a 16 bit address plus data byte to ADAR1000 module
def transfer(value):
GPIO.output(SCLK, GPIO.LOW)
GPIO.output(CSB, GPIO.LOW)
for i in range(0,16):
if(value & 0x8000)!=0:
GPIO.output(MOSI, GPIO.HIGH)
else:
GPIO.output(MOSI,GPIO.LOW)
pulseHigh(SCLK)
# value=value<<1
GPIO.output(CSB, GPIO.HIGH)
# Read Function
def read(value):
GPIO.output(CSB, GPIO.HIGH)
for i in range(0,24):
if(value & 0x800000)!=0:
GPIO.output(MOSI, GPIO.LOW)
else:
GPIO.output(MOSI,GPIO.HIGH)
pulseHigh(SCLK)
print(MISO)
pulseLow(SCLK)
value=value<<1
GPIO.output(CSB, GPIO.LOW)
# Define ADAR1000 commands
RESET = 0x000BD
while True:
transfer(RESET) #0x000BD
print('test')
read(0x000) #print: BD
Display More
Leider ist meine Ausgabe immer nur die Zahl "21"
ich hatte "BD" erwartet, also den Content der Adresse...Weißt du vielleicht, wo der Bug liegen könnte?
dankee, ich verstehe was du meinst...
def read(value):
GPIO.output(SCLK, GPIO.HIGH)
GPIO.output(CSB, GPIO.HIGH)
for i in range(0,16): # eine Adresse hat 16 bits
if(value & 0x10)!=0:
GPIO.output(MISO, GPIO.HIGH)
else:
GPIO.output(MISO,GPIO.LOW)
pulseLow(SCLK)
value=value<<1
GPIO.output(CSB, GPIO.LOW)
print(GPIO.input(21)) #MISO wird ausgegeben
Display More
müsste das dann nicht in etwa so aussehen, nach dem ich die Transfer Funktion verwendet habe? Dann würde ich sehen, welcher Wert in MISO vorhanden ist
In welchen Kommentaren? Meinst du den ADAR1000 aus deinem anderen Thread? Ich habe mir das Datenblatt angeschaut, absoluter Hardcore. Nichts für Amateure.
Hast du dir die Grundlagen zum SPI durchgelesen? Weisst du wie die Kommunikatio, senden und empfangen, funktioniert? Wann welcher Teilnehmer was bekommt?
ja, das habe ich. Ich habe meinen Code bereits überprüft. Ich habe GPIOs des Raspberrys an den Logic Analyzer angeschlossen und habe mit dem Code das Timing Diagramm vom ADAR1000 realisieren können. Sobald ich jedoch den Raspberry Pi über die SPI Schnittstelle an den ADAR1000 anschließe und das Programm laufen lasse, reagiert der ADAR nicht. Aus diesem Grund wollte ich die Read Funktion einbauen, um zu prüfen, was bei dem ADAR ankommt....
Hallo,
du müsstest noch verraten, welchen Baustein du konkret hast, sonst wird das nichts mit dem Helfen.
Gruß, noisefloor
Ich habe in den Kommentaren das Datenblatt von dem Baustein eingefügt