Porterweiterung Atmega8 mit 74HC164

[Peter B. (shaphard)]

Hallo,

ich bin neu in der Welt der Mikrocontroller und habe eine Frage

ich habe das AVR MK2 Board mit einem Atmga8 ich benötige mehr Eingänge 
und habe mir hierfür zwei 74HC165 kaskadiert. Schaltplan siehe 
angehängtes Bild.

ich Programmiere in C leider habe ich ich nur eine Assembler Code finden 
können. Kann mir evtl. jemand den Code in C übersetzen? Wäre echt super.
Schon mal Danke im voraus.

Hier der Code:

; Porterweiterung für Eingänge mit Schieberegister 74xx165
; Ansteuerung per Software
 
.include "m8def.inc"
 
.def temp1 = r16
.def temp2 = r17
.def temp3 = r18
 
; Pins anpassen, frei wählbar
 
.equ SCHIEBE_DDR  = DDRB
.equ SCHIEBE_PORT = PORTB
.equ SCHIEBE_PIN  = PINB
.equ CLK          = PB3
.equ PL           = PB1
.equ DIN          = PB2
 
;-----------------------------------------------------------------------------
;
; Datensegment im RAM
;
;-----------------------------------------------------------------------------
 
.dseg
.org 0x60
Daten:      .byte 2             ; Speicherplatz für Eingangsdaten
 
;-----------------------------------------------------------------------------
;
; Programmsegment im FLASH
;
;-----------------------------------------------------------------------------
.cseg
    ldi     temp1, LOW(RAMEND)  ; Stackpointer initialisieren
    out     SPL, temp1
    ldi     temp1, HIGH(RAMEND)
    out     SPH, temp1
 
; CLK und PL als Ausgänge schalten
 
    ldi     temp1, (1<<clk) | (1<<pl)
    out     SCHIEBE_DDR, temp1
 
    sbi     schiebe_port, clk   ; Takt im Ruhezustand immer auf 1
                                ; komische Schaltung im 74xx165
 
; Zwei Bytes einlesen
 
    ldi     ZL,low(Daten)
    ldi     ZH,high(Daten)
    ldi     temp1,2
    rcall   schiebe_eingang
 
loop:
    rjmp    loop
 
;-----------------------------------------------------------------------------
;
; N Bytes seriell einlesen
;
; temp1 : N, Anzahl der Bytes
; Z     : Zeiger auf einen Datenbereich im SRAM
;-----------------------------------------------------------------------------
 
schiebe_eingang:
    push    temp2               ; Register sichern
    push    temp3
 
    cbi     schiebe_port, pl    ; Daten parallel laden
    sbi     schiebe_port, pl
 
schiebe_eingang_byte_schleife:
 
    ldi     temp3, 8            ; Bitzähler
schiebe_eingang_bit_schleife:
    lsl     temp2               ; Daten weiterschieben
 
; das IO Bit Din in das niederwerigste Bit von temp2 kopieren
 
    sbic    schiebe_pin, din    ; wenn Null, nächsten Befehl überspringen
    ori     temp2,1             ; nein, Bit setzen
 
    cbi     SCHIEBE_PORT, CLK   ; Taktausgang auf 0
    sbi     SCHIEBE_PORT, CLK   ; und wieder zurück auf 1, dabei Daten schieben 
 
    dec     temp3               ; Bitzähler um eins verringern
    brne    schiebe_eingang_bit_schleife ;wenn noch keine 8 Bits ausgegeben, nochmal
 
    st      z+,temp2            ; Datenbyte speichern
    dec     temp1               ; Anzahl Bytes um eins verringern
    brne    schiebe_eingang_byte_schleife   ; wenn noch mehr Bytes zu lesen sind
 
    pop     temp3
    pop     temp2
    ret

[Werner (Gast)]

Peter Bauer schrieb:
> ich Programmiere in C leider habe ich ich nur eine Assembler Code finden
> können.

cbi - Clear Bit
sbi - Set Bit
ori - bitweises oder
u.s.w.

Wenn du C kannst sollte das kein Problem sein. Die Befehlsbeschreibungen 
stehen in Kurzform alle im Datenblatt im Anschnitt "Instruction Set 
Summary"

[Peter B. (shaphard)]

so hab mal das C-Programm geschrieben, lässt sich auch ohne Fehler 
übersetzen, funktioniert aber leider nicht.
Jemand ne Idee??

nach dem Durchgang sollte das Eingansregister ja eingelesen sein und im 
Array eingang_mux stehen macht es aber nicht.

int main(void)
{
  DDRB |= ((1<<DDB0) | (1<<DDB1));  // Port B Pin 0 und 1 als Ausgang
  PORTB &= ~((1<<DDB0) | (1<<DDB1));  // auf 0 setzen
  DDRB &= ~((1<<DDB2));        // Port B Pin 2 als Eingang
  PORTB &= ~(1<<DDB2);        // Pullup aus
  
  int eingang_mux[16];

while(1) 
{
    
HC165_Lesen(eingang_mux);


} // End While 
} // End Main

void HC165_Lesen()
{
  int werte[16]={0};  // Array mit Eingangsdaten initalisiert mit 0
  int i;        // Zählvariable
  // PB0 = PL
  // PB1 = CLK
  // PB2 = Q7 (DIN)
  PORTB |= (1<<PB1);  // CLK auf 1 setzen
  
  PORTB &= ~(1<<PB0);  // PL = 0;
  PORTB |= (1<<PB0);  // PL = 1;
  
  for (i=0;i<16;i++)
  {
  if(PINB & (1<<PB2)) // Eingang Q7 ist 1
  {
      werte[i]=1;  // dann schreibe 1 ins Register
    
  }    
    else        // sonst
    {
     werte[i]=0;  // schreibe 0 ins register
    }
    
    // Eingansregister eins weiter takten
    
  PORTB &= ~(1<<PB1);  // CLK = 0;
  PORTB |= (1<<PB1);  // CLK = 1;
  }
  return werte[16]; // Eingangsregister an Hauptprogramm übergeben
}

[Dauergast (Gast)]

Peter Bauer schrieb:
> nach dem Durchgang sollte das Eingansregister ja eingelesen sein und im
> Array eingang_mux stehen macht es aber nicht.

Warum sollte es denn in eingang_mux stehen?
Du möchtest das sicher gern, aber dazu muß es auch jemand reinschreiben.

HC165_Lesen schreibt die eingelesenen Werte in die lokale Variable 
"werte", und zwar index 0..15. Dann wird der Inhalt von werte[16] 
zurückgegeben, der gar nicht existiert. Ist aber egal, denn der 
Rückgabewert wird ja sowieso nicht benutzt.

[amateur (Gast)]

Da ist was faul im Staate Dänemark!

void HC165_Lesen()
mit Aufruf: HC165_Lesen(eingang_mux);
und mit:    return werte[16];

[Peter B. (shaphard)]

Dauergast schrieb:
> Warum sollte es denn in eingang_mux stehen?
> Du möchtest das sicher gern, aber dazu muß es auch jemand reinschreiben.

ich gebe mit Werte[16] das ganze Array zum Hauptprogramm zurück und 
schreibe es dort in das Array eingang_mux

ich kann auch einfach nur

return werte;

schreiben, ändert aber nichts


hier nochmal der Code habe noch einen Ausgang der mit eingang_mux 
gesetzt wird ergänzt

@Dauergast: wenn du eine Idee hast wies richtig geht wäre es schön wenn 
du meinen code an denn entsprechenden stellen korrigierst, dann kann ich 
auch verstehen was ich falsch mache.

int main(void)
{
  DDRB |= ((1<<DDB0) | (1<<DDB1) | (1<<DDB3) | (1<<DDB4));  // Port B 0, 1, 3 als Ausgang
  PORTB &= ~((1<<DDB0) | (1<<DDB1) | (1<<DDB3) | (1<<DDB4));  // auf 0 setzen
  DDRB &= ~((1<<DDB2));        // Port B 2 als Eingang
  PORTB &= ~(1<<DDB2);        // Pullup aus
  
  int eingang_mux[16];
while(1) 
{
    
HC165_Lesen(eingang_mux);

if(eingang_mux[0]=1) // wenn 1 dann
{
  PORTB |= (1<<DDB3); // Ausgang auf 1 setzen
}
else          // sonst
{
  //DDRB |= (1<<DDB3);
  PORTB &= ~(1<<DDB3); // Ausgang auf 0 setzen
}
} // End While 
} // End Main

int HC165_Lesen()
{
  int werte[16]={0};  // Array mit Eingangsdaten initalisiert mit 0
  int i;        // Zählvariable
  // PB0 = PL
  // PB1 = CLK
  // PB2 = Q7 (DIN)
  PORTB |= (1<<PB1);  // CLK auf 1 setzen
  
  PORTB &= ~(1<<PB0);  // PL = 0;
  PORTB |= (1<<PB0);  // PL = 1;
  
  for (i=0;i<16;i++)
  {
  if(PINB & (1<<PB2)) // Eingang Q7 ist 1
  {
      werte[i]=1;  // dann schreibe 1 ins Register
  }    
    else        // sonst
    {
     werte[i]=0;  // schreibe 0 ins register
    }
    
    // Eingansregister eins weiter takten
    
  PORTB &= ~(1<<PB1);  // CLK = 0;
  PORTB |= (1<<PB1);  // CLK = 1;
  }
  return werte; // Eingangsregister an Hauptprogramm übergeben
}

[Dauergast (Gast)]

Du kannst kein Array zurückgeben, höchstens eine Pointer darauf. Ein 
Pointer auf Dein lokales "werte" ist allerdings nach Rückkehr aus der 
Funktion HC165_lesen ungültig, da "werte" nicht mehr existiert.

Du übergibst also eingang_mux als Parameter, und benutzt das für Deine 
Ergebnisse:

void HC165_Lesen(int *werte);

int main(void)
{
  int eingang_mux[16];

  DDRB |= ((1<<DDB0) | (1<<DDB1) | (1<<DDB3) | (1<<DDB4));  // Port B 0, 1, 3 als Ausgang
  PORTB &= ~((1<<DDB0) | (1<<DDB1) | (1<<DDB3) | (1<<DDB4));  // auf 0 setzen
  DDRB &= ~((1<<DDB2));        // Port B 2 als Eingang
  PORTB &= ~(1<<DDB2);        // Pullup aus

  while(1)
  {
    HC165_Lesen(eingang_mux);
    
    if(eingang_mux[0]=1) // wenn 1 dann
    {
      PORTB |= (1<<DDB3); // Ausgang auf 1 setzen
    }
    else          // sonst
    {
      //DDRB |= (1<<DDB3);
      PORTB &= ~(1<<DDB3); // Ausgang auf 0 setzen
    }
  } // End While
} // End Main


void HC165_Lesen(int *werte)
{
  int i;        // Zählvariable
  // PB0 = PL
  // PB1 = CLK
  // PB2 = Q7 (DIN)
  PORTB |= (1<<PB1);  // CLK auf 1 setzen

  PORTB &= ~(1<<PB0);  // PL = 0;
  PORTB |= (1<<PB0);  // PL = 1;

  for (i=0;i<16;i++)
  {
    if(PINB & (1<<PB2)) // Eingang Q7 ist 1
    {
      werte[i]=1;  // dann schreibe 1 ins Register
    }
    else        // sonst
    {
      werte[i]=0;  // schreibe 0 ins register
    }

    // Eingansregister eins weiter takten
    PORTB &= ~(1<<PB1);  // CLK = 0;
    PORTB |= (1<<PB1);  // CLK = 1;
  }
}

[EGS_TI (Gast)]

Peter Bauer schrieb:
> Dauergast schrieb:
>> Warum sollte es denn in eingang_mux stehen?
>> Du möchtest das sicher gern, aber dazu muß es auch jemand reinschreiben.
>
> ich gebe mit Werte[16] das ganze Array zum Hauptprogramm zurück und
> schreibe es dort in das Array eingang_mux

Wie kommst du denn da drauf??????

[Karl H. (kbuchegg)]

Dauergast schrieb:

nitpicking

>     if(eingang_mux[0]=1) // wenn 1 dann

     if(eingang_mux[0] == 1) // wenn 1 dann

Nicht dass der TO in seinem nicht vorhandenem C-Buch auch danach noch 
stundenlang sucht.

[Peter D. (peda)]

Peter Bauer schrieb:
> leider habe ich ich nur eine Assembler Code finden
> können.

Dann hast Du aber sehr schlecht gesucht.
Es gibt haufenweise SPI-Code in C.

Peter Bauer schrieb:
> int werte[16]={0};  // Array mit Eingangsdaten initalisiert mit 0

Ja, man kann die Hose auch mit der Kneifzange anziehen. Warum diese 
16-fache Verschwendung von SRAM?
Ein 16 Bit Wert (unsigned int) reicht völlig. Es passen ganze 16 Bit 
hinein, wer hätte das gedacht.

[Peter B. (shaphard)]

Danke für die Antworten, ich werde das heute ausprobieren sobald ich von 
der Arbeit Zuhause bin.


@Peter Dannegger
wollte das ohne SPI machen wie im AVR Tutorial beschrieben (unters 
drittel):
http://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister

Im Tutorial ist ja leider nur Assembler Code dabei was ich leider gar 
nicht kann.
Falls du aber noch irgendwo eine bessern C-Code gesehen hast kannst du 
Ihn gerne Posten, habe leider bisher nichts funktionierendes gefunden.

mit dem unsigned int hast du natürlich recht.

[Karl H. (kbuchegg)]

Peter Bauer schrieb:
> Danke für die Antworten, ich werde das heute ausprobieren sobald ich von
> der Arbeit Zuhause bin.
>
>
> @Peter Dannegger
> wollte das ohne SPI machen wie im AVR Tutorial beschrieben (unters
> drittel):
> http://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister
>
> Im Tutorial ist ja leider nur Assembler Code dabei was ich leider gar
> nicht kann.

Wichtig ist das Prinzip - und das geht aus dem ganzen beschriebenen 
Vorgeplänkel eindeutig hervor.

> Falls du aber noch irgendwo eine bessern C-Code gesehen hast kannst du
> Ihn gerne Posten, habe leider bisher nichts funktionierendes gefunden.

Du musst endlich einsehen, dass eine Programmiersprache nicht einfach 
nur irgendwie schmückendes Beiwerk ist, sondern dass man das LERNEN 
muss. Es hat keinen Sinn sich über die Feinheiten einer SPI 
Programmierung zu unterhalten, wenn du das dafür notwendige C nicht 
beherrscht.

Wer malen anfangen will, muss lernen Farben zu mischen und Pinsel 
auszuwaschen. Solange er das nicht kann, ist es sinnlos, sich über 
Farbkomposition und Bildaufbau mit ihm zu unterhalten. Wir können 
stundenlang die alten Meister studieren und wie sie ihre Bilder 
komponiert haben und wo sie welchen Trick eingesetzt haben, wenn der 
Lehrling dann an der ganz banalen Frage "wie mische ich meine Farbe, 
welchen Pinsel nehme ich und wie kriege ich ihn wieder sauber" 
scheitert. Mit dem einen Unterschied, dass man diese Malgrundlagen in 
einer Stunde lernen kann, eine Programmiersprache zu lernen aber Monate 
dauert. Ok, den Teil, den man hier braucht, hat man in ein paar 
Tagen/Wochen intus. Aber alleine die Formulierung "ein Array 
zurückgeben" zeigt schon, dass da etwas wesentliches im Grundverständnis 
fehlt. Und da geht es nicht um SPI bzw. wie man das geschickt anstellt. 
Denn bei SPI geht es im Grunde nur um zeitlich richtiges Wackeln mit 
µC-Pins und entsprechendes Setzen bzw. Abfragen von Werten. Und genau 
das ist hier NICHT dein eigentliches Problem. Dein eigentliches Problem, 
wie man es aus der ganzen Art der Fragestellung ablesen kann, besteht 
darin, dass dein C generell noch viel zu schwach ist. Die 
Schwierigkeiten mit SPI sind nur eine logische Folgeerscheinung davon.

Und ich möchte hinzufügen: Du bist damit nicht alleine, wie sich hier im 
Forum jeden Tag zeigt. Es tauchen immer wieder Leute auf, denen man im 
Grunde sagen muss: Sorry, aber deine ganze Ausdrucksweise, dein genazer 
Code zeigt, dass du mit deinen Kentnissen und mit deinem Wissen über die 
Programmiersprache noch nicht soweit bist, ein reales Projekt in Angriff 
zu nehmen. Wer einen Hammer nicht richtig rum in die Hand nehmen kann, 
sollte nicht (noch nicht) anfangen, ein Haus bauen zu wollen, sondern 
erst mal 20 Übrungsnägel in ein Stück Übungsholz einschlagen.

[Peter D. (peda)]

#include <avr/io.h>


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

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


#define SPI_CLK    SBIT( PORTB, 0 )  // clock
#define SPI_CLK_DDR  SBIT( DDRB,  0 )
#define SPI_MOSI  SBIT( PORTB, 1 )  // data out
#define SPI_MOSI_DDR  SBIT( DDRB,  1 )
#define  SPI_MISO_PIN  SBIT( PINB,  2 )  // data in


uint8_t shift_io( uint8_t b )  // send / receive byte
{
  uint8_t i;

  SPI_CLK_DDR = 1;    // set as output
  SPI_MOSI_DDR = 1;

  for( i = 8; i; i-- ){    // 8 bits
    SPI_MOSI = 0;
    if( b & 0x80 )    // high bit first
      SPI_MOSI = 1;
    b <<= 1;
    SPI_CLK = 1;
    if( SPI_MISO_PIN )
      b++;
    SPI_CLK = 0;
  }
  return b;
}

[Peter B. (shaphard)]

Danke Peter für den Code
ich habe noch ein Frage dazu. Wie Frage ich jetzt das bit der Struktur 
ab?

normalerweise ja Strukturvariable.Struckturelement aber was ist hier 
dann die Strukturvariable?

z.B.

if(???.b7==1) // wenn 1 dann
{
  PORTB |= (1<<PB3); // Ausgang auf 1 setzen
}
else          // sonst
{
  PORTB &= ~(1<<PB3); // Ausgang auf 0 setzen
}

Danke für die Geduld mit mir...

[Peter D. (peda)]

Du hast doch keine Struktur, sondern einen 16Bit-Wert.
Und da fragst Du eben ein Bit ab, indem Du alle anderen maskierst.
Genau, wie Du einen Portpin abfragst.