demo of the project
-> simulator
-> problem statement
1. select the washing program
2. select the water level
3. start
4. function selected and time
machine fan rotation,
automatic gate opening system( pure hardware)
1.sensor -> ir
uc -> hardware software
2.compator
3. relay ->
4. timers
design ->
stand alone
take decision on its own
example tesla cars :-
location airport , road construction
reroute
real time;- ES which will complete the task within deadline
ex ;-missile system , air bag
networked
ES which can connect to other devices and able transmit data and recive
mobile
ES which you carry it from one place to another
hybrid ES
processing unit
up , uc , soc
memory
RAm: random acess memory
-> write/read = infinite times
volatile memory -> requires powersupply to retain the data
if there is no power supply the data will be erased
sram:- constant power to retain the data , cost more
dram:- more power
constant power supply + extra power supply to refresh the data
Rom:read only memory
-> write =one time read -> infinite times
non volatile memory
-> doest require the power supply to retain the data
rom
OTP/PROM ;-one time programable memory ,
W -> 1 , r -> infinite
ex: micro oven, toys -> mobile
EPROM/UVROM;- uv rays
R-> infinite , W-> n times
ex : Rand D
memory
masked ROM;-
data stored below this memory will never get currpted
ex man fact date , chip id
taken selfie :-
ram ->
deleted
rom-> H ROM
RAM
i cannot delete
W-> inifite
non volatile
hybrid memories
EEPROM -
-non volatile memory
-persistant
-> r - infinite w -> 1 million times
byte acessable
size -> 256 bytes to 128 KB.
ex -> number or count or any state
Flash memories
Flash memories:-
nor-> byte accessable
non volatile memory
r- infinite w ->n
xip -> execute in place -> need not load code in ram for execution
store code in micro controllers
nand-> bolck acess able -> store data in blocks 256 bytes , 512 bytes
non volatile
r- infinite w ->n
less reliable
nand -> data is stored
ex: sd cards , pendrives
overview about the tools
simple program
switches ->
clcd ->
timer ->
buzzer->
fan/ motor ->
refer requirement document and start implementing the requirements one by one
host :- system which is used to develop the target
laptop
BOARD: picsimlab simulator pic genious board
pic16f877a
code execute in the board
target:- a system which is being developed
C programing
wrote ->laptop
->execute laptop
uc
development ->laptop -> c code = execute able file
being developed = board ->
host:
sytem which is used to develop the target
laptop
target :
system which is being developed for particular purpose
simulator -> picsimlab
board :- pic genious
controller : pic16f877a
First code :- simple pheripheral available board
less complication ,less overhead
code is simple
-> hardware is working or not
-> tools properly installed
-> conection host and target eshtablished or not
what pheripherals available on the board
RB
FB
OFF
condtion
ON
interfacing an LED to uC pin LED 2. +5v
1 ON
1
0 OFF
uC pin
vdd 1
pin 0 +
uC -
gnd
pin LED
pin -> 1 +5v vdd 1 OFF
0 gnd 0 ON
sourcing circuit sinking circuit
WAP to blink the LED? main()
-> 16 LEDs {
where the LEDS are conected? int led;
how they are connected?
led = 1;
led = 0;
i/0 ports
uC
external pheripheral to your micro controller
fixed number of I/O ports
pic16f877a
architecture of the uc
data sheet -> technical document information of the controller
pic16f877a -> 5 ports
33i/o pin
led-> schematic -> blue print of the board
PORTD , PORTB
sourcing
1 -> ON , 0 -> OFF
biderection out put / input port
PORTB -> 8 bit wide
PORTB -> leds RB7 RB6 .......... RB0
data sheet -> DDR
TRISB -> 8 bit
TRISB7 6 ....................... 0
TRSIB = 0000 0000
portb pin will be output pin
TRISB = 1111 1111
portb pin will be input pin
PORTB -> 0x06
<xc.h>
TRISB -> 0x86
include this header
TRISB
-> 0x00
unsigned char * portb = 0x06;
WAP to blink the LEDs connected to PORTB
8 leds -> poRTB , sourcing circuit
PORTB
DDR -> TRISB = 0x00 -> output pins
0xFF -> input pins
pointers -> <xc.h>
step 1
config the led port as output port
step2
turn on the leds
delay
turn off the leds
delay
goto step2
led :-
mc -> 5 ports
led -> PORTB , sourcing circuit fashion
DDR -> TRISB
WAP to toogle the LED
#include <xc.h>
#pragma config WDTE = OFF
void init_config(void)
xc.h ->
{
// one time initialisation code
}
watch dog timer
void main(void)
reseting the uc for configured time
{
init_config();
while (1)
{
//logic
}
} WDT
uc 1 hr
1 day
1 week
pheripherals :-
*lcd
*switches
*buzzer
*fan
*timer
Switches: tactile switches
interfaced with micro controller
detecte the switch pressed on the mic
pull up circuit pull down circuit
vdd vdd
pin R2> 10r1
uc uc pin
sw R1
R2
gnd
gnd
pin sw pin SW
0 prssed 0 R
1 released 1 P
detection type
level triggering
vdd edge trigerring 5v
0v
vol button 1
pin -> vol++ continous action
CRo sw level trig 0
vol++ vol++
gnd power button one time
->on /off
off ON off
edge edge
level : to trigger the task based on the value
edge : to triggger the task based on the change in the value
where the switches are connected and how they are connnected
6 switches -> rbo to rb5 , pull up circuit
WAp to toogle the led when sw is preesed
led -> rd0 , sw -> rb0
toogle as long as switch is pressed Rb0 = 0
PORTB
TRISB = RB0 = input
TRISB0 = 1;
PORTD =
TRISD = 0x00
level triggering
once = 1 once =1
edge trigger
one time action
once = 1
change state led one once =0 one
once =0 time time
led = on led = off
while (1)
{
/*check if the switch is pressed*/
if(RB0 == 0 && once )
{
PORTD = ~PORTD;
once = 0;
}
if(RB0 == 1)
{
once = 1;
}
Off
ON
}
voidinit_digital_keypad(void)
{ PORTB = RB7 6 5 4 3 2 1 0
/*to config RB0 to RB5 as input pins*/ TRISB = x x x x x x x x
KEYPAD_PORT_DDR = TRISB| 0x3F => x x 1 1 1 1 1 1
}
TRISB = x x x x x x x x
|0 0 11 1111
void init_config(void) = x x 11 1111
{ -> 0x3F
/*config led port as output port PORTD*/ TRISB = TRISB | 0x3F
TRISD = 0x00;
PORTD = 0x00;
TRISB = 00 11 1111
/*config RB0 to RB5 pin as input pin*/ RB7 , RB6
init_digital_keypad();
#define LEVEL 0
#define STATE 1
void main(void)
{
unsigned char once = 1, key ;
init_config();
while (1)
{
/*check if the switch is pressed*/
key = read_switches(STATE) SW1
if(key == SWITCH1)
{
PORTD = ~PORTD;
for(unsigned int wait = 50000; wait--;);
}
}
}
SWITCHES
#define ALL_RELESED 0x3F
#define SWiTCH1 0x3E PORTB = rb7 6 5 4 3 2 1 0 PORTB&0x3F
#define SWITCH2 0x3D & = x x 1 1 1 1 1 1
#define KEYPAD_PORT PORTB 0 0 1 1 1 1 1 1
#define KEYPAD_PORT_DDR TRISB => 0 0 1 1 1 1 1 1
#define INPUT_LINES 0x3F no swit = x x 1 1 1 1 1 1 0x3F
switch1 = x x 1 1 1 1 1 0 0x3E
unsigned char read_switches(detection_type) switch2 = x x 1 1 1 1 0 1 0x3D
{
static unsinged char once = 1;
if (detection_type == LEVEL)
{
return (KEYPAD_PORT & INPUT_LINES);
}
if (detection_type == STATE)
{ /* if any switch is pressed*/
if((KEYPAD_PORT & INPUT_LINES) != ALL_RELEASED && once )
{
once = 0;
return (PORTB & 0x3F)
}
if(PORTB &0x3F== ALL_RELEASED)
{
once = 1;
}
return ALL_RELESED;
}
}
A_R,A_R once=1
AR AR
SW1 AR AR AR SW1
once=0 once =0
project
main.c
main.h
digital_keypad.h
switches
digital_keypad.c
init_digital_keypad()
read_digital_keypad()
sw 2 =
toogle alternate led
portb = 0xaa 1010 1010
portb = 0x55 0101 0101
main() read_digital_kepad->
{ level->
init_config(); as long as switch is prresed
while(1) which switch is preesed
{ all_realsed
key= read_digital_keypad(LEVEL)
if(key == SWITCH1) state:-
{ return one time
code which switch is pressed
}
if(key == SWITCH2) example
{ vol++ -> level
code entering the password -> state
}
}
SW1
pattern1
alternate leds
PORTB = 0 1 0 1 0 1 0 1 -> 0x55
sw2
= 1 0 1 0 1 0 1 0 -> 0xAA
toogle the nibble
PORTB = 1 1 1 1 0 0 0 0 -> 0xF0
4 led on
0 0 0 0 1 1 1 1 -> 0x0F
4 led off
pORTB = 1 1 1 1 1 1 1 1 -> 0xFF
sw3
0 0 0 0 0 0 0 0 -> 0x00
toogle al the leds
0x55 - 0101 0101
~ 0xAA- 1010 1010
while(1)
{
// application code
}
LED->
SWITCHES -> switches for washing machine
timer -> interrupt source
interrupt ->
high priority execution
timers ->
external/ internal -> set interrupt flag
main()
{ Interrupt handler
isr()
while(1)
{
{
I1
clear the int flag
I2
I1 was being executed
}
I3
->complete the i1 instruction
->execute the isR()
}
-> i2
}
interrupt handlers pic isr()-> all interrupt source
-> IVT interrupt service routine()
timers 0x11 {
external 0x22
.
. }
.
-> ISR
while() exrternal / internal -> setting int_flag
{
ISR()
{
I1->requested 1. i1 should be completed
I2 2. PC -> stack
3. PC -> *(isr)
int_flag =0;
}
}
case1: I1
PC -> *(I2)
case2: I1
PC -> *(isr)
*(I2)saved on stack registers
interrupt latency :- delay in execution of the isr.
ISR will not be execute as soonas interrupt is requested
delay
-> completeion I1 dealy
-> PC
-> priorty execution
-> setting int flag
-> isr() function wiil be called
-> clear int_flag
timers: default pherpheral uC
calculate or tack the time resolution : width of the timer register
ex : 8 bit , 16 bit, 32
timer TMR0 tick : UP tick , down tick
1
timer regiters Quantum : time taken by one tick
255 0
2
sytem clock setting-> F =
3 8 bit 1 tick -> 4 clk pulse -> 4 * t
4
0 time -> 4 * 1/f
1 Q -> 4 * 1/ 20 * 1o^6
2 up tick = 0.2 us -> 200ns
3
. 1 tick -> 200ns
. 255 2 tick -> 400ns
down tick
start timer time = no of ticks * Q
start time= 255 * 200ns
counting ticking 8 bit
timer_int_flag
0
overflow-> 0
255 request interrupt-> isr()
main()
{
start timer
while(1) isr() count = 1
{ {
if (timer_int_flag)
++count;
} timer_int_flag = 0;
} }
time taken by one overrflow timer 8 bit
256
= 256 *200ns
= 51200ns -> 51.2us 255 2 1 0
time taken count overflow
time = count *time taken 1 ov time = count * no of tick in ov * Q * P
time= count * no of tick in ov * Q
= 2 * 256 *200ns -> 102.4us
while() isr()
scaling : way to increase the time to go to isr
{ {
51.2us
prescaling: Q is scaled
1:1 Q= 1IC-> 200ns ov-> 51.2us 102.4us
1:2 Q= 2IC ->400ns ov -> 102.4us }
}
postscaling: after how many ov isr()
1:1 1ov-> 51.2us 1 ov isr () will be called
1:2 51.2us 2 ov isr() will be called
1:4 4 ov isr()
R = 8 bit -> 256
R = 16 -> 65536
time = count * no of tick in ov * Q * P
count = time
P* Q * R
timer reg-> R/W
example : calculate count for the folowing
P 1:1 , Q = 200ns , R -> 8 bit = 256 , time = 1 sec
6 0
count = 1sec/ 1 * 200* 10^ -9 s * 250 255 1
count = 19531 .25 250
count = 20000
timer -> over flow ->int
timer reg
how to get 250 ticks
250
2 1 0
6
255
250
250 ticks
comparator reg
timer
resolution count = time / p*q*r
tick
q
ov
int
WAP to toggle the led for every one second using timers
use timer2
tmr2
resolution = 8 bit
TMR2 = timer register
PR2 => how tick for o.v
timer2 int flag pr2
-> TMR2IF = 1
intcon
-> gie -
-> peie -
10 min to be full
5 min->
