Sign in Join
Wiki copytemporary

AVR Embedded Tutorial - SPI/de: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

OldNewLine
1-Zur Übersichtseite [[AVR Embedded Tutorial/de|AVR Embedded Tutorial]].
1+Zur Übersichtseite [[AVR Embedded Tutorial/de|AVR Embedded Tutorial]].
22
3+## Contents
4+
5+ * 1 Nutzung der Hardware-SPI-Schnittstelle bei einem ATmega328 / Arduino
6+ * 1.1 SPI-Master
7+ * 1.1.1 Header der Unit
8+ * 1.1.2 Initialisierung
9+ * 1.1.3 Daten übertragen
10+ * 1.1.4 Daten nur Schreiben
11+ * 1.1.5 Einzelnes Byte senden und empfangen
12+ * 1.2 Anwendung als Master
13+ * 1.2.1 Konfig schreiben
14+ * 1.2.2 Konfig auslesen
15+ * 1.2.3 Register schreiben
16+ * 1.2.4 Register auslesen
17+ * 1.3 Siehe auch
18+
319# Nutzung der Hardware-SPI-Schnittstelle bei einem ATmega328 / Arduino
420
5-Voraussetzung ist ein eingerichteter Crosscompiler für AVR Controller wie hier beschrieben:
21+Voraussetzung ist ein eingerichteter Crosscompiler für AVR Controller wie hier beschrieben:
622
7-- [[AVR Embedded Tutorial - Entry Lazarus and Arduino/de|Einstieg Lazarus und Arduino]]
23+ * [[AVR Embedded Tutorial - Entry Lazarus and Arduino/de|Einstieg Lazarus und Arduino]]
824
9-Zu den Grundlagen von SPI, Master-Slave, Verdrahtung siehe Wikipedia:
25+Zu den Grundlagen von SPI, Master-Slave, Verdrahtung siehe Wikipedia:
1026
11-- <https://de.wikipedia.org/wiki/Serial_Peripheral_Interface>
27+ * <https://de.wikipedia.org/wiki/Serial_Peripheral_Interface>
1228
13-Das ist eine ganz einfache SPI-Unit, bei der die Einstellungen für
29+Das ist eine ganz einfache SPI-Unit, bei der die Einstellungen für
1430
15-- Datenformat
16-- Mode
17-- ChipSelect
18-- Speed
31+ * Datenformat
32+ * Mode
33+ * ChipSelect
34+ * Speed
1935
20-von Hand vorgenommen werden müssen. Zur Funktion der einzelnen Register und Flags siehe Datenblatt zum ATmega328.
36+von Hand vorgenommen werden müssen. Zur Funktion der einzelnen Register und Flags siehe Datenblatt zum ATmega328.
2137
2238## SPI-Master
2339
24-Zuerst kommt der
40+Zuerst kommt der
2541
2642### Header der Unit
2743
28-welcher die Pin- und Portkonfiguration enthält:
29-
30-``` pascal
44+welcher die Pin- und Portkonfiguration enthält:
45+```
3146unit gh_spi;
32-
33-{$mode objfpc}{$H+}
34-{$goto on}
35-
36-interface
37-
38-uses
39- ;
40-
41-procedure spi_init();
42-procedure spi_transfer_sync(var dout : array of uint8; var din : array of uint8; len : uint8);
43-procedure spi_transmit_sync(var dout : array of uint8; len : uint8);
44-function spi_fast_shift(data : uint8) : uint8;
45-
46-const
47- Psck = 1 shl 5; // PB5
48- Pmiso = 1 shl 4; // PB4
49- Pmosi = 1 shl 3; // PB3
50- Pss = 1 shl 2; // PB2
51- Pcs = 1 shl 1; // PB1
52-
53-var
54- DDRspi : byte absolute DDRB; // SPI an Port B
55- PORTspi : byte absolute PORTB;
56- PINspi : byte absolute PINB;
57-
58-implementation
47+
48+ {$mode objfpc}{$H+}
49+ {$goto on}
50+
51+ interface
52+
53+ uses
54+ ;
55+
56+ procedure spi_init();
57+ procedure spi_transfer_sync(var dout : array of uint8; var din : array of uint8; len : uint8);
58+ procedure spi_transmit_sync(var dout : array of uint8; len : uint8);
59+ function spi_fast_shift(data : uint8) : uint8;
60+
61+ const
62+ Psck = 1 shl 5; // PB5
63+ Pmiso = 1 shl 4; // PB4
64+ Pmosi = 1 shl 3; // PB3
65+ Pss = 1 shl 2; // PB2
66+ Pcs = 1 shl 1; // PB1
67+
68+ var
69+ DDRspi : byte absolute DDRB; // SPI an Port B
70+ PORTspi : byte absolute PORTB;
71+ PINspi : byte absolute PINB;
72+
73+ implementation
5974```
6075
61-Wenn man mehrere SPI-Devices ansprechen will, kann man sich dafür mehrere CS (ChipSelect) Pins definieren. Das SS Pin **muß** auf Ausgang stehen. Steht es auf Eingang, kann darüber das SPI-Interface in den Slave-Mode geschaltet werden - und nix geht mehr. Und wenn es einmal auf Ausgang steht, kann man es auch gleich noch für CE (ChipEnable) oder CS (ChipSelect) verwenden.
76+Wenn man mehrere SPI-Devices ansprechen will, kann man sich dafür mehrere CS (ChipSelect) Pins definieren. Das SS Pin **muß** auf Ausgang stehen. Steht es auf Eingang, kann darüber das SPI-Interface in den Slave-Mode geschaltet werden - und nix geht mehr. Und wenn es einmal auf Ausgang steht, kann man es auch gleich noch für CE (ChipEnable) oder CS (ChipSelect) verwenden.
6277
6378### Initialisierung
64-
65-``` pascal
79+```
6680// SPI initialisieren
67-
68-procedure spi_init();
69-begin
70- DDRspi := DDRspi and not(Pmiso); // MISO Eingang
71- DDRspi := DDRspi or (Pmosi or Psck or Pss); // MOSI, SCK, SS Ausgang
72- // SS muß Ausgang sein, sonst Umschalten auf Slave von außen möglich
73-
74- SPCR := ((1 shl SPE) or (0 shl SPIE) or (0 shl DORD) or (1 shl MSTR) or (0 shl CPOL) or (0 shl CPHA) or (%01 shl SPR));
75- // SPI enable, MSB first, Master select, SCK 1MHz = XTAL / 16 x 2
76- SPSR := (1 shl SPI2X); // SCK x 2 auf 1 MHZ
77-end;
81+
82+ procedure spi_init();
83+ begin
84+ DDRspi := DDRspi and not(Pmiso); // MISO Eingang
85+ DDRspi := DDRspi or (Pmosi or Psck or Pss); // MOSI, SCK, SS Ausgang
86+ // SS muß Ausgang sein, sonst Umschalten auf Slave von außen möglich
87+
88+ SPCR := ((1 shl SPE) or (0 shl SPIE) or (0 shl DORD) or (1 shl MSTR) or (0 shl CPOL) or (0 shl CPHA) or (%01 shl SPR));
89+ // SPI enable, MSB first, Master select, SCK 1MHz = XTAL / 16 x 2
90+ SPSR := (1 shl SPI2X); // SCK x 2 auf 1 MHZ
91+ end;
7892```
7993
80-Eingestellt werden hier
94+Eingestellt werden hier
8195
82-- SPE = 1: SPI enable
83-- SPIE = 0: kein Interrupt
84-- DORD = 0: MSB first, 1: LSB first
85-- MSTR = 1: als Master, kann aber durch Pin SS von Außen überschrieben werden, 0: als Slave
86-- CPOL = 0: SCK Polarität normal, 1: SCK invertiert
87-- CPHA = 0: SCK Phase normal, 1: SCK verschoben
88-- SPR = 01: fcpu / 16
89-- SPI2X = 1: fcpu * 2, ergibt 1MHz Clock bei 8Mhz Controllertakt, siehe Datenblatt für andere Clockraten.
96+ * SPE = 1: SPI enable
97+ * SPIE = 0: kein Interrupt
98+ * DORD = 0: MSB first, 1: LSB first
99+ * MSTR = 1: als Master, kann aber durch Pin SS von Außen überschrieben werden, 0: als Slave
100+ * CPOL = 0: SCK Polarität normal, 1: SCK invertiert
101+ * CPHA = 0: SCK Phase normal, 1: SCK verschoben
102+ * SPR = 01: fcpu / 16
103+ * SPI2X = 1: fcpu * 2, ergibt 1MHz Clock bei 8Mhz Controllertakt, siehe Datenblatt für andere Clockraten.
90104
91-Die Register entsprechend der Unit ATmega328P aus den Embedded AVR Sources. Für andere Controller unbedingt die Register anhand des Datenblattes überprüfen.
105+Die Register entsprechend der Unit ATmega328P aus den Embedded AVR Sources. Für andere Controller unbedingt die Register anhand des Datenblattes überprüfen.
92106
93107### Daten übertragen
94108
95-Um Daten von einem Device zu lesen, müssen gleichzeitig auch Daten geschrieben werden. Das können aber auch Dummydaten sein. Die Anzahl geschriebener und gelesener Bytes ist gleich.
96-
97-``` pascal
109+Um Daten von einem Device zu lesen, müssen gleichzeitig auch Daten geschrieben werden. Das können aber auch Dummydaten sein. Die Anzahl geschriebener und gelesener Bytes ist gleich.
110+```
98111// SPI Daten senden, empfangen
99-
100-procedure spi_transfer_sync(var dout : array of uint8; var din : array of uint8; len : uint8);
101-var
102- cnt : uint8;
103-begin
104- for cnt := 0 to len - 1 do begin
105- SPDR := dout[cnt]; // zu sendendes Byte ausgeben
106- while (SPSR and (1 shl SPIF)) = 0 do; // warten bis fertig
107- din[cnt] := SPDR; // empfangenes Byte einlesen
112+
113+ procedure spi_transfer_sync(var dout : array of uint8; var din : array of uint8; len : uint8);
114+ var
115+ cnt : uint8;
116+ begin
117+ for cnt := 0 to len - 1 do begin
118+ SPDR := dout[cnt]; // zu sendendes Byte ausgeben
119+ while (SPSR and (1 shl SPIF)) = 0 do; // warten bis fertig
120+ din[cnt] := SPDR; // empfangenes Byte einlesen
121+ end;
108122 end;
109-end;
110123```
111124
112-Das Schöne bei Pascal ist, dass man mit richtigen Arrays arbeiten kann und nicht wie bei C mit Pointern rummachen muß. Wichtig ist hier, dass die Arrays per **var** übergeben werden. Dann arbeitet Pascal mit dem ursprünglichen Array, andernfalls wird eine Kopie erstellt, was unnötige Zeit und unnötigen Speicherbedarf erfordert.
125+Das Schöne bei Pascal ist, dass man mit richtigen Arrays arbeiten kann und nicht wie bei C mit Pointern rummachen muß. Wichtig ist hier, dass die Arrays per **var** übergeben werden. Dann arbeitet Pascal mit dem ursprünglichen Array, andernfalls wird eine Kopie erstellt, was unnötige Zeit und unnötigen Speicherbedarf erfordert.
113126
114-Die Routine wartet, bis alle Bytes aus *dout* rausgeschrieben und gleichzeitig die empfangenen Daten in *din* eingelesen sind, was bei 1Mhz etwa 10µsec pro Byte dauert. Da das real nur wenige Systemtakte pro Byte sind lohnt sich hier ein Interrupt nicht. Die Routine kann durch andere Interrupts (Timer, Uart) unterbrochen werden, was das Ausgeben des nächsten Bytes verzögert, aber unproblematisch ist.
127+Die Routine wartet, bis alle Bytes aus _dout_ rausgeschrieben und gleichzeitig die empfangenen Daten in _din_ eingelesen sind, was bei 1Mhz etwa 10µsec pro Byte dauert. Da das real nur wenige Systemtakte pro Byte sind lohnt sich hier ein Interrupt nicht. Die Routine kann durch andere Interrupts (Timer, Uart) unterbrochen werden, was das Ausgeben des nächsten Bytes verzögert, aber unproblematisch ist.
115128
116-Für *dout*, *din* darf auch das gleiche Array angegeben werden, dann werden die ursprünglichen Daten durch die empfangenen Daten ersetzt.
129+Für _dout_ , _din_ darf auch das gleiche Array angegeben werden, dann werden die ursprünglichen Daten durch die empfangenen Daten ersetzt.
117130
118-**Achtung!** Hier und für die folgenden Routinen gilt: Wird die Routine aufgerufen, ohne dass SPE im SPCR gesetzt wurde (siehe Init), bleibt der Controller in der Warteschleife hängen, da das Datenbyte nicht gesendet und folglich das SPIF-Flag nicht gesetzt wird.
131+**Achtung!** Hier und für die folgenden Routinen gilt: Wird die Routine aufgerufen, ohne dass SPE im SPCR gesetzt wurde (siehe Init), bleibt der Controller in der Warteschleife hängen, da das Datenbyte nicht gesendet und folglich das SPIF-Flag nicht gesetzt wird.
119132
120133### Daten nur Schreiben
121134
122-Wenn nur Daten geschrieben werden soll, aber keine Antwort vom Device erwartet wird, kann man die Routine vereinfachen.
123-
124-``` pascal
135+Wenn nur Daten geschrieben werden soll, aber keine Antwort vom Device erwartet wird, kann man die Routine vereinfachen.
136+```
125137// SPI Daten senden ohne Empfang
126-
127-procedure spi_transmit_sync(var dout : array of uint8; len : uint8);
128-var
129- cnt : uint8;
130-begin
131- for cnt := 0 to len - 1 do begin
132- SPDR := dout[cnt]; // zu sendendes Byte ausgeben
133- while (SPSR and (1 shl SPIF)) = 0 do; // warten bis fertig
138+
139+ procedure spi_transmit_sync(var dout : array of uint8; len : uint8);
140+ var
141+ cnt : uint8;
142+ begin
143+ for cnt := 0 to len - 1 do begin
144+ SPDR := dout[cnt]; // zu sendendes Byte ausgeben
145+ while (SPSR and (1 shl SPIF)) = 0 do; // warten bis fertig
146+ end;
134147 end;
135-end;
136148```
137149
138-Hier gilt das Gleiche wie für die Transfer-Routine.
150+Hier gilt das Gleiche wie für die Transfer-Routine.
139151
140152### Einzelnes Byte senden und empfangen
141153
142-Mitunter muß nur ein einzelnes Byte übertragen werden, zum Beispiel zum Abfragen eines Status.
143-
144-``` pascal
154+Mitunter muß nur ein einzelnes Byte übertragen werden, zum Beispiel zum Abfragen eines Status.
155+```
145156// SPI einzelnes Byte senden, empfangen
146-
147-function spi_fast_shift(data : uint8) : uint8;
148-begin
149- SPDR := data; // zu sendendes Byte ausgeben
150- while (SPSR and (1 shl SPIF)) = 0 do; // warten bis fertig
151- spi_fast_shift := SPDR; // empfangenes Byte einlesen
152-end;
157+
158+ function spi_fast_shift(data : uint8) : uint8;
159+ begin
160+ SPDR := data; // zu sendendes Byte ausgeben
161+ while (SPSR and (1 shl SPIF)) = 0 do; // warten bis fertig
162+ spi_fast_shift := SPDR; // empfangenes Byte einlesen
163+ end;
153164```
154165
155-Raus, warten, rein. Eigentlich ganz einfach.
156-
157-Und fertig ist die Unit.
166+Raus, warten, rein. Eigentlich ganz einfach.
158167
159-``` pascal
168+Und fertig ist die Unit.
169+```
160170end.
161171```
162172
163173## Anwendung als Master
164174
165-Die beispielhafte Anwendung der Unit als Master für ein NRF-Modul.
175+Die beispielhafte Anwendung der Unit als Master für ein NRF-Modul.
166176
167-Am Programmanfang muss natürlich **spi_init** aufgerufen werden. Außerdem sind die Register des NRF-Moduls als Konstanten deklariert und ein Sende- und ein Empfangsbuffer als array of uint8 eingerichtet.
177+Am Programmanfang muss natürlich **spi_init** aufgerufen werden. Außerdem sind die Register des NRF-Moduls als Konstanten deklariert und ein Sende- und ein Empfangsbuffer als array of uint8 eingerichtet.
168178
169-Um das CS müssen wir uns selbst kümmern. Beim NRF-Modul ist das CS low-aktiv, der Ruhepegel ist also high und wird zur Aktivierung auf low gezogen.
179+Um das CS müssen wir uns selbst kümmern. Beim NRF-Modul ist das CS low-aktiv, der Ruhepegel ist also high und wird zur Aktivierung auf low gezogen.
170180
171181### Konfig schreiben
172-
173-``` pascal
182+```
174183procedure nrf_set_config(reg, data : uint8);
175-begin
176- PORTspi := PORTspi and not(Pspi_cs); // CS setzen, ist beim Modul low-aktiv
177- spi_fast_shift(cW_REGISTER or (cREGISTER_MASK and reg)); // Controlbyte senden
178- spi_fast_shift(data); // Datenbyte senden
179- PORTspi := PORTspi or Pspi_cs; // CS löschen, ist beim Modul low-aktiv
180-end;
184+ begin
185+ PORTspi := PORTspi and not(Pspi_cs); // CS setzen, ist beim Modul low-aktiv
186+ spi_fast_shift(cW_REGISTER or (cREGISTER_MASK and reg)); // Controlbyte senden
187+ spi_fast_shift(data); // Datenbyte senden
188+ PORTspi := PORTspi or Pspi_cs; // CS löschen, ist beim Modul low-aktiv
189+ end;
181190```
182191
183-Es wird ein Byte zur Adressierung des Registers und ein Byte mit dem Wert gesendet, auf den das Register gesetzt werden soll.
192+Es wird ein Byte zur Adressierung des Registers und ein Byte mit dem Wert gesendet, auf den das Register gesetzt werden soll.
184193
185194### Konfig auslesen
186-
187-``` pascal
195+```
188196function nrf_get_config(reg : uint8) : uint8;
189-begin
190- PORTspi := PORTspi and not(Pspi_cs); // CS setzen, ist beim Modul low-aktiv
191- spi_fast_shift(cR_REGISTER or (cREGISTER_MASK and reg)); // Controlbyte senden
192- nrf_get_config := spi_fast_shift(0); // Dummy senden und Datenbyte lesen
193- PORTspi := PORTspi or Pspi_cs; // CS löschen, ist beim Modul low-aktiv
194-end;
197+ begin
198+ PORTspi := PORTspi and not(Pspi_cs); // CS setzen, ist beim Modul low-aktiv
199+ spi_fast_shift(cR_REGISTER or (cREGISTER_MASK and reg)); // Controlbyte senden
200+ nrf_get_config := spi_fast_shift(0); // Dummy senden und Datenbyte lesen
201+ PORTspi := PORTspi or Pspi_cs; // CS löschen, ist beim Modul low-aktiv
202+ end;
195203```
196204
197-Es wird ein Byte zur Adressierung des Registers gesendet, dann wird ein Dummybyte gesendet. Der empfangene Registerinhalt wird übergeben.
205+Es wird ein Byte zur Adressierung des Registers gesendet, dann wird ein Dummybyte gesendet. Der empfangene Registerinhalt wird übergeben.
198206
199207### Register schreiben
200-
201-``` pascal
208+```
202209procedure nrf_write_register(reg : uint8; len : uint8);
203-begin
204- PORTspi := PORTspi and not(Pspi_cs); // CS setzen, ist beim Modul low-aktiv
205- spi_fast_shift(cW_REGISTER or (cREGISTER_MASK and reg)); // Controlbyte senden
206- spi_transmit_sync(nrftxbuf, len); // Daten aus Tx-Buffer senden
207- PORTspi := PORTspi or Pspi_cs; // CS löschen, ist beim Modul low-aktiv
208-end;
210+ begin
211+ PORTspi := PORTspi and not(Pspi_cs); // CS setzen, ist beim Modul low-aktiv
212+ spi_fast_shift(cW_REGISTER or (cREGISTER_MASK and reg)); // Controlbyte senden
213+ spi_transmit_sync(nrftxbuf, len); // Daten aus Tx-Buffer senden
214+ PORTspi := PORTspi or Pspi_cs; // CS löschen, ist beim Modul low-aktiv
215+ end;
209216```
210217
211-Es wird ein Controlbyte gesendet, gefolgt von den zu schreibenden Daten. Während des gesamten Vorgangs bleibt CS low.
218+Es wird ein Controlbyte gesendet, gefolgt von den zu schreibenden Daten. Während des gesamten Vorgangs bleibt CS low.
212219
213220### Register auslesen
214-
215-``` pascal
221+```
216222procedure nrf_read_register(reg : uint8; len : uint8);
217-begin
218- PORTspi := PORTspi and not(Pspi_cs); // CS setzen, ist beim Modul low-aktiv
219- spi_fast_shift(cR_REGISTER or (cREGISTER_MASK and reg)); // Controlbyte senden
220- spi_transfer_sync(nrftxbuf, nrfrxbuf, len); // Daten in Rx-Buffer lesen, Tx-Buffer ist Dummy
221- PORTspi := PORTspi or Pspi_cs; // CS löschen, ist beim Modul low-aktiv
222-end;
223+ begin
224+ PORTspi := PORTspi and not(Pspi_cs); // CS setzen, ist beim Modul low-aktiv
225+ spi_fast_shift(cR_REGISTER or (cREGISTER_MASK and reg)); // Controlbyte senden
226+ spi_transfer_sync(nrftxbuf, nrfrxbuf, len); // Daten in Rx-Buffer lesen, Tx-Buffer ist Dummy
227+ PORTspi := PORTspi or Pspi_cs; // CS löschen, ist beim Modul low-aktiv
228+ end;
223229```
224230
225-Es wird ein Controlbyte gesendet, gefolgt von Dummydaten. Die empfangenen Daten stehen im Rx-Buffer.
231+Es wird ein Controlbyte gesendet, gefolgt von Dummydaten. Die empfangenen Daten stehen im Rx-Buffer.
226232
227-Eine umfangreiche Anleitung für die nRF24L01+ Funkmodule folgt demnächst.
233+Eine umfangreiche Anleitung für die nRF24L01+ Funkmodule folgt demnächst.
228234
229235## Siehe auch
230236
231-- Übersichtseite [[AVR Embedded Tutorial/de|AVR Embedded Tutorial]]
237+ * Übersichtseite [[AVR Embedded Tutorial/de|AVR Embedded Tutorial]]
232238
233239---
234-*From the Free Pascal wiki, page "AVR Embedded Tutorial - SPI/de", as it stood on 2020-03-06 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).*
240+*From the Free Pascal wiki, page "AVR Embedded Tutorial - SPI/de", as the Internet Archive kept it on 2022-12-06. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).*

Back to history