int serdis_main(int argc, char *argv[])
#endif
{
struct boardioc_usbdev_ctrl_s ctrl;
/* First check if the USB mass storage device is already connected */
if (!g_cdcacm.handle)
{
printf("serdis: ERROR: Not connected\n");
return EXIT_FAILURE;
}
/* Then, in any event, disable trace data collection as configured BEFORE
* enabling the CDC/ACM device.
*/
usbtrace_enable(0);
/* Then disconnect the device and uninitialize the USB mass storage driver */
ctrl.usbdev = BOARDIOC_USBDEV_CDCACM;
ctrl.action = BOARDIOC_USBDEV_DISCONNECT;
ctrl.instance = CONFIG_SYSTEM_CDCACM_DEVMINOR;
ctrl.handle = &g_cdcacm.handle;
(void)boardctl(BOARDIOC_USBDEV_CONTROL, (uintptr_t)&ctrl);
g_cdcacm.handle = NULL;
printf("serdis: Disconnected\n");
return EXIT_SUCCESS;
}
void symtab_initialize(void)
{
/* We set the symbol table indirectly through the boardctl() */
struct boardioc_symtab_s symdesc;
symdesc.symtab = g_symtab;
symdesc.nsymbols = NSYMBOLS;
(void)boardctl(BOARDIOC_SYMTAB, (uintptr_t)&symdesc);
}
int sercon_main(int argc, char *argv[])
#endif
{
struct boardioc_usbdev_ctrl_s ctrl;
int ret;
/* Check if there is a non-NULL USB mass storage device handle (meaning that the
* USB mass storage device is already configured).
*/
if (g_cdcacm.handle)
{
printf("sercon:: ERROR: Already connected\n");
return EXIT_FAILURE;
}
/* Then, in any event, enable trace data collection as configured BEFORE
* enabling the CDC/ACM device.
*/
usbtrace_enable(TRACE_BITSET);
/* Initialize the USB CDC/ACM serial driver */
printf("sercon: Registering CDC/ACM serial driver\n");
ctrl.usbdev = BOARDIOC_USBDEV_CDCACM;
ctrl.action = BOARDIOC_USBDEV_CONNECT;
ctrl.instance = CONFIG_SYSTEM_CDCACM_DEVMINOR;
ctrl.handle = &g_cdcacm.handle;
ret = boardctl(BOARDIOC_USBDEV_CONTROL, (uintptr_t)&ctrl);
if (ret < 0)
{
printf("sercon: ERROR: Failed to create the CDC/ACM serial device: %d\n", -ret);
return EXIT_FAILURE;
}
printf("sercon: Successfully registered the CDC/ACM serial driver\n");
return EXIT_SUCCESS;
}
static inline int nximage_initialize(void)
{
FAR NX_DRIVERTYPE *dev;
#if defined(CONFIG_EXAMPLES_NXIMAGE_EXTERNINIT)
struct boardioc_graphics_s devinfo;
int ret;
/* Use external graphics driver initialization */
printf("nximage_initialize: Initializing external graphics device\n");
devinfo.devno = CONFIG_EXAMPLES_NXIMAGE_DEVNO;
devinfo.dev = NULL;
ret = boardctl(BOARDIOC_GRAPHICS_SETUP, (uintptr_t)&devinfo);
if (ret < 0)
{
printf("nximage_initialize: boardctl failed, devno=%d: %d\n",
CONFIG_EXAMPLES_NXIMAGE_DEVNO, errno);
g_nximage.code = NXEXIT_EXTINITIALIZE;
return ERROR;
}
dev = devinfo.dev;
#elif defined(CONFIG_NX_LCDDRIVER)
int ret;
/* Initialize the LCD device */
printf("nximage_initialize: Initializing LCD\n");
ret = board_lcd_initialize();
if (ret < 0)
{
printf("nximage_initialize: board_lcd_initialize failed: %d\n", -ret);
g_nximage.code = NXEXIT_LCDINITIALIZE;
return ERROR;
}
/* Get the device instance */
dev = board_lcd_getdev(CONFIG_EXAMPLES_NXIMAGE_DEVNO);
if (!dev)
{
printf("nximage_initialize: board_lcd_getdev failed, devno=%d\n",
CONFIG_EXAMPLES_NXIMAGE_DEVNO);
g_nximage.code = NXEXIT_LCDGETDEV;
return ERROR;
}
/* Turn the LCD on at 75% power */
(void)dev->setpower(dev, ((3*CONFIG_LCD_MAXPOWER + 3)/4));
#else
int ret;
/* Initialize the frame buffer device */
printf("nximage_initialize: Initializing framebuffer\n");
ret = up_fbinitialize(0);
if (ret < 0)
{
printf("nximage_initialize: up_fbinitialize failed: %d\n", -ret);
g_nximage.code = NXEXIT_FBINITIALIZE;
return ERROR;
}
dev = up_fbgetvplane(0, CONFIG_EXAMPLES_NXIMAGE_VPLANE);
if (!dev)
{
printf("nximage_initialize: up_fbgetvplane failed, vplane=%d\n",
CONFIG_EXAMPLES_NXIMAGE_VPLANE);
g_nximage.code = NXEXIT_FBGETVPLANE;
return ERROR;
}
#endif
/* Then open NX */
printf("nximage_initialize: Open NX\n");
g_nximage.hnx = nx_open(dev);
if (!g_nximage.hnx)
{
printf("nximage_initialize: nx_open failed: %d\n", errno);
g_nximage.code = NXEXIT_NXOPEN;
return ERROR;
}
return OK;
}
int adc_main(int argc, char *argv[])
#endif
{
struct adc_msg_s sample[CONFIG_EXAMPLES_ADC_GROUPSIZE];
size_t readsize;
ssize_t nbytes;
int fd;
int errval = 0;
int ret;
int i;
/* Check if we have initialized */
if (!g_adcstate.initialized)
{
/* Initialization of the ADC hardware is performed by logic external to
* this test.
*/
printf("adc_main: Initializing external ADC device\n");
ret = boardctl(BOARDIOC_ADCTEST_SETUP, 0);
if (ret < 0)
{
printf("adc_main: boardctl failed: %d\n", errno);
errval = 1;
goto errout;
}
/* Set the default values */
adc_devpath(&g_adcstate, CONFIG_EXAMPLES_ADC_DEVPATH);
#if CONFIG_EXAMPLES_ADC_NSAMPLES > 0
g_adcstate.count = CONFIG_EXAMPLES_ADC_NSAMPLES;
#else
g_adcstate.count = 1;
#endif
g_adcstate.initialized = true;
}
/* Parse the command line */
#ifdef CONFIG_NSH_BUILTIN_APPS
parse_args(&g_adcstate, argc, argv);
#endif
/* If this example is configured as an NX add-on, then limit the number of
* samples that we collect before returning. Otherwise, we never return
*/
#if defined(CONFIG_NSH_BUILTIN_APPS) || CONFIG_EXAMPLES_ADC_NSAMPLES > 0
printf("adc_main: g_adcstate.count: %d\n", g_adcstate.count);
#endif
/* Open the ADC device for reading */
printf("adc_main: Hardware initialized. Opening the ADC device: %s\n",
g_adcstate.devpath);
fd = open(g_adcstate.devpath, O_RDONLY);
if (fd < 0)
{
printf("adc_main: open %s failed: %d\n", g_adcstate.devpath, errno);
errval = 2;
goto errout;
}
/* Now loop the appropriate number of times, displaying the collected
* ADC samples.
*/
#if defined(CONFIG_NSH_BUILTIN_APPS)
for (; g_adcstate.count > 0; g_adcstate.count--)
#elif CONFIG_EXAMPLES_ADC_NSAMPLES > 0
for (g_adcstate.count = 0; g_adcstate.count < CONFIG_EXAMPLES_ADC_NSAMPLES; g_adcstate.count++)
#else
for (;;)
#endif
{
/* Flush any output before the loop entered or from the previous pass
* through the loop.
*/
fflush(stdout);
#ifdef CONFIG_EXAMPLES_ADC_SWTRIG
/* Issue the software trigger to start ADC conversion */
ret = ioctl(fd, ANIOC_TRIGGER, 0);
if (ret < 0)
{
int errcode = errno;
printf("adc_main: ANIOC_TRIGGER ioctl failed: %d\n", errcode);
}
#endif
/* Read up to CONFIG_EXAMPLES_ADC_GROUPSIZE samples */
readsize = CONFIG_EXAMPLES_ADC_GROUPSIZE * sizeof(struct adc_msg_s);
nbytes = read(fd, sample, readsize);
/* Handle unexpected return values */
if (nbytes < 0)
{
errval = errno;
if (errval != EINTR)
{
printf("adc_main: read %s failed: %d\n",
g_adcstate.devpath, errval);
errval = 3;
goto errout_with_dev;
}
printf("adc_main: Interrupted read...\n");
}
else if (nbytes == 0)
{
printf("adc_main: No data read, Ignoring\n");
}
/* Print the sample data on successful return */
else
{
int nsamples = nbytes / sizeof(struct adc_msg_s);
if (nsamples * sizeof(struct adc_msg_s) != nbytes)
{
printf("adc_main: read size=%ld is not a multiple of sample size=%d, Ignoring\n",
(long)nbytes, sizeof(struct adc_msg_s));
}
else
{
printf("Sample:\n");
for (i = 0; i < nsamples ; i++)
{
printf("%d: channel: %d value: %d\n",
i+1, sample[i].am_channel, sample[i].am_data);
}
}
}
}
close(fd);
return OK;
/* Error exits */
errout_with_dev:
close(fd);
errout:
printf("Terminating!\n");
fflush(stdout);
return errval;
}
int usbterm_main(int argc, char *argv[])
#endif
{
struct boardioc_usbdev_ctrl_s ctrl;
FAR void *handle;
pthread_attr_t attr;
int ret;
/* Initialize global data */
memset(&g_usbterm, 0, sizeof(struct usbterm_globals_s));
/* Initialization of the USB hardware may be performed by logic external to
* this test.
*/
#ifdef CONFIG_EXAMPLES_USBTERM_DEVINIT
printf("usbterm_main: Performing external device initialization\n");
ret = usbterm_devinit();
if (ret != OK)
{
printf("usbterm_main: usbterm_devinit failed: %d\n", ret);
goto errout;
}
#endif
/* Initialize the USB serial driver */
printf("usbterm_main: Registering USB serial driver\n");
#ifdef CONFIG_CDCACM
ctrl.usbdev = BOARDIOC_USBDEV_CDCACM;
ctrl.action = BOARDIOC_USBDEV_CONNECT;
ctrl.instance = 0;
ctrl.handle = &handle;
#else
ctrl.usbdev = BOARDIOC_USBDEV_PL2303;
ctrl.action = BOARDIOC_USBDEV_CONNECT;
ctrl.instance = 0;
ctrl.handle = &handle;
#endif
ret = boardctl(BOARDIOC_USBDEV_CONTROL, (uintptr_t)&ctrl);
if (ret < 0)
{
printf("usbterm_main: ERROR: Failed to create the USB serial device: %d\n", -ret);
goto errout_with_devinit;
}
printf("usbterm_main: Successfully registered the serial driver\n");
#if defined(CONFIG_USBDEV_TRACE) && CONFIG_USBDEV_TRACE_INITIALIDSET != 0
/* If USB tracing is enabled and tracing of initial USB events is specified,
* then dump all collected trace data to stdout
*/
sleep(5);
dumptrace();
#endif
/* Then, in any event, configure trace data collection as configured */
usbtrace_enable(TRACE_BITSET);
/* Open the USB serial device for writing */
do
{
printf("usbterm_main: Opening USB serial driver\n");
g_usbterm.outstream = fopen(USBTERM_DEVNAME, "w");
if (g_usbterm.outstream == NULL)
{
int errcode = errno;
printf("usbterm_main: ERROR: Failed to open " USBTERM_DEVNAME " for writing: %d\n",
errcode);
/* ENOTCONN means that the USB device is not yet connected */
if (errcode == ENOTCONN)
{
printf("usbterm_main: Not connected. Wait and try again.\n");
sleep(5);
}
else
{
/* Give up on other errors */
goto errout_with_devinit;
}
}
/* If USB tracing is enabled, then dump all collected trace data to stdout */
dumptrace();
}
while (g_usbterm.outstream == NULL);
/* Open the USB serial device for reading. Since we are already connected, this
* should not fail.
*/
g_usbterm.instream = fopen(USBTERM_DEVNAME, "r");
if (g_usbterm.instream == NULL)
{
printf("usbterm_main: ERROR: Failed to open " USBTERM_DEVNAME " for reading: %d\n", errno);
goto errout_with_outstream;
}
printf("usbterm_main: Successfully opened the serial driver\n");
/* Start the USB term listener thread */
printf("usbterm_main: Starting the listener thread\n");
ret = pthread_attr_init(&attr);
if (ret != OK)
{
printf("usbterm_main: pthread_attr_init failed: %d\n", ret);
goto errout_with_streams;
}
ret = pthread_create(&g_usbterm.listener, &attr,
usbterm_listener, (pthread_addr_t)0);
if (ret != 0)
{
printf("usbterm_main: Error in thread creation: %d\n", ret);
goto errout_with_streams;
}
/* Send messages and get responses -- forever */
printf("usbterm_main: Waiting for local input\n");
for (;;)
{
/* Display the prompt string on stdout */
fputs("usbterm> ", stdout);
fflush(stdout);
/* Get the next line of input */
#ifdef CONFIG_EXAMPLES_USBTERM_FGETS
/* fgets returns NULL on end-of-file or any I/O error */
if (fgets(g_usbterm.outbuffer, CONFIG_EXAMPLES_USBTERM_BUFLEN, stdin) == NULL)
{
printf("ERROR: fgets failed: %d\n", errno);
return 1;
}
#else
ret = readline(g_usbterm.outbuffer, CONFIG_EXAMPLES_USBTERM_BUFLEN, stdin, stdout);
/* Readline normally returns the number of characters read,
* but will return EOF on end of file or if an error occurs. Either
* will cause the session to terminate.
*/
if (ret == EOF)
{
printf("ERROR: readline failed: %d\n", ret);
return 1;
}
#endif
/* Is there anyone listening on the other end? */
else if (g_usbterm.peer)
{
/* Yes.. Send the line of input via USB */
fputs(g_usbterm.outbuffer, g_usbterm.outstream);
/* Display the prompt string on the remote USB serial connection */
fputs("\rusbterm> ", g_usbterm.outstream);
fflush(g_usbterm.outstream);
}
else
{
printf("Still waiting for remote peer. Please try again later.\n");
}
/* If USB tracing is enabled, then dump all collected trace data to stdout */
dumptrace();
}
/* Error exits */
errout_with_streams:
fclose(g_usbterm.instream);
errout_with_outstream:
fclose(g_usbterm.outstream);
errout_with_devinit:
#ifdef CONFIG_EXAMPLES_USBTERM_DEVINIT
usbterm_devuninit();
errout:
#endif
printf("usbterm_main: Aborting\n");
return 1;
}
int nx_servertask(int argc, char *argv[])
{
FAR NX_DRIVERTYPE *dev;
int ret;
#if defined(CONFIG_EXAMPLES_NX_EXTERNINIT)
/* Use external graphics driver initialization */
printf("nxeg_initialize: Initializing external graphics device\n");
dev = boardctl(BOARDIOC_GRAPHICS_SETUP, CONFIG_EXAMPLES_NX_DEVNO);
if (!dev)
{
printf("nxeg_initialize: boardctl failed, devno=%d\n",
CONFIG_EXAMPLES_NX_DEVNO);
g_exitcode = NXEXIT_EXTINITIALIZE;
return ERROR;
}
#elif defined(CONFIG_NX_LCDDRIVER)
/* Initialize the LCD device */
printf("nx_servertask: Initializing LCD\n");
ret = board_lcd_initialize();
if (ret < 0)
{
printf("nx_servertask: board_lcd_initialize failed: %d\n", -ret);
return 1;
}
/* Get the device instance */
dev = board_lcd_getdev(CONFIG_EXAMPLES_NX_DEVNO);
if (!dev)
{
printf("nx_servertask: board_lcd_getdev failed, devno=%d\n",
CONFIG_EXAMPLES_NX_DEVNO);
return 2;
}
/* Turn the LCD on at 75% power */
(void)dev->setpower(dev, ((3*CONFIG_LCD_MAXPOWER + 3)/4));
#else
/* Initialize the frame buffer device */
printf("nx_servertask: Initializing framebuffer\n");
ret = up_fbinitialize();
if (ret < 0)
{
printf("nx_servertask: up_fbinitialize failed: %d\n", -ret);
return 1;
}
dev = up_fbgetvplane(CONFIG_EXAMPLES_NX_VPLANE);
if (!dev)
{
printf("nx_servertask: up_fbgetvplane failed, vplane=%d\n", CONFIG_EXAMPLES_NX_VPLANE);
return 2;
}
#endif
/* Then start the server */
ret = nx_run(dev);
printf("nx_servertask: nx_run returned: %d\n", errno);
return 3;
}
int tc_main(int argc, char *argv[])
#endif
{
#ifdef CONFIG_EXAMPLES_TOUCHSCREEN_MOUSE
struct mouse_report_s sample;
#else
struct touch_sample_s sample;
#endif
ssize_t nbytes;
#if defined(CONFIG_NSH_BUILTIN_APPS) || CONFIG_EXAMPLES_TOUCHSCREEN_NSAMPLES > 0
long nsamples;
#endif
int fd;
int errval = 0;
#ifdef CONFIG_EXAMPLES_TOUCHSCREEN_ARCHINIT
int ret;
#endif
/* If this example is configured as an NX add-on, then limit the number of
* samples that we collect before returning. Otherwise, we never return
*/
#if defined(CONFIG_NSH_BUILTIN_APPS)
nsamples = 1;
if (argc > 1)
{
nsamples = strtol(argv[1], NULL, 10);
}
printf("tc_main: nsamples: %d\n", nsamples);
#elif CONFIG_EXAMPLES_TOUCHSCREEN_NSAMPLES > 0
printf("tc_main: nsamples: %d\n", CONFIG_EXAMPLES_TOUCHSCREEN_NSAMPLES);
#endif
#ifdef CONFIG_EXAMPLES_TOUCHSCREEN_ARCHINIT
/* Initialization of the touchscreen hardware is performed by logic
* external to this test.
*/
printf("tc_main: Initializing external touchscreen device\n");
ret = boardctl(BOARDIOC_TSCTEST_SETUP, CONFIG_EXAMPLES_TOUCHSCREEN_MINOR);
if (ret != OK)
{
printf("tc_main: board_tsc_setup failed: %d\n", errno);
errval = 1;
goto errout;
}
#endif
/* Open the touchscreen device for reading */
printf("tc_main: Opening %s\n", CONFIG_EXAMPLES_TOUCHSCREEN_DEVPATH);
fd = open(CONFIG_EXAMPLES_TOUCHSCREEN_DEVPATH, O_RDONLY);
if (fd < 0)
{
printf("tc_main: open %s failed: %d\n",
CONFIG_EXAMPLES_TOUCHSCREEN_DEVPATH, errno);
errval = 2;
goto errout_with_tc;
}
/* Now loop the appropriate number of times, displaying the collected
* touchscreen samples.
*/
#if defined(CONFIG_NSH_BUILTIN_APPS)
for (; nsamples > 0; nsamples--)
#elif CONFIG_EXAMPLES_TOUCHSCREEN_NSAMPLES > 0
for (nsamples = 0; nsamples < CONFIG_EXAMPLES_TOUCHSCREEN_NSAMPLES; nsamples++)
#else
for (;;)
#endif
{
/* Flush any output before the loop entered or from the previous pass
* through the loop.
*/
fflush(stdout);
#ifdef CONFIG_EXAMPLES_TOUCHSCREEN_MOUSE
/* Read one sample */
ivdbg("Reading...\n");
nbytes = read(fd, &sample, sizeof(struct mouse_report_s));
ivdbg("Bytes read: %d\n", nbytes);
/* Handle unexpected return values */
if (nbytes < 0)
{
errval = errno;
if (errval != EINTR)
{
printf("tc_main: read %s failed: %d\n",
CONFIG_EXAMPLES_TOUCHSCREEN_DEVPATH, errval);
errval = 3;
goto errout_with_dev;
}
printf("tc_main: Interrupted read...\n");
}
else if (nbytes != sizeof(struct mouse_report_s))
{
printf("tc_main: Unexpected read size=%d, expected=%d, Ignoring\n",
nbytes, sizeof(struct mouse_report_s));
}
/* Print the sample data on successful return */
else
{
printf("Sample :\n");
printf(" buttons : %02x\n", sample.buttons);
printf(" x : %d\n", sample.x);
printf(" y : %d\n", sample.y);
#ifdef CONFIG_MOUSE_WHEEL
printf(" wheel : %d\n", sample.wheel);
#endif
}
#else
/* Read one sample */
ivdbg("Reading...\n");
nbytes = read(fd, &sample, sizeof(struct touch_sample_s));
ivdbg("Bytes read: %d\n", nbytes);
/* Handle unexpected return values */
if (nbytes < 0)
{
errval = errno;
if (errval != EINTR)
{
printf("tc_main: read %s failed: %d\n",
CONFIG_EXAMPLES_TOUCHSCREEN_DEVPATH, errval);
errval = 3;
goto errout_with_dev;
}
printf("tc_main: Interrupted read...\n");
}
else if (nbytes != sizeof(struct touch_sample_s))
{
printf("tc_main: Unexpected read size=%ld, expected=%d, Ignoring\n",
(long)nbytes, sizeof(struct touch_sample_s));
}
/* Print the sample data on successful return */
else
{
printf("Sample :\n");
printf(" npoints : %d\n", sample.npoints);
printf("Point 1 :\n");
printf(" id : %d\n", sample.point[0].id);
printf(" flags : %02x\n", sample.point[0].flags);
printf(" x : %d\n", sample.point[0].x);
printf(" y : %d\n", sample.point[0].y);
printf(" h : %d\n", sample.point[0].h);
printf(" w : %d\n", sample.point[0].w);
printf(" pressure : %d\n", sample.point[0].pressure);
}
#endif
}
errout_with_dev:
close(fd);
errout_with_tc:
#ifdef CONFIG_EXAMPLES_TOUCHSCREEN_ARCHINIT
boardctl(BOARDIOC_TSCTEST_TEARDOWN, 0);
errout:
#endif
printf("Terminating!\n");
fflush(stdout);
return errval;
}
int nxterm_server(int argc, char *argv[])
{
FAR NX_DRIVERTYPE *dev;
int ret;
#if defined(CONFIG_EXAMPLES_NXTERM_EXTERNINIT)
struct boardioc_graphics_s devinfo;
int ret;
/* Use external graphics driver initialization */
printf("nxterm_server: Initializing external graphics device\n");
devinfo.devno = CONFIG_EXAMPLES_NXTERM_DEVNO;
devinfo.dev = NULL;
ret = boardctl(BOARDIOC_GRAPHICS_SETUP, (uintptr_t)&devinfo);
if (ret < 0)
{
printf("nxterm_server: boardctl failed, devno=%d: %d\n",
CONFIG_EXAMPLES_NXTERM_DEVNO, errno);
return ERROR;
}
dev = devinfo.dev;
#elif defined(CONFIG_NX_LCDDRIVER)
/* Initialize the LCD device */
printf("nxterm_server: Initializing LCD\n");
ret = board_lcd_initialize();
if (ret < 0)
{
printf("nxterm_server: board_lcd_initialize failed: %d\n", -ret);
return 1;
}
/* Get the device instance */
dev = board_lcd_getdev(CONFIG_EXAMPLES_NXTERM_DEVNO);
if (!dev)
{
printf("nxterm_server: board_lcd_getdev failed, devno=%d\n",
CONFIG_EXAMPLES_NXTERM_DEVNO);
return 2;
}
/* Turn the LCD on at 75% power */
(void)dev->setpower(dev, ((3*CONFIG_LCD_MAXPOWER + 3)/4));
#else
/* Initialize the frame buffer device */
printf("nxterm_server: Initializing framebuffer\n");
ret = up_fbinitialize(0);
if (ret < 0)
{
printf("nxterm_server: up_fbinitialize failed: %d\n", -ret);
return 1;
}
dev = up_fbgetvplane(0, CONFIG_EXAMPLES_NXTERM_VPLANE);
if (!dev)
{
printf("nxterm_server: up_fbgetvplane failed, vplane=%d\n",
CONFIG_EXAMPLES_NXTERM_VPLANE);
return 2;
}
#endif
/* Then start the server */
ret = nx_run(dev);
gvdbg("nx_run returned: %d\n", errno);
return 3;
}
int ostest_main(int argc, FAR char *argv[])
{
int result;
#ifdef CONFIG_EXAMPLES_OSTEST_WAITRESULT
int ostest_result = ERROR;
#else
int ostest_result = OK;
#endif
/* Verify that stdio works first */
stdio_test();
#ifdef SDCC
/* I am not yet certain why SDCC does not like the following initilizers.
* It involves some issues with 2- vs 3-byte pointer types.
*/
g_argv[0] = arg1;
g_argv[1] = arg2;
g_argv[2] = arg3;
g_argv[3] = arg4;
g_argv[4] = NULL;
#endif
/* Set up some environment variables */
#ifndef CONFIG_DISABLE_ENVIRON
printf("ostest_main: putenv(%s)\n", g_putenv_value);
putenv(g_putenv_value); /* Varaible1=BadValue3 */
printf("ostest_main: setenv(%s, %s, TRUE)\n", g_var1_name, g_var1_value);
setenv(g_var1_name, g_var1_value, TRUE); /* Variable1=GoodValue1 */
printf("ostest_main: setenv(%s, %s, FALSE)\n", g_var2_name, g_bad_value1);
setenv(g_var2_name, g_bad_value1, FALSE); /* Variable2=BadValue1 */
printf("ostest_main: setenv(%s, %s, TRUE)\n", g_var2_name, g_var2_value);
setenv(g_var2_name, g_var2_value, TRUE); /* Variable2=GoodValue2 */
printf("ostest_main: setenv(%s, %s, FALSE)\n", g_var3_name, g_var3_name);
setenv(g_var3_name, g_var3_value, FALSE); /* Variable3=GoodValue3 */
printf("ostest_main: setenv(%s, %s, FALSE)\n", g_var3_name, g_var3_name);
setenv(g_var3_name, g_bad_value2, FALSE); /* Variable3=GoodValue3 */
show_environment(true, true, true);
#endif
/* Verify that we can spawn a new task */
result = task_create("ostest", PRIORITY, STACKSIZE, user_main,
(FAR char * const *)g_argv);
if (result == ERROR)
{
printf("ostest_main: ERROR Failed to start user_main\n");
ostest_result = ERROR;
}
else
{
printf("ostest_main: Started user_main at PID=%d\n", result);
#ifdef CONFIG_EXAMPLES_OSTEST_WAITRESULT
/* Wait for the test to complete to get the test result */
if (waitpid(result, &ostest_result, 0) != result)
{
printf("ostest_main: ERROR Failed to wait for user_main to terminate\n");
ostest_result = ERROR;
}
#endif
}
printf("ostest_main: Exiting with status %d\n", ostest_result);
#ifdef CONFIG_EXAMPLES_OSTEST_POWEROFF
/* Power down, providing the test result. This is really only an
*interesting case when used with the NuttX simulator. In that case,
* test management logic can received the result of the test.
*/
boardctl(BOARDIOC_POWEROFF, ostest_result);
#endif
return ostest_result;
}
int can_main(int argc, FAR char *argv[])
#endif
{
struct canioc_bittiming_s bt;
#ifdef CONFIG_EXAMPLES_CAN_WRITE
struct can_msg_s txmsg;
#ifdef CONFIG_CAN_EXTID
bool extended = true;
uint32_t msgid;
#else
uint16_t msgid;
#endif
long minid = 1;
long maxid = MAX_ID;
int msgdlc;
uint8_t msgdata;
int i;
#endif
#ifdef CONFIG_EXAMPLES_CAN_READ
struct can_msg_s rxmsg;
#endif
size_t msgsize;
ssize_t nbytes;
bool badarg = false;
bool help = false;
#ifdef CONFIG_NSH_BUILTIN_APPS
long nmsgs = CONFIG_EXAMPLES_CAN_NMSGS;
long msgno;
#endif
int option;
int fd;
int errval = 0;
int ret;
/* Parse command line parameters */
while ((option = getopt(argc, argv, OPT_STR)) != ERROR)
{
switch (option)
{
#ifdef CONFIG_EXAMPLES_CAN_WRITE
#ifdef CONFIG_CAN_EXTID
case 's':
extended = false;
break;
#endif
case 'a':
minid = strtol(optarg, NULL, 10);
if (minid < 1 || minid > maxid)
{
fprintf(stderr, "<min-id> out of range\n");
badarg = true;
}
break;
case 'b':
maxid = strtol(optarg, NULL, 10);
if (maxid < minid || maxid > MAX_ID)
{
fprintf(stderr, "ERROR: <max-id> out of range\n");
badarg = true;
}
break;
#endif
case 'h':
help = true;
break;
#ifdef CONFIG_NSH_BUILTIN_APPS
case 'n':
nmsgs = strtol(optarg, NULL, 10);
if (nmsgs < 1)
{
fprintf(stderr, "ERROR: <nmsgs> out of range\n");
badarg = true;
}
break;
#endif
case ':':
fprintf(stderr, "ERROR: Bad option argument\n");
badarg = true;
break;
case '?':
default:
fprintf(stderr, "ERROR: Unrecognized option\n");
badarg = true;
break;
}
}
if (badarg)
{
show_usage(argv[0]);
return EXIT_FAILURE;
}
if (help)
{
show_usage(argv[0]);
return EXIT_SUCCESS;
}
#if defined(CONFIG_EXAMPLES_CAN_WRITE) && defined(CONFIG_CAN_EXTID)
if (!extended && maxid > CAN_MAX_STDMSGID)
{
maxid = CAN_MAX_STDMSGID;
if (minid > maxid)
{
minid = maxid;
}
}
#endif
if (optind != argc)
{
fprintf(stderr, "ERROR: Garbage on command line\n");
show_usage(argv[0]);
return EXIT_FAILURE;
}
#ifdef CONFIG_NSH_BUILTIN_APPS
printf("nmsgs: %d\n", nmsgs);
#endif
#ifdef CONFIG_EXAMPLES_CAN_WRITE
printf("min ID: %ld max ID: %ld\n", minid, maxid);
#endif
/* Initialization of the CAN hardware is performed by logic external to
* this test.
*/
ret = boardctl(BOARDIOC_CAN_INITIALIZE, 0);
if (ret < 0)
{
printf("ERROR: BOARDIOC_CAN_INITIALIZE failed: %d\n", ret);
errval = 1;
goto errout;
}
/* Open the CAN device for reading */
fd = open(CONFIG_EXAMPLES_CAN_DEVPATH, CAN_OFLAGS);
if (fd < 0)
{
printf("ERROR: open %s failed: %d\n",
CONFIG_EXAMPLES_CAN_DEVPATH, errno);
errval = 2;
goto errout_with_dev;
}
/* Show bit timing information if provided by the driver. Not all CAN
* drivers will support this IOCTL.
*/
ret = ioctl(fd, CANIOC_GET_BITTIMING, (unsigned long)((uintptr_t)&bt));
if (ret < 0)
{
printf("Bit timing not available: %d\n", errno);
}
else
{
printf("Bit timing:\n");
printf(" Baud: %lu\n", (unsigned long)bt.bt_baud);
printf(" TSEG1: %u\n", bt.bt_tseg1);
printf(" TSEG2: %u\n", bt.bt_tseg2);
printf(" SJW: %u\n", bt.bt_sjw);
}
/* Now loop the appropriate number of times, performing one loopback test
* on each pass.
*/
#ifdef CONFIG_EXAMPLES_CAN_WRITE
msgdlc = 1;
msgid = minid;
msgdata = 0;
#endif
#ifdef CONFIG_NSH_BUILTIN_APPS
for (msgno = 0; msgno < nmsgs; msgno++)
#else
for (; ; )
#endif
{
/* Flush any output before the loop entered or from the previous pass
* through the loop.
*/
fflush(stdout);
#ifdef CONFIG_EXAMPLES_CAN_WRITE
/* Construct the next TX message */
txmsg.cm_hdr.ch_id = msgid;
txmsg.cm_hdr.ch_rtr = false;
txmsg.cm_hdr.ch_dlc = msgdlc;
#ifdef CONFIG_CAN_ERRORS
txmsg.cm_hdr.ch_error = 0;
#endif
#ifdef CONFIG_CAN_EXTID
txmsg.cm_hdr.ch_extid = extended;
#endif
txmsg.cm_hdr.ch_unused = 0;
for (i = 0; i < msgdlc; i++)
{
txmsg.cm_data[i] = msgdata + i;
}
/* Send the TX message */
msgsize = CAN_MSGLEN(msgdlc);
nbytes = write(fd, &txmsg, msgsize);
if (nbytes != msgsize)
{
printf("ERROR: write(%ld) returned %ld\n",
(long)msgsize, (long)nbytes);
errval = 3;
goto errout_with_dev;
}
printf(" ID: %4u DLC: %d\n", msgid, msgdlc);
#endif
#ifdef CONFIG_EXAMPLES_CAN_READ
/* Read the RX message */
msgsize = sizeof(struct can_msg_s);
nbytes = read(fd, &rxmsg, msgsize);
if (nbytes < CAN_MSGLEN(0) || nbytes > msgsize)
{
printf("ERROR: read(%ld) returned %ld\n",
(long)msgsize, (long)nbytes);
errval = 4;
goto errout_with_dev;
}
printf(" ID: %4u DLC: %u\n",
rxmsg.cm_hdr.ch_id, rxmsg.cm_hdr.ch_dlc);
#ifdef CONFIG_CAN_ERRORS
/* Check for error reports */
if (rxmsg.cm_hdr.ch_error != 0)
{
printf("ERROR: CAN error report: [0x%04x]\n", rxmsg.cm_hdr.ch_id);
if ((rxmsg.cm_hdr.ch_id & CAN_ERROR_TXTIMEOUT) != 0)
{
printf(" TX timeout\n");
}
if ((rxmsg.cm_hdr.ch_id & CAN_ERROR_LOSTARB) != 0)
{
printf(" Lost arbitration: %02x\n", rxmsg.cm_data[0]);
}
if ((rxmsg.cm_hdr.ch_id & CAN_ERROR_CONTROLLER) != 0)
{
printf(" Controller error: %02x\n", rxmsg.cm_data[1]);
}
if ((rxmsg.cm_hdr.ch_id & CAN_ERROR_PROTOCOL) != 0)
{
printf(" Protocol error: %02x %02x\n", rxmsg.cm_data[2], rxmsg.cm_data[3]);
}
if ((rxmsg.cm_hdr.ch_id & CAN_ERROR_TRANSCEIVER) != 0)
{
printf(" Transceiver error: %02x\n", rxmsg.cm_data[4]);
}
if ((rxmsg.cm_hdr.ch_id & CAN_ERROR_NOACK) != 0)
{
printf(" No ACK received on transmission\n");
}
if ((rxmsg.cm_hdr.ch_id & CAN_ERROR_BUSOFF) != 0)
{
printf(" Bus off\n");
}
if ((rxmsg.cm_hdr.ch_id & CAN_ERROR_BUSERROR) != 0)
{
printf(" Bus error\n");
}
if ((rxmsg.cm_hdr.ch_id & CAN_ERROR_RESTARTED) != 0)
{
printf(" Controller restarted\n");
}
}
else
#endif
{
#if defined(CONFIG_EXAMPLES_CAN_WRITE) && defined(CONFIG_CAN_LOOPBACK)
/* Verify that the received messages are the same */
if (memcmp(&txmsg.cm_hdr, &rxmsg.cm_hdr, sizeof(struct can_hdr_s)) != 0)
{
printf("ERROR: Sent header does not match received header:\n");
lib_dumpbuffer("Sent header",
(FAR const uint8_t *)&txmsg.cm_hdr,
sizeof(struct can_hdr_s));
lib_dumpbuffer("Received header",
(FAR const uint8_t *)&rxmsg.cm_hdr,
sizeof(struct can_hdr_s));
errval = 4;
goto errout_with_dev;
}
if (memcmp(txmsg.cm_data, rxmsg.cm_data, msgdlc) != 0)
{
printf("ERROR: Data does not match. DLC=%d\n", msgdlc);
for (i = 0; i < msgdlc; i++)
{
printf(" %d: TX 0x%02x RX 0x%02x\n",
i, txmsg.cm_data[i], rxmsg.cm_data[i]);
errval = 5;
goto errout_with_dev;
}
}
/* Report success */
printf(" ID: %4u DLC: %d -- OK\n", msgid, msgdlc);
#else
/* Print the data received */
printf("Data received:\n");
for (i = 0; i < msgdlc; i++)
{
printf(" %d: 0x%02x\n", i, rxmsg.cm_data[i]);
}
#endif
}
#endif
#ifdef CONFIG_EXAMPLES_CAN_WRITE
/* Set up for the next pass */
msgdata += msgdlc;
if (++msgid > maxid)
{
msgid = minid;
}
if (++msgdlc > CAN_MAXDATALEN)
{
msgdlc = 1;
}
#endif
}
errout_with_dev:
close(fd);
errout:
printf("Terminating!\n");
fflush(stdout);
return errval;
}
