Its 8051 code for heart rate monitor. I found it here: http://www.zembedded.com/heart-rate...rocontroller-at89c51-based-heartbeat-monitor/
I want someone to explain me it in normal language. Please help

#include<at89x52.h> // plz ad the reg51 . h file
#include<string.h> // plz ad the string . h file
//heart beat monitor 8051 based
#define lcdport P2 // chnage it for ur hardware
sbit rw = P3^7; // LCD connection may be different
sbit rs=P3^6; // LCD interface with microcontroller
sbit en=P3^5; // Enable pin of LCD
unsigned char sec,sec100;
unsigned int bt,tick,r,bpm;
void lcdinit();
void lcdcmd(unsigned char);
void lcddata(unsigned char);
void send_string(unsigned char *s);
void msdelay(unsigned int);
void extrint (void) interrupt 0 // external Interrupt to detect the heart pulse
{
bt=tick; // number of ticks are picked
tick=0; // reset for next counting
}
void timer0 (void) interrupt 1 using 1 // Timer 0 for one second time
{
TH0 = 0xdc; //The value is taken for Ssc/100 at crystal 11.0592MHz
sec100++; // It is incremented every Ssc/100 at crystal 11.0592MHz
tick++; // This variable counts the time period of incoming pulse in Sec/100
if(tick>=3500){tick=0;} // tick are limited to less trhan 255 for valid calculation
if(sec100 >=100) // 1 sec = sec100 * 100
{
sec++;
sec100=0;
}
}
void main()
{
P0=0xff;
P1=0xff;
P2=0xff;
P3=0xff;
rw=0;
EA = 1;
TMOD = 0x21;
IT0 = 1;
EX0 = 1;
ET0 = 1;
TR0 = 1;
msdelay(1000);
lcdinit();
msdelay(1000);
send_string("Heart beat ");
msdelay(1500);
msdelay(500);
//delay(15000);
bpm=0;bt=0;
while(1)
{
if(sec >=1)
{
sec=0;
/*
The sampling time is fixed 1 sec.
A variable "tick" is incremented with one tick per 100mSc in the timer 0 interrupt routine.
Each on occurring of external interrupt the value in the "tick" is picked up
and it is set to zero for recounting.
The process continues till next external interrupt.
Formula for calculating beats per minutes (microcontroller based heartbeat monitor ) is
as tick is the time period in Sec/100. so extract the frequency of pulses at external interrupt
Frequency = (1/tick)* 100 i.e pulses /sec
Then
bpm = frequency * 60 for one minutes i.e pulses per minute
in short we can do it as
bpm = 6000/ bt
*/
lcdcmd(0x02);
if(bt >=7){
bpm = 6000/bt; // for valid output bt is limited so that it should be greater than 6
msdelay(500);
send_string("Pulse. ");
lcddata((bpm/100)+0x30);
r=bpm%100;
lcddata((r/10)+0x30);
lcddata((r%10)+0x30);
send_string(" bpm ");
}
else {
send_string("out of range");} // otherwise bpm will be shown zero, if limit does not fit for your project you can change it.
}
}
}
void lcdinit()
{
msdelay(100);
lcdcmd(0x01);
msdelay(500);
lcdcmd(0x38);
msdelay(500);
lcdcmd(0x38);
msdelay(500);
lcdcmd(0x38);
msdelay(500);
lcdcmd(0x06);
msdelay(500);
lcdcmd(0x0c);
msdelay(500);
lcdcmd(0x03);
msdelay(500);
msdelay(500);
}
void lcdcmd(unsigned char value)
{
rs=0;
lcdport=value;
msdelay(100);
en=1;
msdelay(100);
en=0;
msdelay(100);
rs=1;
}
void lcddata(unsigned char value)
//heart beat monitoring system using microcontroller
{
rs=1;
lcdport=value;
msdelay(10);
en=1;
msdelay(100);
en=0;
rs=0;
}
void msdelay(unsigned int i)
{
//unsigned int i;
while(i --);
}
void send_string(unsigned char *s)
{
unsigned char l,i;
l = strlen(s); // get the length of string
for(i=1;i <=l;i++)
{
lcddata(*s); // write every char one by one
s++;
}
}

 

So you find a program off the Internet and you want to learn what it does or how it does what it is supposed to do.

That is a terrible way to learn programming.

A better way is to write code yourself. Start with something simple such as making an LED flash on and off.

 

Timer 0 is counting basic time units of the processors oscillator frequency.
The external interrupt causes the accumulated number of ticks to be evaluated and reset for the next interval.
The main program interprets the number and formats it for the LCD display.

Reading other people's code can be valuable as long as it is known to be "good code". Reading other people's bad code can be worst thing you could do. You will pick up their bad habits.

 

I haven't written any MCU code in C (all in assembly, to date), but there are things in this code that don't seem to make sense.

The statements:

sbit rw = P3^7; // LCD connection may be different
sbit rs=P3^6; // LCD interface with microcontroller
sbit en=P3^5; // Enable pin of LCD

Presumably P3 is a constant declared in one of the header files. Okay.

But then how does XORing P3 with 5, for instance, set the variable en to something related to the enable pin of the LCD?

And en is just a variable and every place it is used it either has 0 or 1 written to it, so whatever P3^5 is intended to do is irrelevant because it is never used.

This is C, right?

 

It is not standard C. It is a C variant specifically for the bit addressable functions in the 8051 microcontroller.

sbit is a decalration that declares a bit address. P3^7 refers to bit 7 of Port3. Similarly with the other two declarations. The code generator in the compiler will use bit manipulation instructions whenever the identifiers rw, rs, or en appear in an expression. This syntax predated the later variant that used a dot to separate the register name from the bit number. The IAR compiler for example would use P3.7 to indicate the same bit. The original C standard did not cover bit addressing except in terms of register operations on larger quantities.

Example

#define MYBIT (1<<3)
unsigned int flag ;
    flag &= ~MYBIT  ;  //clear MYBIT in flag
    flag |= MYBIT ;  //set MYBIT in flag

 

Thanks.

So it's a non-standard variant compiler that is overloading the assignment operator in both the variable declaration and expression evaluation?

To the TS: You can see that it might be valuable to indicate what language and what compiler the code you post is associated with.

 

I think that is an accurate characterization of what is happening. I don't think any of the followup standards for C have tackled the bit addressing question either.
C89 talks about bitfields as a variation on unsigned, but it is not quite the same thing as addressable bits in RAM or registers of a microcontroller. That is why C for those devices has to be an extended version.