nuttx-apps/examples/nxscope/nxscope_main.c
Xiang Xiao a29d9ea9da fsutils/examples: Include unistd.h explicitly
to get the prototypes or macros are defined in it

Signed-off-by: Xiang Xiao <xiaoxiang@xiaomi.com>
2023-02-05 08:46:59 +02:00

553 lines
13 KiB
C

/****************************************************************************
* apps/examples/nxscope/nxscope_main.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <assert.h>
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include "logging/nxscope/nxscope.h"
/****************************************************************************
* Private Type Definition
****************************************************************************/
struct nxscope_thr_env_s
{
FAR struct nxscope_s *nxs;
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: nxscope_cb_userid
****************************************************************************/
int nxscope_cb_userid(FAR void *priv, uint8_t id, FAR uint8_t *buff)
{
UNUSED(priv);
printf("--> nxscope_cb_userid: id=%d\n", id);
return OK;
}
/****************************************************************************
* Name: nxscope_cb_start
****************************************************************************/
int nxscope_cb_start(FAR void *priv, bool start)
{
UNUSED(priv);
printf("--> nxscope_cb_start: start=%d\n", start);
return OK;
}
/****************************************************************************
* Name: nxscope_samples_thr
****************************************************************************/
static FAR void *nxscope_samples_thr(FAR void *arg)
{
FAR struct nxscope_thr_env_s *envp = arg;
FAR uint8_t *ptr = NULL;
uint32_t i = 0;
float v[3];
DEBUGASSERT(envp);
printf("nxscope_samples_thr\n");
/* Initialize float vector */
v[0] = -1.0f;
v[1] = 0.0f;
v[2] = 1.0f;
while (1)
{
/* Channel 0 */
nxscope_put_uint8(envp->nxs, 0, i);
/* Channel 1 */
nxscope_put_int8(envp->nxs, 1, -1);
/* Channel 2 */
nxscope_put_uint16(envp->nxs, 2, 300);
/* Channel 3 */
nxscope_put_int16(envp->nxs, 3, -300);
/* Channel 4 */
nxscope_put_uint32(envp->nxs, 4, 35000);
/* Channel 5 */
nxscope_put_int32(envp->nxs, 5, -35000);
/* Channel 6 */
nxscope_put_uint64(envp->nxs, 6, 4294967296);
/* Channel 7 */
nxscope_put_int64(envp->nxs, 7, -4294967296);
/* Channel 8 */
nxscope_put_float(envp->nxs, 8, 1.0f);
/* Channel 9 */
nxscope_put_double(envp->nxs, 9, 1.11111111);
/* Channel 10 */
nxscope_put_ub8(envp->nxs, 10, ftob8(1.0f));
/* Channel 11 */
nxscope_put_b8(envp->nxs, 11, ftob8(-1.0f));
/* Channel 12 */
nxscope_put_ub16(envp->nxs, 12, ftob16(1.0f));
/* Channel 13 */
nxscope_put_b16(envp->nxs, 13, ftob16(-1.0f));
#ifdef CONFIG_HAVE_LONG_LONG
/* Channel 14 */
nxscope_put_ub32(envp->nxs, 14, dtob32(1.0));
/* Channel 15 */
nxscope_put_b32(envp->nxs, 15, dtob32(-1.0));
#endif
/* Channel 16 */
nxscope_put_vfloat(envp->nxs, 16, v, 3);
/* Channel 17 */
ptr = (FAR uint8_t *) &i;
nxscope_put_vfloat_m(envp->nxs, 17, v, 3, ptr, sizeof(uint32_t));
/* Channel 18 */
nxscope_put_none_m(envp->nxs, 18, ptr, sizeof(uint32_t));
i += 1;
usleep(100);
}
return NULL;
}
/****************************************************************************
* Name: nxscope_charlog_thr
****************************************************************************/
static FAR void *nxscope_charlog_thr(FAR void *arg)
{
FAR struct nxscope_thr_env_s *envp = arg;
int i = 0;
DEBUGASSERT(envp);
printf("nxscope_charlog_thr\n");
while (1)
{
/* Channel 19 - send hello with metadata */
nxscope_put_vchar_m(envp->nxs, 19, "hello", 64,
(FAR uint8_t *)&i, sizeof(int));
i += 1;
usleep(100000);
}
return NULL;
}
#ifdef CONFIG_LOGGING_NXSCOPE_CRICHANNELS
/****************************************************************************
* Name: nxscope_crichan_thr
****************************************************************************/
static FAR void *nxscope_crichan_thr(FAR void *arg)
{
FAR struct nxscope_thr_env_s *envp = arg;
uint8_t i = 0;
DEBUGASSERT(envp);
printf("nxscope_crichan_thr\n");
while (1)
{
/* Channel 20 */
nxscope_put_uint8(envp->nxs, 20, i);
i += 1;
usleep(100000);
}
return NULL;
}
#endif
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: nxscope_main
****************************************************************************/
int main(int argc, FAR char *argv[])
{
struct nxscope_s nxs;
int ret = OK;
pthread_t thread;
struct nxscope_thr_env_s env;
struct nxscope_cfg_s nxs_cfg;
union nxscope_chinfo_type_u u;
struct nxscope_intf_s intf;
struct nxscope_proto_s proto;
struct nxscope_callbacks_s cbs;
#ifdef CONFIG_LOGGING_NXSCOPE_INTF_SERIAL
struct nxscope_ser_cfg_s nxs_ser_cfg;
#endif
#ifdef CONFIG_LOGGING_NXSCOPE_INTF_DUMMY
struct nxscope_dummy_cfg_s nxs_dummy_cfg;
#endif
/* Default serial protocol */
ret = nxscope_proto_ser_init(&proto, NULL);
if (ret < 0)
{
printf("ERROR: nxscope_proto_ser_init failed %d\n", ret);
goto errout_noproto;
}
#ifdef CONFIG_LOGGING_NXSCOPE_INTF_SERIAL
/* Configuration */
nxs_ser_cfg.path = CONFIG_EXAMPLES_NXSCOPE_SERIAL_PATH;
nxs_ser_cfg.nonblock = true;
nxs_ser_cfg.baud = CONFIG_EXAMPLES_NXSCOPE_SERIAL_BAUD;
/* Initialize serial interface */
ret = nxscope_ser_init(&intf, &nxs_ser_cfg);
if (ret < 0)
{
printf("ERROR: nxscope_ser_init failed %d\n", ret);
goto errout_nointf;
}
#endif
#ifdef CONFIG_LOGGING_NXSCOPE_INTF_DUMMY
/* Configuration */
nxs_dummy_cfg.res = 0;
/* Initialize dummy interface */
ret = nxscope_dummy_init(&intf, &nxs_dummy_cfg);
if (ret < 0)
{
printf("ERROR: nxscope_dummy_init failed %d\n", ret);
goto errout_nointf;
}
#endif
/* Connect callbacks */
cbs.userid_priv = NULL;
cbs.userid = nxscope_cb_userid;
cbs.start_priv = NULL;
cbs.start = nxscope_cb_start;
/* Initialize nxscope */
nxs_cfg.intf_cmd = &intf;
nxs_cfg.intf_stream = &intf;
nxs_cfg.proto_cmd = &proto;
nxs_cfg.proto_stream = &proto;
nxs_cfg.callbacks = &cbs;
nxs_cfg.channels = 32;
nxs_cfg.streambuf_len = CONFIG_EXAMPLES_NXSCOPE_STREAMBUF_LEN;
nxs_cfg.rxbuf_len = CONFIG_EXAMPLES_NXSCOPE_RXBUF_LEN;
#ifdef CONFIG_LOGGING_NXSCOPE_CRICHANNELS
nxs_cfg.cribuf_len = CONFIG_EXAMPLES_NXSCOPE_CRIBUF_LEN;
#endif
nxs_cfg.rx_padding = CONFIG_EXAMPLES_NXSCOPE_RX_PADDING;
ret = nxscope_init(&nxs, &nxs_cfg);
if (ret < 0)
{
printf("ERROR: nxscope_init failed %d\n", ret);
goto errout_nonxscope;
}
/* Create channels */
/* Point data channels */
u.s.dtype = NXSCOPE_TYPE_UINT8;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 0, "chan0", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_INT8;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 1, "chan1", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_UINT16;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 2, "chan2", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_INT16;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 3, "chan3", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_UINT32;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 4, "chan4", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_INT32;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 5, "chan5", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_UINT64;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 6, "chan6", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_INT64;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 7, "chan7", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_FLOAT;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 8, "chan8", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_DOUBLE;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 9, "chan9", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_UB8;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 10, "chan10", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_B8;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 11, "chan11", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_UB16;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 12, "chan12", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_B16;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 13, "chan13", u.u8, 1, 0);
#ifdef CONFIG_HAVE_LONG_LONG
u.s.dtype = NXSCOPE_TYPE_UB32;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 14, "chan14", u.u8, 1, 0);
u.s.dtype = NXSCOPE_TYPE_B32;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 15, "chan15", u.u8, 1, 0);
#endif
/* Vector data channel */
u.s.dtype = NXSCOPE_TYPE_FLOAT;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 16, "chan16", u.u8, 3, 0);
/* Vector data channel with metadata */
u.s.dtype = NXSCOPE_TYPE_FLOAT;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 17, "chan17", u.u8, 3, 4);
/* No-data channel with metadata */
u.s.dtype = NXSCOPE_TYPE_NONE;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 18, "chan18", u.u8, 0, 4);
/* Char channel with metadata */
u.s.dtype = NXSCOPE_TYPE_CHAR;
u.s._res = 0;
u.s.cri = 0;
nxscope_chan_init(&nxs, 19, "chan19", u.u8, 64, 4);
#ifdef CONFIG_LOGGING_NXSCOPE_CRICHANNELS
/* Critical channel */
u.s.dtype = NXSCOPE_TYPE_UINT8;
u.s._res = 0;
u.s.cri = 1;
nxscope_chan_init(&nxs, 20, "chan20c", u.u8, 1, 0);
#endif
/* Channels 20-31: reserved for future use */
/* Create samples thread */
env.nxs = &nxs;
ret = pthread_create(&thread, NULL, nxscope_samples_thr, &env);
if (ret != OK)
{
printf("ERROR: pthread_create failed %d\n", ret);
goto errout;
}
/* Create char log thread */
env.nxs = &nxs;
ret = pthread_create(&thread, NULL, nxscope_charlog_thr, &env);
if (ret != OK)
{
printf("ERROR: pthread_create failed %d\n", ret);
goto errout;
}
#ifdef CONFIG_LOGGING_NXSCOPE_CRICHANNELS
/* Create critical channel thread */
env.nxs = &nxs;
ret = pthread_create(&thread, NULL, nxscope_crichan_thr, &env);
if (ret != OK)
{
printf("ERROR: pthread_create failed %d\n", ret);
goto errout;
}
#endif
#ifdef CONFIG_EXAMPLES_NXSCOPE_FORCE_ENABLE
/* Enable channels and enable stream */
nxscope_chan_all_en(&nxs, true);
nxscope_stream_start(&nxs, true);
#endif
/* Main loop */
while (1)
{
/* Flush stream data */
ret = nxscope_stream(&nxs);
if (ret < 0)
{
printf("ERROR: nxscope_stream failed %d\n", ret);
}
/* Handle recv data */
ret = nxscope_recv(&nxs);
if (ret < 0)
{
printf("ERROR: nxscope_recv failed %d\n", ret);
}
usleep(100000);
}
errout:
/* Deinit nxscope */
nxscope_deinit(&nxs);
errout_nonxscope:
/* Deinit interface */
#if defined(CONFIG_LOGGING_NXSCOPE_INTF_SERIAL)
nxscope_ser_deinit(&intf);
#endif
#if defined(CONFIG_LOGGING_NXSCOPE_INTF_DUMMY)
nxscope_dummy_deinit(&intf);
#endif
errout_nointf:
/* Deinit protocol */
#if defined(CONFIG_LOGGING_NXSCOPE_PROTO_SER)
nxscope_proto_ser_deinit(&proto);
#endif
errout_noproto:
return 0;
}