WebSVN - Projects - Blame - /Transportables_Koptertool/branch/GPL_PKT_V3_5_8a

Rev	Author	Line No.	Line
1471	-	1	/*****************************************************************************
		2	* Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net *
		3	* - original LCD control by Thomas "thkais" Kaiser *
		4	* - special number formating routines taken from C-OSD *
		5	* from Claas Anders "CaScAdE" Rathje *
		6	* - some extension, ellipse and circ_line by Peter "woggle" Mack *
		7	* *
		8	* This program is free software; you can redistribute it and/or modify *
		9	* it under the terms of the GNU General Public License as published by *
		10	* the Free Software Foundation; either version 2 of the License. *
		11	* *
		12	* This program is distributed in the hope that it will be useful, *
		13	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
		14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
		15	* GNU General Public License for more details. *
		16	* *
		17	* You should have received a copy of the GNU General Public License *
		18	* along with this program; if not, write to the *
		19	* Free Software Foundation, Inc., *
		20	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
		21	* *
		22	*****************************************************************************/
		23
		24	#include "cpu.h"
		25	#include <avr/io.h>
		26	#include <avr/pgmspace.h>
		27	#include <util/delay.h>
		28	#include <stdlib.h>
		29	#include <string.h>
		30	#include <math.h>
		31
		32	#include "font8x6.h"
		33	//#include "font8x8.h"
		34	#include "eeprom.h"
		35	#include "lcd.h"
		36	#include "HAL_HW3_9.h"
		37
		38
		39	#define DISP_W 128
		40	#define DISP_H 64
		41
		42	#define DISP_BUFFER ((DISP_H * DISP_W) / 8)
		43	#define LINE_BUFFER (((DISP_H/8) * DISP_W) / 8)
		44
		45	#define Jeti 0 // Jeti Routinen
		46
		47	volatile uint8_t display_buffer[DISP_BUFFER]; // Display-Puffer, weil nicht zurückgelesen werden kann
		48	volatile uint8_t line_buffer[LINE_BUFFER]; // Zeilen-Puffer, weil nicht zurückgelesen werden kann
		49
		50	volatile uint16_t display_buffer_pointer; // Pointer auf das aktuell übertragene Byte
		51	volatile uint8_t display_buffer_counter; // Hilfszähler zur Selektierung der Page
		52	volatile uint8_t display_page_counter; // aktuelle Page-Nummer
		53	volatile uint8_t display_mode; // Modus für State-Machine
		54	volatile uint8_t LCD_ORIENTATION;
		55
		56	// DOG: 128 x 64 with 6x8 Font => 21 x 8
		57	// MAX7456: 30 x 16
		58
		59	uint8_t lcd_xpos;
		60	uint8_t lcd_ypos;
		61
		62
		63	//-----------------------------------------------------------
		64	void send_byte (uint8_t data)
		65	{
		66	clr_cs ();
		67	SPDR = data;
		68	while (!(SPSR & (1<<SPIF)));
		69	//SPSR = SPSR;
		70	set_cs ();
		71	}
		72
		73
		74	//-----------------------------------------------------------
		75	// * Writes one command byte
		76	// * cmd - the command byte
		77	//
		78	void lcd_command(uint8_t cmd)
		79	{
		80	// LCD_SELECT();
		81	// LCD_CMD();
		82	// spi_write(cmd);
		83	// LCD_UNSELECT();
		84	clr_cs ();
		85	SPDR = cmd;
		86	while (!(SPSR & (1<<SPIF)));
		87	//SPSR = SPSR;
		88	set_cs ();
		89	}
		90
		91
		92	//-----------------------------------------------------------
		93	void lcd_cls (void)
		94	{
		95	uint16_t i, j;
		96
		97	// memset (display_buffer, 0, 1024);
		98	for (i = 0; i < DISP_BUFFER; i++)
		99	display_buffer[i] = 0x00;
		100	for (i = 0; i < 8; i++)
		101	{
		102	clr_A0 ();
		103	send_byte (0xB0 + i); //1011xxxx
		104	send_byte (0x10); //00010000
		105	// send_byte(0x04); //00000100 gedreht plus 4 Byte
		106	// send_byte(0x00); //00000000
		107	send_byte (LCD_ORIENTATION); //00000000
		108
		109	set_A0 ();
		110	for (j = 0; j < 128; j++)
		111	send_byte (0x00);
		112	}
		113
		114	lcd_xpos = 0;
		115	lcd_ypos = 0;
		116	}
		117
		118
		119	//-----------------------------------------------------------
		120	void lcd_cls_line (uint8_t x, uint8_t y, uint8_t w)
		121	{
		122	uint8_t lcd_width;
		123	uint8_t lcd_zpos;
		124	uint8_t i;
		125	uint8_t max = 21;
		126	lcd_width = w;
		127	lcd_xpos = x;
		128	lcd_ypos = y;
		129
		130	if ((lcd_xpos + lcd_width) > max)
		131	lcd_width = max - lcd_xpos;
		132
		133	lcd_zpos = lcd_xpos + lcd_width;
		134
		135	for (i = lcd_xpos; i < lcd_zpos; i++)
		136	lcd_putc (i, lcd_ypos, 0x20, 0);
		137	}
		138
		139
		140	//-----------------------------------------------------------
		141	void wait_1ms (void)
		142	{
		143	_delay_ms (1);
		144	}
		145
		146
		147	//-----------------------------------------------------------
		148	void wait_ms (uint16_t time)
		149	{
		150	uint16_t i;
		151
		152	for (i = 0; i < time; i++)
		153	wait_1ms ();
		154	}
		155
		156
		157	//-----------------------------------------------------------
		158	void LCD_Init (uint8_t LCD_Mode) // LCD_Mode 0= Default Mode 1= EEPROM-Parameter)
		159	{
		160	lcd_xpos = 0;
		161	lcd_ypos = 0;
		162
		163	// DDRB = 0xFF;
		164
		165	// SPI max. speed
		166	// the DOGM128 lcd controller can work at 20 MHz
		167	SPCR = (1 << SPE) \| (1 << MSTR) \| (1 << CPHA) \| (1 << CPOL);
		168	SPSR = (1 << SPI2X);
		169
		170	set_cs ();
		171	clr_reset ();
		172	wait_ms (10);
		173	set_reset ();
		174
		175	clr_cs ();
		176	clr_A0 ();
		177
		178	send_byte (0x40); //Display start line = 0
		179	if (LCD_Mode == 1)
		180	{
		181	if (LCD_ORIENTATION == 0)
		182	{
		183	send_byte (0xA1); // A1 normal A0 reverse(original)
		184	send_byte (0xC0); // C0 normal C8 reverse(original)
		185	}
		186	else
		187	{
		188	send_byte (0xA0); // A1 normal A0 reverse(original)
		189	send_byte (0xC8); // C0 normal C8 reverse(original)
		190	}
		191	}
		192	else
		193	{
		194	send_byte (0xA1); // A1 normal A0 reverse(original)
		195	send_byte (0xC0); // C0 normal C8 reverse(original)
		196	}
		197	if (LCD_Mode == 1)
		198	{
		199	if (LCD_DisplayMode == 0)
		200	send_byte (0xA6); //Display normal, not mirrored
		201	else
		202	send_byte (0xA7); //Display reverse, not mirrored
		203	}
		204	else
		205	send_byte (0xA6);
		206
		207
		208	send_byte (0xA2); //Set bias 1/9 (Duty 1/65)
		209	send_byte (0x2F); //Booster, regulator and follower on
		210	send_byte (0xF8); //Set internal booster to 4x
		211	send_byte (0x00); //Set internal booster to 4x
		212	send_byte (0x27); //resistor ratio set
		213
		214	if (LCD_Mode == 1)
		215	{
		216	send_byte (0x81); //Electronic volume register set
		217	send_byte (LCD_Kontrast); //Electronic volume register set
		218	}
		219	else
		220	{
		221	send_byte (0x81);
		222	send_byte (0x16);
		223	}
		224
		225	send_byte (0xAC); //Cursor
		226	send_byte (0x00); //No Cursor
		227	send_byte (0xAF); //No indicator
		228
		229	if (LCD_Mode == 1)
		230	{
		231	// Helligkeit setzen
		232	OCR2A = LCD_Helligkeit * 2.55;
		233	}
		234	else
		235	{
		236	OCR2A = 255;
		237	}
		238
		239	lcd_cls ();
		240	}
		241
		242
		243	//-----------------------------------------------------------
		244	void set_adress (uint16_t adress, uint8_t data)
		245	{
		246	uint8_t page;
		247	uint8_t column;
		248
		249	page = adress >> 7;
		250
		251	clr_A0 ();
		252	send_byte (0xB0 + page);
		253
		254	column = (adress & 0x7F) + LCD_ORIENTATION;
		255
		256	send_byte (0x10 + (column >> 4));
		257	send_byte (column & 0x0F);
		258
		259	set_A0 ();
		260	send_byte (data);
		261	}
		262
		263
		264	//-----------------------------------------------------------
		265	void scroll (void)
		266	{
		267	uint16_t adress;
		268
		269	for (adress = 0; adress < 896; adress++)
		270	{
		271	display_buffer[adress] = display_buffer[adress + 128];
		272	set_adress (adress, display_buffer[adress]);
		273	}
		274
		275	for (adress = 896; adress < 1024; adress++)
		276	{
		277	display_buffer[adress] = 0;
		278	set_adress (adress, 0);
		279	}
		280	}
		281
		282
		283	//-----------------------------------------------------------
		284	// sicher eine Zeile für die Statusanzeige
		285	void copy_line (uint8_t y)
		286	{
		287	uint8_t i;
		288	uint16_t adress;
		289
		290	adress = y * 128 + 0 * 6;
		291	adress &= 0x3FF;
		292
		293	for (i = 0; i < 6*21; i++)
		294	{
		295	line_buffer[i] = display_buffer[adress+i];
		296	set_adress (adress + i, display_buffer[adress + i]);
		297	}
		298	}
		299
		300
		301	//-----------------------------------------------------------
		302	// holt gesicherte Zeile wieder zurück
		303	void paste_line (uint8_t y)
		304	{
		305	uint8_t i;
		306	uint16_t adress;
		307
		308	adress = y * 128 + 0 * 6;
		309	adress &= 0x3FF;
		310
		311	for (i = 0; i < 6*21; i++)
		312	{
		313	display_buffer[adress+i] =line_buffer[i];
		314	set_adress (adress + i, display_buffer[adress + i]);
		315	}
		316	}
		317
		318
		319	//-----------------------------------------------------------
		320	void lcd_puts_at(uint8_t x, uint8_t y,const char *s, uint8_t mode )
		321	{
		322	while (*s)
		323	{
		324	lcd_putc(x, y, *s++, mode);
		325	x++;
		326	}
		327
		328	}/* lcd_puts */
		329
		330
		331	//-----------------------------------------------------------
		332	void lcd_putc (uint8_t x, uint8_t y, uint8_t c, uint8_t mode)
		333	{
		334	uint8_t ch;
		335	uint8_t i;
		336	uint16_t adress;
		337
		338	if (mode == 2)
		339	lcd_frect ((x6),(y8),5,7,1); // invertierte Darstellung
		340
		341	switch (c)
		342	{ // ISO 8859-1
		343
		344	case 0xc4: // Ä
		345	c = 0x01;
		346	break;
		347
		348	case 0xe4: // ä
		349	c = 0x02;
		350	break;
		351
		352	case 0xd6: // Ö
		353	c = 0x03;
		354	break;
		355
		356	case 0xf6: // ö
		357	c = 0x04;
		358	break;
		359
		360	case 0xdc: // Ü
		361	c = 0x05;
		362	break;
		363
		364	case 0xfc: // ü
		365	c = 0x06;
		366	break;
		367
		368	case 0xdf: // ß
		369	//c = 0x07;
		370	c = 0x1e; // ° (used by Jeti)
		371	break;
		372	}
		373
		374	c &= 0x7f;
		375
		376	adress = y * 128 + x * 6;
		377	adress &= 0x3FF;
		378
		379	for (i = 0; i < 6; i++)
		380	{
		381	ch = pgm_read_byte (&font8x6[0][0] + i + c * 6);
		382
		383	switch (mode)
		384	{
		385
		386	case 0:
		387	display_buffer[adress+i] = ch;
		388	break;
		389
		390	case 1:
		391	display_buffer[adress+i] \|= ch;
		392	break;
		393
		394	case 2:
		395	display_buffer[adress+i] ^= ch;
		396	break;
		397
		398	case 3:
		399	display_buffer[adress+i] &= ch;
		400	break;
		401
		402	case 4:
		403	display_buffer[adress+i] &= ~ch;
		404	break;
		405	}
		406
		407	set_adress (adress + i, display_buffer[adress + i]);
		408	}
		409	}
		410
		411
		412	#if Jeti
		413	//-----------------------------------------------------------
		414	void lcd_putc_jeti (uint8_t x, uint8_t y, uint8_t c, uint8_t mode)
		415	{
		416	uint8_t ch;
		417	uint8_t i;
		418	uint16_t adress;
		419
		420	switch (c)
		421	{
		422
		423	case 0x7e:
		424	c = 0x1a; // ->
		425	break;
		426
		427	case 0x7f:
		428	c = 0x1b; // <-
		429	break;
		430
		431	case 0xdf:
		432	c = 0xf8; // °
		433	break;
		434	}
		435
		436	adress = y * 128 + x * 8;
		437	adress &= 0x3FF;
		438
		439	for (i = 0; i < 8; i++)
		440	{
		441	ch = pgm_read_byte (&font8x8[0][0] + i + c * 8);
		442
		443	switch (mode)
		444	{
		445
		446	case 0:
		447	display_buffer[adress+i] = ch;
		448	break;
		449
		450	case 1:
		451	display_buffer[adress+i] \|= ch;
		452	break;
		453
		454	case 2:
		455	display_buffer[adress+i] ^= ch;
		456	break;
		457
		458	case 3:
		459	display_buffer[adress+i] &= ch;
		460	break;
		461
		462	case 4:
		463	display_buffer[adress+i] &= ~ch;
		464	break;
		465	}
		466
		467	set_adress (adress + i, display_buffer[adress + i]);
		468	}
		469	}
		470
		471
		472	//-----------------------------------------------------------
		473	void lcd_printpj (const char *text, uint8_t mode)
		474	{
		475	while (pgm_read_byte(text))
		476	{
		477	switch (pgm_read_byte(text))
		478	{
		479
		480	case 0x0D:
		481	lcd_xpos = 0;
		482	break;
		483
		484	case 0x0A:
		485	new_line();
		486	break;
		487
		488	default:
		489	lcd_putc_jeti (lcd_xpos, lcd_ypos, pgm_read_byte(text), mode);
		490	lcd_xpos++;
		491	if (lcd_xpos > 20)
		492	{
		493	lcd_xpos = 0;
		494	new_line ();
		495	}
		496	break;
		497	}
		498	text++;
		499	}
		500	}
		501
		502
		503	//-----------------------------------------------------------
		504	void lcd_printpj_at (uint8_t x, uint8_t y, const char *text, uint8_t mode)
		505	{
		506	lcd_xpos = x;
		507	lcd_ypos = y;
		508	lcd_printpj (text, mode);
		509	}
		510	#endif
		511
		512
		513	//-----------------------------------------------------------
		514	void new_line (void)
		515	{
		516	lcd_ypos++;
		517
		518	if (lcd_ypos > 7)
		519	{
		520	scroll ();
		521	lcd_ypos = 7;
		522	}
		523	}
		524
		525
		526	//-----------------------------------------------------------
		527	void lcd_printpns (const char *text, uint8_t mode)
		528	{
		529	while (pgm_read_byte(text))
		530	{
		531	switch (pgm_read_byte(text))
		532	{
		533
		534	case 0x0D:
		535	lcd_xpos = 0;
		536	break;
		537
		538	case 0x0A:
		539	new_line();
		540	break;
		541
		542	default:
		543	lcd_putc (lcd_xpos, lcd_ypos, pgm_read_byte(text), mode);
		544	lcd_xpos++;
		545	if (lcd_xpos > 21)
		546	{
		547	lcd_xpos = 0;
		548	// new_line ();
		549	}
		550	break;
		551	}
		552	text++;
		553	}
		554	}
		555
		556
		557	//-----------------------------------------------------------
		558	void lcd_printpns_at (uint8_t x, uint8_t y, const char *text, uint8_t mode)
		559	{
		560	lcd_xpos = x;
		561	lcd_ypos = y;
		562	lcd_printpns (text, mode);
		563	}
		564
		565
		566	//-----------------------------------------------------------
		567	void lcd_printp (const char *text, uint8_t mode)
		568	{
		569	while (pgm_read_byte(text))
		570	{
		571	switch (pgm_read_byte(text))
		572	{
		573
		574	case 0x0D:
		575	lcd_xpos = 0;
		576	break;
		577
		578	case 0x0A:
		579	new_line();
		580	break;
		581
		582	default:
		583	lcd_putc (lcd_xpos, lcd_ypos, pgm_read_byte(text), mode);
		584	lcd_xpos++;
		585	if (lcd_xpos > 21)
		586	{
		587	lcd_xpos = 0;
		588	new_line ();
		589	}
		590	break;
		591	}
		592	text++;
		593	}
		594	}
		595
		596
		597	//-----------------------------------------------------------
		598	void lcd_printp_at (uint8_t x, uint8_t y, const char *text, uint8_t mode)
		599	{
		600	lcd_xpos = x;
		601	lcd_ypos = y;
		602	lcd_printp (text, mode);
		603	}
		604
		605
		606	//-----------------------------------------------------------
		607	void lcd_print (uint8_t *text, uint8_t mode)
		608	{
		609	while (*text)
		610	{
		611	switch (*text)
		612	{
		613
		614	case 0x0D:
		615	lcd_xpos = 0;
		616	break;
		617
		618	case 0x0A:
		619	new_line();
		620	break;
		621
		622	default:
		623	lcd_putc (lcd_xpos, lcd_ypos, *text, mode);
		624	lcd_xpos++;
		625	if (lcd_xpos > 21)
		626	{
		627	lcd_xpos = 0;
		628	new_line ();
		629	}
		630	break;
		631	}
		632	text++;
		633	}
		634	}
		635
		636
		637	//-----------------------------------------------------------
		638	void lcd_print_at (uint8_t x, uint8_t y, uint8_t *text, uint8_t mode)
		639	{
		640	lcd_xpos = x;
		641	lcd_ypos = y;
		642	lcd_print (text, mode);
		643	}
		644
		645
		646	//-----------------------------------------------------------
		647	void print_display (uint8_t *text)
		648	{
		649	while (*text)
		650	{
		651	lcd_putc (lcd_xpos, lcd_ypos, *text, 0);
		652	lcd_xpos++;
		653	if (lcd_xpos >= 20)
		654	{
		655	lcd_xpos = 0;
		656	new_line ();
		657	}
		658	text++;
		659	}
		660	}
		661
		662
		663	//-----------------------------------------------------------
		664	void print_display_at (uint8_t x, uint8_t y, uint8_t *text)
		665	{
		666	lcd_xpos = x;
		667	lcd_ypos = y;
		668	print_display (text);
		669	}
		670
		671
		672	//-----------------------------------------------------------
		673	// + Plot (set one Pixel)
		674	//-----------------------------------------------------------
		675	// mode:
		676	// 0=Clear, 1=Set, 2=XOR
		677	void lcd_plot (uint8_t xpos, uint8_t ypos, uint8_t mode)
		678	{
		679	uint16_t adress;
		680	uint8_t mask;
		681
		682	if ((xpos < DISP_W) && (ypos < DISP_H))
		683	{
		684	adress = (ypos / 8) * DISP_W + xpos; // adress = 0/8 * 128 + 0 = 0
		685	mask = 1 << (ypos & 0x07); // mask = 1<<0 = 1
		686	adress &= DISP_BUFFER - 1;
		687	switch (mode)
		688	{
		689
		690	case 0:
		691	display_buffer[adress] &= ~mask;
		692	break;
		693
		694	case 1:
		695	display_buffer[adress] \|= mask;
		696	break;
		697
		698	case 2:
		699	display_buffer[adress] ^= mask;
		700	break;
		701	}
		702	set_adress (adress, display_buffer[adress]);
		703	}
		704	}
		705
		706
		707	//-----------------------------------------------------------
		708	// + Line (draws a line from x1,y1 to x2,y2
		709	// + Based on Bresenham line-Algorithm
		710	// + found in the internet, modified by thkais 2007
		711	//-----------------------------------------------------------
		712
		713	void lcd_line (unsigned char x1, unsigned char y1, unsigned char x2, unsigned char y2, uint8_t mode)
		714	{
		715	int x, y, count, xs, ys, xm, ym;
		716
		717	x = (int) x1;
		718	y = (int) y1;
		719	xs = (int) x2 - (int) x1;
		720	ys = (int) y2 - (int) y1;
		721	if (xs < 0)
		722	xm = -1;
		723	else
		724	if (xs > 0)
		725	xm = 1;
		726	else
		727	xm = 0;
		728	if (ys < 0)
		729	ym = -1;
		730	else
		731	if (ys > 0)
		732	ym = 1;
		733	else
		734	ym = 0;
		735	if (xs < 0)
		736	xs = -xs;
		737
		738	if (ys < 0)
		739	ys = -ys;
		740
		741	lcd_plot ((unsigned char) x, (unsigned char) y, mode);
		742
		743	if (xs > ys) // Flat Line <45 degrees
		744	{
		745	count = -(xs / 2);
		746	while (x != x2)
		747	{
		748	count = count + ys;
		749	x = x + xm;
		750	if (count > 0)
		751	{
		752	y = y + ym;
		753	count = count - xs;
		754	}
		755	lcd_plot ((unsigned char) x, (unsigned char) y, mode);
		756	}
		757	}
		758	else // Line >=45 degrees
		759	{
		760	count =- (ys / 2);
		761	while (y != y2)
		762	{
		763	count = count + xs;
		764	y = y + ym;
		765	if (count > 0)
		766	{
		767	x = x + xm;
		768	count = count - ys;
		769	}
		770	lcd_plot ((unsigned char) x, (unsigned char) y, mode);
		771	}
		772	}
		773	}
		774
		775
		776	//-----------------------------------------------------------
		777	// + Filled rectangle
		778	// + x1, y1 = upper left corner
		779	//-----------------------------------------------------------
		780
		781	void lcd_frect (uint8_t x1, uint8_t y1, uint8_t widthx, uint8_t widthy, uint8_t mode)
		782	{
		783	uint16_t x2, y2;
		784	uint16_t i;
		785
		786	if (x1 >= DISP_W)
		787	x1 = DISP_W - 1;
		788
		789	if (y1 >= DISP_H)
		790	y1 = DISP_H - 1;
		791
		792	x2 = x1 + widthx;
		793	y2 = y1 + widthy;
		794
		795	if (x2 > DISP_W)
		796	x2 = DISP_W;
		797
		798	if (y2 > DISP_H)
		799	y2 = DISP_H;
		800
		801	for (i = y1; i <= y2; i++)
		802	{
		803	lcd_line (x1, i, x2, i, mode);
		804	}
		805	}
		806
		807
		808	//-----------------------------------------------------------
		809	// + outline of rectangle
		810	// + x1, y1 = upper left corner
		811	//-----------------------------------------------------------
		812
		813	void lcd_rect (uint8_t x1, uint8_t y1, uint8_t widthx, uint8_t widthy, uint8_t mode)
		814	{
		815	uint16_t x2, y2;
		816
		817	if (x1 >= DISP_W)
		818	x1 = DISP_W - 1;
		819	if (y1 >= DISP_H)
		820	y1 = DISP_H - 1;
		821	x2 = x1 + widthx;
		822	y2 = y1 + widthy;
		823
		824	if (x2 > DISP_W)
		825	x2 = DISP_W;
		826
		827	if (y2 > DISP_H)
		828	y2 = DISP_H;
		829
		830	lcd_line (x1, y1, x2, y1, mode);
		831	lcd_line (x2, y1, x2, y2, mode);
		832	lcd_line (x2, y2, x1, y2, mode);
		833	lcd_line (x1, y2, x1, y1, mode);
		834	}
		835
		836
		837	//-----------------------------------------------------------
		838	// + outline of a circle
		839	// + Based on Bresenham-algorithm found in wikipedia
		840	// + modified by thkais (2007)
		841	//-----------------------------------------------------------
		842
		843	void lcd_circle (int16_t x0, int16_t y0, int16_t radius, uint8_t mode)
		844	{
		845	int16_t f = 1 - radius;
		846	int16_t ddF_x = 0;
		847	int16_t ddF_y = -2 * radius;
		848	int16_t x = 0;
		849	int16_t y = radius;
		850
		851	lcd_plot (x0, y0 + radius, mode);
		852	lcd_plot (x0, y0 - radius, mode);
		853	lcd_plot (x0 + radius, y0, mode);
		854	lcd_plot (x0 - radius, y0, mode);
		855
		856	while (x < y)
		857	{
		858	if (f >= 0)
		859	{
		860	y --;
		861	ddF_y += 2;
		862	f += ddF_y;
		863	}
		864	x ++;
		865	ddF_x += 2;
		866	f += ddF_x + 1;
		867
		868	lcd_plot (x0 + x, y0 + y, mode);
		869	lcd_plot (x0 - x, y0 + y, mode);
		870
		871	lcd_plot (x0 + x, y0 - y, mode);
		872	lcd_plot (x0 - x, y0 - y, mode);
		873
		874	lcd_plot (x0 + y, y0 + x, mode);
		875	lcd_plot (x0 - y, y0 + x, mode);
		876
		877	lcd_plot (x0 + y, y0 - x, mode);
		878	lcd_plot (x0 - y, y0 - x, mode);
		879	}
		880	}
		881
		882
		883	//-----------------------------------------------------------
		884	// + filled Circle
		885	// + modified circle-algorithm thkais (2007)
		886	//-----------------------------------------------------------
		887
		888	void lcd_fcircle (int16_t x0, int16_t y0, int16_t radius)
		889	{
		890	int16_t f = 1 - radius;
		891	int16_t ddF_x = 0;
		892	int16_t ddF_y = -2 * radius;
		893	int16_t x = 0;
		894	int16_t y = radius;
		895
		896	lcd_line (x0, y0 + radius, x0, y0 - radius, 1);
		897
		898	lcd_line (x0 + radius, y0, x0 - radius, y0, 1);
		899
		900	while (x < y)
		901	{
		902	if (f >= 0)
		903	{
		904	y--;
		905	ddF_y += 2;
		906	f += ddF_y;
		907	}
		908	x++;
		909	ddF_x += 2;
		910	f += ddF_x + 1;
		911
		912	lcd_line (x0 + x, y0 + y, x0 - x, y0 + y, 1);
		913	lcd_line (x0 + x, y0 - y, x0 - x, y0 - y, 1);
		914	lcd_line (x0 + y, y0 + x, x0 - y, y0 + x, 1);
		915	lcd_line (x0 + y, y0 - x, x0 - y, y0 - x, 1);
		916	}
		917	}
		918
		919
		920	//-----------------------------------------------------------
		921	//
		922	void lcd_circ_line (uint8_t x, uint8_t y, uint8_t r, uint16_t deg, uint8_t mode)
		923	{
		924	uint8_t xc, yc;
		925	double deg_rad;
		926
		927	deg_rad = (deg * M_PI) / 180.0;
		928
		929	yc = y - (uint8_t) round (cos (deg_rad) * (double) r);
		930	xc = x + (uint8_t) round (sin (deg_rad) * (double) r);
		931	lcd_line (x, y, xc, yc, mode);
		932	}
		933
		934
		935	//-----------------------------------------------------------
		936	//
		937	void lcd_ellipse_line (uint8_t x, uint8_t y, uint8_t rx, uint8_t ry, uint16_t deg, uint8_t mode)
		938	{
		939	uint8_t xc, yc;
		940	double deg_rad;
		941
		942	deg_rad = (deg * M_PI) / 180.0;
		943
		944	yc = y - (uint8_t) round (cos (deg_rad) * (double) ry);
		945	xc = x + (uint8_t) round (sin (deg_rad) * (double) rx);
		946	lcd_line (x, y, xc, yc, mode);
		947	}
		948
		949
		950	//-----------------------------------------------------------
		951	//
		952	void lcd_ellipse (int16_t x0, int16_t y0, int16_t rx, int16_t ry, uint8_t mode)
		953	{
		954	const int16_t rx2 = rx * rx;
		955	const int16_t ry2 = ry * ry;
		956	int16_t F = round (ry2 - rx2 * ry + 0.25 * rx2);
		957	int16_t ddF_x = 0;
		958	int16_t ddF_y = 2 * rx2 * ry;
		959	int16_t x = 0;
		960	int16_t y = ry;
		961
		962	lcd_plot (x0, y0 + ry, mode);
		963	lcd_plot (x0, y0 - ry, mode);
		964	lcd_plot (x0 + rx, y0, mode);
		965	lcd_plot (x0 - rx, y0, mode);
		966	// while ( 2ry2x < 2rx2y ) { we can use ddF_x and ddF_y
		967	while (ddF_x < ddF_y)
		968	{
		969	if(F >= 0)
		970	{
		971	y -= 1; // south
		972	ddF_y -= 2 * rx2;
		973	F -= ddF_y;
		974	}
		975	x += 1; // east
		976	ddF_x += 2 * ry2;
		977	F += ddF_x + ry2;
		978	lcd_plot (x0 + x, y0 + y, mode);
		979	lcd_plot (x0 + x, y0 - y, mode);
		980	lcd_plot (x0 - x, y0 + y, mode);
		981	lcd_plot (x0 - x, y0 - y, mode);
		982	}
		983	F = round (ry2 * (x + 0.5) * (x + 0.5) + rx2 * (y - 1) * (y - 1) - rx2 * ry2);
		984	while(y > 0)
		985	{
		986	if(F <= 0)
		987	{
		988	x += 1; // east
		989	ddF_x += 2 * ry2;
		990	F += ddF_x;
		991	}
		992	y -= 1; // south
		993	ddF_y -= 2 * rx2;
		994	F += rx2 - ddF_y;
		995	lcd_plot (x0 + x, y0 + y, mode);
		996	lcd_plot (x0 + x, y0 - y, mode);
		997	lcd_plot (x0 - x, y0 + y, mode);
		998	lcd_plot (x0 - x, y0 - y, mode);
		999	}
		1000	}
		1001
		1002
		1003	//-----------------------------------------------------------
		1004	//
		1005	void lcd_ecircle (int16_t x0, int16_t y0, int16_t radius, uint8_t mode)
		1006	{
		1007	lcd_ellipse (x0, y0, radius + 3, radius, mode);
		1008	}
		1009
		1010
		1011	//-----------------------------------------------------------
		1012	//
		1013	void lcd_ecirc_line (uint8_t x, uint8_t y, uint8_t r, uint16_t deg, uint8_t mode)
		1014	{
		1015	lcd_ellipse_line(x, y, r + 3, r, deg, mode);
		1016	}
		1017
		1018
		1019	//-----------------------------------------------------------
		1020	//
		1021	void lcd_view_font (uint8_t page)
		1022	{
		1023	int x;
		1024	int y;
		1025
		1026	lcd_cls ();
		1027	lcd_printp (PSTR(" 0123456789ABCDEF\r\n"), 0);
		1028	lcd_printpns_at (0, 7, PSTR(" \x1a \x1b Exit"), 0);
		1029
		1030	lcd_ypos = 2;
		1031	for (y = page * 4 ; y < (page * 4 + 4); y++)
		1032	{
		1033	if (y < 10)
		1034	{
		1035	lcd_putc (0, lcd_ypos, '0' + y, 0);
		1036	}
		1037	else
		1038	{
		1039	lcd_putc (0, lcd_ypos, 'A' + y - 10, 0);
		1040	}
		1041	lcd_xpos = 2;
		1042	for (x = 0; x < 16; x++)
		1043	{
		1044	lcd_putc (lcd_xpos, lcd_ypos, y * 16 + x, 0);
		1045	lcd_xpos++;
		1046	}
		1047	lcd_ypos++;
		1048	}
		1049	}
		1050
		1051
		1052	//-----------------------------------------------------------
		1053	uint8_t hdigit (uint8_t d)
		1054	{
		1055	if (d < 10)
		1056	{
		1057	return '0' + d;
		1058	}
		1059	else
		1060	{
		1061	return 'A' + d - 10;
		1062	}
		1063	}
		1064
		1065
		1066	//-----------------------------------------------------------
		1067	void lcd_print_hex_at (uint8_t x, uint8_t y, uint8_t h, uint8_t mode)
		1068	{
		1069	lcd_xpos = x;
		1070	lcd_ypos = y;
		1071
		1072	lcd_putc (lcd_xpos++, lcd_ypos, hdigit (h >> 4), mode);
		1073	lcd_putc (lcd_xpos, lcd_ypos, hdigit (h & 0x0f), mode);
		1074	}
		1075
		1076
		1077	//-----------------------------------------------------------
		1078	void lcd_print_hex (uint8_t h, uint8_t mode)
		1079	{
		1080	// lcd_xpos = x;
		1081	// lcd_ypos = y;
		1082
		1083	lcd_putc (lcd_xpos++, lcd_ypos, hdigit (h >> 4), mode);
		1084	lcd_putc (lcd_xpos++, lcd_ypos, hdigit (h & 0x0f), mode);
		1085	lcd_putc (lcd_xpos++, lcd_ypos, ' ', mode);
		1086	}
		1087
		1088
		1089	//-----------------------------------------------------------
		1090	void lcd_write_number_u (uint8_t number)
		1091	{
		1092	uint8_t num = 100;
		1093	uint8_t started = 0;
		1094
		1095	while (num > 0)
		1096	{
		1097	uint8_t b = number / num;
		1098	if (b > 0 \|\| started \|\| num == 1)
		1099	{
		1100	lcd_putc (lcd_xpos++, lcd_ypos, '0' + b, 0);
		1101	started = 1;
		1102	}
		1103	number -= b * num;
		1104
		1105	num /= 10;
		1106	}
		1107	}
		1108
		1109
		1110	//-----------------------------------------------------------
		1111	void lcd_write_number_u_at (uint8_t x, uint8_t y, uint8_t number)
		1112	{
		1113	lcd_xpos = x;
		1114	lcd_ypos = y;
		1115	lcd_write_number_u (number);
		1116	}
		1117
		1118
		1119	//-----------------------------------------------------------
		1120	// Write only some digits of a unsigned <number> at <x>/<y> to MAX7456 display memory
		1121	// <num> represents the largest multiple of 10 that will still be displayable as
		1122	// the first digit, so num = 10 will be 0-99 and so on
		1123	// <pad> = 1 will cause blank spaced to be filled up with zeros e.g. 007 instead of 7
		1124	//
		1125	void write_ndigit_number_u (uint8_t x, uint8_t y, uint16_t number, int16_t length, uint8_t pad)
		1126	{
		1127	char s[7];
		1128
		1129	utoa(number, s, 10 );
		1130
		1131	uint8_t len = strlen(s);
		1132
		1133	if (length < len)
		1134	{
		1135	for (uint8_t i = 0; i < length; i++)
		1136	{
		1137	lcd_putc (x++, y, '*', 0);
		1138	}
		1139	return;
		1140	}
		1141
		1142	for (uint8_t i = 0; i < length - len; i++)
		1143	{
		1144	if (pad)
		1145	{
		1146	lcd_putc (x++, y, '0', 0);
		1147	}
		1148	else
		1149	{
		1150	lcd_putc (x++, y, ' ', 0);
		1151	}
		1152	}
		1153	lcd_print_at(x, y, (uint8_t*)s, 0);
		1154	}
		1155
		1156	//-----------------------------------------------------------
		1157	// Write only some digits of a signed <number> at <x>/<y> to MAX7456 display memory
		1158	// <num> represents the largest multiple of 10 that will still be displayable as
		1159	// the first digit, so num = 10 will be 0-99 and so on
		1160	// <pad> = 1 will cause blank spaced to be filled up with zeros e.g. 007 instead of 7
		1161	//
		1162	void write_ndigit_number_s (uint8_t x, uint8_t y, int16_t number, int16_t length, uint8_t pad)
		1163	{
		1164	char s[7];
		1165
		1166	itoa(number, s, 10 );
		1167
		1168	uint8_t len = strlen(s);
		1169
		1170	if (length < len)
		1171	{
		1172	for (uint8_t i = 0; i < length; i++)
		1173	{
		1174	lcd_putc (x++, y, '*', 0);
		1175	}
		1176	return;
		1177	}
		1178
		1179	for (uint8_t i = 0; i < length - len; i++)
		1180	{
		1181	if (pad)
		1182	{
		1183	lcd_putc (x++, y, '0', 0);
		1184	}
		1185	else
		1186	{
		1187	lcd_putc (x++, y, ' ', 0);
		1188	}
		1189	}
		1190	lcd_print_at(x, y, (uint8_t*)s, 0);
		1191	}
		1192
		1193
		1194	//-----------------------------------------------------------
		1195	// Write only some digits of a unsigned <number> at <x>/<y> to MAX7456 display memory
		1196	// as /10th of the value
		1197	// <num> represents the largest multiple of 10 that will still be displayable as
		1198	// the first digit, so num = 10 will be 0-99 and so on
		1199	// <pad> = 1 will cause blank spaced to be filled up with zeros e.g. 007 instead of 7
		1200	//
		1201	void write_ndigit_number_u_10th (uint8_t x, uint8_t y, uint16_t number, int16_t length, uint8_t pad)
		1202	{
		1203	char s[7];
		1204
		1205	itoa(number, s, 10 );
		1206
		1207	uint8_t len = strlen(s);
		1208
		1209	if (length < len)
		1210	{
		1211	for (uint8_t i = 0; i < length; i++)
		1212	{
		1213	lcd_putc (x++, y, '*', 0);
		1214	}
		1215	return;
		1216	}
		1217
		1218	for (uint8_t i = 0; i < length - len; i++)
		1219	{
		1220	if (pad)
		1221	{
		1222	lcd_putc (x++, y, '0', 0);
		1223	}
		1224	else
		1225	{
		1226	lcd_putc (x++, y, ' ', 0);
		1227	}
		1228	}
		1229
		1230	char rest = s[len - 1];
		1231
		1232	s[len - 1] = 0;
		1233
		1234	if (len == 1)
		1235	{
		1236	lcd_putc (x-1, y, '0', 0);
		1237	}
		1238	else if (len == 2 && s[0] == '-')
		1239	{
		1240	lcd_putc (x-1, y, '-', 0);
		1241	lcd_putc (x, y, '0', 0);
		1242	}
		1243	else
		1244	{
		1245	lcd_print_at(x, y, (uint8_t*)s, 0);
		1246	}
		1247	x += len - 1;
		1248	lcd_putc (x++, y, '.', 0);
		1249	lcd_putc (x++, y, rest, 0);
		1250	}
		1251
		1252
		1253	//-----------------------------------------------------------
		1254	void write_ndigit_number_u_100th (uint8_t x, uint8_t y, uint16_t number, int16_t length, uint8_t pad)
		1255	{
		1256	uint8_t num = 100;
		1257
		1258	while (num > 0)
		1259	{
		1260	uint8_t b = number / num;
		1261
		1262	if ((num / 10) == 1)
		1263	{
		1264	lcd_putc (x++, y, '.', 0);
		1265	}
		1266	lcd_putc (x++, y, '0' + b, 0);
		1267	number -= b * num;
		1268
		1269	num /= 10;
		1270	}
		1271	}
		1272
		1273
		1274	//-----------------------------------------------------------
		1275	// Write only some digits of a signed <number> at <x>/<y> to MAX7456 display memory
		1276	// as /10th of the value
		1277	// <num> represents the largest multiple of 10 that will still be displayable as
		1278	// the first digit, so num = 10 will be 0-99 and so on
		1279	// <pad> = 1 will cause blank spaced to be filled up with zeros e.g. 007 instead of 7
		1280	//
		1281	void write_ndigit_number_s_10th (uint8_t x, uint8_t y, int16_t number, int16_t length, uint8_t pad)
		1282	{
		1283	char s[7];
		1284
		1285	itoa (number, s, 10 );
		1286
		1287	uint8_t len = strlen(s);
		1288
		1289	if (length < len)
		1290	{
		1291	for (uint8_t i = 0; i < length; i++)
		1292	{
		1293	lcd_putc (x++, y, '*', 0);
		1294	}
		1295	return;
		1296	}
		1297
		1298	for (uint8_t i = 0; i < length - len; i++)
		1299	{
		1300	if (pad)
		1301	{
		1302	lcd_putc (x++, y, '0', 0);
		1303	}
		1304	else
		1305	{
		1306	lcd_putc (x++, y, ' ', 0);
		1307	}
		1308	}
		1309
		1310	char rest = s[len - 1];
		1311
		1312	s[len - 1] = 0;
		1313
		1314	if (len == 1)
		1315	{
		1316	lcd_putc (x-1, y, '0', 0);
		1317	}
		1318	else if (len == 2 && s[0] == '-')
		1319	{
		1320	lcd_putc (x-1, y, '-', 0);
		1321	lcd_putc (x, y, '0', 0);
		1322	}
		1323	else
		1324	{
		1325	lcd_print_at(x, y, (uint8_t*)s, 0);
		1326	}
		1327	x += len - 1;
		1328	lcd_putc (x++, y, '.', 0);
		1329	lcd_putc (x++, y, rest, 0);
		1330	}
		1331
		1332
		1333	//-----------------------------------------------------------
		1334	// write <seconds> as human readable time at <x>/<y> to MAX7456 display mem
		1335	//
		1336	void write_time (uint8_t x, uint8_t y, uint16_t seconds)
		1337	{
		1338	uint16_t min = seconds / 60;
		1339	seconds -= min * 60;
		1340	write_ndigit_number_u (x, y, min, 2, 0);
		1341	lcd_putc (x + 2, y, ':', 0);
		1342	write_ndigit_number_u (x + 3, y, seconds, 2, 1);
		1343	}
		1344
		1345
		1346	//-----------------------------------------------------------
		1347	// wirte a <position> at <x>/<y> assuming it is a gps position for long-/latitude
		1348	//
		1349	void write_gps_pos (uint8_t x, uint8_t y, int32_t position)
		1350	{
		1351	if (position < 0)
		1352	{
		1353	position ^= ~0;
		1354	position++;
		1355	lcd_putc (x++, y, '-', 0);
		1356	}
		1357	else
		1358	{
		1359	lcd_putc (x++, y, ' ', 0);
		1360	}
		1361	write_ndigit_number_u (x, y, (uint16_t) (position / (int32_t) 10000000), 3, 1);
		1362	lcd_putc (x + 3, y, '.', 0);
		1363	position = position - ((position / (int32_t) 10000000) * (int32_t) 10000000);
		1364	write_ndigit_number_u (x + 4, y, (uint16_t) (position / (int32_t) 1000), 4, 1);
		1365	position = position - ((uint16_t) (position / (int32_t) 1000) * (int32_t) 1000);
		1366	write_ndigit_number_u (x + 8, y, (uint16_t) position, 3, 1);
		1367	lcd_putc (x + 11, y, 0x1e, 0); // degree symbol
		1368	}
		1369
		1370

Subversion Repositories Projects

(root)/Transportables_Koptertool/branch/GPL_PKT_V3_5_8a_FC086/lcd.c @ 2183 - Rev