2x16Bit zu 1x14Bit wandeln

Über die SPI-Schnittstelle wird immer zuerst das MSB übertragen.

etwas mehr details zum DAC wären gut...
geh ich richtig in der Annahme, das sozusagen aus 4 bytes 2 integert32 
Werte gebildet werden sollen, die wiederrum die Werte für die 2 DAC 
Kanäle darstellen und auf 12bit gerundet werden!?

1

uint32 soll_kanal1;

2

uint32 soll_kanal2;

3

4

uint8 soll_both[3];

5

6

soll_both[0] = (uint8)soll_kanal1;

7

soll_both[1] = (uint8)(soll_kanal1<<8);

8

soll_both[1] &= 0xF0;

9

soll_both[1] |= (uint8)(soll_kanal2>>4);

10

soll_both[2] = (uint8)(soll_kanal2<<8);

dann hast du in soll_both 3x8bit Werte mit

[kanal_1_high][kanal_1_low,kanal_2_high][kanal_2_low]

Ich habe 2x INT_16 (jeder INT_16 enthält die 12 Bit für den AD-Wandler 
Bit 0 bis Bit 11 sind die wichtigen -->Bit 12 bis Bit 15 sind immer 0)

An den AD-Wandler übertrage ich je 3 Bytes in folgender Reihenfolge

1. Byte DAC 1 (Bit 11 bis Bit 4)
2. Byte DAC 1 (Bit 3 bis Bit 0) und DAC 2 (Bit 11 bis Bit 8)
3. Byte DAC 2 (Bit 7 bis Bit 0)

ich verwende den folgenden Wandler

http://www.linear.com/pc/downloadDocument.do?navId=H0,C1,C1155,C1005,C1156,P1217,D3168

siehe Seite 5

Ich habe es jetzt so gelöst. Muss es jedoch noch testen. Vielen Dank für 
die Hinweise:


void dac_1_und dac_2_ansteuern(unsigned int *ptr_datenpuffer)
{
   unsigned char byte_1, byte_2, byte_3;
   unsigned int dac_1, dac_2

   dac_1 = ptr_datenpuffer[1];
   dac_2 = ptr_datenpuffer[2];

   // 1. Byte = DAC 1 Bit (11 bis 4)
   byte_1 = ((unsigned char) (((unsigned int)(dac_1)) >> 4 ));

   // 2. Byte = DAC 1 (Bit 3 bis 0) und DAC 2 (Bit 11 bis 8)
   // Zuerst DAC 1 (Bit 3 bis 0) in Byte 2 schreiben
   byte_2 = ((unsigned char) (((unsigned int)(dac_1)) << 4 ));
   byte_2 |= ((unsigned char) (((unsigned int)(dac_2)) >> 8 ));

   // 3.Byte DAC 2 (Bit 7 bis 0)
   byte_3 = (unsigned char) dac_2;

}

Genau nach

 hatte ich gesucht ^^

Ich hatte so die Erfahrung gemacht das man da ein Typecast einfügen 
muss. Damit der Compiler weiß welches Bit er schieben soll.

Ich weiß auch das es unsinnig ist einen unsigned int Typecast von einem 
unsigned int zu machen. Ich werde es mal ohne den Typecast ausprobieren.

Was sagst Du denn zu meiner Datenumwandlung?

// 1. Byte = DAC 1 Bit (11 bis 4)
   byte_1 = ((unsigned char) (((unsigned int)(dac_1)) >> 4 ));


Hiermit speicher ich in Byte 1 Bit 11 bis 4 vom DAC 1. Der Wert der in 
DAC 1 steht wird dabei nicht verändert, da ich die Manipulation vom DAC 
1 NICHT im DAC 1 speicher.

Der Mikrocontroller lädt ins Alu Register die 2 Bytes aus dem SRAM 
schiebt das ganze um 4 Stellen und speichert es im SRAM in der Variablen 
"byte_1"

Danke für den Hinweis.

Und vor allem für die verinfachte Darstellung.