fork download 
  1. #include<pic.h>
  2. __CONFIG(0X3F72);
  3. unsigned int A=0,B=0,C=0,D=0,E=0,F=0,G=0,H=0,I=0,J=0;
  4. unsigned int K=0,L=0,M=0,N=0,O=0,P=0,Q=0,R=0,S=0,K1=0,L1=0,M1=0,N1=0,O1=0;  
  5. unsigned int U=0,V=0,W=0,X=0,Y=0,Z=0;
  6. unsigned char T=0,ser1='R',data_cap1=0,st1=1,n,o,gpsdata[50];
  7. unsigned int  COUNT,CNT,COUNT,COUNT1,VAL8=0,VALA=0,VALB=1,VALC=0;
  8. unsigned int Z,val2,val3,val4,val5,M2,M3;
  9. unsigned int d=0,e=0;
  10.  
  11.  
  12. #define RS RD1
  13. #define RW RD2
  14. #define EN RD3
  15. //***********************************************************************
  16. // KEYPAD PIN DEFINE
  17. //**********************************************************************
  18. #define RESET RB1             //RESET SWITCH
  19. #define SS RB2               //IR SENSOR
  20. #define MOTOR RC0
  21. #define BUZZER RC1
  22.  
  23. #define ir1 RB5
  24. #define ir2 RB6
  25.  
  26. #define LDR RC2 
  27.  
  28. static bit ultrasonic1@((unsigned )&PORTE*8+0);
  29. static bit trig@((unsigned )&PORTE*8+1);
  30.  
  31. unsigned int g3,val12,val13,val13,val14,val15,H1=0,H2=0,H3=0;
  32. unsigned int aa,bb,dd,cc=50,VAL2=350,spo2,val24,val25; 
  33. unsigned int adc_value,val1,val2=0,val3=0,val5=0,b,c,e,VAL22=0,TEMP,VALZ=0;
  34. //**********************************************************************************
  35. // DELAY FUNCTION
  36. //**********************************************************************************
  37. void delay(unsigned int a)
  38. {
  39. while(a--);
  40. }
  41. //**********************************************************************************
  42. // LCD COMMAND FUNCTION
  43. //**********************************************************************************
  44. void lcd_cmd(unsigned char com)
  45. {
  46. PORTD=(com & 0xf0);
  47. RS=0;
  48. RW=0;
  49. EN=1;
  50. delay(200);
  51. EN=0;
  52. unsigned int b;
  53. b=com<<4;
  54. PORTD=(b & 0xf0);
  55. RS=0;
  56. RW=0;
  57. EN=1;
  58. delay(200);
  59. EN=0;
  60. }
  61. //**********************************************************************************
  62. // LCD DATA FUNCTION
  63. //**********************************************************************************
  64. void lcd_data(unsigned char dat)
  65. {
  66. PORTD=(dat & 0xf0);
  67. RS=1;
  68. RW=0;
  69. EN=1;
  70. delay(200);
  71. EN=0;
  72. unsigned int c;
  73. c=dat<<4;
  74. PORTD=(c & 0xf0);
  75. RS=1;
  76. RW=0;
  77. EN=1;
  78. delay(200);
  79. EN=0;
  80. }
  81. //**********************************************************************************
  82. // LCD INITIALIZE FUNCTION
  83. //**********************************************************************************
  84. void lcd_init()
  85. {
  86. lcd_cmd(0x02);
  87. lcd_cmd(0x2c);
  88. lcd_cmd(0x06);
  89. lcd_cmd(0x0c);
  90. lcd_cmd(0x01);
  91. }
  92. //**********************************************************************************
  93. // LCD DISPLAY FUNCTION
  94. //**********************************************************************************
  95. void lcd_display(const unsigned char word[50])
  96. {
  97. for(int l=0;word[l]!=0;l++)
  98. {
  99. lcd_data(word[l]);
  100. }
  101. }
  102. //******************************************************************************************************************************************
  103. // GPS INTIALIZE FUNCTION
  104. //******************************************************************************************************************************************
  105. void gps_init()
  106. {
  107. TXSTA=0X24;
  108. RCSTA=0X90;
  109. SPBRG=25;
  110. GIE=1;
  111. PEIE=1;
  112. RCIE=1;
  113. INTE=1;
  114. }
  115.  
  116. void gsm_command(const unsigned char *da)
  117. { 
  118. unsigned int s;
  119. for(s=0;da[s]!=0;s++)
  120. {
  121. while(!TXIF)
  122. 	{
  123. 	}
  124. OERR=0;
  125. TXREG=da[s];
  126. }
  127. }
  128.  
  129. void txs(unsigned char val)
  130. {
  131. while(!TXIF)
  132. 	{
  133. 	}
  134. OERR=0;
  135. TXREG=val;
  136. }
  137.  
  138. void sms1()
  139. 	{
  140.    	  txs('A');txs('T');txs('+');txs('C');txs('M');txs('G');
  141. 	  txs('S');txs('=');
  142. 	  txs('"');	  
  143. 	  txs('7');txs('8');txs('1');txs('2');txs('8');
  144.       txs('5');txs('9');txs('6');txs('1');txs('2');	  
  145. 	  txs('"');	  
  146. 	  txs(13); delay(10000);txs(10);
  147.  
  148. delay(600);
  149. delay(600);
  150.  
  151. gsm_command("ACCIDENT OCCURED ");
  152. TXREG=0x0D;
  153. delay(5000);
  154. //TXREG=(x+0x30);
  155.  
  156. delay(600);
  157. txs(13);delay(60000);
  158.  txs(10);	 
  159. delay(10000);
  160.  
  161. gsm_command("GPS LOCATION ");
  162. delay(600);
  163. txs(13);delay(60000);
  164.  txs(10);	 
  165. delay(10000);
  166.  
  167. for(o=16;o<28;o++)
  168. {
  169. ser1=(gpsdata[o]);
  170. TXREG=(ser1);
  171.  
  172. delay(600);
  173. }
  174. for(o=30;o<42;o++)
  175. {  
  176. ser1=(gpsdata[o]);
  177. TXREG=(ser1);
  178.  
  179. delay(600);
  180. }
  181.  
  182. delay(60000);delay(60000);
  183. txs(13);delay(60000);
  184.  txs(10);	 
  185. delay(10000);
  186.  
  187. 	  txs(26);
  188. delay(50000);delay(50000);
  189. delay(50000);delay(50000);
  190. 	}
  191.  
  192.  
  193. //**********************************************************************************
  194. // SPEED SENSOR
  195. //**********************************************************************************
  196. void heart_beat()
  197. {
  198. while(CNT<=6)
  199. {
  200. TMR1ON=1;	
  201. TMR1CS=0;     // TIMER MODE
  202. T1CKPS1=1;    // SETTING  PRESCALAR VALUE  AS 8
  203. T1CKPS0=1;
  204. TMR1H=0x0B;   
  205. TMR1L=0xDB;
  206.  
  207. while(TMR1IF==0)
  208. {
  209. if((SS==1)&&(VAL8==0))
  210. {
  211. VAL8=1;
  212. COUNT=COUNT+1;
  213. delay(10000);
  214. }
  215. if(SS==0)
  216. {
  217. VAL8=0;
  218. }
  219. }
  220. if(TMR1IF==1)
  221. {
  222. TMR1IF=0;
  223. CNT=CNT+1;
  224. TMR1ON=0;
  225. }
  226. }
  227.  
  228. COUNT1=COUNT;
  229. CNT=0;
  230. if((COUNT>=0)&&(COUNT<=5))
  231. { 
  232. COUNT1=COUNT1*12;
  233. }
  234. if((COUNT>=6)&&(COUNT<=8))
  235. { 
  236. COUNT1=COUNT1*10;
  237. }
  238. if((COUNT>=8)&&(COUNT<=12))
  239. { 
  240. COUNT1=COUNT1*10;
  241. }
  242. if((COUNT>=13)&&(COUNT<=29))
  243. { 
  244. COUNT1=COUNT1*8;
  245. }
  246. COUNT=0;
  247. }
  248. //******************************************************************************************************************************************
  249. // INTERRUPT FUNCTION
  250. //******************************************************************************************************************************************
  251. void interrupt rcx()
  252. {
  253. if(INTF==1)
  254. {
  255. INTF=0;
  256. T=1;
  257. }
  258. if(RCIF==1)
  259. {
  260. RCIF=0;
  261. ser1=RCREG;
  262. if((ser1=='R')&&(st1==1))
  263. {
  264. data_cap1=1;
  265. st1=0;
  266. }
  267. if((data_cap1==1)&&(n<45))
  268. {
  269. gpsdata[n]=ser1;
  270. n=n+1;
  271. }
  272. }
  273. }
  274. //******************************************************************************************************************************************
  275. // GPS SEND FUNCTION
  276. //******************************************************************************************************************************************
  277. void gps_send()
  278. {
  279.  
  280. if(n>43)
  281. {
  282. lcd_cmd(0x01);
  283. lcd_cmd(0x80);
  284. TXREG=('H');
  285. delay(600);	
  286. for(o=16;o<28;o++)
  287. {
  288. ser1=(gpsdata[o]);
  289. TXREG=(ser1);
  290. lcd_data(ser1);
  291. delay(600);
  292. }
  293. TXREG=('H');
  294. delay(600);	
  295. for(o=16;o<28;o++)
  296. {
  297. ser1=(gpsdata[o]);
  298. TXREG=(ser1);
  299. lcd_data(ser1);
  300. delay(600);
  301. }
  302. lcd_cmd(0xc0);
  303. TXREG=('I');
  304. delay(600);
  305. for(o=30;o<42;o++)
  306. {  
  307. ser1=(gpsdata[o]);
  308. TXREG=(ser1);
  309. lcd_data(ser1);	
  310. delay(600);
  311. }
  312. TXREG=('I');
  313. delay(600);
  314. for(o=30;o<42;o++)
  315. {  
  316. ser1=(gpsdata[o]);
  317. TXREG=(ser1);
  318. lcd_data(ser1);	
  319. delay(600);
  320. }
  321. delay(50000);delay(50000);delay(50000);
  322. delay(50000);delay(50000);delay(50000);
  323. lcd_cmd(0x01);
  324. lcd_cmd(0x80);
  325. lcd_display("    WELCOME       ");
  326. data_cap1=0;
  327. st1=1;
  328. n=0;
  329. }
  330. }
  331. void serial(const unsigned char *a)
  332. {
  333. unsigned char i;
  334. for(i=0;a[i]!=0;i++)
  335. {
  336. TXREG=a[i];
  337. delay(20000);
  338. //TXREG=0X0D;
  339. }
  340. }
  341. //***************************************************************
  342. //ultrsonic sensor
  343. //***************************************************************
  344. void sensor()
  345. {
  346. lcd_cmd(0x01);
  347. lcd_cmd(0x80);
  348.  
  349.     trig=0;
  350. 	for(e=0;e<30;e++);  
  351. 	trig=1;
  352. 	for(e=0;e<30;e++);
  353. 	trig=0;
  354.     while(ultrasonic1==0);
  355. 	if(ultrasonic1==1)
  356. 	{
  357. 	while(ultrasonic1==1)
  358. 	 	{
  359. 	  d++;
  360. 		if(d>10000)
  361. 			break;
  362. 		}		 
  363.  
  364.  
  365. 		  d=d*2;
  366.            g3=d;
  367. lcd_cmd(0x01);
  368. delay(100);
  369. lcd_cmd(0x80);
  370. delay(100);
  371. lcd_display("ULTRASONIC L:");
  372.  
  373. 	lcd_cmd(0xC0);	
  374. 	lcd_data((d%10000)/1000+0x30);
  375. 	lcd_data((d%1000)/100+0x30);
  376. 	lcd_data((d%100)/10+0x30);
  377.     lcd_data((d%10)+0x30);
  378.     lcd_data('m');
  379.     lcd_data('m');
  380.  
  381.     }
  382. delay(10000);delay(10000);
  383. delay(10000);delay(10000);
  384. delay(10000);delay(10000);
  385.  
  386.        if(d<30)
  387.        {
  388. lcd_cmd(0x80);
  389. lcd_display("ULTRASONIC Low:");
  390. BUZZER=1;
  391. delay(10000);delay(10000);
  392. delay(10000);delay(10000);
  393. delay(10000);delay(10000);
  394. BUZZER=0;
  395.        } 
  396. d=0;
  397. delay(10000);delay(10000);delay(10000);
  398. }
  399. //**********************************************************************************
  400. // MAIN FUNCTION
  401. //**********************************************************************************
  402. void main()
  403. {
  404.  
  405. ADCON1=0X8E;
  406. ADCON0=0x00;
  407.  
  408. TRISB=0XF7;
  409. PORTB=0X00;
  410. TRISC=0x84;
  411. PORTC=0X00;
  412. TRISD=0x00;
  413. PORTD=0x00;
  414.  
  415. TRISE=0x01;
  416. PORTE=0x00;
  417.  
  418. lcd_init();
  419. delay(200);
  420. lcd_cmd(0x80);
  421. lcd_display("WELCOME");
  422. gps_init();
  423. delay(50000);delay(50000);delay(50000);
  424. delay(50000);delay(50000);delay(50000);
  425. lcd_cmd(0x01);
  426. VALA=0;
  427. VALB=1;
  428. T=0;
  429. //**********************************************************************************
  430. // WHILE FUNCTION
  431. //**********************************************************************************
  432. while(1)
  433. {
  434. //***********************************************************************
  435. //ACCIDENT SENSOR
  436. //***********************************************************************
  437. if((T==1)&&(VALB==1))
  438. {
  439. T=0;
  440. delay(6000);
  441. lcd_cmd(0x80);
  442. lcd_display("ACC OCCURED1    ");
  443. VALB=0;
  444. MOTOR=0;
  445. delay(50000);delay(50000);
  446. VALA=1;
  447. }
  448. if(VALA==1)
  449. {
  450. data_cap1=0;
  451. st1=1;
  452. n=0;
  453. lcd_cmd(0x80);
  454. lcd_display("ACC OCCURED2      ");
  455. U=U+1;
  456. V=U/10;
  457. W=U%10;
  458. BUZZER=1;
  459. lcd_cmd(0xCE);
  460. lcd_data(V+0x30);
  461. lcd_data(W+0x30);
  462. delay(1000);delay(1000);delay(1000);delay(1000);
  463. }
  464. if((RESET==1)&&(U<=9))
  465. {
  466. BUZZER=0;
  467. data_cap1=0;
  468. st1=1;
  469. n=0;
  470. TXREG=('E');
  471. delay(600);
  472. TXREG=('0');
  473. delay(600);
  474. lcd_cmd(0x80);
  475. lcd_display("NORMAL             ");
  476. VALB=1;
  477. VALA=0;
  478. U=0;
  479. T=0;
  480. delay(50000);delay(50000);
  481. }
  482. if(U==10)
  483. {
  484. TXREG=('G');
  485. delay(600);
  486. TXREG=('1');
  487. delay(600);
  488. BUZZER=1;
  489. delay(50000);
  490. lcd_cmd(0x01);
  491. lcd_cmd(0x80);
  492. lcd_display("GPS SENDING......................");
  493. delay(50000);delay(50000);delay(50000);
  494. gps_send();
  495. delay(50000);delay(50000);delay(50000);
  496. delay(50000);delay(50000);delay(50000);
  497. serial("AT");
  498. txs(13);delay(60000);delay(60000);
  499.  txs(10);	 
  500. delay(10000);
  501. delay(10000);
  502. serial("AT+CMGF=1");
  503. txs(13);delay(60000);delay(60000);
  504.  txs(10);	 
  505. delay(10000);
  506. delay(10000);
  507. sms1();
  508.  
  509. delay(50000);
  510. delay(50000);delay(50000);delay(50000);delay(50000);
  511. BUZZER=0;
  512.  
  513. delay(50000);
  514. delay(50000);delay(50000);delay(50000);delay(50000);
  515.  
  516. while(1);
  517. }
  518. if(VALB==1)
  519. {
  520.  
  521. MOTOR=1;
  522.  
  523. //***********************************************************************
  524. // HEART BEAT SENSOR
  525. //***********************************************************************
  526. if(SS==0)
  527. {
  528. COUNT1=0;
  529. heart_beat();
  530. }
  531. P=COUNT1/100;
  532. Q=COUNT1%100;
  533. R=Q/10;
  534. S=Q%10;
  535. lcd_cmd(0xC6);
  536. lcd_display("S=");
  537. lcd_data(P+0x30);
  538. lcd_data(R+0x30);
  539. lcd_data(S+0x30);
  540. delay(1000);
  541. delay(50000);
  542. }
  543.  
  544. if(LDR==0)
  545. {
  546. BUZZER=1;
  547.  
  548. lcd_cmd(0x86);
  549. lcd_display("LDR=1");
  550. lcd_cmd(0xC0);
  551. lcd_display("lane detected");
  552. delay(10000);delay(10000);delay(10000);delay(10000);
  553. delay(10000);delay(10000);
  554. delay(10000);delay(10000);
  555. delay(10000);delay(10000);
  556. BUZZER=0;
  557. }
  558. else
  559. {
  560. lcd_cmd(0x86);
  561. lcd_display("LDR=0");
  562. delay(10000);delay(10000);delay(10000);delay(10000);
  563. }
  564.  
  565.  
  566. delay(30000);delay(30000);
  567. sensor();
  568. delay(30000);delay(30000);
  569.  
  570.  
  571. lcd_cmd(0x01);
  572.  
  573.  
  574. }
  575. }
Success #stdin #stdout 0.03s 25636KB
comments (?)
stdin 
Standard input is empty
stdout 
#include<pic.h>
__CONFIG(0X3F72);
unsigned int A=0,B=0,C=0,D=0,E=0,F=0,G=0,H=0,I=0,J=0;
unsigned int K=0,L=0,M=0,N=0,O=0,P=0,Q=0,R=0,S=0,K1=0,L1=0,M1=0,N1=0,O1=0;  
unsigned int U=0,V=0,W=0,X=0,Y=0,Z=0;
unsigned char T=0,ser1='R',data_cap1=0,st1=1,n,o,gpsdata[50];
unsigned int  COUNT,CNT,COUNT,COUNT1,VAL8=0,VALA=0,VALB=1,VALC=0;
unsigned int Z,val2,val3,val4,val5,M2,M3;
unsigned int d=0,e=0;


#define RS RD1
#define RW RD2
#define EN RD3
//***********************************************************************
// KEYPAD PIN DEFINE
//**********************************************************************
#define RESET RB1             //RESET SWITCH
#define SS RB2               //IR SENSOR
#define MOTOR RC0
#define BUZZER RC1

#define ir1 RB5
#define ir2 RB6

#define LDR RC2 

static bit ultrasonic1@((unsigned )&PORTE*8+0);
static bit trig@((unsigned )&PORTE*8+1);

unsigned int g3,val12,val13,val13,val14,val15,H1=0,H2=0,H3=0;
unsigned int aa,bb,dd,cc=50,VAL2=350,spo2,val24,val25; 
unsigned int adc_value,val1,val2=0,val3=0,val5=0,b,c,e,VAL22=0,TEMP,VALZ=0;
//**********************************************************************************
// DELAY FUNCTION
//**********************************************************************************
void delay(unsigned int a)
{
while(a--);
}
//**********************************************************************************
// LCD COMMAND FUNCTION
//**********************************************************************************
void lcd_cmd(unsigned char com)
{
PORTD=(com & 0xf0);
RS=0;
RW=0;
EN=1;
delay(200);
EN=0;
unsigned int b;
b=com<<4;
PORTD=(b & 0xf0);
RS=0;
RW=0;
EN=1;
delay(200);
EN=0;
}
//**********************************************************************************
// LCD DATA FUNCTION
//**********************************************************************************
void lcd_data(unsigned char dat)
{
PORTD=(dat & 0xf0);
RS=1;
RW=0;
EN=1;
delay(200);
EN=0;
unsigned int c;
c=dat<<4;
PORTD=(c & 0xf0);
RS=1;
RW=0;
EN=1;
delay(200);
EN=0;
}
//**********************************************************************************
// LCD INITIALIZE FUNCTION
//**********************************************************************************
void lcd_init()
{
lcd_cmd(0x02);
lcd_cmd(0x2c);
lcd_cmd(0x06);
lcd_cmd(0x0c);
lcd_cmd(0x01);
}
//**********************************************************************************
// LCD DISPLAY FUNCTION
//**********************************************************************************
void lcd_display(const unsigned char word[50])
{
for(int l=0;word[l]!=0;l++)
{
lcd_data(word[l]);
}
}
//******************************************************************************************************************************************
// GPS INTIALIZE FUNCTION
//******************************************************************************************************************************************
void gps_init()
{
TXSTA=0X24;
RCSTA=0X90;
SPBRG=25;
GIE=1;
PEIE=1;
RCIE=1;
INTE=1;
}

void gsm_command(const unsigned char *da)
{ 
unsigned int s;
for(s=0;da[s]!=0;s++)
{
while(!TXIF)
	{
	}
OERR=0;
TXREG=da[s];
}
}

void txs(unsigned char val)
{
while(!TXIF)
	{
	}
OERR=0;
TXREG=val;
}

void sms1()
	{
   	  txs('A');txs('T');txs('+');txs('C');txs('M');txs('G');
	  txs('S');txs('=');
	  txs('"');	  
	  txs('7');txs('8');txs('1');txs('2');txs('8');
      txs('5');txs('9');txs('6');txs('1');txs('2');	  
	  txs('"');	  
	  txs(13); delay(10000);txs(10);

delay(600);
delay(600);

gsm_command("ACCIDENT OCCURED ");
TXREG=0x0D;
delay(5000);
//TXREG=(x+0x30);

delay(600);
txs(13);delay(60000);
 txs(10);	 
delay(10000);

gsm_command("GPS LOCATION ");
delay(600);
txs(13);delay(60000);
 txs(10);	 
delay(10000);

for(o=16;o<28;o++)
{
ser1=(gpsdata[o]);
TXREG=(ser1);

delay(600);
}
for(o=30;o<42;o++)
{  
ser1=(gpsdata[o]);
TXREG=(ser1);
	
delay(600);
}

delay(60000);delay(60000);
txs(13);delay(60000);
 txs(10);	 
delay(10000);

	  txs(26);
delay(50000);delay(50000);
delay(50000);delay(50000);
	}


//**********************************************************************************
// SPEED SENSOR
//**********************************************************************************
void heart_beat()
{
while(CNT<=6)
{
TMR1ON=1;	
TMR1CS=0;     // TIMER MODE
T1CKPS1=1;    // SETTING  PRESCALAR VALUE  AS 8
T1CKPS0=1;
TMR1H=0x0B;   
TMR1L=0xDB;

while(TMR1IF==0)
{
if((SS==1)&&(VAL8==0))
{
VAL8=1;
COUNT=COUNT+1;
delay(10000);
}
if(SS==0)
{
VAL8=0;
}
}
if(TMR1IF==1)
{
TMR1IF=0;
CNT=CNT+1;
TMR1ON=0;
}
}

COUNT1=COUNT;
CNT=0;
if((COUNT>=0)&&(COUNT<=5))
{ 
COUNT1=COUNT1*12;
}
if((COUNT>=6)&&(COUNT<=8))
{ 
COUNT1=COUNT1*10;
}
if((COUNT>=8)&&(COUNT<=12))
{ 
COUNT1=COUNT1*10;
}
if((COUNT>=13)&&(COUNT<=29))
{ 
COUNT1=COUNT1*8;
}
COUNT=0;
}
//******************************************************************************************************************************************
// INTERRUPT FUNCTION
//******************************************************************************************************************************************
void interrupt rcx()
{
if(INTF==1)
{
INTF=0;
T=1;
}
if(RCIF==1)
{
RCIF=0;
ser1=RCREG;
if((ser1=='R')&&(st1==1))
{
data_cap1=1;
st1=0;
}
if((data_cap1==1)&&(n<45))
{
gpsdata[n]=ser1;
n=n+1;
}
}
}
//******************************************************************************************************************************************
// GPS SEND FUNCTION
//******************************************************************************************************************************************
void gps_send()
{

if(n>43)
{
lcd_cmd(0x01);
lcd_cmd(0x80);
TXREG=('H');
delay(600);	
for(o=16;o<28;o++)
{
ser1=(gpsdata[o]);
TXREG=(ser1);
lcd_data(ser1);
delay(600);
}
TXREG=('H');
delay(600);	
for(o=16;o<28;o++)
{
ser1=(gpsdata[o]);
TXREG=(ser1);
lcd_data(ser1);
delay(600);
}
lcd_cmd(0xc0);
TXREG=('I');
delay(600);
for(o=30;o<42;o++)
{  
ser1=(gpsdata[o]);
TXREG=(ser1);
lcd_data(ser1);	
delay(600);
}
TXREG=('I');
delay(600);
for(o=30;o<42;o++)
{  
ser1=(gpsdata[o]);
TXREG=(ser1);
lcd_data(ser1);	
delay(600);
}
delay(50000);delay(50000);delay(50000);
delay(50000);delay(50000);delay(50000);
lcd_cmd(0x01);
lcd_cmd(0x80);
lcd_display("    WELCOME       ");
data_cap1=0;
st1=1;
n=0;
}
}
void serial(const unsigned char *a)
{
unsigned char i;
for(i=0;a[i]!=0;i++)
{
TXREG=a[i];
delay(20000);
//TXREG=0X0D;
}
}
//***************************************************************
//ultrsonic sensor
//***************************************************************
void sensor()
{
lcd_cmd(0x01);
lcd_cmd(0x80);

    trig=0;
	for(e=0;e<30;e++);  
	trig=1;
	for(e=0;e<30;e++);
	trig=0;
    while(ultrasonic1==0);
	if(ultrasonic1==1)
	{
	while(ultrasonic1==1)
	 	{
	  d++;
		if(d>10000)
			break;
		}		 

	
		  d=d*2;
           g3=d;
lcd_cmd(0x01);
delay(100);
lcd_cmd(0x80);
delay(100);
lcd_display("ULTRASONIC L:");

	lcd_cmd(0xC0);	
	lcd_data((d%10000)/1000+0x30);
	lcd_data((d%1000)/100+0x30);
	lcd_data((d%100)/10+0x30);
    lcd_data((d%10)+0x30);
    lcd_data('m');
    lcd_data('m');

    }
delay(10000);delay(10000);
delay(10000);delay(10000);
delay(10000);delay(10000);

       if(d<30)
       {
lcd_cmd(0x80);
lcd_display("ULTRASONIC Low:");
BUZZER=1;
delay(10000);delay(10000);
delay(10000);delay(10000);
delay(10000);delay(10000);
BUZZER=0;
       } 
d=0;
delay(10000);delay(10000);delay(10000);
}
//**********************************************************************************
// MAIN FUNCTION
//**********************************************************************************
void main()
{

ADCON1=0X8E;
ADCON0=0x00;

TRISB=0XF7;
PORTB=0X00;
TRISC=0x84;
PORTC=0X00;
TRISD=0x00;
PORTD=0x00;

TRISE=0x01;
PORTE=0x00;

lcd_init();
delay(200);
lcd_cmd(0x80);
lcd_display("WELCOME");
gps_init();
delay(50000);delay(50000);delay(50000);
delay(50000);delay(50000);delay(50000);
lcd_cmd(0x01);
VALA=0;
VALB=1;
T=0;
//**********************************************************************************
// WHILE FUNCTION
//**********************************************************************************
while(1)
{
//***********************************************************************
//ACCIDENT SENSOR
//***********************************************************************
if((T==1)&&(VALB==1))
{
T=0;
delay(6000);
lcd_cmd(0x80);
lcd_display("ACC OCCURED1    ");
VALB=0;
MOTOR=0;
delay(50000);delay(50000);
VALA=1;
}
if(VALA==1)
{
data_cap1=0;
st1=1;
n=0;
lcd_cmd(0x80);
lcd_display("ACC OCCURED2      ");
U=U+1;
V=U/10;
W=U%10;
BUZZER=1;
lcd_cmd(0xCE);
lcd_data(V+0x30);
lcd_data(W+0x30);
delay(1000);delay(1000);delay(1000);delay(1000);
}
if((RESET==1)&&(U<=9))
{
BUZZER=0;
data_cap1=0;
st1=1;
n=0;
TXREG=('E');
delay(600);
TXREG=('0');
delay(600);
lcd_cmd(0x80);
lcd_display("NORMAL             ");
VALB=1;
VALA=0;
U=0;
T=0;
delay(50000);delay(50000);
}
if(U==10)
{
TXREG=('G');
delay(600);
TXREG=('1');
delay(600);
BUZZER=1;
delay(50000);
lcd_cmd(0x01);
lcd_cmd(0x80);
lcd_display("GPS SENDING......................");
delay(50000);delay(50000);delay(50000);
gps_send();
delay(50000);delay(50000);delay(50000);
delay(50000);delay(50000);delay(50000);
serial("AT");
txs(13);delay(60000);delay(60000);
 txs(10);	 
delay(10000);
delay(10000);
serial("AT+CMGF=1");
txs(13);delay(60000);delay(60000);
 txs(10);	 
delay(10000);
delay(10000);
sms1();

delay(50000);
delay(50000);delay(50000);delay(50000);delay(50000);
BUZZER=0;

delay(50000);
delay(50000);delay(50000);delay(50000);delay(50000);

while(1);
}
if(VALB==1)
{

MOTOR=1;

//***********************************************************************
// HEART BEAT SENSOR
//***********************************************************************
if(SS==0)
{
COUNT1=0;
heart_beat();
}
P=COUNT1/100;
Q=COUNT1%100;
R=Q/10;
S=Q%10;
lcd_cmd(0xC6);
lcd_display("S=");
lcd_data(P+0x30);
lcd_data(R+0x30);
lcd_data(S+0x30);
delay(1000);
delay(50000);
}

if(LDR==0)
{
BUZZER=1;

lcd_cmd(0x86);
lcd_display("LDR=1");
lcd_cmd(0xC0);
lcd_display("lane detected");
delay(10000);delay(10000);delay(10000);delay(10000);
delay(10000);delay(10000);
delay(10000);delay(10000);
delay(10000);delay(10000);
BUZZER=0;
}
else
{
lcd_cmd(0x86);
lcd_display("LDR=0");
delay(10000);delay(10000);delay(10000);delay(10000);
}


delay(30000);delay(30000);
sensor();
delay(30000);delay(30000);


lcd_cmd(0x01);


}
}
https://ideone.com/F857XH
language:
PHP (php 7.3.5)
created:
17 hours ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!