void main()
{
uint8 idata str1[100],str2[100];
uint8 i,index=0;
lcdinit();
lcdinit();
for(i=0;i<16;i++)
{
str1[i]=' ';
str2[i]=' ';
str1[16+sizeof(string1)+i]=' ';
str2[16+sizeof(string2)+i]=' ';
}
for(i=0;i<sizeof(string1);i++)
{
str1[16+i]=string1[i];
str2[16+i]=string2[i];
}
i--;
str1[16+i]=' ';
str2[16+i]=' ';
while(1)
{
lcdshow(0,0,str1+index,16);
lcdshow(0,1,str2+index,16);
Delay100ms();
index++;
if(index>=(15+sizeof(string1)))index=0;
}
}
void main()
{
trisb=0x00;
lcdinit();
printf("enter the password");
clrscr();
while(1)
{
for(i=0;i<=11;i++)
{
value[i]=getc();
//delay_ms(500); **No delay needed**
//printf("%c", val[i]); /*can use for debugging*/
//printc(value[i]);/*can use for debugging*/
}
if(value[0]=='3' && value[1]=='4' && value[2]=='0' && value[3]=='0' && value[4]=='6' && value[5]=='C' && value[6]=='5' && value[7]=='D' && value[8]=='9' && value[9]=='8' && value[10]=='9' && value[11]=='D')
{
clrscr();
printc("User 1 Identified");
}
else if(value[0]=='3' && value[1]=='4' && value[2]=='0' && value[3]=='0' && value[4]=='6' && value[5]=='C' && value[6]=='5' && value[7]=='9' && value[8]=='4' && value[9]=='3' && value[10]=='4' && value[11]=='2')
{
clrscr();
printc("User 2 Identified");
}
}
}
void
screeninit(void)
{
Mode m;
m.x = Colmaxx;
m.y = Colmaxy;
m.d = Colldepth;
m.aperture = 0;
lcdinit(&m);
if(m.aperture == 0)
return;
gscreen.ldepth = 3;
gscreen.base = (ulong*)m.aperture;
gscreen.width = Colmaxx/BY2WD;
gscreen.r = Rect(0, 0, Colmaxxvis, Colmaxy);
gscreen.clipr = gscreen.r;
/*
* For now, just use a fixed colormap:
* 0 == white and 255 == black
*/
setcolor(0, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
setcolor(255, 0x00000000, 0x00000000, 0x00000000);
gbitblt(&gscreen, Pt(0, 0), &gscreen, gscreen.r, Zero);
out.pos.x = MINX;
out.pos.y = 0;
out.bwid = defont0.info[' '].width;
}
void main()
{
lcdinit();
lcdshow(0,0,"hello world");
lcdshow(8,1,"By HXL");
while(1);
}
static int lcdi2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
data = (LcdData_t *) devm_kzalloc(&client->dev, sizeof(LcdData_t),
GFP_KERNEL);
if (!data)
return -ENOMEM;
i2c_set_clientdata(client, data);
sema_init(&data->sem, 1);
data->row = 0;
data->column = 0;
data->handle = client;
data->backlight = 1;
data->cursor = cursor;
data->blink = blink;
data->deviceopencnt = 0;
data->major = major;
lcdinit(data, topo);
lcdprint(data, "HD44780\nDriver");
dev_info(&client->dev, "%ux%u LCD using bus 0x%X, at address 0x%X",
data->organization.columns,
data->organization.rows, busno, address);
return 0;
}
/*
* main.c
*/
int main(void)
{
WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer
if (CALBC1_1MHZ==0xFF) // If calibration constant erased
{
while(1); // do not load, trap CPU!!
}
lcdinit();
uart_init();
__bis_SR_register(GIE);
// uint8_t str[8] = {'+','+','+',0x00};
//
// uart_send_frame(str);
//
// while( !rx_ok ); // Wait until we have received OK from xbee
// str[0] = 'A';
// str[1] = 'T';
// str[2] = 'A';
// str[3] = 'P';
// str[4] = ' ';
// str[5] = '1';
// str[6] = 0x0D;
// str[7] = 0x00;
// rx_ok = 0;
// uart_send_frame(str);
//
// while( !rx_ok );
// str[2] = 'C';
// str[3] = 'N';
// str[4] = ' ';
// rx_ok = 0;
// uart_send_frame(str);
//
// while( !rx_ok );
//
// // Should be in API mode now
// uint8_t buf[22] = {0x7E, 0x00, 0x04, 0x08, 0x07, 'W', 'R', 0x00};
//
// __delay_cycles(10000000);
// buf[7] = calculate_checksum(buf+3,4);
//
// uart_send_frame(buf);
xbee_init("128");
//
// packet_rx_handler( print_packet );
//
// xbee_tx_packet( 100, "Hi!", 3 );
while(1);
return 0;
}
/*
* main.c
*/
void main(void)
{
WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer
P1DIR |= 0xff;
P2DIR |= 0xff;
lcdinit();
LCD_write_string(5,0,"Hello!");
while(1);
}
int main(void){
lcdinit();
goto_xy(0,0);
lcd_text("hello");
//lcd_text();
//lcd_text();
//lcd_int(10);
while(1);
return 0;
}
static ssize_t lcdi2c_reset(struct device* dev, struct device_attribute* attr,
const char* buf, size_t count)
{
CRIT_BEG(data, ERESTARTSYS);
if (count > 0 && buf[0] == '1')
lcdinit(data, topo);
CRIT_END(data);
return count;
}
void main(void)
{
unsigned int HI, LO, TOTAL;
unsigned char l, OV, OFR[16] = "Out Of Range...";
OV = 0;
T0 = 1;
TMOD = 0x05;
TL0 = 0;
TL1 = 0;
lcdinit();
while(1)
{
do
{
start: TR0 = 1;
MSDelay(145);
LO = TL0;
HI = TH0;
HI = HI << 8;
TOTAL = HI | LO;
Unit[0] = 'H';
Unit[1] = 'z';
Unit[2] = ' ';
Unit[3] = ' ';
if(OV == 1)
{
TOTAL = TOTAL / 1000;
TOTAL = TOTAL + 65;
if(TOTAL > 125)
{
for(l=0; l<16; l++)
lcddata(OFR[l]);
for(l=0; l<16; l++)
lcdcmd(0x10);
goto start;
}
OV = 0;
Unit[0] = 'K';
Unit[1] = 'H';
Unit[2] = 'z';
Unit[3] = ' ';
}
inttoLCD(TOTAL);
TL0 = 0;
TH0 = 0;
}
while(TF0 == 0);
OV = 1;
TR0 = 0;
TF0 = 0;
}
}
void main()
{
trisb=0x00;
delay_ms(10);
lcdinit();
delay_ms(1000);
while(1)
{
printc("Ganesh");
delay_ms(1000);
}
}
void
screeninit(void)
{
int i;
/* map the lcd regs into the kernel's virtual space */
lcd = (struct sa1110regs*)mapspecial(LCDREGS, sizeof(struct sa1110regs));;
framebuf = xspanalloc(sizeof *framebuf, 0x100, 0);
vscreen = xalloc(sizeof(ushort)*Wid*Ht);
lcdpower(1);
lcdinit();
gscreen = &xgscreen;
xgdata.ref = 1;
i = 0;
if (landscape) {
gscreen->r = Rect(0, 0, Ht, Wid);
gscreen->clipr = gscreen->r;
gscreen->width = Ht/2;
xgdata.bdata = (uchar *)framebuf->pixel;
while (i < Wid*Ht*1/3) framebuf->pixel[i++] = 0xf800; /* red */
while (i < Wid*Ht*2/3) framebuf->pixel[i++] = 0xffff; /* white */
while (i < Wid*Ht*3/3) framebuf->pixel[i++] = 0x001f; /* blue */
} else {
gscreen->r = Rect(0, 0, Wid, Ht);
gscreen->clipr = gscreen->r;
gscreen->width = Wid/2;
xgdata.bdata = (uchar *)vscreen;
while (i < Wid*Ht*1/3) vscreen[i++] = 0xf800; /* red */
while (i < Wid*Ht*2/3) vscreen[i++] = 0xffff; /* white */
while (i < Wid*Ht*3/3) vscreen[i++] = 0x001f; /* blue */
flushmemscreen(gscreen->r);
}
memimageinit();
memdefont = getmemdefont();
out.pos.x = MINX;
out.pos.y = 0;
out.bwid = memdefont->info[' '].width;
blanktime = 3; /* minutes */
screenwin();
// screenputs = bitsyscreenputs;
screenputs = nil;
}
/*
* initialisation function
* We start here as soon as we have a stack.
* Here we initialize the various systems
* and devices that need to be initialized.
*/
STARTUP(void kmain())
{
// TODO: move these to the appropriate headers
void vtinit();
void grayinit();
void loadavinit();
void battinit();
void usageinit();
void bogomips();
calloutinit();
lcdinit();
meminit();
grayinit();
vtinit();
linkinit();
audioinit();
sched_init();
procinit();
bufinit();
flashinit();
inodeinit();
loadavinit();
battinit();
usageinit();
#if 1
kprintf("%s build %s\n", uname_sysname, uname_version);
#else
kprintf("%s v%s\n", uname_sysname, uname_release);
kputs(
"Copyright 2005-2011 Christopher Williams <*****@*****.**>\n"
"Some portions copyright 2003, 2005 PpHd\n"
"\n"
"This program comes with ABSOLUTELY NO WARRANTY.\n"
"You may redistribute copies of this program\n"
"under the terms of the GNU General Public License.\n"
"\n");
#endif
if (realtime.tv_sec < 1000000000L) { /* before ~2001 */
extern const unsigned long build_date;
realtime.tv_sec = build_date;
realtime.tv_nsec = 0;
}
G.seconds = realtime.tv_sec;
uptime.tv_sec = uptime.tv_nsec = 0;
spl0();
bogomips();
}
int main(void) {
// Vars
struct fp_dev *device;
struct fp_driver *driver;
struct fp_print_data *print_data;
struct fp_img *img;
int err;
// Init the LCD
lcdinit(0x00, 0x12, 0x20);
lcd_reset();
// Init libfprint
fp_init();
// Init the keypad
matrix_init(4, 17, 27, 22, 10, 9, 11, handle_key_press);
// Signal handler - does an fp_exit() on SIGINT
init_signals();
// Get the first fingerprint device
if ((err = get_fingerprint_device(&device)) < 0 || !device) { // Errorz
if (err == -1) {
error("No devices found");
}
else if (err == -2) {
error("Couldn't open the device");
}
return 1;
}
// Get driver
driver = fp_dev_get_driver(device);
// Init message
printf("Programme started! Device is %s\n\n", fp_driver_get_full_name(driver));
// Scan the print
fp_enroll_finger_img(device, &print_data, &img);
// Deinit libfprint
fp_exit();
return 0;
}
void main(void)
{
cct_init();
lcdinit();
InitTimer0();
while(1)
{
if (start==0 && end==1)// vehicle starts its journey by entering at the first line
{
if(msCounter==0)
{
DisplaytoLCD(secCounter-1);
}
UpdateTimeCounters();
}
else if ( start==0 && end==0)//vehicle reached finish line and hence the speed is caliculated here
{
if(msCounter==0)
{
speed=((float)15/(float)secCounter);
FloatToLCD(speed);
}
UpdateTimeCounters1();
}
else//no vehicle for all the combinations
{
if(msCounter==0)
{
Displaystring();
}
UpdateTimeCounters1();// function to make the letters visible fora second and then to refresh
}
}
}
void
blankscreen(int blank)
{
int cnt;
if (blank) {
lcd->lccr0 &= ~(1<<LEN); /* disable the LCD */
cnt = 0;
while((lcd->lcsr & (1<<LDD)) == 0) {
delay(10);
if (++cnt == 100) {
iprint("LCD doesn't stop\n");
break;
}
}
lcdpower(0);
} else {
lcdpower(1);
lcdinit();
}
}
int main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Para o WDT(Wath dog Timer)
// calibrando o clock para trabalhar em 16MHz
BCSCTL1 = CALBC1_16MHZ;
DCOCTL = CALDCO_16MHZ;
// configurando conversor AD para trabalhar com tensao no pino 4
ADC10CTL0 &= ~ENC;
ADC10CTL1 = 4 << 12;
ADC10CTL0 = SREF_0 + ADC10ON + ENC + ADC10SHT_0;
// configurando LED
P1DIR |= BIT6; // EN saida
P1DIR |= BIT0; // LED Vermelho
P1DIR |= BIT7; // RS saida
P2DIR = 0xFF;
P1OUT = 0x00;
lcdinit();
prints("Batimentos ");
gotoXy(7,1);
prints("BPM");
// Configurando interrupcao
TACCR0 = 32000; // 16 MHz / 32000 = 500 Hz
// Usar clock TASSEL_2, no modo UP (MC_1).
TACTL = TASSEL_2 | MC_1;
// Reseta o timer no fim de contagem(OUTMOD_7) e habilita interrupcao (CCIE)
TACCTL1 = OUTMOD_7 | CCIE;
// LPM0 (Lower power mode) bota a cpu para dormir com interrupcao habilitada.
__bis_SR_register(CPUOFF | GIE);
return 0;
}
void main()
{
unsigned char i=0,j=0,result=0;
unsigned int count;
unsigned char c[15];
unsigned char d[]="42006B1BB8";
signed int amount2=900;
TMOD=0x20; // To configure the serial port at 9600 baud rate
TH1=0xFD;
SCON=0X50;
TR1=1;
S1=1;
S2=1;
BUZZPORT=0;
START_POINT=0;
TERMINATE_POINT=0;
lcdinit();
Welcome("AUTOMATIC RFID","CAR PARKING");
DelayMs(1000);
while(1)
{
known:
Welcome("AUTOMATIC RFID","CAR PARKING");
DelayMs(100);
while(S1==0 && S2==0);
if(S2==1)
{
while(S2==1);
if(count>0)
{
count--;
ConvertAndDisplay(count,"Thanks for Visit");
DelayMs(1000);
exit_dcMotor();
goto known;
}
else
{
count=0;
ConvertAndDisplay(count,"Thanks for Visit");
DelayMs(1000);
exit_dcMotor();
goto known;
}
}
if(S1==1)
{
while(S1==1);
for(i=0;i<12;i++)
{
c[i]=0xFF;
}
ConvertAndDisplay(count,"Please Show Card");
DelayMs(100);
while(RI==0);
for(i=0;i<12;i++) //command to recv data
{
j=0;
while(RI==0)
{
if(j>=1000)
goto timeout;
DelayMs(1);
j++;
}
c[i]=SBUF+48;
RI=0;
}
timeout:
//result=strncmp(c,d,10);
if(c[7] == '"' && c[8] == 'R' && c[9] == 'f' && c[10] == 'J' && c[11] == '0')
{
result=0;
}
else
{
result=1;
}
if(count > 10)
{
Welcome("Parking is Full","Sorry for Inconvenience");
buzzer(500);
DelayMs(1000);
goto known;
}
else if(result==0)
{
lcdinit();
Welcome("VEHICAL Amount ","Detected:100");
DelayMs(3000);
amount2-=100;
if(amount2>0)
{
ConvertAndDisplay(amount2,"Balance Amount");
dcMotor();
DelayMs(1000);
}
else
{
amount2=0;
Welcome("VEHICAL Amount ","BALANCE NIL");
buzzer(500);
Welcome("Recharge Your","Card Please");
while(rc1==1&&rc2==1);
{ if(rc1==0)
{
while(rc1==0);
amount2=900;
Welcome("Card is recharged","with amount 900");
DelayMs(2000);
}
if(rc2==0)
{
while(rc2==0);
amount2=500;
Welcome("Card is recharged","with amount 500");
DelayMs(2000);
}
}
}
if(amount2<=400)
{
Welcome("VEHICAL Amount ","BALANCE LOW");
buzzer(200);
}
DelayMs(1000);
count++;
lcdcmd(0x01);
DelayMs(10);
ConvertAndDisplay(count,"Number of Cars");
DelayMs(2000);
goto known;
}
else if(result!=0)
{
Welcome("Card not Matched","Plz Cnt Security");
buzzer(1000);
DelayMs(2000);
}
}
}
}
void main()
{
unsigned char i=0;
unsigned int j=0;
unsigned char c[15];
TMOD=0x20; // Configure the serial port to 9600 baud rate
TH1=0xFD;
SCON=0X50;
TR1=1;
R=0;
lcdinit();
welcome();
bz=1;
while(1)
{
back:
for(i=0;i<15;i++) //command to recv data
{
c[i]=0xFF;
}
while(RI==0);
for(i=0;i<15;i++) //command to recv data
{
j=0;
while(RI==0)
{
if(j>=1000)
goto timeout;
j++;
}
c[i]=SBUF;
RI=0;
}
timeout:
for(i=0;i<15;i++)
{
if(c[i]=='F' && c[i+1]=='E' && c[i+2]=='0' && c[i+3]=='0' && c[i+4]=='5' && c[i+5]=='E' && c[i+6]=='4' && c[i+7]=='E' && c[i+8]=='c' && c[i+9]=='7'&& c[i+10]=='2'&& c[i+11]=='9')
{
sucessRx();
DelayMs(1000);
R=1;
bz=0;
DelayMs(1000);
R=0;
bz=1;
DelayMs(1000);
lcdinit();
DelayMs(100);
welcome();
goto back;
}
}
unknown();
DelayMs(2000);
bz=0;
DelayMs(2000);
bz=1;
DelayMs(1000);
lcdinit();
DelayMs(100);
welcome();
}
}
void main()
{
float adc_a;
float adc_data;
int i = 0, k = 0;
char send_flag = 0;//1 发送成功 0 重发
// Ds1302Init(); //ds1302初始化函数，更改时间需要用到此函数
inituart();
init_adc();
delayms(1);
lcdinit();
charsend("AT+CLTS=1\r\n");
delayms(200);delayms(200);delayms(200);delayms(200);delayms(200);delayms(200);delayms(200);
delayms(200);delayms(200);delayms(200);delayms(200);delayms(200);
time_a();//时钟初始化
delayms(200);delayms(200);delayms(200);delayms(200);delayms(200);delayms(200);
delayms(200);delayms(200);delayms(200);delayms(200);
delayms(200);delayms(200);delayms(200);delayms(200);delayms(200);delayms(200);delayms(200);
delayms(200);delayms(200);delayms(200);delayms(200);delayms(200);delayms(200);delayms(200);
while (1)
{
while (clk_count_last != clk_count)
{
if (gprs_allow_flag == 1)
{
delayms(100);
gprs_allow_flag = 0;
rec_fin = 0;
time_a();//时钟初始化
delayms(200);delayms(200);delayms(200);delayms(200);delayms(200);
time_a();//时钟初始化
delayms(200);delayms(200);delayms(200);delayms(200);
charsend("AT+CIPSEND=183\r\n"); delayms(100);
charsend("POST /data HTTP/1.1\r\nHost:121.40.171.93\r\nContent-Length:87\r\nAuthorization:Basic dGVzdDp0ZXN0\r\n\r\n");
charsend(http_post);
}
if (gprs_fin_flag == 1&& gprs_fin_flag_2 == 1)
{
gprs_fin_flag = 0;
e_gprs = 0; //互斥访问
charsend("ok2222222222222222");
}
if (gprs_fin_flag == 1 && gprs_fin_flag_1 == 1)
{
gprs_fin_flag = 0;
e_gprs = 0; //互斥访问
charsend("ok11111111");
}
clk_count_last = clk_count + 1;
}
clk_count_last = clk_count + 1;
clk_count_last = clk_count_last % 600;
//datasend( get_ad());
// http_post[54] = (int)chao_data_avg_s % 10 + 48; //传感器数据存在http_post
// http_post[53] = (int)chao_data_avg_s / 10 % 10 + 48;
// http_post[51] = (int)chao_data_avg_s / 100 % 10 + 48;
// http_post[50] = (int)chao_data_avg_s / 100 % 10 + 48;
kDisplayListChar(1, 1, myitoa((int)get_ref(),4), 4);
kDisplayListChar(1, 2, "13", 6);
chao_data[data_count%12] = get_ad(); ///1024* 5
tan_data[data_count%12] = get_ref();
data_count++;
data_count=data_count%12;
temper = ReadTemperature();
kDisplayListChar(3, 4, strcat(myitoa(temper / 10, 2), "."), 3);
kDisplayListChar(5, 4, myitoa(temper % 10, 1), 1);
// Ds1302ReadTime(); //时间显示
// time_formchar(time_char);
// /********************************************
// adc_data=get_ad(); //这两句是接压力传感器的处理函数
// range=(adc_data-0x00BD)*0.6; //
//*********************************************/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// if (clk_count % 600 % 60 == 0) //每分钟
// {
//
// split(chao_data, 0, 11);
// split(tan_data, 0, 11);
// chao_data_avg[data_count_avg%10] = average1(chao_data, 4, 7);
// tan_data_avg[data_count_avg%10] = average1(tan_data, 4, 7);
// data_count++;
// data_count_avg=data_count_avg%10;
//
// datasend(chao_data_avg[data_count_avg%10]);
// }
}
}
void main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
P8DIR |= BIT1 + BIT2; // Set P8.1 and P8.2 to output direction
P6DIR = 0xFF; // configure LCD
P6OUT = 0x00; // initialise all pins to low
lcdinit();
prints("Switch Interrupt");
///////////////////////////////////////////////////////////////////////////////
// Set Master Clock to XT2
P7DIR |= BIT7; // MCLK set out to P7.7
P7SEL |= BIT7;
//////////////////////// use XT1 32768 Hz ////////////////////////////////////////////
P5SEL |= BIT4 + BIT5; // Select XT1
UCSCTL6 &= ~XT1OFF; // Enable XT1
UCSCTL6 |= XCAP_3; // Internal load cap
//////////////////////// use XT2 4.0 MHz ////////////////////////////////////////////
P5SEL |= BIT2 + BIT3; // Select XT2
UCSCTL6 &= ~XT2OFF; // Enable XT2
UCSCTL3 |= SELREF__XT1CLK; // FLLref = XT1
do // Loop until XT1 and XT2 stabilize
{
UCSCTL7 &= ~(XT2OFFG + XT1LFOFFG + DCOFFG); // Clear XT2, XT1 fault flags
SFRIFG1 &= ~OFIFG; // Clear oscillator fault flag
} while (SFRIFG1 & OFIFG); // Test oscillator fault flag
UCSCTL6 &= ~(XT2DRIVE0 + XT2DRIVE1); // Decrease XT2 Drive as it is stabilized
UCSCTL6 &= ~(XT1DRIVE0 + XT1DRIVE1); // Decrease XT1 Drive as it is stabilized
UCSCTL4 |= SELA__XT1CLK + SELS__XT2CLK + SELM__XT2CLK; // ACLK = XT1, MCLK = SMCLK = XT2
// UCSCTL4 |= SELA__XT1CLK + SELM__XT2CLK; // ACLK = XT1, MCLK = XT2
P1DIR |= BIT0; // Set P1.0 to output direction
// Timer interrupt
// TA0CCTL0 = CCIE; // capture & compare interrupt
// TA0CCR0 = 0xFFFF;
// TA0CTL = TASSEL__SMCLK + MC_1 + ID__4; // SMCLK, Up to CCR0, /4
// TA0CTL = TASSEL_1 + MC_1; // ACLK
///////////////////////////////////////////////////////////////////////////////
// interrupt approach
P2IES |= BIT0 + BIT2; // P2.0 and P2.2 Hi/lo edge
// P2IES &= ~BIT0 & ~BIT2; // P2.0 and P2.2 lo/Hi edge
P2IFG &= ~BIT0 & ~BIT2; // P2.0 and P2.2 IFG cleared
P2IE |= BIT0 + BIT2; // P2.0 and P2.2 interrupt enabled
// while(1)
// {
// //_BIS_SR(LPM4_bits + GIE); // Enter LPM4 w/interrupt
// _BIS_SR(GIE); // Enable Ginterrupt
// __no_operation();
// }
// _enable_interrupt(); //global interrupt
_BIS_SR(GIE); // Enable Ginterrupt
for(;;)
{//
P1OUT ^= BIT0;
}
}
// Main routine
void main(void) {
OSCCON = 0x7C; // Internal Oscillator 16MHz Enabled
OSCTUNE = 0x5F;
OSCCON2bits.PLLRDY = 1;
VREFCON1 = 0xE0;
T2CON = 0x7B;
INTCONbits.GIE = 1; // Global, peripheral & timer 2 interrupt enable
INTCONbits.PEIE = 1;
PIE1bits.TMR2IE = 1;
PR2 = 0xff; // period registor 2 with max value
VREFCON2 = 0; // zero brightness
LED_DIR = 0; // LED pin on output
LED = 1;
lcdinit(); // Initialize LCD in 4bit mode, ultrasonic and brightness
lcdcmd(0x01);
initUltrasonic();
initBrightness();
LED = 0;
while(1)
{
readPIR();
if(resPIR)
{
pirIndicate();
readUltrasonic();
f1 = 0;
f2 = 1;
while(resUS < 100 && resUS > 10)
{
T2CONbits.TMR2ON = 1;
setBrightness();
if(f2)
{
lcdcmd(0x80);
sprintf(line1," Welcome ! ");
lcdstring(line1);
sprintf(line2," Chaitanya. ");
lcdcmd(0xc0);
lcdstring(line2);
msDelay(1000);
f2 = 0;
}
if(sec >= 60)
{
mn++;
sec = 0;
}
if(mn >= 60)
{
hr++;
mn = 0;
}
sprintf(line1," Study Time ");
sprintf(line2," %i:%i:%i ",hr,mn,sec);
lcdcmd(0x80);
lcdstring(line1);
lcdcmd(0xc0);
lcdstring(line2);
eventL();
eventL();
readUltrasonic();
f1 = 1;
}
T2CONbits.TMR2ON = 0;
if(f1)
{
sprintf(line1," Thank You ! ");
sprintf(line2," Good Bye...! ");
lcdcmd(0x80);
lcdstring(line1);
lcdcmd(0xc0);
lcdstring(line2);
msDelay(3000);
VREFCON2 = 0;
}
lcdcmd(0x01);
}
}
}
void main()
{
char _msg[32];
P1_5 = 0x00;
_setTime = 10;
_remainingTime = 20;
_timerStatus = 0;
lcdinit();
sprintf(_msg, "FAT TIMER Ver 2 ");
lcdshowstring(0, _msg);
sprintf(_msg, "Starting... ");
lcdshowstring(1, _msg);
DelayMs(2000);
_showNum(0);
_showNum(1);
while(1)
{
//Start / Stop
if(P1_2 == 0x00)
{
DelayMs(2);
if(P1_2 == 0x00){
_timerStatus = 1;
_remainingTime = _setTime;
showNum(1);
_timerFunc();
}
}
//+ / -
if(P1_0 == 0x00)
{
DelayMs(2);
if(P1_0 == 0x00)
{
if(_setTime > 1)
{
_setTime--;
showNum(0);
DelayMs(15);
continue;
}
}
}else
if(P1_1 == 0x00)
DelayMs(2);
if(P1_1 == 0x00)
{
if(_setTime < 999)
{
_setTime++;
showNum(0);
DelayMs(15);
continue;
}
}
}//while
}
static long lcdi2c_ioctl(struct file *file,
unsigned int ioctl_num,
unsigned long arg)
{
char *buffer = (char*)arg, ccb[10];
u8 memaddr, i, ch;
long status = SUCCESS;
CRIT_BEG(data, EAGAIN);
switch (ioctl_num)
{
case LCD_IOCTL_SETCHAR:
get_user(ch, buffer);
memaddr = (1 + data->column + (data->row * data->organization.columns)) % LCD_BUFFER_SIZE;
lcdwrite(data, ch);
data->column = (memaddr % data->organization.columns);
data->row = (memaddr / data->organization.columns);
lcdsetcursor(data, data->column, data->row);
break;
case LCD_IOCTL_GETCHAR:
memaddr = (data->column + (data->row * data->organization.columns)) % LCD_BUFFER_SIZE;
ch = data->buffer[memaddr];
put_user(ch, buffer);
break;
case LCD_IOCTL_GETPOSITION:
printk(KERN_INFO "GETPOSITION called\n");
put_user(data->column, buffer);
put_user(data->row, buffer+1);
break;
case LCD_IOCTL_SETPOSITION:
get_user(data->column, buffer);
get_user(data->row, buffer+1);
lcdsetcursor(data, data->column, data->row);
break;
case LCD_IOCTL_RESET:
get_user(ch, buffer);
if (ch == '1')
lcdinit(data, data->organization.topology);
break;
case LCD_IOCTL_HOME:
printk(KERN_INFO "HOME called\n");
get_user(ch, buffer);
if (ch == '1')
lcdhome(data);
break;
case LCD_IOCTL_GETCURSOR:
put_user(data->cursor ? '1' : '0', buffer);
break;
case LCD_IOCTL_SETCURSOR:
get_user(ch, buffer);
lcdcursor(data, (ch == '1'));
break;
case LCD_IOCTL_GETBLINK:
put_user(data->blink ? '1' : '0', buffer);
break;
case LCD_IOCTL_SETBLINK:
get_user(ch, buffer);
lcdblink(data, (ch == '1'));
break;
case LCD_IOCTL_GETBACKLIGHT:
put_user(data->backlight ? '1' : '0', buffer);
break;
case LCD_IOCTL_SETBACKLIGHT:
get_user(ch, buffer);
lcdsetbacklight(data, (ch == '1'));
break;
case LCD_IOCTL_SCROLLHZ:
get_user(ch, buffer);
lcdscrollhoriz(data, ch - '0');
break;
case LCD_IOCTL_GETCUSTOMCHAR:
get_user(ch, buffer);
for (i=0; i<8; i++)
put_user(data->customchars[ch][i], buffer + i + 1);
break;
case LCD_IOCTL_SETCUSTOMCHAR:
for (i = 0; i < 9; i++)
get_user(ccb[i], buffer + i);
lcdcustomchar(data, ccb[0], ccb+1);
break;
case LCD_IOCTL_CLEAR:
get_user(ch, buffer);
if (ch == '1')
lcdclear(data);
break;
default:
printk(KERN_INFO "Unknown IOCTL\n");
break;
}
CRIT_END(data);
return status;
}
