Om de robotarm aan te sturen met de motoren heb ik robot_arm.h
en robot_arm.c geschreven.
robot_arm.h:
/*
* robot_arm.h
*
* Created on: Sep 16, 2021
* Author: Sem
*/
#ifndef SRC_ROBOT_ARM_H_
#define SRC_ROBOT_ARM_H_
#include "main.h"
typedef enum
{
Up,
Down
} DIRECTION;
typedef struct
{
TIM_TypeDef* timer;
DIRECTION dir;
int speed;
int moving;
}robot_arm_t;
/**
* @brief sets the direction of the robot arm to move
*
* @param arm the arm struct to use
*/
void robot_arm_update_direction(robot_arm_t* arm);
/**
* @brief moves the robot arm with the desired speed
*
* @param robot arm struct to use
* @param speed_percentage the percentage of speed to use
*/
void robot_arm_update_speed(robot_arm_t* arm);
/**
* @brief stops the robot arm
*
* @param timer the timer that handles the PWM signal
*/
void robot_arm_stop(robot_arm_t* arm);
#endif /* SRC_ROBOT_ARM_H_ */
Deze header file bevat de declaraties van de functies om de motoren van de robotarm aan te sturen.
De enum DIRECTION geeft aan of de motor met de klok mee of tegen de klok in moet bewegen, en
dus of deze omlaag of omhoog moet bewegen. De struct robot_arm_t representeert een arm en
bevat alle nodige variabelen om de motor van een arm aan te kunnen sturen. Hierin zit een handle
naar de timer die wordt gebruikt voor het versturen van een PWM signaal, de kant waar de motoren
naar moeten draaien, de huidige snelheid van de motor en of de arm in beweging is of niet.
De kant waarop de motoren draaien kan worden ingesteld
met de functie robot_arm_update_direction.
De snelheid waarmee de motoren draaien kan worden ingesteld met de functie robot_arm_update_speed. Deze functie past het PWM signaal aan
dat naar de motoren wordt gestuurd.
Om de motoren te laten stoppen kan de functie robot_arm_stop
gebruikt worden. Deze stopt de motoren.
De definities van deze functies heb ik geschreven in robot_arm.c:
/*
* robot_arm.c
*
* Created on: Sep 16, 2021
* Author: Sem
*/
#include "robot_arm.h"
void robot_arm_update_direction(robot_arm_t *arm) {
if (arm->dir == Up) {
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_15, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);
} else if (arm->dir == Down) {
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_15, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);
}
}
void robot_arm_update_speed(robot_arm_t *arm) {
if (arm->moving == 0)
return;
int speed_percentage = arm->speed;
if (speed_percentage < 10)
speed_percentage = 10;
if (speed_percentage > 90)
speed_percentage = 90;
arm->timer->CCR1 = arm->timer->ARR * ((float) speed_percentage) / 100.0;
}
void robot_arm_stop(robot_arm_t *arm) {
arm->speed = 0;
robot_arm_update_speed(arm);
arm->moving = 0;
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_15, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_RESET);
}
Bij de functie robot_arm_update_direction is te zien dat
pin B14 en B15 hoog of laag worden gezet aan de hand van welke kant de arm op moeten bewegen. Dit
wordt gedaan met de HAL_GPIO_WritePin functie.
Bij de functie robot_arm_update_speed wordt de snelheid van
de motor ingesteld. Dit wordt gedaan aan de hand van de speed
variabele van de struct die doorgegeven wordt.
Aangezien de ESCON servo controller een PWM signaal van minimaal 10% en maximaal 90% kan ontvangen
wordt de snelheid hierop aangepast voordat deze wordt doorgestuurd. Het sturen van het PWM signaal
gaat door het aanpassen van het Capture Compare register van de timer die voor het PWM signaal
gebruikt
wordt. Om een percentage te krijgen wordt het gewenste percentage vermenigvuldigd met de waarde in
het Auto Reload Register. De waarde die hier uit komt is een percentage van het Auto Reload Register
en zorgt ervoor dat dit percentage als PWM signaal doorgestuurd kan worden.
De functie robot_arm_stop wordt gebruikt om de motor en dus
de arm te stoppen. Hierbij wordt de speed variabele van de
doorgegeven struct op 0 gezet. Hierna wordt de snelheid aangepast door de functie robot_arm_update_speed aan te roepen met de nieuwe snelheid.
Hierna wordt de moving variabele op 0 gezet waardoor de
snelheid niet meer aangepast kan worden. Hierna wordt er een laag signaal naar pins B14 en B15
gestuurd om ervoor te zorgen dat de motor geen kant op kan draaien.
