Character *load_player_by_id(Connection *conn, identifier_t charId)
{
char buf[400];
sql_stmt *stmt;
db_begin_transaction();
int len = sprintf(buf,
"select * from character join player on playerId=characterId where characterId=%"
PRId64,
charId);
if (sql_query(buf, len, &stmt) != SQL_OK)
{
log_data("could not prepare sql statement");
return 0;
}
Character *ch = new_char();
ch->pc = new_player(conn);
if (sql_step(stmt) != SQL_DONE)
{
load_player_columns(conn->account, ch, stmt);
}
if (sql_finalize(stmt) != SQL_OK)
{
log_data("unable to finalize statement");
}
load_char_objs(ch);
load_char_affects(ch);
db_end_transaction();
return ch;
}
int load_char_affects(Character *ch)
{
char buf[400];
sql_stmt *stmt;
int total = 0;
int len = sprintf(buf,
"select * from char_affect where characterId=%"
PRId64,
ch->id);
if (sql_query(buf, len, &stmt) != SQL_OK)
{
log_data("could not prepare statement");
return 0;
}
while (sql_step(stmt) != SQL_DONE)
{
int affId = sql_col_int(stmt, "affectId");
Affect *aff = load_affect_by_id(affId);
if (aff != 0)
{
aff->duration = sql_col_int(stmt, "duration");
affect_to_char(ch, aff);
}
total++;
}
if (sql_finalize(stmt) != SQL_OK)
{
log_data("could not finalize statement");
}
return total;
}
void make_connection(struct connection *c, int port, int *sock, void (*func)(struct connection *))
{
int as;
unsigned char *host;
struct conn_info *b;
if (!(host = get_host_name(c->url))) {
setcstate(c, S_INTERNAL);
abort_connection(c);
return;
}
if (c->newconn)
internal("already making a connection");
b = mem_alloc(sizeof(struct conn_info));
b->func = func;
b->sock = sock;
b->port = port;
c->newconn = b;
log_data("\nCONNECTION: ", 13);
log_data(host, strlen(host));
log_data("\n", 1);
if (c->no_cache >= NC_RELOAD) as = find_host_no_cache(host, &b->addr, &c->dnsquery, (void(*)(void *, int))dns_found, c);
else as = find_host(host, &b->addr, &c->dnsquery, (void(*)(void *, int))dns_found, c);
mem_free(host);
if (as) setcstate(c, S_DNS);
}
int save_npc(Character *ch)
{
int res = save_character(ch, npc_flags);
field_map npc_values[] =
{
{"nonplayerId", &ch->id, SQL_INT},
{"shortDescr", &ch->npc->shortDescr, SQL_TEXT},
{"longDescr", &ch->npc->longDescr, SQL_TEXT},
{"startPosition", &ch->npc->startPosition, SQL_INT},
{"areaId", &ch->npc->area->id, SQL_INT},
{0, 0, 0}
};
if (res == 1)
{
if (sql_insert_query(npc_values, "nonplayer") != SQL_OK)
{
log_data("could not insert player");
return 0;
}
}
else if (res == 2)
{
if (sql_update_query(npc_values, "nonplayer", ch->id) != SQL_OK)
{
log_data("could not update character");
return 0;
}
}
return UMIN(res, 1);
}
int load_npcs(Area *area)
{
char buf[400];
sql_stmt *stmt;
int total = 0;
int len = sprintf(buf,
"select * from character natural join nonplayer where areaId=%"
PRId64,
area->id);
if (sql_query(buf, len, &stmt) != SQL_OK)
{
log_data("could not prepare statement");
return 0;
}
while (sql_step(stmt) != SQL_DONE)
{
Character *ch = new_char();
ch->npc = new_npc();
ch->npc->area = area;
load_npc_columns(ch, stmt);
LINK(area->npcs, ch, next_in_area);
LINK(first_character, ch, next);
total++;
}
if (sql_finalize(stmt) != SQL_OK)
{
log_data("could not finalize statement");
}
return total;
}
Character *load_npc(identifier_t id)
{
char buf[400];
sql_stmt *stmt;
Character *ch = 0;
int len = sprintf(buf,
"select * from character join nonplayer on nonplayerId=characterId where charId=%"
PRId64,
id);
if (sql_query(buf, len, &stmt) != SQL_OK)
{
log_data("could not prepare statement");
return 0;
}
if (sql_step(stmt) != SQL_DONE)
{
ch = new_char();
ch->npc = new_npc();
load_npc_columns(ch, stmt);
LINK(ch->npc->area->npcs, ch, next_in_area);
LINK(first_character, ch, next);
}
if (sql_finalize(stmt) != SQL_OK)
{
log_data("could not finalize statement");
}
return ch;
}
void clean(){
int i;
int flag = FALSE;
lock_repo();
for (i=0; i<REPO_SIZE; ++i) {
if (SHM_SERVER_IDS_ADRESS[i] == MSG_RECEIVER) {
SHM_SERVER_IDS_ADRESS[i] = -1;
} else if (SHM_SERVER_IDS_ADRESS[i] != -1) {
flag = TRUE;
}
}
unlock_repo();
for(i=0; i<MAX_USERS_NUMBER; ++i) {
if (LOCAL_REPO[i].client_id != -1){
MSG_LOGIN user;
user.ipc_num = LOCAL_REPO[i].client_id;
strcpy(user.username, LOCAL_REPO[i].user_name);
unregister_user(user);
}
}
log_data("DEAD");
//we are last server so we clean whole repo
if(!flag){
log_data("CLEANING REPOSITORY");
clean_repo();
}
release_resources();
signal(SIGINT, SIG_DFL);
exit(EXIT_SUCCESS);
}
Character *load_player_by_name(Connection *conn, const char *name)
{
char buf[400];
sql_stmt *stmt;
db_begin_transaction();
int len = sprintf(buf,
"select * from character natural join player where name='%s'",
escape_sql_str(name));
if (sql_query(buf, len, &stmt) != SQL_OK)
{
log_data("could not prepare sql statement");
return 0;
}
Character *ch = new_char();
ch->pc = new_player(conn);
if (sql_step(stmt) != SQL_DONE)
{
load_player_columns(conn->account, ch, stmt);
}
if (sql_finalize(stmt) != SQL_OK)
{
log_data("unable to finalize statement");
}
load_char_objs(ch);
load_char_affects(ch);
db_end_transaction();
return ch;
}
int save_character(Character *ch, const Lookup *flag_table)
{
static const int CharSaveVersion = 1;
const int maxStat = MAX_STAT;
const int maxDam = MAX_DAM;
field_map char_values[] =
{
{"version", &CharSaveVersion, SQL_INT},
{"name", &ch->name, SQL_TEXT},
{"description", &ch->description, SQL_TEXT},
{"level", &ch->level, SQL_INT},
{"sex", &ch->sex, SQL_LOOKUP, sex_table},
{"raceId", &ch->race->id, SQL_INT},
{"hit", &ch->hit, SQL_INT},
{"maxHit", &ch->maxHit, SQL_INT},
{"mana", &ch->mana, SQL_INT},
{"maxMana", &ch->maxMana, SQL_INT},
{"move", &ch->move, SQL_INT},
{"maxMove", &ch->maxMove, SQL_INT},
{"gold", &ch->gold, SQL_DOUBLE},
{"position", &ch->position, SQL_LOOKUP, position_table},
{"flags", &ch->flags, SQL_FLAG, flag_table},
{"classes", &ch->classes, SQL_CUSTOM, NULL, NULL, 0, save_char_classes},
{
"stats", &ch->stats, SQL_ARRAY, NULL, &maxStat, 0, db_save_int_array
},
{"alignment", &ch->alignment, SQL_INT},
{
"resists", &ch->resists, SQL_ARRAY, NULL, &maxDam, 0, db_save_int_array
},
{"size", &ch->size, SQL_FLOAT},
{"level", &ch->level, SQL_INT},
{0}
};
if (ch->id == 0)
{
if (sql_insert_query(char_values, "character") != SQL_OK)
{
log_data("could not insert character");
return 0;
}
ch->id = db_last_insert_rowid();
return 1;
}
else
{
if (sql_update_query(char_values, "character", ch->id) !=
SQL_OK)
{
log_data("could not update character");
return 0;
}
return 2;
}
}
void handle_gps_update_packet(char *buffer, size_t buf_size)
{
/* If END is found, then end the ride */
if (strstr(buffer, "END") != NULL)
{
ctrl_c_interrupt(SIGINT);
return;
}
smartphone_gps_t gps = parse_raw_data(buffer, buf_size);
/* If start_lat is NaN */
if (start_lat != start_lat)
{
start_lat = gps.lat;
start_lng = gps.lng;
start_time = gps.time;
}
/* Update end points to most recent example */
end_lat = gps.lat;
end_lng = gps.lng;
end_time = gps.time;
log_data(&gps);
}
int main(int argc, char **argv)
{
FILE *file;
Hubyte mac[6];
mac[0] = 0x00; mac[1] = 0xE0;
mac[2] = 0x18; mac[3] = 0xE4;
mac[4] = 0xB2; mac[5] = 0x74;
eth_init( mac );
setup_ncurses();
num_packets = 0;
num_bytes = 0;
res_total = 0;
res_number = 0;
res_max = 0;
res_min = 0;
file = open_file( argv[1] );
log_data( file );
close_ncurses();
eth_destroy();
return 0;
}
int change_room(MSG_ROOM room_action, int client_id){
lock_repo();
int i;
int room_exists_on_server = FALSE;
for(i=0; i<REPO_SIZE; ++i){
if( !strcmp(SHM_ROOM_SERVER_ADRESS[i].room_name, room_action.room_name) &&
SHM_ROOM_SERVER_ADRESS[i].server_id == MSG_RECEIVER){
room_exists_on_server = TRUE;
break;
}
}
unlock_repo();
if (!room_exists_on_server) {
int return_flag = create_room(room_action.room_name);
if (return_flag == FULL) {
return FULL;
}
}
char* old_room = change_users_room_in_local_repo(client_id, room_action.room_name);
if( count_people_in_room(old_room) == 0){
delete_room(old_room);
}
log_data("USER %s CHANGED ROOM FROM %s TO %s", room_action.user_name, old_room, room_action.room_name);
free(old_room);
return SUCCESS;
}
int main(int argc, char *argv[])
{
if(argc < 3) die("Insufficient arguments supplied.");
int length = atoll(argv[1]);
float prec = atof(argv[2]);
printf("sizeof(length) = %lu\n", sizeof(length));
float *samples = gensample(length, prec, hamming);
float *K = malloc(length*sizeof(float));
memset(K, 0, length);
float *X_real = malloc(length*sizeof(float));
memset(X_real, 0, length);
float *X_img = malloc(length*sizeof(float));
memset(X_img, 0, length);
float *result = dft(samples, length, X_real, X_img, K);
log_data(length, result, K);
free(X_real);
free(X_img);
free(K);
free(samples);
return 0;
}
/* Write a byte of data to the serial link or set it up to be sent later (QR-side)
* Returns 1 if data was written directly, 0 if placed in buffer, -1 otherwise
* Author: Maurijn Neumann
*/
int serial_write(unsigned char c) {
//Check if data can be written immediately
if ((serial_buffer_send_top == serial_buffer_send_base) &&
(X32_serial_status & 0x01)) {
//Write to buffer, and done
// X32_display = c;
X32_serial_data = c;
return 1;
} else {
//Place data in buffer, update, *critical section due to top/base comparison*
DISABLE_INTERRUPT(INTERRUPT_GLOBAL);
serial_buffer_send[serial_buffer_send_top] = c;
serial_buffer_send_top++;
if (serial_buffer_send_top >= SERIAL_BUFFER_SIZE)
serial_buffer_send_top = 0;
if (serial_buffer_send_top == serial_buffer_send_base) {
log_msg("Serial output buffer full; discarding");
log_int(serial_buffer_send_top);
log_data(LOG_COMM_DISCARD_BUFFER, serial_buffer_send, SERIAL_BUFFER_SIZE);
return -1;
}
ENABLE_INTERRUPT(INTERRUPT_GLOBAL);
return 0;
}
}
//This function initializes all sensors to be ready for logging and also tests that
//the SD-card's filesystem is working.
int logging_setup() {
p_sensor.MS5803Init();
gps_ser.baud(9600);
mkdir("/sd/test_dir", 0777);
wait(1.0);
//Opens a test file to validate logging.
FILE *fp = fopen("/sd/test_dir/test_file2.txt", "a");
wait(1.0);
if(fp == NULL) {
error("Could not open test file for write\n");
return 1;
} else { //Now write in one line of data into the new file!
update_data();
log_data(fp);
fclose(fp);
}
mkdir("/sd/data", 0777);
wait(1.0);
logging_file = fopen("/sd/data/logging2.txt", "a");
wait(1.0);
if(logging_file == NULL) {
error("Could not open log file for write\n");
return 1;
}
return 0;
}
int load_char_objs(Character *ch)
{
char buf[400];
sql_stmt *stmt;
int total = 0;
int len = sprintf(buf,
"select * from char_objects where carriedById=%"
PRId64,
ch->id);
if (sql_query(buf, len, &stmt) != SQL_OK)
{
log_data("could not prepare statement");
return 0;
}
while (sql_step(stmt) != SQL_DONE)
{
Object *obj = new_object();
obj->carriedBy = ch;
load_obj_columns(obj, stmt);
LINK(obj->area->objects, obj, next_in_area);
LINK(first_object, obj, next);
if (!obj->inObj)
{
LINK(ch->carrying, obj, next_content);
if (obj->wearLoc != WEAR_NONE)
{
equip_char(ch, obj, obj->wearLoc);
}
}
else
{
LINK(obj->inObj->contains, obj, next_content);
}
total++;
}
if (sql_finalize(stmt) != SQL_OK)
{
log_data("could not finalize statement");
}
return total;
}
int main(int argc, char **argv)
{
plc_tag tag = PLC_TAG_NULL;
int rc;
int delay = 200; /* ms */
if(argc>1) {
delay = atoi(argv[1]);
}
if(delay < 30) {
fprintf(stderr,"ERROR: delay too small!\n");
return 1;
}
/* create the tag */
tag = plc_tag_create(TAG_PATH);
/* everything OK? */
if(!tag) {
fprintf(stderr,"ERROR: Could not create tag!\n");
return 0;
}
/* let the connect succeed we hope */
while(plc_tag_status(tag) == PLCTAG_STATUS_PENDING) {
sleep(1);
}
if(plc_tag_status(tag) != PLCTAG_STATUS_OK) {
fprintf(stderr,"Error setting up tag internal state.\n");
return 0;
}
rc = plc_tag_read(tag, 1000);
while(1) {
/* get the data */
rc = plc_tag_read(tag, 0);
sleep_ms(delay);
if(plc_tag_status(tag) != PLCTAG_STATUS_OK) {
fprintf(stderr,"ERROR: Unable to read the data! Got error code %d\n",rc);
return 0;
}
log_data(tag);
}
/* we are done */
plc_tag_destroy(tag);
return 0;
}
byte * _f_handler_inst_jmp2(byte * inst) {
dword target = *(dword*)(inst+1);
//flux_staple(RADDR(inst),5);
if (do_jmp((dword)RADDR(inst), (dword)RADDR(inst+5+target),2)) {
log_data("jmping (32-bits) rel: (%i)",target);
return inst+5+target;
}
return 0;
}
int delete_room(const char* roomname){
lock_repo();
int return_flag = FAIL;
int i;
for (i=0; i<REPO_SIZE; ++i) {
if (SHM_ROOM_SERVER_ADRESS[i].server_id == MSG_RECEIVER && !strcmp(SHM_ROOM_SERVER_ADRESS[i].room_name, roomname)) {
SHM_ROOM_SERVER_ADRESS[i].server_id = -1;
strcpy(SHM_ROOM_SERVER_ADRESS[i].room_name, "");
log_data("ROOM %s DELETED", roomname);
return_flag = SUCCESS;
break;
}
}
unlock_repo();
if (return_flag == FAIL) {
log_data("ROOM %s COULDNT BE DELETED, NOT FOUND", roomname);
}
return return_flag;
}
byte * _f_handler_inst_jmp(byte * inst) {
char target = *(char*)(inst+1);
if (do_jmp((dword)RADDR(inst), (dword)RADDR(inst+2+target),2)) {
log_data("jmping (8-bits) rel: (%i)",target);
return inst+2+target;
}
return 0;
}
int create_room(const char* roomname){
lock_repo();
int return_flag = FULL;
int i;
for (i=0; i<REPO_SIZE; ++i) {
if (SHM_ROOM_SERVER_ADRESS[i].server_id == -1) {
SHM_ROOM_SERVER_ADRESS[i].server_id = MSG_RECEIVER;
strcpy(SHM_ROOM_SERVER_ADRESS[i].room_name, roomname);
return_flag = SUCCESS;
log_data("ROOM %s CREATED", roomname);
break;
}
}
unlock_repo();
if (return_flag == FULL) {
log_data("ROOM %s COULDNT BE CREATED, NO SPACE", roomname);
}
return return_flag;
}
void send_td(sio2_transfer_data_t *td)
{
int i;
#ifndef XSIO2MAN
log_default(LOG_TRS);
#endif
for (i = 0; i < 4; i++) {
sio2_portN_ctrl1_set(i, td->port_ctrl1[i]);
sio2_portN_ctrl2_set(i, td->port_ctrl2[i]);
}
#ifndef XSIO2MAN
log_portdata(td->port_ctrl1, td->port_ctrl2);
#endif
for (i = 0; i < 16; i++)
sio2_regN_set(i, td->regdata[i]);
#ifndef XSIO2MAN
log_regdata(td->regdata);
#endif
if (td->in_size) {
for (i = 0; i < td->in_size; i++)
sio2_data_out(td->in[i]);
#ifndef XSIO2MAN
log_data(LOG_TRS_DATA, td->in, td->in_size);
#endif
}
if (td->in_dma.addr) {
dmac_request(IOP_DMAC_SIO2in, td->in_dma.addr, td->in_dma.size,
td->in_dma.count, DMAC_FROM_MEM);
dmac_transfer(IOP_DMAC_SIO2in);
#ifndef XSIO2MAN
log_dma(LOG_TRS_DMA_IN, &td->in_dma);
#endif
}
if (td->out_dma.addr) {
dmac_request(IOP_DMAC_SIO2out, td->out_dma.addr, td->out_dma.size,
td->out_dma.count, DMAC_TO_MEM);
dmac_transfer(IOP_DMAC_SIO2out);
#ifndef XSIO2MAN
log_dma(LOG_TRS_DMA_OUT, &td->out_dma);
#endif
}
}
int register_new_user(MSG_LOGIN user){
lock_repo();
int return_flag = FULL;
int i;
for(i=0; i<REPO_SIZE; ++i){
if( SHM_USER_SERVER_ADRESS[i].server_id == -1){
strcpy(SHM_USER_SERVER_ADRESS[i].user_name, user.username);
SHM_USER_SERVER_ADRESS[i].server_id = MSG_RECEIVER;
log_data("USER FROM %d JOINED AS %s", user.ipc_num, user.username);
return_flag = SUCCESS;
break;
} else if ( !strcmp(SHM_USER_SERVER_ADRESS[i].user_name, user.username) ) {
log_data("USER FROM %d WAS REJECT WHEN TRYING TO JOIN AS %s, NAME ALREADY TAKEN",user.ipc_num, user.username);
return_flag = EXISTS;
break;
}
}
unlock_repo();
if(return_flag == FULL)
log_data("USER FROM %d WAS REJECT WHEN TRYING TO JOIN AS %s, SERVER FULL",user.ipc_num, user.username);
return return_flag;
}
void register_new_server(){
lock_repo();
int i;
for (i=0; i<REPO_SIZE; ++i) {
if( SHM_SERVER_IDS_ADRESS[i] == -1){
SHM_SERVER_IDS_ADRESS[i] = MSG_RECEIVER;
log_data("ALIVE");
break;
}
}
unlock_repo();
}
int delete_character(Character *ch)
{
char buf[BUF_SIZ];
sprintf(buf, "delete from character where characterId=%" PRId64,
ch->id);
if (sql_exec(buf) != SQL_OK)
{
log_data("could not delete character");
return 0;
}
return 1;
}
void read_select(struct connection *c)
{
struct read_buffer *rb;
int rd;
if (!(rb = c->buffer)) {
internal("read socket has no buffer");
setcstate(c, S_INTERNAL);
abort_connection(c);
return;
}
set_handlers(rb->sock, NULL, NULL, NULL, NULL);
if ((unsigned)rb->len > MAXINT - sizeof(struct read_buffer) - READ_SIZE) overalloc();
rb = mem_realloc(rb, sizeof(struct read_buffer) + rb->len + READ_SIZE);
c->buffer = rb;
#ifdef HAVE_SSL
if(c->ssl) {
if ((rd = SSL_read(c->ssl, rb->data + rb->len, READ_SIZE)) <= 0) {
int err;
if ((err = SSL_get_error(c->ssl, rd)) == SSL_ERROR_WANT_READ) {
read_from_socket(c, rb->sock, rb, rb->done);
return;
}
if (rb->close && !rd) {
rb->close = 2;
rb->done(c, rb);
return;
}
setcstate(c, rd ? (err == SSL_ERROR_SYSCALL ? get_error_from_errno(errno) : S_SSL_ERROR) : S_CANT_READ);
/*mem_free(rb);*/
if (!rd || err == SSL_ERROR_SYSCALL) retry_connection(c);
else abort_connection(c);
return;
}
} else
#endif
if ((rd = read(rb->sock, rb->data + rb->len, READ_SIZE)) <= 0) {
if (rb->close && !rd) {
rb->close = 2;
rb->done(c, rb);
return;
}
setcstate(c, rd ? get_error_from_errno(errno) : S_CANT_READ);
/*mem_free(rb);*/
retry_connection(c);
return;
}
log_data(rb->data + rb->len, rd);
rb->len += rd;
rb->done(c, rb);
}
int forward_client_to_service(struct ConnectionState *st) {
char buf[4096];
int r = 1;
int ret = SSL_read(st->ssl, buf, sizeof(buf));
int err = SSL_get_error(st->ssl, ret);
switch (err) {
case SSL_ERROR_NONE:
{
// fcntl(st->service_conn, F_SETFL, 0);
assert(ret > 0);
stats.up_bytes += ret;
int status = sendall(st->service_conn, buf, ret);
log_data(st, buf, ret);
if (status < 0) {
fprintf(stderr, "couldn't forward data to service\n");
cleanup_connection(st);
return 0;
}
// fcntl(st->service_conn, F_SETFL, O_NONBLOCK);
break;
}
case SSL_ERROR_ZERO_RETURN:
case SSL_ERROR_WANT_CONNECT:
case SSL_ERROR_WANT_ACCEPT:
case SSL_ERROR_WANT_X509_LOOKUP:
case SSL_ERROR_SYSCALL:
case SSL_ERROR_SSL:
if (err == SSL_ERROR_SSL) {
extern BIO *bio_err;
if (!bio_err) {
bio_err=BIO_new_fp(stderr,BIO_NOCLOSE);
}
ERR_print_errors(bio_err);
} else if (err == SSL_ERROR_SYSCALL) {
// Socket closed
cleanup_connection_after_ssl(st, 1);
return 0;
}
cleanup_connection(st);
r = 0;
break;
case SSL_ERROR_WANT_READ:
case SSL_ERROR_WANT_WRITE:
//fprintf(stderr, "Ignoring recoverable SSL error %d while forwarding to service\n", err);
break;
}
return r;
}
void write_to_socket(struct connection *c, int s, unsigned char *data, int len, void (*write_func)(struct connection *))
{
struct write_buffer *wb;
log_data(data, len);
if ((unsigned)len > MAXINT - sizeof(struct write_buffer)) overalloc();
wb = mem_alloc(sizeof(struct write_buffer) + len);
wb->sock = s;
wb->len = len;
wb->pos = 0;
wb->done = write_func;
memcpy(wb->data, data, len);
if (c->buffer) mem_free(c->buffer);
c->buffer = wb;
set_handlers(s, NULL, (void (*)(void *))write_select, (void (*)(void *))exception, c);
}
static UINT16 get_data(omti8621_state *state) {
UINT16 data = 0xff;
if (state->data_index < state->data_length) {
data = state->data_buffer[state->data_index++] << 8;
data |= state->data_buffer[state->data_index++];
if (state->data_index >= state->data_length) {
state->omti_state = OMTI_STATE_STATUS;
state->status_port |= OMTI_STATUS_IO | OMTI_STATUS_CD;
log_data(state);
}
} else {
LOG(("UNEXPECTED reading OMTI 8621 data (buffer length exceeded)"));
}
return data;
}
/* ISR for incoming serial data on the QR-side
* Author: Maurijn Neumann
*/
void isr_serial_rx(void) {
//Keep reading while flag is raised
while (X32_serial_status & 0x02) {
//Read into buffer, update
serial_buffer_recv[serial_buffer_recv_top] = X32_serial_data;
//Update and circle index
serial_buffer_recv_top++;
if (serial_buffer_recv_top >= SERIAL_BUFFER_SIZE)
serial_buffer_recv_top = 0;
if (serial_buffer_recv_top == serial_buffer_recv_base) {
log_msg("Serial input buffer full; discarding");
log_int(serial_buffer_recv_top);
log_data(LOG_COMM_DISCARD_BUFFER, serial_buffer_recv, SERIAL_BUFFER_SIZE);
}
}
}
