Porterweiterung über 74HC595 (Ausgang)

[Le H. (beks)]

Hallo,

ich versuche mich gerade mit meinem ersten Schieberegister.

Habe mir dazu den Artikel im Tutorial durchgelesen (Porterweiterung über 
74HC595 (Ausgang)).

Im Anhang habe ich erstmal meine Anschaltung des Schieberegisters 
skizziert. Habe mich weitestgehend am Datenblatt und Tutorial versucht 
zu orientieren.

Als MC kommt ein ATMEGA8 zum Einsatz. Der Quellcode lässt sich ohne 
Schwierigkeiten kompilieren. Ich habe an jeden Ausgang eine LED 
angeschlossen, damit ich ein gesetztes Bit sehen kann.

Da ich erstmal nur Bit 1 setzen möchte habe ich den Code des Main-file 
etwas abgeändert.

  com74hc595_init();

      while(1)
      {
        com74hc595_setBit(1);

      }

Leider tut sich bislang überhaupt nichts. Habe ich eventuell schon einen 
Schaltungsfehler in der Ansteuerung des 74HC595?

[Thomas E. (thomase)]

Le Ha schrieb:
> com74hc595_init();
> com74hc595_setBit(1);

Und was macht das?

Le Ha schrieb:
> Leider tut sich bislang überhaupt nichts. Habe ich eventuell schon einen
> Schaltungsfehler in der Ansteuerung des 74HC595?

Offensichtlich nicht.

Ganz nebenbei: Bei Leitungskreuzungen zeichnet man weder Tunnel noch 
Brücken, sondern kreuzt einfach die Leitungen. Dort, wo Verbindungen 
bestehen sollen, setzt man dicke Punkte.


mfg.

[Le H. (beks)]

Hallo Thomas,

ich habe den Quellcode aus dem Tutorial entnommen.

https://www.mikrocontroller.net/articles/Porterweiterungen#Porterweiterung_.C3.BCber_74HC595_.28Ausgang.29_2

com74hc595.h

 
* com74hc595.h
 *
 *  Created on: 18.05.2015
 *      Author: ericjahn
 */
#ifndef _COM74HC595_H_
#define _COM74HC595_H_

// Anzahl der über Software-SPI anzusteuernde 74HC595 Bausteine
#define COM74HC595_SIZE 1

// Anzahl der Bits über alle Bausteine
#define COM74HC595_BYTES COM74HC595_SIZE * 8

// PORT am Mikrokontroller über den der Software SPI erfolgen soll
#define PORT_com74hc595         PORTB
#define PORT_SER     PB0    // 74HC595 PIN 14
#define PORT_SCK     PB1    // 74HC595 PIN 11
#define PORT_RCK     PB2    // 74HC595 PIN 12
#define PORT_OE     PB3    // 74HC595 PIN 13

#define DDR_com74hc595          DDRB
#define DDR_SER     DDB0          // 74HC595 PIN 14
#define DDR_SCK     DDB1          // 74HC595 PIN 11
#define DDR_RCK     DDB2          // 74HC595 PIN 12
#define DDR_OE       DDB3          // 74HC595 PIN 13

/*
Falls eine Steuerung über /OE PIN 13 des 74HC595 gewünscht ist,
muss PIN 13 per Pullup Widerstand gesetzt werden, dass sorgt
dafür, dass der 74HC595 nach einem Reset in einem definierten
Zustand gesetzt werden kann.
Der 74HC595 wird in der Initialisierungsroutine mit 0x00 initialisiert.
Dadurch, dass /OE über den Pullup-Widerstand auf HIGH gezogen wurde,
befindet sich der 74HC595 im Tristate-Modus. Wird jetzt /OE auf LOW
gezogen, steht der gesetzte Zustand an den Ports an.
*/
#define WITH_OE

// globales Array zur Speicherung der Bitmuster
extern unsigned char com74hc595[];

// Initialisierung der Ports im Mikrocontroller
extern void com74hc595_init(void);

// Ausgabe der Bitmuster an die 74HC595
extern void com74hc595_out(void);

// setzen eines einzelnen Bits innerhalb des Arrays
extern void com74hc595_setBit( unsigned char BitNumber );

// zurücksetzen eines einzelnen Bits innerhalb des Arrays
extern void com74hc595_unsetBit( unsigned char BitNumber );

// setzen eines ganzen Ports
extern void com74hc595_setPort( unsigned char Port, unsigned char Bits );

// zurücksetzen eines ganzen Ports
extern void com74hc595_unsetPort( unsigned char Port );

// setzt alle Bits auf logisch 1
extern void com74hc595_setall(void);

// setzt alle Bits auf logisch 0
extern void com74hc595_unsetall(void);

#endif /* _COM74HC595_H_ */

com74hc595.c

 
#include <avr/io.h>
#include <stdlib.h>
#include "com74hc595.h"

// Array fuer die Daten
unsigned char com74hc595[ COM74HC595_SIZE ];

void com74hc595_setBit( unsigned char BitNumber)
{
  unsigned char Port = BitNumber >> 3;
  unsigned char Bit = BitNumber & 7;
  com74hc595[ Port ] |= (1 << ( Bit ) );
}

void com74hc595_unsetBit( unsigned char BitNumber)
{
  unsigned char Port = BitNumber >> 3;
  unsigned char Bit = BitNumber & 7;
  com74hc595[ Port ] &= ~(1 << ( Bit ) );
}

void Com74hc595_setall(void)
{
  for ( int i = 0; i < COM74HC595_BYTES; i++ )
  {
    com74hc595_setBit( i );
  }
}

void com74hc595_unsetall(void)
{
  for ( int i = 0; i < COM74HC595_BYTES; i++ )
  {
    com74hc595_unsetBit( i );
  }
}

void com74hc595_setPort( unsigned char Port, unsigned char Bits )
{
  com74hc595[ Port ] = Bits;
}

void com74hc595_unsetPort( unsigned char Port )
{
  com74hc595[ Port ] = 0x00;
}


void com74hc595_init()
{
        /* Verwendete Ports auf OUT */
  DDR_com74hc595 |= ( 1 << DDR_SER);
  DDR_com74hc595 |= ( 1 << DDR_SCK);
  DDR_com74hc595 |= ( 1 << DDR_RCK);

#ifdef WITH_OE
  DDR_com74hc595 |= ( 1 << DDR_OE);
#endif

        /* SER auf definierten Level LOW */
  PORT_com74hc595 &= ~(1<<PORT_SER);



        /* SCR und RCK auf definierten Level HIGH */
  PORT_com74hc595 |= (1<<PORT_SCK);
  PORT_com74hc595 |= (1<<PORT_RCK);

#ifdef WITH_OE
  PORT_com74hc595 |= (1<<PORT_OE);
#endif

  com74hc595_unsetall();
  com74hc595_out();

#ifdef WITH_OE
  PORT_com74hc595 &= ~(1<<PORT_OE);
#endif
}

void com74hc595_out()
{
    unsigned char anz = COM74HC595_SIZE;
    unsigned char* serp = com74hc595 + COM74HC595_SIZE;

    do
    {
        unsigned char bits;
        unsigned char data = *--serp;

        /* 8 Bits pro Byte rausschieben */
        for (bits = 8; bits > 0; bits--)
        {
      PORT_com74hc595 &= ~(1<<PORT_SER);
            if (data & 0x80)
            {
    PORT_com74hc595 |= (1<<PORT_SER);
            };

            data <<= 1;
            /* Strobe an SCK schiebt Daten im Gaensemarsch */
            /* um 1 Position weiter durch alle Schieberegister */
      PORT_com74hc595 &= ~(1<<PORT_SCK);
      PORT_com74hc595 |= (1<<PORT_SCK);
        }
    }
    while (--anz > 0);

    /* Strobe an RCK bringt die Daten von den Schieberegistern in die Latches */
    PORT_com74hc595 &= ~(1<<PORT_RCK);
    PORT_com74hc595 |= (1<<PORT_RCK);
}

test.c

#include <util/delay.h>
#include <avr/io.h>
#include "com74hc595.h"
int main (void) {

  com74hc595_init();
      while(1)
      {
        com74hc595_setBit(1);

      }
 return 0;
}

[Peter C. (peter_c49)]

aufruf von com74hc595_out() fehlt.

[Codedurchwühler (Gast)]

void com74hc595_setBit( unsigned char BitNumber)
{
  unsigned char Port = BitNumber >> 3;   // <------- !!
  unsigned char Bit = BitNumber & 7;
  com74hc595[ Port ] |= (1 << ( Bit ) );
}

In der markierten Zeile gibt es einen unsinnigen Shift.
Zumindest wenn man eine Bitnummer 0..7 an die Funktion übergibt.

Da muss man wohl nochmal drüber nachdenken.

[Le H. (beks)]

Danke Peter! Das war es und weiterhin hat sich genau bei Bit 1 leider 
eine defekte LED eingeschlichen. Alle anderen LED´s haben sich nämlich 
ansteuern lassen.

Lässt sich das Schieberegister eigentlich auch über SPI des ATMEGA 
ansteuern? Wäre der Quellcode dann einfacher bzw. weniger in Summe?

[Thomas E. (thomase)]

Le Ha schrieb:
> ich habe den Quellcode aus dem Tutorial entnommen.

Na gut. Aber das Werk tu ich mir jetzt nicht an.

#define PORT595 PORTB
#define DATA 0
#define SHIFT 1
#define LATCH 2

void Set595(unsigned char BitMuster)
{
   unsigned char mask = 0x80;

   while(mask)
   {
      if(BitMuster & mask) PORT595 |= (1 << DATA); else PORT595 &= ~(1 << DATA);
      PORT595 ^= (1 << SHIFT);
      PORT595 ^= (1 << SHIFT);
      mask >>= 1;
   }

   PORT595 ^= (1 << LATCH);
   PORT595 ^= (1 << LATCH);
}

mfg.

[Le H. (beks)]

Hallo Thomas,

der Code sieht auf jeden Fall erstmal übersichtlicher aus. Habe gerade 
versucht ihn zu verstehen. So ganz klappt das noch nicht und leider 
läuft es bei mir auch nicht. Kannst du mit kurzen Kommentaren oder einer 
kleinen Erklärung mir etwas helfen.

Warum hast du die mask auf 0x80 gesetzt?

In mask werden solange die bits rechts verschoben bis die if Bedingungen 
erfüllt sind. Dann lege ich an den Dateneingang das High Signal an, 
welches dann in das Schieberegister übernommen werden soll. Dazu muss 
meines Wissen dann aber an SHIFT auch ein High Pegel anliegen.

#include <util/delay.h>
#include <avr/io.h>

#define PORT595 PORTB
#define DATA 0
#define SHIFT 1
#define LATCH 2

void Set595(unsigned char BitMuster)
{
   unsigned char mask = 0x80;  //0b1000 0000

   while(mask)
   {                      //bitMuster = 0b0000 0001
      if(BitMuster & mask)  //0b0000 0000 -> false
        PORT595 |= (1 << DATA); 
      else 
        PORT595 &= ~(1 << DATA); // B0 = Low
          PORT595 ^= (1 << SHIFT); 
          PORT595 ^= (1 << SHIFT);
      mask >>= 1; //0b0100 0000
   }

   PORT595 ^= (1 << LATCH);
   PORT595 ^= (1 << LATCH);
}

int main (void) {
      while(1)
      {
        Set595(0b00000001);
      }
 return 0;
}

[Thomas E. (thomase)]

Le Ha schrieb:
> Warum hast du die mask auf 0x80 gesetzt?

0x80 = 0b1000 0000

Damit wird Bit7 zuerst rausgeschoben. Nach jedem Schieben wird das 
mask-Bit um 1 nach rechts geschoben und fällt zum Schluss "hinten raus". 
Dann ist die Bedingung 'while(mask)' nicht mehr erfüllt und das 
Geschiebe ist beendet. Somit landet das erste rausgeschobene 
Bit(Bit7)dann, nach 8x schieben, auf D7 am Schieberegister und die 
anderen 7 Bits reihen sich entsprechend ein.

Le Ha schrieb:
> Dazu muss
> meines Wissen dann aber an SHIFT auch ein High Pegel anliegen.

Es muss ein Taktimpuls erzeugt werden. Tick-Tack. 0 - 1 oder 1 - 0. je 
nachdem wie dieser Pegel vorher war.

Dazu wird der Portpin 2x invertiert, auf neudeutsch getoggelt:

> PORT595 ^= (1 << SHIFT);
> PORT595 ^= (1 << SHIFT);

Genau wie am Ende der Latch-Up, der die Bits vom Schieberegister auf den 
Ausgang schaufelt.

Le Ha schrieb:
> So ganz klappt das noch nicht und leider
> läuft es bei mir auch nicht.

Hast du die 3 Portpins auf Ausgang gesetzt?

mfg.

[Le H. (beks)]

Thomas Eckmann schrieb:
> Hast du die 3 Portpins auf Ausgang gesetzt?

Das war es. Hatte ich vorher ausersehen mit auskommentiert.

Danke für die sonst gute Erklärung. Habe jetzt mal ein kleines Lauflicht 
damit gebastelt.

/*
 * test.c
 *
 *  Created on: 14.05.2015
 *      Author: ericjahn
 */
#include <util/delay.h>
#include <avr/io.h>
#include <stdint.h>

#define PORT595 PORTB
#define DATA 0
#define SHIFT 1
#define LATCH 2

void Set595(unsigned char BitMuster)
{
   unsigned char mask = 0x80;  //0b1000 0000

   while(mask)
   {  //bitMuster = 0b0000 0001
      if(BitMuster & mask)  //Ist in BitMuster das Bit mask gesetzt (mask)?
        PORT595 |= (1 << DATA); // das mask Bit in Bitmuster ist gesetzt, dann DATA = true
      else
        PORT595 &= ~(1 << DATA);//das mask Bit in Bitmuster ist nicht gesetzt, dann DATA = false

          PORT595 ^= (1 << SHIFT); //SHIFT invertieren; Flanke erzeugen um DATA Bit ins Schieberegister zu schieben
          PORT595 ^= (1 << SHIFT); //SHIFT invertieren
      mask >>= 1; //mask Bit rechtsschieben
   }

   PORT595 ^= (1 << LATCH); //LATCH invertieren; Flanke erzeugen um Schieberegister an Ausgänge zu geben
   PORT595 ^= (1 << LATCH); //LATCH invertieren
}

int main (void) {
  unsigned char Bitmask = 0b00000000;

  DDRB  = 0xff;
  while(1)
  {
    Bitmask = 0b10000000;
      for (int i=0; i<14; i++)
      {
      Set595(Bitmask);
      _delay_ms(100);
      if (i<7)
        Bitmask>>=1;
      if (i>=7)
        Bitmask<<=1;
      }
  }
 return 0;
}

[neeDanke (Gast)]

Le Ha schrieb:
> Danke für die sonst gute Erklärung. Habe jetzt mal ein kleines Lauflicht
> damit gebastelt.

Ich zB will mir das gar nicht näher ansehen. Ich weiß nicht, wie das 
verschaltet ist, weiß nicht wie das Licht läuft. Der Inhalt und Format 
vom Dateianhang ist auch unbekannt.

Das müßte ich mir alles mühsam aus dem Code zusammereimen. Aus 
Kommentaren geht es nicht hervor. Nein danke. Hättest dir den Post 
sparen können bis auf die Bekanntgabe des entdeckten Fehlers :(

[Le H. (beks)]

neeDanke schrieb:
> Das müßte ich mir alles mühsam aus dem Code zusammereimen. Aus
> Kommentaren geht es nicht hervor. Nein danke. Hättest dir den Post
> sparen können bis auf die Bekanntgabe des entdeckten Fehlers :(

Danke für deine Bemühungen.
Wie kommst du darauf das ich einen Fehler bekanntgebe in meinem Post?

Es läuft doch bereits schon :)

Die Datei Lauflicht ist eine JPG. Das Dateiende wird nur nicht mit 
angezeigt. Die Kommentare sind nur für mich zum Verständnis. Damit habe 
ich die sehr gute Erklärung von Thomas für seinen Code verständlich 
gemacht für mich.