APPENDIX

SOURCECODE
#include "LCD.c"
#include <stdio.h>
#define TranEna 0x00080000 //P0.16 --> LCD.11 (D4)
#define TranEna_Set() IO0SET |= TranEna
#define TranEna_Clr() IO0CLR |= TranEna
#define DELAY_SEC 7500000
void wait_sec(void);
void TransmitRF (unsigned char);
void Transmit_Dec(unsigned char ch);
void RFDelay (unsigned char);
#define _ADC_H
#define _ADC_H
#define END_0F_CONVERSION_BIT
(1<<31)
#define END_OF_CONVERSION(i)
(i & END_0F_CONVERSION_BIT)
#define ADC_VALUE_MASK
0x03FF
#define ADC_CHANNEL_NUMBER_MASK
0x07
#define CHANNEL_0
#define CHANNEL_1
#define CHANNEL_2
#define CHANNEL_3
#define CHANNEL_4
#define CHANNEL_5
#define CHANNEL_6
#define CHANNEL_7

0
1
2
3
4
5
6
7

/* A/D Control Register */

#define AD0_0
#define AD0_1
#define AD0_2
#define AD0_3
#define AD0_4
#define AD0_5
#define AD0_6
#define AD0_7

0x00000001
0x00000002
0x00000004
0x00000008
0x00000010
0x00000020
0x00000040
0x00000080

#define AD1_0
#define AD1_1
#define AD1_2
#define AD1_3

0x00000001
0x00000002
0x00000004
0x00000008

#define AD1_4
#define AD1_5
#define AD1_6
#define AD1_7

0x00000010
0x00000020
0x00000040
0x00000080

#define CLKDIV_BIT0
(1<<8)
#define CLKDIV_BIT1
(1<<9)
#define CLKDIV_BIT2
(1<<10)
#define CLKDIV_BIT3
(1<<11)
#define CLKDIV_BIT4
(1<<12)
#define CLKDIV_BIT5
(1<<13)
#define CLKDIV_BIT6
(1<<14)
#define CLKDIV_BIT7
(1<<15)
#define BURST
(1<<16)
#define CLKS_BIT0 (1<<17)
#define CLKS_BIT1 (1<<18)
#define CLKS_BIT2 (1<<19)
#define PDN
(1<<21)
#define START_BIT0
(1<<24)
#define START_BIT1
(1<<25)
#define START_BIT2
(1<<26)
#define EDGE
(1<<27)

//to eneble burst mode

/* A/D Global Data Register */

#define OVERRUN
(1L<<30)
#define DONE
(1L<<31)
/* A/D Interrupt Enable Register */
#define ADINTEN0 (1<<0)
#define ADINTEN1 (1<<1)
#define ADINTEN2 (1<<2)
#define ADINTEN3 (1<<3)
#define ADINTEN4 (1<<4)
#define ADINTEN5 (1<<5)
#define ADINTEN6 (1<<6)
#define ADINTEN7 (1<<7)
#define ADGINTEN (1<<8)
#define ADC0 0
#define ADC1 1
#define ADC0CHANNELS 8
#define ADC1CHANNELS 8
#define POWER_DOWN_ADC0() AD0CR &= ~(PDN)
#define POWER_UP_ADC0() AD0CR |= (PDN)
#define POWER_DOWN_ADC1() AD1CR &= ~(PDN)
#define POWER_UP_ADC1() AD1CR |= (PDN)

//TN_EVENT EVT_ADC0;
//TN_EVENT EVT_ADC1;
void adc0_isr(void);
void adc1_isr(void);
void init_adc0( void );
void init_adc1( void );
unsigned short adc_read(unsigned char adc_num, unsigned char ch);
#endif
void READSENSOR_DATA(void);
void process_adc(void);
void init_adc0(void);
void init_adc1(void);
unsigned short adc_read(unsigned char adc_num, unsigned char ch);
////////////////////////////////////////////////////////////////////////////////////////////
#define _DONE_BIT 0X80000000
int adc_val,adc_val1,cmp;

void Enable_Uart_Intrpt(void);
void init_serial (void);
void UART0ISR (void) __irq ;
unsigned char a[100]; //used for UART0
unsigned char ut0=0;
unsigned char temp;
char uart0_buf[];
void send_bcd(int value);
void ascii(unsigned int data);
void delay(void);
void delay_ms1(unsigned long int);
void del_1ms
(void);
void del_30ms
(void);
void del_1s
(void);
void del_3ms
(void);

//30 milli second delay

//delay of 1 second
//delay of 3 milli seconds

void Send_Dec(unsigned int ch);

int Send_Data (int ch);
void Send_String(char* string, unsigned char no_of_bytes);
void sendString(unsigned char *str);
void sendsms(unsigned int S1, unsigned int S2,unsigned int S3,unsigned int S4);
void putchar0 (int);

void print_uart0(void);
void Enter(void);
void displaydata(void);
unsigned short X, Y, Z, W;
unsigned char a[]={"Design of ARM Based Embedded Ethernet Interface"};
unsigned char a1[]={"
\r\n************************************************** \r\n"}; //60
unsigned char a8[]={" \r\n-------------------------------------------------- \r\n"}; //60
unsigned char a2[]={" \r\n Design of ARM-Based \r\n"}; //34
unsigned char a3[]={" \r\n As per MTech cource curriculam \r\n"}; //41
unsigned char a4[]={" \r\n Deveoloped by hemanth \r\n"}; // 31
unsigned char a5[]={" \r\n Embedded Ethernet Interface \r\n"};
// 38
unsigned char a6[]={" \r\n Rmc Engineering College \r\n"}; //38
unsigned char b[]={"Usg Ethernet LAN \r\n"};
#define
#define
#define
#define

D1
D2
D3
D4

0x00000100
0x00000200
0x00000400
0x00000800

// P0.16(0000 0000 0000 000x 0000 0000 0000 0000)

// P0.17(0000 0000 0000 00x0 0000 0000 0000 0000)
// P0.18(0000 0000 0000 0x00 0000 0000 0000 0000)
// P0.19(0000 0000 0000 x000 0000 0000 0000 0000)

#define DEVALL D1|D2|D3|D4

///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
unsigned short L1, L2, L3, L4;
L1=200;
L2=35;
L3=150;
L4=120;
PINSEL0 = 0X00000000;
IO0DIR = 0X0000FF00;
delay_ms(100);
IO0SET = DEVALL;
delay_ms(100000000);
IO0CLR = DEVALL;
delay_ms(100);
init_serial();
delay_ms(100);
init_lcd();
delay_ms(1000);
display_lcd(" ARM+SEN+LAN ");

//

display_lcd(" PROGRAM ");

delay_ms(1000);
displaydata();
cmd_lcd(0x01);
while(1)
{
//
display_lcd("ETHERNET TEST ");
// display_lcd(" PROGRAM ");
delay_ms(1000);
cmd_lcd(0x01);
READSENSOR_DATA();

if(X<L1)
{
cmd_lcd(0x01);
cmd_lcd(0x84);
display_lcd("LIGHT NOT");
cmd_lcd(0xC2);
display_lcd("AVAILABLE");
delay_ms(100000);
cmd_lcd(0x01);
display_lcd("LIGHT 1 ON ");
IO0SET = D1;
delay_ms(50000000);
}
else
{
cmd_lcd(0x01);
cmd_lcd(0x84);
display_lcd("LIGHT");
cmd_lcd(0xC2);
display_lcd("AVAILABLE");
delay_ms(100000);
cmd_lcd(0x01);
display_lcd("LIGHT 1 OFF ");
IO0CLR = D1;
delay_ms(5000000);
}
delay_ms(100000000);
if(Y>L2)

{
cmd_lcd(0x01);
cmd_lcd(0x80);
display_lcd("HIGH TEMPERATURE");
cmd_lcd(0xC2);
display_lcd("DETECTED");
delay_ms(100000);
cmd_lcd(0x01);
cmd_lcd(0x82);
display_lcd("FAN 2 ON ");
IO0SET=D2;
delay_ms(50000000);
}
else
{
cmd_lcd(0x01);
cmd_lcd(0x84);
display_lcd("NORMAL TEMPERATURE");
cmd_lcd(0xC2);
display_lcd("DETECTED");
delay_ms(100000);
cmd_lcd(0x01);
cmd_lcd(0x82);
display_lcd("FAN 2 OFF ");
IO0CLR=D2;
delay_ms(5000000);
}
delay_ms(100000000);
if(Z>L3)
{
cmd_lcd(0x01);
cmd_lcd(0x84);
display_lcd("HUMIDITY");
cmd_lcd(0xC2);
display_lcd("IS NORMAL");
delay_ms(100000);
cmd_lcd(0x01);
display_lcd("DEVICE 3 ON ");
IO0SET=D3;
delay_ms(5000000);
}
else
{

cmd_lcd(0x01);
cmd_lcd(0x84);
display_lcd("NORMAL HUMIDITY");
cmd_lcd(0xC2);
display_lcd("DETECTED");
delay_ms(100000);
cmd_lcd(0x01);
cmd_lcd(0x81);
display_lcd("DEVICE 3 OFF ");
IO0CLR=D3;
delay_ms(5000000);
}

delay_ms(100000000);
if(W>L4)
{
cmd_lcd(0x01);
cmd_lcd(0x84);
display_lcd("SMOKE");
cmd_lcd(0xC2);
display_lcd("DETECTED");
delay_ms(100000);
cmd_lcd(0x01);
cmd_lcd(0x82);
display_lcd("ALARM 4 ON ");
IO0SET=D4;
delay_ms(5000000);
}
else
{
cmd_lcd(0x01);
cmd_lcd(0x84);
display_lcd("NO SMOKE");
cmd_lcd(0xC3);
display_lcd("DETECTED");
delay_ms(100000);

//

}
delay_ms(500000);

cmd_lcd(0x01);
display_lcd("ALARM 4 OFF ");
IO0CLR=D4;
delay_ms(5000000);

cmd_lcd(0x01);
delay_ms(500000);
init_serial();

sendsms(X,Y,Z,W); ////// VALUES N SENDING

delay_ms(200000);
continue;
}
}
//////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
void Enter(void)
{
U0THR='\r';
while(!(U0LSR&0X20));
U0THR='\n';
while(!(U0LSR&0X20));
}
void displaydata(void)
{
unsigned char i;
//title 1line
for(i=0;i<13;i++)
{
write_lcd(a[i]);
}
cmd_lcd(0xc0); // title 2nd line
for(i=0;i<16;i++)
{
write_lcd(b[i]);
}
delay_ms(100);
//for(i=0;i<50;i++)
for(i=0;a[i]!='\0';i++)
{
U0THR=a[i];
while(!(U0LSR&0X20));
delay_ms(500);
}

//

for(i=0;i<50;i++)
for(i=0;a1[i]!='\0';i++)
{
U0THR=a1[i];
while(!(U0LSR&0X20));
delay_ms(500);
}

//

for(i=0;i<50;i++)
for(i=0;a8[i]!='\0';i++)
{
U0THR=a8[i];
while(!(U0LSR&0X20));
delay_ms(500);
}

//

for(i=0;i<50;i++)
for(i=0;a2[i]!='\0';i++)
{
U0THR=a2[i];
while(!(U0LSR&0X20));
delay_ms(500);
}
//
for(i=0;i<50;i++)
for(i=0;a3[i]!='\0';i++)
{
U0THR=a3[i];
while(!(U0LSR&0X20));
delay_ms(500);
}

//
for(i=0;i<50;i++)
for(i=0;a4[i]!='\0';i++)
{
U0THR=a4[i];
while(!(U0LSR&0X20));
delay_ms(500);
}
//
for(i=0;i<50;i++)
for(i=0;a5[i]!='\0';i++)
{
U0THR=a5[i];
while(!(U0LSR&0X20));
delay_ms(500);
}
//

for(i=0;i<50;i++)

for(i=0;a6[i]!='\0';i++)
{
U0THR=a6[i];
while(!(U0LSR&0X20));
delay_ms(500);
}
//for(i=0;i<50;i++)
for(i=0;b[i]!='\0';i++)
{
U0THR=b[i];
while(!(U0LSR&0X20));
delay_ms(500);
}
//
for(i=0;i<50;i++)
for(i=0;a8 [i]!='\0';i++)
{
U0THR=a8[i];
while(!(U0LSR&0X20));
delay_ms(500);
}

Enter();
Enter();
}
///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
void sendsms(unsigned int S1, unsigned int S2,unsigned int S3,unsigned int S4)
{
delay_ms(10000);
cmd_lcd(0x01);
display_lcd("DATA SENDING...");
delay_ms(5000);
sendString("\r\n");
delay_ms(5000);
sendString("***********************************************");
sendString("\r\n");
sendString("\r\n");
delay_ms(50000);
sendString("SENSOR VAL RECEIVING..");
delay_ms(100000);

sendString("\r\n");
sendString("\r\n");
delay_ms(100000);
sendString("LDR SenSor VAL :");
Send_Dec(S1);
delay_ms(1000000);
sendString("\r\n");
delay_ms(1000000);

delay_ms(1000000);
sendString("\r\n");
delay_ms(1000000);
sendString("TEMPERATURE VAL :");
Send_Dec(S2);
delay_ms(1000000);
sendString("\r\n");
delay_ms(1000000);

delay_ms(1000000);
sendString("\r\n");
delay_ms(1000000);
sendString("HUMIDITY VAL :");
Send_Dec(S3);
delay_ms(1000000);
sendString("\r\n");
delay_ms(1000000);

delay_ms(1000000);
sendString("\r\n");
delay_ms(1000000);
sendString("SMOKE VALUE :");
Send_Dec(S4);
delay_ms(1000000);
sendString("\r\n");
sendString("\r\n");
delay_ms(1000000);
delay_ms(50000);
sendString("************************************************");
sendString("\r\n");
sendString("\r\n");
delay_ms(50000);

cmd_lcd(0x01);
display_lcd(" SENSOR VALUES....");
delay_ms(2000);
cmd_lcd(0xC2);
display_lcd("SENDED......");
delay_ms(10000000);
}
////////////////////////////////////////////////////////////////////
void sendString(unsigned char *str)
{
while(*str != '\0')
Send_Data(*str++);
delay_ms(10000);
}
//////////////////////////////////////////////////////////////////////////////////////////////////
void Enable_Uart_Intrpt(void)
{
VICVectCntl0 = 0x00000026;
VICVectAddr0 = (unsigned)UART0ISR;
VICIntEnable = 0x00000040; // Enable UART0 Interrupt
U0IER = 0x03;

// Enable Transmit interrupt and

// Recieve line status

interrupts
//
}

IO1DIR = 0xffffffff;

void init_serial(void)
{
PINSEL0 = 0x00000005; // Enable RxD0 and TxD0
U0LCR = 0x83;
// 8 bits, no Parity, 1 Stop bit
U0DLL = 97;
// 9600 Baud Rate @ 15MHz VPB Clock
U0LCR = 0x03;
// DLAB = 0
U0FCR = 0x01;
// FIFO Enable
}
void UART0ISR (void) __irq
{
while(!(U0LSR & 0x01));//Loop for UART0 RDR(Receive Data
Ready(U0RBR contains valid data))
a[ut0]=U0RBR; //Taking Received value into the array "a" @ location "ut0"

temp=a[ut0]; //Taking Received value into the Variable "temp"

//
U0THR = temp;
Transmit pin"

//Transmitting the Received value into the "UART

write_lcd(temp); //Transmitting the Received value into the "LCD"

/*

if(ut0==15)
cmd_lcd(0xc0);
if(ut0==31)
{ ut0=0;
cmd_lcd(0x01);
}

*/
ut0++;

//incrementing the array

VICVectAddr = 0x00000000; //Dummy write to signal end of interrupt

return;
}

/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
void Send_Dec(unsigned int ch)
{
unsigned char x1,x2,x3,temp;
x1 =ch%10; // first decimal digit
temp=ch/10; //
x2 =temp%10; // second digit
temp=temp/10;
x3 =temp%10; // third digit
x3 =dis[x3];
x2 =dis[x2];
x1 =dis[x1];
Send_Data(x3);
del_1s();
Send_Data(x2);
del_1s();
Send_Data(x1);
del_1s();
}
//////////////////////////////////////////////////////////////////////
int Send_Data(int data)
{
while (!(U0LSR & 0x20));
delay_ms(20000);
U0THR = data;

return (U0THR);
}
void Send_String(char* string, unsigned char no_of_bytes)
{
int i, stringlength = no_of_bytes;
for(i=1; i<=stringlength; i++)
{
Send_Data(*string++);
delay_ms(1000000);
}
}
/********************************************************************
*/
/* Write character to UART0 */
/********************************************************************
*/
void putchar0 (int ch)
{
if (ch == '\n')
{
while (!(U0LSR & 0x20));
// Wait TXD Buffer Empty
U0THR = 0x0D;
// Write CR
}
while (!(U0LSR & 0x20));
// Wait TXD Buffer Empty
U0THR = ch;
// Write Character
}
///////////////////////////////////////////////////////////////////////
/*
void print_uart0(void)
{
while(*p)
{
putchar0(*p);
// Write char to
UART
p++;
delay_ms(10);
}
}
*/
/* delay interrupt routine*/
void delay(void)
{
unsigned int i;
for(i=0;i<=60000;i++);

}
///////////// DELAYS /////////////////////////////////////////////////////////
void del_1ms(void)
{
unsigned char j;
for(j=0;j<100;j++);
}
void del_3ms(void)
{
unsigned char i,j;
for(i=0;i<15;i++)
for(j=0;j<98;j++);
}
void del_30ms(void)
{
unsigned char j;
for(j=0;j<10;j++)
del_3ms();
}
void del_1s(void)
{
unsigned char i;
for(i=0;i < 60;i++)
del_30ms();
}
////////////////////////////////////////////////////////////////////

/********************************************************************
**************************
Function Name :
main()
Description :
Input : Void
*********************************************************************
*************************/
void READSENSOR_DATA(void)
{
PINSEL0=0X00000000;
PINSEL1=0x00000000;
IO0DIR=0x0000FFFF;
IO1DIR = IO1DIR| 0xFF000000;
// Initialize LCD
init_adc0();
delay_ms(500000);
cmd_lcd(0x01);

display_lcd("READING SENSOR ");

delay_ms(500000);
cmd_lcd(0xc0);
display_lcd(" VALUES ");
delay_ms(10000000);
cmd_lcd(0x01);
display_lcd("READING LDR:");
delay_ms(500000);
cmd_lcd(0xc0);
display_lcd(" VALUE ");
delay_ms(10000000);
init_adc0();

//

X = adc_read(0,1);
X= ((5.00*X)/1024)*100;
X = ((5.00*X)/0xff);
X=X+10;
/*
init_adc0();
delay_ms(10000);
X = adc_read(0,1);
X = ((3.3*X)/1024)*100;
X = X - 10;
*/
delay_ms(10000000);
cmd_lcd(0x01);
display_lcd("READING TEMPERATURE");
delay_ms(500000);
cmd_lcd(0xc0);
display_lcd(" VALUE ");
init_adc0();
delay_ms(10000000);
Y = adc_read(0,2);
Y=Y-54;
Y= ((3.3*Y)/1024)*100;

delay_ms(10000000);

cmd_lcd(0x01);
display_lcd("READING HUMIDITY");
delay_ms(500000);
cmd_lcd(0xc0);
display_lcd(" VALUE ");
init_adc0();
delay_ms(10000000);
Z = adc_read(0,3);
Z= ((3.3*Z)/1024)*100;
Z=Z-64;
delay_ms(10000000);
cmd_lcd(0x01);
display_lcd("READING SMOKE");
delay_ms(500000);
cmd_lcd(0xc0);
display_lcd(" VALUE ");

//

init_adc0();
delay_ms(10000000);
W = adc_read(0,4);
W= ((3.3*W)/1024)*100;
W = ((5.00*W)/0xff);
W=W+106;
delay_ms(10000000);
init_adc0();
cmd_lcd(0x01);
display_lcd("LDR VALUE :");
cmd_lcd(0xc0);
display_lcd(" ");
delay_ms(10000000);

Dec(X);
//

send_bcd(X);
delay_ms(5000000);
cmd_lcd(0x01);
display_lcd("TEMPERATURE VALUE:");
cmd_lcd(0xc0);
display_lcd(" ");

delay_ms(5000000);
Dec(Y);
//

send_bcd(Y);
delay_ms(5000000);
cmd_lcd(0x01);
display_lcd("HUMIDITY VALUE :");
delay_ms(5000000);
cmd_lcd(0xc0);
display_lcd(" ");

//

Dec(Z);
send_bcd(Z);
delay_ms(5000000);
delay_ms(50000);
cmd_lcd(0x01);
display_lcd("SMOKE VALUE :");
delay_ms(500000);
cmd_lcd(0xc0);
display_lcd(" ");

//

Dec(W);
send_bcd(W);
delay_ms(5000000);

cmd_lcd(0x01);
delay_ms(500000);
display_lcd("DISPLAY SENSOR");
delay_ms(5000000);
cmd_lcd(0xC0);
display_lcd("VALUES CMPLTD");
delay_ms(500000);
cmd_lcd(0x01);
init_serial();
delay_ms(500);
cmd_lcd(0x01);
}
/********************************************************************
**************************
Function Name :
process_adc()
Description :

Input : Void
Output : Void
Note :
*********************************************************************
*************************/
void process_adc(void)
{
}
/********************************************************************
*************
Function Name :init_adc0()
Description : Initialises the ADC0
Input :
None
Output :
None
*********************************************************************
***********/
void init_adc0(void)
{
PINSEL1 = (PINSEL1 & ~(3 << 28)) | (1 << 28);
PINSEL1 |= 0x15000000;
}
/********************************************************************
*************
Function Name :init_adc1()
Description : Initialises the ADC1
Input :
None
Output :
None
Note :
*********************************************************************
***********/
void init_adc1(void)
{
}

/********************************************************************
*************
Function Name : adc_read()
Description :
Input
: adc number,channel
Output
: 10 bit AD value
Note
:
*********************************************************************
***********/
unsigned short adc_read(unsigned char adc_num, unsigned char ch)
{

unsigned int i=0;

switch(adc_num)
{
case ADC0:
AD0CR = 0x00200D00 | (1<<ch); // select channel
AD0CR |= 0x01000000; // Start A/D Conversion
do
{
i = AD0GDR; // Read A/D Data Register
} while ((i & 0x80000000) == 0); // Wait for end of A/D Conversion
break;
case ADC1:
AD1CR = 0x00200D00 | (1<<ch); // select channel
AD1CR |= 0x01000000; // Start A/D Conversion
do
{
i = AD1GDR; // Read A/D Data Register
} while ((i & 0x80000000) == 0); // Wait for end of A/D Conversion
break;
}
return (i >> 6) & 0x03FF; // bit 6:15 is 10 bit AD value
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
/**********Sending Data to Receiver***************/
void send_bcd(int value)
{
unsigned int d1=0,d2=0,d3=0,d4=0;
while(value>=1000)
{
value=value-1000;
d4++ ;
}
ascii(d4);
while(value>=100)
{
value=value-100;
d3++ ;
}
ascii(d3);

while(value>=10)
{
value=value-10;
d2++ ;
}
ascii(d2);
d1=value;
ascii(d1);
}
void ascii(unsigned int data)
{
data=data+0x30;
write_lcd(data);
delay_ms(500000);
U0THR=data;
while(!(U0LSR&0X20));
}

REFERENCES
Reference books:
Cryptography & Network security by William Stallings, 4th edition, prentice hall of
India
Embedded systems using microcontroller 8051, M.A.mazidi., PHI publications
Embedded C, Dr.K.V.K.K.Prasad, 4th edition. Dream-tech publications
Embedded & Real time control systems, Dr.K.V.K.K.Prasad, 4th edition. Dream-tech
publications

Internet :
www.keil.com
www.wiznet.com
www.wikipedia.org
www.electronics-lab.org