Dom > Novice > Vsebine

FT_App_Clocks

May 06, 2019

/ *

#include

#include

#include

#include

#include

* /

/ * # vključuje "FT_Platform.h"

#include "FT_Hal_SPI.cpp"

#include "FT_CoPro_Cmds.cpp"

* /


#include


#include "FT_Platform.h"

#include "FT_Hal_I2C.h"



#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)


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


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;


#define DISPLAY_QVGA


#define ON 1

#define OFF 0

#define Font 27 // Velikost pisave

#define MAX_LINES 4 // Max Lines omogoča prikaz


#define SPECIAL_FUN 251

#define BACK_SPACE 251 // Nazaj

#define CAPS_LOCK 252 // Caps Lock

#define NUMBER_LOCK 253 // Zaklepanje številke

#define BACK 254 // Izhod


#define LINE_STARTPOS FT_DispWidth / 50 // Začetek vrstice

#define LINE_ENDPOS FT_DispWidth // največja dolžina linije


/ * 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 spreminjanjem PWM zaslona od 0 do 100 in na koncu 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);

}


#ifdef SAMAPP_ENABLE_APIS_SET0


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

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 SAMAPP_qsin (ft_uint16_t a)

{

ft_uint8_t f;

ft_int16_t s0, s1;


če (a & 32768)

vrnitev -SAMAPP_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 SAMAPP_qcos (ft_uint16_t a)

{

vrnitev (SAMAPP_qsin (a + 16384));

}

#endif


/ * 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);

}

}

}


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

/ * 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

};


/ * deflacionirane ikone * /

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};


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


"APP za prikaz interaktivnih ur",

"z uporabo ure, sledi",

"& Nadzor RTC."

};

#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;

/ ******** API za vrnitev dodeljene vrednosti TAG, ko je penup, za primitive / widgets ****** /


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;

}

/ *********************** API, ki se uporablja za nastavitev ICON ******************** ********************** /

/ * Upoštevajte pretok kode v diagramu poteka, ki je na voljo v Opombi za uporabo * /


ft_void_t home_setup ()

{

/ * Datoteka ikone je deflacionirana z J1 ukazom za napihovanje datoteke in zapisovanje v GRAM * /

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));

/ * Nastavite lastnosti Bitmapa za ICONS * /

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);

}

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;


// Umerjanje zaslona na dotik

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);

// Ftdi animacija logotipa

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));

// Kopiranje seznama Display from DL RAM v GRAM

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);

// Ponastavite lastnosti BITMAP, uporabljene med animacijo Logo

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));

// Prikaz informacij s preglednim logotipom s pomočjo robnega traku

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, (char *) pgm_read_word (& info [0]));

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

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

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

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

// Preverite, ali je tipka za predvajanje in sprememba barve

č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);

/ * počakajte, da tipka Play ni pritisnjena * /

}


/ * Init Scroller * /

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;

}


/ * Zaženi Scroller v vodoravni linearni liniji * /


statični ft_void_t scroller_run ()

{

ft_int32_t sprememba;


podpisan 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];

/ * pretvarjanje podatkov za rtc * /

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));

}


/ * zapiše podatke v RTC * /

void Rtc_puts ()

{

temp [0] = 0x80 | (decToBcd (ist.Secs));

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

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

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

}


// Pridobi datum in čas

void Rtc_gets ()

{

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

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

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

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

}

/ * API, ki se uporablja za izračun časa od rotacijske vrednosti * /

statični ft_uint16_t adj_time = 0;

statični ft_uint32_t t_adj = 0;

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;

// trenutni čas v 16bitnem pritisku za prilagoditev

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

adj = 0;

}

povratno povračilo;

}

/ * api izračuna standardni čas za države * /


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;

}

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

utc.Mins = (Mins)% 60;

/ * sinhronizacija RTC in MCU čas * /

#ifdef RTC_PRESENT

t = millis ();

t = t% 1000L;


if (ist.Secs! = temp_secs)

{

temp_secs = ist.Secs;

temp_msecs = 1000L-t;

}

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

#endif

// utc.Secs = ist.Secs;

/ * če se prilagodi čas, potem se zapiše v RTC * /

če (clk_adj)

{

clk_adj = 0;

ist.Mins = min_val% 60;

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

#ifdef RTC_PRESENT

Rtc_puts ();

#else

t_adj = millis ();

t_adj = (t_adj / 60000L)% 60;

adj_time = ((ist.Mins) + (ist.Hrs * 60)) - t_adj;

#endif

}

}

statični bajt istouch ()

{

return! (Ft_Gpu_Hal_Rd16 (fost, REG_TOUCH_RAW_XY & 0x8000));

}

/ * Funkcija ure * /

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, startup_time = 0;


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

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

temp_m, Hrs;


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, Mins, Velocity = 0;

per_f = col;

n_f = (DRŽAVE) / per_f;

Oy = (FT_DispHeight / 2);

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

timer (0);

narediti

{

Oznaka = Ft_Gpu_Hal_Rd8 (fost, REG_TOUCH_TAG);

#ifdef RTC_PRESENT

Rtc_gets ();

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

#else

ft_uint32_t t = millis ();

utc.mSecs = t% 1000L;

ist.Secs = (t / 1000L)% 60;

ist.Mins = (t / 60000L)% 60;

ist.Hrs = (t / 3600000L)% 12;

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

temp_m + = adj_time;

temp_m% = 720;

#endif

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);

// Nastavite barvo bg ure

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

Ft_Gpu_CoCmd_BgColor (fost, 0x101040);

// Nariši ure z sledilnikom

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

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

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

}

Ft_App_WrCoCmd_Buffer (fost, TAG_MASK (0));

// Prikaz imena države

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]);

}

if (scroller.vel! = 0) Velocity = scroller.vel;

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

#ifdef ARDUINO_PLATFORM

ft_void_t setup ()

#endif

{

/ * Lokalne spremenljivke * /

ft_uint8_t chipid;


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;


/ * 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);

// Ft_Gpu_CoreReset (fost);


/ * Dostopni naslov 0 za zbiranje FT800 * /

Ft_Gpu_HostCommand (fost, FT_GPU_ACTIVE_M);


{

// 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);


/ * Na začetku napolnite ping in pong buffer * /

Ft_Gpu_Hal_Wr8 (fost, REG_GPIO_DIR, 0xff);

Ft_Gpu_Hal_Wr8 (fost, REG_GPIO, 0x0ff);

/ * 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);




/ * 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.

#ifdef RTC_PRESENT

hal_rtc_i2c_init ();

bajt WriteByte = 0x03;

hal_rtc_i2c_write (0x07, & WriteByte, 1);

hal_rtc_i2c_read (0x00, & WriteByte, 1);

if ((WriteByte & 0x80) == 0)

{

WriteByte = 0x80;

hal_rtc_i2c_write (0x00, & WriteByte, 1);

}

#endif


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 * /