GPS + GSM + LCD + LPC2148

[BenC]

Projeyi pic le yapmaya çalıştım kaynak sorunu yüzünden ARM kullanmak zorunda kaldım. Malum hesap kitap işi.

Öncelikle proje hakkında biraz bilgi vereyim. Devre üzerinde bulunan GPS sayesinde bulunduğu yerin konumunu 3 ila 7 metre hassasiyetinde buluyor. Bu konum bilgisi içerisinde hız,yükseklik,coğrafi koordinat vs var. Bu proje araç için kullanılacağı gibi asıl yapılma maksadı tekne vb. hareketli platformlar için tasarlanmıştır. Hedef koordinat giriyorsunuz sizi hedefe navigasyon cihazları gibi yönlendiriyor, kalan mesafe, gidilen mesafe,hız ve varış zamanı gibi değerler veriyor. Navigasyon cihazında bulunan vektör harita muhabbeti burda yok. Zaten tekne de de bi işe yaramazdı. Hedef gir,sizi hedefe 5 metre hassasiyetle götürsün.

Bir diğer özelliği ise teknenin çalışnmasını önlemek için ( aslında çalınma durumunda demek daha doğru olur.)  yarı çap giriyorsunuz tekne o yarı çapın dışına çıkınca GSM ile mesaj ve çağrı yapıyor. Arandığı vakit te otamatik olarak GSM i açıyor ve ortam dinlemesi yapabiliyorsunuz.


Projenin hesap kısmında (koordinat vs) yardımcı olan Harita Mühendis Servet ÖZAĞAÇ' a burdan teşekkür etmek istiyorum. Onun yardımı olmasa idi bu projede pek ilerleme kaydedemezdim. Özelliklede haritacılık konusunda.

Proje Keil uVision 3.62c de yapılmış olup LPC2148 ilşemcisi kullanılmıştır.

Zaman bulamadığım için kodda yeterli açıklama satırları ekleyemedim. Şimdiden özürdilerim.

Startup.s dosyası ile başlayalım.

;/*****************************************************************************/
;/* STARTUP.S: Startup file for Philips LPC2000                               */
;/*****************************************************************************/
;/* <<< Use Configuration Wizard in Context Menu >>>                          */ 
;/*****************************************************************************/
;/* This file is part of the uVision/ARM development tools.                   */
;/* Copyright (c) 2005-2007 Keil Software. All rights reserved.               */
;/* This software may only be used under the terms of a valid, current,       */
;/* end user licence from KEIL for a compatible version of KEIL software      */
;/* development tools. Nothing else gives you the right to use this software. */
;/*****************************************************************************/


;/*
; *  The STARTUP.S code is executed after CPU Reset. This file may be 
; *  translated with the following SET symbols. In uVision these SET 
; *  symbols are entered under Options - ASM - Define.
; *
; *  REMAP: when set the startup code initializes the register MEMMAP 
; *  which overwrites the settings of the CPU configuration pins. The 
; *  startup and interrupt vectors are remapped from:
; *     0x00000000  default setting (not remapped)
; *     0x80000000  when EXTMEM_MODE is used
; *     0x40000000  when RAM_MODE is used
; *
; *  EXTMEM_MODE: when set the device is configured for code execution
; *  from external memory starting at address 0x80000000.
; *
; *  RAM_MODE: when set the device is configured for code execution
; *  from on-chip RAM starting at address 0x40000000.
; *
; *  EXTERNAL_MODE: when set the PIN2SEL values are written that enable
; *  the external BUS at startup.
; */


; Standard definitions of Mode bits and Interrupt (I & F) flags in PSRs

Mode_USR        EQU     0x10
Mode_FIQ        EQU     0x11
Mode_IRQ        EQU     0x12
Mode_SVC        EQU     0x13
Mode_ABT        EQU     0x17
Mode_UND        EQU     0x1B
Mode_SYS        EQU     0x1F

I_Bit           EQU     0x80            ; when I bit is set, IRQ is disabled
F_Bit           EQU     0x40            ; when F bit is set, FIQ is disabled


;// <h> Stack Configuration (Stack Sizes in Bytes)
;//   <o0> Undefined Mode      <0x0-0xFFFFFFFF:8>
;//   <o1> Supervisor Mode     <0x0-0xFFFFFFFF:8>
;//   <o2> Abort Mode          <0x0-0xFFFFFFFF:8>
;//   <o3> Fast Interrupt Mode <0x0-0xFFFFFFFF:8>
;//   <o4> Interrupt Mode      <0x0-0xFFFFFFFF:8>
;//   <o5> User/System Mode    <0x0-0xFFFFFFFF:8>
;// </h>

UND_Stack_Size  EQU     0x00000000
SVC_Stack_Size  EQU     0x00000008
ABT_Stack_Size  EQU     0x00000000
FIQ_Stack_Size  EQU     0x00000000
IRQ_Stack_Size  EQU     0x00000080
USR_Stack_Size  EQU     0x00000400

ISR_Stack_Size  EQU     (UND_Stack_Size + SVC_Stack_Size + ABT_Stack_Size + \
                         FIQ_Stack_Size + IRQ_Stack_Size)

                AREA    STACK, NOINIT, READWRITE, ALIGN=3

Stack_Mem       SPACE   USR_Stack_Size
__initial_sp    SPACE   ISR_Stack_Size

Stack_Top


;// <h> Heap Configuration
;//   <o>  Heap Size (in Bytes) <0x0-0xFFFFFFFF>
;// </h>

Heap_Size       EQU     0x00000000

                AREA    HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base
Heap_Mem        SPACE   Heap_Size
__heap_limit


; VPBDIV definitions
VPBDIV          EQU     0xE01FC100      ; VPBDIV Address

;// <e> VPBDIV Setup
;// <i> Peripheral Bus Clock Rate
;//   <o1.0..1>   VPBDIV: VPB Clock
;//               <0=> VPB Clock = CPU Clock / 4
;//               <1=> VPB Clock = CPU Clock
;//               <2=> VPB Clock = CPU Clock / 2
;//   <o1.4..5>   XCLKDIV: XCLK Pin
;//               <0=> XCLK Pin = CPU Clock / 4
;//               <1=> XCLK Pin = CPU Clock
;//               <2=> XCLK Pin = CPU Clock / 2
;// </e>
VPBDIV_SETUP    EQU     0
VPBDIV_Val      EQU     0x00000000


; Phase Locked Loop (PLL) definitions
PLL_BASE        EQU     0xE01FC080      ; PLL Base Address
PLLCON_OFS      EQU     0x00            ; PLL Control Offset
PLLCFG_OFS      EQU     0x04            ; PLL Configuration Offset
PLLSTAT_OFS     EQU     0x08            ; PLL Status Offset
PLLFEED_OFS     EQU     0x0C            ; PLL Feed Offset
PLLCON_PLLE     EQU     (1<<0)          ; PLL Enable
PLLCON_PLLC     EQU     (1<<1)          ; PLL Connect
PLLCFG_MSEL     EQU     (0x1F<<0)       ; PLL Multiplier
PLLCFG_PSEL     EQU     (0x03<<5)       ; PLL Divider
PLLSTAT_PLOCK   EQU     (1<<10)         ; PLL Lock Status

;// <e> PLL Setup
;//   <o1.0..4>   MSEL: PLL Multiplier Selection
;//               <1-32><#-1>
;//               <i> M Value
;//   <o1.5..6>   PSEL: PLL Divider Selection
;//               <0=> 1   <1=> 2   <2=> 4   <3=> 8
;//               <i> P Value
;// </e>
PLL_SETUP       EQU     1
PLLCFG_Val      EQU     0x00000024


; Memory Accelerator Module (MAM) definitions
MAM_BASE        EQU     0xE01FC000      ; MAM Base Address
MAMCR_OFS       EQU     0x00            ; MAM Control Offset
MAMTIM_OFS      EQU     0x04            ; MAM Timing Offset

;// <e> MAM Setup
;//   <o1.0..1>   MAM Control
;//               <0=> Disabled
;//               <1=> Partially Enabled
;//               <2=> Fully Enabled
;//               <i> Mode
;//   <o2.0..2>   MAM Timing
;//               <0=> Reserved  <1=> 1   <2=> 2   <3=> 3
;//               <4=> 4         <5=> 5   <6=> 6   <7=> 7
;//               <i> Fetch Cycles
;// </e>
MAM_SETUP       EQU     1
MAMCR_Val       EQU     0x00000002
MAMTIM_Val      EQU     0x00000004


; External Memory Controller (EMC) definitions
EMC_BASE        EQU     0xFFE00000      ; EMC Base Address
BCFG0_OFS       EQU     0x00            ; BCFG0 Offset
BCFG1_OFS       EQU     0x04            ; BCFG1 Offset
BCFG2_OFS       EQU     0x08            ; BCFG2 Offset
BCFG3_OFS       EQU     0x0C            ; BCFG3 Offset

;// <e> External Memory Controller (EMC)
EMC_SETUP       EQU     0

;//   <e> Bank Configuration 0 (BCFG0)
;//     <o1.0..3>   IDCY: Idle Cycles <0-15>
;//     <o1.5..9>   WST1: Wait States 1 <0-31>
;//     <o1.11..15> WST2: Wait States 2 <0-31>
;//     <o1.10>     RBLE: Read Byte Lane Enable
;//     <o1.26>     WP: Write Protect
;//     <o1.27>     BM: Burst ROM
;//     <o1.28..29> MW: Memory Width  <0=>  8-bit  <1=> 16-bit
;//                                   <2=> 32-bit  <3=> Reserved
;//   </e>
BCFG0_SETUP EQU         0
BCFG0_Val   EQU         0x0000FBEF

;//   <e> Bank Configuration 1 (BCFG1)
;//     <o1.0..3>   IDCY: Idle Cycles <0-15>
;//     <o1.5..9>   WST1: Wait States 1 <0-31>
;//     <o1.11..15> WST2: Wait States 2 <0-31>
;//     <o1.10>     RBLE: Read Byte Lane Enable
;//     <o1.26>     WP: Write Protect
;//     <o1.27>     BM: Burst ROM
;//     <o1.28..29> MW: Memory Width  <0=>  8-bit  <1=> 16-bit
;//                                   <2=> 32-bit  <3=> Reserved
;//   </e>
BCFG1_SETUP EQU         0
BCFG1_Val   EQU         0x0000FBEF

;//   <e> Bank Configuration 2 (BCFG2)
;//     <o1.0..3>   IDCY: Idle Cycles <0-15>
;//     <o1.5..9>   WST1: Wait States 1 <0-31>
;//     <o1.11..15> WST2: Wait States 2 <0-31>
;//     <o1.10>     RBLE: Read Byte Lane Enable
;//     <o1.26>     WP: Write Protect
;//     <o1.27>     BM: Burst ROM
;//     <o1.28..29> MW: Memory Width  <0=>  8-bit  <1=> 16-bit
;//                                   <2=> 32-bit  <3=> Reserved
;//   </e>
BCFG2_SETUP EQU         0
BCFG2_Val   EQU         0x0000FBEF

;//   <e> Bank Configuration 3 (BCFG3)
;//     <o1.0..3>   IDCY: Idle Cycles <0-15>
;//     <o1.5..9>   WST1: Wait States 1 <0-31>
;//     <o1.11..15> WST2: Wait States 2 <0-31>
;//     <o1.10>     RBLE: Read Byte Lane Enable
;//     <o1.26>     WP: Write Protect
;//     <o1.27>     BM: Burst ROM
;//     <o1.28..29> MW: Memory Width  <0=>  8-bit  <1=> 16-bit
;//                                   <2=> 32-bit  <3=> Reserved
;//   </e>
BCFG3_SETUP EQU         0
BCFG3_Val   EQU         0x0000FBEF

;// </e> End of EMC


; External Memory Pins definitions
PINSEL2         EQU     0xE002C014      ; PINSEL2 Address
PINSEL2_Val     EQU     0x0E6149E4      ; CS0..3, OE, WE, BLS0..3, 
                                        ; D0..31, A2..23, JTAG Pins


                PRESERVE8
                

; Area Definition and Entry Point
;  Startup Code must be linked first at Address at which it expects to run.

                AREA    RESET, CODE, READONLY
                ARM


; Exception Vectors
;  Mapped to Address 0.
;  Absolute addressing mode must be used.
;  Dummy Handlers are implemented as infinite loops which can be modified.

Vectors         LDR     PC, Reset_Addr         
                LDR     PC, Undef_Addr
                LDR     PC, SWI_Addr
                LDR     PC, PAbt_Addr
                LDR     PC, DAbt_Addr
                NOP                            ; Reserved Vector 
;               LDR     PC, IRQ_Addr
                LDR     PC, [PC, #-0x0FF0]     ; Vector from VicVectAddr
                LDR     PC, FIQ_Addr

Reset_Addr      DCD     Reset_Handler
Undef_Addr      DCD     Undef_Handler
SWI_Addr        DCD     SWI_Handler
PAbt_Addr       DCD     PAbt_Handler
DAbt_Addr       DCD     DAbt_Handler
                DCD     0                      ; Reserved Address 
IRQ_Addr        DCD     IRQ_Handler
FIQ_Addr        DCD     FIQ_Handler

Undef_Handler   B       Undef_Handler
SWI_Handler     B       SWI_Handler
PAbt_Handler    B       PAbt_Handler
DAbt_Handler    B       DAbt_Handler
IRQ_Handler     B       IRQ_Handler
FIQ_Handler     B       FIQ_Handler


; Reset Handler

                EXPORT  Reset_Handler
Reset_Handler   


; Setup External Memory Pins
                IF      :DEF:EXTERNAL_MODE
                LDR     R0, =PINSEL2
                LDR     R1, =PINSEL2_Val
                STR     R1, [R0]
                ENDIF


; Setup External Memory Controller
                IF      EMC_SETUP <> 0
                LDR     R0, =EMC_BASE

                IF      BCFG0_SETUP <> 0
                LDR     R1, =BCFG0_Val
                STR     R1, [R0, #BCFG0_OFS]
                ENDIF

                IF      BCFG1_SETUP <> 0
                LDR     R1, =BCFG1_Val
                STR     R1, [R0, #BCFG1_OFS]
                ENDIF

                IF      BCFG2_SETUP <> 0
                LDR     R1, =BCFG2_Val
                STR     R1, [R0, #BCFG2_OFS]
                ENDIF

                IF      BCFG3_SETUP <> 0
                LDR     R1, =BCFG3_Val
                STR     R1, [R0, #BCFG3_OFS]
                ENDIF

                ENDIF   ; EMC_SETUP


; Setup VPBDIV
                IF      VPBDIV_SETUP <> 0
                LDR     R0, =VPBDIV
                LDR     R1, =VPBDIV_Val
                STR     R1, [R0]
                ENDIF


; Setup PLL
                IF      PLL_SETUP <> 0
                LDR     R0, =PLL_BASE
                MOV     R1, #0xAA
                MOV     R2, #0x55

;  Configure and Enable PLL
                MOV     R3, #PLLCFG_Val
                STR     R3, [R0, #PLLCFG_OFS] 
                MOV     R3, #PLLCON_PLLE
                STR     R3, [R0, #PLLCON_OFS]
                STR     R1, [R0, #PLLFEED_OFS]
                STR     R2, [R0, #PLLFEED_OFS]

;  Wait until PLL Locked
PLL_Loop        LDR     R3, [R0, #PLLSTAT_OFS]
                ANDS    R3, R3, #PLLSTAT_PLOCK
                BEQ     PLL_Loop

;  Switch to PLL Clock
                MOV     R3, #(PLLCON_PLLE:OR:PLLCON_PLLC)
                STR     R3, [R0, #PLLCON_OFS]
                STR     R1, [R0, #PLLFEED_OFS]
                STR     R2, [R0, #PLLFEED_OFS]
                ENDIF   ; PLL_SETUP


; Setup MAM
                IF      MAM_SETUP <> 0
                LDR     R0, =MAM_BASE
                MOV     R1, #MAMTIM_Val
                STR     R1, [R0, #MAMTIM_OFS] 
                MOV     R1, #MAMCR_Val
                STR     R1, [R0, #MAMCR_OFS] 
                ENDIF   ; MAM_SETUP


; Memory Mapping (when Interrupt Vectors are in RAM)
MEMMAP          EQU     0xE01FC040      ; Memory Mapping Control
                IF      :DEF:REMAP
                LDR     R0, =MEMMAP
                IF      :DEF:EXTMEM_MODE
                MOV     R1, #3
                ELIF    :DEF:RAM_MODE
                MOV     R1, #2
                ELSE
                MOV     R1, #1
                ENDIF
                STR     R1, [R0]
                ENDIF


; Initialise Interrupt System
;  ...


; Setup Stack for each mode

                LDR     R0, =Stack_Top

;  Enter Undefined Instruction Mode and set its Stack Pointer
                MSR     CPSR_c, #Mode_UND:OR:I_Bit:OR:F_Bit
                MOV     SP, R0
                SUB     R0, R0, #UND_Stack_Size

;  Enter Abort Mode and set its Stack Pointer
                MSR     CPSR_c, #Mode_ABT:OR:I_Bit:OR:F_Bit
                MOV     SP, R0
                SUB     R0, R0, #ABT_Stack_Size

;  Enter FIQ Mode and set its Stack Pointer
                MSR     CPSR_c, #Mode_FIQ:OR:I_Bit:OR:F_Bit
                MOV     SP, R0
                SUB     R0, R0, #FIQ_Stack_Size

;  Enter IRQ Mode and set its Stack Pointer
                MSR     CPSR_c, #Mode_IRQ:OR:I_Bit:OR:F_Bit
                MOV     SP, R0
                SUB     R0, R0, #IRQ_Stack_Size

;  Enter Supervisor Mode and set its Stack Pointer
                MSR     CPSR_c, #Mode_SVC:OR:I_Bit:OR:F_Bit
                MOV     SP, R0
                SUB     R0, R0, #SVC_Stack_Size

;  Enter User Mode and set its Stack Pointer
                MSR     CPSR_c, #Mode_USR
                IF      :DEF:__MICROLIB

                EXPORT __initial_sp

                ELSE

                MOV     SP, R0
                SUB     SL, SP, #USR_Stack_Size

                ENDIF


; Enter the C code

                IMPORT  __main
                LDR     R0, =__main
                BX      R0


                IF      :DEF:__MICROLIB

                EXPORT  __heap_base
                EXPORT  __heap_limit

                ELSE
; User Initial Stack & Heap
                AREA    |.text|, CODE, READONLY

                IMPORT  __use_two_region_memory
                EXPORT  __user_initial_stackheap
__user_initial_stackheap

                LDR     R0, =  Heap_Mem
                LDR     R1, =(Stack_Mem + USR_Stack_Size)
                LDR     R2, = (Heap_Mem +      Heap_Size)
                LDR     R3, = Stack_Mem
                BX      LR
                ENDIF


                END

[BenC]

Retarget.c Dosyası

/******************************************************************************/
/* This file is part of the uVision/ARM development tools.                    */
/* Copyright (c) 2005-2006 Keil Software. All rights reserved.                */
/* This software may only be used under the terms of a valid, current,        */
/* end user licence from KEIL for a compatible version of KEIL software       */
/* development tools. Nothing else gives you the right to use this software.  */
/******************************************************************************/

#include <stdio.h>
#include <rt_misc.h>

#pragma import(__use_no_semihosting_swi)

		  
extern int sendchar(int ch);  /* in serial.c */
extern int getkey (void);

	 

extern int uart0_putc(int c);
extern int uart1_putc(int c);

extern int uart0_puts(char *p);
extern int uart1_puts(char *p);

extern int MyGetKey0(void);
extern int MyGetKey1(void);

struct __FILE { int handle; /* Add whatever you need here */ };
FILE __stdout;


int fputc(int ch, FILE *f) {
  return (sendchar(ch));
}


int ferror(FILE *f) {
  /* Your implementation of ferror */
  return EOF;
}


void _ttywrch(int ch) {
  sendchar(ch);
}


void _sys_exit(int return_code) {
label:  goto label;  /* endless loop */
}

Serial.c Dosyası

/******************************************************************************/
/* SERIAL.C: Low Level Serial Routines                                        */
/******************************************************************************/
/* This file is part of the uVision/ARM development tools.                    */
/* Copyright (c) 2005-2006 Keil Software. All rights reserved.                */
/* This software may only be used under the terms of a valid, current,        */
/* end user licence from KEIL for a compatible version of KEIL software       */
/* development tools. Nothing else gives you the right to use this software.  */
/******************************************************************************/

#include <LPC214x.h>                     /* LPC21xx definitions               */



int MyGetKey0(void)  {                     /* Read character from Serial Port   */

  while (!(U0LSR & 0x01));

  return (U0RBR);
}


int MyGetKey1(void)  {                     /* Read character from Serial Port   */

  while (!(U1LSR & 0x01));

  return (U1RBR);
}



/* implementation of putchar (also used by printf function to output data)    */
int sendchar (int ch)  {                 /* Write character to Serial Port    */

 
  while (!(U1LSR & 0x20));
  return (U1THR = ch);
}



int getkey (void)  {                     /* Read character from Serial Port   */

  while (!(U1LSR & 0x01));

  return (U1RBR);
}










int GetKeyT (int xBeklemeSuresi)  

{
	  
	  int j =0, i =0;



	  for( j = 0 ; j < xBeklemeSuresi ; j++ )
		  
		  {

	
			 for( i = 0 ; i < 5000 ; i++ );
			  
			  {
			  	if((U1LSR & 0x01))
					{
					   
					   //uart0_putc(U1RBR);

					   if ( U1RBR == 0x52)  // RING SİNYALİNİN R HARFİ
						{
													  							
					          return(U1RBR);
					 	       
						 }
					}
			  }

			}
  


}


//------------------------------------------------------------------------------------------------//
//---------------------------- Function for send character 1 time via UART0-----------------------//
//------------------------------------------------------------------------------------------------//
int uart0_putc(int c)
{
	while(!(U0LSR & 0x20)); // Wait until UART0 ready to send character  
	U0THR = c; // Send character
}
//------------------------------------------------------------------------------------------------//
//---------------------------- Function for send string via UART1---------------------------------//
//------------------------------------------------------------------------------------------------//
int uart0_puts(char *p)
{
	while(*p) // Point to character
	{
		uart0_putc(*p++);  // Send character then point to next character
	}
}


//------------------------------------------------------------------------------------------------//
//---------------------------- Function for send character 1 time via UART1-----------------------//
//------------------------------------------------------------------------------------------------//
int uart1_putc(int c)
{
	while(!(U1LSR & 0x20)); // Wait until UART1 ready to send character     
	U1THR = c;  // Send character
}
//------------------------------------------------------------------------------------------------//
//---------------------------- Function for send string via UART1---------------------------------//
//------------------------------------------------------------------------------------------------//
int uart1_puts(char *p)
{
	while(*p) // Point to character
	{
		uart1_putc(*p++);   // Send character then point to next character
	}
}

[BenC]

Lcd.h Dosyası

#ifndef _LCD_H
#define _LCD_H

#define MAX_KARAKTER 20								// LCD EKRAN EN BÜYÜK SÜTUN DEĞERİ

#define LCD_VERI_YON	   IO0DIR			// LCD VERİ YOLU YÖNLENDİRMESİ
#define LCD_VERI_SET	   IO0SET			// LCD VERİ YOLU SET (HIGH) 
#define LCD_VERI_CLR	   IO0CLR			// LCD VERİ YOLU CLEAR (LOW)

#define LCD_KONT_YON	   IO0DIR			// LCD KONTROL PORT YÖNLENDİRMESİ
#define LCD_KONT_SET       IO0SET			// LCD KONTROL PORT SET (HIGH)
#define LCD_KONT_CLR       IO0CLR			// LCD KONTROL PORT CLEAR (LOW)

#define LCD_RS	           (1 << 14)		// LCD RS PINI, PIN P0.14
#define LCD_RW	           (1 << 7)			// LCD RW PINI, PIN P0.7
#define LCD_EN	           (1 << 15)		// LCD EN PINI, PIN P0.15

#define LCD_D4 (1 << 10)					// LCD EN PINI, PIN P0.10
#define LCD_D5 (1 << 11)					// LCD EN PINI, PIN P0.11
#define LCD_D6 (1 << 12)					// LCD EN PINI, PIN P0.12
#define LCD_D7 (1 << 13)					// LCD EN PINI, PIN P0.13

#define LCD_VERI_MASK    (LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7)  // LCD VERİ YOLU PINLERI MASKESİ
#define LCD_MESGUL_BAYRAGI    LCD_D7		// LCD MODUL MESGUL PINI P0.13


#define LCD_CONTROL_MASK        0x00003C00	// LCD MODUL KONTROL PORTU MASKESİ




void Lcd_Delay(int xSayac);	  						// LCD BEKLETME FONKSİYONU
void Lcd_Bekle( void );	 							// LCD BEKLEME FONKSİYONU
void Lcd_Komut_Gonder( unsigned char xKomut );		// LCD ye KOMUT GÖNDERME FONKSİYONU
void Lcd_Port_Cikis( void );						// LCD PORTU ÇIKIŞ YAPMA FONKSİYONU
void Lcd_Ekran_Sil( void);							// LCD EKRANI TEMİZLEME FONKSİYONU
int  Lcd_Ekran_XY( unsigned int x, unsigned int y);	// LCD EKRAN ADRESİNE İMLECİ GÖNDERME FONKSİYONU
void Lcd_Veri_Yaz( unsigned char xVeri );			// LCD YE VERI YAZMA FONKSİYONU
void Lcd_PutChar( int c );							// LCD MODULE KARAKTER GÖNDERME FONKSİYONU
void Lcd_PutStr( char *xString );					// LCD MODULE KARAKTER KÜMESİ GÖNDERME FONKSİYONU
void Lcd_Modulu_Hazirla( void );					// LCD MODULU HAZIRLAMA FONKSİYONU


#endif

Lcd.c Dosyası

#include <LPC214x.H>                       // LPC214x TANIMLAMALARI
#include "Lcd.h"						   // LCD FONKSİYON TANIMLAMALARI

/*******************************************************************************/
/***                 LCD İÇİN BEKLETME FONKSİYONU                            ***/
/*******************************************************************************/
/*******************************************************************************/
/*Fonksiyon Adı  : void Lcd_Delay(int xSayac)                                  */
/*Açıklama       : Fonksiyona giren int deger kadar sayarak bekleme sağlar     */
/*               : 60 Mhz de bir döngü 10 (us) mikro saniye. xSayac = 100 ise  */
/*				 : Fonksiyon 1000 us lik bir bekletme sağlamış olur. 		   */
/*                                                                             */
/*Yazar          : Armağan YILMAZ                                              */
/*Tarih          : 05.03.2010                                                  */
/*Version        : 1.0                                                         */
/*                                                                             */
/*Giriş          : int xSayac                                                  */
/*               :                                                             */
/*Çıkış          : Bekleme olusturmak                                          */
/*                                                                             */
/*                                                                             */
/*Kullanılan Veri: 1 byte                                                      */
/*******************************************************************************/
void Lcd_Delay(int xSayac)
	{
  		int j =0, i =0;

		  for( j = 0 ; j < xSayac ; j++ )
		  {
		    for( i = 0 ; i < 35 ; i++ );
		  }
	
	}
/*******************************************************************************/
/*******************************************************************************/



/*******************************************************************************/
/***                      LCD  BEKLEME FONKSİYONU                            ***/
/*******************************************************************************/
/*******************************************************************************/
/*Fonksiyon Adı  : Lcd_Bekle( void )                                           */
/*Açıklama       : Fonksiyon LCD ekranın veri girişi veya veri okumaya hazır   */
/*               : olup olmadığını öğrenmek amaçlı. Meşgul bayrağı yani LCD_D7 */
/*               : pininin low olması gereklidir.                              */
/*               : 60 Mhz de bir döngü 10 (us) mikro saniye. xSayac = 100 ise  */
/*				 : Fonksiyon 1000 us lik bir bekletme sağlamış olur. 		   */
/*                                                                             */
/*Yazar          : Armağan YILMAZ                                              */
/*Tarih          : 05.03.2010                                                  */
/*Version        : 1.0                                                         */
/*                                                                             */
/*Giriş          : int xSayac                                                  */
/*               :                                                             */
/*Çıkış          : Bekleme olusturmak                                          */
/*                                                                             */
/*                                                                             */
/*Kullanılan Veri: 1 byte                                                      */
/*******************************************************************************/
void Lcd_Bekle( void )
	{
	  LCD_KONT_CLR |=  LCD_RS;              // LCD RS pini Low.	
	  LCD_KONT_SET |=  LCD_RW | LCD_EN;		// LCD RW ve RS High.
	
	  while(IO1PIN & LCD_MESGUL_BAYRAGI);	// Meşgul Bayrağının (LCD_D7) low olmasını bekle
	  
	  LCD_KONT_CLR |= LCD_EN | LCD_RW;		// LCD EN ve LCD RW Low.
	  LCD_VERI_YON |= LCD_VERI_MASK;		// LCD Veri (D4,D5,D6,D7) Yönü   
	
	  Lcd_Delay(100);  					    // 1000 us Bekle.
	}
/*******************************************************************************/
/*******************************************************************************/

/*******************************************************************************/
/***                     LCD'YE VERİ YAZMA FONKSİYONU                        ***/
/*******************************************************************************/
/*******************************************************************************/
/*Fonksiyon Adı  : Lcd_Veri_Yaz( unsigned char xVeri )                         */
/*Açıklama       : Fonksiyon LCD Modüle Veri Yazmak için yapılmıştır.          */
/*                                                                             */
/*Yazar          : Armağan YILMAZ                                              */
/*Tarih          : 05.03.2010                                                  */
/*Version        : 1.0                                                         */
/*                                                                             */
/*Giriş          : unsigned char xVeri                                         */
/*               :                                                             */
/*Çıkış          : Fonksiyon Dönüşü Yok                                        */
/*                                                                             */
/*                                                                             */
/*Kullanılan Veri: 1 byte                                                      */
/*******************************************************************************/
void Lcd_Veri_Yaz( unsigned char xVeri )
{
  unsigned char Tmp0 = 0;
  unsigned int  Tmp1 = 0;

  // ÜST 4 BİT GÖNDERİLİYOR.
  Tmp0 = xVeri;
  Tmp0 = ( Tmp0 >> 4 ) & 0x0F;
  Tmp1 = ( Tmp0 << 10 ) & LCD_VERI_MASK;

  LCD_KONT_SET |= LCD_EN | LCD_RS;
  LCD_VERI_CLR = LCD_VERI_MASK;
  LCD_VERI_SET = Tmp1;
  LCD_KONT_CLR |= LCD_EN;

  
  // ALT 4 BİT GÖNDERİLİYOR.
  Tmp0 =  xVeri;
  Tmp0 &= 0x0F;
  Tmp1 = ( Tmp0 << 10 ) & LCD_VERI_MASK;

  LCD_KONT_SET |= LCD_EN | LCD_RS;
  LCD_VERI_CLR = LCD_VERI_MASK;
  LCD_VERI_SET = Tmp1;
  LCD_KONT_CLR |= LCD_EN;

  Lcd_Bekle();
}
/*******************************************************************************/
/*******************************************************************************/


/*******************************************************************************/
/***                   LCD'YE KOMUT GÖNDERME  FONKSİYONU                     ***/
/*******************************************************************************/
/*******************************************************************************/
/*Fonksiyon Adı  : Lcd_Komut_Gonder( unsigned char xKomut )                    */
/*Açıklama       : Fonksiyon LCD Modüle Komut Göndermek için yapılmıştır.      */
/*               : LCD Modüllerde bulunan cursor on/off,ekran adresi,temizleme */
/*               : imleç sağa/sola vs komutları göndermek için.                */
/*                                                                             */
/*Yazar          : Armağan YILMAZ                                              */
/*Tarih          : 05.03.2010                                                  */
/*Version        : 1.0                                                         */
/*                                                                             */
/*Giriş          : unsigned char xKomut                                        */
/*               :                                                             */
/*Çıkış          : Fonksiyon Dönüşü Yok                                        */
/*                                                                             */
/*                                                                             */
/*Kullanılan Veri: 1 byte                                                      */
/*******************************************************************************/

void Lcd_Komut_Gonder( unsigned char xKomut )
{
  unsigned char Tmp0 = 0 ;
  unsigned int  Tmp1 = 0 ;

  Tmp0 = xKomut;
  Tmp0 = ( Tmp0 >> 4 ) & 0x0F ;	 			// Tmp0 ın ilk 4 bitini al.
  Tmp1 = ( Tmp0 << 10 ) & LCD_VERI_MASK ;	// D4,D5,D6,D7 ile Tmp0 and le int Tmp1 ata.

  LCD_KONT_CLR = LCD_RS;					// LCD RS PIN LOW.
  LCD_KONT_SET = LCD_EN;					// LCD EN PIN HIGH.
  LCD_VERI_CLR = LCD_VERI_MASK;				// LCD D4,D5,D6,D7 LOW.
  LCD_VERI_SET = Tmp1 ;						// LCD VERI YOLUNA Tmp1 YAZ.

  Lcd_Delay(10000);							// 100000 uS BEKLE.

  LCD_KONT_CLR = LCD_EN;					// LCD EN PIN LOW. 

  Tmp0 = xKomut ;
  Tmp0 &= 0x0F  ;							// Tmp0 DEĞİŞKENİNİN ÜST 4 BİTİNİ SIFIRLA
  Tmp1 = ( Tmp0 << 10 ) & LCD_VERI_MASK;	// D4,D5,D6,D7 ile Tmp0 and le int Tmp1 ata.

  Lcd_Delay(100*2);							// 20 uS BEKLE.

  LCD_KONT_CLR |= LCD_RS;					// LCD RS PIN LOW.
  LCD_KONT_SET |= LCD_EN;					// LCD EN PIN HIGH
  LCD_VERI_CLR = LCD_VERI_MASK;				// LCD D4,D5,D6,D7 LOW.
  LCD_VERI_SET = Tmp1;						// LCD VERI YOLUNA Tmp1 YAZ.

  Lcd_Delay(10000);							// 100000 uS BEKLE.

  LCD_KONT_CLR |= LCD_EN;					// LCD EN PIN LOW.

  Lcd_Bekle();								// LCD MODÜLÜN HAZIR OLMASINI BEKLE.
}
/*******************************************************************************/
/*******************************************************************************/



/*******************************************************************************/
/***             LCD PORTU ÇIKIŞ OLARAK AYARLAMA FONKSİYONU                  ***/
/*******************************************************************************/
/*******************************************************************************/
/*Fonksiyon Adı  : Lcd_Port_Cikis( void )                                      */
/*Açıklama       : Fonksiyon LCD port bağlantı yönünü Çıkış olarak ayarlamak   */
/*               : için yapılmıştır.                                           */
/*                                                                             */
/*Yazar          : Armağan YILMAZ                                              */
/*Tarih          : 05.03.2010                                                  */
/*Version        : 1.0                                                         */
/*                                                                             */
/*Giriş          : Fonksiyon Girişi Yok                                        */
/*               :                                                             */
/*Çıkış          : Fonksiyon Dönüşü Yok                                        */
/*                                                                             */
/*Kullanılan Veri: 1 byte                                                      */
/*******************************************************************************/
void Lcd_Port_Cikis( void )
	{
	  LCD_KONT_YON |= ( LCD_EN | LCD_RS | LCD_RW );
	  LCD_KONT_CLR |= ( LCD_EN | LCD_RS | LCD_RW );	
	  LCD_VERI_YON |= LCD_VERI_MASK;
	}
/*******************************************************************************/
/*******************************************************************************/



/*******************************************************************************/
/***                   LCD EKRANINI TEMİZLEME FONKSİYONU                     ***/
/*******************************************************************************/
/*******************************************************************************/
/*Fonksiyon Adı  : Lcd_Ekran_Sil( void )                                       */
/*Açıklama       : Fonksiyon LCD Ekranını Temizlemek İçin Yapılmıştır.         */
/*               : LCD Ekran Temizleme Verisi 0x01h dir.                       */
/*                                                                             */
/*Yazar          : Armağan YILMAZ                                              */
/*Tarih          : 05.03.2010                                                  */
/*Version        : 1.0                                                         */
/*                                                                             */
/*Giriş          : Fonksiyon Girişi Yok                                        */
/*               :                                                             */
/*Çıkış          : Fonksiyon Dönüşü Yok                                        */
/*                                                                             */
/*Kullanılan Veri: 1 byte                                                      */
/*******************************************************************************/

void Lcd_Ekran_Sil( void)
	{
  		Lcd_Komut_Gonder( 0x01 );
	}
/*******************************************************************************/
/*******************************************************************************/



/*******************************************************************************/
/***      İMLECİ LCD EKRANIN İSTENİLEN ADRESİNE GÖNDERME  FONKSİYONU         ***/
/*******************************************************************************/
/*******************************************************************************/
/*Fonksiyon Adı  : Lcd_Ekran_XY( unsigned int x ,unsigned int y )              */
/*Açıklama       : Fonksiyon LCD Modülün istenilen ekran adresine veri yazmak  */
/*               : için yapılmıştır. X satırı, Y Sütunu ifade etmektedir. 4x20 */
/*               : satır bir modülde x en fazla 4, y en fazla 20 olabilir.     */
/*                                                                             */
/*Yazar          : Armağan YILMAZ                                              */
/*Tarih          : 05.03.2010                                                  */
/*Version        : 1.0                                                         */
/*                                                                             */
/*Giriş          : unsigned int x ,unsigned int y                              */
/*               :                                                             */
/*Çıkış          : x > 4 veya y > 19 olursa Fonksiyon dönüş değeri -1 dir.     */
/*                                                                             */
/*                                                                             */
/*Kullanılan Veri: 1 byte                                                      */
/*******************************************************************************/
int Lcd_Ekran_XY( unsigned int x, unsigned int y)
	{
	  int HataDurumu = 0;
	  
		  if( (x > 4) && (y > 19) )	  					// X ve Y Sınırdışı ise -1 Döndür.
		  	{
		    	HataDurumu = -1;
		  	} 
		  else 
		  	{
			  if( x == 1 )
				 {
				  	Lcd_Komut_Gonder( 0x80 + y );		//İmleç 1 nci Satır y ninci sütun
				 } 
			  
			  if( x==2 )
				 {
				  	Lcd_Komut_Gonder( 0xC0 + y );		//İmleç 2 nci Satır y ninci sütun
				 }
			   
			  if( x==3 )
			  	{
			    	Lcd_Komut_Gonder( 0x94 + y );		//İmleç 3 nci Satır y ninci sütun
			    }
			
			  if( x==4 )
			  	{
			    	Lcd_Komut_Gonder( 0xD4 + y );		//İmleç 4 nci Satır y ninci sütun
			    }
	
			}
	
	   
	   	return HataDurumu;
	}
/*******************************************************************************/
/*******************************************************************************/








/*******************************************************************************/
/***                  LCD'YE KARAKTER YAZMA FONKSİYONU                       ***/
/*******************************************************************************/
/*******************************************************************************/
/*Fonksiyon Adı  : Lcd_PutChar( int c )                                        */
/*Açıklama       : Fonksiyon LCD Modüle Karakter Veri Yazmak için yapılmıştır. */
/*                                                                             */
/*Yazar          : Armağan YILMAZ                                              */
/*Tarih          : 05.03.2010                                                  */
/*Version        : 1.0                                                         */
/*                                                                             */
/*Giriş          : int c                                                       */
/*               :                                                             */
/*Çıkış          : Fonksiyon Dönüşü Yok                                        */
/*                                                                             */
/*                                                                             */
/*Kullanılan Veri: 1 byte                                                      */
/*******************************************************************************/
void Lcd_PutChar( int c )
	{
  		Lcd_Veri_Yaz( c );	  // KARAKTERİ LCD EKRANA YAZ.
	}
/*******************************************************************************/
/*******************************************************************************/







/*******************************************************************************/
/***           LCD'YE KARAKTER KÜMESİ YAZMA FONKSİYONU                       ***/
/*******************************************************************************/
/*******************************************************************************/
/*Fonksiyon Adı  : Lcd_PutStr( char *xString )                                 */
/*Açıklama       : Fonksiyon LCD Modüle Karakter Veri Yazmak için yapılmıştır. */
/*                                                                             */
/*Yazar          : Armağan YILMAZ                                              */
/*Tarih          : 05.03.2010                                                  */
/*Version        : 1.0                                                         */
/*                                                                             */
/*Giriş          : int c                                                       */
/*               :                                                             */
/*Çıkış          : Fonksiyon Dönüşü Yok                                        */
/*                                                                             */
/*                                                                             */
/*Kullanılan Veri: 1 byte                                                      */
/*******************************************************************************/
void Lcd_PutStr( char *xString ) 

	{
	  unsigned char Boyut = MAX_KARAKTER;
	  
	  while(* xString != '\0' && Boyut--)	// BOYUT VE KARAKTER KÜMESİ BİTENE KADAR DEVAM ET.
			{
	    		Lcd_PutChar( *xString );	// KARAKTERİ LCD EKRANA YAZ.
	
	    		xString++;	 				// SONRAKİ KARAKTERE GEÇ.
	  		}
	}
/*******************************************************************************/
/*******************************************************************************/




/*******************************************************************************/
/***                    LCD MODÜLÜ HAZIRLANMA FONKSİYONU                     ***/
/*******************************************************************************/
/*******************************************************************************/
/*Fonksiyon Adı  : Lcd_Modulu_Hazirla( void )                                  */
/*Açıklama       : Fonksiyon LCD Modülü çalışmaya hazır hale getirmek İçin     */
/*                                                                             */
/*Yazar          : Armağan YILMAZ                                              */
/*Tarih          : 05.03.2010                                                  */
/*Version        : 1.0                                                         */
/*                                                                             */
/*Giriş          : Fonksiyon Girişi Yok                                        */
/*               :                                                             */
/*Çıkış          : Fonksiyon Dönüşü Yok                                        */
/*                                                                             */
/*Kullanılan Veri: 1 byte                                                      */
/*******************************************************************************/

void Lcd_Modulu_Hazirla( void )
{
  Lcd_Port_Cikis()      ;		// LCD PORTU ÇIKIŞ OLARAK YÖNLENDİR.
  Lcd_Delay(100*100)    ;		// 10000 uS BEKLE
  Lcd_Komut_Gonder(0x28);       // VERI YOLU 4 BIT 2 SATIR 5X7 FONT.      
  Lcd_Ekran_Sil()       ;       // LCD EKRANI TEMİZLE.
  Lcd_Komut_Gonder(0x02);       // İMLECİ BAŞA AL.
  Lcd_Komut_Gonder(0x06);       // İMLECİ TAŞI. 
  Lcd_Komut_Gonder(0x0C);       // LCD EKRANI AÇ
  Lcd_Ekran_XY(0, 0)    ;		// LCD EKRANDA 0,0 ADRESİNE GİT
  Lcd_Ekran_Sil()       ;		// LCD EKRANI TEMİZLE.

}
/*******************************************************************************/
/*******************************************************************************/

KeyPad.h Dosyası

#ifndef _KEYPAD_H
#define _KEYPAD_H


void Bekle(int count);
 void KeyPadInit (void);
   int KeyPadOku (void);
		int KeyPadOkuSon (void);

#endif

KeyPad.c Dosyası

#include <LPC214x.H>                       
#include "KeyPad.h"

#define GPIO1_IODIR	   IO1DIR
#define GPIO1_IOCLR	   IO1CLR
#define GPIO1_IOSET	   IO1SET
#define GPIO1_IOPIN	   IO1PIN	


#define KBD_ROW1        ( 1 << 16 ) 
#define KBD_ROW2        ( 1 << 17 ) 
#define KBD_ROW3        ( 1 << 18 ) 
#define KBD_ROW4        ( 1 << 19 ) 
#define KBD_COL1        ( 1 << 20 ) 
#define KBD_COL2        ( 1 << 21 ) 
#define KBD_COL3        ( 1 << 22 ) 
#define KBD_COL4        ( 1 << 23 ) 

#define KBD_ROW_SHIFT   16

#define KBD_ROW_MASK  (KBD_ROW1 | KBD_ROW2 | KBD_ROW3 | KBD_ROW4)

#define kbdReadRow() ((GPIO1_IOPIN & KBD_ROW_MASK) >> KBD_ROW_SHIFT)




void Bekle(int count)
{
  int j=0,i=0;

  for(j=0;j<count;j++)
  {
    for(i=0;i<35;i++);
  }
}








void KeyPadInit (void)
 {
  GPIO1_IODIR &= ~(KBD_ROW4 | KBD_ROW3 | KBD_ROW2 | KBD_ROW1); 
  GPIO1_IODIR |=  (KBD_COL4 | KBD_COL3 | KBD_COL2 | KBD_COL1); 
  GPIO1_IOCLR  =  (KBD_COL4 | KBD_COL3 | KBD_COL1 | KBD_COL1); 

 }



int KeyPadOku (void)
{
  unsigned int keys;

  if ((GPIO1_IOPIN & KBD_ROW_MASK) == KBD_ROW_MASK)
    return 0;

  GPIO1_IOSET = (KBD_COL3 | KBD_COL2 | KBD_COL1);
  Bekle (50);
  keys = kbdReadRow () << 12;
  GPIO1_IOSET = KBD_COL4;

  GPIO1_IOCLR = KBD_COL3;
  Bekle(50);
  keys |= (kbdReadRow () << 8);
  GPIO1_IOSET = KBD_COL3;

  GPIO1_IOCLR = KBD_COL2;
  Bekle (50);
  keys |= (kbdReadRow () << 4);
  GPIO1_IOSET = KBD_COL2;

  GPIO1_IOCLR = KBD_COL1;
  Bekle (50);
  keys |= (kbdReadRow () << 0);

  GPIO1_IOCLR = (KBD_COL4 | KBD_COL3 | KBD_COL2 | KBD_COL1);


	keys = keys^ 0xffff;

  //printf("Keys=%d\r\n",keys);
 /*
  keys = keys ^ 0xffff; 		



  if (keys == 1 )
  		{
		 keys = 0x01 ;
		 return keys;
		}
  if (keys == 16 )
  		{
		 keys = 0x02 ;
		 return keys;
		}
  if (keys == 256 )
  		{
		 keys = 0x03 ;
		 return keys;
		}
  if (keys == 4096 )
  		{
		 keys = 0x0A ;
		 return keys;
		}


  if (keys == 2 )
  		{
		 keys = 0x04 ;
		 return keys;
		}
  if (keys == 32 )
  		{
		 keys = 0x05 ;
		 return keys;
		}
  if (keys == 512 )
  		{
		 keys = 0x06 ;
		 return keys;
		}
  if (keys == 8192 )
  		{
		 keys = 0x0B ;
		 return keys;
		}


  if (keys == 4 )
  		{
		 keys = 0x07 ;
		 return keys;
		}
  if (keys == 64 )
  		{
		 keys = 0x08 ;
		 return keys;
		}
  if (keys == 1024 )
  		{
		 keys = 0x09 ;
		 return keys;
		}
  if (keys == 16384 )
  		{
		 keys = 0x0C ;
		 return keys;
		}



  if (keys == 8 )
  		{
		 keys = 0x0F ;
		 return keys;
		}
  if (keys == 128 )
  		{
		 keys = 0x00 ;
		 return keys;
		}
  if (keys == 2048 )
  		{
		 keys = 0x0E ;
		 return keys;
		}
  if (keys == 32768 )
  		{
		 keys = 0x0D ;
		 return keys;
		}

 */



  return keys ;

  		



}


int KeyPadOkuSon (void)
{
  unsigned int keys;

  if ((GPIO1_IOPIN & KBD_ROW_MASK) == KBD_ROW_MASK)
    return -9999;

  GPIO1_IOSET = (KBD_COL3 | KBD_COL2 | KBD_COL1);
  Bekle (50);
  keys = kbdReadRow () << 12;
  GPIO1_IOSET = KBD_COL4;

  GPIO1_IOCLR = KBD_COL3;
  Bekle(50);
  keys |= (kbdReadRow () << 8);
  GPIO1_IOSET = KBD_COL3;

  GPIO1_IOCLR = KBD_COL2;
  Bekle (50);
  keys |= (kbdReadRow () << 4);
  GPIO1_IOSET = KBD_COL2;

  GPIO1_IOCLR = KBD_COL1;
  Bekle (50);
  keys |= (kbdReadRow () << 0);

  GPIO1_IOCLR = (KBD_COL4 | KBD_COL3 | KBD_COL2 | KBD_COL1);



  keys = keys ^ 0xffff; 		

  

  if (keys == 1 )
  		{
		 keys = 0x31 ;
		 return keys;
		}
  if (keys == 16 )
  		{
		 keys = 0x32 ;
		 return keys;
		}
  if (keys == 256 )
  		{
		 keys = 0x33 ;
		 return keys;
		}
  if (keys == 4096 )
  		{
		 keys = 0x0A ;
		 return keys;
		}


  if (keys == 2 )
  		{
		 keys = 0x34 ;
		 return keys;
		}
  if (keys == 32 )
  		{
		 keys = 0x35 ;
		 return keys;
		}
  if (keys == 512 )
  		{
		 keys = 0x36 ;
		 return keys;
		}
  if (keys == 8192 )
  		{
		 keys = 0x0B ;
		 return keys;
		}


  if (keys == 4 )
  		{
		 keys = 0x37 ;
		 return keys;
		}
  if (keys == 64 )
  		{
		 keys = 0x38 ;
		 return keys;
		}
  if (keys == 1024 )
  		{
		 keys = 0x39 ;
		 return keys;
		}
  if (keys == 16384 )
  		{
		 keys = 0x0C ;
		 return keys;
		}



  if (keys == 8 )
  		{
		 keys = 0x0F ;
		 return keys;
		}
  if (keys == 128 )
  		{
		 keys = 0x30 ;
		 return keys;
		}
  if (keys == 2048 )
  		{
		 keys = 0x0E ;
		 return keys;
		}
  if (keys == 32768 )
  		{
		 keys = 0x0D ;
		 return keys;
		}


 

  if ((keys == 65535) )
  		{
		 keys = 0x10;
		 return keys;
		}



//  return keys ^ 0xffff;

  		



}

Menu.h Dosyası

#ifndef _MENU_H
#define _MENU_H


void Menu_Main();
void Menu_Ayarlar();
void Menu_Seyir();
int Tus_Coz();




#endif

[BenC]

Menu.c Dosyası

#include <LPC214x.H>
#include	<ctype.h>
#include	<float.h>
#include	<math.h>
#include	<stdlib.h>


//#include "KeyPad.c"
#include "Menu.h" 

extern int Tus,TusUp;
extern int AlarmDrm;

extern int TusKilidi;

extern double GDereceE,GDakikaE,GSaniyeE;
extern double GDereceB,GDakikaB,GSaniyeB;

extern double s;

extern double GpsSaatDbl;
extern double GpsDakikaDbl;
extern double GpsSaniyeDbl;

extern int GpsSaat;
extern int GpsDakika;
extern int GpsSaniye;


extern double BaslangicZamani;
extern double AktifZaman;


extern double TopS;		// Toplam Mesafe S.
extern double KatS;		// Katedilen Mesafe KatS.
extern double KalS;			// Kalan Mesafe KalS.

extern int TopSS;		// Toplam Mesafe S.
extern int KatSS;		// Katedilen Mesafe KatS.
extern int KalSS;			// Kalan Mesafe KalS.



extern double HDereceE,HDakikaE,HSaniyeE;
extern double HDereceB,HDakikaB,HSaniyeB;

extern char LcdLedDrm;
extern char TimeDrm;
extern char MenuMainDrm;
extern char MenuKonumDetayDrm;

extern char MenNum;

extern double fi1; 
extern double l1;

extern double fi2;
extern double l2 ;

extern int AcilmaS;
extern double AcilmaFi2;
extern double AcilmaL2;

extern int  der,dak,ss;
extern int TusPtr;
extern char TusBuf[8];

extern int intVSaat,intVDakika,intVSaniye;
extern double dblVSaat,dblVDakika,dblVSaniye;



int i;



void BekleKeyUp()

	{
	 TusUp = KeyPadOkuSon(); 
	 
	 while(!(TusUp == -9999))
	 
	 	{
		 	TusUp = KeyPadOkuSon();
		}

	 DelayMs(50);

	}


void BekleKeyDown()

	{
		Tus = KeyPadOkuSon();

		while( Tus == -9999 )
		 
		{
		 	Tus = KeyPadOkuSon();
		}

	}






void Menu_Main()
	{
	  int Sayac = 0;

	  	Lcd_Ekran_XY(1,0); 
		Lcd_PutStr("1) KONUM ");
		Lcd_Ekran_XY(2,0);
 		Lcd_PutStr("2) SEYIR");
		Lcd_Ekran_XY(3,0);
 		Lcd_PutStr("3) SEYIR DETAY");
		Lcd_Ekran_XY(4,0);
 		Lcd_PutStr("4) ALARM");

		TUS_KONTROL();

		return;
	}



void Menu_Alarm()

	{

	  	int Sayac = 0;
		unsigned char Deger1,Deger2,Deger3=0;

	  	Lcd_Ekran_XY(2,0);
 		Lcd_PutStr("ACILMA MESAFESINI");
		Lcd_Ekran_XY(3,0);
 		Lcd_PutStr("GIRINIZ (Metre) =");
		
	
	

////////////////  ENLEM DERECE /////////////////////
		for(i = 0; i <= 7; i++)
			{
				TusBuf[i]= 0;
			}

		TusPtr=0;
		Lcd_Ekran_XY(3,17);
	   	for(;;)

			{
				BekleKeyDown();
		
		
			    //printf("\r\nTUS = %c",Tus);
		
				BekleKeyUp();


				 if (Tus == 0x0C)		// ISIK KONTROL
					
					  {
					    ISIK_KONTROL();	
					  }



				if (Tus == 0x0D )	   // ENTER TUSU
					{
						//printf("\r\nENTER = %d",Tus);
				    	break;				 
					}

				if ((Tus >= 0x30) & (Tus <= 0x39))		// 0 ile 9 Arası Giriş
					{
						Lcd_PutChar(Tus);
						TusBuf[TusPtr++] = Tus;
					}




				if (Tus == 0x0E )	  // DELETE TUSU

					{	
						Lcd_Ekran_XY(3,17);	
						Lcd_PutStr("   ");
						Lcd_Ekran_XY(3,17);	
				
						for(i = 0; i <= 7; i++)
							{
								TusBuf[i]= 0;
							}
						TusPtr = 0;
						DelayMs(100);
					}
		

			}

//printf("\r\nMESAFE=");
/*
for(MenNum = 0; MenNum <= 7; MenNum++)
	{
		sendchar(TusBuf[MenNum]);
	}
printf("\r\n");
*/

			if(TusPtr >= 4 )
				{
				AcilmaS = DigToDec(0,0,0,TusBuf[0],TusBuf[1],TusBuf[2],TusBuf[3]);
				//printf("\r\nAcilmaS 4 = %d\r\n",AcilmaS);
				}
			if(TusPtr == 3 )
				{
				AcilmaS = DigToDec(0,0,0,0,TusBuf[0],TusBuf[1],TusBuf[2]);
				//printf("\r\nAcilmaS 3 = %d\r\n",AcilmaS);
				}
			if(TusPtr == 2 )
				{
				AcilmaS = DigToDec(0,0,0,0,0,TusBuf[0],TusBuf[1]);
				//printf("\r\nAcilmaS 2 = %d\r\n",AcilmaS);
				}
			if(TusPtr == 1 )
				{
				AcilmaS = DigToDec(0,0,0,0,0,0,TusBuf[0]);
			  	//printf("\r\nAcilmaS 1 = %d\r\n",AcilmaS);
				}


		//AcilmaS   = DigToDec(0,0,0,0,Deger1,Deger2,Deger3);
		AcilmaFi2 = GDereceE;
		AcilmaL2  = GDereceB;

		
		
			

		

		Lcd_Ekran_Sil();
	  	Lcd_Ekran_XY(2,0);
 		Lcd_PutStr("ACILMA MESAFESI");
		Lcd_Ekran_XY(3,0);
 		Lcd_PutStr("GIRILDI !");

		DelayMs(1000);

		//printf("\r\nACILMA S = %d: %f : %f",AcilmaS,GDereceE,GDereceB);

		Lcd_Ekran_Sil();
		AlarmDrm = 1;
		MenNum = 7 ;
		TusKilidi = 1;
		ss = 0 ;
	}




void Menu_Seyir()

	{
		int TusSay = 0 ;

	  	int Sayac = 0 ;
		unsigned char Deger1,Deger2,Deger3=0;

		double OnSaniye; // ONDALIKLI SANIYE ICIN


	   	for(;;)

			{
				BekleKeyDown();
		
		
			    //printf("\r\nTUS = %c",Tus);
		
				BekleKeyUp();


				Lcd_Ekran_Sil();
			  	Lcd_Ekran_XY(1,0); 
				Lcd_PutStr("Yeni Hedef Koord." );
			  	Lcd_Ekran_XY(2,0); 
				Lcd_PutStr("Girecekmisiniz..." );
			  	
				Lcd_Ekran_XY(4,0); 
				Lcd_PutStr("EVET=>ENT HAYIR=>DEL");


				if (Tus == 0x0C)		// ISIK KONTROL
					
					  {
					    ISIK_KONTROL();	
					  }

				if (Tus == 0x0A)		// ANA MENÜ
					
					  {
					    MenNum = 0;
						//Lcd_Ekran_Sil();
						DelayMs(200);
						return;	
					  }



				if (Tus == 0x0E )	// Delete TUSU
					{
						MenNum = 2;
						return;				 
					}

				if (Tus == 0x0D )	// Enter TUSU
						break;				 
			

			}


/*		
		if ( (fi2 != 0) & (l2 != 0)  )
			{
				Lcd_Ekran_Sil();
			  	//Lcd_Ekran_XY(1,0); 
				//Lcd_PutStr("Veri Girilmistir." );
				//DelayMs(500),
				//Lcd_Ekran_Sil();
				MenNum = 2;
				return;
			}

*/



		Lcd_Ekran_Sil();

	  	Lcd_Ekran_XY(1,0); 
		Lcd_PutStr("HEDEF NOKTA ENLEMI" );
		Lcd_Ekran_XY(2,0);
 		Lcd_PutStr("Derece = ");
		Lcd_Ekran_XY(3,0);
 		Lcd_PutStr("Dakika = ");
		Lcd_Ekran_XY(4,0);
 		Lcd_PutStr("Saniye = ");

		Lcd_Komut_Gonder(0x0D) ;
	
		
////////////////  ENLEM DERECE /////////////////////
		for(i = 0; i <= 7; i++)
			{
				TusBuf[i]= 0;
			}

		TusPtr=0;
		Lcd_Ekran_XY(2,9);
	   	for(;;)

			{
				BekleKeyDown();
		
		
			    //printf("\r\nTUS = %c",Tus);
		
				BekleKeyUp();


				 if (Tus == 0x0C)		// ISIK KONTROL
					
					  {
					    ISIK_KONTROL();	
					  }


				if (Tus == 0x0A)		// ANA MENÜ
					
					  {
					    MenNum = 0;
						Lcd_Komut_Gonder(0x0C) ;
						Lcd_Ekran_Sil();
						DelayMs(200);
						return;	
					  }



				if (Tus == 0x0D )	// ENTER TUSU
					{
						//printf("\r\nENTER = %d",Tus);
				    	break;				 
					}

				if ((Tus >= 0x30) & (Tus <= 0x39))		// 0 ile 9 Arası Giriş
					{
						Lcd_PutChar(Tus);
						TusBuf[TusPtr++] = Tus;
					}



				if (Tus == 0x0E )  // DELETE TUSU

					{	
						Lcd_Ekran_XY(2,9);	
						Lcd_PutStr("           ");
						Lcd_Ekran_XY(2,9);	
				
						for(i = 0; i <= 7; i++)
							{
								TusBuf[i]= 0;
							}
						TusPtr = 0;
						DelayMs(100);
					}
		

			}
/*
printf("\r\nTUS BUFER=");

for(MenNum = 0; MenNum <= 7; MenNum++)
	{
		sendchar(TusBuf[MenNum]);
	}
printf("\r\n");

*/
			if(TusPtr >= 3 )
				{
				HDereceE = DigToDec(0,0,0,0,TusBuf[0],TusBuf[1],TusBuf[2]);
				//printf("\r\nHDERECE 3 = %f\r\n",HDereceE);
				}
			if(TusPtr == 2 )
				{
				HDereceE = DigToDec(0,0,0,0,0,TusBuf[0],TusBuf[1]);
				//printf("\r\nHDERECE 2 = %f\r\n",HDereceE);
				}
			if(TusPtr == 1 )
				{
				HDereceE = DigToDec(0,0,0,0,0,0,TusBuf[0]);
			  	//printf("\r\nHDERECE 1 = %f\r\n",HDereceE);
				}


////////////////  ENLEM DADIKA /////////////////////
		for(i = 0; i <= 7; i++)
			{
				TusBuf[i]= 0;
			}

		TusPtr=0;
		Lcd_Ekran_XY(3,9);
	   	for(;;)

			{
				BekleKeyDown();
		
		
			    //printf("\r\nTUS = %c",Tus);
		
				BekleKeyUp();


				 if (Tus == 0x0C)		// ISIK KONTROL
					
					  {
					    ISIK_KONTROL();	
					  }


				if (Tus == 0x0A)		// ANA MENÜ
					
					  {
					    MenNum = 0;
						Lcd_Komut_Gonder(0x0C) ;
						Lcd_Ekran_Sil();
						DelayMs(200);
						return;	
					  }


				if (Tus == 0x0D )	// ENTER TUSU
					{
						//printf("\r\nENTER = %d",Tus);
				    	break;				 
					}

				if ((Tus >= 0x30) & (Tus <= 0x39))		// 0 ile 9 Arası Giriş
					{
						Lcd_PutChar(Tus);
						TusBuf[TusPtr++] = Tus;
					}


				if (Tus == 0x0E ) // DELETE TUSU

					{	
						Lcd_Ekran_XY(3,9);	
						Lcd_PutStr("           ");
						Lcd_Ekran_XY(3,9);	
				
						for(i = 0; i <= 7; i++)
							{
								TusBuf[i]= 0;
							}
						TusPtr = 0;
						DelayMs(100);
					}
		

			}
/*
printf("\r\nTUS BUFER=");

for(MenNum = 0; MenNum <= 7; MenNum++)
	{
		sendchar(TusBuf[MenNum]);
	}
printf("\r\n");

*/	
			
			if(TusPtr >= 2 )
				{
				HDakikaE = DigToDec(0,0,0,0,0,TusBuf[0],TusBuf[1]);
				//printf("\r\nHDAKIKA 2 = %f\r\n",HDakikaE);
				}
			if(TusPtr == 1 )
				{
				HDakikaE = DigToDec(0,0,0,0,0,0,TusBuf[0]);
			  	//printf("\r\nHDAKIKA 1 = %f\r\n",HDakikaE);
				}



////////////////  ENLEM SANIYE /////////////////////
		for(i = 0; i <= 7; i++)
			{
				TusBuf[i]= 0;
			}

		TusPtr=0;
		Lcd_Ekran_XY(4,9);
	   	for(;;)

			{
				BekleKeyDown();
		
		
			    //printf("\r\nTUS = %c",Tus);
		
				BekleKeyUp();

				if (Tus == 0x0A)		// ANA MENÜ
					
					  {
					    MenNum = 0;
						Lcd_Komut_Gonder(0x0C) ;
						Lcd_Ekran_Sil();
						DelayMs(200);
						return;	
					  }



				if (Tus == 0x0D )	// ENTER TUSU
					{
						OnSaniye = atof(TusBuf);
				    	//printf("\r\nSANIYE =%f",OnSaniye);
						break;				 
					}
				else
					{
						if (Tus == 0x0F ) // Ondalıklı Sayılar için Nokta.
							{
								Tus = 0x2E;
							}
							  
						Lcd_PutChar(Tus);
						TusBuf[TusPtr++] = Tus;
						


					}


				if (Tus == 0x0E )	// DELETE TUSU

					{	
						Lcd_Ekran_XY(4,9);	
						Lcd_PutStr("           ");
						Lcd_Ekran_XY(4,9);	
				
						for(i = 0; i <= 7; i++)
							{
								TusBuf[i]= 0;
							}
						TusPtr=0;
						DelayMs(100);
					}
		

			}
 /*
printf("\r\nTUS BUFER=");

for(MenNum = 0; MenNum <= 7; MenNum++)
	{
		sendchar(TusBuf[MenNum]);
	}
printf("\r\n");

 */

			HSaniyeE = OnSaniye ;

   /*
			if(TusPtr >= 3 )
				{
				HSaniyeE = DigToDec(0,0,0,0,TusBuf[0],TusBuf[1],TusBuf[2]);
				printf("\r\nHDERECE 3 = %f\r\n",HSaniyeE);
				HSaniyeE = HSaniyeE / 10 ;
				}
			
			if(TusPtr == 2 )
				{
				HSaniyeE = DigToDec(0,0,0,0,0,TusBuf[0],TusBuf[1]);
				printf("\r\nHDAKIKA 2 = %f\r\n",HSaniyeE);
				}
			if(TusPtr == 1 )
				{
				HSaniyeE = DigToDec(0,0,0,0,0,0,TusBuf[0]);
			  	printf("\r\nHDAKIKA 1 = %f\r\n",HSaniyeE);
				}
	*/

 
////////////////////////////// BOYLAM ////////////////////////



		Lcd_Ekran_Sil();

	  	Lcd_Ekran_XY(1,0); 
		Lcd_PutStr("HEDEF NOKTA BOYLAMI" );
		Lcd_Ekran_XY(2,0);
 		Lcd_PutStr("Derece = ");
		Lcd_Ekran_XY(3,0);
 		Lcd_PutStr("Dakika = ");
		Lcd_Ekran_XY(4,0);
 		Lcd_PutStr("Saniye = ");

		Lcd_Komut_Gonder(0x0D) ;
	
////////////////  BOYLAM DERECE /////////////////////
		for(i = 0; i <= 7; i++)
			{
				TusBuf[i]= 0;
			}

		TusPtr=0;
		Lcd_Ekran_XY(2,9);
	   	for(;;)

			{
				BekleKeyDown();
		
		
			    //printf("\r\nTUS = %c",Tus);
		
				BekleKeyUp();


				 if (Tus == 0x0C)		// ISIK KONTROL
					
					  {
					    ISIK_KONTROL();	
					  }

				if (Tus == 0x0A)		// ANA MENÜ
					
					  {
					    MenNum = 0;
						Lcd_Ekran_Sil();
						Lcd_Komut_Gonder(0x0C) ;
						DelayMs(200);
						return;	
					  }


				if (Tus == 0x0D )	// ENTER TUSU
					{
						//printf("\r\nENTER = %d",Tus);
				    	break;				 
					}

				if ((Tus >= 0x30) & (Tus <= 0x39))		// 0 ile 9 Arası Giriş
					{
						Lcd_PutChar(Tus);
						TusBuf[TusPtr++] = Tus;
					}


				if (Tus == 0x0E )	// DELETE TUSU

					{	
						Lcd_Ekran_XY(2,9);	
						Lcd_PutStr("           ");
						Lcd_Ekran_XY(2,9);	
				
						for(i = 0; i <= 7; i++)
							{
								TusBuf[i]= 0;
							}
						TusPtr = 0;
						DelayMs(100);
					}
		

			}
/*
printf("\r\nTUS BUFER=");

for(MenNum = 0; MenNum <= 7; MenNum++)
	{
		sendchar(TusBuf[MenNum]);
	}
printf("\r\n");
*/

			if(TusPtr >= 3 )
				{
				HDereceB = DigToDec(0,0,0,0,TusBuf[0],TusBuf[1],TusBuf[2]);
				//printf("\r\nHDERECE 3 = %f\r\n",HDereceB);
				}
			if(TusPtr == 2 )
				{
				HDereceB = DigToDec(0,0,0,0,0,TusBuf[0],TusBuf[1]);
				//printf("\r\nHDERECE 2 = %f\r\n",HDereceB);
				}
			if(TusPtr == 1 )
				{
				HDereceB = DigToDec(0,0,0,0,0,0,TusBuf[0]);
			  	//printf("\r\nHDERECE 1 = %f\r\n",HDereceB);
				}


////////////////  BOYLAM DADIKA /////////////////////
		for(i = 0; i <= 7; i++)
			{
				TusBuf[i]= 0;
			}

		TusPtr=0;
		Lcd_Ekran_XY(3,9);
	   	for(;;)

			{
				BekleKeyDown();
		
		
			    //printf("\r\nTUS = %c",Tus);
		
				BekleKeyUp();


				 if (Tus == 0x0C)		// ISIK KONTROL
					
					  {
					    ISIK_KONTROL();	
					  }

				if (Tus == 0x0A)		// ANA MENÜ
					
					  {
					    MenNum = 0;
						Lcd_Ekran_Sil();
						Lcd_Komut_Gonder(0x0C) ;
						DelayMs(200);
						return;	
					  }




				if (Tus == 0x0D )	// ENTER TUSU
					{
						//printf("\r\nENTER = %d",Tus);
				    	break;				 
					}

				if ((Tus >= 0x30) & (Tus <= 0x39))		// 0 ile 9 Arası Giriş
					{
						Lcd_PutChar(Tus);
						TusBuf[TusPtr++] = Tus;
					}


				if (Tus == 0x0E )	// DELETE TUSU

					{	
						Lcd_Ekran_XY(3,9);	
						Lcd_PutStr("           ");
						Lcd_Ekran_XY(3,9);	
				
						for(i = 0; i <= 7; i++)
							{
								TusBuf[i]= 0;
							}
						TusPtr = 0;
						DelayMs(100);
					}
		

			}
/*
printf("\r\nTUS BUFER=");

for(MenNum = 0; MenNum <= 7; MenNum++)
	{
		sendchar(TusBuf[MenNum]);
	}
printf("\r\n");

*/	
			
			if(TusPtr >= 2 )
				{
				HDakikaB = DigToDec(0,0,0,0,0,TusBuf[0],TusBuf[1]);
				//printf("\r\nHDAKIKA 2 = %f\r\n",HDakikaB);
				}
			if(TusPtr == 1 )
				{
				HDakikaB = DigToDec(0,0,0,0,0,0,TusBuf[0]);
			  	//printf("\r\nHDAKIKA 1 = %f\r\n",HDakikaB);
				}



////////////////  BOYLAM SANIYE /////////////////////
		for(i = 0; i <= 7; i++)
			{
				TusBuf[i]= 0;
			}

		TusPtr=0;
		Lcd_Ekran_XY(4,9);
	   	for(;;)

			{
				BekleKeyDown();
		
		
			    //printf("\r\nTUS = %c",Tus);
		
				BekleKeyUp();

				if (Tus == 0x0A)		// ANA MENÜ
					
					  {
					    MenNum = 0;
						Lcd_Komut_Gonder(0x0C);
						Lcd_Ekran_Sil();
						DelayMs(200);
						return;	
					  }



				if (Tus == 0x0D )  // ENTER TUSU
					{
						//printf("\r\nENTER = %d",Tus);
						
						OnSaniye = atof(TusBuf);

				    	//printf("\r\nSANIYE =%f",OnSaniye);

						break;				 
					}
				else
					{
						if (Tus == 0x0F ) // Ondalıklı Sayılar için Nokta.
							{
								Tus = 0x2E;
							}


						Lcd_PutChar(Tus);
						TusBuf[TusPtr++] = Tus;
					}


				if (Tus == 0x0E )	 // DELETE TUSU

					{	
						Lcd_Ekran_XY(4,9);	
						Lcd_PutStr("           ");
						Lcd_Ekran_XY(4,9);	
				
						for(i = 0; i <= 7; i++)
							{
								TusBuf[i]= 0;
							}
						TusPtr = 0;
						DelayMs(100);
					}
		

			}
/*
printf("\r\nTUS BUFER=");

for(MenNum = 0; MenNum <= 7; MenNum++)
	{
		sendchar(TusBuf[MenNum]);
	}
printf("\r\n");
*/
	HSaniyeB = OnSaniye ;	


	/*
			if(TusPtr >= 3 )
				{
				HSaniyeB = DigToDec(0,0,0,0,TusBuf[0],TusBuf[1],TusBuf[2]);
				printf("\r\nHDERECE 3 = %f\r\n",HSaniyeB);
				HSaniyeB = HSaniyeB / 10  ;
				}
			
			if(TusPtr == 2 )
				{
				HSaniyeB = DigToDec(0,0,0,0,0,TusBuf[0],TusBuf[1]);
				printf("\r\nHDAKIKA 2 = %f\r\n",HSaniyeB);
				}
			if(TusPtr == 1 )
				{
				HSaniyeB = DigToDec(0,0,0,0,0,0,TusBuf[0]);
			  	printf("\r\nHDAKIKA 1 = %f\r\n",HSaniyeB);
				}

	 */






		Lcd_Ekran_Sil();

		Lcd_Ekran_XY(2,0);
 		Lcd_PutStr("HEDEF NOKTA GIRILDI");
       	Lcd_Komut_Gonder(0x0C) ;



		HSaniyeE = HSaniyeE / 60 ;

		HDakikaE = HDakikaE + HSaniyeE ;

		HDakikaE = HDakikaE / 60 ;

		HDereceE = HDereceE + HDakikaE ;


		HSaniyeB = HSaniyeB / 60 ;

		HDakikaB = HDakikaB + HSaniyeB ;

		HDakikaB = HDakikaB / 60 ;

		HDereceB = HDereceB + HDakikaB ;

		fi2 = HDereceE;
		l2  = HDereceB;




		GPS_VERI_AL();


		RadyanYap();
		
		dFdLHesapla();

		HESAPLA();

		TopS = s ;


		BaslangicZamani =  GpsSaatDbl;

//		printf("\r\n BASANGIC ZAMANI = %f\r\n",BaslangicZamani);
		
//		printf("\r\ns = %f\r\n",s);

//		printf("\r\nTopS = %f\r\n",TopS);


//  		printf("\r\nHSaniyeE = %f\r\n",HSaniyeE);
//		printf("\r\nHSaniyeB = %f\r\n",HSaniyeB);


		return;

 }

[BenC]

MAIN dosyası


MAIN.C

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>



#include <LPC214x.h> // Nxp LPC2148 için header dosyası

#define Lcd_Led_DIR IO0DIR
#define Lcd_Led_SET IO0SET
#define Lcd_Led_CLR IO0CLR

#define Led1 (1 << 24)
#define Buzer (1 << 2)
#define Lcd_Led  (1 << 4)




#define Led1_DIR IO1DIR
#define Led1_SET IO1SET
#define Led1_CLR IO1CLR

#define Buzer_DIR IO0DIR
#define Buzer_SET IO0SET
#define Buzer_CLR IO0CLR



#define GETBIT(var,bit) (((var)>>(bit))&1)       
#define SETBIT(var,bit) ((var)|=(1<<(bit)))     
#define CLRBIT(var,bit) ((var)&=(~(1<<(bit))))	


#define Fosc    12000000

#define Fcclk   (Fosc * 5)




#define ro  57.29577951

//#define ro (double)(180/3.141592654)
#define Karesi(A)   (A) * (A)

int Tus,TusUp ;

int AlarmDrm;

int CagriDrm = 0 ;

int ZamanDrm = 0;

int MsgGonDrm=0;


int MsgSent=0;


int TusKilidi;

double HDereceE,HDakikaE,HSaniyeE;
double HDereceB,HDakikaB,HSaniyeB;

double GDereceE,GDakikaE,GSaniyeE;
double GDereceB,GDakikaB,GSaniyeB;

int GDerE,GDakE,GSanE;
int GDerB,GDakB,GSanB;


double GSapma;
int    intGSapmaA,intGSapmaB;
double intGSapmaC;

double OrtHiz;



double  GHiz;
double  GHizKm;
int     intGHizA,intGHizB;
double  intGHizC;


int intChar;

char LcdLedDrm;
char TimeDrm ;
char MenuMainDrm;
char MenuKonumDetayDrm;

char MenNum;

int AcilmaS;
double AcilmaFi2;
double AcilmaL2;


double f,u1,u2,c,lambda,w,san,df,dl;

double l;

int  der,dak,ss;

int Der,Dak;

double San;

double FarkSapma;
int FDer,FDak;
double FSan;


unsigned char AlrVar;

double x,alfa,arc ;

char sayac,sayac1 = 0;

double fark,uu,aa,bb,dsigma,s,azimut12,azimut21;

double sigma,sinsigma,cossigma,cos2sigmam,sinalfa;


double GpsSaatDbl;
double GpsDakikaDbl;
double GpsSaniyeDbl;

int GpsSaat;
int GpsDakika;
int GpsSaniye;

double BaslangicZamani;
double AktifZaman;

double TopS;		// Toplam Mesafe S.
double KatS;		// Katedilen Mesafe KatS.
double KalS;		// Kalan Mesafe KalS.

int TopSS;		// Toplam Mesafe S.
int KatSS;		// Katedilen Mesafe KatS.
int KalSS;			// Kalan Mesafe KalS.



double fi1; 
double l1;

double fi2;
double l2 ;

double a;
double b;

double d1,d2,d3,d4,d5,d6;

int TusPtr;

int intVSaat,intVDakika,intVSaniye;
double dblVSaat,dblVDakika,dblVSaniye;


unsigned char BosVeri;


unsigned char Buf[8];
unsigned char BufHesap[8];


unsigned char Buf1[16];
unsigned char Buf2[16];
unsigned char Buf3[16];
unsigned char Buf4[16];
unsigned char Buf5[16];
unsigned char Buf6[16];
unsigned char Buf7[16];
unsigned char Buf8[16];
unsigned char Buf9[16];

unsigned char Buf10[16];

char TusBuf[8];



unsigned char Sayac=0;


unsigned char GpsZaman[9];
unsigned char GpsStatu;
unsigned char GpsKuzey[10];
unsigned char GpsDogu[11];
unsigned char GpsHiz[7];
unsigned char GpsSapma[6];
unsigned char GpsTarih[6];
unsigned char GpsZet[5];

int GSapmaDer;
int GSapmaDak;
double GSapmaSan;


unsigned char Gosterge=0;

void DelayMs(long ms);
void GpsDurumShow();





void System_Init()

{


PLL0CFG=0x24; 

PLL0FEED=0xAA; 
PLL0FEED=0x55;

PLL0CON=0x1; 
PLL0FEED=0xAA;
PLL0FEED=0x55;
while(!(PLL0STAT&0x400)) ; 

PLL0CON=0x3; 
PLL0FEED=0xAA; 
PLL0FEED=0x55;

MAMCR=0x2;   
MAMTIM=0x4; 

VPBDIV=0x00000001; 

SCS = 0x00; 

	

Buzer_DIR |= Buzer;
Buzer_CLR |= Buzer;	



Led1_DIR |= Led1;

Led1_CLR = Led1;
DelayMs(500);
Led1_SET = Led1;
DelayMs(500);

Led1_CLR |= Led1;
DelayMs(500);
Led1_SET |= Led1;
DelayMs(500);

	
Lcd_Led_DIR |= Lcd_Led;
Lcd_Led_CLR = Lcd_Led;







MenuMainDrm = 1; 

MenNum = 0;
GpsStatu= 'V';

AlrVar = 0;

TusKilidi = 0;

}


void ISIK_KONTROL()
	{

 	if(LcdLedDrm == 0)
		{
			 Lcd_Led_DIR |= Lcd_Led;
			 Lcd_Led_SET |= Lcd_Led;
			 LcdLedDrm = 1;
			 DelayMs(200);								 
		}
	else
		{
			 Lcd_Led_DIR |= Lcd_Led;
			 Lcd_Led_CLR |= Lcd_Led;
			 LcdLedDrm = 0;
			 DelayMs(200);
		}

	}


void GPS_INIT()

	{


		uart0_puts("$PUBX,40,ZDA,0,0,0,0*");
 		uart0_putc(0x34);
		uart0_putc(0x34);
		uart0_putc(0x0D);
		uart0_putc(0x0A);
		
		uart0_puts("$PUBX,40,GLL,0,0,0,0*");
 		uart0_putc(0x35);
		uart0_putc(0x43);
		uart0_putc(0x0D);
		uart0_putc(0x0A);


		uart0_puts("$PUBX,40,GSA,0,0,0,0*");
		uart0_putc(0x34);
		uart0_putc(0x45);
		uart0_putc(0x0D);
		uart0_putc(0x0A);				


		uart0_puts("$PUBX,40,GSV,0,0,0,0*");
		uart0_putc(0x35);
		uart0_putc(0x39);
		uart0_putc(0x0D);
		uart0_putc(0x0A);				

		uart0_puts("$PUBX,40,VTG,0,0,0,0*");
		uart0_putc(0x35);
		uart0_putc(0x45);
		uart0_putc(0x0D);
		uart0_putc(0x0A);				

			

	}




void init_serial0 ( unsigned long baudrate )
{
    unsigned long Fdiv;

    PINSEL0 |= 0x00050005;                 
    U0LCR = 0x83;                          
    Fdiv = ( Fcclk / 16 ) / baudrate ;    
    U0DLM = Fdiv / 256;
    U0DLL = Fdiv % 256;
    U0LCR = 0x03;                           
}

void init_serial1 ( unsigned long baudrate )
{
    unsigned long Fdiv;

	PINSEL0 |= 0x00050005;                  
	PINSEL1 |= 0x00050005;                 
	//Port    =31 30 29 28, 27 26 25 24  23 22 21 20, 19 18 17 16  15 14 13 12, 11 10 9 8  7 6 5 4, 3 2 1 0
	//PINSEL0 =0  0  0  0,  0  0  0  0   0  0  0  0,  0  0  0  0   0  0  0  0,  0  0  0 0  0 0 0 0, 0 0 0 0
   //PINSEL0  =0  0  0  0,  0  0  0  0   0  0  0  0,  0  1  0  1   0  0  0  0,  0  0  0 0  0 0 0 0, 0 1 0 1

 
   //PINSEL0 &= ~0xC0000000;
   //PINSEL0 |=  0x40000000;                   
   //PINSEL1 &= ~0x00000003;
   //PINSEL1 |=  0x00000001;                   




//    PINSEL0 |= 0x00050005;                  
    U1LCR   = 0x83;                          
    Fdiv = ( Fcclk / 16 ) / baudrate ;     
    U1DLM = Fdiv / 256;
    U1DLL = Fdiv % 256;
    U1LCR   = 0x03;                           
}



void DelayMs(long ms)

{ 
long i; int j;
for (i = 0; i < ms; i++ )
for (j = 0; j < 7500; j++ );
}



 void GPS_VERI_AL()

	{

		unsigned char cVeri;


//$GPRMC,083319.00,A,3955.90624,N,03252.90514,E,0.624,23.07,260210,,,A*53
//$GPVTG,23.07,T,,M,0.624,N,1.157,K,A*09
//$GPGGA,083319.00,3955.90624,N,03252.90514,E,1,04,3.00,461.4,M,38.6,M,,*5D

	
		while (!(cVeri=='$'))
				cVeri=MyGetKey0();
		
		while (!(cVeri=='G'))
				cVeri=MyGetKey0();

		while (!(cVeri=='P'))
				cVeri=MyGetKey0();

		while (!(cVeri=='R'))
				cVeri=MyGetKey0();
		
		while (!(cVeri=='M'))
				cVeri=MyGetKey0();

		while (!(cVeri=='C'))
				cVeri=MyGetKey0();

		while (!(cVeri==','))
				cVeri=MyGetKey0();
	
		
		

		cVeri = MyGetKey0();
		Sayac=0;
		while(!(cVeri==','))
			{
				GpsZaman[Sayac++] =cVeri;
				cVeri = MyGetKey0();
			}

		cVeri = MyGetKey0();
		Sayac=0;
		while(!(cVeri==','))
			{
				GpsStatu =cVeri;
				cVeri = MyGetKey0();
				
			}

/*
		if (GpsStatu = 'V')
			goto Lab;
*/

		cVeri = MyGetKey0();
		Sayac=0;
		while(!(cVeri==','))
			{
				GpsKuzey[Sayac++] =cVeri;
				cVeri = MyGetKey0();
			}

		cVeri = MyGetKey0();
		Sayac=0;
		while(!(cVeri==','))
			{
				BosVeri =cVeri;
				cVeri = MyGetKey0();
				
			}

		cVeri = MyGetKey0();
		Sayac=0;
		while(!(cVeri==','))
			{
				GpsDogu[Sayac++] =cVeri;
				cVeri = MyGetKey0();
			}

		cVeri = MyGetKey0();
		Sayac=0;
		while(!(cVeri==','))
			{
				BosVeri =cVeri;
				cVeri = MyGetKey0();
				
			}

		cVeri = MyGetKey0();
		Sayac=0;
		while(!(cVeri==','))
			{
				GpsHiz[Sayac++] =cVeri;
				cVeri = MyGetKey0();
			}

		cVeri = MyGetKey0();
		Sayac=0;
		while(!(cVeri==','))
			{
				GpsSapma[Sayac++] =cVeri;
				cVeri = MyGetKey0();
			}

		cVeri = MyGetKey0();
		Sayac=0;
		while(!(cVeri==','))
			{
				GpsTarih[Sayac++] =cVeri;
				cVeri = MyGetKey0();
			}

  

 
		while (!(cVeri=='$'))
				cVeri=MyGetKey0();
		
		while (!(cVeri=='G'))
				cVeri=MyGetKey0();

		while (!(cVeri=='P'))
				cVeri=MyGetKey0();

		while (!(cVeri=='G'))
				cVeri=MyGetKey0();
		
		while (!(cVeri=='G'))
				cVeri=MyGetKey0();

		while (!(cVeri=='A'))
				cVeri=MyGetKey0();

		while (!(cVeri==','))
				cVeri=MyGetKey0();


		while (!(cVeri=='E'))
				cVeri=MyGetKey0();

		while (!(cVeri==','))
				cVeri=MyGetKey0();


	
		cVeri = MyGetKey0();
		Sayac=0;
		while(!(cVeri==','))
			{
				BosVeri =cVeri;
				cVeri = MyGetKey0();
				
			}

	

		cVeri = MyGetKey0();
		Sayac=0;
		while(!(cVeri==','))
			{
				BosVeri =cVeri;
				cVeri = MyGetKey0();
				
			}

 
		cVeri = MyGetKey0();
		Sayac=0;
		while(!(cVeri==','))
			{
				BosVeri =cVeri;
				cVeri = MyGetKey0();
							  
			}


		cVeri = MyGetKey0();
		Sayac=0;
		while(!(cVeri==','))
			{
				GpsZet[Sayac++] =cVeri;
				cVeri = MyGetKey0();
			}


/*	  printf("\r\nGGA =");

	sendchar(GpsZet[0]);   
	sendchar(GpsZet[1]);
	sendchar(GpsZet[2]);
	sendchar(GpsZet[3]);
	sendchar(GpsZet[4]);

	 printf("\r\n");
 */



		GpsSaat   = DigToDec (0,0,0,0,0,GpsZaman[0],GpsZaman[1]);
		GpsDakika = DigToDec (0,0,0,0,0,GpsZaman[2],GpsZaman[3]);
		GpsSaniye = DigToDec (0,0,0,0,0,GpsZaman[4],GpsZaman[5]);

		//printf("GPS ZAMAN=%d:%d:%d\r\n",GpsSaat,GpsDakika,GpsSaniye);

		GpsSaniyeDbl = (GpsSaniye / 60.0) ;

	//	printf("GPS SANIYE =%f\r\n",GpsSaniyeDbl);

		GpsDakikaDbl = (GpsDakika + GpsSaniyeDbl) / 60.0 ;
		
		

		GpsSaatDbl   = GpsSaat +  GpsDakikaDbl ;


		//printf("GPS Zaman DBL =%.12f\r\n",GpsSaatDbl);

		AktifZaman = GpsSaatDbl; 
	
		//printf("GPS Aktif Zaman=%.12f\r\n",AktifZaman);

//		printf("\r\nGPS SAAT INT = %02d:%02d:%02d\r\n",GpsSaat,GpsDakika,GpsSaniye);

//		printf("\r\nGPS SAAT DOUBLE = %f\r\n",GpsSaatDbl);




		GDereceE = DigToDec (0,0,0,0,0,GpsKuzey[0],GpsKuzey[1]);

		GDakikaE = DigToDec (0,0,0,0,0,GpsKuzey[2],GpsKuzey[3]);

		GSaniyeE = DigToDec (0,0,GpsKuzey[5],GpsKuzey[6],GpsKuzey[7],GpsKuzey[8],GpsKuzey[9]) ;

		GSaniyeE = (GSaniyeE / 100000) * 60 ;


 		GDereceB = DigToDec (0,0,0,0,GpsDogu[0],GpsDogu[1],GpsDogu[2]);

		GDakikaB = DigToDec (0,0,0,0,0,GpsDogu[3],GpsDogu[4]);

		GSaniyeB = DigToDec (0,0,GpsDogu[6],GpsDogu[7],GpsDogu[8],GpsDogu[9],GpsDogu[10]) ;

		GSaniyeB = (GSaniyeB / 100000) * 60 ;


		if (GpsHiz[1]=='.')
			
			{
			  intGHizA =  DigToDec (0,0,0,0,0,0,GpsHiz[0]) ; 
			  intGHizB =  DigToDec (0,0,GpsHiz[2],GpsHiz[3],GpsHiz[4],GpsHiz[5],GpsHiz[6]) ;
			  intGHizC = (double)intGHizB / 100000 ;
			  GHiz = intGHizA + intGHizC ;

			   
			}


		if (GpsHiz[2]=='.')
			
			{
			  intGHizA =  DigToDec (0,0,0,0,0,GpsHiz[0],GpsHiz[1]) ; 
			  intGHizB =  DigToDec (0,0,0,GpsHiz[3],GpsHiz[4],GpsHiz[5],GpsHiz[6]) ;
			  intGHizC = (double)intGHizB / 10000 ;
			  GHiz = intGHizA + intGHizC ;	

			   
			}


		if (GpsHiz[3]=='.')
			
			{
			  intGHizA =  DigToDec (0,0,0,0,GpsHiz[0],GpsHiz[1],GpsHiz[2]) ; 
			  intGHizB =  DigToDec (0,0,0,0,GpsHiz[4],GpsHiz[5],GpsHiz[6]) ;
			  intGHizC = (double)intGHizB / 1000 ;
			  GHiz = intGHizA + intGHizC ;

			   
			}




		if (GpsSapma[1]=='.')
			
			{
			  intGSapmaA =  DigToDec (0,0,0,0,0,0,GpsSapma[0]) ; 
			  intGSapmaB =  DigToDec (0,0,0,GpsSapma[2],GpsSapma[3],GpsSapma[4],GpsSapma[5]) ;
			  intGSapmaC = (double)intGSapmaB / 10000 ;
			  GSapma = intGSapmaA + intGSapmaC ;

			  GSapmaDer = intGSapmaA ;
			  GSapmaDak	= (int)(intGSapmaC * 60) ;
			  GSapmaSan = (intGSapmaC * 60) - GSapmaDak ;
			  GSapmaSan = GSapmaSan * 60;
			}


		if (GpsSapma[2]=='.')
			
			{
			  intGSapmaA =  DigToDec (0,0,0,0,0,GpsSapma[0],GpsSapma[1]) ; 
			  intGSapmaB =  DigToDec (0,0,0,0,GpsSapma[3],GpsSapma[4],GpsSapma[5]) ;
			  intGSapmaC = (double)intGSapmaB / 1000 ;
			  GSapma = intGSapmaA + intGSapmaC ;

 			  GSapmaDer = intGSapmaA ;
			  GSapmaDak	= (int)(intGSapmaC * 60) ;
			  GSapmaSan = (intGSapmaC * 60) - GSapmaDak ;
			  GSapmaSan = GSapmaSan * 60;


			   
			}


		if (GpsSapma[3]=='.')
			
			{
			  intGSapmaA =  DigToDec (0,0,0,0,GpsSapma[0],GpsSapma[1],GpsSapma[2]) ; 
			  intGSapmaB =  DigToDec (0,0,0,0,0,GpsSapma[4],GpsSapma[5]) ;
			  intGSapmaC = (double)intGSapmaB / 100 ;
			  GSapma = intGSapmaA + intGSapmaC ;

  			  GSapmaDer = intGSapmaA ;
			  GSapmaDak	= (int)(intGSapmaC * 60) ;
			  GSapmaSan = (intGSapmaC * 60) - GSapmaDak ;
			  GSapmaSan = GSapmaSan * 60;


			   
			}



		//printf("\r\nsaniyee = %f\r\n",GSaniyeE);


		GDerE = (int)GDereceE;
		GDakE = (int)GDakikaE;
		GSanE = (int)GSaniyeE;

		GDerB = (int)GDereceB;
		GDakB = (int)GDakikaB;
		GSanB = (int)GSaniyeB;
		
		
		GHizKm = GHiz * 1.852;		// KM için 1.852 ile Çarpılıyor.


		sprintf(Buf1,"%03d %02d %04f",GDerE,GDakE,GSaniyeE);
		sprintf(Buf2,"%03d %02d %04f",GDerB,GDakB,GSaniyeB);
		sprintf(Buf3,"%03d %02d %04f",GDerE,GDakE,GSaniyeE);
		sprintf(Buf4,"%03d %02d %04f",GSapmaDer,GSapmaDak,GSapmaSan);
		sprintf(Buf5,"%05f %05f %06f",GHiz,GHizKm,GSapma);
		
		
				
		
//				sprintf(Buf,"%03d %02d %04f%03d %02d %04f %05f %05f %06f %03d %02d %04f",GDerE,GDakE,GSaniyeE,GDerB,GDakB,GSaniyeB,GHiz,GHizKm,GSapma,GSapmaDer,GSapmaDak,GSapmaSan);
		
	
 /*
		printf("\r\nGDereceE = %f",GDereceE);
		printf("\r\nGDakikaE = %f",GDakikaE);
		printf("\r\nGSaniyeE = %f",GSaniyeE);


		printf("\r\nGDereceB = %f",GDereceB);
		printf("\r\nGDakikaB = %f",GDakikaB);
		printf("\r\nGSaniyeB = %f",GSaniyeB);

		printf("\r\nGSapma = %f",GSapma);
		printf("\r\nGHiz = %f",GHiz);
		printf("\r\nGHizKm = %f",GHizKm);
		 
  */


 /*
	printf("\r\nZAMAN =");

	sendchar(GpsZaman[0]);   
	sendchar(GpsZaman[1]);
	sendchar(GpsZaman[2]);
	sendchar(GpsZaman[3]);
	sendchar(GpsZaman[4]);
	sendchar(GpsZaman[5]);
	sendchar(GpsZaman[6]);
	sendchar(GpsZaman[7]);
	sendchar(GpsZaman[8]);

*/  
		GSaniyeE = GSaniyeE / 60 ;

		GDakikaE = GDakikaE + GSaniyeE ;

		GDakikaE = GDakikaE / 60 ;

		GDereceE = GDereceE + GDakikaE ;


		GSaniyeB = GSaniyeB / 60 ;

		GDakikaB = GDakikaB + GSaniyeB ;

		GDakikaB = GDakikaB / 60 ;

		GDereceB = GDereceB + GDakikaB ;



		fi1 = GDereceE;
		l1  = GDereceB;



//		printf("\r\nGfiE = %f\r\n",fi1);

//		printf("\r\nGl1B = %f\r\n",l1);

//	   if (GpsStatu == 'V')
//	   		{
//	   			Lcd_Ekran_Sil();
//	   			GpsDurumShow();
//  			}
//	   if (GpsStatu == 'A')
//	   		{
//	   			Lcd_Ekran_Sil();
//	   			MenNum = 0 ;
// 			}







	}

Devamı var

[BenC]

MAIN.C nin devamı

/*******************************************************************************/
/***                   DIGIT VERİYİ DECIMAL VERİYE DÖNÜŞTÜR                  ***/
/*******************************************************************************/
/*******************************************************************************/
/*Fonksiyon Adı  : int DigToDec()                                              */
/*Açıklama       : Fonksiyona giren 4 değişik digit verisini birleştirip       */
/*                 int türünde decimal veri üretmek.                           */
/*                 Örneğin herhangi bir cihazdan alınan 4 basamaklı veriyi 4   */
/*                 değişik değişkende saklamak yerine int türünden bir değiş-  */
/*                 kende decimal değeri olarak saklamak.                       */
/*                                                                             */
/*                                                                             */
/*Yazar          : Armağan YILMAZ                                              */
/*Tarih          : 01.06.2009                                                  */
/*Version        : 1.0                                                         */
/*                                                                             */
/*Giriş          : char xDeger1,char xDeger2,char xDeger3,char xDeger4         */
/*               :                                                             */
/*Çıkış          : int DigToDec()                                              */
/*                                                                             */
/*                                                                             */
/*Kullanılan Veri: 1 byte                                                      */
/*******************************************************************************/
int DigToDec(char xDeger1,char xDeger2,char xDeger3,char xDeger4,char xDeger5,char xDeger6,char xDeger7)

	{
		char tmp1,tmp2,tmp3,tmp4,tmp5,tmp6,tmp7,tmp8,tmp9,tmp10,tmp11,tmp12,tmp13,tmp14;

		tmp1 = xDeger1 << 4;		
		tmp2 = tmp1 >>4;

		tmp3 = xDeger2 << 4;		
		tmp4 = tmp3 >>4;

		tmp5 = xDeger3 << 4;		
		tmp6 = tmp5 >>4;

		tmp7 = xDeger4 << 4;		
		tmp8 = tmp7 >>4;

		tmp9  = xDeger5 << 4;		
		tmp10 = tmp9 >>4;

		tmp11  = xDeger6 << 4;		
		tmp12 = tmp11 >>4;

		tmp13  = xDeger7 << 4;		
		tmp14 = tmp13 >>4;



		return (((tmp2*1000000)+(tmp4*100000)+(tmp6*10000)+(tmp8*1000)+(tmp10*100) +(tmp12*10)+ (tmp14*1)));

	}	
/*******************************************************************************/
/*******************************************************************************/







double ArcSin(double x)

       {
         return(atan(( x /(sqrt(-x*x+1)))));
       } 

double ArcCos(double x)

       {
         return(atan(-x/sqrt(-x*x+1))+2*atan(1));
       } 

	 
void RadyanYap()

       {



          fi1 = fi1 / ro ; 
          //printf("Fi1=%f\r\n",fi1);
                        
          l1  = l1  / ro ;
          //printf("L1=%f\r\n\r\n",l1);

          fi2 = fi2 / ro ;            
          //printf("Fi2=%f\r\n",fi2);   
          
          l2  = l2  / ro ;
          //printf("L2=%f\r\n\r\n",l2);
       }


void dFdLHesapla()

       {
           df = fi2 - fi1 ;
           //printf("df=%.12e\r\n",df);
           
           dl = l2  -  l1  ;        
           //printf("dl=%.12e\r\n\r\n",dl);
           
       }

void HESAPLA ()

     {
        a = 6378137;
        b = 6356752.31424518;




       f  = ( a - b ) / a ;
       //printf("f=%.12e\r\n\r\n",f);
       
       u1 = (atan(((1-f) * tan(fi1))));
       //printf("u1=%.12f\r\n",u1);
       
       u2 = (atan(((1-f) * tan(fi2))));
       //printf("u2=%.12f\r\n\r\n",u2);
       
       
       l  =   fabs( (l2 - l1) )  ;
       
       //printf("l=%.12e\r\n\r\n",l);
       
       w  =  l;
       
       //printf("w=%.12e\r\n\r\n",w);
       
       // İTERASYON BAŞLANGICI
       
       fark = 1 ;
       
       
       while( fark > 0.000000000001 )
       
              {
                   
                   
                   d1 = cos(u2) * sin(l);
                   d2 = Karesi(d1);
                   
                   d3 = ( cos(u1) * sin(u2) )  ;
                   d4 = ( sin(u1) * cos(u2)* cos(l) );
                   
                   d5 = d3 - d4 ;
                   
                   d6 = Karesi(d5);
                     
                   
                    
                   sinsigma =  sqrt ( d2  + d6  ) ;
                   
                   //sinsigma =  sqrt ( (Karesi((cos(u2) * sin(l))))  + ( Karesi ( ( ( cos(u1) * sin(u2) ) - ( sin(u1) * cos(u2)* cos(l) ) )  ) ) ) ;
                   
                   
                   arc = sinsigma;
                   
                   //printf("arc=%.12f\r\n\r\n",arc);
                   
                   sigma = ArcSin(arc);
                   
                   //printf("sigma=%.12e\r\n\r\n",sigma);
                   
                                     
                   cossigma = ( sin(u1) * sin(u2) ) + ( cos(u1) * cos(u2) * cos(l));
                   
                   //printf("cossigma=%.12f\r\n\r\n",cossigma);
                   
                   sinalfa =  ( cos(u1) * cos(u2) * sin(l) ) / sinsigma ;
                   
                   arc = sinalfa ;
                   
                   alfa = ArcSin(arc);
                   
                   //printf("alfa=%.12f\r\n\r\n",alfa);                   

                   d1 = Karesi((cos(alfa)));
                   d2 = 2 *  sin(u1) * sin(u2) ;
                   
                   d3 = d2 / d1;
                   
                   cos2sigmam = cossigma - d3 ;

                   //cos2sigmam = cossigma - ( ( 2 * sin(u1) * sin(u2) ) / Karesi((cos(alfa))) );
                  
                   //printf("cos2sigmam=%.12f\r\n\r\n",cos2sigmam);  
                   
                   
                   
                   c = (f/16) * (Karesi(cos(alfa))) * ( 4 + f * ( 4 - 3 * ( Karesi (cos(alfa)))));
                   
                   //printf("c=%.12e\r\n\r\n",c);
                    //break;
                   
                   lambda = w + (1 - c) * f * sinalfa * ( sigma + c * sinsigma * ( cos2sigmam + (c * cossigma * (( 2 * Karesi(cos2sigmam)) -1 ))));   
                   
                   //printf("lambda=%.12e\r\n\r\n",lambda);  
                   
                   
                   fark = fabs(lambda - l );
                   
                   l = lambda;
                   
                    //printf("fark=%.12e\r\n\r\n",fark);                           
					// printf("fark=\r\n");                           
              //break;
              
            /*
			  if (sayac1>10)
			  	{sayac1=0; 
                 break;}
              
              sayac1++;
             */ 
              
              
              }
              
               fark = 1;
       
              
              l = lambda ;
       
       d1 = Karesi((cos(alfa)));
       d2 = Karesi(a);
       d3 = Karesi(b);
       //uu = Karesi((cos(alfa))) * ( Karesi(a) - Karesi(b) ) / Karesi(b);
       uu = d1 *  ( (d2 - d3 ) / d3 ) ;
       //printf("uu=%.12e\r\n\r\n",uu); 
       
       
       aa = 1 + ( uu / 16384 ) * ( 4096 + uu * (-768 + uu * ( 320 - 175 * uu )));
       //printf("aa=%.12f\r\n\r\n",aa); 
       
       
       bb = (uu / 1024) * (256 + uu * (-128 + uu * ( 74 - 47 * uu )));
       //printf("bb=%.12e\r\n\r\n",bb); 
       
       
       d1 = Karesi(cos2sigmam);
       d2 = Karesi(sinsigma);
       
       dsigma = bb * sinsigma * (cos2sigmam + (bb/4) * ( cossigma * ( -1 + 2 * d1 ) - ( bb / 6 ) * cos2sigmam * (-3 + 4 * d2 ) * ( -3+4* d1 )));
       //dsigma = bb * sinsigma * (cos2sigmam + (bb/4) * ( cossigma * ( -1 + 2 * Karesi(cos2sigmam)) - ( bb / 6 ) * cos2sigmam * (-3+4* Karesi(sinsigma)) * ( -3+4* Karesi(cos2sigmam))));
       //printf("dsigma=%.12e\r\n\r\n",dsigma); 
       
       

// 		printf("\r\nGiren S = %f\r\n",s);

//		printf("\r\nGiren TopS = %f\r\n",TopS);

       
       
       s =  b * aa * ( sigma - dsigma );
	   ss=(int)(fabs(s)); 



	   KatS  = fabs((TopS-s)) ;

	   KatSS =(int)(KatS);       

		      




//		printf("\r\nCikan KatS = %f\r\n",KatS);

//		printf("\r\nCikan KatSS = %06d\r\n",KatSS);




       //printf("s=%.12f\r\n\r\n",s); 
       
       
       azimut12 = (atan((cos(u2)* sin(l)) / ( cos(u1) * sin(u2) - sin(u1) * cos(u2) * cos(l)))) * ro ;
       
       //printf("azimut12=%f\r\n\r\n",azimut12); 
       
       
       if ( (df < 0) & (dl > 0))
          {
		  	azimut12 = 180 + azimut12;
          }

       if ( (df < 0) & (dl < 0))
           {
		  	azimut12 = 180 - azimut12;
		   }

       if ( (df > 0) & (dl < 0))
		  {
          	azimut12 = 360 - azimut12;
		  }

       if ( (df < 0) & (dl == 0))
	      	{
		  		azimut12 = 180 - azimut12;
			}

       if ( (df == 0) & (dl < 0))
          {
		  	azimut12 = 360 - azimut12;
		  }

          
       der = azimut12 - (azimut12 - (int)(azimut12));
       
       dak = (int) ( azimut12 - der ) * 60 ;
       
       san = ((( azimut12 - der ) * 60 ) - dak ) * 60 ;
       
       
	   Der = fabs(azimut12);
	   Dak = (azimut12 - Der) * 60;
	   San = (((azimut12 - Der) * 60)- Dak) * 60;
	   
	   
	   //sprintf(Buf,"%03d %03d %03d %5d",Der,Dak,San,ss);

	  //azimut12=234.567843;
	  //GSapma  =324.675432;

	   FarkSapma =  azimut12 - GSapma  ;	       

		


	   //printf ("FARK SAPMA=%f \r\n",FarkSapma);		


	   FDer = (int)(FarkSapma);
	   FDak = ((FarkSapma - FDer) * 60 );	
	   FSan = (((( FarkSapma - FDer) * 60 ) - FDak ) * 60 );	

	   FDak= abs(FDak);
	   FSan= fabs(FSan);
	   

		sprintf(Buf6,"%03d %02d %04f",Der,Dak,San);
		sprintf(Buf7,"%06d %07d",ss,KatSS);
		sprintf(Buf8,"%03d %02d %04f",FDer,FDak,FSan);
		


	   //sprintf(BufHesap,"%03d %02d %04f %5d %03d %02d %04f",Der,Dak,San,ss,FDer,FDak,FSan);
	   
	     

       
       //printf ("FARK=%d:%d:%f \r\n",FDer,FDak,FSan);       
       
             
     }


  void DegerOku()
{
//	    fi1 =  40.51056944; 
//        l1  =  28.05739722;
        

//        fi2  = 40.9327;
//        l2   = 28.79712778;
   
//	    fi1 =  39.93212222; 
//        l1  =  32.88258055;
        

//        fi2  = 39.92949722;
//        l2   = 32.88877778;

// IKINCI BOLGE ////////////
//fi1 = 39.93208333 ; 
//l1  = 32.88258333 ;

//fi2=39.92952778;
//l2=	32.88872222;

// ACI = 118 23 58.79
// MES = 596 metre

////////////////////////////


// UCUNCU BOLGE ////////////
//fi1 = 39.93208333 ; 
//l1  = 32.88258333 ;

//fi2=39.89619444;
//l2=	32.83872222;

// ACI = 223 16 34,13
// MES = 5471 metre

////////////////////////////


// DORDUNCU BOLGE ////////////
//fi1 = 39.93208333 ; 
//l1  = 32.88258333 ;

//fi2=39.96286111;
//l2=	32.83872222;

// ACI = 312 22 10,49
// MES = 5072 metre

////////////////////////////



        a = 6378137;
        b = 6356752.31424518;


 }




void VarisZamaniHesapla()

	{
	   int Say;

	    //printf ("\r\n\r\nKATS=%f \r\n",KatS);
		//printf ("Baslangic ZAMAN=%f \r\n",BaslangicZamani);
		//printf ("Aktif ZAMAN=%f \r\n",AktifZaman);	


		if (KatS < 10)
		   {
	   			OrtHiz = 0;	
					  for(Say=0;Say>=15;Say++)	
						  {
						    Buf9[Say]=0;
						    Buf10[Say]=0;
						  }
					 
					  sprintf(Buf9,"%02d:%02d:%02d",intVSaat,intVDakika,intVSaniye);
					  sprintf(Buf10,"%f",OrtHiz);


		   }
		else
		   {
		   		if (AktifZaman != BaslangicZamani)
					{
						 OrtHiz = (((KatS / 1000)/1.852)/(AktifZaman - BaslangicZamani));

						 dblVSaat = (s / 1000)/OrtHiz;
						 	
						 intVSaat = (int)(dblVSaat);
						
						 intVDakika	= ((dblVSaat - intVSaat) * 60 );	

						 intVSaniye = (((( dblVSaat - intVSaat) * 60 ) - intVDakika ) * 60 );

						 intVDakika = abs(intVDakika);
						   		
						 intVSaniye = fabs(intVSaniye);
		
						 sprintf(Buf9,"%02d:%02d:%02d",intVSaat,intVDakika,intVSaniye);
						 sprintf(Buf10,"%f",OrtHiz);



						 
/*						
						
						 dblVSaat =(( s /1.852) / GHiz);  // Mesafe Deniz mili
					
						 intVSaat = (int)(dblVSaat);
					
						 intVDakika	= ((dblVSaat - intVSaat) * 60 );	
					
						 intVSaniye = (((( dblVSaat - intVSaat) * 60 ) - intVDakika ) * 60 );
					
					
						 intVDakika = abs(intVDakika);
						   		
						 intVSaniye = fabs(intVSaniye);
					
					 	 sprintf(Buf9,"%02d:%02d:%02d %f",intVSaat,intVDakika,intVSaniye,OrtHiz);
						 sprintf(Buf10,"%f",OrtHiz);

*/

					}
				else
					{
					  OrtHiz = 0 ;
					  
					  /*
					  
					  for(Say=0;Say>=15;Say++)	
						  {
						    Buf9[Say]=0;
						    Buf10[Say]=0;
						  }
					 
					  sprintf(Buf9,"%02d:%02d:%02d",intVSaat,intVDakika,intVSaniye);
					  sprintf(Buf10,"%f",OrtHiz);
					  
					  */
					}
			
				
		   }



		//OrtHiz = (((KatS *1.852))/1000)/((AktifZaman - BaslangicZamani));

		//printf ("ORT HIZ=%f \r\n",OrtHiz);

	 




	//	s=120;
	//	GHiz=38.0;
	
	 

	 //printf ("VARIS ZAMANI=%d:%d:%d \r\n",intVSaat,intVDakika,intVSaniye);

	}



void LogoShow()

	 {
		
	  	Lcd_Ekran_XY(1,0); 
		Lcd_PutStr("********************");
		Lcd_Ekran_XY(2,0);
 		Lcd_PutStr("* www.picproje.org *");
		Lcd_Ekran_XY(3,0);
 		Lcd_PutStr("*   HOSGELDINIZ    *");
		Lcd_Ekran_XY(4,0);
 		Lcd_PutStr("********************");

		DelayMs(2000);

		Lcd_Ekran_Sil();

	 }


void TarihZamanShow()

	 {
	
		Lcd_Ekran_XY(1,0);
 		Lcd_PutStr("TARIH : ");
		Lcd_PutChar(GpsTarih[0]);
		Lcd_PutChar(GpsTarih[1]);
		Lcd_PutStr(".");
		Lcd_PutChar(GpsTarih[2]);
		Lcd_PutChar(GpsTarih[3]);		
		Lcd_PutStr(".20");
		Lcd_PutChar(GpsTarih[4]);
		Lcd_PutChar(GpsTarih[5]);


		

		Lcd_Ekran_XY(3,0);
 		Lcd_PutStr("ZAMAN : ");
		Lcd_PutChar(GpsZaman[0]);   
		Lcd_PutChar(GpsZaman[1]);
		Lcd_PutStr(":");
		Lcd_PutChar(GpsZaman[2]);
		Lcd_PutChar(GpsZaman[3]);
		Lcd_PutStr(":");
		Lcd_PutChar(GpsZaman[4]);
		Lcd_PutChar(GpsZaman[5]);
		
//		Lcd_PutStr(":");
//		Lcd_PutChar(GpsZaman[6]);
//		Lcd_PutChar(GpsZaman[7]);
//		Lcd_PutChar(GpsZaman[8]);

	
	 }


 

void SeyirDetayShow()

	 {
		

		Lcd_Ekran_XY(1,0);
 		Lcd_PutStr("ACI : ");
		Lcd_PutChar(Buf6[0]);
		Lcd_PutChar(Buf6[1]);
		Lcd_PutChar(Buf6[2]);
		Lcd_PutChar(Buf6[3]);		
		Lcd_PutChar(Buf6[4]);
		Lcd_PutChar(Buf6[5]);
		Lcd_PutChar(Buf6[6]);
		Lcd_PutChar(Buf6[7]);
		Lcd_PutChar(Buf6[8]);
		Lcd_PutChar(Buf6[9]);		
		Lcd_PutChar(Buf6[10]);
		Lcd_PutChar(Buf6[11]);

		

	


		Lcd_Ekran_XY(2,0);
 		Lcd_PutStr("GPS : ");
		Lcd_PutChar(Buf4[0]);
		Lcd_PutChar(Buf4[1]);
		Lcd_PutChar(Buf4[2]);
		Lcd_PutChar(Buf4[3]);
		Lcd_PutChar(Buf4[4]);		
		Lcd_PutChar(Buf4[5]);
		Lcd_PutChar(Buf4[6]);
		Lcd_PutChar(Buf4[7]);		
		Lcd_PutChar(Buf4[8]);
		Lcd_PutChar(Buf4[9]);
		Lcd_PutChar(Buf4[10]);		
		Lcd_PutChar(Buf4[11]);
		


		Lcd_Ekran_XY(3,0);
 		Lcd_PutStr("FARK:");
		Lcd_PutChar(Buf8[0]);    	
		Lcd_PutChar(Buf8[1]);
		Lcd_PutChar(Buf8[2]);
		Lcd_PutChar(Buf8[3]);
		Lcd_PutChar(Buf8[4]);
		Lcd_PutChar(Buf8[5]);
		Lcd_PutChar(Buf8[6]);
		Lcd_PutChar(Buf8[7]);
		Lcd_PutChar(Buf8[8]);
		Lcd_PutChar(Buf8[9]);
		Lcd_PutChar(Buf8[10]);
		Lcd_PutChar(Buf8[11]);
		Lcd_PutChar(Buf8[12]);
		//Lcd_PutChar(Buf8[13]);
		
		


		Lcd_Ekran_XY(4,0);
 		Lcd_PutStr("M:");
		Lcd_PutChar(Buf7[0]);
		Lcd_PutChar(Buf7[1]);
		Lcd_PutChar(Buf7[2]);
		Lcd_PutChar(Buf7[3]);
		Lcd_PutChar(Buf7[4]);
		Lcd_PutChar(Buf7[5]);

 		Lcd_PutStr(" H:");
		
		Lcd_PutChar(Buf5[0]);
		Lcd_PutChar(Buf5[1]);
		Lcd_PutChar(Buf5[2]);
		Lcd_PutChar(Buf5[3]);
		Lcd_PutChar(Buf5[4]);
 		Lcd_PutStr(" Mil");


 	
	 }


void KonumDetayShow()

	 {

//BUFER039 55 55.628400032 52 56.640600 0.658000 1.218616 291.040000
		
	  	Lcd_Ekran_XY(1,0); 
		Lcd_PutStr("ENLEM :");
		Lcd_PutChar(Buf1[0]);
		Lcd_PutChar(Buf1[1]);
		Lcd_PutChar(Buf1[2]);
		Lcd_PutChar(Buf1[3]);		
		Lcd_PutChar(Buf1[4]);
		Lcd_PutChar(Buf1[5]);
		Lcd_PutChar(Buf1[6]);
		Lcd_PutChar(Buf1[7]);
		Lcd_PutChar(Buf1[8]);
		Lcd_PutChar(Buf1[9]);
		Lcd_PutChar(Buf1[10]);
		Lcd_PutChar(Buf1[11]);

		Lcd_Ekran_XY(2,0);
 		Lcd_PutStr("BOYLAM:");
		Lcd_PutChar(Buf2[0]);
		Lcd_PutChar(Buf2[1]);
		Lcd_PutChar(Buf2[2]);
		Lcd_PutChar(Buf2[3]);
		Lcd_PutChar(Buf2[4]);
		Lcd_PutChar(Buf2[5]);
		Lcd_PutChar(Buf2[6]);
		Lcd_PutChar(Buf2[7]);
		Lcd_PutChar(Buf2[8]);
		Lcd_PutChar(Buf2[9]);
		Lcd_PutChar(Buf2[10]);
		Lcd_PutChar(Buf2[11]);

		Lcd_Ekran_XY(3,0);
 		Lcd_PutStr("HIZ:");
		
		Lcd_PutChar(Buf5[0]);
		Lcd_PutChar(Buf5[1]);
		Lcd_PutChar(Buf5[2]);
		Lcd_PutChar(Buf5[3]);
 		Lcd_PutStr(" Mil ");
		

		Lcd_PutChar(Buf5[9]);
		Lcd_PutChar(Buf5[10]);
		Lcd_PutChar(Buf5[11]);
		Lcd_PutChar(Buf5[12]);
 		Lcd_PutStr(" KM");

		Lcd_Ekran_XY(4,0);
 		Lcd_PutStr("YUKSEKLIK :");
		Lcd_PutChar(GpsZet[0]);   
		Lcd_PutChar(GpsZet[1]);
		Lcd_PutChar(GpsZet[2]);
		Lcd_PutChar(GpsZet[3]);
		Lcd_PutChar(GpsZet[4]);
		Lcd_PutStr(" M.");



	 }

void GpsDurumShow()

	{
	  	Lcd_Ekran_XY(2,0); 
		Lcd_PutStr(" GPS HAZIR DEGIL ! ");
	  	Lcd_Ekran_XY(3,0); 
		Lcd_PutStr(" LUTFEN BEKLEYINIZ");

	}


void VarisZamaniShow()

	{
		VarisZamaniHesapla();

	  	Lcd_Ekran_XY(1,0); 
		Lcd_PutStr("Gidilen : ");
		Lcd_PutChar(Buf7[8]);
		Lcd_PutChar(Buf7[9]);
		Lcd_PutChar(Buf7[10]);
		Lcd_PutChar(Buf7[11]);
		Lcd_PutChar(Buf7[12]);
	    Lcd_PutChar(Buf7[13]);
        Lcd_PutStr(" M.");

	  	Lcd_Ekran_XY(2,0); 
		Lcd_PutStr("Kalan   : ");
		Lcd_PutChar(Buf7[0]);
		Lcd_PutChar(Buf7[1]);
		Lcd_PutChar(Buf7[2]);
		Lcd_PutChar(Buf7[3]);
		Lcd_PutChar(Buf7[4]);
		Lcd_PutChar(Buf7[5]);
		Lcd_PutStr(" M.");




	  	Lcd_Ekran_XY(3,0); 
		Lcd_PutStr("Ort.Hiz : ");
		Lcd_PutChar(Buf10[0]);
		Lcd_PutChar(Buf10[1]);
		Lcd_PutChar(Buf10[2]);
		Lcd_PutChar(Buf10[3]);
		Lcd_PutChar(Buf10[4]);
		Lcd_PutStr("  Mil");



	  	Lcd_Ekran_XY(4,0); 
		Lcd_PutStr("Varis Z.: ");
		Lcd_PutChar(Buf9[0]);
		Lcd_PutChar(Buf9[1]);
		Lcd_PutChar(Buf9[2]);
		Lcd_PutChar(Buf9[3]);
		Lcd_PutChar(Buf9[4]);
		Lcd_PutChar(Buf9[5]);
		Lcd_PutChar(Buf9[6]);
		Lcd_PutChar(Buf9[7]);

	  	

/*
	  	Lcd_Ekran_XY(1,0); 
		Lcd_PutStr("HEDEFE VARIS ZAMANI");
	  	Lcd_Ekran_XY(2,0); 
		Lcd_PutStr("MESAFE = ");
		Lcd_PutChar(Buf7[0]);
		Lcd_PutChar(Buf7[1]);
		Lcd_PutChar(Buf7[2]);
		Lcd_PutChar(Buf7[3]);
		Lcd_PutChar(Buf7[4]);
		Lcd_PutChar(Buf7[5]);

	  	Lcd_Ekran_XY(3,0); 
		Lcd_PutStr("HIZ = ");
		Lcd_PutChar(Buf5[0]);
		Lcd_PutChar(Buf5[1]);
		Lcd_PutChar(Buf5[2]);
		Lcd_PutChar(Buf5[3]);


	  	Lcd_Ekran_XY(4,0); 
		Lcd_PutStr("SURE = ");
		Lcd_PutChar(Buf9[0]);
		Lcd_PutChar(Buf9[1]);
		Lcd_PutChar(Buf9[2]);
		Lcd_PutChar(Buf9[3]);
		Lcd_PutChar(Buf9[4]);
		Lcd_PutChar(Buf9[5]);
		Lcd_PutChar(Buf9[6]);
		Lcd_PutChar(Buf9[7]);
 */

	}



int GetKeyTT (long xBeklemeSuresi) 

 {
	long Sayac = 0 ;
	long j ;

	

	while (!(U1LSR & 0x01) )
		
		  {
			//printf("SAYAC=%d\r\n",Sayac);

			if (Sayac > xBeklemeSuresi )	
		  		{
		  			
					return (U1RBR);
				}
  		  	
			for( j = 0 ; j < 35 ; j++ );

			Sayac ++ ;

		  }
	
	
		  
	return (U1RBR);

		

}


int CagriKontrol()
		
	{
		int gChar;
		
		gChar=GetKeyTT(90000);
	
	    
		
		if (gChar == 'R')
	        
			{
				CagriDrm = 1;
				printf("\r\n");
				printf("ATA\r\n");
				Lcd_Ekran_Sil();
				//MenNum = 1 ;
				//AlarmDrm = 0;
				TusKilidi = 0;
				return 1;
										 
			}
		else
	        {         
				//CagriDrm = 0;
				
				//printf("ATH\r\n");
				return 0;

			}
	}








void CagriYap()

	{
		printf ("ATD053022x0x7x;\r\n");
		//printf ("ATD05069104153;\r\n");
		AlrVar = 1;
		DelayMs(10000);
	
	}

void MesajGonder()

	{	
	
		

		unsigned char cc;
		
				 //MsgSent=1;
				  					 
				 //Lcd_Ekran_Sil();
				 //Lcd_Ekran_XY(3,0);
				 //Lcd_PutStr("Mesaj Sending");
				 
				 printf ("ATH\r\n");
		
				 DelayMs(500);
		
				 printf ("AT+CMGF=1\r\n");
		
				 DelayMs(500);
		
				 printf ("AT+CMGS=");
						
				 sendchar(0x22);
		
				 
				 printf ("053022x0x7x");		  
				 //printf ("05069104153");
				 sendchar(0x22);
		
		 		 printf ("\r\n");
		
						 cc = getkey();
		
						 while(!(cc=='>'))
						 	
							{
							 	cc = getkey();	
							}	
		
		
						printf ("TEKNEDE ALARM ");
						
						
						sendchar(Buf1[0]);
						sendchar(Buf1[1]);
						sendchar(Buf1[2]);
						sendchar(Buf1[3]);
						sendchar(Buf1[4]);
						sendchar(Buf1[5]);
						sendchar(Buf1[6]);
						sendchar(Buf1[7]);
						sendchar(Buf1[8]);
						sendchar(Buf1[9]);
						sendchar(Buf1[10]);
						sendchar(Buf1[11]);
						 
						printf (" N  ");
		
						sendchar(Buf2[0]);
						sendchar(Buf2[1]);
						sendchar(Buf2[2]);
						sendchar(Buf2[3]);
						sendchar(Buf2[4]);
						sendchar(Buf2[5]);
						sendchar(Buf2[6]);
						sendchar(Buf2[7]);
						sendchar(Buf2[8]);
						sendchar(Buf2[9]);
						sendchar(Buf2[10]);
						sendchar(Buf2[11]);
						 
						 printf (" E ");
		
						
		
						sendchar(0x1A);

						DelayMs(15000);
						DelayMs(15000);
						DelayMs(5000);
						    			
						//Lcd_Ekran_XY(3,0);
						//Lcd_PutStr("Mesaj Sent   ");

						DelayMs(5000);

						Lcd_Ekran_Sil();
						
	


	}

void ZamanKontrol()
	
	{

	if ((GpsDakika==0) & (MsgSent==0))	
			{
			 ZamanDrm = 1;
			 return;
			}	

	 if ((GpsDakika==15) & (MsgSent==0))
			{
			 ZamanDrm = 1;
			 return;
			}	

	 if ((GpsDakika==30) & (MsgSent==0))
			{
			 ZamanDrm = 1;
			 return;
			}	

	 if ((GpsDakika==45) & (MsgSent==0))
			{
			 ZamanDrm = 1;
			 return;
			}	

	}


void ALARM()

	{
	   int Sayac = 0;
	   
	   if (AlarmDrm == 1)

	   		{

			   if (ss > AcilmaS )
					
					{
										   

					


				 
				   
					if (AlrVar == 0)
						{
						  AlrVar = 1;
						  CagriYap();
						}

				   /*
				     //ilk çağrıda mesaj atar
					if (MsgGonDrm == 0)
						{
						  MsgGonDrm = 1;
						  MesajGonder();
						}
				   */



					   if (CagriDrm == 0)
							
							{					   

							   ZamanKontrol();	
					   		
							   if(ZamanDrm == 1)
							   		{
										ZamanDrm = 0;							

	

					   					MesajGonder();
									}


					   		}

					}

		
		while(Sayac < 40)

			{
			  	CagriKontrol();
				Sayac++;
			}	
   
   
   	}


	}


void Alarm_Seyir_Show()
	{
	   

 		Lcd_Ekran_XY(1,0);
		Lcd_PutStr(".");

		if (ss > AcilmaS )
			{
			  Lcd_Ekran_XY(2,0);
			  Lcd_PutStr(".");
			}

	
	/*
		Lcd_PutChar(Buf7[0]);
		Lcd_PutChar(Buf7[1]);
		Lcd_PutChar(Buf7[2]);
		Lcd_PutChar(Buf7[3]);
		Lcd_PutChar(Buf7[4]);
		Lcd_PutChar(Buf7[5]);

		Lcd_Ekran_XY(2,0);
		Lcd_PutStr("                  ");


		if (ss > AcilmaS )
			{
			Lcd_Ekran_XY(2,0);
			Lcd_PutStr("ALARM CALIYOR");

		
			}

	  */


		/*
		 if (AlrVar == 0)

				{
				 printf ("ATD05302200070;\r\n");

				 AlrVar = 1;
				 return;
				 DelayMs(5000);
				 DelayMs(5000);
				 DelayMs(5000);
				 DelayMs(5000);

				 

				 printf ("AT+CMGF=1\r\n");

				 DelayMs(500);

				 printf ("AT+CMGS=");
				
				 sendchar(0x22);

				 printf ("05457617732");
				  
				 sendchar(0x22);

 				 printf ("\r\n");

				 cc = getkey();

				 while(!(cc=='>'))
				 	
					{
					 	cc = getkey();	
					}	


				printf ("TEKNEDE ALARM ");
				
				
				sendchar(Buf1[0]);
				sendchar(Buf1[1]);
				sendchar(Buf1[2]);
				sendchar(Buf1[3]);
				sendchar(Buf1[4]);
				sendchar(Buf1[5]);
				sendchar(Buf1[6]);
				sendchar(Buf1[7]);
				sendchar(Buf1[8]);
				sendchar(Buf1[9]);
				sendchar(Buf1[10]);
				sendchar(Buf1[11]);
				 
				printf (" N  ");

				sendchar(Buf2[0]);
				sendchar(Buf2[1]);
				sendchar(Buf2[2]);
				sendchar(Buf2[3]);
				sendchar(Buf2[4]);
				sendchar(Buf2[5]);
				sendchar(Buf2[6]);
				sendchar(Buf2[7]);
				sendchar(Buf2[8]);
				sendchar(Buf2[9]);
				sendchar(Buf2[10]);
				sendchar(Buf2[11]);
				 
				 printf (" E ");

				

				sendchar(0x1A);
				
			  
				}

		   */
				

		
	
	}



void TUS_KONTROL()

	{

		for(;;)

			{
				Tus = KeyPadOku();

					

				if (Tus == 0)
					return;
					//break;

				//printf("tus=%d\r\n",Tus);
				
					
				DelayMs(200);
									
				    if (Tus == 16384)		// ISIK KONTROL
					    {
						
							 if(LcdLedDrm == 0)
								{
								 Lcd_Led_DIR |= Lcd_Led;
								 Lcd_Led_SET |= Lcd_Led;
								 LcdLedDrm = 1;
								 DelayMs(200);
								 return;
								 //break;	
								}
							 else
								{
								 Lcd_Led_DIR |= Lcd_Led;
								 Lcd_Led_CLR |= Lcd_Led;
								 LcdLedDrm = 0;
								 DelayMs(200);
								 return;
								 //break;
								}
						}

			    
					if (Tus == 8192)	// TARIH ZAMAN SHOW
						{
							 DelayMs(200);
							 MenNum = 3 ;
							 AlarmDrm = 0;
							 Lcd_Ekran_Sil();
							 return;
							 //break;	
						
						 }
						
					if (Tus == 16)		// SEYIR MENU GIRIS
						{
							 DelayMs(200);
							 MenNum = 4 ;
							 AlarmDrm = 0 ;
							 Lcd_Ekran_Sil();
							 return;
							 //break;	
						}


					if (Tus == 1)		// KONUM DETAY SHOW
						{
							 DelayMs(200);
							 MenNum = 1 ;
							 AlarmDrm = 0 ;
							 Lcd_Ekran_Sil();
							 return;
							 //break;	
						}

					if (Tus == 2)		// ALARM MENU GIRIŞ
						{
							 DelayMs(200);
							 MenNum = 6 ;
							 AlarmDrm = 0 ;
							 Lcd_Ekran_Sil();
							 return;
							 //break;	
						}





					if (Tus == 4096)		// ANA MENU
						{
							 DelayMs(200);
							 MenNum = 0 ;
							 Lcd_Ekran_Sil();
							 CagriDrm = 0;
							 AlarmDrm = 0;
							 return;
							 //break;	
						}


					if (Tus == 256)		// SEYIR DETAY SHOW 
						{
							 DelayMs(200);
							 MenNum = 8 ;
							 Lcd_Ekran_Sil();
							 return;
							 //break;	
						}


				   }



	}



void F2L2Oku()
  {
    fi2 = HDereceE;
    l2  = HDereceB;

  }


void AlrF2L2Oku()
  {
    fi2 = AcilmaFi2;
    l2  = AcilmaL2;

  }








//*******************************************************************************
//*******************************************************************************
//*******************************************************************************
//*******************************************************************************
int main (void)

	{
		System_Init();
	    
		init_serial0(9600);
   		
		init_serial1(9600);

  		GPS_INIT();

/*
		while(1)
		
		{
				printf("BASLA\r\n");
				
				
				intChar = GetKeyTT(10000);
				sendchar(intChar);
			
		
		}

  */



	  
	
	    

		Lcd_Modulu_Hazirla();
		
		KeyPadInit();
		
		Lcd_Ekran_Sil();
		LogoShow();

		DelayMs(1000);

		Lcd_Ekran_Sil();



/* 

while(1)

{
	
   Gosterge=getkey();
   uart0_putc(Gosterge);





}

*/


		GpsDurumShow();


/*

		while( GpsStatu == 'V')

			{
				GPS_VERI_AL();
				
				GpsDurumShow();

				printf("GPS STATU=%c\r\n",GpsStatu); 

			}
 */
		Lcd_Ekran_Sil();


		
		

		while(1)

			{
	
				
			    if (MenNum == 0 )
					{
						TusKilidi = 0;
						AlarmDrm = 0;
						AlrVar   = 0;
						Menu_Main();		
					}
	
			    if (MenNum == 1 )
					{
						KonumDetayShow();		
					}
				
			    if (MenNum == 2 )
					{
						SeyirDetayShow();		
					}
	
	
			    if (MenNum == 3 )
					{
						TarihZamanShow();		
					}
	
			    if (MenNum == 4 )
					{
						Menu_Seyir();
						Lcd_Ekran_Sil();
						MenNum = 2;		
					}

			    if (MenNum == 6 )
					{
						Menu_Alarm();		
					}

			    if (MenNum == 7 )
					{
						Alarm_Seyir_Show();		
					}

			    if (MenNum == 8 )
					{
						VarisZamaniShow();		
					}

				
			  //printf("TUS KILID=%d\r\n",TusKilidi);

			  if  (TusKilidi == 0) 
			  		{
						TUS_KONTROL();
					}
		
	
				GPS_VERI_AL();
				




				
			if(AlarmDrm == 1)
				{
					AlrF2L2Oku();
				}
			else
				{
					F2L2Oku();
				}

				RadyanYap();
		
				dFdLHesapla();
		
				HESAPLA();


				ALARM();
		
	
			}

		


	}

[BenC]

Arkadaşlar şema yok  malesef hazır lpc2148 header bord vardı ona bir lcd keypad pcb si yaptım öylece aldı gitti arkadaş. Vakit bulabilrisem şema eklerim. Sözvermeyim vakit bulursam.  Projenin bitmiş halinin resimleri ve video görüntüleri olacak. bulursam onlarıda ekleyeceğim. Saygılarımla.

[BenC]

Projenin bitmiş resimleri:

[BenC]

[BenC]

[elt42at]

Çok güzel bir çalışma! Başarılar dilerim. Ben de GPS e heves edip micro-tracker projesi yapmaya çalışmıştım. 8051 kullanarak 1 proje yaptım. UART moddan 4800bps GPGGA ve GPVTG verisini alıp 2x16 ekran üzerinde enlem, boylam, aktif kanal sayısı ve hız bilgisini gösteriyor. Projende sd/mmc kart desteği verebilirmişsin. Google earth için KLM verileri depolayabilirsin.
Tebrik ederim. iyi çalışmalar

[BenC]

[PROTECH_]

Güzel bir çalışma tebrikler.

Yanlız bir sorum olacaktı: Anladığım kadarı ile gsm işlemlerini  telefon üzerinden hallediyorsunuz, işlemi sony-ericson telefon üzerinden gerçekleştirme işlemi tam olarak nasıl oluyor ? telefona ait dışarıdan at komutlarını girebilme gibi spesifik bir özellikmi var tam olarak olay nasıl oluyor ?

saygılar.

[BenC]

Teşekürler arkadaşlar.

GSM kısmını AT komutları ile yapıyorum. Telefonun alt konnektöründe txd,rxd pinlerini kullandım. Video da sonlandırma vs elle yaptım ama o deneme aşamalarıydı.

Bu da LPC2148 header board:

[BenC]

Projeye ait bütün kaynaklar.

http://rapidshare.com/files/390227747/GPS_LCD_NAV.rar.html