+ + NX Graphics Subsystem ++Last Updated: December 5, 2008 + |
+
+ Table of Contents+ |
+
+ 1.0 Introduction+ |
+
+ This document describes the tiny graphics support included in NuttX. + It includes an overview description of that graphics support, detailed + descriptions of the NuttX graphics APIs, and discussion of code organization, + and OS configuration options. +
+ + |
+
Figure 1.
+ This sceen shot shows the final frame for the NuttX example at examples/nx
+ running on the simulated, Linux x86 platform with simulated framebuffer output to
+ an X window.
+ This picture shows to framed windows with (blank) toolbars.
+ Each window has displayed text as received from the NX keyboard interface
+ The second window has just been raised to the top of the display.
+
+ |
+ The objective of this development was to provide a tiny windowing system in the + spirit of X, but greatly scaled down and appropriate for most resource-limited + embedded environments. + The current NX implementation supports the general following, high-level features: +
++ NX is organized into 6 (and perhaps someday 7 or 8) logical modules. + These logical modules also correspond to the directory organization. + That NuttX directory organization is discussed in + Appendix B of this document. + The logic modules are discussed in the following sub-paragraphs. +
+ ++
NXGL)+ NXGLIB is a standalone library that contains low-level graphics utilities and + direct framebuffer rendering logic. NX is built on top NXGLIB. +
+ +NXSU and NXMU)
+ NX is the tiny NuttX windowing system for raw windows (i.e., simple regions of
+ graphics memory).
+ NX includes both a small-footprint, single user implementaton (NXSU) and a somewhat
+ larger multi-user implentation (NXMU as described below).
+ Both conform to the same APIs as defined in include/nuttx/nx.h and, hence,
+ are interchangable1.
+ NX can be used without NXWIDGETS and without NXTOOLKIT for raw window displays.
+
+ 1NXMU and NXSU are interchangeable other than (1) certain start-up + and intialization APIs (as described below), and (2) timing. With NXSU, NX APIs + execute immediately; with NXMU, NX APIs defer and serialize the operations and, hence, + introduce different timing and potential race conditions that you would not experience + with NXSU. +
+ +NXNULL? + At one time, I also envisoned a NULL front-end that did not support windowing + at all but, rather, simply provided the entire framebuffer memory as one dumb window. + This has the advantage that the same NX APIs can be used on the one dumb window as + for the other NX windows. + This would be in the NuttX spirit of scalability. +
+
+ However, the same end result can be obtained by using the
+ nx_requestbkgd() API.
+ It still may be possible to reduce the footprint in this usage case by developing
+ and even thinner NXNULL front-end.
+ That is a possible future development.
+
NXTK)+ NXTK is a s set of C graphics tools that provide higher-level window drawing + operations. + This is the module where the framed windows and toolbar logic is implemented. + NXTK is built on top of NX and does not depend on NXWIDGETS. +
+ +NXFONTS)+ A set of C graphics tools for present (bitmap) font images. + The font implementation is at a very low level or graphics operation, + comparable to the logic in NXGLIB. + NXFONTS does not depend on any NX module other than some utilities and types from NXGLIB. +
+ +NXWIDGETS)+ I had originally planned a high level, C++, object-oriented library for + object-oriented access to graphics widgets. + However, C++ compilers are not available for some of the targets supported by NuttX. + So I have decided to implement the entire solution in C. + That decision makes the solution somewhat more difficult to work with, but supports all platforms. +
++ At this point, the amount of C in the implementation would make conversion to C++ a + more difficult job. + I leave the C++ widget interface to any contributor who may have an interest in such things. +
+ +
+ 2.0 NX User APIs+ |
+
include/nuttx/nxglib.h
+ - Describes the NXGLIB C interfaces
+
include/nuttx/nx.h
+ - Describes the NX C interfaces
+
include/nutt/nxtk.h
+ - Describe the NXTOOLKIT C interfaces
+
include/nutt/nxfont.h
+ - Describe sthe NXFONT C interfaces
+
include/nuttx/nxwidgets.h
+ - Will describe the NXWIDGETS classes (no longer planned)
+
NXGL)
+ NXGL provides many APIs, some available for use internally by NX and
+ others for use by applications as well.
+ Only those APIs intended for application usage are documented here
+ See include/nuttx/nxglib.h for the full set of APIs;
+ those APIs might be of interest if you are rendering directly into
+ framebuffer memory.
+
+ nxgl_mxpixel_t.
+ Holds one device pixel.
+ NXGLIB will select the smallest size for the nxgl_mxpixel_t
+ that just contains the pixel: byte if 16, 24, and 32 resolution
+ support is disabled, uint16 if 24, and 32 resolution
+ support is disabled, or uint32.
+
+ nxgl_coord_t
+ A given coordinate is limited to the screen height an width. If either
+ of those values exceed 32,767 pixels, then the following will have to need
+ to change:
+
+typedef sint16 nxgl_coord_t; ++ +
+ struct nxgl_point_s. Describes a point on the display:
+
+struct nxgl_point_s
+{
+ nxgl_coord_t x; /* X position, range: 0 to screen width - 1 */
+ nxgl_coord_t y; /* Y position, range: 0 to screen height - 1 */
+};
+
+
+
+ struct nxgl_size_s. Describes the size of a rectangular region.
+
+struct nxgl_size_s
+{
+ nxgl_coord_t w; /* Width in pixels */
+ nxgl_coord_t h; /* Height in rows */
+};
+
+
+
+ struct nxgl_rect_s. Describes a positioned rectangle on the display.
+
+struct nxgl_rect_s
+{
+ struct nxgl_point_s pt1; /* Upper, left-hand corner */
+ struct nxgl_point_s pt2; /* Lower, right-hand corner */
+};
+
+
+
+ struct nxgl_run_s.
+ Describes a run, i.e., a horizontal line. Note that the start/end positions
+ have fractional precision. This is necessary for good joining of trapezoids
+ when a more complex shape is decomposed into trapezoids
+
+struct nxgl_run_s
+{
+ b16_t x1; /* Left X position, range: 0 to x2 */
+ b16_t x2; /* Right X position, range: x1 to screen width - 1 */
+ nxgl_coord_t y; /* Top Y position, range: 0 to screen height - 1 */
+};
+
+
+
+ struct nxgl_trapezoid_s.
+ Describes a horizontal trapezoid on the display in terms the run at the
+ top of the trapezoid and the run at the bottom
+
+struct nxgl_trapezoid_s
+{
+ struct nxgl_run_s top; /* Top run */
+ struct nxgl_run_s bot; /* bottom run */
+};
+
+
+nxgl_rgb2yuv()Function Prototype:
++#include <nuttx/nxglib.h> +void nxgl_rgb2yuv(ubyte r, ubyte g, ubyte b, ubyte *y, ubyte *u, ubyte *v); ++
+ Description: + Convert 8-bit RGB triplet to 8-bit YUV triplet. +
+ +nxgl_yuv2rgb()Function Prototype:
++#include <nuttx/nxglib.h> +void nxgl_yuv2rgb(ubyte y, ubyte u, ubyte v, ubyte *r, ubyte *g, ubyte *b); ++
+ Description: + Convert 8-bit RGB triplet to 8-bit YUV triplet. +
+ +nxgl_rectcopy()Function Prototype:
++#include <nuttx/nxglib.h> +void nxgl_rectcopy(FAR struct nxgl_rect_s *dest, + FAR const struct nxgl_rect_s *src); ++
+ Description:
+ This is essentially memcpy()for rectangles. We don't do structure
+ assignments because some compilers are not good at that.
+
nxgl_rectoffset()Function Prototype:
++#include <nuttx/nxglib.h> +void nxgl_rectoffset(FAR struct nxgl_rect_s *dest, + FAR const struct nxgl_rect_s *src, + nxgl_coord_t dx, nxgl_coord_t dy); ++
+ Description: + Offset the rectangle position by the specified dx, dy values. +
+ +nxgl_vectoradd()Function Prototype:
++#include <nuttx/nxglib.h> +void nxgl_vectoradd(FAR struct nxgl_point_s *dest, + FAR const struct nxgl_point_s *v1, + FAR const struct nxgl_point_s *v2); ++
+ Description: + Add two 2x1 vectors and save the result to a third. +
+ +nxgl_vectorsubtract()Function Prototype:
++#include <nuttx/nxglib.h> +void nxgl_vectsubtract(FAR struct nxgl_point_s *dest, + FAR const struct nxgl_point_s *v1, + FAR const struct nxgl_point_s *v2); ++
+ Description:
+ Add subtract vector v2 from vector v1 and return the result in vector dest.
+
nxgl_rectintersect()Function Prototype:
++#include <nuttx/nxglib.h> +void nxgl_rectintersect(FAR struct nxgl_rect_s *dest, + FAR const struct nxgl_rect_s *src1, + FAR const struct nxgl_rect_s *src2); ++
+ Description: + Return the rectangle representing the intersection of the two rectangles. +
+ +nxgl_rectunion()Function Prototype:
++#include <nuttx/nxglib.h> +void nxgl_rectunion(FAR struct nxgl_rect_s *dest, + FAR const struct nxgl_rect_s *src1, + FAR const struct nxgl_rect_s *src2); ++
+ Description:
+ Given two rectanges, src1 and src2, return the larger rectangle that
+ contains both, dest.
+
nxgl_nonintersecting()Function Prototype:
++#include <nuttx/nxglib.h> +nxgl_nonintersecting(FAR struct nxgl_rect_s result[4], + FAR const struct nxgl_rect_s *rect1, + FAR const struct nxgl_rect_s *rect2); ++
+ Description:
+ Return the regions of rectangle rect1 that do not intersect with
+ rect2. This will four rectangles, some of which may be
+ degenerate (and can be picked off with nxgl_nullrect()).
+
nxgl_rectoverlap()Function Prototype:
++#include <nuttx/nxglib.h> +boolean nxgl_rectoverlap(FAR struct nxgl_rect_s *rect1, + FAR struct nxgl_rect_s *rect2); ++
+ Description: + Return TRUE if the two rectangles overlap. +
+ +nxgl_rectinside()Function Prototype:
++#include <nuttx/nxglib.h> +boolean nxgl_rectinside(FAR const struct nxgl_rect_s *rect, + FAR const struct nxgl_point_s *pt); ++
+ Description:
+ Return TRUE if the point pt lies within rect.
+
nxgl_rectsize()Function Prototype:
++#include <nuttx/nxglib.h> +void nxgl_rectsize(FAR struct nxgl_size_s *size, + FAR const struct nxgl_rect_s *rect); ++
+ Description: + Return the size of the specified rectangle. +
+ +nxgl_nullrect()Function Prototype:
++#include <nuttx/nxglib.h> +boolean nxgl_nullrect(FAR const struct nxgl_rect_s *rect); ++
+ Description: + Return TRUE if the area of the retangle is <= 0. +
+ +nxgl_runoffset()Function Prototype:
++#include <nuttx/nxglib.h> +void nxgl_runoffset(FAR struct nxgl_run_s *dest, + FAR const struct nxgl_run_s *src, + nxgl_coord_t dx, nxgl_coord_t dy); ++
+ Description:
+ Offset the run position by the specified dx, dy values.
+
nxgl_runcopy()Function Prototype:
++#include <nuttx/nxglib.h> +void nxgl_runcopy(FAR struct nxgl_run_s *dest, + FAR const struct nxgl_run_s *src); ++
+ Description:
+ This is essentially memcpy()for runs. We don't do structure assignments
+ because some compilers are not good at that.
+
nxgl_trapoffset()Function Prototype:
++#include <nuttx/nxglib.h> +void nxgl_trapoffset(FAR struct nxgl_trapezoid_s *dest, + FAR const struct nxgl_trapezoid_s *src, + nxgl_coord_t dx, nxgl_coord_t dy); ++
+ Description:
+ Offset the trapezoid position by the specified dx, dy values.
+
nxgl_trapcopy()Function Prototype:
++#include <nuttx/nxglib.h> +void nxgl_trapcopy(FAR struct nxgl_trapezoid_s *dest, + FAR const struct nxgl_trapezoid_s *src); ++
+ Description:
+ This is essentially memcpy()for trapezoids. We don't do structure
+ assignments because some compilers are not good at that.
+
nxgl_colorcopyFunction Prototype:
++#include <nuttx/nxglib.h> +nxgl_colorcopy(nxgl_mxpixel_t dest[CONFIG_NX_NPLANES], + const nxgl_mxpixel_t src[CONFIG_NX_NPLANES]); ++
+ Description:
+ This is essentially memcpy()for colors. This does very little for us
+ other than hide all of the conditional compilation for planar colors
+ in one place.
+
+ The default server message queue name used by the
+ nx_run() macro:
+
+#define NX_DEFAULT_SERVER_MQNAME "/dev/nxs" ++ +
+ Mouse button bits: +
++#define NX_MOUSE_NOBUTTONS 0x00 +#define NX_MOUSE_LEFTBUTTON 0x01 +#define NX_MOUSE_CENTERBUTTON 0x02 +#define NX_MOUSE_RIGHTBUTTON 0x04 ++ +
+ The interface to the NX server is managed using a opaque handle: +
++typedef FAR void *NXHANDLE; ++ +
+ The interface to a specific window is managed using an opaque handle: +
++typedef FAR void *NXWINDOW; ++ +
+ These define callbacks that must be provided to
+ nx_openwindow().
+ In the multi-user model, these callbacks will be invoked as part of the
+ processing performed by
+ nx_eventhandler().
+
+struct nx_callback_s
+{
+ void (*redraw)(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
+ boolean more, FAR void *arg);
+ void (*position)(NXWINDOW hwnd, FAR const struct nxgl_size_s *size,
+ FAR const struct nxgl_point_s *pos,
+ FAR const struct nxgl_rect_s *bounds,
+ FAR void *arg);
+#ifdef CONFIG_NX_MOUSE
+ void (*mousein)(NXWINDOW hwnd, FAR const struct nxgl_point_s *pos,
+ ubyte buttons, FAR void *arg);
+#endif
+#ifdef CONFIG_NX_KBD
+ void (*kbdin)(NXWINDOW hwnd, ubyte nch, FAR const ubyte *ch, FAR void *arg);
+#endif
+};
+
+
+redraw()Callback Function Prototype:
++void redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect, + boolean more, FAR void *arg); ++
+ Description: + NX requests that the client re-draw the portion of the window within + with rectangle. +
++ Input Parameters: +
hwnd
+ nx_openwindow()
+ or nx_requestbkgd()
+ rect
+ more
+ arg
+ nx_openwindow())
+ + Returned Value: None +
+ +position()Callback Function Prototype:
++void position(NXWINDOW hwnd, FAR const struct nxgl_size_s *size, + FAR const struct nxgl_point_s *pos, + FAR const struct nxgl_rect_s *bounds, + FAR void *arg); ++
+ Description: + The size or position of the window has changed (or the window was + just created with zero size. +
++ Input Parameters: +
hwnd
+ nx_openwindow()
+ or nx_requestbkgd()
+ size
+ pos
+ bounds
+ arg
+ nx_openwindow())
+ + Returned Value: None +
+ +mousein()Callback Function Prototype:
++#ifdef CONFIG_NX_MOUSE +void mousein(NXWINDOW hwnd, FAR const struct nxgl_point_s *pos, + ubyte buttons, FAR void *arg); +#endif ++
+ Description: + New mouse data is available for the window +
++ Input Parameters: +
hwnd
+ nx_openwindow()
+ or nx_requestbkgd()
+ pos
+ buttons
+ NX_MOUSE_* definitions
+ arg
+ nx_openwindow())
+ + Returned Value: None +
+ +kbdin()Callback Function Prototype:
++#ifdef CONFIG_NX_KBD +void (*kbdin)(NXWINDOW hwnd, ubyte nch, FAR const ubyte *ch, FAR void *arg); +#endif ++
+ Description: + New keyboard/keypad data is available for the window. +
++ Input Parameters: +
hwnd
+ nx_openwindow()
+ or nx_requestbkgd()
+ nch
+ ch
+ arg
+ nx_openwindow())
+ + Returned Value: NOne +
+ +nx_runinstance() (and nx_run() macro)Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +#ifdef CONFIG_NX_MULTIUSER +int nx_runinstance(FAR const char *mqname, FAR struct fb_vtable_s *fb); +#define nx_run(fb) nx_runinstance(NX_DEFAULT_SERVER_MQNAME, fb) +#endif ++
+ Description: + This is the server entry point. It does not return; the calling thread + is dedicated to supporting NX server. +
+
+ NOTE that multiple instances of the NX server may run at the same time,
+ with different callback and message queue names. nx_run() is simply
+ a macro that can be used when only one server instance is required. In
+ that case, a default server name is used.
+
+ Multiple user mode only! +
++ Input Parameters: +
mqname
+ fb
+
+ Returned Value:
+ This function usually does not return. If it does return, it will
+ return ERROR and errno will be set appropriately.
+
nx_connectinstance() (and nx_connect() macro)Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +#ifdef CONFIG_NX_MULTIUSER +NXHANDLE nx_connectinstance(FAR const char *svrmqname); +#define nx_connect(cb) nx_connectinstance(NX_DEFAULT_SERVER_MQNAME) +#endif ++
+ Description: + Open a connection from a client to the NX server. One one client + connection is normally needed per thread as each connection can host + multiple windows. +
++ NOTES: +
+nx_connect() is simply a macro that can be used when only one
+ server instance is required. In that case, a default server name
+ is used.
+ + Multiple user mode only! +
++ Input Parameters: +
svrmqname
+ + Returned Value: +
+errno is set appropriately.
+nx_open()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +#ifndef CONFIG_NX_MULTIUSER +NXHANDLE nx_open(FAR struct fb_vtable_s *fb); +#endif ++
+ Description:
+ Create, initialize and return an NX handle for use in subsequent
+ NX API calls. nx_open() is the single user equivalent of
+ nx_connect() plus
+ nx_run().
+
+ Single user mode only! +
++ Input Parameters: +
fb
+ cb
+ + Returned Value: +
+errno is set appropriately.
+nx_disconnect()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +#ifdef CONFIG_NX_MULTIUSER +void nx_disconnect(NXHANDLE handle); +#endif ++
+ Description:
+ Disconnect a client from the NX server and/or free resources reserved
+ by nx_connect()/nx_connectinstance().
+ nx_disconnect() is muliti-user equivalent of
+ nx_close().
+
+ Multiple user mode only! +
++ Input Parameters: +
handle
+ nx_connect().
+ + Returned Value: None. +
+ +nx_close()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +#ifndef CONFIG_NX_MULTIUSER +void nx_close(NXHANDLE handle); +#endif ++
+ Description:
+ Close the single user NX interface. nx_close is single-user equivalent
+ of nx_disconnect().
+
+ Single user mode only! +
++ Input Parameters: +
handle
+ nx_open().
+ + Returned Value: None +
+ +nx_eventhandler()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +#ifdef CONFIG_NX_MULTIUSER +int nx_eventhandler(NXHANDLE handle); +#else +# define nx_eventhandler(handle) (OK) +#endif ++
+ Description:
+ The client code must call this function periodically to process
+ incoming messages from the server. If CONFIG_NX_BLOCKING is defined,
+ then this function not return until a server message is received.
+
+ When CONFIG_NX_BLOCKING is not defined, the client must exercise
+ caution in the looping to assure that it does not eat up all of
+ the CPU bandwidth calling nx_eventhandler repeatedly.
+ nx_eventnotify()
+ may be called to get a signal event whenever a new incoming server
+ event is avaiable.
+
+ Input Parameters: +
handle
+ nx_connect().
+ + Returned Value: +
+OK: No errors occurred. If CONFIG_NX_BLOCKING is defined,
+ then one or more server messages were processed.
+ ERROR: An error occurred and errno has been set appropriately.
+ Of particular interest, it will return errno == EHOSTDOWN when the
+ server is disconnected. After that event, the handle can no longer be used.
+ nx_eventnotify()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +#if defined(CONFIG_NX_MULTIUSER) && !defined(CONFIG_DISABLE_SIGNALS) +int nx_eventnotify(NXHANDLE handle, int signo); +#else +# define nx_eventnotify(handle, signo) (OK) +#endif ++
+ Description:
+ Rather than calling nx_eventhandler() periodically,
+ the client may register to receive a signal when a server event is available.
+ The client can then call nv_eventhandler() only when
+ incoming events are available.
+
+ The underlying implementation used mq_notifiy() and, as a result,
+ the client must observe the rules for using mq_notifiy():
+
nx_eventnotify() again.
+ + Input Parameters: +
handle
+ nx_connect().
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_openwindow()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +NXWINDOW nx_openwindow(NXHANDLE handle, + FAR const struct nx_callback_s *cb, + FAR void *arg); ++
+ Description: Create a new window. +
++ Input Parameters: +
handle
+ nx_connect()
+ or nx_open().
+ cb
+ arg
+ + Returned Value: +
+errno is set appropriately.
+nx_closewindow()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +int nx_closewindow(NXWINDOW hwnd); ++
+ Description:
+ Destroy a window created by nx_openwindow() window.
+
+ Input Parameters: +
hwnd
+ nx_openwindow()
+ that identifies the window to be destroyed.
+ This handle must not have been one returned by
+ nx_requestbkgd().
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_requestbkgd()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +int nx_requestbkgd(NXHANDLE handle, + FAR const struct nx_callback_s *cb, + FAR void *arg); ++
+ Description: + NX normally controls a separate window called the background window. + It repaints the window as necessary using only a solid color fill. The + background window always represents the entire screen and is always + below other windows. It is useful for an application to control the + background window in the following conditions: +
+CONFIG_NX_MULTIUSER as well.
+ + This API only requests the handle of the background window. That + handle will be returned asynchronously in a subsequent position and + redraw callbacks. +
++ Cautions: +
+nx_setposition(),
+ nx_setsize(),
+ nx_raise(), or
+ nx_lower().
+ nx_requestbkgd() nor
+ nx_releasebkgd () should be called more than once.
+ Multiple instances of the background window are not supported.
+ + Input Parameters: +
handle
+ nx_connect()
+ or nx_open().
+ cb
+ arg
+ nx_openwindow())
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_releasebkgd()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +int nx_releasebkgd(NXWINDOW hwnd); ++
+ Description:
+ Release the background window previously acquired using
+ nx_requestbkgd()
+ and return control of the background to NX.
+
+ Input Parameters: +
handle
+ nx_requestbkgd().
+ This handle must not have been one created by
+ nx_openwindow().
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_getposition()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +int nx_getposition(NXWINDOW hwnd); ++
+ Description: + Request the position and size information for the selected window. The + values will be return asynchronously through the client callback function + pointer. +
++ Input Parameters: +
hwnd
+ nx_openwindow() or
+ nx_requestbkgd().
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_setposition()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +int nx_setposition(NXWINDOW hwnd, FAR struct nxgl_point_s *pos); ++
+ Description: + Set the position and size for the selected window. +
++ Input Parameters: +
hwnd
+ nx_openwindow().
+ This handle must not have been created by
+ nx_requestbkgd().
+ pos
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_setsize()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +int nx_setsize(NXWINDOW hwnd, FAR struct nxgl_size_s *size); ++
+ Description: Set the size of the selected window. +
++ Input Parameters: +
hwnd
+ nx_openwindow().
+ This handle must not have been created by
+ nx_requestbkgd().
+ size
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_raise()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +int nx_raise(NXWINDOW hwnd); ++
+ Description: Bring the specified window to the top of the display. +
++ Input Parameters: +
hwnd
+ nx_openwindow().
+ This handle must not have been created by
+ nx_requestbkgd().
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_lower()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +int nx_lower(NXWINDOW hwnd); ++
+ Description: Lower the specified window to the bottom of the display. +
++ Input Parameters: +
hwnd
+ nx_openwindow().
+ This handle must not have been created by
+ nx_requestbkgd().
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_fill()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +int nx_fill(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect, + nxgl_mxpixel_t color[CONFIG_NX_NPLANES]); ++
+ Description: + Fill the specified rectangle in the window with the specified color. +
++ Input Parameters: +
hwnd
+ nx_openwindow()
+ or nx_requestbkgd()
+ rect
+ color
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_filltrapezoid()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +int nx_filltrapezoid(NXWINDOW hwnd, FAR const struct nxgl_rect_s *clip, + FAR const struct nxgl_trapezoid_s *trap, + nxgl_mxpixel_t color[CONFIG_NX_NPLANES]); ++
+ Description: + Fill the specified trapezoidal region in the window with the specified color. +
++ Input Parameters: +
hwnd
+ nx_openwindow()
+ or nx_requestbkgd()
+ clip
+ trap
+ color
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_setbgcolor()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +int nx_setbgcolor(NXHANDLE handle, + nxgl_mxpixel_t color[CONFIG_NX_NPLANES]); ++
+ Description: Set the color of the background. +
++ Input Parameters: +
handle
+ nx_openwindow()
+ or nx_requestbkgd()
+ color
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_move()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +int nx_move(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect, + FAR const struct nxgl_point_s *offset); ++
+ Description: Move a rectangular region within the window. +
++ Input Parameters: +
hwnd
+ nx_openwindow()
+ or nx_requestbkgd() that specifies
+ the window within which the move is to be done
+ rect
+ offset
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_bitmap()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +int nx_bitmap(NXWINDOW hwnd, FAR const struct nxgl_rect_s *dest, + FAR const void *src[CONFIG_NX_NPLANES], + FAR const struct nxgl_point_s *origin, + unsigned int stride); ++
+ Description: + Copy a rectangular region of a larger image into the rectangle in the + specified window. +
++ Input Parameters: +
hwnd
+ nx_openwindow()
+ or nx_requestbkgd() that specifies the
+ window that will receive the bitmap image.
+ dest
+ src
+ CONFIG_NX_NPLANES (probably 1).
+ origin
+ stride
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_kbdin()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +#ifdef CONFIG_NX_KBD +int nx_kbdchin(NXHANDLE handle, ubyte ch); +int nx_kbdin(NXHANDLE handle, ubyte nch, FAR const ubyte *ch); +#endif ++
+ Description: + Used by a thread or interrupt handler that manages some kind of keypad + hardware to report text information to the NX server. That text + data will be routed by the NX server to the appropriate window client. +
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nx_mousein()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> + +#ifdef CONFIG_NX_MOUSE +int nx_mousein(NXHANDLE handle, nxgl_coord_t x, nxgl_coord_t y, ubyte buttons); +#endif ++
+ Description: + Used by a thread or interrupt handler that manages some kind of pointing + hardware to report new positional data to the NX server. That positional + data will be routed by the NX server to the appropriate window client. +
++ Input Parameters: +
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
NXTK)NXTK Types()+ This is the handle that can be used to access the window data region. +
++typedef FAR void *NXTKWINDOW; ++ +
nxtk_openwindow()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +NXTKWINDOW nxtk_openwindow(NXHANDLE handle, + FAR const struct nx_callback_s *cb, + FAR void *arg); ++
+ Description: Create a new, framed window. +
++ Input Parameters: +
handle
+ nx_connect()
+ or nx_open().
+ cb
+ arg
+ nx_openwindow())
+ + Returned Value: +
+errno is set appropriately.
+nxtk_closewindow()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_closewindow(NXTKWINDOW hfwnd); ++
+ Description:
+ Close the window opened by nxtk_openwindow().
+
+ Input Parameters: +
hfwnd
+ nxtk_openwindow().
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_getposition()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_getposition(NXTKWINDOW hfwnd); ++
+ Description: + Request the position and size information for the selected framed window. + The size/position for the client window and toolbar will be return + asynchronously through the client callback function pointer. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow().
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_setposition()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_setposition(NXTKWINDOW hfwnd, FAR struct nxgl_point_s *pos); ++
+ Description: + Set the position for the selected client window. This position does not + include the offsets for the borders nor for any toolbar. Those offsets + will be added in to set the full window position. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow().
+ pos
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_setsize()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_setsize(NXTKWINDOW hfwnd, FAR struct nxgl_size_s *size); ++
+ Description: + Set the size for the selected client window. This size does not + include the sizes of the borders nor for any toolbar. Those sizes + will be added in to set the full window size. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow().
+ size
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_raise()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_raise(NXTKWINDOW hfwnd); ++
+ Description: + Bring the window containing the specified client sub-window to the top + of the display. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow()
+ specifying the window to be raised.
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_lower()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_lower(NXTKWINDOW hfwnd); ++
+ Description: + Lower the window containing the specified client sub-window to the + bottom of the display. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow()
+ specifying the window to be lowered.
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_fillwindow()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_fillwindow(NXTKWINDOW hfwnd, FAR const struct nxgl_rect_s *rect, + nxgl_mxpixel_t color[CONFIG_NX_NPLANES]); ++
+ Description: + Fill the specified rectangle in the client window with the specified color. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow().
+ rect
+ color
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_filltrapwindow()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_filltrapwindow(NXTKWINDOW hfwnd, + FAR const struct nxgl_trapezoid_s *trap, + nxgl_mxpixel_t color[CONFIG_NX_NPLANES]); ++
+ Description: + Fill the specified trapezoid in the client window with the specified color +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow().
+ trap
+ color
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_movewindow()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_movewindow(NXTKWINDOW hfwnd, FAR const struct nxgl_rect_s *rect, + FAR const struct nxgl_point_s *offset); ++
+ Description: + Move a rectangular region within the client sub-window of a framed window. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow()
+ specifying the client sub-window within which the move is to be done.
+ rect
+ offset
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_bitmapwindow()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_bitmapwindow(NXTKWINDOW hfwnd, + FAR const struct nxgl_rect_s *dest, + FAR const void *src[CONFIG_NX_NPLANES], + FAR const struct nxgl_point_s *origin, + unsigned int stride); ++
+ Description: + Copy a rectangular region of a larger image into the rectangle in the + specified client sub-window. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow()
+ specifying the client sub-window that will receive the bitmap.
+ dest
+ src
+ CONFIG_NX_NPLANES (probably 1).
+ origin
+ stride
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_opentoolbar()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_opentoolbar(NXTKWINDOW hfwnd, nxgl_coord_t height, + FAR const struct nx_callback_s *cb, + FAR void *arg); ++
+ Description: + Create a tool bar at the top of the specified framed window. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow().
+ height
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_closetoolbar()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_closetoolbar(NXTKWINDOW hfwnd); ++
+ Description: + Remove the tool bar at the top of the specified framed window. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow().
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_filltoolbar()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_filltoolbar(NXTKWINDOW hfwnd, FAR const struct nxgl_rect_s *rect, + nxgl_mxpixel_t color[CONFIG_NX_NPLANES]); ++
+ Description: + Fill the specified rectangle in the toolbar sub-window with the specified color. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow().
+ rect
+ color
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_filltraptoolbar()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_filltraptoolbar(NXTKWINDOW hfwnd, FAR const struct nxgl_trapezoid_s *trap, + nxgl_mxpixel_t color[CONFIG_NX_NPLANES]); ++
+ Description: + Fill the specified trapezoid in the toolbar sub-window with the specified color. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow().
+ trap
+ color
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_movetoolbar()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_movetoolbar(NXTKWINDOW hfwnd, FAR const struct nxgl_rect_s *rect, + FAR const struct nxgl_point_s *offset); ++
+ Description: + Move a rectangular region within the toolbar sub-window of a framed window. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow().
+ rect
+ offset
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
nxtk_bitmaptoolbar()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nx.h> +#include <nuttx/nxtk.h> + +int nxtk_bitmaptoolbar(NXTKWINDOW hfwnd, + FAR const struct nxgl_rect_s *dest, + FAR const void *src[CONFIG_NX_NPLANES], + FAR const struct nxgl_point_s *origin, + unsigned int stride); ++
+ Description: + Copy a rectangular region of a larger image into the rectangle in the + specified toolbar sub-window. +
++ Input Parameters: +
hfwnd
+ nxtk_openwindow().
+ dest
+ src
+ origin
+ stride
+
+ Returned Value:
+ OK on success;
+ ERROR on failure with errno set appropriately
+
NXFONTS)NXFONTS Types()+ This structures provides the metrics for one glyph: +
+
+struct nx_fontmetic_s
+{
+ uint32 stride : 2; /* Width of one font row in bytes */
+ uint32 width : 6; /* Width of the font in bits */
+ uint32 height : 6; /* Height of the font in rows */
+ uint32 xoffset : 6; /* Top, left-hand corner X-offset in pixels */
+ uint32 yoffset : 6; /* Top, left-hand corner y-offset in pixels */
+ uint32 unused : 6;
+};
+
+
++ This structure binds the glyph metrics to the glyph bitmap: +
+
+struct nx_fontbitmap_s
+{
+ struct nx_fontmetic_s metric; /* Character metrics */
+ FAR const ubyte *bitmap; /* Pointer to the character bitmap */
+};
+
+
+
+ This structure describes one contiguous grouping of glyphs that
+ can be described by an array starting with encoding first and
+ extending through (first + nchars - 1).
+
+struct nx_fontset_s
+{
+ ubyte first; /* First bitmap character code */
+ ubyte nchars; /* Number of bitmap character codes */
+ FAR const struct nx_fontbitmap_s *bitmap;
+};
+
+
++ This structure describes the overall fontset: +
+
+struct nx_font_s
+{
+ ubyte mxheight; /* Max height of one glyph in rows */
+ ubyte mxwidth; /* Max width of any glyph in pixels */
+ ubyte mxbits; /* Max number of bits per character code */
+ ubyte spwidth; /* The width of a space in pixels */
+};
+
+
+nxf_getfontset()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nxfonts.h> + +FAR const struct nx_font_s *nxf_getfontset(void); ++
+ Description: + Return information about the current font set. +
++ Input Parameters: None +
+
+ Returned Value:
+ An instance of struct nx_font_s describing the font set.
+
nxf_getbitmap()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nxfonts.h> + +FAR const struct nx_fontbitmap_s *nxf_getbitmap(uint16 ch); ++
+ Description: + Return font bitmap information for the selected character encoding. +
++ Input Parameters: +
+ Returned Value:
+ An instance of struct nx_fontbitmap_s describing the glyph.
+
nxf_convert_*bpp()Function Prototype:
++#include <nuttx/nxglib.h> +#include <nuttx/nxfonts.h> + +int nxf_convert_2bpp(FAR ubyte *dest, uint16 height, + uint16 width, uint16 stride, uint16 ch, + nxgl_mxpixel_t color); +int nxf_convert_4bpp(FAR ubyte *dest, uint16 height, + uint16 width, uint16 stride, uint16 ch, + nxgl_mxpixel_t color); +int nxf_convert_8bpp(FAR ubyte *dest, uint16 height, + uint16 width, uint16 stride, uint16 ch, + nxgl_mxpixel_t color); +int nxf_convert_16bpp(FAR uint16 *dest, uint16 height, + uint16 width, uint16 stride, uint16 ch, + nxgl_mxpixel_t color); +int nxf_convert_24bpp(FAR uint32 *dest, uint16 height, + uint16 width, uint16 stride, uint16 ch, + nxgl_mxpixel_t color); +int nxf_convert_32bpp(FAR uint32 *dest, uint16 height, + uint16 width, uint16 stride, uint16 ch, + nxgl_mxpixel_t color); ++
+ Description: Convert the 1BPP font to a new pixel depth. +
++ Input Parameters: +
dest
+ height
+ width
+ stride
+ ch
+ color
+
+ Returned Value:
+ On Success, these functions returns the actual width of the font in bytes.
+ on failed, a negated errno is retured.
+
+ Appendix A
+ |
+
graphics/nxglib
+ graphics/nxbe
+ nxmu and nxsu/ below).
+ It contains most of the important window management logic: clipping, window controls,
+ window drawing, etc.
+
+ graphics/nxsu
+ - This is the NX single user front end.
+ When combined with the generic back-end (
nxbe), it implements a
+ single threaded, single user windowing system.
+ The files in this directory present the window APIs described in
+ include/nuttx/nx.h.
+ The single user front-end is selected when CONFIG_NX_MULTIUSER is not
+ defined in the NuttX configuration file.
+
+ graphics/nxsu
+ - This is the NX multi user front end.
+ When combined with the generic back-end (
nxbe), it implements a
+ multi-threaded, multi-user windowing system.
+ The files in this directory present the window APIs described in
+ include/nuttx/nx.h.
+ The multi-user front end includes a graphics server that executes on its own thread;
+ multiple graphics clients then communicate with the server via a POSIX message
+ queue to serialize window operations from many threads.
+ The multi-user front-end is selected when CONFIG_NX_MULTIUSER is defined
+ in the NuttX configuration file.
+
+ graphics/nxfonts
+ - This is where the NXFONTS implementation resides.
+ This is a relatively low-level set of charset set/glyph management APIs.
+ See
include/nuttx/nxfonts.h.
+
+ graphics/nxtk
+ - This is where the NXTOOLKIT implementation resides.
+ This toolkit is built on top of NX and works with either the single-user or
+ multi-user NX version.
+ See
include/nuttx/nxtk.h.
+
+ graphics/nxwidgets
+ - At one time, I planned to put NXWIDGETS implementation here, but not anymore.
+
+ Appendix B NX Configuration Options+ |
+
CONFIG_NX
+ Enables overall support for graphics library and NX
+ CONFIG_NX_NPLANES:
+ CONFIG_NX_DISABLE_1BPP, CONFIG_NX_DISABLE_2BPP,
+ CONFIG_NX_DISABLE_4BPP, CONFIG_NX_DISABLE_8BPP
+ CONFIG_NX_DISABLE_16BPP, CONFIG_NX_DISABLE_24BPP, and
+ CONFIG_NX_DISABLE_32BPP:
+ CONFIG_NX_PACKEDMSFIRST:
+ CONFIG_NX_MOUSE:
+ CONFIG_NX_KBD:
+ CONFIG_NX_MULTIUSER:
+ CONFIG_NX_BLOCKING
+ nx_eventhandler() will not return until a message is received and processed.
+ CONFIG_NX_MXSERVERMSGS and CONFIG_NX_MXCLIENTMSGS
+ CONFIG_PREALLOC_MQ_MSGS controls how many
+ messages are pre-allocated).
+ CONFIG_NXTK_BORDERWIDTH:
+ CONFIG_NXTK_BORDERCOLOR1 and CONFIG_NXTK_BORDERCOLOR2:
+ CONFIG_NXTK_BORDERCOLOR2 is the shadow side color and so
+ CONFIG_NXTK_AUTORAISE:
+ CONFIG_NXFONTS_CHARBITS:
+ CONFIG_NXFONT_SANS:
+
+ Appendix C NX Test Coverage+ |
+
+ The primary test tool for debugging NX resides at examples/nx.
+ At present, that test only exercises a subset of NX; the remainder is essentially
+ untested.
+ The following table describes the testing performed on each NX API:
+
| To be provided |
|---|
-
+ + NuttX RTOS Porting Guide ++Last Updated: December 5, 2008 + |
+
NuttX Operating System - Porting Guide
- -by
-Gregory Nutt
-Last Update: December 5, 2008
-
+ Table of Contents+ |
+
up_initialize()up_idle()up_initial_state()up_create_stack()up_use_stack()up_release_stack()up_unblock_task()up_block_task()up_release_pending()up_reprioritize_rtr()_exit()up_assert()up_schedule_sigaction()up_allocate_heap()up_interrupt_context()up_disable_irq()up_enable_irq()up_putc()os_start()sched_process_timer()irq_dispatch()up_initialize()up_idle()up_initial_state()up_create_stack()up_use_stack()up_release_stack()up_unblock_task()up_block_task()up_release_pending()up_reprioritize_rtr()_exit()up_assert()up_schedule_sigaction()up_allocate_heap()up_interrupt_context()up_disable_irq()up_enable_irq()up_prioritize_irq()
+ 4.1.19 up_putc()
+
+ 1.0 Introduction+ |
+
Overview
This document provides and overview of the NuttX build and configuration
@@ -104,10 +119,13 @@
See also arch/README.txt and configs/README.txt.
General Philosophy. - -
+ 2.0 Directory Structure+ |
+
Directory Structure.
@@ -868,8 +886,14 @@ tools/
Use of this Makefile to build NuttX is described below.
+ 3.0 Configuring and Building+ |
+
Manual Configuration.
@@ -948,7 +972,13 @@ The system can be re-made subsequently by just typing make.
+ 4.0 Architecture APIs+ |
+
The file include/nuttx/arch.h identifies by prototype all of the APIs that must
@@ -1285,28 +1315,76 @@ The system can be re-made subsequently by just typing make.
up_disable_irq()Prototype: void up_disable_irq(int irq);
Prototype:
++#ifndef CONFIG_ARCH_NOINTC + void up_disable_irq(int irq); +#endf +
Description. Disable the IRQ specified by 'irq' + On many architectures, there are three levels of interrupt enabling: (1) + at the global level, (2) at the level of the interrupt controller, + and (3) at the device level. In order to receive interrupts, they + must be enabled at all three levels. +
++ This function implements enabling of the device specified by 'irq' + at the interrupt controller level if supported by the architecture + (irqsave() supports the global level, the device level is hardware + specific). +
+ If the architecture does not support up_disable_irq,
+ CONFIG_ARCH_NOINTC should be defined in the NuttX configuration file.
+ Since this API cannot be supported on all architectures, it should be
+ avoided in common implementations where possible.
up_enable_irq()Prototype: void up_enable_irq(int irq);
Prototype:
++#ifndef CONFIG_ARCH_NOINTC + void up_enable_irq(int irq); +#endf +
Description. - Enable the IRQ specified by 'irq' + This function implements disabling of the device specified by 'irq' + at the interrupt controller level if supported by the architecture + (irqrestore() supports the global level, the device level is hardware + specific). +
+
+ If the architecture does not support up_disable_irq,
+ CONFIG_ARCH_NOINTC should be defined in the NuttX configuration file.
+ Since this API cannot be supported on all architectures, it should be
+ avoided in common implementations where possible.
up_putc()up_prioritize_irq()Prototype:
++#ifdef CONFIG_ARCH_IRQPRIO + void up_enable_irq(int irq); +#endf ++
Description. + Set the priority of an IRQ. +
+
+ If the architecture supports up_enable_irq,
+ CONFIG_ARCH_IRQPRIO should be defined in the NuttX configuration file.
+ Since this API cannot be supported on all architectures, it should be
+ avoided in common implementations where possible.
+
up_putc()Prototype: int up_putc(int ch);
Description. This is a debug interface exported by the architecture-specific logic. Output one character on the console -
- This API is NOT required if CONFIG_HEAP_BASE
- is defined.
make.
the appropriate, registered handling logic.
-
+ 5.0 NuttX File System+ |
+
Overview.
NuttX includes an optional, scalable file system.
@@ -1395,7 +1479,13 @@ The system can be re-made subsequently by just typing make.
from the very tiny platform to the moderate platform.
+ Appendix A: NuttX Configuration Settings+ |
+
The following variables are recognized by the build (you may
@@ -1977,7 +2067,13 @@ The system can be re-made subsequently by just typing make.
+ Appendix B: Trademarks+ |
+