Probleme mit mehr als 8 Bit rausschreiben

Ich denk mal, weil spi_write (wie auch immer das definiert ist) nur 8 
Bit haben will. Einfach 2x 8 Bit schicken oder die Funktion ändern.

Ja wie oben schon geschrieben: spi_write(x) schreibt nur 8-Bit über SPI.

Möglichkeit:

1

void spi_writeBytes(unsigned int8 u8Anzahl, unsigned int8 *pu8Bytes)

2

{

3

 unsigned int8 u8Index;

4

5

 for(u8Index = 0; u8Index < u8Anzahl; u8Index++)

6

 {

7

  spi_write(*(pu8Bytes+u8Anzahl));

8

 }

9

}

Nicht getestet !

Dem chip ist es egal. Nu musst nur das Chip Select richtig setzen.

Also:

setze Chipselect;
spi_write(0xaa);
spi_write(0xaa);
lösche Chipselet;

Um welchen Baustein handelt es sich denn?

Hab das Dtaenblatt eben überflogen:
Der wird mit 16-Bit gefüttert. Die ersten 2 Bits haben dabei keine 
Funktion.

Nachtrag:

Zitat aus dem Datenblatt: "The AD5291/AD5292 shift register is 16 bits 
wide (see Figure 2). The 16-bit input word consists of two unused bits 
(set to 0),
followed by four control bits, and 10 RDAC data bits."

Aber du hast doch oben schon 16Bit geschrieben?
Wo liegt denn jetzt das Problem?

Nach wie vor:

> setze Chipselect;
> spi_write(0xaa);
> spi_write(0xaa);
> lösche Chipselet;

Du musst nur den ersten und zweiten Wert entsprechend vorbereiten, ist 
easy.
Nimm eine uint16_t variable, und setze sie auf zu übertragenden wert (10 
Bit).
Das ganze shiftest du 6 bits nach links, verORst das mit deinen 
Controlbits, und gut. Anschliessend macht du spi_writes() für das lo und 
und hi byte.

Nicht falsch verstehen, der obrige Quellcode hat mit dem AD5292 nichts 
zu tun!!!
Das ist ein ganz unabhängiges Thema!

Also so, dass zum Beispiel im Higher Byte schon ein Teil der Daten 
steht. D.h. zwei Datenbits werden schon im ersten Byte mitgesendet?
2 aussagelose Bits + 4 Steuerbits + 2 Datenbits = 1 Byte
Rest im Lower Byte?

Ja.

Puh...
Da stellt sich mir schon die nächste Frage.
Ich möchte die zehn Datenbits aber als Dezimalwert rausschreiben.
Jetzt stellt sich ja die Frage, wie kann ich den Dezimalwert in einen 
Binärwert umwandeln, sodass ich die Bits shiften kann?
Versteht Ihr was ich meine?
Wie würde so eine Realisierung aussehen?

Ja OK, aber, möchte ich zum Beispiel den Wert "126d", also 1111110b 
rausschreiben, wie realisiere ich dann das shiften? Sodass eben die zwei 
MSB schon mit dem Higher Byte gesendet werden?

...gleichzeitig sind alles zahlen hexadezimal, was anderes gibt es 
nicht!
und sie sind auch "dezimal", was anderes gibt es nicht!

ok..was damit gesagt werden soll, ist: nur die DARSTELLUNG entscheidet, 
ob bei du der AUSGABE einer Zahl ihre Binäre, Dezimale, oder 
Hexadezimale oder wasauchimmer REPRESENTATION siehst.


Aber das sind absolutes Bascis.. bevor du irgendwas mit Programmierung 
anfängst, noch dazu in C solltest du dich zumindest ein bischen 
einlesen.

uint16_t a = 126; // = 1111110b

inhalt von a : 000000001111110b

um 6 stellen shiften:

a = (a<<6); // 001111110000000b

jetzt noch die control-bits um 2 verschoben verORen

//controlbits = 0101b

a = a | (0b0101 << 2);

ergebnis:

0b001111110010100

oder anders ausgedrückt :
00111111 0010100
^hi      ^lo

huch...wenn du meinen fehler findest, hast du's verstanden ;-)

Nein warum?
Ich bin mir dessen bewusst, dass die Zahlenformate in jeglicher Form 
implementiert werden können. Hab nur gedacht, zum shiften muss man es 
vielleicht in eine Art umwandeln etc.
Dass wenn ich einen Int16 verwende die Dezimalzahl immer "16" Bit hat, 
ist mir bewusst!
Ich dachte nicht, dass mein so "einfach" shiften kann, aber DANKE für 
die Information!!

Passt irgendwie nicht ganz mit der Bitanzahl zusammen?

uint16_t a = 126; // = 1111110b

inhalt von a : 00000000001111110b

um 6 stellen shiften:

a = (a<<3); // 0000011111100000b

jetzt noch die control-bits verschieben

//controlbits = 0101b

a = a | (0b0101 << 13);

ergebnis:

0b0001010001111110

oder anders ausgedrückt :
00010100 01111110
^hi      ^lo

uint16_t a = 126; // = 1111110b

inhalt von a : 0000000001111110b

um 3 stellen shiften:

a = (a<<3); // 0000001111110000b

jetzt noch die control-bits verschieben

//controlbits = 0101b

a = a | (0b0101 << 10);

ergebnis:

0b0001011111110000b

oder anders ausgedrückt :
00010111 11110000
^hi      ^lo

Jetzt hab ich mal genau nachgezählt^^

Ja sorry sorry sorry, aber ich hab mich verzählt :-D

Stimmt, hier stellt sich die Frage warum überhaupt verschieben? Es würde 
so ganz gut klappen.
Und jetzt habe ich mir noch etwas überlegt, wozu das Ganze?
Ich kann ja ganz einfach den Higher Byte rausschreiben und die zwei MSB 
mit Null ergänzen (Gut, dann hab ich nichtmehr so viel Bit für Daten zur 
Verfügung, aber das ist mir egal!)
In das restliche Lower Byte schreibe ich meinen Wert ganz einfach als 
unsigned int8 und fertig.
Ist meine Überlegung richtig oder?


Blöd wäre es nur, würde ich die vollen 10 Bit wollen.
Denn was wäre, wenn ich eine Zahl eingebe, wo die letzten MSB 1 sind? 
Z.B.: 1000000000b = 512d.
Dann müsste ich eine Abfrage dazuprogrammieren, bei welchen Zahlen die 
MSB eins sind, und diese dann verarbeiten.
Ist aber auch irgendwie blöd oder?

Oder so gehts natürlich auch, wie du das beschrieben hast!!
Super, danke für die Hilfe! :-)

öh... ok,ich nehm alles zurück, ich hab das Datenblatt nämlich nicht 
gelesen und ging von einer anderer Reihenfolge aus.

Entschuldigung.

Das war natürlich nur eine ironische Ergänzung ;-D

Aber Spaß beiseite, danke für die Hilfe!