STM32 ADC Wandlungsergebnis auf verschiedenen Pins ausgeben

Alexander M. OP #6731879
Lesenswert?
• ▲
▼ 
while (1)
  {

    // Der ADC wird gestartet und misst den Wert auf adc1 (PIN A0)
    HAL_ADC_Start(&hadc1); // adc1 auf pin PA0 == A0
    HAL_ADC_PollForConversion(&hadc1, 10);
    // Der Wert von adc1 (Poti) wird ausgelesen und in value gespeichert
    value= HAL_ADC_GetValue(&hadc1);

}


Also ADC auslesen in einer Round Robin Struktur und in das Ergebnis in 
value speichern habe ich bis jetzt geschaft. Das Problem bei mir ist 
Ausgabe des Wandlungsergebnises auf Ports C0-C3.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Erwin Gast #6731895
Lesenswert?
• ▲
▼ 
Aber wenn wir hier schon die Hausaufgaben von anderen machen, können 
doch wir alle etwas dabei lernen?

Wie sinnvoll ist das Beispiel überhaupt??

Denke die meisten von uns hätten das jetzt über einen Timer-Interrupt, 
drei Bitmasken und einen free-running ADC gelöst, aber was hat das mit 
Round Robin zu tun?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thomas W. Gast #6731918
Lesenswert?
• ▲
▼ 
Moin, -

die Zauberworte sind Bit-Manipulationen mit & und |, z.B. 
https://www.mikrocontroller.net/articles/Bitmanipulation#Standard_C_3

Ueberlege bitte, wie Du einzelne Bits Deines ADC-Wortes maskieren 
kannst.

Diese Ueberlegungen mit AND, OR und XOR wirst Du immer brauchen.

Ueberlege bitte was ist 0x1234 & 0x0001?

Viele Gruesse

Th.

Oder:
https://www.c-howto.de/tutorial/variablen/bitmanipulation/
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Stefan F. Gast #6732624
Lesenswert?
• ▲
▼ 
Oleksandr S. schrieb:
> Ich hoffe dass dir in deinem Leben auch keiner hilft. Wer bist du um
> überhaupt irgendwas hier zu sagen? Wenn du nichts angemessenes zu sagen
> hast, spar lieber deine Zeit.

Interessant. Mit der Einstellung hast du definitiv keine Hilfe verdient. 
Auch nicht von einem Autor, der im Laufe von 25 Jahren zahlreiche Bücher 
und Tutorials von Anfang an kostenlos veröffentlicht hat. So viel zur 
Frage, wer ich eigentlich bin.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Alexander M. OP #6732641
Lesenswert?
• ▲
▼ 
Moment mal, ich habe niemanden gebeten, meine Hausaufgaben für mich zu 
machen, ich hatte nur an einer Stelle dieser Aufgabe ein Problem (siehe 
2. Kommentar). Warum ist es jetzt notwendig, wegen einer unauffälligen 
Person hier sinnlose Diskussionen zu veranstalten oder habt ihr heute 
nichts wichtigeres zu tun?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Alexander M. OP #6732656
Lesenswert?
• ▲
▼ 
Ich dachte wir befinden uns im Forum wo gegenseitig geholfen wird ? Wie 
würdest du reagieren, wenn du eine Frage hast und dann komme ich und 
sage "Hey Leute , hilft ihm nicht" ? Du hast einfach die Kommentare 
nicht aufmerksam gelesen und hast dir gedacht, dass hier jemand meine 
Hausaufgaben für mich machen soll, aber das stimmt gar nicht. Ich hatte 
eine konkrete Frage, aber naja  es ist schon dank dir vorbei.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
dummschwaetzer Gast #6732669
Lesenswert?
• ▲
▼ 
Du soltest deine Lesekompetenz verbessern!
>"Hey Leute , hilft ihm nicht"
hat Stefan nicht gesagt, ehr so "Heft ihm bei den Teilschritten"

Hättest du Stefans Tutorial gelesen wüstest du wie mann Pins 
setzt/löscht.

Aus den bisher gegebenen Informationen meiner Vorredner ist die Aufgabe 
eingentlich lösbar.
Bitte deine Lösung hier posten.
Oder wo hast du noch Probleme?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Alexander M. OP #6732807
Lesenswert?
• ▲
▼ 
Hier ist meine Lösung, allerdings weiß ich nicht ob die korrekt ist

1
#include "main.h"

2


3
ADC_HandleTypeDef hadc1;

4


5
void SystemClock_Config(void);

6
static void MX_GPIO_Init(void);

7
static void MX_ADC1_Init(void);

8


9
int main(void)

10
{

11
  /* USER CODE BEGIN 1 */

12
  int value = 0;

13
  /* USER CODE END 1 */

14


15
  HAL_Init();

16
  SystemClock_Config();

17
  MX_GPIO_Init();

18
  MX_USART2_UART_Init();

19
  MX_ADC1_Init();

20


21
while (1)

22
  {

23
   

24
    HAL_ADC_Start(&hadc1); // adc1 auf pin PA0 == A0

25
    HAL_ADC_PollForConversion(&hadc1, 10);

26
    // Der Wert von adc1 (Poti) wird ausgelesen und in value gespeichert

27
     if (value & (1<<11))  { // höchstes Bit

28
      HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET);

29


30
   } else {

31
        HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_RESET);

32


33
       }

34
    if (value & (1<<0)) { // niedrigstes Bit

35
         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_SET);

36


37
      } else {

38
           HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_RESET);

39


40
          }

41
    if (value & (1<<3)) { // 3 Bit

42
         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_SET);

43


44
      } else {

45
           HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_RESET);

46


47
          }

48
    if (value & (1<<4)) { // 4 Bit

49
         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_SET);

50


51
      } else {

52
           HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_RESET);

53


54
          }

55


56
  }

57


58
  }

59


60
/*Configure GPIO pin Output Level */

61
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, GPIO_PIN_RESET);

62
/*Configure GPIO pins : PC0 PC1 PC2 PC3 */

63
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3;

64
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

65
  GPIO_InitStruct.Pull = GPIO_NOPULL;

66
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

67
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Alexander M. OP #6732824
Lesenswert?
• ▲
▼ 
Genau ich soll 4 Porte PC0 PC1 PC2 PC3 benutzen, die habe ich auch als 
GPIO Ausgänge definiert. Die "value" habe ich beim Kopieren tatsächlich 
vergessen.  Jetzt habe ich korrigiert.

1
#include "main.h"

2
ADC_HandleTypeDef hadc1;

3
void SystemClock_Config(void);

4
static void MX_GPIO_Init(void);

5
static void MX_ADC1_Init(void);

6
int main(void)

7
{

8
  /* USER CODE BEGIN 1 */

9
  int value = 0;

10
  /* USER CODE END 1 */

11
  HAL_Init();

12
  SystemClock_Config();

13
  MX_GPIO_Init();;

14
  MX_ADC1_Init();

15
while (1)

16
  {

17
   

18
    HAL_ADC_Start(&hadc1); // adc1 auf pin PA0 == A0

19
    HAL_ADC_PollForConversion(&hadc1, 10);

20
    value = HAL_ADC_GetValue(&hadc1);

21
    // Der Wert von adc1 (Poti) wird ausgelesen und in value gespeichert

22
     if (value & (1<<11))  { // höchstes Bit

23
      HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET);

24
   } else {

25
        HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_RESET);

26
       }

27
    if (value & (1<<0)) { // niedrigstes Bit

28
         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_SET);

29
      } else {

30
           HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_RESET);

31
          }

32
    if (value & (1<<3)) { // 3 Bit

33
         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_SET);

34
      } else {

35
           HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_RESET);

36
          }

37
    if (value & (1<<4)) { // 4 Bit

38
         HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_SET);

39
      } else {

40
           HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_RESET);

41
          }

42
  }

43
  }

44
/*Configure GPIO pin Output Level */

45
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, GPIO_PIN_RESET);

46
/*Configure GPIO pins : PC0 PC1 PC2 PC3 */

47
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3;

48
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

49
  GPIO_InitStruct.Pull = GPIO_NOPULL;

50
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

51
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

52


53
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thomas W. Gast #6732832
Lesenswert?
• ▲
▼ 
Moin, -

Oleksandr S. schrieb:
> vergessen.  Jetzt habbe ich korrigiert.

Nein.

1
     if (value & (1<<11))  { // höchstes Bit

2
      HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET);

3
   } else {

4
        HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_RESET);

5
       }


Jetzt den Code in CubeIDE einkloeppern und compile.

Gruesse

Th.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Alexander M. OP #6732856
Lesenswert?
• ▲
▼ 
Ah ja sehe ich, GPIOC muss ich nehmen. Danke dir. Warum ist das kein 
Round Robin?
1
while (1)

2
  {

3
  

4


5
    HAL_ADC_Start(&hadc1); // adc1 auf pin PA0 == A0

6
    HAL_ADC_PollForConversion(&hadc1, 10);

7
    // Der Wert von adc1 (Poti) wird ausgelesen und in value gespeichert

8
    value = HAL_ADC_GetValue(&hadc1);

9


10


11
    if (value & (1<<11))  { // höchstes Bit

12
         HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET);

13
      } else {

14
           HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_RESET);

15
          }

16
       if (value & (1<<0)) { // niedrigstes Bit

17
            HAL_GPIO_WritePin(GPIOC, GPIO_PIN_1, GPIO_PIN_SET);

18
         } else {

19
              HAL_GPIO_WritePin(GPIOC, GPIO_PIN_1, GPIO_PIN_RESET);

20
             }

21
       if (value & (1<<3)) { // 3 Bit

22
            HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, GPIO_PIN_SET);

23
         } else {

24
              HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, GPIO_PIN_RESET);

25
             }

26
       if (value & (1<<4)) { // 4 Bit

27
            HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, GPIO_PIN_SET);

28
         } else {

29
              HAL_GPIO_WritePin(GPIOC, GPIO_PIN_3, GPIO_PIN_RESET);

30
             }

31


32
  }
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thomas W. Gast #6732858
Lesenswert?
• ▲
▼ 
Moin, -

ich hatte es Copy & Paste fehler gehalten, aber was willst Du mit diesem 
Teil machen:

1
>           }

2
>     if (value & (1<<4)) { // 4 Bit

3
>          HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_SET);

4
>       } else {

5
>            HAL_GPIO_WritePin(GPIOA, GPIO_PIN_3, GPIO_PIN_RESET);

6
>           }

7
>   }

8
>   }

9
> /*Configure GPIO pin Output Level */

10
>   HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 

11
> GPIO_PIN_RESET);

12
> /*Configure GPIO pins : PC0 PC1 PC2 PC3 */

13
>   GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3;

14
>   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

15
>   GPIO_InitStruct.Pull = GPIO_NOPULL;

16
>   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

17
>   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

18
> 

19
> }

20
>


also das Configure NACH dem while() das NIE ausgefuehrt wird.

Gruesse

Th.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Alexander M. OP #6732864
Lesenswert?
• ▲
▼ 
Das sind die GPIO Einstellungen, die gehören zur MX_GPIO_Init Funktion

so musste das aussehen:

1
static void MX_GPIO_Init(void) {

2
/*Configure GPIO pin Output Level */

3
>   HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 

4
> GPIO_PIN_RESET);

5
> /*Configure GPIO pins : PC0 PC1 PC2 PC3 */

6
>   GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3;

7
>   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

8
>   GPIO_InitStruct.Pull = GPIO_NOPULL;

9
>   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

10
>   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

11
> 

12
> }
Antwort Zitieren Bearbeiten Löschen Beitrag melden
dummschwaetzer Gast #6732866
Lesenswert?
• ▲
▼ 
> /*Configure GPIO pin Output Level */

>   HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,

> GPIO_PIN_RESET);

> /*Configure GPIO pins : PC0 PC1 PC2 PC3 */

>   GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3;

>   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;

>   GPIO_InitStruct.Pull = GPIO_NOPULL;

>   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

>   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

>

> }

ist doch eigentlich in der MX_GPIO_Init(void);
und nicht nach der Endlosschleife.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Guido K. (Firma: Code Mercenaries GmbH) #6733814
Lesenswert?
• ▲
▼ 
Stefan ⛄ F. schrieb:
> Vielleicht wird die Round-Robin Struktur in einer Folge-Aufgabe
> benötigt.

Ja, vielleicht schon, aber ich wüsste jetzt nicht mal wie man bei einem 
linearen Algorithmus, also Wert lesen, Wert ausgeben, irgendwie einen 
Round Robin einbauen könnte. Es gibt keinen konkurrierenden Prozess, der 
Ablauf ist synchron und nicht nebenläufig.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Gerald M. #6733991
Lesenswert?
• ▲
▼ 
Vielleicht soll er auch nicht auf das Ergebnis warten, sondern den ADC 
nur triggern.
Dann kann es passieren dass "jemand" zweites ein ADC Ergebnis haben 
möchte, noch bevor das Ergebnis der ersten Messung da ist. Es sollte 
also irgendwo ein FIFO geben welches die Anfrager verwaltet und eine 
Queue bildet.
So würde ich das interpretieren (und ist im Gegensatz zu dem Teil mit 
den Pins auch Praxisrelevant, auch wenn es normal eher eine 
Schnittstelle wie SPI o.ä. trifft).
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren