04-DigIn-Library (STM32F4)

diese Library dient zum auslesen von Digital Eingangsspins der CPU

die Pins die benutzt werden sollen, müssen im H-File deklariert und im C-File den entsprechenden Port-Pins zugeordnet werden.

für jeden Pin kann auch der Eingangswiderstand definiert werden
(keiner, Pull-Up, Pull-Down)

Ab der Version 1.2 kann im H-File eingestellt werden ob auch die entprellten Funktionen per Timer benutzt werden sollen. Dann können die Funktionen “OnHiLevel” , “OnHiEdge” und “OnLoEdge” benutzt werden.

Diese Funktionen liefern ein “true” wenn das Ereignis eingetreten ist.

im Beispiel wurden 4 Pins als Digital-In definiert

1	PD3,PD6,PD11,PE4

Voraussetzungen :

1 2	Benutzte Module der CooCox-IDE : GPIO, (TIM, MISC) Benutzte Librarys : keine

Enumerationen :

typedef enum 
{
  DIN_PD3 = 0,    // PD3-Pin
  DIN_PD6 = 1,    // PD6-Pin
  DIN_PD11 = 2,   // PD11-Pin
  DIN_PE4 = 3     // PE4-Pin
}DIN_NAME_t;

Funktionen :

void UB_DigIn_Init(void);                    // zum init der Digital-In-Pins
BitAction UB_DigIn_Read(DIN_NAME_t dig_pin); // um einen Pin auszulesen (nicht entprellt)
bool UB_DigIn_OnHiLevel(DIN_NAME_t dig_pin); // true, wenn ein Hi-Pegel anliegt (entprellt)
bool UB_DigIn_OnHiEdge(DIN_NAME_t dig_pin);  // true, bei einer Hi-Flanke (entprellt)
bool UB_DigIn_OnLoEdge(DIN_NAME_t dig_pin);  // true, bei einer Lo-Flanke (entprellt)

Beispiel :

//--------------------------------------------------------------
// File     : main.c
// Datum    : 16.02.2013
// Version  : 1.0
// Autor    : UB
// EMail    : mc-4u(@)t-online.de
// Web      : www.mikrocontroller-4u.de
// CPU      : STM32F4
// IDE      : CooCox CoIDE 1.7.0
// Module   : CMSIS_BOOT, M4_CMSIS_CORE
// Funktion : Demo der DigIn-Library
// Hinweis  : Diese zwei Files muessen auf 8MHz stehen
//              "cmsis_boot/stm32f4xx.h"
//              "cmsis_boot/system_stm32f4xx.c"
//--------------------------------------------------------------
 
#include "main.h"
#include "stm32_ub_dig_in.h"
#include "stm32_ub_dig_out.h"
 
int main(void)
{
  BitAction wert;
 
  SystemInit(); // Quarz Einstellungen aktivieren
 
  UB_DigIn_Init();  // init aller DigIn-Pins
  UB_DigOut_Init(); // init aller DigOut-Pins
 
  while(1)
  {
    // Pegel an PD3 lesen und an PB2 ausgeben
    wert=UB_DigIn_Read(DIN_PD3);
    UB_DigOut_Pin(DOUT_PB2,wert);
    // Pegel an PD6 lesen und an PB7 ausgeben
    wert=UB_DigIn_Read(DIN_PD6);
    UB_DigOut_Pin(DOUT_PB7,wert);
    // Pegel an PD11 lesen und an PC6 ausgeben
    wert=UB_DigIn_Read(DIN_PD11);
    UB_DigOut_Pin(DOUT_PC6,wert);
    // Pegel an PE4 lesen und an PC13 ausgeben
    wert=UB_DigIn_Read(DIN_PE4);
    UB_DigOut_Pin(DOUT_PC13,wert);
  }
}

Beschreibung :

Funktion :
-die GPIO-Pins PB2, PB7, PC6, PC13 werden als Ausgang definiert (in der LIB)
-die GPIO-Pins PD3, PD6, PD11, PE4 werden als Eingang definiert (in der LIB)
-die Pegel an den Eingängen werden eingelesen und an
 den Ausgängen wieder ausgegeben
 
Librarys die für das Beispiel benutzt werden :
-stm32_ub_dig_in
-stm32_ub_dig_out

Hier die Library zum Download :

ub_stm32f4_digin_v102

Hier der komplette CooCox-Projektordner zum Download :

Demo_04_DigIn

15 Antworten auf 04-DigIn-Library (STM32F4)

Joerg sagt:

6. Oktober 2013 um 11:58

Hallo Uwe,
könntest du die Funktion nicht noch um eine Entprellung erweitern? Am besten mit einstellbarer Zeit.

Grüße

Jörg
- admin_ub sagt:
  
  6. Oktober 2013 um 12:01
  
  ja, kann ich machen. Dann geht halt ein Timer dafür drauf.
Joerg sagt:

6. Oktober 2013 um 15:43

Bei 14 Stück kann man das glaube ich verkraften
Möglichst nicht 3 und 4, die benutze ich gerade schon in meiner Anwendung
- admin_ub sagt:
  
  7. Oktober 2013 um 18:21
  
  die Version 1.2 benutzt jetzt Timer-7 zum einlesen der Pins. Im H-File kann das Intervall eingestellt werden (im Moment 50ms)
Joerg sagt:

8. Oktober 2013 um 22:44

Cool, danke!
Timo sagt:

27. Mai 2014 um 12:05

Moin Moin,

ist es möglich, einen PIN für DigIn sowie DigOut zu nutzen?
- admin_ub sagt:
  
  27. Mai 2014 um 20:24
  Ja, wenn der Pin als Open-Collector initialisiert wird :
```
  // Config als OpenDrain-Ausgang
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
```
  so kann er von der CPU oder von extern auf Lo gezogen werden
  (der Pull-Up sorgt für das Hi Signal)
Tito Arevalo sagt:

14. November 2014 um 05:35

Hi, I’m starting with STM32F407 and I don’t understand why you configure the timer to set digital in’s..?? please help me

Greetings from ECUADOR
- admin_ub sagt:
  
  15. November 2014 um 12:58
  
  a “normal” GPIO input dont need a timer. the function “UB_DigIn_Read” reads the input without a timer. but to implement a debounce functionality a timer is the easiest way. the three functions “UB_DigIn_OnHiLevel”, “UB_DigIn_OnHiEdge”, “UB_DigIn_OnLoEdge” needs a timer. but you can deactivate these functions with the define “DIN_USE_TIMER 0″ if you dont need a debounced input.
Joerg B. sagt:

15. November 2014 um 18:39

Hallo Uwe,
jetzt würde ich gerne mal die Entprellte Version benutzen und habe da ein Verständnis Problem. Du Schreibst als Bemerkung:

// Digital-In OnLoEdge Auswertung (entprellt)
// ret_wert, ist nur einmal true nach Lo-Flanke am GPIO-Pin

oder

// Digital-In OnHiEdge Auswertung (entprellt)
// ret_wert, ist nur einmal true nach Hi-Flanke am GPIO-Pin

Eigentlich ist eine Entprellung ja so zu sehen, dass nur wenn ein Impuls über eine gewisse Zeit anliegt er gewertet werden soll. Nicht jeder Impuls. Ist das so???
- admin_ub sagt:
  
  16. November 2014 um 11:08
  
  nein, eine Längenmessung vom Impuls habe ich nicht realisiert und ist in meinen Augen für einen Anschluss von einem Taster oder Schalter auch nicht notwendig. Falls du “Spikes” auf der Leitung hast, sind das Störsignale die man per Hardware in den Griff bekommen müsste. Was man event. machen könnte ist mehr Messpunkte zu speichern und zu vergleichen aber das würde ich erst realisieren wenn es mit der bestehenden Lib ein Problem gibt.
Joerg B. sagt:

16. November 2014 um 13:30

Ich habe darüber auch mal nachgedacht. Da ich gegen Ground ziehe sind Spikes auch kein Problem denke ich.

Problematisch wäre es wohl eher bei Open Drain Geschichten.

Eine Längenmessung wäre auch beim Zählen mit Lichtschranken sinnvoll aber das würde ich dann sowieso anders angehen.

Danke für deine Antwort
- Joerg B. sagt:
  
  16. November 2014 um 20:53
  
  Das sprites kein Problem sind muss ich wohl revidieren.
  Ich habe 2 Endlagenschalter mit ca 2m Kabel dran die trotz externer Pullups von 1,8 k scheinbar auf null gezogen werden. 330 Ohm hatte ich versucht, schafft die CPU aber nicht runter zu ziehen. Mit 2 Kurzen Kabeln ohne ext. Pullups funktioniert es einwandfrei.
  - Joerg B. sagt:
    
    17. November 2014 um 09:55
    
    Ein paar Kondensatoren tuen doch Wunder Läuft jetzt…
  - admin_ub sagt:
    
    17. November 2014 um 19:29
    
    Die CPU muss bei Eingängen doch gar nichts “ziehen” oder “treiben”. Ein externer PullUp 4k7 am CPU Eingangspin und ein Schalter der gegen GND schaltet. Das funktioniert immer, egal wie lange die Leitung ist.