void app(t_listc *listc, t_listh *listh, t_listm *listm, int sock)
{
int csock;
int max;
fd_set rdfs;
fd_set wdfs;
max = sock;
while (1)
{
init_rdfs(listc, &rdfs, sock);
init_wdfs(listm, &wdfs);
/*show_listm(listm);*/
if (select(max + 1, &rdfs, &wdfs, NULL, NULL) < 0)
{
perror("select()");
return ;
}
if(FD_ISSET(STDIN_FILENO, &rdfs))
return;
else if(FD_ISSET(sock, &rdfs))
{
if ((csock = add_new_client(listc, sock, &rdfs)) > max)
max = csock;
}
else
{
select_read(listc, listh, listm, &rdfs);
select_write(listm, &wdfs);
}
}
}
/* internal: abstract the SSL calls for the other functions */
static int net_read(UPSCONN_t *ups, char *buf, size_t buflen)
{
int ret;
#ifdef HAVE_SSL
if (ups->ssl) {
ret = SSL_read(ups->ssl, buf, buflen);
if (ret < 1) {
ups->upserror = UPSCLI_ERR_SSLERR;
}
return ret;
}
#endif
ret = select_read(ups->fd, buf, buflen, 5, 0);
/* error reading data, server disconnected? */
if (ret < 0) {
ups->upserror = UPSCLI_ERR_READ;
ups->syserrno = errno;
}
/* no data available, server disconnected? */
if (ret == 0) {
ups->upserror = UPSCLI_ERR_SRVDISC;
}
return ret;
}
static int
dvb_read (vbi_capture * cap,
vbi_capture_buffer ** raw,
vbi_capture_buffer ** sliced,
const struct timeval * timeout)
{
vbi_capture_dvb *dvb = PARENT (cap, vbi_capture_dvb, capture);
vbi_capture_buffer *sb;
struct timeval start;
struct timeval now;
unsigned int n_lines;
int64_t pts;
if (!sliced || !(sb = *sliced)) {
sb = &dvb->sliced_buffer;
sb->data = dvb->sliced_data;
}
start.tv_sec = 0;
start.tv_usec = 0;
/* When timeout is zero elapsed time doesn't matter. */
if ((timeout->tv_sec | timeout->tv_usec) > 0)
gettimeofday (&start, /* timezone */ NULL);
now = start;
for (;;) {
if (0 == dvb->b_left) {
ssize_t actual;
actual = select_read (dvb, &now, &start, timeout);
if (actual <= 0)
return actual;
gettimeofday (&now, /* timezone */ NULL);
/* XXX inaccurate. Should be the time when we
received the first byte of the first packet
containing data of the returned frame. Or so. */
dvb->sample_time = now.tv_sec
+ now.tv_usec * (1 / 1e6);
dvb->bp = dvb->pes_buffer;
dvb->b_left = actual;
}
/* Demultiplexer coroutine. Returns when one frame is complete
or the buffer is empty, advancing bp and b_left. Don't
change sb->data in flight. */
/* XXX max sliced lines needs an API change. Currently this
value is determined by vbi_raw_decoder line count below,
256 / 2 because fields don't really apply here and in
practice even 32 should be enough. */
n_lines = vbi_dvb_demux_cor (dvb->demux,
sb->data,
/* max sliced lines */ 128,
&pts,
&dvb->bp,
&dvb->b_left);
if (n_lines > 0)
break;
if (dvb->bug_compatible) {
/* Only one read(), timeout ignored. */
return 0; /* timeout */
} else {
/* Read until EAGAIN, another error or the
timeout expires, in this order. */
}
}
if (sliced) {
sb->size = n_lines * sizeof (vbi_sliced);
sb->timestamp = dvb->sample_time;
/* XXX PTS needs an API change.
sb->sample_time = dvb->sample_time;
sb->stream_time = pts; (first sliced line) */
dvb->last_pts = pts;
*sliced = sb;
}
if (raw && *raw) {
/* Not implemented yet. */
sb = *raw;
sb->size = 0;
}
return 1; /* success */
}
// Main function
void main(void) {
reset_peripheral(); initClock(); initTimer(); initDisplay(); initPin();
initGPIO(); initADC(); initConsole(); int i = 0;
//init_password();
send_data();
initCircBuf (&speed_buffer, BUF_SIZE); init_set_speed_data(&speed_set_data);
int screen = 0; int screen_prev = 0; float speed = 0; float buffed_speed = 0;
int fake_speed = 0; float acc = 0; float max_acc = 0; //float fuel_eco = 0;
float distance = 0;
bool fix = 0; uint8_t satillite = 0; float quality = 0; clock time;
int aim_pos = 0; unsigned long adc = 0; //int error_stepper = 0;
IntMasterEnable();
while(1){
//reading data
read_data = split_data(UART_char_data_old, read_data); // decode data
speed = read_speed(); //read data into variables
adc = run_adc()/7;
//calculations
aim_pos = speed_feedback(buffed_speed, encoder_1/40, speed_set_data.speed);
if (speed_set_data.enable == 1){
step_motor_control(encoder_1/40, aim_pos);
}
//sending fake data
fake_speed = (int)adc;//= random_at_most(100/1.852);
send_info(fake_speed);//knots
//storing data
store_speed(speed);
buffed_speed = analysis_speed();
acc = read_acceleration(buffed_speed);
max_acc = max_acc_func(acc, max_acc);
time = read_time();
satillite = read_satillite();
fix = read_fix();
quality = read_quality();
debounce_button(); // debounce buttons
screen = read_button_screen(screen, fix);
distance = read_distance();
select_read(); //need a mosfet for turning power off
// select adds a an on and off switch yo
if (screen == 1){
if(screen_prev != 1 && screen == 1){
speed_set_data.speed = buffed_speed;
}
speed_set_data.speed = set_speed(speed_set_data.speed); // set the speed to cruise at
}
if (screen == 2){ //0 to 100
acceleration_test(speed);
}
// refresh chainging
if (fix == 1 && speed_set_data.old == speed_set_data.speed && refresh_rate < 4){
UARTSend((unsigned char *)PMTK_SET_NMEA_UPDATE_5HZ, 18, 0);
refresh_rate += 1;
}
if (i >= 50){
display(screen, buffed_speed, acc, max_acc, speed_set_data.speed, satillite,
encoder_1/40, time, distance, quality, UART_char_data_old, aim_pos, adc, acc_times);
i = 0;
}
screen_prev = screen;
i++;
}
}
/*******************************************************************************
**
** Function userial_read_thread
**
** Description
**
** Returns void *
**
*******************************************************************************/
static void *userial_read_thread(void *arg)
{
int rx_length = 0;
HC_BT_HDR *p_buf = NULL;
uint8_t *p;
USERIALDBG("Entering userial_read_thread()");
prctl(PR_SET_NAME, (unsigned long)"userial_read", 0, 0, 0);
rx_flow_on = TRUE;
userial_running = 1;
raise_priority_a2dp(TASK_HIGH_USERIAL_READ);
while (userial_running)
{
if (bt_hc_cbacks)
{
p_buf = (HC_BT_HDR *) bt_hc_cbacks->alloc( \
BTHC_USERIAL_READ_MEM_SIZE);
}
else
p_buf = NULL;
if (p_buf != NULL)
{
p_buf->offset = 0;
p_buf->layer_specific = 0;
p = (uint8_t *) (p_buf + 1);
rx_length = select_read(userial_cb.fd, p, READ_LIMIT);
}
else
{
rx_length = 0;
utils_delay(100);
ALOGW("userial_read_thread() failed to gain buffers");
continue;
}
if (rx_length > 0)
{
p_buf->len = (uint16_t)rx_length;
utils_enqueue(&(userial_cb.rx_q), p_buf);
bthc_signal_event(HC_EVENT_RX);
}
else /* either 0 or < 0 */
{
ALOGW("select_read return size <=0:%d, exiting userial_read_thread",\
rx_length);
/* if we get here, we should have a buffer */
bt_hc_cbacks->dealloc((TRANSAC) p_buf, (char *) (p_buf + 1));
/* negative value means exit thread */
break;
}
} /* for */
userial_running = 0;
USERIALDBG("Leaving userial_read_thread()");
pthread_exit(NULL);
return NULL; // Compiler friendly
}
