74HC595 ohne SPI

[Frank L. (franklink)]

Hallo,
ich benötige mal Eure Hilfe, ich versuche schon den ganzen Tag die 
Routine zur Ansteuerung eines 74HC595 ohne SPI ans laufen zu bekommen.

Im Simulator sieht es gut aus, aber technisch kommt nichts an.

Header:

/* SERiell nach PArallel (serpa) im SPI-Protokoll */
#ifndef _COM74HC595_H_
#define _COM74HC595_H_

/* 4 Bytes (32 Ports) */
#define COM74HC595_SIZE 1

#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 DDR_COM74HC595  DDRB
#define DDR_SER     DDB0  //74HC595 PIN 14
#define DDR_SCK     DDB1  //74HC595 PIN 11
#define DDR_RCK     DDB2  //74HC595 PIN 12

extern unsigned char com74hc595[];
extern void Com74hc595_out();
extern void Com74hc595_init();

#endif /* _COM74HC595_H_ */

Main:

#include <avr/io.h>
#include "Com74hc595.h"

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

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


  PORT_COM74HC595 &= ~(1<<PORT_SER);
    /* SCR und RCK auf definierten Level HIGH */
  PORT_COM74HC595 |= (1<<PORT_SCK);
  PORT_COM74HC595 |= (1<<PORT_RCK);
}

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);
}
 
int main(void)
{
    Com74hc595_init();

    com74hc595[0] = 0x1;
    com74hc595[1] = 0x1;
    com74hc595[2] = 0x1;
    com74hc595[3] = 0x1;
    com74hc595[4] = 0x0;
    com74hc595[5] = 0x0;
    com74hc595[6] = 0x0;
    com74hc595[7] = 0x0;

    Com74hc595_out();     

    while(1)
    {
    }
 
    return 0;
}

Der Ursprungscode stammt übringends von hier:

http://www.roboternetz.de/wissen/index.php/Portexpander_am_AVR#Makros.2C_Datenstrukturen.2C_Funktionen

Danke für jeden Tip.

Gruß
Frank

[Christian Z. (christianz)]

Dir ist klar, dass die Routine nur die 8 Bits aus com74hc595[0] ausgibt?

[Ekschperde (Gast)]

> #define COM74HC595_SIZE 1

> unsigned char com74hc595[ COM74HC595_SIZE ];

passt nicht zu:

>   com74hc595[0] = 0x1;
>   com74hc595[1] = 0x1;
>   com74hc595[2] = 0x1;
>   com74hc595[3] = 0x1;
>   com74hc595[4] = 0x0;
>   com74hc595[5] = 0x0;
>   com74hc595[6] = 0x0;
>   com74hc595[7] = 0x0;

Es gibt nämlich nur:

>   com74hc595[0] = 0x1;

Da steht das ganze Byte für den 595 drin.

[Frank L. (franklink)]

Danke,
das wars, wenn man sich nicht jeden Tag mit c beschäftigt, interpretiert 
man bestimmte Warnings des Compilers falsch.

Der Fehler ist entstanden durch ein Warnining, in der Zuweisung:

com74hc595[0] = 0x00000001;

korrekt muss es natürlich heißen

com74hc595[0] = 0b00000001;

dann funktionierts.

Danke
Gruß
Frank

[Andreas K. (a-k)]

Interessant. Ist nämlich exakt das gleiche.

[Christian Z. (christianz)]

Wenn

com74hc595[0] = 0x00000001;

nicht funktioniert, aber

com74hc595[0] = 0b00000001;

schon, dann ist Dein C-Compiler kaputt.

Übrigens: Die Zeilen

com74hc595[1] = 0x1;
com74hc595[2] = 0x1;
com74hc595[3] = 0x1;
com74hc595[4] = 0x0;
com74hc595[5] = 0x0;
com74hc595[6] = 0x0;
com74hc595[7] = 0x0;

haben keinen (von Dir gewünschten) Effekt.

[Frank L. (franklink)]

Hallo,

com74hc595[0] = 0x00000000;
Com74hc595_out();     
sleep();
com74hc595[0] = 0x00000001;
Com74hc595_out();     
sleep();
com74hc595[0] = 0x00000010;
Com74hc595_out();     
sleep();
com74hc595[0] = 0x00000100;
Com74hc595_out();

ist nicht das selbe wie

com74hc595[0] = 0b00000000;
Com74hc595_out();     
sleep();
com74hc595[0] = 0b00000001;
Com74hc595_out();     
sleep();
com74hc595[0] = 0b00000010;
Com74hc595_out();     
sleep();
com74hc595[0] = 0b00000100;
Com74hc595_out();

in der ersten Variante erhalte in in dieser Zeile einen Warning

com74hc595[0] = 0x00000100;

warning: large integer implicity truncated to unsigned type

Vielleicht kann mir jemand erklären warum?

Ich kann natürlich falsch liegen, aber "0x" ist doch Hex- und "0b" 
Binärschreibweise oder?

Gruß
Frank

[Joachim (Gast)]

>in der ersten Variante erhalte in in dieser Zeile einen Warning
>com74hc595[0] = 0x00000100;
>warning: large integer implicity truncated to unsigned type

Weil ein CHARacter nur 8 Bit hat, 0x00000100 aber 9.

[Bobby (Gast)]

0x100 passt nicht in ein Byte...

[Christian Z. (christianz)]

Klar. Ich habe ja nicht geschrieben, dass

com74hc595[0] = 0x00000100;

das selbe wäre wie

com74hc595[0] = 0b00000100;

sondern nur, dass 0x1 == 0b1 ist. Das eine ist eine hexadezimale 
Darstellung, das andere eine binäre (die übrigens kein Standard-C ist).

[Frank L. (franklink)]

Danke, ich dachte ich wäre blöd.

Deshalb ist der Wert 0x00000001 = 0b00000001 aber in der Verwendung mit 
dem Rest der Routine nicht korrekt.

Die Definition von com74hc595 ist unsigned char com74hc595 also maximal 
1 Byte.

Aber mal eine andere Frage, wie setzte ich elegant ein Bit in einem 
unsigned char bzw. nehme das Bit wieder raus.

Gruß
Frank

[Christian Z. (christianz)]

Frank Link wrote:

> Aber mal eine andere Frage, wie setzte ich elegant ein Bit in einem
> unsigned char bzw. nehme das Bit wieder raus.

Das hast Du doch schon oben in Deinem Code stehen: Setzen mit

byte |= (1 << BITNR)

löschen mit

byte &= ~(1 << BITNR)

[Matthias Kölling (Gast)]

Ganz verstehe ich es immer noch nicht.
Wenn
#define COM74HC595_SIZE 1
dann sind doch
com74hc595[1] = 0x1;
com74hc595[2] = 0x1;
com74hc595[3] = 0x1;
com74hc595[4] = 0x0;
com74hc595[5] = 0x0;
com74hc595[6] = 0x0;
com74hc595[7] = 0x0;
undefinierte Speicherzugriffe.
Oder sehe ich das falsch?


Gruß Matthias

[Sven (Gast)]

@ Matthias:

> Oder sehe ich das falsch?

Nein, siehst Du ganz richtig.
Array ist nur auf ...[0] definiert..

Gruß Sven

P.S.: Also mit dem Posting #1.

[Frank L. (franklink)]

Ich sag ja, ich habe mich am Anfang von dem Warning des Compilers 
irritieren lassen, mein Fehler.

Jetzt läuft die ganze Sache rund.

Gruß
Frank