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

FT_Gpu_Hal.cpp

May 06, 2019

#include "FT_Platform.h"



/ * API כדי לאתחל את ממשק SPI * /

ft_bool_t Ft_Gpu_Hal_Init (Ft_Gpu_HalInit_t * הליניט)

{

#ifdef ARDUINO_PLATFORM_SPI

pinMode (FT_ARDUINO_PRO_SPI_CS, OUTPUT);

pinMode (FT800_PD_N, OUTPUT);

DigitalWrite (FT_ARDUINO_PRO_SPI_CS, HIGH);

DigitalWrite (FT800_PD_N, HIGH);

#endif

#ifdef MSVC_PLATFORM_SPI

/ * אתחול libmpsse * /

Init_libMPSSE ();

SPI_GetNumChannels (& halinit-> TotalChannelNum);

/ * כברירת מחדל אני מניח רק כבל mpsse אחד מחובר למחשב וערוץ 0 של כבל mpsse זה משמש עסקאות spi * /

אם (halinit-> TotalChannelNum> 0)

{

FT_DEVICE_LIST_INFO_NODE devList;

SPI_GetChannelInfo (0, & devList);

printf ("מידע על מספר ערוץ% d:", 0);

/ * להדפיס את פרטי dev * /

printf ("דגלים = 0x% x", devList.Flags);

printf ("Type = 0x% x", devList.Type);

printf ("ID = 0x% x", devList.ID);

printf ("LocId = 0x% x", devList.LocId);

printf ("SerialNumber =% s", devList.SerialNumber);

printf ("תיאור =% s", devList.Description);

printf ("ftHandle = 0x% x", devList.ftHandle); / * הוא 0 אלא אם כן פתוח * /

}

#endif

חזור TRUE;

}

ft_bool_t Ft_Gpu_Hal_Open (Ft_Gpu_Hal_Context_t * מארח)

{

#ifdef ARDUINO_PLATFORM_SPI

SPI.begin ();

SPI.setClockDivider (SPI_CLOCK_DIV2);

SPI.setBitOrder (MSBFIRST);

SPI.setDataMode (SPI_MODE0);

#endif

#ifdef MSVC_PLATFORM_SPI

ChannelConfig channelConf; // ערוץ הערוץ

סטטוס FT_STATUS;

/ * להגדיר את הגדרות spi * /

channelConf.ClockRate = host-> hal_config.spi_clockrate_khz * 1000;

channelConf.LatencyTimer = 2;

channelConf.configOptions = SPI_CONFIG_OPTION_MODE0 | SPI_CONFIG_OPTION_CS_DBUS3 | SPI_CONFIG_OPTION_CS_ACTIVELOW;

channelConf.Pin = 0x00000000; / * FinalVal-FinalDir-InitVal-InitDir (עבור dir 0 = ב, 1 = החוצה) * /


/ * פתח את הערוץ הזמין הראשון * /

SPI_OpenChannel (host-> hal_config.channel_no, (FT_HANDLE *) & מארח -> hal_handle);

מצב = SPI_InitChannel ((FT_HANDLE) host-> hal_handle, & channelConf);

printf ("ידית = 0x% x מצב = 0x% x", host -> hal_handle, status);

#endif

host -> ft_cmd_fifo_wp = host-> ft_dl_buff_wp = 0;

host -> status = FT_GPU_HAL_OPENED;

חזור TRUE;

}

ft_void_t Ft_Gpu_Hal_Close (Ft_Gpu_Hal_Context_t * מארח)

{

host -> status = FT_GPU_HAL_CLOSED;

#ifdef MSVC_PLATFORM_SPI

/ * סגור את הערוץ * /

SPI_CloseChannel (host-> hal_handle);

#endif

#ifdef ARDUINO_PLATFORM_SPI

SPI.end ();

#endif

}

ft_void_t Ft_Gpu_Hal_DeInit ()

{

#ifdef MSVC_PLATFORM_SPI

/ ניקוי MPSSE ליב

Cleanup_libMPSSE ();

#endif

}


/ * APIs לקריאה / כתיבה העברה ברציפות רק עם מערכת חיץ קטן * /

ft_void_t Ft_Gpu_Hal_StartTransfer (Ft_Gpu_Hal_Context_t * מארח, FT_GPU_TRANSFERDIR_T rw, ft_uint32_t addr)

{

אם (FT_GPU_READ == rw) {


#ifdef MSVC_PLATFORM_SPI

ft_uint8_t Transfer_Array [4];

ft_uint32_t גודל ההעברה;


/ * לחבר את מנות הקריאה * /

Transfer_Array [0] = addr >> 16;

Transfer_Array [1] = addr >> 8;

Transfer_Array [2] = addr;


Transfer_Array [3] = 0; // דומם לקרוא בתים

SPI_Write (מארח FT_HANDLE) -> hal_handle, Transfer_Array, sizeof (Transfer_Array), & SizeTransfered, SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES | SPI_TRANSFER_OPTIONS_CHIPSELECT_ENABLE);

#endif

#ifdef ARDUINO_PLATFORM_SPI

DigitalWrite (FT_ARDUINO_PRO_SPI_CS, LOW);

SPI.transfer (Addr >> 16);

SPI.transfer (highByte (addr));

SPI.transfer (lowByte (addr));


SPI.transfer (0); // דמה לקרוא בייט

#endif

host -> status = FT_GPU_HAL_READING;

} else

#ifdef MSVC_PLATFORM_SPI

ft_uint8_t Transfer_Array [3];

ft_uint32_t גודל ההעברה;


/ * לחבר את מנות הקריאה * /

Transfer_Array [0] = (0x80 | (addr >> 16));

Transfer_Array [1] = addr >> 8;

Transfer_Array [2] = addr;

SPI_Write (מארח FT_HANDLE) -> hal_handle, Transfer_Array, 3, & SizeTransfered, SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES | SPI_TRANSFER_OPTIONS_CHIPSELECT_ENABLE);

#endif

#ifdef ARDUINO_PLATFORM_SPI

DigitalWrite (FT_ARDUINO_PRO_SPI_CS, LOW);

SPI.transfer (0x80 (Addr >> 16));

SPI.transfer (highByte (addr));

SPI.transfer (lowByte (addr));

#endif

host -> status = FT_GPU_HAL_WRITING;

}

}

/ * APIs לכתיבת העברה רציפה בלבד * /

ft_void_t Ft_Gpu_Hal_StartCmdTransfer (Ft_Gpu_Hal_Context_t * מארח, FT_GPU_TRANSFERDIR_T rw, ft_uint16_t count)

{

Ft_Gpu_Hal_StartTransfer (מארח, rw, host-> ft_cmd_fifo_wp + RAM_CMD);

}


ft_uint8_t Ft_Gpu_Hal_TransferString (Ft_Gpu_Hal_Context_t * מארח, const ft_char8_t * string)

{

ft_uint16_t length = strlen (string);

בעוד (length -) {

Ft_Gpu_Hal_Transfer8 (host, * string);

מחרוזת ++;

}

/ / צרף ריק אחד כמו דגל הסיום

Ft_Gpu_Hal_Transfer8 (host, 0);

}

ft_uint8_t Ft_Gpu_Hal_Transfer8 (Ft_Gpu_Hal_Context_t * ערך מארח, ft_uint8_t)

{

#ifdef ARDUINO_PLATFORM_SPI

החזרת SPI.transfer (ערך);

#endif

#ifdef MSVC_PLATFORM_SPI

ft_uint32_t גודל ההעברה;

אם (host-> סטטוס == FT_GPU_HAL_WRITING) {

SPI_Write (host-> hal_handle, & value, sizeof (value), & SizeTransfered, SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES);

} else

SPI_Read (host-> hal_handle, & value, sizeof (value), & SizeTransfered, SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES);

}


אם (SizeTransfered! = sizeof (ערך))

host -> status = FT_GPU_HAL_STATUS_ERROR;

ערך החזרה;

#endif

}


ft_uint16_t Ft_Gpu_Hal_Transfer16 (Ft_Gpu_Hal_Context_t * ערך מארח, ft_uint16_t)

{

ft_uint16_t retVal = 0;


אם (host-> סטטוס == FT_GPU_HAL_WRITING) {

Ft_Gpu_Hal_Transfer8 (מארח, ערך & 0xFF); // LSB תחילה

Ft_Gpu_Hal_Transfer8 (מארח, (ערך >> 8) & 0xFF);

} else

retVal = Ft_Gpu_Hal_Transfer8 (host, 0);

retVal | = (ft_uint16_t) Ft_Gpu_Hal_Transfer8 (host, 0) <>

}


לחזור retVal;

}

ft_uint32_t Ft_Gpu_Hal_Transfer32 (Ft_Gpu_Hal_Context_t * ערך מארח, ft_uint32_t)

{

ft_uint32_t retVal = 0;

אם (host-> סטטוס == FT_GPU_HAL_WRITING) {

Ft_Gpu_Hal_Transfer16 (host, value & 0xFFFF); // LSB תחילה

Ft_Gpu_Hal_Transfer16 (מארח, (ערך >> 16) & 0xFFFF);

} else

retVal = Ft_Gpu_Hal_Transfer16 (host, 0);

retVal | = (ft_uint32_t) Ft_Gpu_Hal_Transfer16 (host, 0) <>

}

לחזור retVal;

}


ft_void_t Ft_Gpu_Hal_EndTransfer (Ft_Gpu_Hal_Context_t * מארח)

{

#ifdef MSVC_PLATFORM_SPI

/ / פשוט disbale CS - לשלוח 0 בתים עם CS לנטרל

SPI_ToggleCS ((FT_HANDLE) host-> hal_handle, FALSE);

#endif

#ifdef ARDUINO_PLATFORM_SPI

DigitalWrite (FT_ARDUINO_PRO_SPI_CS, HIGH);

#endif

host -> status = FT_GPU_HAL_OPENED;

}

ft_uint8_t Ft_Gpu_Hal_Rd8 (Ft_Gpu_Hal_Context_t * host, ft_uint32_t addr)

{

ft_uint8_t ערך;

(FT_GPU_READ, Addr);

value = Ft_Gpu_Hal_Transfer8 (host, 0);

Ft_Gpu_Hal_EndTransfer (מארח);

ערך החזרה;

}

ft_uint16_t Ft_Gpu_Hal_Rd16 (Ft_Gpu_Hal_Context_t * host, ft_uint32_t addr)

{

ft_uint16_t ערך;

(FT_GPU_READ, Addr);

value = Ft_Gpu_Hal_Transfer16 (host, 0);

Ft_Gpu_Hal_EndTransfer (מארח);

ערך החזרה;

}

ft_uint32_t Ft_Gpu_Hal_Rd32 (Ft_Gpu_Hal_Context_t * host, ft_uint32_t addr)

{

ft_uint32_t ערך;

(FT_GPU_READ, Addr);

value = Ft_Gpu_Hal_Transfer32 (host, 0);

Ft_Gpu_Hal_EndTransfer (מארח);

ערך החזרה;

}

ft_void_t Ft_Gpu_Hal_Wr8 (Ft_Gpu_Hal_Context_t * host, ft_uint32_t addr, ft_uint8_t v)

{

(FT_GPU_WRITE, Addr);

Ft_Gpu_Hal_Transfer8 (מארח, v);

Ft_Gpu_Hal_EndTransfer (מארח);

}

ft_void_t Ft_Gpu_Hal_Wr16 (Ft_Gpu_Hal_Context_t * host, ft_uint32_t addr, ft_uint16_t v)

{

(FT_GPU_WRITE, Addr);

Ft_Gpu_Hal_Transfer16 (מארח, v);

Ft_Gpu_Hal_EndTransfer (מארח);

}

ft_void_t Ft_Gpu_Hal_Wr32 (Ft_Gpu_Hal_Context_t * host, ft_uint32_t addr, ft_uint32_t v)

{

(FT_GPU_WRITE, Addr);

Ft_Gpu_Hal_Transfer32 (מארח, v);

Ft_Gpu_Hal_EndTransfer (מארח);

}

ft_void_t Ft_Gpu_HostCommand (Ft_Gpu_Hal_Context_t * מארח, ft_uint8_t cmd)

{

#ifdef MSVC_PLATFORM_SPI

ft_uint8_t Transfer_Array [3];

ft_uint32_t גודל ההעברה;


Transfer_Array [0] = cmd;

Transfer_Array [1] = 0;

Transfer_Array [2] = 0;


SPI_Write (host-> hal_handle, Transfer_Array, sizeof (Transfer_Array), & SizeTransfered, SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES | SPI_TRANSFER_OPTIONS_CHIPSELECT_ENABLE | SPI_TRANSFER_OPTIONS_CHIPSELECT_DISABLE);

#endif

#ifdef ARDUINO_PLATFORM_SPI

DigitalWrite (FT_ARDUINO_PRO_SPI_CS, LOW);

SPI.transfer (cmd);

SPI.transfer (0);

SPI.transfer (0);

DigitalWrite (FT_ARDUINO_PRO_SPI_CS, HIGH);

#endif

}

ft_void_t Ft_Gpu_ClockSelect (Ft_Gpu_Hal_Context_t * מארח, FT_GPU_PLL_SOURCE_T pllsource)

{

Ft_Gpu_HostCommand (מארח, pllsource);

}

ft_void_t Ft_Gpu_PLL_FreqSelect (Ft_Gpu_Hal_Context_t * מארח, FT_GPU_PLL_FREQ_T freq)

{

Ft_Gpu_HostCommand (מארח, freq);

}

ft_void_t Ft_Gpu_PowerModeSwitch (Ft_Gpu_Hal_Context_t * מארח, FT_GPU_POWER_MODE_T pwrmode)

{

Ft_Gpu_HostCommand (מארח, pwrmode);

}

ft_void_t Ft_Gpu_CoreReset (Ft_Gpu_Hal_Context_t * מארח)

{

Ft_Gpu_HostCommand (מארח, 0x68);

}

ft_void_t Ft_Gpu_Hal_Updatecmdfifo (Ft_Gpu_Hal_Context_t * host, ft_uint16_t count)

{

host -> ft_cmd_fifo_wp = (host-> ft_cmd_fifo_wp + count) & 4095;


// יישור 4 בתים

host-> ft_cmd_fifo_wp = (host-> ft_cmd_fifo_wp + 3) & 0xffc;

Ft_Gpu_Hal_Wr16 (מארח, REG_CMD_WRITE, host -> ft_cmd_fifo_wp);

}



ft_uint16_t Ft_Gpu_Cmdfifo_Freespace (Ft_Gpu_Hal_Context_t * מארח)

{

ft_uint16_t מלאות, retval;


מלאות = (host-> ft_cmd_fifo_wp - Ft_Gpu_Hal_Rd16 (מארח, REG_CMD_READ)) & 4095;

retval = (FT_CMD_FIFO_SIZE - 4) - מלאות;

החזרה (retval);

}

ft_void_t Ft_Gpu_Hal_WrCmdBuf (Ft_Gpu_Hal_Context_t * host, ft_uint8_t * buffer, ft_uint16_t count)

{

ft_uint32_t length = 0, SizeTransfered = 0;


#define MAX_CMD_FIFO_TRANSFER Ft_Gpu_Cmdfifo_Freespace (מארח)

לעשות {

אורך = לספור;

אם (length> MAX_CMD_FIFO_TRANSFER) {

אורך = MAX_CMD_FIFO_TRANSFER;

}

Ft_Gpu_Hal_CheckCmdBuffer (מארח, אורך);


(FT_GPU_WRITE, אורך);


#ifdef ARDUINO_PLATFORM_SPI

גודל Transfered = 0;

בעוד (אורך--) {

Ft_Gpu_Hal_Transfer8 (מארח, * מאגר);

מאגר + +;

גודל Transfered ++;

}

אורך = גודל Transfered;

#endif

#ifdef MSVC_PLATFORM_SPI

{

SPI_Write (host-> hal_handle, מאגר, אורך, & גודל Transfered, SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES);

אורך = גודל Transfered;

מאגר + גודל = העברה;

}

#endif


Ft_Gpu_Hal_EndTransfer (מארח);

Ft_Gpu_Hal_Updatecmdfifo (מארח, אורך);


Ft_Gpu_Hal_WaitCmdfifo_empty (מארח);


count - 3,000

} בעוד (count> 0);

}

ft_void_t Ft_Gpu_Hal_WrCmdBuf_nowait (Ft_Gpu_Hal_Context_t * host, ft_uint8_t * buffer, ft_uint16_t count)

{

ft_uint32_t length = 0, SizeTransfered = 0;


#define MAX_CMD_FIFO_TRANSFER Ft_Gpu_Cmdfifo_Freespace (מארח)


לעשות {

אורך = לספור;

אם (length> MAX_CMD_FIFO_TRANSFER) {

אורך = MAX_CMD_FIFO_TRANSFER;

}

Ft_Gpu_Hal_CheckCmdBuffer (מארח, אורך);


(FT_GPU_WRITE, אורך);


#ifdef ARDUINO_PLATFORM_SPI

גודל Transfered = 0;

בעוד (אורך--) {

Ft_Gpu_Hal_Transfer8 (מארח, * מאגר);

מאגר + +;

גודל Transfered ++;

}

אורך = גודל Transfered;

#endif


#ifdef MSVC_PLATFORM_SPI

{

SPI_Write (host-> hal_handle, מאגר, אורך, & גודל Transfered, SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES);

אורך = גודל Transfered;

מאגר + גודל = העברה;

}

#endif


Ft_Gpu_Hal_EndTransfer (מארח);

Ft_Gpu_Hal_Updatecmdfifo (מארח, אורך);

count - 3,000

} בעוד (count> 0);

}

#ifdef ARDUINO_PLATFORM_SPI

ft_void_t Ft_Gpu_Hal_WrCmdBufFromFlash (Ft_Gpu_Hal_Context_t * מארח, FT_PROGMEM ft_prog_uchar8_t * buffer, ft_uint16_t count)

{

ft_uint32_t length = 0, SizeTransfered = 0;


#define MAX_CMD_FIFO_TRANSFER Ft_Gpu_Cmdfifo_Freespace (מארח)

לעשות {

אורך = לספור;

אם (length> MAX_CMD_FIFO_TRANSFER) {

אורך = MAX_CMD_FIFO_TRANSFER;

}

Ft_Gpu_Hal_CheckCmdBuffer (מארח, אורך);


(FT_GPU_WRITE, אורך);



גודל Transfered = 0;

בעוד (אורך--) {

Ft_Gpu_Hal_Transfer8 (מארח, ft_pgm_read_byte_near (מאגר));

מאגר + +;

גודל Transfered ++;

}

אורך = גודל Transfered;


Ft_Gpu_Hal_EndTransfer (מארח);

Ft_Gpu_Hal_Updatecmdfifo (מארח, אורך);


Ft_Gpu_Hal_WaitCmdfifo_empty (מארח);


count - 3,000

} בעוד (count> 0);

}

#endif

ft_void_t Ft_Gpu_Hal_CheckCmdBuffer (Ft_Gpu_Hal_Context_t * host, ft_uint16_t count)

{

ft_uint16_t getfreespace;

לעשות {

getfreespace = Ft_Gpu_Cmdfifo_Freespace (host);

} בעוד (getfreespace <>

}

ft_pu_Hal_Context_t * מארח)

{

בעוד (Ft_Gpu_Hal_Rd16 (מארח, REG_CMD_READ)! = Ft_Gpu_Hal_Rd16 (מארח, REG_CMD_WRITE));

host -> ft_cmd_fifo_wp = Ft_Gpu_Hal_Rd16 (מארח, REG_CMD_WRITE);

}


ft_uint8_t Ft_Gpu_Hal_WaitCmdfifo_empty_status (Ft_Gpu_Hal_Context_t * מארח)

{

אם (Ft_Gpu_Hal_Rd16 (מארח, REG_CMD_READ)! = Ft_Gpu_Hal_Rd16 (מארח, REG_CMD_WRITE))

{

Return 0;

}

Other

{

host -> ft_cmd_fifo_wp = Ft_Gpu_Hal_Rd16 (מארח, REG_CMD_WRITE);

Return 1;

}

}


ft_void_t Ft_Gpu_Hal_WaitLogo_Finish (Ft_Gpu_Hal_Context_t * מארח)

{

ft_int16_t cmdrdptr, cmdwrptr;


לעשות {

cmdrdptr = Ft_Gpu_Hal_Rd16 (מארח, REG_CMD_READ);

cmdwrptr = Ft_Gpu_Hal_Rd16 (מארח, REG_CMD_WRITE);

} בעוד (cmdwrptr! = cmdrdptr) || (cmdrdptr! = 0));

host -> ft_cmd_fifo_wp = 0;

}



ft_pu_Hal_Context_t * מארח)

{

host -> ft_cmd_fifo_wp = 0;

}



ft_void_t Ft_Gpu_Hal_WrCmd32 (Ft_Gpu_Hal_Context_t * host, ft_uint32_t cmd)

{

Ft_Gpu_Hal_CheckCmdBuffer (מארח, sizeof (cmd));

Ft_Gpu_Hal_Wr32 (מארח, RAM_CMD + host-> ft_cmd_fifo_wp, cmd);

Ft_Gpu_Hal_Updatecmdfifo (מארח, sizeof (cmd));

}

ft_void_t Ft_Gpu_Hal_ResetDLBuffer (Ft_Gpu_Hal_Context_t * מארח)

{

host -> ft_dl_buff_wp = 0;

}

/ * החלפת PD_N פינים של לוח FT800 עבור מחזור כוח * /

ft_void_t Ft_Gpu_Hal_Powercycle (Ft_Gpu_Hal_Context_t * host, ft_bool_t up)

{

אם (למעלה)

{

#ifdef MSVC_PLATFORM

FT_WriteGPIO (Host-> hal_handle, 0xBB, 0x08); / PDN מוגדר 0, לחבר חוט כחול של MPSSE ל PDN # של לוח FT800

Ft_Gpu_Hal_Sleep (20);


FT_WriteGPIO (host-> hal_handle, 0xBB, 0x88); // PDN מוגדר ל- 1

Ft_Gpu_Hal_Sleep (20);

#endif

#ifdef ARDUINO_PLATFORM

DigitalWrite (FT800_PD_N, LOW);

Ft_Gpu_Hal_Sleep (20);


DigitalWrite (FT800_PD_N, HIGH);

Ft_Gpu_Hal_Sleep (20);

#endif

} אחר

{

#ifdef MSVC_PLATFORM

FT_WriteGPIO (host-> hal_handle, 0xBB, 0x88); // PDN מוגדר ל- 1

Ft_Gpu_Hal_Sleep (20);

FT_WriteGPIO (Host-> hal_handle, 0xBB, 0x08); / PDN מוגדר 0, לחבר חוט כחול של MPSSE ל PDN # של לוח FT800

Ft_Gpu_Hal_Sleep (20);

#endif

#ifdef ARDUINO_PLATFORM

DigitalWrite (FT800_PD_N, HIGH);

Ft_Gpu_Hal_Sleep (20);

DigitalWrite (FT800_PD_N, LOW);

Ft_Gpu_Hal_Sleep (20);

#endif

}

}

ft_void_t Ft_Gpu_Hal_WrMemFromFlash (Ft_Gpu_Hal_Context_t * host, ft_uint32_t addr, const ft_prog_uchar8_t * buffer, ft_uint32_t length)

{

ft_uint32_t SizeTransfered = 0;


(FT_GPU_WRITE, Addr);


#ifdef ARDUINO_PLATFORM

בעוד (אורך--) {

Ft_Gpu_Hal_Transfer8 (מארח, ft_pgm_read_byte_near (מאגר));

מאגר + +;

}

#endif


#ifdef MSVC_PLATFORM_SPI

{

SPI_Write ((FT_HANDLE) host -> hal_handle, מאגר, אורך, & גודל Transfered, SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES);

}

#endif



Ft_Gpu_Hal_EndTransfer (מארח);

}


ft_void_t Ft_Gpu_Hal_WrMem (Ft_Gpu_Hal_Context_t * host, ft_uint32_t addr, const ft_uint8_t * buffer, ft_uint32_t length)

{

ft_uint32_t SizeTransfered = 0;


(FT_GPU_WRITE, Addr);


#ifdef ARDUINO_PLATFORM

בעוד (אורך--) {

Ft_Gpu_Hal_Transfer8 (מארח, * מאגר);

מאגר + +;

}

#endif


#ifdef MSVC_PLATFORM_SPI

{

SPI_Write ((FT_HANDLE) host -> hal_handle, מאגר, אורך, & גודל Transfered, SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES);

}

#endif



Ft_Gpu_Hal_EndTransfer (מארח);

}



ft_void_t Ft_Gpu_Hal_RdMem (Ft_Gpu_Hal_Context_t * host, ft_uint32_t addr, ft_uint8_t * buffer, ft_uint32_t length)

{

ft_uint32_t SizeTransfered = 0;


(FT_GPU_READ, Addr);


#ifdef ARDUINO_PLATFORM

בעוד (אורך--) {

* buffer = Ft_Gpu_Hal_Transfer8 (host, 0);

מאגר + +;

}

#endif


#ifdef MSVC_PLATFORM_SPI

{

SPI_Read ((FT_HANDLE) host -> hal_handle, מאגר, אורך, & גודל Transfered, SPI_TRANSFER_OPTIONS_SIZE_IN_BYTES);

}

#endif


Ft_Gpu_Hal_EndTransfer (מארח);

}


ft_int32_t Ft_Gpu_Hal_Dec2Ascii (ft_char8_t * ערך pSrc, ft_int32_t)

{

ft_int16_t אורך;

ft_char8_t * pdst, charval;

ft_int32_t CurrVal = value, tmpval, i;

ft_char8_t tmparray [16], idx = 0;


אורך = strlen (pSrc);

pdst = pSrc + אורך;


אם (0 == ערך)

{

* pdst ++ = '0';

* pdst ++ = '';

Return 0;

}


אם (CurrVal <>

{

* pdst ++ = '-';

CurrVal = - CurrVal;

}

/ * הכנס את הערך * /

בעוד (CurrVal> 0) {

tmpval = CurrVal;

CurrVal / = 10;

tmpval = tmpval - CurrVal * 10;

charval = '0' + tmpval;

tmparray [idx ++] = charval;

}


עבור (i = 0; i

{

* pdst ++ = tmparray [idx - i - 1];

}

* pdst ++ = '';


Return 0;

}


ft_void_t Ft_Gpu_Hal_Sleep (ft_uint16_t ms)

{

#ifdef MSVC_PLATFORM

שינה (ms);

#endif

#ifdef ARDUINO_PLATFORM

עיכוב (אלפיות השנייה);

#endif

}