הבית > חֲדָשׁוֹת > תוכן

FT_App_Clocks

May 06, 2019

/ *

#include

#include

#include

#include

#include

* /

/ * # כוללים "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)


/ * משתנים גלובליים עבור רזולוציית התצוגה לתמוך לוחות תצוגה שונים * /


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 על 1

#define OFF 0

#define גופן 27 // גודל גופן

#define MAX_LINES 4 / / מקס שורות מאפשר להציג


#define SPECIAL_FUN 251

#define BACK_SPACE 251 / / שטח אחורי

#define CAPS_LOCK 252 // נעילה אותיות גדולות

#define NUMBER_LOCK 253 // מספר נעל

#define חזרה 254 // יציאה


#define LINE_STARTPOS FT_DispWidth / 50 // התחלה של הקו

#define LINE_ENDPOS FT_DispWidth / / אורך מרבי של הקו


/ * גלובלי המשמש למאגר אופטימיזציה * /

Ft_Gpu_Hal_Context_t host, * 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

/ * העתק את פקודת הפקודה למאגר * /

ft_uint32_t * pBuffcmd;

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

* pBuffcmd = cmd;

#endif

#ifdef ARDUINO_PLATFORM

Ft_Gpu_Hal_WrCmd32 (phost, cmd);

#endif

/ * הגדלת מדד הפקודה * /

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

/ * העתק את פקודת הפקודה למאגר * /

ft_uint32_t * pBuffcmd;

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

* pBuffcmd = cmd;

#endif


#ifdef ARDUINO_PLATFORM

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

#endif

/ * הגדלת מדד הפקודה * /

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 length = 0;

אורך = strlen (s) + 1; // האחרון עבור סיום null

strcpy (& Ft_CmdBuffer [Ft_CmdBuffer_Index], s);


/ * להגדיל את אורך וליישר אותו על ידי 4 בתים * /

Ft_CmdBuffer_Index + = ((אורך + 3) & ~ 3);

#endif

}


ft_void_t Ft_App_Flush_DL_Buffer (Ft_Gpu_Hal_Context_t * phost)

{

#ifdef BUFFER_OPTIMIZATION

אם (Ft_DlBuffer_Index> 0)

Ft_Gpu_Hal_WrMem (phost, 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

אם (Ft_CmdBuffer_Index> 0)

Ft_Gpu_Hal_WrCmdBuf (phost, Ft_CmdBuffer, Ft_CmdBuffer_Index);

#endif

Ft_CmdBuffer_Index = 0;

}


/ * API לתת אפקט fadeout על ידי שינוי התצוגה PWM מ 100 עד 0 * / /

ft_void_t SAMAPP_fadeout ()

{

ft_int32_t i;

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

{

Ft_Gpu_Hal_Wr8 (phost, REG_PWM_DUTY, i);


Ft_Gpu_Hal_Sleep (2); / לישון עבור 2 אלפיות השנייה

}

}


* API כדי לבצע אפקט התצוגה fadein על ידי שינוי PWM התצוגה מ 0 עד 100 ולבסוף 128 * /

ft_void_t SAMAPP_fadein ()

{

ft_int32_t i;

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

{

Ft_Gpu_Hal_Wr8 (phost, REG_PWM_DUTY, i);

Ft_Gpu_Hal_Sleep (2); / לישון עבור 2 אלפיות השנייה

}

/ * לבסוף להפוך את PWM 100% * /

i = 128;

Ft_Gpu_Hal_Wr8 (phost, REG_PWM_DUTY, i);

}


#ifdef SAMAPP_ENABLE_APIS_SET0


/ * יישום מיטבי של חטא ו COS טבלה - דיוק הוא 16 סיביות * /

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, 14459, 144599, 14745, 17189, 17530, 17868,

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

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

27895, 27766, 27466, 27466, 27683, 27896, 28105, 28309, 28510, 28706, 28897, 29085, 29268, 29446, 29621, 29790, 29955,

30116, 30224, 30524, 30571, 30713, 30851, 30984, 31113, 31236, 31356, 31470, 31580, 31684, 31785, 31880, 31970,

3206, 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;


אם (a & 32768)

return -SAMAPP_qsin (a & 32767);

אם (a & 16384)

א = 32768 - a;

f = a & 127;

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

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

החזרה (s0 + ((ft_int32_t) f * (s1 - s0) >> 7));

}


/ * cos funtion * /

ft_int16_t SAMAPP_qcos (ft_uint16_t a)

{

Return (SAMAPP_qsin (+ 16384));

}

#endif


/ * API כדי לבדוק את הסטטוס של DLSWAP הקודם ולבצע DLSWAP של DL חדש * /

/ * בדוק את הסטטוס של DLSWAP הקודם ואם עדיין לא לעשות לחכות ms כמה לבדוק שוב * /

ft_void_t SAMAPP_GPU_DLSwap (ft_uint8_t DL_Swap_Type)

{

ft_uint8_t Swap_Type = DLSWAP_FRAME, Swap_Done = DLSWAP_FRAME;


אם (DL_Swap_Type == DLSWAP_LINE)

{

Swap_Type = DLSWAP_LINE;

}


/ * לבצע החלפת DL חדש * /

Ft_Gpu_Hal_Wr8 (phost, REG_DLSWAP, Swap_Type);


/ * המתן עד החלפה נעשה * /

בעוד (Swap_Done)

{

Swap_Done = Ft_Gpu_Hal_Rd8 (phost, REG_DLSWAP);


אם (DLSWAP_DONE! = Swap_Done)

{

Ft_Gpu_Hal_Sleep (10); // המתן עד 10ms

}

}

}


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

/ * קוד לדוגמה כדי להציג כמה נקודות על קיזוזים שונים עם צבעים שונים * /




/ * אתחול עבור FT800 ואחריו גרפיקה דוגמאות מדגם פרימיטיבי * /

/ * אתחול ראשוני את DL - להפוך את הקרקע בצבע ירוק אחורי * /


FT_DLCODE_BOOTUP [12] =

{

255,255,255,2, // הוראות GPU CLEAR_COLOR_RGB

7,0,0,38, // הוראה GPU ברור

0,0,0,0, / / GPU הוראה תצוגה

};


/ * אייקונים מנופחים * /

static 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, 0x78,0x04,0x98,0x5D, 0x30,0x26,0x0E, 0x4A, 0xA2,0x3E, 0x82,0x0E, 0x8E 0x82,0xC1,0x38,0x0C, 0x0A, 0x42,0x7F, 0xDE, 0xB5,0x77,0xB4,0x77,0x17,0x28,0x21,0x26,0x46,0xFD, 0x26,0xCD, 0xE5,0xD3,0x7C , 0xB9,0xCC, 0xA4,0xE8,0x99,0x80,0x61,0xC4,0x8A, 0x9F, 0xCB, 0x6F, 0x31,0x3B, 0xE3,0x61,0x7A, 0x98,0x84,0x7C 0x37,0xF6,0xEE, 0x40,0xEC, 0x0E, 0xE6,0x91,0xF1,0xD2,0x00,0x42,0x34,0x5E, 0xCE , 0xE5,0x05,0x26,0x2C, 0x20,0x51,0x17,0xA2,0xB8,0x03,0xB0,0xFE, 0x49,0xDD, 0x54,0x15 , 0xD8,0xEE, 0x73,0x37,0x9D, 0xD4,0x1A, 0xB7,0xA5,0x26,0xC4,0x91,0xA9,0x0B, 0x06,0xEE, 0x72,0xB7,0xFB, 0xC5,0x16,0x80,0xE9,0xF1 , 0x07,0x8D, 0x15,0x5F, 0x1C, 0x0B, 0xFC, 0x0A, 0x90,0xF0,0xF3,0x09,0xA9,0x90,0xC4,0xC6,0x37,0xB0,0x93,0x Bx, 0xE1,0x71,0xDB, 0xA9,0xD7,0x41,0xAD, 0x46,0xEA, 0x19,0xA9,0xD5,0xCE, 0x93,0xB3,0x35,0x73,0x0A, 0x69,0x59,0x91,0xC3,0x0F, 0x22, 0x1D, 0x91, 0x91, 0x91,0x3D, 0x91,0x73,0x43,0xF1,0x6C, 0x55,0xDA, 0x3A, 0x4F, 0xBA, 0x25,0xCE, 0x4F, 0x04,0xF1,0xC5,0xCF, 0x71,0xDA, 0x3C, 0xD7,0xB9, 0x2A, 0x95,0x0C, 0xD5,0xEF, 0x5B, 0xAD, 0x96,0x45,0x8A, 0x41,0x96,0x7A, 0x1F, 0x60,0x0D, 0xD7,0x48,0x0,0xB9,0xB9,0xB9,0xB9,0xB9,0xB2,0xB2,0xB2,0xB4,0x89,0x38,0x20B, 0x2F, 0xF, 0xCE, 0x51,0x3D, 0x2E, 0x3A, 0x21,0xF3,0x1C, 0xD9,0x38,0x86,0x2C, 0xC6,0x05,0xB6,0x7B, 0x9A, 0x8F, 0x0,0x1A, 0xEC, 0xEE, 0xAE, 0xAE, 0xFF, 0xDA, 0x97,0x0D, 0xBA, 0x43,0x32,0xCA, 0x66,0x34,0x3D, 0x54,0xCB, 0x24,0x9B, 0x43,0xF2, 0x70,0x3B, 0x42, 0x3, 0x3A, 0x3E, 0xD1,0x65,0x0E, 0x6F, 0x58,0xF8,0x9E, 0x5,0x3, 0x5, 0xDB, 0x55, 0xDB, 0x55, 0xDB, 0x55, 0x5B, 0xBE, 0xDB, 0x87,0x5F, 0xA9,0xD1,0x85,0x6B, 0xB3,0x17,0x9C, 0x61,0x0C, 0x9B, 0xA2,0x5D, 0x61,0x10, 0x2A, 0xA2,0xED, 0x61,0x10,0xED, 0x2A, 0x9B, 0xA2,0x5D, 0x61,0x10,0xED, 0x2A, 0x9B, 0xED, 0xC9,0xFC, 0xDF, 0x14,0x54,0x8F, 0x80, 0x 7, 0x06,0xF5,0x23,0xA0,0x9F, 0x41,0xF3,0x10,0x30,0x4F, 0x41,0xF3,0x18,0x30,0xCF, 0xCA, 0xFC, 0xFF, 0x35,0xC9,0x79,0xC9,0x89,0xFA, 0x33,0x5E, 0x84,0x5E, 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 [] = {"FT800 שעון יישומים",


"APP להפגין שעונים אינטראקטיביים",,

"באמצעות שעונים, מסלול",

"& RTC שליטה."

};

#define COUNTRIES 12


* "הודו", "סינגפור", "ניו זילנד", "יפן", "דנמרק", "סין", "אוסטרליה", "בלגיה", "בחריין", "איטליה" "," גרמניה "};


קל דגם

{

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,' +}}};

מבנה סטטי {

חתום קצר dragprev;

int vel; / / מהירות

בסיס ארוך; / / x x לתאם, ב 1/16 פיקסלים

גבול ארוך;

} Scroller;

מבנה

{

ft_uint8_t שעות;

ft_uint16_t דקות;

ft_uint16_t שניות;

ft_uint16_t mSecs;

} ist, utc;

/ ******** API כדי להחזיר את הערך שהוקצה TAG כאשר penup, עבור פרימיטיבים / יישומונים ****** /


static ft_uint8_t sk = 0;

ft_uint8_t Read_Keys ()

{

static ft_uint8_t Read_tag = 0, temp_tag = 0, ret_tag = 0;

Read_tag = Ft_Gpu_Hal_Rd8 (פוסט, REG_TOUCH_TAG);

ret_tag = NULL;

אם (Read_tag! = NULL) אם אפשר לשחרר את המפתח

{

אם (temp_tag! = Read_tag)

{

temp_tag = Read_tag;

sk = Read_tag; / / טען את תג לקריאה משתנה זמני

}

}

Other

{

אם (temp_tag! = 0)

{

ret_tag = temp_tag;

}

sk = 0;

}

Return ret_tag;

}

/ *********************** API המשמש להגדרת הסמל ******************** ********************** /

/ * הפנה את קוד הזרימה ב availble תרשים זרימה ביישום הערה * /


ft_void_t home_setup ()

{

/ * קובץ האייקון הוא deflated להשתמש J1 פקודה לנפח את הקובץ לכתוב לתוך GRAM * /

Ft_Gpu_Hal_WrCmd32 (phost, CMD_INFLATE);

Ft_Gpu_Hal_WrCmd32 (phost, 250 * 1024L);

Ft_Gpu_Hal_WrCmdBuf (phost, home_star_icon, sizeof (home_star_icon));

/ * הגדרת מאפייני מפת סיביות עבור צלמיות * /

Ft_Gpu_CoCmd_Dlstart (פוסט); // להתחיל

Ft_App_WrCoCmd_Buffer (פוסט, CLEAR (1,1,1));

Ft_App_WrCoCmd_Buffer (פוסט, COLOR_RGB (255, 255, 255));

Ft_App_WrCoCmd_Buffer (phost, BITMAP_HANDLE (13)); / / עבור כוכבים ברקע

Ft_App_WrCoCmd_Buffer (פוסט, BITMAP_SOURCE (250 * 1024L)); // כתובת ההתחלה בגרם

Ft_App_WrCoCmd_Buffer (פוסט, BITMAP_LAYOUT (L4, 16, 32)); בפורמט

Ft_App_WrCoCmd_Buffer (phost, BITMAP_SIZE (הקרוב ביותר, REPEAT, REPEAT, 512, 512));

Ft_App_WrCoCmd_Buffer (phost, BITMAP_HANDLE (14)); / / עבור כוכבים ברקע

Ft_App_WrCoCmd_Buffer (פוסט, BITMAP_SOURCE (250 * 1024L)); // כתובת ההתחלה בגרם

Ft_App_WrCoCmd_Buffer (פוסט, BITMAP_LAYOUT (L4, 16, 32)); בפורמט

Ft_App_WrCoCmd_Buffer (פוסט, BITMAP_SIZE (הקרוב ביותר, בורדר, בורדר, 32, 32));

Ft_App_WrCoCmd_Buffer (פוסט, DISPLAY ());

Ft_Gpu_CoCmd_Swap (phost);

Ft_App_Flush_Co_Buffer (phost);

(Fost);

}

VT_Play_Sound ריק (ft_uint8_t צליל, ft_uint8_t vol, ft_uint8_t midi)

{

ft_uint16_t val = (midi < 8)=""> נשמע;

Ft_Gpu_Hal_Wr8 (phost, REG_SOUND, val);

Ft_Gpu_Hal_Wr8 (phost, REG_PLAY, 1);

}


פרטי ft_void_t ()

{

ft_uint16_t dloffset = 0, z;

Ft_CmdBuffer_Index = 0;


// כיול מסך מגע

Ft_Gpu_CoCmd_Dlstart (פוסט);

Ft_App_WrCoCmd_Buffer (פוסט, CLEAR (1,1,1));

Ft_App_WrCoCmd_Buffer (פוסט, COLOR_RGB (255,255,255));

Ft_Gpu_CoCmd_Text (phost, FT_DispWidth / 2, FT_DispHeight / 2,26, OPT_CENTERX | OPT_CENTERY, "הקש על נקודה");

Ft_Gpu_CoCmd_Calibrate (phost, 0);

Ft_App_WrCoCmd_Buffer (פוסט, DISPLAY ());

Ft_Gpu_CoCmd_Swap (phost);

Ft_App_Flush_Co_Buffer (phost);

(Fost);

// Ftdi לוגו אנימציה

Ft_Gpu_CoCmd_Logo (פוסט);

Ft_App_Flush_Co_Buffer (phost);

(Fost);

בעוד (0! = Ft_Gpu_Hal_Rd16 (phost, REG_CMD_READ));

/ / העתק את Displaylist מ RAM RAM ל GRAM

dloffset = Ft_Gpu_Hal_Rd16 (phost, REG_CMD_DL);

dloffset - = 4;

Ft_Gpu_Hal_WrCmd32 (phost, CMD_MEMCPY);

Ft_Gpu_Hal_WrCmd32 (phost, 100000L);

Ft_Gpu_Hal_WrCmd32 (phost, RAM_DL);

Ft_Gpu_Hal_WrCmd32 (phost, dloffset);

לעשות

{

Ft_Gpu_CoCmd_Dlstart (פוסט);

Ft_Gpu_CoCmd_Append (phost, 100000L, dloffset);

/ / אפס את מאפייני BITMAP בשימוש במהלך אנימציה לוגו

Ft_App_WrCoCmd_Buffer (phost, BITMAP_TRANSFORM_A (256));

Ft_App_WrCoCmd_Buffer (phost, BITMAP_TRANSFORM_A (256));

Ft_App_WrCoCmd_Buffer (פוסט, BITMAP_TRANSFORM_B (0));

Ft_App_WrCoCmd_Buffer (phost, BITMAP_TRANSFORM_C (0));

Ft_App_WrCoCmd_Buffer (פוסט, BITMAP_TRANSFORM_D (0));

Ft_App_WrCoCmd_Buffer (phost, BITMAP_TRANSFORM_E (256));

Ft_App_WrCoCmd_Buffer (phost, BITMAP_TRANSFORM_F (0));

/ / הצג את המידע עם לוגו שקוף באמצעות רצועת קצה

Ft_App_WrCoCmd_Buffer (phost, SAVE_CONTEXT ());

Ft_App_WrCoCmd_Buffer (פוסט, COLOR_RGB (219,180,150));

Ft_App_WrCoCmd_Buffer (פוסט, COLOR_A (220));

Ft_App_WrCoCmd_Buffer (phost, BEGIN (EDGE_STRIP_A));

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

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

Ft_App_WrCoCmd_Buffer (phost, COLOR_A (255));

Ft_App_WrCoCmd_Buffer (phost, RESTORE_CONTEXT ());

Ft_App_WrCoCmd_Buffer (פוסט, COLOR_RGB (0,0,0));

// מידע

Ft_Gpu_CoCmd_Text (phost, FT_DispWidth / 2,20,28, OPT_CENTERX | OPT_CENTERY, (char *) pgm_read_word (& info [0]));

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

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

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

Ft_Gpu_CoCmd_Text (phost, FT_DispWidth / 2, FT_DispHeight-30,26, OPT_CENTERX | OPT_CENTERY, "לחץ להפעלה");

// בדוק את מקש Play ושנה את הצבע

אם (sk! = 'P')

Ft_App_WrCoCmd_Buffer (פוסט, COLOR_RGB (255,255,255));

Other

Ft_App_WrCoCmd_Buffer (פוסט, COLOR_RGB (100,100,100));

Ft_App_WrCoCmd_Buffer (phost, BEGIN (FTPOINTS));

Ft_App_WrCoCmd_Buffer (פוסט, POINT_SIZE (20 * 16));

Ft_App_WrCoCmd_Buffer (פוסט, TAG ('P'));

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

Ft_App_WrCoCmd_Buffer (פוסט, COLOR_RGB (180,35,35));

Ft_App_WrCoCmd_Buffer (phost, BEGIN (BITMAPS));

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

Ft_App_WrCoCmd_Buffer (פוסט, DISPLAY ());

Ft_Gpu_CoCmd_Swap (phost);

Ft_App_Flush_Co_Buffer (phost);

(Fost);

} בעוד (Read_Keys ()! '' P ');

Ft_Play_Sound (0x50,255,0xc0);

/ * המתן עד שלא תלחץ על מקש Play * /

}


/ * התחל את Scroller * /

סטטית ft_void_t scroller_init (ft_uint32_t להגביל)

{

scroller.dragprev = -32768;

scroller.vel = 0; / / מהירות

scroller.base = 0; / / x x לתאם, ב 1/16 פיקסלים

scroller.limit = גבול;

}


/ * הפעל את Scroller ב אופקית linearlly * /


סטטי ft_void_t scroller_run ()

{

שינוי ft_int32_t;


חתום קצר sx = Ft_Gpu_Hal_Rd16 (phost, REG_TOUCH_SCREEN_XY + 2);


אם ((sx! = -32768) & (scroller.dragprev! = -32768))

{

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

}

Other

{

שינוי = מקסימום (1, ABS (scroller.vel) >> 5);

אם (scroller.vel <>

scroller.vel + = שינוי;

אם (scroller.vel> 0)

scroller.vel - = שינוי;

}

scroller.dragprev = sx;

scroller.base + = scroller.vel;

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

}


static ft_uint8_t clk_adj = 0;

static ft_uint16_t min_val;

ft_uint8_t temp [7];

/ * נתונים converstion עבור rtc * /

בייט decToBcd (בתים val)

{

החזרה ((val / 10 * 16) + (val% 10));

}


/ / המרת בינארי מקודד עשרוני למספרים עשרוניים רגילים

בתים bcdToDec (בתים val)

{

החזרה ((val / 16 * 10) + (val% 16));

}


/ * לכתוב את הנתונים לתוך RTC * /

Rtc_puts ריק ()

{

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

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

טמפ [2] = decToBcd (ist.Hrs);

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

}


/ / מקבל את התאריך והשעה

Rtc_gets ריק ()

{

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

ist.Hrs = bcdToDec (טמפ [2] & 0x1f);

ist.Mins = bcdToDec (טמפ [1] & 0x7f);

ist.Secs = bcdToDec (טמפ [0] & 0x7f);

}

/ * API המשמש לחשב את הזמן מערך סיבוב * /

static ft_uint16_t adj_time = 0;

static ft_uint32_t t_adj = 0;

static ft_uint16_t Get_TagRotary_Value (ft_uint16_t תגבל, טווח ft_uint16_t, ft_uint16_t max_rotation, ft_uint16_t ct) / -180I 90

{

ft_int32_t trackval = 0;

סטטי ft_int16_t thcurr = 0, prevth = 0, adj = 0;

סטטי ft_int32_t adj_val = 0;

static ft_uint16_t retval = 0;

trackval = Ft_Gpu_Hal_Rd32 (phost, REG_TRACKER);

אם (trackval)

{

thcurr = (trackval >> 16);

אם (adj == Tagval)

{

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

אם (adj_val <>

adj_val + = (max_rotation * 65536L);

אם (adj_val> = (max_rotation * 65536L))

adj_val - = (max_rotation * 65536L);

retval = (adj_val / (65536L / טווח));

}

prevth = thcurr;

adj = trackval & 0xff;

clk_adj = 0;

}

Other

{

אם (adj! = 0) clk_adj = 1;

מלבד retval = ct;

/ / הזמן הנוכחי ב 16bit presscion עבור ההתאמה

adj_val = ((ct / 60) * 65536L) + ((ct% 60) * (65536L / טווח));

adj = 0;

}

לחזור retval;

}

/ * api לחשב את הזמן הסטנדרטי עבור המדינות * /


טיימר ריק (ft_uint8_t שם)

{

static ft_uint8_t temp_time = 0;

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

st_ ft_uint16_t temp_m = 0, Hrs = 0;

st_ ft_uint16_t temp_msecs = 0, temp_secs = 0;

ft_uint32_t t;

ft_int32_t דקות;

Mins = gmt_prp [name] .gmin;

Hrs = gmt_prp [name] .ghr;

דקות = דקות + (שעות * 60);

אם (gmt_prp [name] .arith == '+')

דקות = min_val + דקות;

אם (gmt_prp [name] .arith == '-')

{

Mins = min_val-mins;

אם (דקות <>

דקות = 720 דקות;

}

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

utc.Mins = (mins)% 60;

/ * סינכרון RTC ו MCU זמן * /

#ifdef RTC_PRESENT

t = millis ();

t = t% 1000L;


אם (ist.Secs = timp_secs)

{

temp_secs = ist.Secs;

temp_msecs = 1000L-t;

}

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

#endif

// utc.Secs = ist.Secs;

/ * אם התאמת זמן מתרחש ואז כותב לתוך RTC * /

אם (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

}

}

בית סטטי סטטי ()

{

(Fost, REG_TOUCH_RAW_XY & 0x8000));

}

/ * שעון פונקציה * /

ft_void_t שעונים (ft_uint8_t clksize, ft_uint8_t אופציות)

{

ft_uint8_t

clk_s = clksize / 10, per_f, n_f, שם, תג, startup_time = 0;


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

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

temp_m, שעות;


ft_uint8_t col = FT_DispWidth / dx;

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

ft_int32_t רצועה, דקות, מהירות = 0;

per_f = col;

n_f = (COUNTRIES) / per_f;

Oy = (FT_DispHeight / 2);

scroller_init (16 * (COUNTRIES * (dx) -FT_DispWidth));

טיימר (0);

לעשות

{

תג = Ft_Gpu_Hal_Rd8 (פוסט, 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 (תג, 60,12, temp_m);

אם ((Ft_Gpu_Hal_Rd32 (phost, REG_TRACKER) & 0xff) == 0)

{

scroller_run ();


גרור = scroller.base >> 4;

cts = גרור / dx;

גרור = גרור% dx;

} אחר

{

scroller.vel = 0;

}

Ft_Gpu_CoCmd_Dlstart (פוסט);

Ft_App_WrCoCmd_Buffer (פוסט, CLEAR (1,1,1));

Ft_App_WrCoCmd_Buffer (פוסט, TAG_MASK (1));

Ft_App_WrCoCmd_Buffer (פוסט, TAG (0));

Ft_Gpu_CoCmd_Gradient (פוסט, 0, 135, 0x000000, 0, 272, 0x605040);

עבור (i = -1; i <(per_f +="" 2);="" i="" +="">

{

שור = (clksize + clk_s) + (dx * i);

Ox- = גרור;

שם = (COUNTRIES + i + cts)% COUNTRIES;

טיימר (שם);

/ / הגדרת צבע bg של השעונים

אם (תג == שם + 1) Ft_Gpu_CoCmd_BgColor (phost, 0x4040a0); Other

Ft_Gpu_CoCmd_BgColor (phost, 0x101040);

// צייר את השעונים עם גשש

Ft_App_WrCoCmd_Buffer (פוסט, TAG (שם + 1));

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

Ft_Gpu_CoCmd_Track (phost, ox, FT_DispHeight / 2,1,1, name + 1);

}

Ft_App_WrCoCmd_Buffer (פוסט, TAG_MASK (0));

// הצג את שם המדינה

עבור (i = -1; i <(per_f +="" 2);="" i="" +="">

{

שור = (clksize + clk_s) + (dx * i);

Ox- = גרור;

שם = (COUNTRIES + i + cts)% COUNTRIES;

Ft_Gpu_CoCmd_Text (phost, Ox, dy, 29, OPT_CENTERX, country [name]);

}

אם (scroller.vel! = 0) מהירות = scroller.vel;

Ft_App_WrCoCmd_Buffer (פוסט, DISPLAY ());

Ft_Gpu_CoCmd_Swap (phost);

Ft_App_Flush_Co_Buffer (phost);

(Fost);

#if מוגדר FT_801_ENABLE

Ft_Gpu_Hal_Sleep (30);

#endif

} בעוד (1);

}

#ifdef MSVC_PLATFORM

/ * נקודת כניסה ראשית * /

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

#endif

#ifdef ARDUINO_PLATFORM

ft_void_t setup ()

#endif

{

/ * משתנים מקומיים * /

ft_uint8_t chipid;


Ft_Gpu_HalInit_t הליניט;


halinit.TotalChannelNum = 1;

Ft_Gpu_Hal_Init (& הליניט);

host.hal_config.channel_no = 0;

#ifdef MSVC_PLATFORM_SPI

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

#endif

#ifdef ARDUINO_PLATFORM_SPI

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

#endif

Ft_Gpu_Hal_Open (ומארח);


phost = & host;


/ * האם מחזור כוח עבור צד בטוח יותר * /

Ft_Gpu_Hal_Powercycle (phost, FT_TRUE);

Ft_Gpu_Hal_Rd16 (פוסט, RAM_G);

/ * להגדיר את clk לשעון חיצוני * /

Ft_Gpu_HostCommand (phost, FT_GPU_EXTERNAL_OSC);

Ft_Gpu_Hal_Sleep (10);



/ * מעבר פלט PLL ל 48MHz * /

Ft_Gpu_HostCommand (phost, FT_GPU_PLL_48M);

Ft_Gpu_Hal_Sleep (10);


/ * האם איפוס הליבה עבור צד בטוח יותר * /

Ft_Gpu_HostCommand (phost, FT_GPU_CORE_RESET);

// Ft_Gpu_CoreReset (phost);


/ * גישה כתובת 0 כדי להעיר את FT800 * /

Ft_Gpu_HostCommand (phost, FT_GPU_ACTIVE_M);


{

// קרא את מזהה הרשם כדי לבדוק אם FT800 מוכן.

chipid = Ft_Gpu_Hal_Rd8 (phost, REG_ID);

בעוד (שבץ! 0x7C)

chipid = Ft_Gpu_Hal_Rd8 (phost, REG_ID);

#ifdef MSVC_PLATFORM

printf ("מזהה רישום VC1 לאחר התעוררות% x", שבב);

#endif

}

/ * תצורה של תצוגת LCD * /

#ifdef SAMAPP_DISPLAY_QVGA

/ * ערכים ספציפיים תצוגת LCD QVGA * /

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 (phost, REG_HCYCLE, FT_DispHCycle);

Ft_Gpu_Hal_Wr16 (phost, REG_HOFFSET, FT_DispHOffset);

Ft_Gpu_Hal_Wr16 (phost, REG_HSYNC0, FT_DispHSync0);

Ft_Gpu_Hal_Wr16 (phost, REG_HSYNC1, FT_DispHSync1);

Ft_Gpu_Hal_Wr16 (phost, REG_VCYCLE, FT_DispVCycle);

Ft_Gpu_Hal_Wr16 (phost, REG_VOFFSET, FT_DispVOffset);

Ft_Gpu_Hal_Wr16 (phost, REG_VSYNC0, FT_DispVSync0);

Ft_Gpu_Hal_Wr16 (phost, REG_VSYNC1, FT_DispVSync1);

Ft_Gpu_Hal_Wr8 (phost, REG_SWIZZLE, FT_DispSwizzle);

Ft_Gpu_Hal_Wr8 (phost, REG_PCLK_POL, FT_DispPCLKPol);

Ft_Gpu_Hal_Wr8 (phost, REG_PCLK, FT_DispPCLK); // לאחר תצוגה זו גלויה ב- LCD

Ft_Gpu_Hal_Wr16 (phost, REG_HSIZE, FT_DispWidth);

Ft_Gpu_Hal_Wr16 (phost, REG_VSIZE, FT_DispHeight);


/ * בתחילה למלא גם פינג חיץ פונג * / /

Ft_Gpu_Hal_Wr8 (phost, REG_GPIO_DIR, 0xff);

Ft_Gpu_Hal_Wr8 (phost, REG_GPIO, 0x0ff);

/ * מגע תצורה - להגדיר את ערך ההתנגדות ל 1200 - ערך זה הוא ספציפי לדרישת הלקוח נגזר על ידי הניסוי * /

Ft_Gpu_Hal_Wr16 (phost, REG_TOUCH_RZTHRESH, 1200);




/ * זה אופציונלי כדי לנקות את המסך כאן * /

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

Ft_Gpu_Hal_Wr8 (phost, REG_DLSWAP, DLSWAP_FRAME);


Ft_Gpu_Hal_Sleep (1000); // הצג את מסך האתחול כלפי מעלה.

#ifdef RTC_PRESENT

hal_rtc_i2c_init ();

בתים WriteByte = 0x03;

hal_rtc_i2c_write (0x07, & WriteByte, 1);

hal_rtc_i2c_read (0x00, & WriteByte, 1);

אם ((WriteByte & 0x80) == 0)

{

WriteByte = 0x80;

hal_rtc_i2c_write (0x00, & WriteByte, 1);

}

#endif


home_setup ();

פרטי ();

שעונים (80,0);

/ * סגור את כל הידיות פתוחות * /

Ft_Gpu_Hal_Close (phost);

Ft_Gpu_Hal_DeInit ();

#ifdef MSVC_PLATFORM

Return 0;

#endif

}


לולאה חלל ()

{

}



/ * שום דבר מעבר לכך * /