An Introduction to Microcontrollers part 2

INTRODUCTION TO MICRO- CONTROLLERS PART 2 PREPARED BY BASEM IBRAHEEM MODIFIED BY KHALED M. IBRAHEEM

ADVANCED MICROCONTROLLER PROGRAMMING ARDUINO PLATFORM PROGRAMMING

AGENDA • DELAY !!! • IDLE STATE • INTERRUPTS ARE NOT AVAILABLE • BLINKING WITHOUT DELAY • INTERRUPT • MILLIS

THE PROBLEM • Assume that: • We have a fire fighting robot. It keep moving searching for fire. Digital fire detector sensor is used. It is connected to pin 4. If the sensor detected fire, it sends HIGH for half a second then return LOW. • This robot has a fire fighting tool to vanquish fire (bump/ fan …etc.) • This tool is connected to pin 12 and is activated by sending HIGH. • The robot has a blinking led that blinks every second.

BASIC DELAY void setup() { pinMode(13, OUTPUT); pinMode(4, INPUT); pinMode(12, OUTPUT);} void loop() { Alarm = digitalRead (4); if (Alarm == HIGH) // If there is fire digitalWrite(12, HIGH); // set the Fire Fighter on digitalWrite(13, HIGH); // set the LED on delay(1000); // wait for a second digitalWrite(13, LOW); // set the LED off delay(1000); // wait for a second }

void setup() { pinMode(13, OUTPUT); } void loop() { digitalWrite(13, HIGH); // set the LED on for (int x=0; x < 1000; x++) { // Wait for 1 second delay(1); } digitalWrite(13, LOW); // set the LED on for (int x=0; x < 1000; x++) { // Wait for 1 second delay(1); } }

void setup() { pinMode(13, OUTPUT); pinMode(4, INPUT); pinMode(12, OUTPUT);} } void loop() { digitalWrite(13, HIGH); // set the LED on for (int x=0; x < 1000; x++) { // wait for a secoond delay(1); Alarm = digitalRead (4); if (Alarm == HIGH) // If there is fire digitalWrite(12, HIGH); // set the Fire Fighter on } digitalWrite(13, LOW); // set the LED off for (int x=0; x < 1000; x++) { // wait for a secoond delay(1); Alarm = digitalRead (4); if (Alarm == HIGH) // If there is fire digitalWrite(12, HIGH); // set the Fire Fighter on } }

unsigned long interval=1000; // the time we need to wait unsigned long previousMillis=0; // millis() returns an unsigned long. int Alarm; bool ledState = false; // state variable for the LED void setup() { pinMode(13, OUTPUT); pinMode(4, INPUT); pinMode(12, OUTPUT);} digitalWrite(13, ledState); } void loop() { unsigned long currentMillis = millis(); // grab current time // check if "interval" time has passed (1000 milliseconds) if ((unsigned long)(currentMillis - previousMillis) >= interval) { ledState = !ledState; // "toggles" the state digitalWrite(13, ledState); // sets the LED based on ledState // save the "current" time previousMillis = millis(); } Alarm = digitalRead (4); if (Alarm == HIGH) // If there is fire digitalWrite(12, HIGH); // set the Fire Fighter on }

const byte ledPin = 13; // LED const byte FanPin = 12; // Fan const byte interruptPin = 2;// Sensor input unsigned long interval=1000; // the time we need to wait unsigned long previousMillis=0; // millis() returns an unsigned long. bool ledState = false; // state variable for the LED void setup() { pinMode(FanPin, OUTPUT); pinMode(ledPin, OUTPUT); pinMode(interruptPin, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(interruptPin), ActivateFan, RISING); //LOW - CHANGE - RISING - FALLING - HIGH for Due, Zero //and MKR1000 boards } void loop() { unsigned long currentMillis = millis(); // grab current time // check if "interval" time has passed (1000 milliseconds) if ((unsigned long)(currentMillis - previousMillis) >= interval) { ledState = !ledState; // "toggles" the state digitalWrite(ledPin, ledState); // sets the LED based on ledState // save the "current" time previousMillis = millis(); }} void ActivateFan() { digitalWrite(FanPin, HIGH); // set the Fire Fighter on

REMEMBERING CHANGES • THE SUPPORTED MICRO-CONTROLLERS ON THE UNO ARDUINO BOARDS HAVE DIFFERENT AMOUNTS OF EEPROM: 1024 BYTES ON THE ATMEGA328 • EPROM IS MEMORY WHOSE VALUES ARE KEPT WHEN THE BOARD IS TURNED OFF (LIKE A TINY HARD DRIVE). • YOU CAN READ , WRITE , CLEAR , UPDATE • EEPROM UPDATE: STORES VALUES READ FROM A0 INTO EEPROM, WRITING THE VALUE ONLY IF DIFFERENT, TO INCREASE EEPROM LIFE.

#include <EEPROM.h> int addr = 0; void setup() {} void loop() { int val = analogRead(0) / 4; EPROM.write(addr, val); addr = addr + 1; if (addr == EEPROM.length()) { addr = 0; } delay(100); } REMEMBERING CHANGES

REMEMBERING CHANGES #include <EEPROM.h> int a = 0; int value; void setup(){} void loop() { value = EEPROM.read(a); a = a + 1; if (a == 512) a = 0; delay(500); } read() Description Reads a byte from the EEPROM. Locations that have never been written to have the value of 255. Syntax EEPROM.read(address) Parameters address: the location to read from, starting from 0 (int) Returns the value stored in that location (byte)

MEMORIES OF AVR / ARDUINO • MEMORY : THE FIRST THING TO GO • THERE ARE THREE POOLS OF MEMORY IN THE MICROCONTROLLER USED ON AVR- BASED ARDUINO BOARDS : • FLASH MEMORY (PROGRAM SPACE), IS WHERE THE ARDUINO SKETCH IS STORED. • SRAM (STATIC RANDOM ACCESS MEMORY) IS WHERE THE SKETCH CREATES AND MANIPULATES VARIABLES WHEN IT RUNS. • EEPROM IS MEMORY SPACE THAT PROGRAMMERS CAN USE TO STORE LONG-TERM INFORMATION. • ATMEGA328 CHIP • FLASH 32K BYTES (OF WHICH 0.5 K IS USED FOR THE BOOTLOADER) • SRAM 2K BYTES • EEPROM 1K BYTE

MY PROGRAM WAS FINE UNTIL : • "INCLUDED ONE MORE LIBRARY" • "ADDED SOME MORE LED PIXELS" • "OPENED A FILE ON THE SD CARD" • "INITIALIZED A GRAPHICAL DISPLAY" • "MERGED IN ANOTHER SKETCH" • "ADDED A NEW FUNCTION

MEMORY ARCHITECTURES • VON NEUMANN VS HARVARD’S • SINGLE DATA/PROGRAM PATH • SEPARATE PATHS (HARVARD) • FLEXIBILITY VS PERFORMANCE

PC CPU (INTEL / CYRIX / AMD) • HYBRID ARCHITECTURE • CACHE MODELS INCLUDE SEPARATE BUSSES FOR DATA CACHE AND INSTRUCTION CACHE. • MEMORY (RAM) MODEL INCLUDE VON-NEUMANN FLEXIBLE ARCHITECTURE. • COST !

AVR ARCHITECTURE FOR ATMEGA328P • HARVARD • FLASH FOR SKETCH (PROGRAM) • SRAM FOR DATA • COMPILER AND RUNTIME SYSTEM (ARDUINO BOOT LOADER) WORKS TO HANDLE ALLOCATION AND DEALLOCATION , AS WELL AS TASK SPACE /SEGMENT PROTECTION. (AND SWAPPING IN OTHER OSS)

GETTING INTO MEMORY MANAGEMENT • FLASH 32 KB • SRAM 2 KB • EPROM 1KB • 10,000 TO 100,000 TIMES LESS THAN PC MEMORY

DIFFERENCES Flash SRAM EEPROM Program Data Static Data Reserved Block Constants - Globals – Initial values Byte by Byte operation Static , 10 , 000 write cycles , fused down when written . Volatile and Dynamic Heap : Dynamically allocated data items growing up Stack : function calls and interrupr handler calls growing down Slower than SRAM , with 100,000 write cycles

FREE MEMORY • DISTANCE BETWEEN HEAP AND STACK • DEFRAGMENTATION OF HEAP • FF (FIRST FIT) ALGORITHM, WHERE THE LIST IS SCANNED FROM THE BEGINNING FOR THE FIRST “HOLE” THAT IS LARGE ENOUGH. • NF (NEXT FIT) WHERE THE LIST IS SCANNED FROM WHERE THE LAST SEARCH ENDED FOR THE NEXT “HOLE” THAT IS LARGE ENOUGH. • BF (BEST FIT) WHERE THE ENTIRE LIST IS SEARCHED FOR THE HOLE THAT BEST FITS THE NEW DATA. • WF (WORST FIT), WHICH PLACES DATA IN THE LARGEST AVAILABLE “HOLE.” • QF (QUICK FIT) WHERE A LIST IS KEPT OF MEMORY SIZES AND ALLOCATION IS DONE FROM THIS INFORMATION.

MEASURING FREE MEMORY • MIKROC STATISTICS LIBRARY • FREEMEMORY() ROUTINE FOR ARDUINO HTTPS://GITHUB.COM/MPFLAGA/ARDUINO-MEMORYFREE

1- OPTIMIZING FLASH USAGE – APPLICATION CODE • REMOVE DEAD CODE • UNUSED LIBRARIES (JUST COMMENT AND COMPILE) • UNUSED FUNCTIONS • UNUSED VARIABLES • UNREACHABLE CODE • REFACTOR (REPEATED CODE) • ELIMINATE THE BOOTLOADER

2- OPTIMIZING SRAM USAGE • PIXELS 3 BYTES PER PIXEL IN RGB • WOULD YOU RUN A 32X32 PIXEL RGB DISPLAY ON UNO 328P ? • 32*32=1024 • 1024*3 BYTES = 3072 BYTES = 3K • UNO 328P SRAM = 2K • 1 BYTE PER 8 PIXELS IN MONOCHROM • COMMUNICATION BUFFERS

2- OPTIMIZING SRAM USAGE – DATA AND DYNAMIC ALLOCATIONS • REMOVE UNUSED VARIABLES • F() FIXED STRINGS TO POINTERS TO BASE ADDRESS IN FLASH • RESERVE() FOR GROWING STRINGS

CONT. 2- OPTIMIZING SRAM USAGE – DATA AND DYNAMIC ALLOCATIONS • MOVING CONSTANTS TO PROGMEM • REDUCING UNUSED BUFFER SIZES OR DATA TYPES • SERIAL BUFFER SIZE FOR FAST COMMUNICATION 64 BYTES , MAKE IT 32 BYTES • ALLOCATE LOCAL VARIABLES IN A FUNCTION SCOPE TO ENSURE CLEANUP WITH STACK POP. • AVOID DYNAMIC HEAP ALLOCATIONS - THESE CAN QUICKLY FRAGMENT THE LIMITED HEAP-SPACE. • PREFER LOCAL TO GLOBAL ALLOCATION - STACK VARIABLES ONLY EXIST WHILE THEY ARE BEING USED. IF YOU HAVE VARIABLES THAT ONLY ARE USED IN A SMALL SECTION OF YOUR CODE, CONSIDER MAKING THAT CODE INTO A FUNCTION AND DECLARING THE VARIABLES LOCAL TO THE FUNCTION.

MEMORY MANAGEMENT UNIT • MANAGING THE MAPPING BETWEEN LOGICAL (PHYSICAL) MEMORY AND TASK MEMORY REFERENCES. • DETERMINING WHICH PROCESSES TO LOAD INTO THE AVAILABLE MEMORY SPACE. • ALLOCATING AND DEALLOCATING OF MEMORY FOR PROCESSES THAT MAKE UP THE SYSTEM. • SUPPORTING MEMORY ALLOCATION AND DEALLOCATION OF CODE REQUESTS (WITHIN A PROCESS), • SUCH AS THE C LANGUAGE “ALLOC” AND “DEALLOC” FUNCTIONS, OR SPECIFIC BUFFER ALLOCATION AND • DEALLOCATION ROUTINES. • TRACKING THE MEMORY USAGE OF SYSTEM COMPONENTS.

FLASH A/D CONVERTER Vref Vref /2 “00“ “01“ “10“ “11“ Vref /4 3Vref /4 Encoding of voltage intervals h(t) No decoding of h(t) > Vref

RESOLUTION AND SPEED OF FLASH A/D- CONVERTER • PARALLEL COMPARISON WITH REFERENCE VOLTAGE • SPEED: O(1) • HARDWARE COMPLEXITY: O(N) • APPLICATIONS: E.G. IN VIDEO PROCESSING

HIGHER RESOLUTION: SUCCESSIVE APPROXIMATION • KEY IDEA: BINARY SEARCH: • SET MSB='1' • IF TOO LARGE: RESET MSB • SET MSB-1='1' • IF TOO LARGE: RESET MSB-1 Speed: O(log2(n)) Hardware complexity: O(log2(n)) with n= # of distinguished voltage levels; slow, but high precision possible. h(t) w(t) V-

SUCCESSIVE APPROXIMATION (2) 1100 1000 1010 1011 t V Vx V- h(t)

An Introduction to Microcontrollers part 2

More Related Content

Similar to An Introduction to Microcontrollers part 2

Recently uploaded

An Introduction to Microcontrollers part 2