Concurrency in embedded systems Practical approach

Transcription

1 Concurrency in embedded systems Practical approach by Łukasz Pobereżnik

2 Agenda 1. Introduction to concurrency problems 2. Concurrency programming models for microcontrollers a. Pros and cons b. Useful patterns 3. Summary

3 Introduction Wikipedia: In computer science, concurrency is a property of systems in which several computations are executing simultaneously, and potentially interacting with each other.

4 Introduction Embedded systems by design are closely interacting with their physical environment especially robots). Physical environment is by its nature concurrent - multiple processes happen at the same time.

5 Introduction For example in a robot those events can happen at once: collision sensor event PWM motor power increase status packet radio transmission LCD status screen update battery level readout using ADC

6 Introduction Almost all of those events have strict time constraints. Programmer must write code in such way that: it will be able to handle event in timely manner it will be readable to other programmers it will be easily changeable and extendable it will work correctly

7 Programming models 1. Big loop 2. Interrupts only 3. Task switching All of those models can be mixed together but sometimes with bad results.

8 Big loop 1. one central never-ending loop 2. polling pins, ADC, sensors 3. waiting for flags, pin values in while(true) loops

9 Big loop Example Arduino: int led = 13; void setup() { pinmode(led, OUTPUT); void loop() { digitalwrite (led, HIGH); delay(1000); digitalwrite (led, LOW); delay(1000);

10 Big loop Pros: simple readable for simple solutions no stack problems Cons: not for production use unreadable for complicated solutions timing problems difficult access to extra uc features (DMA, timers) lot of global state variables

11 Big Loop Example: Arduino - count button presses int buttonpushcounter = 0; int buttonstate = 0; int lastbuttonstate = 0; void setup() { //... void loop() { buttonstate = digitalread(buttonpin); if (buttonstate!= lastbuttonstate) { if (buttonstate == HIGH) { buttonpushcounter++; Serial.println("on"); Serial.print("number of button pushes: "); Serial.println(buttonPushCounter); else { Serial.println("off"); lastbuttonstate = buttonstate; if (buttonpushcounter % 4 == 0) { digitalwrite(ledpin, HIGH); else { digitalwrite(ledpin, LOW);

12 Big Loop Good practices: Divide main loop into subroutines void setup() { //... void readtemp() void checkmotorrotataion(); void checkdistance(); void loop() { readtemp() checkmotorrotataion(); checkdistance();

13 Big Loop Good practices: Minimize shared global state. In C use static. void checkbuttonstate() { static int lastbuttonstate = 0; int buttonstate = digitalread(buttonpin); if (buttonstate!= lastbuttonstate) { if (buttonstate == HIGH) { buttonpushcounter++; lastbuttonstate = buttonstate;

14 Interrupts only 1. No loop at all (except for(;;;) or while(true)) 2. Use interrupts only 3. For cyclic events use timers 4. Use advantage of uc interrupt system features

15 Interrupts only Pros: fast flexible lightweight Cons: stack problems prioritization less readable control flow

16 Interrupts only void USART1_IRQHandler(void) { if (USART_GetITStatus(USART1, USART_IT_RXNE)!= RESET){ char ch = USART_ReceiveData(USART1); data_received(ch); void EXTI9_5_IRQHandler(void) { EXTI_ClearITPendingBit(EXTI_Line9); if(gpio_readinputdatabit(gpiob, GPIO_Pin_11)) { button_pressed();

17 Interrupts only Useful pattern: State machine

18 Interrupts only Useful pattern: State machine Warning: Code might not as readable as you would expect, bu correctly designed and implemented state machine should help you avoid strange errors.

19 Interrupts only enum State { IDLE, HEATING, MEASURING, State state; int counter = 0; void EXTI9_5_IRQHandler(void) { if(gpio_readinputdatabit(gpiob, GPIO_Pin_11) && state == IDLE ) { state = HEATING; sartheater() starttimer(100); void TIM14_IRQHandler(void) { EXTI_ClearITPendingBit(TIM14_Int); switch(state) { case HEATING: state = MEASURING; starttimer(50); break; case MEASURING: values[counter++] = getadc(0); if(counter > 10) { displayvalue(); state = IDLE; else { starttimer(1);

20 Interrupts only

21 Task switching 1. Each parallel process contained within it s own function/object (thread) 2. Thread switching kernel splitting CPU time into small chunks (~1000 ticks) between tasks 3. Inter task communication (queues, locked memory) 4. Task synchronisation (mutexes, semaphores)

22 Task switching FreeRTOS: void taska (void* pvparameters){ for (;;) { printf("task A\n"); vtaskdelay(500); int main (void) { xtaskcreate( taska, ( signed char * ) "TaskA", configminimal_stack_size, NULL, tskidle_priority, ( xtaskhandle * ) NULL ); xtaskcreate( taskb, ( signed char * ) "TaskB", configminimal_stack_size, NULL, tskidle_priority, ( xtaskhandle * ) NULL ); void taskb (void* pvparameters) { for (;;) { printf("task B\n"); vtaskdelay(1000); vtaskstartscheduler(); for (;;);

23 Task switching Pros: Most elegant and readable Good for production Efficient and fast Modular Cons: Consumes more resources (more advanced hardware required) Requires higher programming skills

24 Task switching Good practice: Avoid business logic inside interrupt handler functions. Instead: Add task to the queue, execute business logic in separate thread.

25 Task switching void ext_interupt_1_handler(){ log::log( Interrupt 1 handler ); radio->send_message(...); fs->append_to_file(...); class ExtInterrupt1Handler : public QueueTask { public: virtual void execute() { log::log( Interrupt 1 handler ); radio->send_message(...); fs->append_to_file(...); void ext_interupt_1_handler(){ queue->add_task(new ExtInterrupt1Handler()); void task_processing_thread() { while(true) { QueueTask* task = queue->get_next_task(); task->execute();

26 Task switching Protect operations on buses (I2C, SPI) using mutexes. Neat trick: scoped lock

27 Task switching class Mutex { public: void lock(); void unlock(); ; class ScopedLock { public: ScopedLock(Mutex* mutex) : mutex_(mutex) { mutex_->lock(); ~ScopedLock() { mutex_->unlock(); Usage: void readtemp() { ScopedLock lock(i2c->mutex()); i2c->start(0x34); i2c->write(0x12); i2c->start(0x35); int val = i2c->read_nack(0x16); i2c->stop(); if (val == 0) { i2c->start(0x34); i2c->write(0x12); i2c->stop();

28 Task switching Good advice: Do not try to implement task switching code for reasons different than educational. For production use out-of-a-box solutions like FreeRTOS or ChibiOS.

29 Therac 25 story Software error that costed lives

30 Therac 25 story Source:

31 Summary There is no universally good method You can mix techniques but you should be careful Some of the tricks are working well with one model, but are terrible in other

32 Summary Used method depends on: Project purpose Educational (for non-professionals) Prototype Production device Project scale Hardware (8-bit/32-bit)