Dom > Novice > Vsebine

Vir FTDI FT_App_Clocks.c

May 08, 2019

#include "FT_Platform.h"

#ifdef MSVC_PLATFORM

#include

#include

#include

#include

#include

#endif


#define SAMAPP_DELAY_BTW_APIS (1000)

#define SAMAPP_ENABLE_DELAY () Ft_Gpu_Hal_Sleep (SAMAPP_DELAY_BTW_APIS)

#define SAMAPP_ENABLE_DELAY_VALUE (x) Ft_Gpu_Hal_Sleep (x)

#define F16 (s) ((ft_int32_t) (s) * 65536))

#define WRITE2CMD (a) Ft_Gpu_Hal_WrCmdBuf (phost, a, sizeof (a))


/ * Globalne spremenljivke za ločljivost zaslona za podporo različnih prikaznih plošč * /

/ * Privzeto je WQVGA - 480x272 * /

ft_int16_t FT_DispWidth = 480;

ft_int16_t FT_DispHeight = 272;

ft_int16_t FT_DispHCycle = 548;

ft_int16_t FT_DispHOffset = 43;

ft_int16_t FT_DispHSync0 = 0;

ft_int16_t FT_DispHSync1 = 41;

ft_int16_t FT_DispVCycle = 292;

ft_int16_t FT_DispVOffset = 12;

ft_int16_t FT_DispVSync0 = 0;

ft_int16_t FT_DispVSync1 = 10;

ft_uint8_t FT_DispPCLK = 5;

ft_char8_t FT_DispSwizzle = 0;

ft_char8_t FT_DispPCLKPol = 1;


/ * Globalno uporabljeno za optimizacijo medpomnilnika

Ft_Gpu_Hal_Context_t gostitelj, * phost;


ft_uint32_t Ft_CmdBuffer_Index;

ft_uint32_t Ft_DlBuffer_Index;


#ifdef BUFFER_OPTIMIZATION

ft_uint8_t Ft_DlBuffer [FT_DL_SIZE];

ft_uint8_t Ft_CmdBuffer [FT_CMD_FIFO_SIZE];

#endif


ft_void_t Ft_App_WrCoCmd_Buffer (Ft_Gpu_Hal_Context_t * phost, ft_uint32_t cmd)

{

#ifdef BUFFER_OPTIMIZATION

/ * Kopiraj ukazno navodilo v medpomnilnik * /

ft_uint32_t * pBuffcmd;

pBuffcmd = (ft_uint32_t *) & Ft_CmdBuffer [Ft_CmdBuffer_Index];

* pBuffcmd = cmd;

#endif

#ifdef ARDUINO_PLATFORM

Ft_Gpu_Hal_WrCmd32 (fost, cmd);

#endif


/ * Povečajte indeks ukaza * /

Ft_CmdBuffer_Index + = FT_CMD_SIZE;

}


ft_void_t Ft_App_WrDlCmd_Buffer (Ft_Gpu_Hal_Context_t * phost, ft_uint32_t cmd)

{

#ifdef BUFFER_OPTIMIZATION

/ * Kopiraj ukazno navodilo v medpomnilnik * /

ft_uint32_t * pBuffcmd;

pBuffcmd = (ft_uint32_t *) & Ft_DlBuffer [Ft_DlBuffer_Index];

* pBuffcmd = cmd;

#endif


#ifdef ARDUINO_PLATFORM

Ft_Gpu_Hal_Wr32 (fost, (RAM_DL + Ft_DlBuffer_Index), cmd);

#endif

/ * Povečajte indeks ukaza * /

Ft_DlBuffer_Index + = FT_CMD_SIZE;

}


ft_void_t Ft_App_WrCoStr_Buffer (Ft_Gpu_Hal_Context_t * phost, const ft_char8_t * s)

{

#ifdef BUFFER_OPTIMIZATION

ft_uint16_t dolžina = 0;

dolžina = strlen (s) + 1; // zadnji za null zaključek

strcpy (& Ft_CmdBuffer [Ft_CmdBuffer_Index], s);


/ * poveča dolžino in jo poravnaj za 4 bajte * /

Ft_CmdBuffer_Index + = ((dolžina + 3) & ~ 3);

#endif

}


ft_void_t Ft_App_Flush_DL_Buffer (Ft_Gpu_Hal_Context_t * phost)

{

#ifdef BUFFER_OPTIMIZATION

če (Ft_DlBuffer_Index> 0)

Ft_Gpu_Hal_WrMem (fost, RAM_DL, Ft_DlBuffer, Ft_DlBuffer_Index);

#endif

Ft_DlBuffer_Index = 0;

}


ft_void_t Ft_App_Flush_Co_Buffer (Ft_Gpu_Hal_Context_t * phost)

{

#ifdef BUFFER_OPTIMIZATION

če (Ft_CmdBuffer_Index> 0)

Ft_Gpu_Hal_WrCmdBuf (fost, Ft_CmdBuffer, Ft_CmdBuffer_Index);

#endif

Ft_CmdBuffer_Index = 0;

}


/ * API za podajanje efekta fadeout s spremembo PWM zaslona od 100 do 0 * /

ft_void_t SAMAPP_fadeout ()

{

ft_int32_t i;

za (i = 100; i> = 0; i - = 3)

{

Ft_Gpu_Hal_Wr8 (fost, REG_PWM_DUTY, i);


Ft_Gpu_Hal_Sleep (2);

}

}


/ * API za izvedbo prikaza fadein učinka s spremembo PWM zaslona od 0 do 100 in končno 128 * /

ft_void_t SAMAPP_fadein ()

{

ft_int32_t i;

za (i = 0; i <= 100;="" i="" +="">

{

Ft_Gpu_Hal_Wr8 (fost, REG_PWM_DUTY, i);

Ft_Gpu_Hal_Sleep (2);

}

/ * Končno naredite PWM 100% * /

i = 128;

Ft_Gpu_Hal_Wr8 (fost, REG_PWM_DUTY, i);

}


/ * API za preverjanje stanja prejšnjega DLSWAP in izvajanje DLSWAP novega DL * /

/ * Preverite stanje prejšnje DLSWAP in če še vedno niste končali, počakajte nekaj ms in ponovno preverite * /

ft_void_t SAMAPP_GPU_DLswap (ft_uint8_t DL_Swap_Type)

{

ft_uint8_t Swap_Type = DLSWAP_FRAME, Swap_Done = DLSWAP_FRAME;


če (DL_Swap_Type == DLSWAP_LINE)

{

Swap_Type = DLSWAP_LINE;

}


/ * Izvedite novo zamenjavo DL * /

Ft_Gpu_Hal_Wr8 (phost, REG_DLSWAP, Swap_Type);


/ * Počakajte, da je zamenjava končana * /

medtem ko (Swap_Done)

{

Swap_Done = Ft_Gpu_Hal_Rd8 (fost, REG_DLSWAP);


če (DLSWAP_DONE! = Swap_Done)

{

Ft_Gpu_Hal_Sleep (10);

}

}

}


ft_void_t Ft_BootupConfig ()

{


/ * Izvedite cikel moči za varnejšo stran * /

Ft_Gpu_Hal_Powercycle (fost, FT_TRUE);

Ft_Gpu_Hal_Rd16 (fost, RAM_G);

/ * Nastavite clk na zunanjo uro * /

Ft_Gpu_HostCommand (fost, FT_GPU_EXTERNAL_OSC);

Ft_Gpu_Hal_Sleep (10);


/ * Stikalo PLL izhodov na 48MHz * /

Ft_Gpu_HostCommand (fost, FT_GPU_PLL_48M);

Ft_Gpu_Hal_Sleep (10);


/ * Izvedite obnovitev jedra za varnejšo stran * /

Ft_Gpu_HostCommand (fost, FT_GPU_CORE_RESET);


/ * Dostopni naslov 0 za zbiranje FT800 * /

Ft_Gpu_HostCommand (fost, FT_GPU_ACTIVE_M);


Ft_Gpu_Hal_Wr8 (fost, REG_GPIO_DIR, 0x80 | Ft_Gpu_Hal_Rd8 (phost, REG_GPIO_DIR));

Ft_Gpu_Hal_Wr8 (fost, REG_GPIO, 0x080 | Ft_Gpu_Hal_Rd8 (phost, REG_GPIO));

{

ft_uint8_t chipid;

// Preberi ID registracije, da preveri, ali je FT800 pripravljen.

chipid = Ft_Gpu_Hal_Rd8 (fost, REG_ID);

medtem (chipid! = 0x7C)

chipid = Ft_Gpu_Hal_Rd8 (fost, REG_ID);

#ifdef MSVC_PLATFORM

printf ("ID registra VC1 po zbudi% x", chipid);

#endif

}

/ * Konfiguracija LCD zaslona * /

#ifdef SAMAPP_DISPLAY_QVGA

/ * Vrednosti, specifične za QVGA LCD zaslon * /

FT_DispWidth = 320;

FT_DispHeight = 240;

FT_DispHCycle = 408;

FT_DispHOffset = 70;

FT_DispHSync0 = 0;

FT_DispHSync1 = 10;

FT_DispVCycle = 263;

FT_DispVOffset = 13;

FT_DispVSync0 = 0;

FT_DispVSync1 = 2;

FT_DispPCLK = 8;

FT_DispSwizzle = 2;

FT_DispPCLKPol = 0;

#endif


Ft_Gpu_Hal_Wr16 (fost, REG_HCYCLE, FT_DispHCycle);

Ft_Gpu_Hal_Wr16 (fost, REG_HOFFSET, FT_DispHOffset);

Ft_Gpu_Hal_Wr16 (fost, REG_HSYNC0, FT_DispHSync0);

Ft_Gpu_Hal_Wr16 (fost, REG_HSYNC1, FT_DispHSync1);

Ft_Gpu_Hal_Wr16 (fost, REG_VCYCLE, FT_DispVCycle);

Ft_Gpu_Hal_Wr16 (fost, REG_VOFFSET, FT_DispVOffset);

Ft_Gpu_Hal_Wr16 (fost, REG_VSYNC0, FT_DispVSync0);

Ft_Gpu_Hal_Wr16 (fost, REG_VSYNC1, FT_DispVSync1);

Ft_Gpu_Hal_Wr8 (fost, REG_SWIZZLE, FT_DispSwizzle);

Ft_Gpu_Hal_Wr8 (fost, REG_PCLK_POL, FT_DispPCLKPol);

Ft_Gpu_Hal_Wr8 (phost, REG_PCLK, FT_DispPCLK); // ko je ta zaslon viden na LCD-prikazovalniku

Ft_Gpu_Hal_Wr16 (fost, REG_HSIZE, FT_DispWidth);

Ft_Gpu_Hal_Wr16 (fost, REG_VSIZE, FT_DispHeight);



/ * Konfiguracija dotika - konfigurirajte vrednost upora na 1200 - ta vrednost je specifična za zahtevo kupca in izpeljana s preizkusom * /

Ft_Gpu_Hal_Wr16 (fost, REG_TOUCH_RZTHRESH, 1200);

Ft_Gpu_Hal_Wr8 (fost, REG_GPIO_DIR, 0xff);

Ft_Gpu_Hal_Wr8 (fost, REG_GPIO, 0x0ff);

}


#define SAMAPP_ENABLE_APIS_SET0

#ifdef SAMAPP_ENABLE_APIS_SET0


/ * Optimizirana izvedba tabele sin in cos - natančnost 16 bitov * /

FT_PROGMEM ft_prog_uint16_t sintab [] = {

0, 402, 804, 1206, 1607, 2009, 2410, 2811, 3211, 3611, 4011, 4409, 4807, 5205, 5601, 5997, 6392,

6786, 7179, 7571, 7961, 8351, 8739, 9126, 9511, 9895, 10278, 10659, 11038, 11416, 11792, 12166, 12539,

12909, 13278, 13645, 14009, 14372, 14732, 15090, 15446, 15799, 16150, 16499, 16845, 17189, 17530, 17868,

18204, 18537, 18867, 19194, 19519, 19840, 20159, 20474, 20787, 21096, 21402, 21705, 22004, 22301, 22594,

22883, 23169, 23452, 23731, 24006, 24278, 24546, 24811, 25072, 25329, 25582, 25831, 26077, 26318, 26556, 26789,

27019, 27244, 27466, 27683, 27896, 28105, 28309, 28510, 28706, 28897, 29085, 29268, 29446, 29621, 29790, 29955,

30116, 30272, 30424, 30571, 30713, 30851, 30984, 31113, 31236, 31356, 31470, 31580, 31684, 31785, 31880, 31970,

32056, 32137, 32213, 32284, 32350, 32412, 32468, 32520, 32567, 32609, 32646, 32678, 32705, 32727, 32744, 32757,

32764, 32767, 32764};


ft_int16_t qsin (ft_uint16_t a)

{

ft_uint8_t f;

ft_int16_t s0, s1;


če (a & 32768)

return -qsin (a & 32767);

če (a & 16384)

a = 32768 - a;

f = a & 127;

s0 = ft_pgm_read_word (sintab + (a >> 7));

s1 = ft_pgm_read_word (sintab + (a >> 7) + 1);

return (s0 + ((ft_int32_t) f * (s1 - s0) >> 7));

}

/ * cos funtion * /

ft_int16_t qcos (ft_uint16_t a)

{

return (qsin (a + 16384));

}

#endif


/ ************************************************* **************************** /

/ * Primerna koda za prikaz nekaj točk na različnih odmikih z različnimi barvami * /




/ * Zagon za FT800, ki mu sledijo primitivni primeri primerov * /

/ * Začetni zagon DL - naredite nazaj zeleno barvo * /

const ft_uint8_t FT_DLCODE_BOOTUP [12] =

{

255,255,255,2, // GPU navodila CLEAR_COLOR_RGB

7,0,0,38, // GPU navodila CLEAR

0,0,0,0, // GPU navodila DISPLAY

};

statični ft_uint8_t home_star_icon [] = {0x78,0x9C, 0xE5,0x94,0xBF, 0x4E, 0xC2,0x40,0x1C, 0xC7,0x7F, 0x2D, 0x04,0x8B, 0x20,0x45,0x76,0x14,0x67,0xA3,0xF1,0x0D , 0x64,0x75,0xD2,0xD5,0x09,0x27,0x17,0x13,0xE1,0x0D, 0xE4,0x0D, 0x78,0x04,0x98,0x5D, 0x30,0x26, 0xA, 0xA2,0x3E, 0x82,0x0E, 0x8E , 0x82,0xC1,0x38,0x62,0x51,0x0C, 0x0A, 0x42,0x7F, 0xDE, 0xB5,0x77,0xB4,0x77,0x17,0x28,0x21,0x26,0x46,0xFD, 0x26,0xCD, 0xE5,0xD3,0x7C 0xFB, 0xBB, 0xFB, 0xF9, 0xB9,0x02,0xCC, 0xA4,0xE8,0x99,0x80,0x61,0xC4,0x8A, 0x9F, 0xCB, 0x6F, 0x31,0x3B, 0xE3,0x61,0x7A, 0x98,0x84,0x7C , 0x37,0xF6,0xFC, 0xC8,0xDD, 0x45,0x00,0xDD, 0xBA, 0xC4,0x77,0xE6,0xEE, 0x40,0xEC, 0x0E, 0xE6,0x91,0xF1,0xD2,0x00,0x42,0x34,0x5E, 0xCE , 0xE5,0x08,0x16,0xA0,0x84,0x68,0x67,0xB4,0x86,0xC3,0xD5,0xA2,0xB8,0x03,0xB0,0xFE, 0x49,0xDD, 0x54,0x15 , 0xD8,0xEE, 0x73,0x37,0x95,0x9D, 0xD4,0x1A, 0xB7,0xA5,0x26,0xC4,0x91,0xA9,0x0B, 0x06,0xEE, 0x72,0xB7,0xFB, 0xC5,0x16,0x80,0xE9,0xF1 , 0x07,0x8D, 0x3F, 0x15,0x5F, 0x1C, 0x0B, 0xFC, 0x0A, 0x90,0xF0,0xF3,0x09,0xA9,0x90,0xC4,0xC6,0x37,0xB0,0x93,0x BF, 0xE1,0x71,0xDB, 0xA9,0xD7,0x41,0xAD, 0x46,0xEA, 0x19,0xA9,0xD5,0xCE, 0x93,0x59,0x91,0xC3,0x0F, 0x22, 0x1B, 0x1D, 0x91,0x13,0x3D, 0x91,0x73,0x43,0xF1,0x6C, 0x55,0xDA, 0x3A, 0x4F, 0xBA, 0x25,0xCE, 0x4F, 0x04,0xF1,0xC5,0xCF, 0x71,0xDA, 0x3C, 0xD7,0xB9,0xB2,0x48,0xB4,0x89,0x38,0x20,0x4B, 0x2A, 0x95,0x0C, 0xD5,0xEF, 0x5B, 0xAD, 0x96,0x45,0x8A, 0x41,0x96,0x7A, 0x1F, 0x60,0x0D, 0x7D, 0x22,0x75,0x82,0x2B, 0x0F, 0xFB, 0xCE, 0x51,0x3D, 0x2E, 0x3A, 0x21,0xF3, 0x1C, 0xD9,0x38,0x86,0x2C, 0xC6,0x05,0xB6,0x7B, 0x9A, 0x8F, 0x0F, 0x97,0x1B, 0x72,0x6F, 0x1C, 0xEB, 0xAE, 0xFF, 0xDA, 0x97,0x0D, 0xBA, 0x43,0x32,0xCA, 0x66,0x34,0x3D, 0x54,0xCB, 0x24,0x9B, 0x43,0xF2, 0x70,0x3E, 0x42,0xBB, 0xA0,0x95,0x11,0x37,0x46,0xE1,0x4F, 0x49,0xC5,0x1B, 0xFC, 0x3C, 0x3A, 0x3E, 0xD1,0x65,0x0E, 0x6F, 0x58,0xF8,0x9E 0x5B, 0xDB, 0x55,0xB6,0x41,0x34,0xCB, 0xBE, 0xDB, 0x87,0x5F, 0xA9,0xD1,0x85,0x6B, 0xB3,0x17,0x9C, 0x61,0x0C, 0x9B, 0xA2,0x5D, 0x61,0x10, 0xED, 0x2A, 0x9B, 0xA2,0x5D, 0x61,0x10,0xED, 0x2A, 0x9B, 0xA2,0x5D, 0x61,0x10,0xED, 0x2A, 0x9B, 0xED, 0xC9,0xFC, 0xDF, 0x14,0x54,0x8F, 0x80, 0x 7A, 0x06,0xF5,0x23,0xA0,0x9F, 0x41,0xF3,0x10,0x30,0x4F, 0xCA, 0xFC, 0xFF, 0x35,0xC9,0x79,0xC9,0x89,0xFA, 0x33,0xD7,0x1D, 0xF6,0x5E, 0x84,0x5C, 0x56,0x6E, 0xA7,0xDA, 0x1E, 0xF9,0xFA, 0xAB, 0xF5,0x97,0xFF, 0x2F, 0xED, 0x89,0x7E, 0x29,0x9E, 0xB4, 0x9F, 0x74,0x1E, 0x69,0xDA, 0xA4,0x9F, 0x81,0x94,0xEF, 0x4F, 0xF6,0xF9,0x0B, 0xF4,0x65,0x51,0x08};


ft_void_t home_setup ()

{

Ft_Gpu_Hal_WrCmd32 (fost, CMD_INFLATE);

Ft_Gpu_Hal_WrCmd32 (fost, 250 * 1024L);

Ft_Gpu_Hal_WrCmdBuf (fost, home_star_icon, sizeof (home_star_icon));

Ft_Gpu_CoCmd_Dlstart (fost); // začetek

Ft_App_WrCoCmd_Buffer (fost, CLEAR (1,1,1));

Ft_App_WrCoCmd_Buffer (fost, COLOR_RGB (255, 255, 255));

Ft_App_WrCoCmd_Buffer (fost, BITMAP_HANDLE (13)); // ročaj za ozadne zvezde

Ft_App_WrCoCmd_Buffer (fost, BITMAP_SOURCE (250 * 1024L)); // Začetni naslov v gramih

Ft_App_WrCoCmd_Buffer (fost, BITMAP_LAYOUT (L4, 16, 32)); // format

Ft_App_WrCoCmd_Buffer (fost, BITMAP_SIZE (NEAREST, REPEAT, REPEAT, 512, 512));

Ft_App_WrCoCmd_Buffer (fost, BITMAP_HANDLE (14)); // ročaj za ozadne zvezde

Ft_App_WrCoCmd_Buffer (fost, BITMAP_SOURCE (250 * 1024L)); // Začetni naslov v gramih

Ft_App_WrCoCmd_Buffer (fost, BITMAP_LAYOUT (L4, 16, 32)); // format

Ft_App_WrCoCmd_Buffer (fost, BITMAP_SIZE (NAJPRIMERNEJŠA, MEŽNA, MEJA, 32, 32));

Ft_App_WrCoCmd_Buffer (fost, DISPLAY ());

Ft_Gpu_CoCmd_Swap (fost);

Ft_App_Flush_Co_Buffer (fost);

Ft_Gpu_Hal_WaitCmdfifo_empty (phost);

}

statični ft_uint8_t sk = 0;

ft_uint8_t Read_Keys ()

{

statični ft_uint8_t Read_tag = 0, temp_tag = 0, ret_tag = 0;

Read_tag = Ft_Gpu_Hal_Rd8 (fost, REG_TOUCH_TAG);

ret_tag = NULL;

če (Read_tag! = NULL) // Dovoli, da se ključ sprosti

{

če (temp_tag! = Read_tag)

{

temp_tag = Read_tag;

sk = Read_tag; // Naloži oznako Read v spremenljivko temp

}

}

drugače

{

če (temp_tag! = 0)

{

ret_tag = temp_tag;

}

sk = 0;

}

return ret_tag;

}

char * info [] = {"Aplikacija FT800 Ure",


"APP za prikaz interaktivnih ur",

"z uporabo ure, sledi,",

"& Nadzor RTC."

};

void Ft_Play_Sound (zvok ft_uint8_t, ft_uint8_t vol, ft_uint8_t midi)

{

ft_uint16_t val = (midi < 8)=""> zvok;

Ft_Gpu_Hal_Wr8 (fost, REG_SOUND, val);

Ft_Gpu_Hal_Wr8 (fost, REG_PLAY, 1);

}

Podatki o ft_void_t ()

{

ft_uint16_t dloffset = 0, z;

Ft_CmdBuffer_Index = 0;

Ft_Gpu_CoCmd_Dlstart (fost);

Ft_App_WrCoCmd_Buffer (fost, CLEAR (1,1,1));

Ft_App_WrCoCmd_Buffer (fost, COLOR_RGB (255,255,255));

Ft_Gpu_CoCmd_Text (fost, FT_DispWidth / 2, FT_DispHeight / 2,26, OPT_CENTERX | OPT_CENTERY, "Prosim dotakni piko");

Ft_Gpu_CoCmd_Calibrate (fost, 0);

Ft_App_WrCoCmd_Buffer (fost, DISPLAY ());

Ft_Gpu_CoCmd_Swap (fost);

Ft_App_Flush_Co_Buffer (fost);

Ft_Gpu_Hal_WaitCmdfifo_empty (phost);

Ft_Gpu_CoCmd_Logo (fost);

Ft_App_Flush_Co_Buffer (fost);

Ft_Gpu_Hal_WaitCmdfifo_empty (phost);

while (0! = Ft_Gpu_Hal_Rd16 (fost, REG_CMD_READ));

dloffset = Ft_Gpu_Hal_Rd16 (fost, REG_CMD_DL);

dloffset - = 4;

Ft_Gpu_Hal_WrCmd32 (fost, CMD_MEMCPY);

Ft_Gpu_Hal_WrCmd32 (fost, 100000L);

Ft_Gpu_Hal_WrCmd32 (fost, RAM_DL);

Ft_Gpu_Hal_WrCmd32 (fost, dloffset);

narediti

{

Ft_Gpu_CoCmd_Dlstart (fost);

Ft_Gpu_CoCmd_Append (fost, 100000L, dloffset);

Ft_App_WrCoCmd_Buffer (fost, BITMAP_TRANSFORM_A (256));

Ft_App_WrCoCmd_Buffer (fost, BITMAP_TRANSFORM_A (256));

Ft_App_WrCoCmd_Buffer (fost, BITMAP_TRANSFORM_B (0));

Ft_App_WrCoCmd_Buffer (fost, BITMAP_TRANSFORM_C (0));

Ft_App_WrCoCmd_Buffer (fost, BITMAP_TRANSFORM_D (0));

Ft_App_WrCoCmd_Buffer (fost, BITMAP_TRANSFORM_E (256));

Ft_App_WrCoCmd_Buffer (fost, BITMAP_TRANSFORM_F (0));

Ft_App_WrCoCmd_Buffer (fost, SAVE_CONTEXT ());

Ft_App_WrCoCmd_Buffer (fost, COLOR_RGB (219,180,150));

Ft_App_WrCoCmd_Buffer (fost, COLOR_A (220));

Ft_App_WrCoCmd_Buffer (fost, BEGIN (EDGE_STRIP_A));

Ft_App_WrCoCmd_Buffer (fost, VERTEX2F (0, FT_DispHeight * 16));

Ft_App_WrCoCmd_Buffer (fost, VERTEX2F (FT_DispWidth * 16, FT_DispHeight * 16));

Ft_App_WrCoCmd_Buffer (fost, COLOR_A (255));

Ft_App_WrCoCmd_Buffer (fost, RESTORE_CONTEXT ());

Ft_App_WrCoCmd_Buffer (fost, COLOR_RGB (0,0,0));

// INFORMACIJE

Ft_Gpu_CoCmd_Text (fost, FT_DispWidth / 2,20,28, OPT_CENTERX | OPT_CENTERY, info [0]);

Ft_Gpu_CoCmd_Text (fost, FT_DispWidth / 2,60,26, OPT_CENTERX | OPT_CENTERY, info [1]);

Ft_Gpu_CoCmd_Text (fost, FT_DispWidth / 2,90,26, OPT_CENTERX | OPT_CENTERY, info [2]);

Ft_Gpu_CoCmd_Text (fost, FT_DispWidth / 2,120,26, OPT_CENTERX | OPT_CENTERY, info [3]);

Ft_Gpu_CoCmd_Text (fost, FT_DispWidth / 2, FT_DispHeight-30,26, OPT_CENTERX | OPT_CENTERY, "Kliknite za predvajanje");

če (sk! = 'P')

Ft_App_WrCoCmd_Buffer (fost, COLOR_RGB (255,255,255));

drugače

Ft_App_WrCoCmd_Buffer (fost, COLOR_RGB (100,100,100));

Ft_App_WrCoCmd_Buffer (fost, BEGIN (FTPOINTS));

Ft_App_WrCoCmd_Buffer (fost, POINT_SIZE (20 * 16));

Ft_App_WrCoCmd_Buffer (fost, TAG ('P'));

Ft_App_WrCoCmd_Buffer (fost, VERTEX2F ((FT_DispWidth / 2) * 16, (FT_DispHeight-60) * 16));

Ft_App_WrCoCmd_Buffer (fost, COLOR_RGB (180,35,35));

Ft_App_WrCoCmd_Buffer (fost, BEGIN (BITMAPS));

Ft_App_WrCoCmd_Buffer (fost, VERTEX2II ((FT_DispWidth / 2) -14, (FT_DispHeight-75), 14,4));

Ft_App_WrCoCmd_Buffer (fost, DISPLAY ());

Ft_Gpu_CoCmd_Swap (fost);

Ft_App_Flush_Co_Buffer (fost);

Ft_Gpu_Hal_WaitCmdfifo_empty (phost);

} medtem ko (Read_Keys ()! = 'P');

Ft_Play_Sound (0x50,255,0xc0);

}

#define DRŽAVE 12


char * country [] = {"Indija", "Singapur", "Nova Zelandija", "Japonska", "Danska", "Kitajska", "Avstralija", "Belgija", "Bahrajn", "Italija", "Norveška" "," Nemčija "};


typedef struct

{

ft_uint8_t ghr;

ft_uint8_t gmin;

ft_uint8_t arith;

} t_gmtprp;


t_gmtprp gmt_prp [12] = {{5,30, '+'}, {8,0, '+'}, {12,45, '+'}, {9,0, '+'}, {4, 0, '+'}, {8,0, '+'}, {10,0, '+'}, {1,0, '+'}, {3,0, '+'}, {1, 0, '+'}, {1,0, '+'}, {1,0, '+'}};

statična struktura {

podpisan kratki dragprev;

int vel; // hitrost

dolga baza; // koordinata zaslona x, v 1/16 slikovnih pik

dolga omejitev;

} Scroller;

strukturo

{

ft_uint8_t Hrs;

ft_uint16_t Min;

ft_uint16_t Secs;

ft_uint16_t mSecs;

} ist, utc;

statični ft_void_t scroller_init (omejitev ft_uint32_t)

{

scroller.dragprev = -32768;

scroller.vel = 0; // hitrost

scroller.base = 0; // koordinata zaslona x, v 1/16 slikovnih pik

scroller.limit = limit;

}

statični ft_void_t scroller_run ()

{

ft_int32_t sprememba;


podpisano kratko sx = Ft_Gpu_Hal_Rd16 (fost, REG_TOUCH_SCREEN_XY + 2);


if ((sx! = -32768) & (scroller.dragprev! = -32768))

{

scroller.vel = (scroller.dragprev - sx) <>

}

drugače

{

sprememba = max (1, abs (scroller.vel) >> 5);

če (scroller.vel <>

scroller.vel + = spremeni;

if (scroller.vel> 0)

scroller.vel - = sprememba;

}

scroller.dragprev = sx;

scroller.base + = scroller.vel;

scroller.base = max (0, min (scroller.base, scroller.limit));

}

statični ft_uint8_t clk_adj = 0;

statični ft_uint16_t min_val;

ft_uint8_t temp [7];

#ifdef ARDUINO_PLATFORM

bajt decToBcd (bajt val)

{

donos ((val / 10 * 16) + (val% 10));

}

// Pretvori binarno kodirano decimalno število v normalne decimalne številke

bajt bcdToDec (bajt val)

{

donos ((val / 16 * 10) + (val% 16));

}

void Rtc_puts ()

{

temp [0] = 0x80 | ist.Sec;

temp [1] = decToBcd (ist.Mins);

temp [2] = decToBcd (ist.Hrs);

hal_rtc_i2c_write (0, (ft_uint8_t *) & temp, 7);

}

// Pridobi datum in čas iz ds1307

void Rtc_gets ()

{

hal_rtc_i2c_read (0, (ft_uint8_t *) & temp, 3);

temp [0] & = 0x7f;

temp [1] & = 0x7f;

temp [2] & = 0x7f;

ist.Hrs = bcdToDec (temp [2]);

ist.Mins = bcdToDec (temp [1]);

ist.Secs = bcdToDec (temp [0]);

}

#endif

statični ft_uint16_t Get_TagRotary_Value (ft_uint16_t Tagval, ft_uint16_t obseg, ft_uint16_t max_rotation, ft_uint16_t ct) // -180 za 90

{

ft_int32_t trackval = 0;

statični ft_int16_t thcurr = 0, predogled = 0, adj = 0;

statični ft_int32_t adj_val = 0;

statični ft_uint16_t retval = 0;

trackval = Ft_Gpu_Hal_Rd32 (fost, REG_TRACKER);

če (trackval)

{

thcurr = (trackval >> 16);

če (adj == Tagval)

{

adj_val + = (ft_int16_t) (thcurr - prevth);

če (adj_val <>

adj_val + = (max_rotation * 65536L);

če (adj_val> = (max_rotation * 65536L))

adj_val - = (max_rotation * 65536L);

retval = (adj_val / (65536L / območje));

}

prevth = thcurr;

adj = trackval & 0xff;

clk_adj = 0;

}

drugače

{

if (adj! = 0) clk_adj = 1;

sicer retval = ct;

adj_val = ((ct / 60) * 65536L) + (ct% 60) * (65536L / območje));

adj = 0;

}

povratno povračilo;

}

statični ft_uint8_t temp_mins = 0, temp_secs = 0, temp_Hrs;

#if definirano (MSVC_PLATFORM) || definirano (MSVC_FT800EMU)

SYSTEMTIME str_t;

#endif

void timer (ime ft_uint8_t)

{

statični ft_uint8_t temp_time = 0;

char hrs_t [2], min_t [2], * temp;

statični ft_uint16_t temp_m = 0, Hrs = 0;

statični ft_uint16_t temp_msecs = 0, temp_secs = 0;

ft_uint32_t t;

ft_int32_t Min;

Mins = gmt_prp [ime] .gmin;

Hrs = gmt_prp [ime] .ghr;

Mins = Mins + (Hrs * 60);

if (gmt_prp [name] .arith == '+')

Mins = min_val + min;

if (gmt_prp [name] .arith == '-')

{

Mins = min_val-min;

če (Mins <>

Mins = 720 min;

}

t = ft_millis ();

t = t% 1000L;

utc.Hrs = (Min / 60)% 12;

utc.Mins = (Mins)% 60;

#if definirano (MSVC_PLATFORM) || definirano (MSVC_FT800EMU)

GetLocalTime (& str_t);

ist.Secs = str_t.wSecond;

#endif

if (temp_mins! = str_t.wMinute)

{

ist.Mins = ist.Mins + (str_t.wMinute-temp_mins);

temp_mins = str_t.wMinute;

}

če (temp_Hrs! = (str_t.wHour-8))

{

ist.Hrs = ist.Hrs + ((str_t.wHour-8) -temp_Hrs);

temp_Hrs = str_t.wHour-8;

}


if (ist.Secs! = temp_secs)

{

temp_secs = ist.Secs;

temp_msecs = 1000L-t;

}

utc.mSecs = (t + temp_msecs)% 1000L;

utc.Secs = ist.Secs;

če (clk_adj)

{

clk_adj = 0;

ist.Mins = min_val% 60;

ist.Hrs = (min_val / 60)% 12;

}

}

ft_void_t Ure (ft_uint8_t clksize, možnosti ft_uint8_t)

{

ft_uint8_t

clk_s = clksize / 10, per_f, n_f, ime, oznaka;


ft_uint16_t dx = (clk_s * 2) + (2 * clksize),

dy = (FT_DispHeight / 2) + clksize + 10,

temp_m, Hrs;

ft_uint32_t t;


ft_uint8_t col = FT_DispWidth / dx;

ft_int16_t Ox, Oy, sx, drag = 0, prev = 0, dragth = 0, i, cts = 0, th, pv;

ft_int32_t tir, min;

per_f = col;

n_f = (DRŽAVE) / per_f;

Oy = (FT_DispHeight / 2);

scroller_init (16 * (DRŽAVE * (dx) -FT_DispWidth));

#if definirano (MSVC_PLATFORM) || definirano (MSVC_FT800EMU)

GetLocalTime (& str_t);

ist.Hrs = str_t.wHour-8; // za Signapore

ist.Mins = str_t.wMinute;

ist.Secs = str_t.wSecond;

temp_mins = ist.Mins;

temp_secs = ist.Secs;

temp_Hrs = ist.Hrs;

#else

Rtc_gets ();

#endif

narediti

{

Oznaka = Ft_Gpu_Hal_Rd8 (fost, REG_TOUCH_TAG);

temp_m = (ist.Mins + (ist.Hrs * 60))% 720L;

min_val = Get_TagRotary_Value (oznaka, 60,12, temp_m);


če ((Ft_Gpu_Hal_Rd32 (phost, REG_TRACKER) & 0xff) == 0)

{

scroller_run ();

povlecite = scroller.base >> 4;

cts = drag / dx;

dragth = povleci% dx;

} else

{

scroller.vel = 0;

}

Ft_Gpu_CoCmd_Dlstart (fost);

Ft_App_WrCoCmd_Buffer (fost, CLEAR (1,1,1));

Ft_App_WrCoCmd_Buffer (fost, TAG_MASK (1));

Ft_App_WrCoCmd_Buffer (fost, TAG (0));

Ft_Gpu_CoCmd_Gradient (fost, 0, 135, 0x000000, 0, 272, 0x605040);

za (i = -1; i <(per_f +="" 2);="" i="">

{

Ox = (clksize + clk_s) + (dx * i);

Ox- = dragth;

ime = (DRŽAVE + i + cts)% DRŽAVE;

timer (ime);

if (Oznaka == ime + 1) Ft_Gpu_CoCmd_BgColor (phost, 0x4040a0); drugače

Ft_Gpu_CoCmd_BgColor (fost, 0x101040);

Ft_App_WrCoCmd_Buffer (fost, TAG (ime + 1));

Ft_Gpu_CoCmd_Clock (fost, Ox, FT_DispHeight / 2, clksize, 0, utc.Hrs, utc.Mins, utc.Secs, utc.mSecs);

Ft_Gpu_CoCmd_Track (fost, Ox, FT_DispHeight / 2,1,1, ime + 1);

}

Ft_App_WrCoCmd_Buffer (fost, TAG_MASK (0));

za (i = -1; i <(per_f +="" 2);="" i="">

{

Ox = (clksize + clk_s) + (dx * i);

Ox- = dragth;

ime = (DRŽAVE + i + cts)% DRŽAVE;

Ft_Gpu_CoCmd_Text (fost, Ox, dy, 29, OPT_CENTERX, država [ime]);

}

Ft_App_WrCoCmd_Buffer (fost, DISPLAY ());

Ft_Gpu_CoCmd_Swap (fost);

Ft_App_Flush_Co_Buffer (fost);

Ft_Gpu_Hal_WaitCmdfifo_empty (phost);

#if je definiran FT_801_ENABLE

Ft_Gpu_Hal_Sleep (30);

#endif

} medtem ko (1);

}

#ifdef MSVC_PLATFORM

/ * Glavna vstopna točka * /

ft_int32_t glavni (ft_int32_t argc, ft_char8_t * argv [])

#endif

#if definirano (ARDUINO_PLATFORM) || definirano (MSVC_FT800EMU)

ft_void_t setup ()

#endif

{

Ft_Gpu_HalInit_t halinit;

halinit.TotalChannelNum = 1;


Ft_Gpu_Hal_Init (& halinit);

host.hal_config.channel_no = 0;

#ifdef MSVC_PLATFORM_SPI

host.hal_config.spi_clockrate_khz = 12000; // v KHz

#endif

#ifdef ARDUINO_PLATFORM_SPI

host.hal_config.spi_clockrate_khz = 4000; // v KHz

#endif

Ft_Gpu_Hal_Open (& gostitelj);

phost = & gostitelj;

Ft_BootupConfig ();


printf ("reg_touch_rz = 0x% x", Ft_Gpu_Hal_Rd16 (phost, REG_TOUCH_RZ));

printf ("reg_touch_rzthresh = 0x% x", Ft_Gpu_Hal_Rd32 (fost, REG_TOUCH_RZTHRESH));

printf ("reg_touch_tag_xy = 0x% x", Ft_Gpu_Hal_Rd32 (phost, REG_TOUCH_TAG_XY));

printf ("reg_touch_tag = 0x% x", Ft_Gpu_Hal_Rd32 (phost, REG_TOUCH_TAG));



/ * Neobvezno je tukaj izbrisati zaslon * /

Ft_Gpu_Hal_WrMem (fost, RAM_DL, (ft_uint8_t *) FT_DLCODE_BOOTUP, sizeof (FT_DLCODE_BOOTUP));

Ft_Gpu_Hal_Wr8 (fost, REG_DLSWAP, DLSWAP_FRAME);

Ft_Gpu_Hal_Sleep (1000); // Prikaži zagonski zaslon.


home_setup ();

Info ();

Ure (80,0);

/ * Zapri vse odprte ročice * /

Ft_Gpu_Hal_Close (fost);

Ft_Gpu_Hal_DeInit ();

#ifdef MSVC_PLATFORM

return 0;

#endif

}

void loop ()

{

}



/ * Nič več od tega * /