Detailed Description

Module to build a uniform abstraction layer between uGFX and the underlying system.

Note: Some of the routines specified below may be implemented simply as a macro to the real operating system call.

Data Structures
struct	gSem
	A semaphore. More...

struct	gMutex
	A mutex. More...

Functions
void	gfxHalt (const char *msg)
	Halt the GFX application due to an error. More...

void	gfxExit (void)
	Exit the GFX application. More...

void *	gfxAlloc (gMemSize sz)
	Allocate memory. More...

void *	gfxRealloc (void *ptr, gMemSize oldsz, gMemSize newsz)
	Re-allocate memory. More...

void	gfxFree (void *ptr)
	Free memory. More...

void	gfxYield (void)
	Yield the current thread. More...

void	gfxSleepMilliseconds (gDelay ms)
	Put the current thread to sleep for the specified period in milliseconds. More...

void	gfxSleepMicroseconds (gDelay us)
	Put the current thread to sleep for the specified period in microseconds. More...

gTicks	gfxSystemTicks (void)
	Get the current operating system tick time. More...

gTicks	gfxMillisecondsToTicks (gDelay ms)
	Convert a given number of millseconds to a number of operating system ticks. More...

void	gfxSystemLock (void)
	Lock the operating system to protect a sequence of code. More...

void	gfxSystemUnlock (void)
	Unlock the operating system previous locked by gfxSystemLock() More...

void	gfxMutexInit (gMutex *pmutex)
	Initialise a mutex to protect a region of code from other threads. More...

void	gfxMutexDestroy (gMutex *pmutex)
	Destroy a Mutex. More...

void	gfxMutexEnter (gMutex *pmutex)
	Enter the critical code region protected by the mutex. More...

void	gfxMutexExit (gMutex *pmutex)
	Exit the critical code region protected by the mutex. More...

void	gfxSemInit (gSem *psem, gSemcount val, gSemcount limit)
	Initialise a Counted Semaphore. More...

void	gfxSemDestroy (gSem *psem)
	Destroy a Counted Semaphore. More...

gBool	gfxSemWait (gSem *psem, gDelay ms)
	Wait on a semaphore. More...

gBool	gfxSemWaitI (gSem *psem)
	Test if a wait on a semaphore can be satisfied immediately. More...

void	gfxSemSignal (gSem *psem)
	Signal a semaphore. More...

void	gfxSemSignalI (gSem *psem)
	Signal a semaphore. More...

gThread	gfxThreadCreate (void stackarea, gMemSize stacksz, gThreadpriority prio, GFX_THREAD_FUNCTION((fn), p), void *param)
	Start a new thread. More...

gThreadreturn	gfxThreadWait (gThread thread)
	Wait for a thread to finish. More...

gThread	gfxThreadMe (void)
	Get the current thread handle. More...

void	gfxThreadClose (gThread thread)
	Close the thread handle. More...

Various integer sizes
Note Your platform may define these differently to these. These sizes are guaranteed minimum sizes for the type. It might actually be larger. eg gI8 may actually be 9 bits.
typedef unsigned char	gBool

typedef signed char	gI8

typedef unsigned char	gU8

typedef short	gI16

typedef unsigned short	gU16

typedef long	gI32

typedef unsigned long	gU32

More integer sizes
Precondition These are only available if GFX_TYPE_64 is GFXON as not all compilers support 64 bit. Note GFX_TYPE_64 is set to GFXON or GFXOFF by the compiler detector. It is not a user configuration macro.
typedef long long	gI64

typedef unsigned long long	gU64

Various platform (and operating system) dependent types
Note Your platform may use slightly different definitions to these
typedef unsigned long	gDelay

typedef unsigned long	gTicks

typedef short	gSemcount

typedef int	gThreadreturn

typedef int	gThreadpriority

Various platform (and operating system) constants
Note Your platform may use slightly different definitions to these
#define	gDelayNone 0

#define	gDelayForever ((gDelay)-1)

#define	gSemMaxCount ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))

#define	gThreadpriorityLow 0

#define	gThreadpriorityNormal 1

#define	gThreadpriorityHigh 2

The operating system to use. One (and only one) of these must be defined.
#define	GFX_USE_OS_CHIBIOS GFXOFF
	Use ChibiOS. More...

#define	GFX_USE_OS_FREERTOS GFXOFF
	Use FreeRTOS. More...

#define	GFX_USE_OS_WIN32 GFXOFF
	Use Win32. More...

#define	GFX_USE_OS_LINUX GFXOFF
	Use a linux based system running X11. More...

#define	GFX_USE_OS_OSX GFXOFF
	Use a Mac OS-X based system. More...

#define	GFX_USE_OS_RAW32 GFXOFF
	Use a Raw 32-bit CPU based system (Bare Metal) More...

#define	GFX_USE_OS_ECOS GFXOFF
	Use a eCos. More...

#define	GFX_USE_OS_RAWRTOS GFXOFF
	Use RAWRTOS. More...

#define	GFX_USE_OS_ARDUINO GFXOFF
	Use Arduino. More...

#define	GFX_USE_OS_CMSIS GFXOFF
	Use CMSIS RTOS compatible OS. More...

#define	GFX_USE_OS_CMSIS2 GFXOFF
	Use CMSIS2 RTOS compatible OS. More...

#define	GFX_USE_OS_KEIL GFXOFF
	Use Keil CMSIS 1.x (RTOS, RTX4) More...

#define	GFX_USE_OS_RTX5 GFXOFF
	Use Keil RTX5. More...

#define	GFX_USE_OS_NIOS GFXOFF
	Use NIOS-II. More...

#define	GFX_USE_OS_ZEPHYR GFXOFF
	Use Zephyr. More...

#define	GFX_USE_OS_QT GFXOFF
	Use Qt. More...

GFX_OS_EXTRA_DEINIT_FUNCTION
A macro that defines a function that uGFX calls as part of gfxDeInit() just before de-initializing the operating system. Defaults to undefined Note If defined the specified function is called just before the operating system is de-initialized by gfxDeInit(). Eg. In your source: void myOSDeInitRoutine(void); In gfxconf.h: #define GFX_OS_EXTRA_DEINIT_FUNCTION myOSDeInitRoutine
#define	GFX_OS_NO_INIT GFXOFF
	Should uGFX avoid initializing the operating system. More...

#define	GFX_OS_INIT_NO_WARNING GFXOFF
	Turn off warnings about initializing the operating system. More...

#define	GFX_OS_CALL_UGFXMAIN GFXOFF
	Call uGFXMain() after all initialisation. More...

#define	GFX_OS_UGFXMAIN_STACKSIZE 0
	When uGFXMain() is started as a thread, what stack size should be used. More...

#define	GFX_FREERTOS_USE_TRACE GFXOFF
	Should uGFX stuff be added to the FreeRTOS+Tracer. More...

#define	GFX_OS_HEAP_SIZE 0
	How much RAM should uGFX use for the heap when using its own internal heap allocator. More...

#define	GFX_EMULATE_MALLOC GFXOFF
	Enable wrappers for malloc() and free() More...

#define	GFX_MEM_LT64K GFXOFF
	Is the maximum memory allocation less than 64K. More...

Macros
#define	GFX_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
	Declare a thread function. More...

#define	GFX_THREAD_STACK(name, sz) gU8 name[sz];
	Declare a thread stack. More...

#define	GFX_EMULATE_MALLOC GFXOFF
	Use gfxAlloc and gfxFree to implement malloc() and free() More...

Typedefs
typedef void *	gThread
	A thread handle. More...

Function Documentation

◆ gfxAlloc()

void* gfxAlloc ( gMemSize sz )

Allocate memory.

Returns: A pointer to the memory allocated or NULL if there is no more memory available

Parameters

[in] sz The size in bytes of the area to allocate

Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by gdriverRegister().

◆ gfxExit()

void gfxExit ( void )

Exit the GFX application.

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxFree()

void gfxFree ( void * ptr )

Free memory.

Parameters

[in] ptr The memory to free

Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by gdriverRegister(), and gdriverUnRegister().

◆ gfxHalt()

void gfxHalt ( const char * msg )

Halt the GFX application due to an error.

Parameters

[in] msg An optional debug message to show (Can be NULL)

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxMillisecondsToTicks()

gTicks gfxMillisecondsToTicks ( gDelay ms )

Convert a given number of millseconds to a number of operating system ticks.

Returns: The period in system ticks.

Note: A "tick" is an arbitrary period of time that the operating system uses to mark time.

Parameters

[in] ms The number of millseconds

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxMutexDestroy()

void gfxMutexDestroy ( gMutex * pmutex )

Destroy a Mutex.

Parameters

[in] pmutex A pointer to the mutex

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxMutexEnter()

void gfxMutexEnter ( gMutex * pmutex )

Enter the critical code region protected by the mutex.

Blocks until there is no other thread in the critical region.

Parameters

[in] pmutex A pointer to the mutex

Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by geventDetachSourceListeners(), geventGetEventBuffer(), geventGetSourceListener(), geventSendEvent(), gtimerJab(), and gtimerStop().

◆ gfxMutexExit()

void gfxMutexExit ( gMutex * pmutex )

Exit the critical code region protected by the mutex.

May cause another thread waiting on the mutex to now be placed into the run queue.

Parameters

[in] pmutex A pointer to the mutex

Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by geventDetachSourceListeners(), geventGetEventBuffer(), geventGetSourceListener(), geventSendEvent(), gtimerJab(), and gtimerStop().

◆ gfxMutexInit()

void gfxMutexInit ( gMutex * pmutex )

Initialise a mutex to protect a region of code from other threads.

Parameters

[in] pmutex A pointer to the mutex

Note: Whilst a counting semaphore with a limit of 1 can be used for similiar purposes on many operating systems using a seperate mutex structure is more efficient.

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxRealloc()

void* gfxRealloc	(	void *	ptr,
		gMemSize	oldsz,
		gMemSize	newsz
	)

Re-allocate memory.

Returns: A pointer to the new memory area or NULL if there is no more memory available

Parameters

[in]	ptr	The old memory area to be increased/decreased in size
[in]	oldsz	The size in bytes of the old memory area
[in]	newsz	The size in bytes of the new memory area

Note: Some operating systems don't use the oldsz parameter as they implicitly know the size of old memory area. The parameter must always be supplied however for API compatibility.; gfxRealloc() can make the area smaller or larger but may have to return a different pointer. If this occurs the new area contains a copy of the data from the old area. The old memory pointer should not be used after this routine as the original area may have been freed.; If there is insufficient memory to create the new memory region, NULL is returned and the old memory area is left unchanged.

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSemDestroy()

void gfxSemDestroy ( gSem * psem )

Destroy a Counted Semaphore.

Parameters

[in] psem A pointer to the semaphore

Note: Any threads waiting on the semaphore will be released

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSemInit()

void gfxSemInit	(	gSem *	psem,
		gSemcount	val,
		gSemcount	limit
	)

Initialise a Counted Semaphore.

Parameters

[in]	psem	A pointer to the semaphore
[in]	val	The initial value of the semaphore
[in]	limit	The maxmimum value of the semaphore

Note: Operations defined for counted semaphores: Signal: The semaphore counter is increased and if the result is non-positive then a waiting thread is queued for execution. Note that once the thread reaches "limit", further signals are ignored. Wait: The semaphore counter is decreased and if the result becomes negative the thread is queued in the semaphore and suspended.

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSemSignal()

void gfxSemSignal ( gSem * psem )

Signal a semaphore.

The semaphore counter is increased and if the result is non-positive then a waiting thread is queued for execution. Note that once the thread reaches "limit", further signals are ignored.

Parameters

[in] psem A pointer to the semaphore

Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by geventSendEvent(), and gtimerJab().

◆ gfxSemSignalI()

void gfxSemSignalI ( gSem * psem )

Signal a semaphore.

The semaphore counter is increased and if the result is non-positive then a waiting thread is queued for execution. Note that once the thread reaches "limit", further signals are ignored.

Parameters

[in] psem A pointer to the semaphore

Function Class: This is an I-Class API, this function can be invoked from within a system lock zone by both threads and interrupt handlers.

Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by gtimerJabI().

◆ gfxSemWait()

gBool gfxSemWait	(	gSem *	psem,
		gDelay	ms
	)

Wait on a semaphore.

The semaphore counter is decreased and if the result becomes negative the thread waits for it to become non-negative again

Returns: gFalse if the wait timeout occurred otherwise gTrue

Parameters

[in]	psem	A pointer to the semaphore
[in]	ms	The maximum time to wait for the semaphore

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSemWaitI()

gBool gfxSemWaitI ( gSem * psem )

Test if a wait on a semaphore can be satisfied immediately.

Equivalent to gfxSemWait(psem, gDelayNone) except it can be called at interrupt level

Returns: gFalse if the wait would occur occurred otherwise gTrue

Parameters

[in] psem A pointer to the semaphore

Function Class: This is an I-Class API, this function can be invoked from within a system lock zone by both threads and interrupt handlers.

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSleepMicroseconds()

void gfxSleepMicroseconds ( gDelay us )

Put the current thread to sleep for the specified period in microseconds.

Parameters

[in] us The number microseconds to sleep

Note: Specifying gDelayNone will return immediately (no sleeping); Specifying gDelayForever will sleep forever.

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSleepMilliseconds()

void gfxSleepMilliseconds ( gDelay ms )

Put the current thread to sleep for the specified period in milliseconds.

Parameters

[in] ms The number milliseconds to sleep

Note: Specifying gDelayNone will yield the current thread but return on the next time slice.; Specifying gDelayForever will sleep forever.

Function Class: Normal API, this function can be invoked by regular system threads.

Referenced by ginputGetToggleStatus().

◆ gfxSystemLock()

void gfxSystemLock ( void )

Lock the operating system to protect a sequence of code.

Note: Calling this will lock out all other threads from executing even at interrupt level within the GFX system. On hardware this may be implemented as a disabling of interrupts, however in an operating system which hides real interrupt level code it may simply use a mutex lock.; The thread MUST NOT block whilst the system is locked. It must execute in this state for as short a period as possible as this can seriously affect interrupt latency on some platforms.; While locked only interrupt level (iclass) GFX routines may be called.

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSystemTicks()

gTicks gfxSystemTicks ( void )

Get the current operating system tick time.

Returns: The current tick time

Note: A "tick" is an arbitrary period of time that the operating system uses to mark time.; The absolute value of this call is relatively meaningless. Its usefulness is in calculating periods between two calls to this function.; As the value from this function can wrap it is important that any periods are calculated as t2 - t1 and then compared to the desired period rather than comparing t1 + period to t2

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxSystemUnlock()

void gfxSystemUnlock ( void )

Unlock the operating system previous locked by gfxSystemLock()

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxThreadClose()

void gfxThreadClose ( gThread thread )

Close the thread handle.

Parameters

[in] thread The Thread Handle

Note: This does not affect the thread, it just closes our handle to the thread.

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxThreadCreate()

gThread gfxThreadCreate	(	void *	stackarea,
		gMemSize	stacksz,
		gThreadpriority	prio,
		GFX_THREAD_FUNCTION((*fn), p)	,
		void *	param
	)

Start a new thread.

Returns: Returns a thread handle if the thread was started, NULL on an error

Parameters

[in]	stackarea	A pointer to the area for the new threads stack or NULL to dynamically allocate it
[in]	stacksz	The size of the thread stack. 0 means the default operating system size although this is only valid when stackarea is dynamically allocated.
[in]	prio	The priority of the new thread
[in]	fn	The function the new thread will run
[in]	param	A parameter to pass the thread function.

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxThreadMe()

gThread gfxThreadMe ( void )

Get the current thread handle.

Returns: A thread handle

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxThreadWait()

gThreadreturn gfxThreadWait ( gThread thread )

Wait for a thread to finish.

Returns: Returns the thread exit code.

Parameters

[in] thread The Thread Handle

Note: This will also close the thread handle as it is no longer useful once the thread has ended.

Function Class: Normal API, this function can be invoked by regular system threads.

◆ gfxYield()

void gfxYield ( void )

Yield the current thread.

Give up the rest of the current time slice for this thread in order to give other threads a chance to run.

Function Class: Normal API, this function can be invoked by regular system threads.

Macro Definition Documentation

◆ GFX_EMULATE_MALLOC [1/2]

#define GFX_EMULATE_MALLOC GFXOFF

Use gfxAlloc and gfxFree to implement malloc() and free()

Note: Sometimes your application will include functions that want to internally use malloc() and free(). As the default implementations of these in your C library are almost invariably incorrect for an embedded platform, this option allows you to emulate those calls with gfxAlloc() and gfxFree(). An example is the C library routine rand() which on many implementations internally uses malloc().

Function Class: Normal API, this function can be invoked by regular system threads.

Definition at line 191 of file gos.h.

◆ GFX_EMULATE_MALLOC [2/2]

#define GFX_EMULATE_MALLOC GFXOFF

Enable wrappers for malloc() and free()

Defaults to GFXOFF

Note: If enabled, malloc() and free() will be implemented as wrappers that call gfxAlloc() and gfxFree() in order to provide portability to libraries using these function.; Enabling this can solve 'unresolved _sbrk' issues; It is strongly recommended to always use gfxAlloc() and gfxFree() directy to ensure portability of uGFX applications across all platforms.

Definition at line 261 of file gos_options.h.

◆ GFX_FREERTOS_USE_TRACE

#define GFX_FREERTOS_USE_TRACE GFXOFF

Should uGFX stuff be added to the FreeRTOS+Tracer.

Defaults to GFXOFF

Definition at line 234 of file gos_options.h.

◆ GFX_MEM_LT64K

#define GFX_MEM_LT64K GFXOFF

Is the maximum memory allocation less than 64K.

Defaults to GFXOFF

Note: Many CPU's cannot allocate memory blocks larger than 64K. Note that this is not necessarily mean that a pointer is 16 bit but a 16 bit pointer will definitely impose this restriction. An example is the x86 processor running in "FAR" mode. Pointers are 32 bit but the maximum size memory block is 64K.; Specifying this only leads to code and memory optimisations. uGFX should still work on these processors even if it is not set although obviously an attempted memory allocation larger than 64K will fail.

Definition at line 275 of file gos_options.h.

◆ GFX_OS_CALL_UGFXMAIN

#define GFX_OS_CALL_UGFXMAIN GFXOFF

Call uGFXMain() after all initialisation.

Defaults to GFXOFF

Note: uGFXMain() is a function defined by the user in their project that contains the application main code. This is not expected to return and thus gfxInit() will also never return. This is required for some operating systems whose main thread never returns after starting the scheduler.
Its prototype is:
void uGFXMain(void);

Definition at line 216 of file gos_options.h.

◆ GFX_OS_HEAP_SIZE

#define GFX_OS_HEAP_SIZE 0

How much RAM should uGFX use for the heap when using its own internal heap allocator.

Defaults to 0.

Note: Only used when the internal ugfx heap allocator is used (GFX_USE_OS_RAW32, GFX_USE_OS_ARDUINO, GFX_US_OS_KEIL, GFX_USE_OS_CMSIS); If 0 then the standard C runtime malloc(), free() and realloc() are used.; If it is non-zero then this is the number of bytes of RAM to use for the heap (gfxAlloc() and gfxFree()). No C runtime routines will be used and a new routine gfxAddHeapBlock() is added allowing the user to add extra memory blocks to the heap.

Definition at line 249 of file gos_options.h.

◆ GFX_OS_INIT_NO_WARNING

#define GFX_OS_INIT_NO_WARNING GFXOFF

Turn off warnings about initializing the operating system.

Defaults to GFXOFF

Note: This is only relevant where GOS cannot initialize the operating system automatically or the operating system initialization has been explicitly turned off.

Definition at line 202 of file gos_options.h.

◆ GFX_OS_NO_INIT

#define GFX_OS_NO_INIT GFXOFF

Should uGFX avoid initializing the operating system.

Defaults to GFXOFF

Note: This is not relevant to all operating systems eg Win32 never initializes the operating system as uGFX runs as an application outside the boot process.; Operating system initialization is not necessarily implemented for all operating systems yet even when it is relevant. These operating systems will display a compile warning reminding you to initialize the operating system in your application code. Note that on these operating systems the demo applications will not work without modification.

Definition at line 192 of file gos_options.h.

◆ GFX_OS_UGFXMAIN_STACKSIZE

#define GFX_OS_UGFXMAIN_STACKSIZE 0

When uGFXMain() is started as a thread, what stack size should be used.

Defaults to 0

Note: uGFXMain() contains the application main code. Some operating systems will start this as a thread. eg FreeRTOS. When it is started as a thread this defines how many bytes should be used for the thread stack.; 0 means to use the operating systems default stack size.

Definition at line 227 of file gos_options.h.

◆ GFX_THREAD_FUNCTION

#define GFX_THREAD_FUNCTION	(	fnName,
		param
	)	gThreadreturn fnName(void *param)

Declare a thread function.

Parameters

[in]	fnName	The name of the function
[in]	param	A custom parameter that is passed to the function

Definition at line 73 of file gos.h.

◆ GFX_THREAD_STACK

#define GFX_THREAD_STACK	(	name,
		sz
	)	gU8 name[sz];

Declare a thread stack.

Parameters

[in]	name	The name of the stack
[in]	sz	The size of the stack in bytes

Note: The size provided is just a suggestion to the required stack size. Many platforms will round the size to ensure correct stack alignment. Other platforms may entirely ignore the suggested size.

Definition at line 85 of file gos.h.

◆ GFX_USE_OS_ARDUINO

#define GFX_USE_OS_ARDUINO GFXOFF

Use Arduino.

Defaults to GFXOFF

Definition at line 84 of file gos_options.h.

◆ GFX_USE_OS_CHIBIOS

#define GFX_USE_OS_CHIBIOS GFXOFF

Use ChibiOS.

Defaults to GFXOFF

Definition at line 28 of file gos_options.h.

◆ GFX_USE_OS_CMSIS

#define GFX_USE_OS_CMSIS GFXOFF

Use CMSIS RTOS compatible OS.

Defaults to GFXOFF

Definition at line 91 of file gos_options.h.

◆ GFX_USE_OS_CMSIS2

#define GFX_USE_OS_CMSIS2 GFXOFF

Use CMSIS2 RTOS compatible OS.

Defaults to GFXOFF

Definition at line 98 of file gos_options.h.

◆ GFX_USE_OS_ECOS

#define GFX_USE_OS_ECOS GFXOFF

Use a eCos.

Defaults to GFXOFF

Definition at line 70 of file gos_options.h.

◆ GFX_USE_OS_FREERTOS

#define GFX_USE_OS_FREERTOS GFXOFF

Use FreeRTOS.

Defaults to GFXOFF

Definition at line 35 of file gos_options.h.

◆ GFX_USE_OS_KEIL

#define GFX_USE_OS_KEIL GFXOFF

Use Keil CMSIS 1.x (RTOS, RTX4)

Defaults to GFXOFF

Definition at line 105 of file gos_options.h.

◆ GFX_USE_OS_LINUX

#define GFX_USE_OS_LINUX GFXOFF

Use a linux based system running X11.

Defaults to GFXOFF

Definition at line 49 of file gos_options.h.

◆ GFX_USE_OS_NIOS

#define GFX_USE_OS_NIOS GFXOFF

Use NIOS-II.

Defaults to GFXOFF

Definition at line 119 of file gos_options.h.

◆ GFX_USE_OS_OSX

#define GFX_USE_OS_OSX GFXOFF

Use a Mac OS-X based system.

Defaults to GFXOFF

Definition at line 56 of file gos_options.h.

◆ GFX_USE_OS_QT

#define GFX_USE_OS_QT GFXOFF

Use Qt.

Defaults to GFXOFF

Definition at line 133 of file gos_options.h.

◆ GFX_USE_OS_RAW32

#define GFX_USE_OS_RAW32 GFXOFF

Use a Raw 32-bit CPU based system (Bare Metal)

Defaults to GFXOFF

Definition at line 63 of file gos_options.h.

◆ GFX_USE_OS_RAWRTOS

#define GFX_USE_OS_RAWRTOS GFXOFF

Use RAWRTOS.

Defaults to GFXOFF

Definition at line 77 of file gos_options.h.

◆ GFX_USE_OS_RTX5

#define GFX_USE_OS_RTX5 GFXOFF

Use Keil RTX5.

Defaults to GFXOFF

Definition at line 112 of file gos_options.h.

◆ GFX_USE_OS_WIN32

#define GFX_USE_OS_WIN32 GFXOFF

Use Win32.

Defaults to GFXOFF

Definition at line 42 of file gos_options.h.

◆ GFX_USE_OS_ZEPHYR

#define GFX_USE_OS_ZEPHYR GFXOFF

Use Zephyr.

Defaults to GFXOFF

Definition at line 126 of file gos_options.h.

Typedef Documentation

◆ gThread

typedef void* gThread

A thread handle.

Note: Your operating system will have a proper definition for this.

Definition at line 116 of file gos.h.

Detailed Description

Data Structures

Functions

Various integer sizes

More integer sizes

Various platform (and operating system) dependent types

Various platform (and operating system) constants

The operating system to use. One (and only one) of these must be defined.

GFX_OS_EXTRA_DEINIT_FUNCTION

Macros

Typedefs

Function Documentation

◆ gfxAlloc()

◆ gfxExit()

◆ gfxFree()

◆ gfxHalt()

◆ gfxMillisecondsToTicks()

◆ gfxMutexDestroy()

◆ gfxMutexEnter()

◆ gfxMutexExit()

◆ gfxMutexInit()

◆ gfxRealloc()

◆ gfxSemDestroy()

◆ gfxSemInit()

◆ gfxSemSignal()

◆ gfxSemSignalI()

◆ gfxSemWait()

◆ gfxSemWaitI()

◆ gfxSleepMicroseconds()

◆ gfxSleepMilliseconds()

◆ gfxSystemLock()

◆ gfxSystemTicks()

◆ gfxSystemUnlock()

◆ gfxThreadClose()

◆ gfxThreadCreate()

◆ gfxThreadMe()

◆ gfxThreadWait()

◆ gfxYield()

Macro Definition Documentation

◆ GFX_EMULATE_MALLOC [1/2]

◆ GFX_EMULATE_MALLOC [2/2]

◆ GFX_FREERTOS_USE_TRACE

◆ GFX_MEM_LT64K

◆ GFX_OS_CALL_UGFXMAIN

◆ GFX_OS_HEAP_SIZE

◆ GFX_OS_INIT_NO_WARNING

◆ GFX_OS_NO_INIT

◆ GFX_OS_UGFXMAIN_STACKSIZE

◆ GFX_THREAD_FUNCTION

◆ GFX_THREAD_STACK

◆ GFX_USE_OS_ARDUINO

◆ GFX_USE_OS_CHIBIOS

◆ GFX_USE_OS_CMSIS

◆ GFX_USE_OS_CMSIS2

◆ GFX_USE_OS_ECOS

◆ GFX_USE_OS_FREERTOS

◆ GFX_USE_OS_KEIL

◆ GFX_USE_OS_LINUX

◆ GFX_USE_OS_NIOS

◆ GFX_USE_OS_OSX

◆ GFX_USE_OS_QT

◆ GFX_USE_OS_RAW32

◆ GFX_USE_OS_RAWRTOS

◆ GFX_USE_OS_RTX5

◆ GFX_USE_OS_WIN32

◆ GFX_USE_OS_ZEPHYR

Typedef Documentation

◆ gThread