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() {
}
void loop() {
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(4, INPUT);
}
void loop() {
for (int x=0; x < 1000; x++) { // wait for a secoond
delay(1);
}
digitalWrite(13, LOW); // set the LED off
for (int x=0; x < 1000; x++) { // wait for a secoond
delay(1);
}
}

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(4, INPUT);
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();
}
}

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 (20)

Recently uploaded (20)

An Introduction to Microcontrollers part 2