Hallo zusammen.
Ich arbeite gerade an einem Projekt bei dem ich eine Stromregelung auf
einem FPGA (Altera Cyclon IV) implementiert habe. Über eine in MatLab
entworfene GUI gebe ich den Sollwert vor. Die Übertragung von MatLab zum
FPGA geschieht über UART. Nachfolgend die Codes die ich geschrieben
habe.
Der MatLabcode für die GUI:
1
function Current_Source_Control_GUI_OpeningFcn(hObject, eventdata, handles, varargin)
2
3
handles.output = hObject;
4
5
guidata(hObject, handles);
6
7
global serialPort;
8
serialPort = []; %Initialisiere serialPort mit Nullen.
9
10
global USB_COM_Port;
11
USB_COM_Port = handles.USB_COM_Port;
12
13
global connect_COM_Port;
14
connect_COM_Port = handles.connect_COM_Port;
15
16
guidata(hObject, handles);
17
18
19
% --- Executes on selection change in USB_COM_Port.
20
function USB_COM_Port_Callback(hObject, eventdata, handles)
21
22
USB_COM_Port
23
24
guidata(hObject, handles);
25
26
27
% --- Executes on button press in connect_COM_Port.
28
function connect_COM_Port_Callback(hObject, eventdata, handles)
Im Endeffekt habe ich vor, über Matlab eine 32-Bit Nachricht zu
verschicken. Zum Empfang dieser Nachricht habe ich im Nios ii Prozessor
ein Array mit 4 Feldern implementiert, wo der Reihe nach Byte für Byte
der 32-Bit Nachricht abgespeichert werden.
Zum testen habe ich die Werte [11 23 32 44] rüber geschickt. Folgendes
Ergebnis habe ich erhalten:
1. Byte = 0
2. Byte = 11
3. Byte = 23
4. Byte = 32.
Es scheit so als ob mein Array erst ab den zweiten Feld gefüllt wird und
der letzte Wert, die 44 dabei verloren gehen. Doch wenn ich umittelbar
danach die selben Wert erneut sende, erhalte ich folgendes Ergebnis:
1. Byte = 44
2. Byte = 11
3. Byte = 23
4. Byte = 32.
Der letzte Wert schein nun im ersten Feld meines Arrays gespeichert zu
werden und soltte dabei eigentlich im letzten Feld gespeichert werden.
Meine Theorie ist, vor dem erstmaligem Senden wird durch den
Programmablauf der Rx-Buffer ausgelesen und der leere Bufferwert im
ersten Feld meines Arrays gespeichert. Nachdem ich die Zahlenfolge
gesendet habe, werden die ersten drei Zahlen in den restlichen Felder
meines Arrays gespeichert. Der letzte Wert hat nun kein freies Feld
mehr, in das es abgelegt werden kann, also wird es im Rx-Buffer zwischen
gespeichert bis zum nächsten Empfang der Zahlenfolge. Wenn nun die
Zahlenfolge erneut ankommt, wird der Rx-Buffer ausgelesen, in dem zuvor
der letzte Wert gespeichert wurde und diesmal im ersten Feld meines
Arrays abgespeichert.
Was ich schon probiert habe ist, denn Buffer erst dann auszulesen,
nachdem ich die Zahlenfolge gesendet habe, doch das Ergebnisse war das
selbe.
Nun hoffe ich, dass ihr mir sagen könnt, was ich machen kann, damit
meine gesendete Zahlenfolge in der richtigen Reihenfolge in meinem Array
abgespeichert wird.
Was du da hast ist kein Buffer, sondern ein Array! Das ist ein
klassischer Fehltritt. Oftmals wird bei der Initialisierung
fälschlicherweise ein byte gesendet und schon läuft nix. Erhöhe den
Buffer auf 256 und schreibe ein Protokoll mit einen Header und
Terminator.
Erstmal danke für deine Antwort Kanack.
Kanack schrieb:> Was du da hast ist kein Buffer, sondern ein Array!
Mein Altera besitzt zwei Register, ein Holding- und ein Shiftregister.
Ankommende Nachrichten kommen zuerst ins Holding Register bevor sie ans
Shift Register weitergegeben und ausgelesen werden. Das meinte ich mit
Buffer. Sorry ich hätte da vielleicht etwas ausführlicher werden sollen.
Kanack schrieb:> Das ist ein klassischer Fehltritt. Oftmals wird bei der Initialisierung> fälschlicherweise ein byte gesendet und schon läuft nix. Erhöhe den> Buffer auf 256 und schreibe ein Protokoll mit einen Header und> Terminator.
Sorry ich muss dann nochmal nachfragen. Welchen Buffer meinst du?
Also soll ich jetzt jede Nachricht mit einem Header ausstatten an der
mein Nios II Prozessor erkennt, ob die Nachricht angenommen oder wieder
verworfen werden soll. Das klingt logisch, danke.
Kanack schrieb:>
>> "get_uart_message" ist von typ !void. Ein kleines delay bei der while> Schleife wäre für ein Testdurchlauf nicht schlecht.
Ups, da ist mir ein Fehler unterlaufen. Die Funktion sollte eigentlich
vom Typ
Servus,
du hast zwei Programme geschrieben und somit sind zwei Fehlerquellen
möglich.
Lade dir ein Terminal Programm wie hTerm und such nach den Fehler.
Weiterhin rate ich dir einen fifo Buffer mit einen Protokoll zu
erstellen, damit die Fehlerwahrcheinlichkeit minimiert wird. Bei
konstanter Wortlänge reicht ein header oder terminator oftmals für erste
aus.
mfg