Ga naar hoofdinhoud

Embedded Cheatsheet

Snel iets opzoeken? Hieronder staan de functies, pinnen en commando's die je het vaakst nodig hebt. Klik een blok open voor een minimaal voorbeeld.

Arduino-basis​

Hoe ziet een leeg programma eruit? (setup / loop)
void setup() {
  // draait één keer bij het opstarten
}

void loop() {
  // draait daarna oneindig opnieuw
}
Een pin als uitgang of ingang instellen (pinMode)
void setup() {
  pinMode(13, OUTPUT);       // pin 13 stuurt iets aan
  pinMode(2, INPUT_PULLUP);  // pin 2 leest iets in, met interne pull-up
}
Wachten (delay)
delay(1000);  // wacht 1000 milliseconden = 1 seconde

Digitale IO​

Een LED aan- of uitzetten (digitalWrite)
digitalWrite(13, HIGH);  // aan (5V)
digitalWrite(13, LOW);   // uit (0V)
Een knop uitlezen (digitalRead)
int waarde = digitalRead(2);  // HIGH of LOW

Met INPUT_PULLUP is een ingedrukte knop LOW.

Analoge IO & PWM​

Een analoge waarde inlezen (analogRead)
int waarde = analogRead(A0);  // 0 t/m 1023 op de Uno
Een LED dimmen met PWM (analogWrite)
analogWrite(9, 128);  // 0 = uit, 255 = volledig aan. Alleen op ~pinnen.
Een bereik omrekenen (map)
int helderheid = map(analogRead(A0), 0, 1023, 0, 255);

Serieel​

De seriële monitor starten en printen (Serial)
void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println("Hallo");
  delay(500);
}

Zet de monitor in je editor op dezelfde snelheid (9600 baud).

Timing zonder delay​

Iets doen op een interval zonder te blokkeren (millis)
unsigned long vorige = 0;
const unsigned long interval = 1000;

void loop() {
  if (millis() - vorige >= interval) {
    vorige = millis();
    // doe hier iets elke seconde
  }
}

PlatformIO​

Een minimale platformio.ini voor de Arduino Uno
[env:uno]
platform = atmelavr
board = uno
framework = arduino
monitor_speed = 9600
Een platformio.ini voor de STM32 Blue Pill (HAL)
[env:bluepill]
platform = ststm32
board = bluepill_f103c8
framework = stm32cube
upload_protocol = stlink
Een library toevoegen (lib_deps)
lib_deps =
  adafruit/Adafruit SSD1306@^2.5.7
Veelgebruikte PlatformIO-commando's
pio run                 # bouwen
pio run --target upload # uploaden naar het board
pio device monitor      # seriële monitor openen

STM32 (Blue Pill)​

Klok naar een poort aanzetten (verplichte eerste stap)
__HAL_RCC_GPIOC_CLK_ENABLE();  // poort C
__HAL_RCC_GPIOB_CLK_ENABLE();  // poort B

In een STM32 staat elk onderdeel uit tot je de klok aanzet. Vergeet je dit, dan werkt de pin niet.

Een pin als uitgang instellen en aansturen (HAL_GPIO)
GPIO_InitTypeDef gpio = {0};
gpio.Pin = GPIO_PIN_13;
gpio.Mode = GPIO_MODE_OUTPUT_PP;
HAL_GPIO_Init(GPIOC, &gpio);

HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);  // PC13: RESET = aan
HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);

De ingebouwde LED (PC13) is omgekeerd bedraad: GPIO_PIN_RESET zet hem aan.

Een knop inlezen met pull-up (HAL_GPIO)
GPIO_InitTypeDef knop = {0};
knop.Pin = GPIO_PIN_10;
knop.Mode = GPIO_MODE_INPUT;
knop.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOB, &knop);

if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_10) == GPIO_PIN_RESET) {
  // ingedrukt
}
Analoog inlezen met de ADC (12-bit)
HAL_ADC_Start(&hadc);
HAL_ADC_PollForConversion(&hadc, 100);
uint32_t waarde = HAL_ADC_GetValue(&hadc);  // 0 t/m 4095

Interfaces (HAL)​

Tekst versturen via UART (HAL_UART)
char tekst[] = "Hallo\r\n";
HAL_UART_Transmit(&huart, (uint8_t *)tekst, 7, 100);
I2C-apparaten zoeken (HAL_I2C)
for (uint8_t adres = 1; adres < 127; adres++) {
  if (HAL_I2C_IsDeviceReady(&hi2c, adres << 1, 2, 10) == HAL_OK) {
    // gevonden op adres
  }
}

Schuif het adres één bit op (adres << 1): HAL verwacht het 8-bits adres.

Een byte sturen via SPI (HAL_SPI)
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);  // CS laag = selecteer
HAL_SPI_Transmit(&hspi, &byte, 1, 100);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);    // CS hoog = klaar
PWM-helderheid aanpassen (HAL timer)
HAL_TIM_PWM_Start(&htim, TIM_CHANNEL_1);
__HAL_TIM_SET_COMPARE(&htim, TIM_CHANNEL_1, 500);  // 0 = uit, period = vol

Onder de motorkap (registers)​

Blink met registers op de Blue Pill (PC13)
#include "stm32f1xx.h"

int main(void) {
  RCC->APB2ENR |= RCC_APB2ENR_IOPCEN;        // klok naar poort C
  GPIOC->CRH &= ~(0xF << ((13 - 8) * 4));    // wis config van PC13
  GPIOC->CRH |=  (0x1 << ((13 - 8) * 4));    // output, 10 MHz

  while (1) {
    GPIOC->ODR ^= (1 << 13);                 // toggle PC13
    for (volatile int i = 0; i < 200000; i++);
  }
}