Serielle Daten bitweise in die Variable schreiben

[Sam (Gast)]

Hallo Leute,

ich versuche über eine serielle Schnittstelle, 10 Bits zu empfangenn, 
und diese in einer Variablen zu speichern. Das Ganze versuche ich halt 
"zu Fuß" zu realisieren.

Um mich direkt ein bisschen zu outen, ich bin mit Arduino 
"aufgewachsen", versuche jetzt aber nach und nach in der üblichen C 
Programmiersprache (ohne Arduino Libs) zu programmieren. Eben aus den 
Gründen, um den Code besser verstehen zu können, flexibler zu bleiben, 
um in Zukunft nicht nur an handvoll Atmel µC gebunden zu sein.

Den ersten Test habe ich so ausgeführt.

digitalWriteFast(CLK, LOW);    
digitalWriteFast(CLK, HIGH);
value |= digitalRead(DATAPIN) << 9;

...
...
...

digitalWrite(CLK, LOW);    
digitalWrite(CLK, HIGH);
value |= digitalRead(DATAPIN) << 0;

Zuerst wird einmal Clock-Cycle durchgeführt und dann der Pegel 
eingelesen und dann an der entsprechenden Bit-Stelle, in einem Integer 
abgelegt.

Es hat auch wunderbar in einer for-Schleife funktioniert.

Nun würde ich gern etwas schneller lesen, weil digitalRead/Write zum 
Einschlafen sind und da komme ich irgendwie nicht weiter.

Ich ich habe anstelle von digitalRead schon vieles mit Bitmanipulation 
ausprobiert und komme aber zu keinem brauchbaren Ergebnis. Wenn ich mir 
die Variable dann im seriellen Monitor ausgeben lasse, habe ich dort 
meistens mehr als 10 Bits.

Zwischendurch dachte ich, dass ich den µC irgendwie gehimmelt habe. Aber 
mit "digitalRead" klappt es nach wie vor, nur eben zu langsam.


Bin für jede Hilfestellung sehr dankbar :-)

[Sam (Gast)]

Achsoo, der Code stimmt so nicht ganz.

Ich habe das mal als Test mit digitalWriteFast ausprobiert, jedoch 
meckert der Compiler, bei dieser Bibliothek.

digitalWrite(CLK, LOW);    
digitalWrite(CLK, HIGH);
value |= digitalRead(DATAPIN) << 9;

...
...
...

digitalWrite(CLK, LOW);    
digitalWrite(CLK, HIGH);
value |= digitalRead(DATAPIN) << 0;

[Peter D. (peda)]

Hier ein Beispielcode zum Einlesen 2 * 74HC165 kaskadiert:

#include <avr\io.h>

struct bits {
  uint8_t b0:1, b1:1, b2:1, b3:1, b4:1, b5:1, b6:1, b7:1;
} __attribute__((__packed__));

#define SBIT(port,pin) ((*(volatile struct bits*)&port).b##pin)

#define SPI_CLK         SBIT( PORTB, 0 )        // clock
#define SPI_CLK_oe      SBIT( DDRB,  0 )
#define SPI_MISO_in     SBIT( PINB,  2 )        // input
#define HC165_LD        SBIT( PORTB, 3 )        // parallel load
#define HC165_LD_oe     SBIT( DDRB,  3 )

uint16_t read_2xhc165( void )
{
  uint8_t i;
  uint16_t b = 0;

  SPI_CLK_oe = 1;
  HC165_LD_oe = 1;
  HC165_LD = 0;
  HC165_LD = 1;

  for( i = 16; i; i-- ){
    b <<= 1;
    if( SPI_MISO_in )
      b |=1;
    SPI_CLK = 0;
    SPI_CLK = 1;
  }
  return b;
}

[Frank M. (ukw) (Moderator)]

Peter Dannegger schrieb:
> #include <avr\io.h>

Peter, auch unter Windows funktioniert der Slash in Include-Pfaden 
tadellos.

#include <avr/io.h>

ist daher portabler.

[Jürgen S. (jurs)]

Sam schrieb:
> Zwischendurch dachte ich, dass ich den µC irgendwie gehimmelt habe. Aber
> mit "digitalRead" klappt es nach wie vor, nur eben zu langsam.


Wenn Du, wie man an Deinem Beispielcode sehen kann, ein Makro für 
"digitalWriteFast" installiert hast, dürftest Du ziemlich sicher auch 
ein Makro für "digitalReadFast" installiert haben.

Wenn es mit "digitalRead" funktioniert, wäre die erste Maßnahme also, 
für eine Konstante als Datenpin das Makro "digitalReadFast" zu 
verwenden. Das beschleunigt die Dinge schon mal etwas.

Funktioniert es dann?

Wenn das immer noch nicht schnell genug ist, gehst Du mit direkter 
Registerprogrammierung dran.

Und wenn nicht die Geschwindigkeit, sondern Deine Programmlogik das 
Problem ist, dann prüfe mal, ob Du in Deinem nicht gezeigten Code die 
Variable "value" überhaupt auf Null setzt, bevor Du sie mit den 
gelesenen Werten veroderst.

 value = 0;
...
  value |= 
...
  value |= 
...
  value |=

Wenn Du die Variable nicht anfangs auf null setzt und stattdessen einen 
Zufallswert aus dem RAM abgreifst, hat sie hinterher ziemlich sicher 
mehr Bits gesetzt als Du sie mit den Veroderungen setzt.

[Sam (Gast)]

Vielen Dank für eure Antworten.

Ich glaube, ich sollte mich noch etwas tiefer in die ganzen Anweisung 
(Operanden? <<= ) einarbeiten.

@Jürgen S. ja, die digitalWriteFast Bibliothek habe ich ausprobiert.
Leider hatte ich immer eine Fehlermeldung "invalid type argument of 
'unary *'".
Ich habe mir die Bibliothek etwas genauer angeschaut und noch ein Befehl 
digitalWriteFast2 gefunden. Damit habe ich keine Fehlermeldungen und ich 
bekomme auch meine 10Bits. Was da aber genau gemacht wird, muss ich mir 
noch genauer anschauen.

Im Moment hüpfe ich noch durch die Tutorials durch.


Nochmal vielen Dank.