Encoder ayarlamalı saat

[necati]

//Encoder.c
#include <16f628a.h>
#fuses INTRC_IO, NOWDT, BROWNOUT, NOLVP
#use delay (internal=4MHz)

//=======================
#include "flex_lcd.h"
#include "ds1302.h"
//===================================
static long iTemperature;


#define CLEAR_DISP 0x01
#define DEGREE_SYM 0xdf

//========================================MENU FLAGS==========================================
//menu flags/value. default state/value of all flags is 0
int   menu_digit_flag=0; //1 is hour; 2 is minute ;0 is normal modde
int   clock_mode=0;      //0 is normal ; 1 is menu mode (blinking display); 2 is edit mode
//============================================================================================
byte hour,minute,second,day,month,year,weekday;
int8 b1, b2, b3, b4;
byte HH,MM;
///////////////////////////////////////////////
set_time(){
//set rtc time
rtc_set_datetime(day,month,year,weekday,HH,MM);
//reset all flags to normal state
}
////////////////////////////////////////////////////////////////////////////////
//for rotary encoder
#define CH_A   PIN_A4
#define CH_B   PIN_A3
#define button PIN_A2

int encoder0Pos = 0;
int encoder0PinALast = 0;
int n = 0;
int stp=0;
void read_encoder(){
    int MAX=9; int MIN=0;
    if (menu_digit_flag==1){MAX=23;}//hours
    if (menu_digit_flag==2) {MAX=59;}//minutes
    ///////////////////////////////////////////
    n=input(CH_B);
    if((encoder0PinALast==0)&&(n==1)){
    lcd_gotoxy(1,1);
    printf(lcd_putc,"                   ");
    lcd_gotoxy(1,2);
    printf(lcd_putc,"                   ");

    if(input(CH_A)==0){encoder0Pos--;}
    else {encoder0Pos++;}
    }
    encoder0PinALast = n;
    ///////////////////////////////////////////
if(encoder0Pos>MAX){encoder0Pos=0;}
if(encoder0Pos<MIN){encoder0Pos=0;}
}
////////////////////////////////////////////////////////////////////////////////
void display_number(int num){
int digit1,digit2;
////////////////////////////
if (num<=99){
digit1=num/10;
digit2=num%10;
show_num(digit1);
x_pos_state=x_pos_state+4;
show_num(digit2);
x_pos_state=1;
}
}
////////////////////////////
adj_hour(){
x_pos_state=2;
read_encoder();
HH=encoder0Pos;
display_number(HH);
//set_time();
}
////////////////////////////
adj_minute(){
x_pos_state=13;
read_encoder();
MM=encoder0Pos;
display_number(MM);
//set_time();
}
////////////////////////////

//=============================
void main(){

lcd_init();
lcd_load_custom_chars();
rtc_init();

lcd_gotoxy(3,1);
printf ( lcd_putc, "PiCPROJE.ORG     ");
delay_ms(2000);
// Clear the LCD.
printf(lcd_putc, "\f");
delay_ms(250);
////////////////////////////////////////////////////////////////////////////////
while(true){

//clock_mode=2;
//menu_digit_flag=2;

if ((clock_mode==2) && (menu_digit_flag==1)){adj_hour();}
if ((clock_mode==2) && (menu_digit_flag==2)){adj_minute();}
///////////////////////////////////////////////////////////////////////saati yaz
if (clock_mode==0 && menu_digit_flag==1){
rtc_get_time( hour, minute, second );

x_pos_state=2;
rtc_get_time( hour, minute, second );
b1=hour;
b2=minute;
if (b3!=b1){clearnumber(2);clearnumber(4);b3=b1;}
if (b4!=b2){clearnumber(13);clearnumber(17);b4=b2;}
display_number(hour);
x_pos_state=10;
//if (second%2==0){custom_dah();clearnumber(10);}
//if (second%2==1){custom_dit();}
x_pos_state=13;
display_number(minute);

lcd_gotoxy(10,2);
printf(lcd_putc,"%2u ",second);
}
///////////////////////////////////////////////////////////////////////saati yaz
//encoder button
if(!input(button)){stp++;
if(stp>4){stp=0;}
while(!input(button)){
lcd_gotoxy(1,3);
printf(lcd_putc,"%u ",stp);
delay_ms(250);
}
}

switch (stp){

    case 0:clock_mode=0;
      menu_digit_flag=1;
           break;

    case 1:clock_mode=2;
      menu_digit_flag=1;
           break;

    case 2:clock_mode=2;
      menu_digit_flag=2;
           break;

    case 3:clock_mode=0;
      menu_digit_flag=1;
           break;   
           
    case 4:clock_mode=0;
      menu_digit_flag=1;
           break;
           
            }
//////////////////////////////////////////////////////////////////////
}
}
////////////////////////////////////////////////////////////////////////////////
//flex_lcd.h
// Flex_LCD420.c

// These pins are for my Microchip PicDem2-Plus board,
// which I used to test this driver.
// An external 20x4 LCD is connected to these pins.
// Change these pins to match your own board's connections.

#define LCD_DB4   PIN_A1
#define LCD_DB5   PIN_A0
#define LCD_DB6   PIN_A7
#define LCD_DB7   PIN_A6

#define LCD_RS    PIN_B2
#define LCD_RW    PIN_B1
#define LCD_E     PIN_B0

/*
// To prove that the driver can be used with random
// pins, I also tested it with these pins:
#define LCD_DB4   PIN_D4
#define LCD_DB5   PIN_B1
#define LCD_DB6   PIN_C5
#define LCD_DB7   PIN_B5

#define LCD_RS    PIN_E2
#define LCD_RW    PIN_B2
#define LCD_E     PIN_D6
*/

// If you want only a 6-pin interface to your LCD, then
// connect the R/W pin on the LCD to ground, and comment
// out the following line.  Doing so will save one PIC
// pin, but at the cost of losing the ability to read from
// the LCD.  It also makes the write time a little longer
// because a static delay must be used, instead of polling
// the LCD's busy bit.  Normally a 6-pin interface is only
// used if you are running out of PIC pins, and you need
// to use as few as possible for the LCD.
//#define USE_RW_PIN   0     


// These are the line addresses for most 4x20 LCDs.
#define LCD_LINE_1_ADDRESS 0x00
#define LCD_LINE_2_ADDRESS 0x40
#define LCD_LINE_3_ADDRESS 0x14
#define LCD_LINE_4_ADDRESS 0x54

// These are the line addresses for LCD's which use
// the Hitachi HD66712U controller chip.
/*
#define LCD_LINE_1_ADDRESS 0x00
#define LCD_LINE_2_ADDRESS 0x20
#define LCD_LINE_3_ADDRESS 0x40
#define LCD_LINE_4_ADDRESS 0x60
*/


//========================================

#define lcd_type 2   // 0=5x7, 1=5x10, 2=2 lines(or more)

int8 lcd_line;

int x_pos_state=1;


int8 const LCD_INIT_STRING[4] =
{
0x20 | (lcd_type << 2),  // Set mode: 4-bit, 2+ lines, 5x8 dots
0xc,                     // Display on
1,                       // Clear display
6                        // Increment cursor
};
//-------------------------------------
void lcd_send_nibble(int8 nibble)
{
// Note:  !! converts an integer expression
// to a boolean (1 or 0).
output_bit(LCD_DB4, !!(nibble & 1));
output_bit(LCD_DB5, !!(nibble & 2)); 
output_bit(LCD_DB6, !!(nibble & 4));   
output_bit(LCD_DB7, !!(nibble & 8));   

delay_cycles(1);
output_high(LCD_E);
delay_us(2);
output_low(LCD_E);
}
//-----------------------------------
// This sub-routine is only called by lcd_read_byte().
// It's not a stand-alone routine.  For example, the
// R/W signal is set high by lcd_read_byte() before
// this routine is called.     

#ifdef USE_RW_PIN
int8 lcd_read_nibble(void)
{
int8 retval;
// Create bit variables so that we can easily set
// individual bits in the retval variable.
#bit retval_0 = retval.0
#bit retval_1 = retval.1
#bit retval_2 = retval.2
#bit retval_3 = retval.3

retval = 0;
   
output_high(LCD_E);
delay_us(1);

retval_0 = input(LCD_DB4);
retval_1 = input(LCD_DB5);
retval_2 = input(LCD_DB6);
retval_3 = input(LCD_DB7);
 
output_low(LCD_E);
delay_us(1);
   
return(retval);   
}   
#endif
//---------------------------------------
// Read a byte from the LCD and return it.

#ifdef USE_RW_PIN
int8 lcd_read_byte(void)
{
int8 low;
int8 high;

output_high(LCD_RW);
delay_cycles(1);

high = lcd_read_nibble();

low = lcd_read_nibble();

return( (high<<4) | low);
}
#endif
//----------------------------------------
// Send a byte to the LCD.
void lcd_send_byte(int8 address, int8 n)
{
output_low(LCD_RS);

#ifdef USE_RW_PIN
while(bit_test(lcd_read_byte(),7)) ;
#else
delay_us(60); 
#endif

if(address)
   output_high(LCD_RS);
else
   output_low(LCD_RS);
     
delay_cycles(1);

#ifdef USE_RW_PIN
output_low(LCD_RW);
delay_cycles(1);
#endif

output_low(LCD_E);

lcd_send_nibble(n >> 4);
lcd_send_nibble(n & 0xf);
}
//----------------------------

void lcd_init(void)
{
int8 i;

lcd_line = 1;

output_low(LCD_RS);

#ifdef USE_RW_PIN
output_low(LCD_RW);
#endif

output_low(LCD_E);

// Some LCDs require 15 ms minimum delay after
// power-up.  Others require 30 ms.  I'm going
// to set it to 35 ms, so it should work with
// all of them.
delay_ms(35);         

for(i=0 ;i < 3; i++)
   {
    lcd_send_nibble(0x03);
    delay_ms(5);
   }

lcd_send_nibble(0x02);

for(i=0; i < sizeof(LCD_INIT_STRING); i++)
   {
    lcd_send_byte(0, LCD_INIT_STRING);
   
    // If the R/W signal is not used, then
    // the busy bit can't be polled.  One of
    // the init commands takes longer than
    // the hard-coded delay of 50 us, so in
    // that case, lets just do a 5 ms delay
    // after all four of them.
    #ifndef USE_RW_PIN
    delay_ms(5);
    #endif
   }
}
//----------------------------

void lcd_gotoxy(int8 x, int8 y)
{
int8 address;


switch(y)
  {
   case 1:
     address = LCD_LINE_1_ADDRESS;
     break;

   case 2:
     address = LCD_LINE_2_ADDRESS;
     break;

   case 3:
     address = LCD_LINE_3_ADDRESS;
     break;

   case 4:
     address = LCD_LINE_4_ADDRESS;
     break;

   default:
     address = LCD_LINE_1_ADDRESS;
     break;
     
  }

address += x-1;
lcd_send_byte(0, 0x80 | address);
}
//----------------------------

//-----------------------------
void lcd_putc(char c)
{
switch(c)
   {
    case '\f':
      lcd_send_byte(0,1);
      lcd_line = 1;
    //  delay_ms(2);
      break;
   
    case '\n':
       lcd_gotoxy(1, ++lcd_line);
       break;
   
    case '\b':
       lcd_send_byte(0,0x10);
       break;
   
    default:
       lcd_send_byte(1,c);
       break;
   }
}
//------------------------------
#ifdef USE_RW_PIN
char lcd_getc(int8 x, int8 y)
{
char value;

lcd_gotoxy(x,y);

// Wait until busy flag is low.
while(bit_test(lcd_read_byte(),7)); 

output_high(LCD_RS);
value = lcd_read_byte();
output_low(LCD_RS);

return(value);
}
#endif

const int8 lcd_custom_chars[] =
{
  0b00000111,
  0b00001111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,

  0b00011111,
  0b00011111,
  0b00011111,
  0b00000000,
  0b00000000,
  0b00000000,
  0b00000000,
  0b00000000,

  0b00011100,
  0b00011110,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,

  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00001111,
  0b00000111,

  0b00000000,
  0b00000000,
  0b00000000,
  0b00000000,
  0b00000000,
  0b00011111,
  0b00011111,
  0b00011111,

  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011110,
  0b00011100,

  0b00011111,
  0b00011111,
  0b00011111,
  0b00000000,
  0b00000000,
  0b00000000,
  0b00011111,
  0b00011111,

  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
  0b00011111,
};

void lcd_load_custom_chars(void)
{
int8 i;

// Set address counter pointing to CGRAM address 0.
lcd_send_byte(0, 0x40); 

// Load custom lcd character data into CGRAM.
// It can only hold a maximum of 8 custom characters.
for(i = 0; i < sizeof(lcd_custom_chars); i++)
   {
    lcd_send_byte(1, lcd_custom_chars);
   }

// Set address counter pointing back to the DDRAM.
lcd_send_byte(0, 0x80);
}

void custom0()
{ // uses segments to build the number 0
  lcd_gotoxy(x_pos_state+0,1); // set cursor to column 0, line 0 (first row)
  lcd_putc(0);  // call each segment to create
  lcd_putc(1);  // top half of the number
  lcd_putc(2);
  lcd_gotoxy(x_pos_state+0, 2); // set cursor to colum 0, line 1 (second row)
  lcd_putc(3);  // call each segment to create
  lcd_putc(4);  // bottom half of the number
  lcd_putc(5);
}

void custom1()
{
  lcd_gotoxy(x_pos_state+0,1);
  lcd_putc(1);
  lcd_putc(2);
  lcd_gotoxy(x_pos_state+0,2);
  lcd_putc(4);
  lcd_putc(7);
  lcd_putc(4);
}

void custom2()
{
  lcd_gotoxy(x_pos_state+0,1);
  lcd_putc(6);
  lcd_putc(6);
  lcd_putc(2);
  lcd_gotoxy(x_pos_state+0, 2);
  lcd_putc(3);
  lcd_putc(4);
  lcd_putc(4);
}

void custom3()
{
  lcd_gotoxy(x_pos_state+0,1);
  lcd_putc(6);
  lcd_putc(6);
  lcd_putc(2);
  lcd_gotoxy(x_pos_state+0, 2);
  lcd_putc(4);
  lcd_putc(4);
  lcd_putc(5);
}

void custom4()
{
  lcd_gotoxy(x_pos_state+0,1);
  lcd_putc(3);
  lcd_putc(4);
  lcd_putc(7);
  lcd_gotoxy(x_pos_state+2, 2);
  lcd_putc(7);
}

void custom5()
{
  lcd_gotoxy(x_pos_state+0,1);
  lcd_putc(3);
  lcd_putc(6);
  lcd_putc(6);
  lcd_gotoxy(x_pos_state+0, 2);
  lcd_putc(4);
  lcd_putc(4);
  lcd_putc(5);
}

void custom6()
{
  lcd_gotoxy(x_pos_state+0,1);
  lcd_putc(0);
  lcd_putc(6);
  lcd_putc(6);
  lcd_gotoxy(x_pos_state+0, 2);
  lcd_putc(3);
  lcd_putc(4);
  lcd_putc(5);
}

void custom7()
{
  lcd_gotoxy(x_pos_state+0,1);
  lcd_putc(1);
  lcd_putc(1);
  lcd_putc(2);
  lcd_gotoxy(x_pos_state+2, 2);
  lcd_putc(7);
}

void custom8()
{
  lcd_gotoxy(x_pos_state+0,1);
  lcd_putc(0);
  lcd_putc(6);
  lcd_putc(2);
  lcd_gotoxy(x_pos_state+0, 2);
  lcd_putc(3);
  lcd_putc(4);
  lcd_putc(5);
}

void custom9()
{
  lcd_gotoxy(x_pos_state+0,1);
  lcd_putc(0);
  lcd_putc(6);
  lcd_putc(2);
  lcd_gotoxy(x_pos_state+2, 2);
  lcd_putc(7);
}

void custom_dit(){
  lcd_gotoxy(x_pos_state+1,1);
  lcd_putc(1);
  lcd_gotoxy(x_pos_state+0,2);
  lcd_putc(4);
}


void custom_dah(){
  lcd_gotoxy(x_pos_state+0,1);
  lcd_putc(1);
  lcd_gotoxy(x_pos_state+1,2);
  lcd_putc(4);

}

void clearnumber(int m)
{ // clears the area the custom number is displayed in
lcd_gotoxy(m,1);
printf(lcd_putc,"   ");
lcd_gotoxy(m,2);
printf(lcd_putc,"   ");
}


void show_num(int num){
if (num<=9){
switch (num) {
    case 0:custom0();
           break;
    case 1:custom1();
           break;
    case 2:custom2();
           break;
    case 3:custom3();
           break;
    case 4:custom4();
           break;
    case 5:custom5();
           break;
    case 6:custom6();
           break;
    case 7:custom7();
           break;
    case 8:custom8();
           break;
    case 9:custom9();
           break;   
   }   
}
}
////////////////////////////////////////////////////////////////////////////////
//ds1302.h
#ifndef RTC_SCLK

#define RTC_SCLK PIN_B4
#define RTC_IO   PIN_B5
#define RTC_RST  PIN_B6

#endif

void write_ds1302_byte(BYTE cmd) {
   BYTE i;

   for(i=0;i<=7;++i) {
      output_bit(RTC_IO, shift_right(&cmd,1,0) );
      output_high(RTC_SCLK);
      output_low(RTC_SCLK);
   }
}

void write_ds1302(BYTE cmd, BYTE data) {

   output_high(RTC_RST);
   write_ds1302_byte(cmd);
   write_ds1302_byte(data);
   output_low(RTC_RST);
}

BYTE read_ds1302(BYTE cmd) {
   BYTE i,data;

   output_high(RTC_RST);
   write_ds1302_byte(cmd);

   for(i=0;i<=7;++i) {
      shift_right(&data,1,input(RTC_IO));
      output_high(RTC_SCLK);
      delay_us(2);
      output_low(RTC_SCLK);
      delay_us(2);
   }
   output_low(RTC_RST);

   return(data);
}

void rtc_init() {
   BYTE x;
   output_low(RTC_RST);
   delay_us(2);
   output_low(RTC_SCLK);
   write_ds1302(0x8e,0);
   write_ds1302(0x90,0xa4);
   x=read_ds1302(0x81);
   if((x & 0x80)!=0)
     write_ds1302(0x80,0);
}

int get_bcd(BYTE data)
{
   int nibh;
   int nibl;

   nibh=data/10;
   nibl=data-(nibh*10);

   return((nibh<<4)|nibl);
}

int rm_bcd(BYTE data)
{
   int i;

   i=data;
   data=(i>>4)*10;
   data=data+(i<<4>>4);

   return data;
}

void rtc_set_datetime(BYTE day, BYTE mth, BYTE year, BYTE dow, BYTE hr, BYTE min) {

   write_ds1302(0x86,get_bcd(day));
   write_ds1302(0x88,get_bcd(mth));
   write_ds1302(0x8c,get_bcd(year));
   write_ds1302(0x8a,get_bcd(dow));
   write_ds1302(0x84,get_bcd(hr));
   write_ds1302(0x82,get_bcd(min));
   write_ds1302(0x80,get_bcd(0));
}

void rtc_get_date(BYTE& day, BYTE& mth, BYTE& year, BYTE& dow) {
   day = rm_bcd(read_ds1302(0x87));
   mth = rm_bcd(read_ds1302(0x89));
   year = rm_bcd(read_ds1302(0x8d));
   dow = rm_bcd(read_ds1302(0x8b));
}

void rtc_get_time(BYTE& hr, BYTE& min, BYTE& sec) {
   hr = rm_bcd(read_ds1302(0x85));
   min = rm_bcd(read_ds1302(0x83));
   sec = rm_bcd(read_ds1302(0x81));
}

void rtc_write_nvr(BYTE address, BYTE data) {
   write_ds1302(address|0xc0,data);
}

BYTE rtc_read_nvr(BYTE address) {
    return(read_ds1302(address|0xc1));
}

http://www.4shared.com/rar/rjN7c6xV/Encoder_ayaril_saat.html

[Murat Mert]

S.A.
Sn. Necati güzel paylaşım lcd de farklı karakter olarak sayılar gösterilmiş baya hoş olmuş.