void stm32_wlinitialize(void)
{
# ifndef CONFIG_STM32_SPI2
# error "STM32_SPI2 is required to support nRF24L01 module on this board"
# endif
int result;
FAR struct spi_dev_s *spidev;
/* Setup CE & IRQ line IOs */
stm32_configgpio(GPIO_NRF24L01_CE);
stm32_configgpio(GPIO_NRF24L01_IRQ);
/* Init SPI bus */
spidev = stm32_spibus_initialize(2);
if (!spidev)
{
_err("ERROR: Failed to initialize SPI bus\n");
return;
}
result = nrf24l01_register(spidev, &nrf_cfg);
if (result != OK)
{
_err("ERROR: Failed to register initialize SPI bus\n");
return;
}
}
// Construct the chunker.
K7Chunker::K7Chunker(const ConfigNode& config) : AbstractChunker(config)
{
// Check the configuration type matches the class name.
if (config.type() != "K7Chunker")
{
throw _err("K7Chunker::K7Chunker(): Invalid or missing XML configuration.");
}
// Packet dimensions.
_packetSize = sizeof(K7Packet);
_headerSize = sizeof(K7Packet::Header);
// Number of packets per chunk (pipeline iteration).
_nPackets = config.getOption("udpPacketsPerIteration", "value", "128").toUInt();
// Number of Nyquist-sampled values leaving F-engines per second.
_packetsPerSecond = 390625;
// Total number of channels per incoming packet.
_nChannels = config.getOption("channelsPerPacket", "value", "1024").toUInt();
// Channel range for the output stream (counted from 0).
_channelStart = config.getOption("stream", "channelStart", "0").toUInt();
_channelEnd = config.getOption("stream", "channelEnd", "1023").toUInt();
if ( (_channelEnd >= _nChannels) || (_channelStart >= _channelEnd) || (_channelStart < 0) || (_channelEnd < 0) )
{
throw _err("K7Chunker::K7Chunker(): Invalid channel ranges.");
}
std::cout << "K7Chunker::K7Chunker(): _channelStart " << _channelStart << std::endl;
std::cout << "K7Chunker::K7Chunker(): _channelEnd " << _channelEnd << std::endl;
// Calculate the size of the packet for the output stream...
_streamChannels = _channelEnd - _channelStart + 1;
std::cout << "K7Chunker::K7Chunker(): _streamChannels " << _streamChannels << std::endl;
// Since there is only one sample per packet and no raw polarizations but pseudo-Stokes both values are 1.
_packetSizeStream = _streamChannels * sizeof(uint64_t) + _headerSize;
std::cout << "K7Chunker::K7Chunker(): _packetSizeStream " << _packetSizeStream << std::endl;
// ...and the output streams.
_bytesStream = _packetSizeStream - _headerSize;
std::cout << "K7Chunker::K7Chunker(): _bytesStream " << _bytesStream << std::endl;
_byte1OfStream = _channelStart * sizeof(uint64_t);
std::cout << "K7Chunker::K7Chunker(): _byte1OfStream " << _byte1OfStream << std::endl;
// Initialise class variables.
_startTimestamp = 0;
_startAccumulation = 0;
_packetsAccepted = 0;
_packetsRejected = 0;
// Set the empty packet data for stream.
memset((void*)_emptyPacket.data, 0, _bytesStream);
_emptyPacket.header.UTCtimestamp = 0;
_emptyPacket.header.accumulationNumber = 0;
_emptyPacket.header.accumulationRate = 0;
// Set the chunk processed counter.
_chunksProcessed = 0;
_chunkerCounter = 0;
}
int program_make(struct program *prog, struct shader **shader, int num)
{
int i;
GLchar log[256] = "nil";
GLsizei len = 0;
GLint res = GL_FALSE;
if (!prog) {
errno = EFAULT;
return -1;
}
timeinit();
prog->id = glCreateProgram();
if (prog->id == 0) {
glerr("glCreateProgram() failed");
return -1;
}
prog->shader = shader;
prog->shader_num = num;
for (i = 0; i < num; i++) {
if (make_shader(shader[i]) < 0) {
_err("shader %s failed\n", shader[i]->name);
goto err;
}
glAttachShader(prog->id, shader[i]->id);
}
timestart();
glLinkProgram(prog->id);
glGetProgramiv(prog->id, GL_LINK_STATUS, &res);
if (res != GL_TRUE) {
_err("failed to link program\n");
goto err;
}
timestop("program %d linked\n", prog->id);
return prog->id;
err:
if (prog->id > 0) {
glGetProgramInfoLog(prog->id, sizeof (log), &len, log);
_msg("len: %d, log: %s\n", len, log);
}
program_clean(prog);
return -1;
}
int nsh_telnetstart(void)
{
struct telnetd_config_s config;
int ret;
/* Initialize any USB tracing options that were requested. If standard
* console is also defined, then we will defer this step to the standard
* console.
*/
#if defined(CONFIG_NSH_USBDEV_TRACE) && !defined(CONFIG_NSH_CONSOLE)
usbtrace_enable(TRACE_BITSET);
#endif
/* Configure the telnet daemon */
config.d_port = HTONS(CONFIG_NSH_TELNETD_PORT);
config.d_priority = CONFIG_NSH_TELNETD_DAEMONPRIO;
config.d_stacksize = CONFIG_NSH_TELNETD_DAEMONSTACKSIZE;
config.t_priority = CONFIG_NSH_TELNETD_CLIENTPRIO;
config.t_stacksize = CONFIG_NSH_TELNETD_CLIENTSTACKSIZE;
config.t_entry = nsh_telnetmain;
/* Start the telnet daemon */
_info("Starting the Telnet daemon\n");
ret = telnetd_start(&config);
if (ret < 0)
{
_err("ERROR: Failed to tart the Telnet daemon: %d\n", ret);
}
return ret;
}
void ps_free(ps_node* node)
{
struct array *what = NULL;
switch (node->type) {
case NODE_BOOL :
case NODE_INT :
case NODE_FLOAT :
case NODE_NULL : break;
case NODE_STRING : free(node->val.s.val); break;
case NODE_OBJECT :
what = &node->val.o.val;
free(node->val.o.type);
goto inside_array;
case NODE_ARRAY :
what = &node->val.a;
inside_array:
for (int i = 0; i < what->len; i++) {
ps_free(what->pairs[i].key);
ps_free(what->pairs[i].val);
}
free(what->pairs);
break;
default:
_err("Invalid node type %d in %s", node->type, __func__);
};
free(node);
}
static ps_node *ps_dispatch(struct ps_parser_state *state, int *pos)
{
ps_node *result = NULL;
const char *input = state->chunker(state->userdata, *pos, 1);
if (!input)
return NULL;
int here = 0;
while (isspace(input[here]))
here++;
(*pos) += here;
switch (input[here]) {
case NODE_ARRAY: result = ps_handle_array (state, pos); break;
case NODE_BOOL: result = ps_handle_bool (state, pos); break;
case NODE_FLOAT: result = ps_handle_float (state, pos); break;
case NODE_INT: result = ps_handle_int (state, pos); break;
case NODE_NULL: result = ps_handle_null (state, pos); break;
case NODE_OBJECT: result = ps_handle_object(state, pos); break;
case NODE_STRING: result = ps_handle_string(state, pos); break;
case '}':
case ';': (*pos)++; result = ps_dispatch(state, pos); break;
default:
_err("ERROR: Parse failure in %s", __func__);
return PS_PARSE_FAILURE;
}
return result;
}
static int sam_busfault(int irq, FAR void *context)
{
(void)up_irq_save();
_err("PANIC!!! Bus fault received: %08x\n", getreg32(NVIC_CFAULTS));
PANIC();
return 0;
}
static int up_setcursor(FAR struct fb_vtable_s *vtable,
FAR struct fb_setcursor_s *setttings)
{
_info("vtable=%p setttings=%p\n", vtable, setttings);
if (vtable && setttings)
{
_info("flags: %02x\n", settings->flags);
if ((flags & FB_CUR_SETPOSITION) != 0)
{
g_cpos = settings->pos;
_info("pos: (h:%d, w:%d)\n", g_cpos.x, g_cpos.y);
}
#ifdef CONFIG_FB_HWCURSORSIZE
if ((flags & FB_CUR_SETSIZE) != 0)
{
g_csize = settings->size;
_info("size: (h:%d, w:%d)\n", g_csize.h, g_csize.w);
}
#endif
#ifdef CONFIG_FB_HWCURSORIMAGE
if ((flags & FB_CUR_SETIMAGE) != 0)
{
_info("image: (h:%d, w:%d) @ %p\n",
settings->img.height, settings->img.width, settings->img.image);
}
#endif
return OK;
}
_err("ERROR: Returning EINVAL\n");
return -EINVAL;
}
static int up_getcmap(FAR struct fb_vtable_s *vtable, FAR struct fb_cmap_s *cmap)
{
int len;
int i;
_info("vtable=%p cmap=%p len=%d\n", vtable, cmap, cmap->len);
if (vtable && cmap)
{
for (i = cmap->first, len = 0; i < 256 && len < cmap->len; i++, len++)
{
cmap->red[i] = i;
cmap->green[i] = i;
cmap->blue[i] = i;
#ifdef CONFIG_FB_TRANSPARENCY
cmap->transp[i] = i;
#endif
}
cmap->len = len;
return OK;
}
_err("ERROR: Returning EINVAL\n");
return -EINVAL;
}
static int ov2640_putreg(FAR struct i2c_master_s *i2c, uint8_t regaddr,
uint8_t regval)
{
struct i2c_config_s config;
uint8_t buffer[2];
int ret;
#ifdef CONFIG_OV2640_REGDEBUG
_err("%02x <- %02x\n", regaddr, regval);
#endif
/* Set up for the transfer */
buffer[0] = regaddr; /* Register address */
buffer[1] = regval; /* New register value */
/* Set up the I2C configuration */
config.frequency = CONFIG_OV2640_FREQUENCY;
config.address = CONFIG_OV2640_I2CADDR;
config.addrlen = 7;
/* And do it */
ret = i2c_write(i2c, &config, buffer, 2);
if (ret < 0)
{
gerr("ERROR: i2c_write failed: %d\n", ret);
return ret;
}
return OK;
}
int ConnectionServer::CreateConnection(int fd,int flag)
{
/*
SocketHandle * newhdle = new SocketHandle;
newhdle->set_flag(flag);
newhdle->set_fd(fd);
insert_handle(fd,newhdle);
*/
Connection* conn = new Connection(fd);
conn->SetConnectionManager(this);
conn->SetFlag(flag);
pthread_mutex_lock(&_map_mutex);
std::pair< std::map<int, Connection*>::iterator, bool> ret =
m_fd_set.insert(std::map<int, Connection*>::value_type(fd, conn));
pthread_mutex_unlock(&_map_mutex);
if(!ret.second)
{
_err("ConnectionServer::CreateConnection <btlswkxt> insert map error!!\n");
return -1;
}
return 0;
}
int sam_pwm_setup(void)
{
static bool initialized = false;
struct pwm_lowerhalf_s *pwm;
int ret;
/* Have we already initialized? */
if (!initialized)
{
/* Call sam_pwminitialize() to get an instance of the PWM interface */
pwm = sam_pwminitialize(CONFIG_SAMA5D4EK_CHANNEL);
if (!pwm)
{
_err("ERROR: Failed to get the SAMA5 PWM lower half\n");
return -ENODEV;
}
/* Register the PWM driver at "/dev/pwm0" */
ret = pwm_register("/dev/pwm0", pwm);
if (ret < 0)
{
aerr("ERROR: pwm_register failed: %d\n", ret);
return ret;
}
/* Now we are initialized */
initialized = true;
}
return OK;
}
static int kinetis_busfault(int irq, FAR void *context)
{
(void)up_irq_save();
_err("PANIC!!! Bus fault recived\n");
PANIC();
return 0;
}
static int sam_pendsv(int irq, FAR void *context)
{
(void)up_irq_save();
_err("PANIC!!! PendSV received\n");
PANIC();
return 0;
}
static int sam_reserved(int irq, FAR void *context)
{
(void)up_irq_save();
_err("PANIC!!! Reserved interrupt\n");
PANIC();
return 0;
}
static int stm32_usagefault(int irq, FAR void *context, FAR void *arg)
{
(void)up_irq_save();
_err("PANIC!!! Usage fault received: %08x\n", getreg32(NVIC_CFAULTS));
PANIC();
return 0;
}
static int stm32_dbgmonitor(int irq, FAR void *context, FAR void *arg)
{
(void)up_irq_save();
_err("PANIC!!! Debug Monitor received\n");
PANIC();
return 0;
}
/*
* sl_init(): Initialize a string list
*/
StringList *
sl_init(void)
{
StringList *sl;
sl = malloc(sizeof(StringList));
if (sl == NULL)
_err(1, "stringlist: %m");
sl->sl_cur = 0;
sl->sl_max = _SL_CHUNKSIZE;
sl->sl_str = malloc(sl->sl_max * sizeof(char *));
if (sl->sl_str == NULL)
_err(1, "stringlist: %m");
return sl;
}
static mleak_mem_node_t*
_node_find(
unsigned long ptr)
{
mleak_mem_node_t *pCur = g_mleak_dev.pNode_head;
mleak_mem_node_t *pTarget = 0;
while( pCur )
{
if( pCur->verify_tag != MLEAK_VERIFY_TAG )
{
_err("fail, node is dirty !!\n");
break;
}
if( (unsigned long)((void*)(pCur->pPtr)) == ptr )
{
pTarget = pCur;
break;
}
pCur = pCur->next;
}
return pTarget;
}
/**
* @details
* Constructor.
*
* @param[in] config XML configuration node.
*/
PPFChanneliser::PPFChanneliser(const ConfigNode& config)
: AbstractModule(config), _buffersInitialised(false)
{
// Get options from the XML configuration node.
_nChannels = config.getOption("outputChannelsPerSubband", "value", "512").toUInt();
_nThreads = config.getOption("processingThreads", "value", "2").toUInt();
unsigned nTaps = config.getOption("filter", "nTaps", "8").toUInt();
QString window = config.getOption("filter", "filterWindow", "kaiser").toLower();
// Set the number of processing threads.
omp_set_num_threads(_nThreads);
_iOldestSamples.resize(_nThreads, 0);
// Enforce even number of channels.
if (_nChannels != 1 && _nChannels%2 == 1)
throw _err("Number of channels needs to be even.");
// Generate the FIR coefficients;
_generateFIRCoefficients(window, nTaps);
// Allocate buffers used for holding the output of the FIR stage.
_filteredData.resize(_nThreads);
for (unsigned i = 0; i < _nThreads; ++i)
_filteredData[i].resize(_nChannels);
// Create the FFTW plan.
_createFFTWPlan(_nChannels, _fftPlan);
}
static int xmc4_usagefault(int irq, FAR void *context, FAR void *arg)
{
(void)up_irq_save();
_err("PANIC!!! Usage fault received\n");
PANIC();
return 0;
}
static int lpc43_busfault(int irq, FAR void *context, FAR void *arg)
{
(void)up_irq_save();
_err("PANIC!!! Bus fault recived\n");
PANIC();
return 0;
}
static int open_outfile(int fnum, int cpu, int remove_file)
{
char buf[PATH_MAX];
time_t t;
if (!outfile_name) {
_err("-S is set without -o. Please file a bug report.\n");
return -1;
}
time(&t);
if (fnum_max) {
if (remove_file) {
/* remove oldest file */
if (make_outfile_name(buf, PATH_MAX, fnum - fnum_max,
cpu, read_backlog(cpu, fnum - fnum_max),
bulkmode) < 0)
return -1;
remove(buf); /* don't care */
}
write_backlog(cpu, fnum, t);
}
if (make_outfile_name(buf, PATH_MAX, fnum, cpu, t, bulkmode) < 0)
return -1;
out_fd[cpu] = open (buf, O_CREAT|O_TRUNC|O_WRONLY, 0666);
if (out_fd[cpu] < 0) {
perr("Couldn't open output file %s", buf);
return -1;
}
if (set_clexec(out_fd[cpu]) < 0)
return -1;
return 0;
}
static int sam_nmi(int irq, FAR void *context)
{
(void)up_irq_save();
_err("PANIC!!! NMI received\n");
PANIC();
return 0;
}
int ssynth_init (void) {
struct roar_stream_server * ss;
struct roar_stream * s;
int sid;
if ( !ssynth_conf.enable )
return 0;
memset(&g_ssynth, 0, sizeof(g_ssynth));
g_ssynth.stream = -1;
if ( (sid = streams_new()) == -1 )
return -1;
if ( streams_set_client(sid, g_self_client) == -1 ) {
_err();
}
if ( streams_set_dir(sid, ROAR_DIR_BRIDGE, 1) == -1 ) {
_err();
}
if ( streams_set_flag(sid, ROAR_FLAG_PRIMARY) == -1 ) {
_err();
}
if ( streams_set_name(sid, "Simple Synthesizer") == -1 ) {
_err();
}
if ( streams_get(sid, &ss) == -1 ) {
_err();
}
s = ROAR_STREAM(ss);
memcpy(&(s->info), g_sa, sizeof(struct roar_audio_info));
s->info.channels = 1;
s->info.codec = ROAR_CODEC_DEFAULT;
g_ssynth.stream = sid;
return 0;
}
int ConnectionServer::Open(size_t thread_num, int port)
{
struct sockaddr_in addr;
struct hostent *host;
struct ifreq req;
int sock;
char *dn_or_ip;
sock = socket(AF_INET, SOCK_DGRAM, 0);
strncpy(req.ifr_name, "eth0", IFNAMSIZ);
if ( ioctl(sock, SIOCGIFADDR, &req) < 0 ) {
_err("ConnectionServer::Open ioctl error: %s Cann't get current IP\n", strerror (errno));
sprintf(current_ip,"Get currentip error %d",errno);
}
else
{
dn_or_ip = (char *)inet_ntoa(*(struct in_addr *) &((struct sockaddr_in *) &req.ifr_addr)->sin_addr);
strcpy(current_ip,dn_or_ip);
}
_info("ConnectionServer::Open Current IP:%s\n", current_ip);
shutdown(sock, 2);
::close(sock);
if ((_epoll_fd = epoll_create(MAX_FD_NUM)) == -1)
{
_err("error: epoll create fail!!\n");
return -1;
}
if (create_pipe())
{
_err("error: create pipe fail!! \n");
return -1;
}
if (create_listen(_socket_server_listen, port))
{
_err("error: create listen fail !! %d\n",port);
return -1;
}
add_input_fd(_pipe_read);
add_input_fd(_socket_server_listen);
return STaskBase<Connection*>::Open(thread_num);
}
static ps_node *ps_handle_string(struct ps_parser_state *state, int *pos)
{
ps_node *result = NULL;
const char *input = state->chunker(state->userdata, *pos, 10);
if (!input)
return NULL;
char *next;
int len = strtol(&input[2], &next, 10);
if (next == input) {
_err("ERROR: Parse failure in %s", __func__);
return PS_PARSE_FAILURE;
}
/// @todo make an expect() call
if (strncmp(next, ":\"", 2)) {
char got[3] = { 0 };
strncpy(got, next, 2);
_err("ERROR: Parse failure in %s : expecting \":\"\", got \"%s\"",
__func__, got);
return PS_PARSE_FAILURE;
}
(*pos) += next - input + 2; // 1 for colon, 1 for opening quote
input = state->chunker(state->userdata, *pos, len);
if (!input)
return NULL;
char *val = malloc(len + 1);
/// @todo what about possibly escaped characters ?
strncpy(val, next + 2, len);
val[len] = 0;
result = malloc(sizeof *result);
*result = (ps_node){
.type = NODE_STRING,
.val = { .s = { .len = len, .val = val } }
};
(*pos) += len + 1; // 1 for closing quote
return result;
}
static ps_node *ps_handle_object(struct ps_parser_state *state, int *pos)
{
ps_node *result = NULL;
const char *input = state->chunker(state->userdata, *pos, 10);
if (!input) return PS_PARSE_FAILURE;
char *next;
int typelen = strtol(&input[2], &next, 10);
if (next == input) {
_err("ERROR: Parse failure in %s", __func__);
return PS_PARSE_FAILURE;
}
(*pos) += next - input;;
// +2 for quotes
input = state->chunker(state->userdata, *pos, typelen + 2);
if (!input) return PS_PARSE_FAILURE;
char type[typelen + 1];
memcpy(type, &input[2], typelen);
type[typelen] = 0;
(*pos) += typelen + 4;
input = state->chunker(state->userdata, *pos, 10);
if (!input) return PS_PARSE_FAILURE;
int len = strtol(input, &next, 10);
if (next == input) {
_err("ERROR: Parse failure in %s", __func__);
return PS_PARSE_FAILURE;
}
(*pos) += next - input + 2; // 2 for ":{"
result = malloc(sizeof *result);
if (_ps_object_or_array(state, pos, len, &result->val.o.val) == PS_PARSE_FAILURE)
return PS_PARSE_FAILURE;
result->type = NODE_OBJECT;
result->val.o.type = strdup(type);
result->val.o.val.is_array = false;
return result;
}
int Connection::ReadTimeout(void *buf, size_t buf_len, timeval *timeout)
{
//buf_len =1024;
//char * buff= new char[buf_len];
//char * old_buf =buff;
int left = buf_len;
int n;
fd_set rset;
if (_fd == INVALID_FD){
_err("ReadTimeout fd is INVALID\n");
goto ERROR;
}
while (left > 0)
{
//fprintf(stderr, "############3333 000000 readn_timout is left:%d,fd:%d ",left,_fd);
FD_ZERO(&rset);
FD_SET(_fd, &rset);
if (select(_fd + 1, &rset, NULL, NULL, timeout) <= 0){
_err("Connection::ReadTimeout select error\n");
goto ERROR;
}
if ((n = read(_fd, buf, left)) == 0){
//fprintf(stderr, "############3333 readn_timout is left:%d,fd:%d ",left,_fd);
//return buf_len - left;
buf_len = buf_len - left;
goto OUT;
}
buf = (char *)buf + n;
left -= n;
}
OUT:
/*fprintf(stderr,"========================\n");
for (int i =0 ;i<buf_len;i++)
fprintf(stderr," %x ",old_buf[i]);
fprintf(stderr,"\n========================.done\n");
*/
//fprintf(stderr,"\n======================== buf_len =%d\n",buf_len);
return buf_len;
ERROR:
return -1;
}
static void sam_i2c_register(int bus)
{
FAR struct i2c_master_s *i2c;
int ret;
i2c = sam_i2cbus_initialize(bus);
if (i2c == NULL)
{
_err("ERROR: Failed to get I2C%d interface\n", bus);
}
else
{
ret = i2c_register(i2c, bus);
if (ret < 0)
{
_err("ERROR: Failed to register I2C%d driver: %d\n", bus, ret);
sam_i2cbus_uninitialize(i2c);
}
}
}
