STM32 und 11x74HC595.

[Daniel S. (sany)]

Moin,

Ich bräuchte mal Hilfe mit einem Code für die Ansteuerung.

Ich habe 11 Stück 74HC595, die jeweils 84 LEDs ansteuern, 4 Ausgänge 
sind leer, die Ansteuerung erfolgt scheinbar mit LSB und nicht mit MSB.

Wenn mein Task startet, gehen die LEDs in umgekehrter Reinfolge an und 
wieder aus, also Beginnend bei Ausgang 88 bis Ausgang 73...

Wie drehe ich das um, so das Ausgang 1 - 16 angesteuert wird?

currentVal & (1 >> i)) brachte leider kein erfolg.


Mein Code:

uint64_t currentVal =  0b00000000000000000000000000000000000000000000000000000000000000000000000000000000;
void HC595write()
{
    for(int i=0; i<88; i++)
    {
        if(currentVal & (1<< i))
        {
            HAL_GPIO_WritePin(SER_GPIO_Port, SER_Pin, GPIO_PIN_SET);
        }
        else
        {
            HAL_GPIO_WritePin(SER_GPIO_Port, SER_Pin, GPIO_PIN_RESET);
        }
        HAL_GPIO_WritePin(SRCLK_GPIO_Port, SRCLK_Pin, GPIO_PIN_SET);
        HAL_GPIO_WritePin(SRCLK_GPIO_Port, SRCLK_Pin, GPIO_PIN_RESET);
    }
    HAL_GPIO_WritePin(RCLK_GPIO_Port, RCLK_Pin, GPIO_PIN_SET);
    HAL_GPIO_WritePin(RCLK_GPIO_Port, RCLK_Pin, GPIO_PIN_RESET);
}

void HC595writePin(uint8_t pin, uint8_t value)
{
      if (value == 0)
      {
          currentVal &= ~(1 << pin);
      }
      else
      {
          currentVal |= (1 << pin);
      }
      HC595write();
}

void StartDefaultTask(void *argument)
{
  /* init code for USB_DEVICE */
  MX_USB_DEVICE_Init();
  /* USER CODE BEGIN 5 */

  /* Infinite loop */
  for(;;)
  {

    for(int i=0; i < 16; i++)
    {
      HC595writePin(i, 0);
      osDelay(100);
    }
    osDelay(1000);
    for(int i=0; i < 16; i++)
        {
          HC595writePin(i, 1);
          osDelay(100);
        }
  }
  /* USER CODE END 5 */
}

vielen Dank für eure Hilfe :)

[Sherlock 🕵🏽‍♂️ (rubbel-die-katz)]

Deine for Schleife bestimmt, in welcher Reihenfolge die Bits gezählt 
werden. Ich bezweifle allerdings, dass deine 64 Bit Variable 88 Bits 
enthalten kann.

[Niklas G. (erlkoenig)]

88 Bits in einer 64bit-Variable? Optimistisch!

[Christian M. (christian_m280)]

Sherlock 🕵🏽‍♂️ schrieb:
> Ich bezweifle allerdings, dass deine 64 Bit Variable 88 Bits enthalten
> kann.

Da musst Du Gregor fragen, der kann das:

Beitrag "Re: AT89C2051 und das UART Rätsel"

Gruss Chregu

[Falk B. (falk)]

Daniel S. schrieb:
> Moin,
>
> Ich bräuchte mal Hilfe mit einem Code für die Ansteuerung.
>
> Ich habe 11 Stück 74HC595, die jeweils 84 LEDs ansteuern, 4 Ausgänge
> sind leer, die Ansteuerung erfolgt scheinbar mit LSB und nicht mit MSB.

> Wenn mein Task startet, gehen die LEDs in umgekehrter Reinfolge an und
> wieder aus, also Beginnend bei Ausgang 88 bis Ausgang 73...
>
> Wie drehe ich das um, so das Ausgang 1 - 16 angesteuert wird?
>
> currentVal & (1 >> i)) brachte leider kein erfolg.

Logisch, du hast den Code nicht verstanden. Siehe Bitmanipulation.

Naja. Solche Sachen packt man in ein Array mit uint8_t Datentyp, das ist 
verdaulicher, auch für fette 32 Bit CPUs. Und viel besser erweiterbar 
auf beliebige Schieberegisterlängen.
Im aktuellen Code und auch meiner Version unten, liegt das Ende der 
LED-Kette am Anfang der Daten, denn die werden zuerst ausgegeben. Kann 
man ggf. auch umdrehen.

uint8_t LEDdata[11];
 
void HC595write()
{
    int data;

    for(int i=0; i<11; i++)
    {
        data = LEDdata[i];
        for (int j=0; j < 8; j++)
        {
            if(data & (1<<j))
            {
                HAL_GPIO_WritePin(SER_GPIO_Port, SER_Pin, GPIO_PIN_SET);
            }
            else
            {
                HAL_GPIO_WritePin(SER_GPIO_Port, SER_Pin, GPIO_PIN_RESET);
            }
            HAL_GPIO_WritePin(SRCLK_GPIO_Port, SRCLK_Pin, GPIO_PIN_SET);
            HAL_GPIO_WritePin(SRCLK_GPIO_Port, SRCLK_Pin, GPIO_PIN_RESET);
        }
    } 
    HAL_GPIO_WritePin(RCLK_GPIO_Port, RCLK_Pin, GPIO_PIN_SET);
    HAL_GPIO_WritePin(RCLK_GPIO_Port, RCLK_Pin, GPIO_PIN_RESET);
}

void HC595writePin(uint8_t pin, uint8_t value)
{
    int bit, byte;

    byte = pin / 8;
    bit = pin % 8;

    if (value == 0)
    {
        LEDdata[byte] &= ~(1 << bit);
    }
    else
    {
        LEDdata[byte] |= (1 << bit);
    }
    HC595write();
}

void StartDefaultTask(void *argument)
{
    /* init code for USB_DEVICE */
    MX_USB_DEVICE_Init();
    /* USER CODE BEGIN 5 */
    /* Infinite loop */
    for(;;)
    {
        for(int i=87; i>=70; i--)
        {
            HC595writePin(i, 0);
            osDelay(100);
        }
        osDelay(1000);
        for(int i=70; i < 88; i++)
        {
            HC595writePin(i, 1);
            osDelay(100);
        }
    }
    /* USER CODE END 5 */
}

[Daniel S. (sany)]

Hallo Falk,

vielen Dank, habe den Code mal getestet, funktioniert.

habe mal den Code abgeändert, nun funktionierts wie gewollt! :)

void HC595write()
{
  int data;
  for(int i=11; i >=  0; i--)
  {
    data = channelData[i];

    for(int j=7; j >= 0; j--)
    {
      if(data & (1<< j))
      {
        HAL_GPIO_WritePin(SER_GPIO_Port, SER_Pin, GPIO_PIN_SET);
      }
      else
      {
        HAL_GPIO_WritePin(SER_GPIO_Port, SER_Pin, GPIO_PIN_RESET);
      }
      HAL_GPIO_WritePin(SRCLK_GPIO_Port, SRCLK_Pin, GPIO_PIN_SET);
      HAL_GPIO_WritePin(SRCLK_GPIO_Port, SRCLK_Pin, GPIO_PIN_RESET);
    }
  }
    HAL_GPIO_WritePin(RCLK_GPIO_Port, RCLK_Pin, GPIO_PIN_SET);
    HAL_GPIO_WritePin(RCLK_GPIO_Port, RCLK_Pin, GPIO_PIN_RESET);
}

[Falk B. (falk)]

Daniel S. schrieb:
> Hallo Falk,
>
> vielen Dank, habe den Code mal getestet, funktioniert.
> Jetzt müsste ich nur noch das ganze gedreht bekommen, denn wenn ich Pin
> 1 auf 1 stelle, geht die LED 88 an u.s.w.

Tja, sagte ich ja bereits.

> Über die Bitmanipulation müsste ich doch eigentlich das gedreht
> bekommen?

Jain, man muss die Adressierung der Bytes auch spiegeln.

> Wenn ich meine for-schleife nun aufif(data & (1>> j))
>
> funktionierts leider nicht,

Logisch.

> eigentlich muss ich doch die 1 in die andere
> Richtung schieben mit 1>>j... ?

Das allein reicht nicht.

#define LCD_CNT 88
#define BYTE_CNT ((LED_CNT+7)/8)

uint8_t LEDdata[BYTE_CNT];
 
void HC595write()
{
    int data;

    for(int i=BYTE_CNT; i>=0; i--)
    {
        data = LEDdata[i];
        for (int j=7; j >= 0; j--)
        {
            if(data & (1<<j))
            {
                HAL_GPIO_WritePin(SER_GPIO_Port, SER_Pin, GPIO_PIN_SET);
            }
            else
            {
                HAL_GPIO_WritePin(SER_GPIO_Port, SER_Pin, GPIO_PIN_RESET);
            }
            HAL_GPIO_WritePin(SRCLK_GPIO_Port, SRCLK_Pin, GPIO_PIN_SET);
            HAL_GPIO_WritePin(SRCLK_GPIO_Port, SRCLK_Pin, GPIO_PIN_RESET);
        }
    } 
    HAL_GPIO_WritePin(RCLK_GPIO_Port, RCLK_Pin, GPIO_PIN_SET);
    HAL_GPIO_WritePin(RCLK_GPIO_Port, RCLK_Pin, GPIO_PIN_RESET);
}

void HC595writePin(uint8_t pin, uint8_t value)
{
    int bit, byte;

    byte = pin / 8;
    bit = pin % 8;

    if (value == 0)
    {
        LEDdata[byte] &= ~(1 << bit);
    }
    else
    {
        LEDdata[byte] |= (1 << bit);
    }
    HC595write();
}

void StartDefaultTask(void *argument)
{
    /* init code for USB_DEVICE */
    MX_USB_DEVICE_Init();
    /* USER CODE BEGIN 5 */
    /* Infinite loop */
    for(;;)
    {
        for(int i=0; i<16; i++)
        {
            HC595writePin(i, 0);
            osDelay(100);
        }
        osDelay(1000);
        for(int i=16; i >= 0; i--)
        {
            HC595writePin(i, 1);
            osDelay(100);
        }
    }
    /* USER CODE END 5 */
}

[Sherlock 🕵🏽‍♂️ (rubbel-die-katz)]

Daniel S. schrieb:
> Wenn ich meine for-schleife nun auf
> if(data & (1>> j))
> funktionierts leider nicht

Versuche morgen nochmal, die Frage neu zu formulieren, so dass sie 
verständlich ist. Bei der Gelegenheit kannst du dann auch eine Skizze 
von der Verschaltung der Schieberegister und deinen LEDs mit Nummern 
nachreichen.

Aber erst morgen!

[Daniel S. (sany)]

Moin,

Scheinbar war das Forum nicht so schnell, oder ich zu langsam mit 
bearbeiten.

Habe es mir dass bereits so gedreht, wie ich das gebraucht habe, die 
Lösung hat sich eigentlich beim Beitrag schreiben automatisch ergeben 
:-)

[Gregor J. (Firma: Jasinski) (gregor_jasinski)]

Daniel S. schrieb:
> vielen Dank für eure Hilfe :)

Für die 74HC595 kann man eine SPI-Schnittstelle nehmen, um bequem die 
Daten in die kaskadierten Chips hineinpumpen zu lassen, aber wenn man 
das Bitkippen schon selbst per Software macht oder üben will oder von 
mir aus auch machen muss und sowieso viele Kilobytes an SRAM noch übrig 
hat, kann man z.B. 100 Bytes für ein Bytearray opfern und jeweils nur 
ein Bit in einem Byte speichern, gerne auch an der LSB-Stelle, also im 
Bit 0. Dieser verschwenderische Umgang mit dem SRAM, der am Ende des 
Projekts sowieso ungenutzt im µController liegen würde, erleichtert 
unheimlich die Bitadressierung, also eigentlich dann schon die 
LED-Adressierung, da die LED-Adresse dann dem Index vom Array entspricht 
– demnach wird also auch das Codeschreiben sehr vereinfacht, obendrein 
wird im Hintergrund von der CPU vermutlich alles deutlich schneller 
ausgeführt, da grundsätzlich nur noch mit Bytes hantiert wird.

Man muss halt wissen, wann Sparen angesagt ist und wann aus Komfort- 
oder Geschwindigkeitsgründen das genaue Gegenteil angewandt werden darf 
– bei einem AT89C2051 oder AT89C51 kommt es auf jedes Byte an und dort 
muss man teilweise extrem sparen und oft auch zu Assembler greifen, weil 
auch der Flash relativ kurz ist, beim STM32 ist es Unsinn, krampfhaft 
irgendwelche Bitakrobatik mit Schiebe-, Modulooperationen oder gar 
Divisionen, die quasi mit jedem Schleifendurchlauf ausgeführt werden 
müssen, zu vollführen, wenn man sowieso sehr viel Speicher zur Verfügung 
hat und alles viel einfacher und vermutlich auch übersichtlicher oder 
leserlicher in C gestaltet werden kann. Wie ich bereits woanders mal 
sagte – eine kostbare Ressource, mit der schonend umgegangen werden 
muss, kann immer etwas anderes bedeuten, mal ist es der Speicher, mal 
die Zeit, ein anderes mal etwas ganz anderes oder eine Kombination aus 
allem, aber die wichtigste Ressource eines Homo sapiens ist die 
entsprechend gefaltete und vernetzte Hirnmasse, die es einem ermöglichen 
kann, über den Tellerrand hinauszuschauen und generell einen besseren 
Überblick zu bekommen; ja, zu bekommen, denn dieser wird nicht jedem von 
der geistigen, unsichtbaren Welt gewährt, geschenkt oder erlaubt, sich 
diesen selbst hart erarbeiten zu dürfen.