BWP-SS19-01/Fein Design/Engine

Engine

Die Engine besteht aus dem C-File (Engine.c) und einen Header-File (Engine.h) und spricht die notwendigen GPIO-Pins an, um die Motor anzusteuern.

Engine.h

Im Header-File befinden sich 4 Konstanten, die den PINS auf dem Motor-Treiber entsprechen.
PIN AIN1 auf dem Motor-Treiber ist mit dem GPIO-Pin 11 auf dem Feather verbunden. AIN2 ist mit PIN 7 verbunden.
PIN BIN1 und BIN2 sind an GPIO-PIN A3 bzw. A2 angeschlossen.

#define AIN1 EXT_P11_GPIO_PIN // 11
#define AIN2 EXT_P7_GPIO_PIN  // 7
#define BIN2 EXT_A2_GPIO_PIN  // A2
#define BIN1 EXT_A3_GPIO_PIN  // A3

Engine.c

Im Wesentlichen werden hier die notwendigen PINS initialisiert, um diese mittels GPIO verwenden zu können. Dies geschieht in der void internal_init_Engine(void) {...} Funktion.
Um die angeschlossenen PINs nutzen zu können, ist ein Binding notwendig, dies geschieht mittels:

dev_pin11      = device_get_binding(GPIO_DRIVER);
dev_pin7       = device_get_binding(GPIO_DRIVER);
dev_pinA3      = device_get_binding(GPIO_DRIVER);
dev_pinA2      = device_get_binding(GPIO_DRIVER);

Nach diesem Binding ist es notwendig die entsprechenden PINs auf "OUT" zu setzen, um ein Signal senden zu können:

gpio_pin_configure(dev_pin11, AIN1, GPIO_DIR_OUT );
gpio_pin_configure(dev_pin7 , AIN2, GPIO_DIR_OUT );
gpio_pin_configure(dev_pinA3, BIN1, GPIO_DIR_OUT );
gpio_pin_configure(dev_pinA2, BIN2, GPIO_DIR_OUT );

Die Funktion void gpio_engine_pin_write (u32_t gpio_pin, int enable) {...} ist eine Hilfs-Funktion, um leicht die GPIO-PINs an-/ausschalten zu können.
Um alle PINs auf False zu setzen und somit beide Motoren auszuschalten, wird die folgende Funktion verwendet:

void engine_off(void) {

	gpio_engine_pin_write(AIN1, False);
	gpio_engine_pin_write(AIN2, False);
	gpio_engine_pin_write(BIN1, False);
	gpio_engine_pin_write(BIN2, False);

}

Wie hier zu sehen ist, kommt hier die o.g. Hilfs-Funktion zum Einsatz.

Um vorwärts fahren zu können muss PIN AIN1 & PIN BIN1 auf True gesetzt werden, die beiden anderen PINs AIN2 & BIN2 müssen auf False gesetzt sein.
Hier wird ein int übergeben, um die Zeit, die der Motor laufen soll, festzulegen.

void engine_forward(int msec) {
	gpio_engine_pin_write( AIN1, True);
	gpio_engine_pin_write( AIN2, False);
	gpio_engine_pin_write( BIN1, True);
	gpio_engine_pin_write( BIN2, False);
	k_sleep(msec);
	engine_off();
}

Um rückwärts zu fahren, muss die True/False-Belegung umgedreht werden.

void engine_backward(int msec) {
	gpio_engine_pin_write( AIN1, False);
	gpio_engine_pin_write( AIN2, True);
	gpio_engine_pin_write( BIN1, False);
	gpio_engine_pin_write( BIN2, True);
	k_sleep(msec);
	engine_off();
}

Hier ist das Entscheidende, dass beide Räder in die gleiche Richtung drehen. Um eine Kurve fahren zu können bzw. sich drehen zu können gibt es die void engine_turn(int msec, int direction) {...} Funktion.

void engine_turn(int msec, int direction) {
	if (direction == DIRECTION_RIGHT) {
		gpio_engine_pin_write( AIN1, True);
		gpio_engine_pin_write( AIN2, False);
		gpio_engine_pin_write( BIN1, False);
		gpio_engine_pin_write( BIN2, True);
	} else if (direction == DIRECTION_LEFT) {
		gpio_engine_pin_write( AIN1, False);
		gpio_engine_pin_write( AIN2, True);
		gpio_engine_pin_write( BIN1, True);
		gpio_engine_pin_write( BIN2, False);
	} else {
		printk("engine_turn(): ERROR");
		printk("=> direction unknown");
		return;
	}
	k_sleep(msec);
	engine_off();
}

Hier wird je nach Richtung entweder das linke Rad vorwärts und das rechte Rad rückwärts (bzw. andersherum) gedreht.