int main() { FIFO_DATA_TYPE out_val; fifo_init(&data_in_f, data_in, FIFO_SIZE); fifo_init(&data_out_f, data_out, FIFO_SIZE); fifo_push(&data_in_f, 1); fifo_push(&data_in_f, 2); fifo_push(&data_in_f, 3); fifo_push(&data_in_f, 4); fifo_push(&data_in_f, 5); if (fifo_pop(&data_in_f, &out_val)) printf("Valore: %d\n", out_val); if (fifo_pop(&data_in_f, &out_val)) printf("Valore: %d\n", out_val); if (fifo_pop(&data_in_f, &out_val)) printf("Valore: %d\n", out_val); if (fifo_pop(&data_in_f, &out_val)) printf("Valore: %d\n", out_val); if (fifo_pop(&data_in_f, &out_val)) printf("Valore: %d\n", out_val); //ft_init(); //ft_step(); return 0; }
int main() { struct fifo * list = fifo_create_thread_safe_fifo(); int i = 0; /*pop empty queue*/ fifo_pop(list); printf("length: %d\n",fifo_length(list)); for(;i<10;i++) { fifo_push(list,(void*)i); } printf("length: %d\n",fifo_length(list)); for(i=0;i<5;i++) { printf("%d\n",(int)fifo_pop(list)); } printf("length: %d\n",fifo_length(list)); for(i=0;i<2;i++) { fifo_push(list,(void*)(i+10)); } printf("length: %d\n",fifo_length(list)); for(i=0;i<7;i++) { printf("%d\n",(int)fifo_pop(list)); } printf("length: %d\n",fifo_length(list)); for(i=0;i<2;i++) { fifo_push(list,(void*)(i+10)); } printf("length: %d\n",fifo_length(list)); for(i=0;i<2;i++) { printf("%d\n",(int)fifo_pop(list)); } printf("length: %d\n",fifo_length(list)); fifo_delete(list,NULL); }
static int bch_allocator_push(struct cache *ca, long bucket) { unsigned i; /* Prios/gens are actually the most important reserve */ if (fifo_push(&ca->free[RESERVE_PRIO], bucket)) return true; for (i = 0; i < RESERVE_NR; i++) if (fifo_push(&ca->free[i], bucket)) return true; return false; }
void connect_grabbanners(ip_report_t *r) { union { void *ptr; connection_status_t *c; } c_u; uint64_t state_key=0; uint8_t *c_ptr=NULL; output_data_t *e_out=NULL; char pchars[256]; size_t p_off=0, j=0; state_key=get_connectionkey(r); if (rbfind(state_tbl, state_key, &c_u.ptr) > 0) { memset(pchars, 0, sizeof(pchars)); for (j=0, p_off=0, c_ptr=c_u.c->recv_buf; j < c_u.c->recv_len; j++, c_ptr++) { if (isgraph(*c_ptr) || *c_ptr == ' ') { pchars[p_off++]=(char )*c_ptr; } if (p_off > (sizeof(pchars) -2)) break; } if (p_off > 0) { e_out=(output_data_t *)xmalloc(sizeof(output_data_t)); e_out->type=OD_TYPE_BANNER; e_out->t_u.banner=xstrdup(pchars); fifo_push(r->od_q, (void *)e_out); } } return; }
uint32_t event_handler_push(async_event_t* p_evt) { if (p_evt == NULL) { return NRF_ERROR_NULL; } fifo_t* p_fifo = NULL; switch (p_evt->type) { case EVENT_TYPE_GENERIC: case EVENT_TYPE_PACKET: case EVENT_TYPE_SET_FLAG: case EVENT_TYPE_TIMER_SCH: p_fifo = &g_async_evt_fifo; break; case EVENT_TYPE_TIMER: p_fifo = &g_async_evt_fifo_ts; break; default: return NRF_ERROR_INVALID_PARAM; } uint32_t result = fifo_push(p_fifo, p_evt); if (result != NRF_SUCCESS) { return result; } /* trigger IRQ */ NVIC_SetPendingIRQ(EVENT_HANDLER_IRQ); return NRF_SUCCESS; }
void signal_thread(struct thread* thread, int signum, intptr_t sigval) { struct thread* delivered = 0; // thread to awaken. uint64_t sigbit = 1ull << (signum%SIGNAL_LIMIT); { SPIN_GUARD_RAW(thread->signal.lock); ++signal.seq; // can we do 'instant delivery'? if (thread->signal.wait_mask & sigbit) { // deliver the signal to this thread. thread->signal.wait_mask = 0; thread->signal.wait_signum = signum; thread->signal.wait_sigval = sigval; delivered = thread; // remove it from waiting list. list_remove(&thread->signal.waiting_item); } // queue the signal if it was not instantly delivered. if (!delivered) { struct thread_signal_info* sig = thread->signal.sig + signum; struct signal_pending *pending = HEAP_NEW(struct signal_pending); pending->sigval = sigval; fifo_push(&sig->pending, &pending->item); thread->signal.pending_mask |= sigbit; } } // wake up the thread if it received the signal: if (delivered) { scheduler_wakeup(delivered); } }
void room_generateDoor (Room *room, Fifo *fifo) { Room *nextRoom; Direction dir, opDir; for (dir = RIGHT; dir <= UP; dir++) { nextRoom = room_next(room, dir); if (nextRoom == NULL) { _room_attach(room, NULL, dir); } else { room->door[dir*2] = rand() % 3 == 0;/* chance porte1 */ room->door[(dir*2)+1] = rand() % 5 == 0; /* porte2 */ if (nextRoom->type == RT_EMPTY) { if (room_doorCount(room, dir)) { fifo_push(fifo, nextRoom); nextRoom->type = RT_SIMPLE; } } else { opDir = opDir(dir); /* chances de boucler */ if (room_doorCount(nextRoom, opDir) || rand() % 4 == 0) { _room_attach(room, nextRoom, dir); } else { _room_attach(nextRoom, room, opDir); } } } } }
bool serial_handler_event_send(serial_evt_t* evt) { if (fifo_is_full(&tx_fifo)) { return false; } enable_pin_listener(false); NVIC_DisableIRQ(SPI1_TWI1_IRQn); /* critical section */ serial_data_t raw_data; raw_data.status_byte = 0; memcpy(raw_data.buffer, evt, evt->length + 1); fifo_push(&tx_fifo, &raw_data); if (fifo_is_full(&rx_fifo)) { enable_pin_listener(true); serial_state = SERIAL_STATE_WAIT_FOR_QUEUE; } else if (serial_state == SERIAL_STATE_IDLE) { do_transmit(); } NVIC_EnableIRQ(SPI1_TWI1_IRQn); /* critical section complete */ return true; }
void write_ai_regs(void* opaque, uint32_t address, uint32_t value, uint32_t mask) { struct ai_controller* ai = (struct ai_controller*)opaque; uint32_t reg = ai_reg(address); switch (reg) { case AI_LEN_REG: masked_write(&ai->regs[AI_LEN_REG], value, mask); if (ai->regs[AI_LEN_REG] != 0) { fifo_push(ai); } else { /* stop sound */ } return; case AI_STATUS_REG: clear_rcp_interrupt(ai->mi, MI_INTR_AI); return; case AI_BITRATE_REG: case AI_DACRATE_REG: /* lazy audio format setting */ if ((ai->regs[reg]) != (value & mask)) ai->samples_format_changed = 1; masked_write(&ai->regs[reg], value, mask); return; } masked_write(&ai->regs[reg], value, mask); }
/*** * The thread pool has the property that all the threads will keep running until signalled to quit. * Each thread will call pthread_exit() once it has completed execution of it's current 'task_t'. */ void thread_pool_join_all( thread_pool_t *pool ) { dna_log(DEBUG, "Joining thread pool:"); while ( !fifo_is_empty(pool->thread_queue) ) { dna_mutex_lock( pool->mutex ); int threadsAreStillRunning = 0; while ( (threadsAreStillRunning = fifo_any( pool->thread_queue, &thread_context_is_running)) ) { dna_log(DEBUG, "Some threads are still running...%i", threadsAreStillRunning); dna_cond_wait( pool->wait, pool->mutex ); } dna_thread_context_t *context = (dna_thread_context_t*) fifo_pop( pool->thread_queue ); if (context->runstate == RUNNING) { dna_log(WARN, "context is still running, placing back in the queue."); fifo_push( pool->thread_queue, context ); } else { // if the context is != RUNNING, it's either SHOULD_QUIT or HAS_QUIT // so we have to rely on the null work we pushed earlier to clear // any blocks dna_thread_context_join( context ); dna_thread_context_destroy(context); } dna_mutex_unlock( pool->mutex ); } dna_log(DEBUG, "Thread pool joined."); }
// in: linda_ud, key, ... // out: true|false int keepercall_send( lua_State* L) { keeper_fifo* fifo; int n = lua_gettop( L) - 2; push_table( L, 1); // ud key ... fifos // get the fifo associated to this key in this linda, create it if it doesn't exist lua_pushvalue( L, 2); // ud key ... fifos key lua_rawget( L, -2); // ud key ... fifos fifo if( lua_isnil( L, -1)) { lua_pop( L, 1); // ud key ... fifos fifo_new( L); // ud key ... fifos fifo lua_pushvalue( L, 2); // ud key ... fifos fifo key lua_pushvalue( L, -2); // ud key ... fifos fifo key fifo lua_rawset( L, -4); // ud key ... fifos fifo } lua_remove( L, -2); // ud key ... fifo fifo = (keeper_fifo*) lua_touserdata( L, -1); if( fifo->limit >= 0 && fifo->count + n > fifo->limit) { lua_settop( L, 0); // lua_pushboolean( L, 0); // false } else { fifo = prepare_fifo_access( L, -1); lua_replace( L, 2); // ud fifo ... fifo_push( L, fifo, n); // ud fifo lua_settop( L, 0); // lua_pushboolean( L, 1); // true } return 1; }
void serial_handle_interrupt(void) { if (!PIR1bits.RCIF) return ; if (RCSTAbits.OERR) { unsigned char c; c = RCREG; gfifo.error = 1; } else if (RCSTAbits.FERR) { RCSTAbits.CREN = 0; RCSTAbits.CREN = 1; gfifo.error = 1; } else { if (gfifo.size < sizeof(gfifo.buffer)) fifo_push(&gfifo, RCREG); else gfifo.overflow = 1; } PIR1bits.RCIF = 0; }
static int mystify_timer(TWidget *wid) { if(paused){ return 0; } if(polygons.nb_items > nb_polygons){ /* We have too many polygons, we must drop some of them */ fifo_pop(&polygons); } if(nb_polygons == polygons.nb_items){ /* We have the good number of polygons, we can safely drop the last one to add the new one later */ fifo_pop(&polygons); } fifo_push(&polygons, &leading_polygon); /* * Then we update the leading polygon for the next round acording to * current move (the move may be altered in case of sreen border * collision) */ polygon_update(&leading_polygon, &move); change_color(); wid->dirty++; return 0; }
// -----[ _post ]---------------------------------------------------- static int _post(sched_t * self, const sim_event_ops_t * ops, void * ctx, double time, sim_time_t time_type) { sched_static_t * sched= (sched_static_t *) self; _event_t * event= _event_create(ops, ctx); return fifo_push(sched->events, event); }
static void invalidate_one_bucket(struct cache *ca, struct bucket *b) { bch_inc_gen(ca, b); b->prio = INITIAL_PRIO; atomic_inc(&b->pin); fifo_push(&ca->free_inc, b - ca->buckets); }
int create_report(const void *r) { union { const ip_report_t *ir; const arp_report_t *ar; const void *ptr; const uint8_t *cr; const uint32_t *r_magic; const uint16_t *len; struct myiphdr *i; } r_u; size_t dlen=0; output_data_t *e_out=NULL; char *res=NULL; struct in_addr ia; r_u.ptr=r; if (_disabled == 1 || *r_u.r_magic != IP_REPORT_MAGIC) { return 1; } if (r_u.ir->proto != IPPROTO_TCP) { return 1; } if (r_u.ir->doff > 0) { dlen=(size_t)r_u.ir->doff; r_u.cr += sizeof(ip_report_t); if (*r_u.len != dlen) { ERR("Mis-Match length of packet data"); return 1; } r_u.len++; if (dlen < sizeof(struct myiphdr)) { return 1; } ia.s_addr=r_u.i->saddr; res=do_osdetect(r_u.cr, dlen); if (GET_IMMEDIATE() && res != NULL && strlen(res)) { OUT("System at %s matches OS %s", inet_ntoa(ia), res); } if (res != NULL) { e_out=(output_data_t *)xmalloc(sizeof(output_data_t)); e_out->type=OD_TYPE_OS; e_out->t_u.os=(char *)xstrdup(res); r_u.ptr=r; /* reset */ assert(r_u.ir->od_q != NULL); fifo_push(r_u.ir->od_q, (void *)e_out); } } return 1; }
void ui_printf(const char *msg, ...) { char *buf; size_t len; va_list args; ui_msg_t *m; /* Compute buffer length. */ va_start(args, msg); len = vsnprintf(NULL, 0, msg, args) + 1; va_end(args); /* Allocate data. */ buf = malloc(len); if(buf == NULL) return; m = malloc(sizeof *m); if(m == NULL) { free(buf); return; } /* Print into string. */ va_start(args, msg); vsprintf(buf, msg, args); va_end(args); /* Push message to UI queue. */ m->type = UI_MSG_PRINT; m->data = buf; fifo_push(event_queue, m); }
/* Add an operation to the queue for tile @index * Note: if an operation affects more than one tile, it must be added once per tile. * * Concurrency: This function is not thread-safe on the same @self instance. */ void operation_queue_add(OperationQueue *self, TileIndex index, OperationDataDrawDab *op) { while (!tile_map_contains(self->tile_map, index)) { #ifdef HEAVY_DEBUG operation_queue_resize(self, self->tile_map->size+1); #else operation_queue_resize(self, self->tile_map->size*2); #endif } Fifo **queue_pointer = (Fifo **)tile_map_get(self->tile_map, index); Fifo *op_queue = *queue_pointer; if (op_queue == NULL) { // Lazy initialization op_queue = fifo_new(); *queue_pointer = op_queue; } if (fifo_peek_first(op_queue) == NULL) { // Critical section, not thread-safe if (!(self->dirty_tiles_n < self->tile_map->size*2*self->tile_map->size*2)) { // Prune duplicate tiles that cause us to almost exceed max self->dirty_tiles_n = remove_duplicate_tiles(self->dirty_tiles, self->dirty_tiles_n); } assert(self->dirty_tiles_n < self->tile_map->size*2*self->tile_map->size*2); self->dirty_tiles[self->dirty_tiles_n++] = index; } fifo_push(op_queue, (void *)op); }
void progressive_display_add_rect(struct xrdp_screen * self) { int i, j; struct list* update_rects = self->update_rects; struct update_rect* urect; struct update_rect* fu_rect; struct update_rect* ur; struct xrdp_rect intersection; struct update_rect* tmp; struct list* l_tmp = list_create(); l_tmp->auto_free = 1; bool no_inter = true; while (!fifo_is_empty(self->candidate_update_rects)) { fu_rect = (struct update_rect*) fifo_pop(self->candidate_update_rects); if (update_rects->count > 0) { no_inter = true; for (i = update_rects->count - 1; i >= 0; i--) { urect = (struct update_rect*) list_get_item(update_rects, i); if (!rect_equal(&urect->rect, &fu_rect->rect)) { if (rect_intersect(&urect->rect, &fu_rect->rect, &intersection)) { no_inter = false; progressive_display_rect_union(fu_rect, urect, l_tmp); list_remove_item(update_rects, i); for (j = 0; j < l_tmp->count; j++) { ur = (struct update_rect*) list_get_item(l_tmp, j); tmp = (struct update_rect*) g_malloc(sizeof(struct update_rect), 0); g_memcpy(tmp, ur, sizeof(struct update_rect)); fifo_push(self->candidate_update_rects, tmp); } list_clear(l_tmp); break; } } else { no_inter = false; urect->quality = fu_rect->quality; urect->quality_already_send = fu_rect->quality_already_send; break; } } if (no_inter) { list_add_progressive_display_rect(update_rects, fu_rect->rect.left, fu_rect->rect.top, fu_rect->rect.right, fu_rect->rect.bottom, fu_rect->quality, fu_rect->quality_already_send); } } else { list_add_progressive_display_rect(update_rects, fu_rect->rect.left, fu_rect->rect.top, fu_rect->rect.right, fu_rect->rect.bottom, fu_rect->quality, fu_rect->quality_already_send); } } list_delete(l_tmp); }
static int kill_connection(uint64_t key, void *cptr, void *pri_work) { union { void *ptr; connection_status_t *c; } c_u; union { uint64_t state_key; struct { uint32_t dhost; uint16_t sport; uint16_t dport; } s; } k_u; union { void *ptr; send_pri_workunit_t *w; uint8_t *inc; } w_u; struct in_addr ia; char shost_s[32]; if (cptr == NULL) { PANIC("state table has NULL entry"); } if (pri_work == NULL) { PANIC("pri_work is NULL"); } c_u.ptr=cptr; k_u.state_key=key; ia.s_addr=c_u.c->send_ip; snprintf(shost_s, sizeof(shost_s) -1, "%s", inet_ntoa(ia)); ia.s_addr=k_u.s.dhost; if (c_u.c->status != U_TCP_CLOSE) { DBG(M_CON, "%s:%u -> %s:%u hanging in %s", shost_s, k_u.s.dport, inet_ntoa(ia), k_u.s.sport, strconnstatus(c_u.c->status)); w_u.ptr=xmalloc(sizeof(send_pri_workunit_t)); w_u.w->magic=PRI_4SEND_MAGIC; w_u.w->dhost=k_u.s.dhost; w_u.w->dport=k_u.s.dport; w_u.w->sport=k_u.s.sport; w_u.w->shost=c_u.c->send_ip; w_u.w->tseq=c_u.c->tseq + (c_u.c->window / 2); w_u.w->mseq=c_u.c->mseq; w_u.w->window_size=0; w_u.w->flags=TH_RST; w_u.w->doff=0; w_u.w->t_tstamp=c_u.c->t_tstamp; w_u.w->m_tstamp=c_u.c->m_tstamp + 1; fifo_push(pri_work, w_u.ptr); s->stats.stream_segments_sent++; w_u.ptr=NULL; } return 1; }
/** * @brief SPI event handler, from SPI driver */ void spi_event_handler(spi_slave_evt_t evt) { switch (evt.evt_type) { case SPI_SLAVE_BUFFERS_SET_DONE: if (has_pending_tx) { NRF_GPIO->OUTCLR = (1 << PIN_RDYN); } has_pending_tx = false; break; case SPI_SLAVE_XFER_DONE: NRF_GPIO->OUTSET = (1 << PIN_RDYN); nrf_gpio_pin_set(1); nrf_gpio_pin_clear(1); /* handle incoming */ if (rx_buffer.buffer[SERIAL_LENGTH_POS] > 0) { if (fifo_push(&rx_fifo, &rx_buffer) == NRF_SUCCESS) { /* notify ACI handler */ async_event_t async_evt; async_evt.callback.generic = mesh_aci_command_check; async_evt.type = EVENT_TYPE_GENERIC; event_handler_push(&async_evt); } else { APP_ERROR_CHECK(NRF_ERROR_NO_MEM); } } if (fifo_is_empty(&tx_fifo)) { serial_state = SERIAL_STATE_IDLE; prepare_rx(); enable_pin_listener(true); } else if (fifo_is_full(&rx_fifo)) { prepare_rx(); serial_state = SERIAL_STATE_WAIT_FOR_QUEUE; } else { do_transmit(); } break; default: /* no implementation necessary */ break; } }
void signal_process(struct process* process, int signum, intptr_t sigval) { struct thread* delivered = 0; // thread to awaken. { SPIN_GUARD_RAW(process->signal.lock); ++signal.seq; uint64_t sigbit = 1ull << (signum%SIGNAL_LIMIT); // can we do 'instant delivery' to the signal specific waiting thread? struct process_signal_info* sig = process->signal.sig + signum; struct thread* thread = sig->waiting; if (thread) { SPIN_GUARD_RAW(thread->signal.lock); if (thread->signal.wait_mask & sigbit) { // deliver the signal to this thread. thread->signal.wait_mask = 0; thread->signal.wait_signum = signum; thread->signal.wait_sigval = sigval; delivered = thread; // remove it from waiting list. sig->waiting = 0; list_remove(&thread->signal.waiting_item); } } // can we do 'instant delivery' to any waiting thread? if (!delivered) { for (list_item_t *li = list_first(&process->signal.waiting_list); li; li = list_next(li)) { struct thread* thread = list_container(li, struct thread, signal.waiting_item); SPIN_GUARD_RAW(thread->signal.lock); if (thread->signal.wait_mask & sigbit) { // deliver the signal to this thread. thread->signal.wait_mask = 0; thread->signal.wait_signum = signum; thread->signal.wait_sigval = sigval; delivered = thread; // remove it from waiting list. list_remove(li); break; } } } // queue the signal if it was not instantly delivered. if (!delivered) { struct signal_pending *pending = HEAP_NEW(struct signal_pending); pending->sigval = sigval; fifo_push(&sig->pending, &pending->item); process->signal.pending_mask |= sigbit; } } // wake up the thread that received the signal: if (delivered) { scheduler_wakeup(delivered); } }
//in: linda_ud key [val] int keepercall_set( lua_State* L) { STACK_GROW( L, 6); // make sure we have a value on the stack if( lua_gettop( L) == 2) // ud key val? { lua_pushnil( L); // ud key nil } // retrieve fifos associated with the linda push_table( L, 1); // ud key val fifos lua_replace( L, 1); // fifos key val if( !lua_isnil( L, 3)) // set/replace contents stored at the specified key? { keeper_fifo* fifo; lua_pushvalue( L, -2); // fifos key val key lua_rawget( L, 1); // fifos key val fifo|nil fifo = (keeper_fifo*) lua_touserdata( L, -1); if( fifo == NULL) // might be NULL if we set a nonexistent key to nil { lua_pop( L, 1); // fifos key val fifo_new( L); // fifos key val fifo lua_pushvalue( L, 2); // fifos key val fifo key lua_pushvalue( L, -2); // fifos key val fifo key fifo lua_rawset( L, 1); // fifos key val fifo } else // the fifo exists, we just want to clear its contents { // empty the fifo for the specified key: replace uservalue with a virgin table, reset counters, but leave limit unchanged! lua_newtable( L); // fifos key val fifo {} lua_setuservalue( L, -2); // fifos key val fifo fifo->first = 1; fifo->count = 0; } fifo = prepare_fifo_access( L, -1); lua_insert( L, -2); // fifos key fifo val fifo_push( L, fifo, 1); // fifos key fifo } else // val == nil // fifos key nil { keeper_fifo* fifo; lua_pop( L, 1); // fifos key lua_rawget( L, 1); // fifos fifo|nil // empty the fifo for the specified key: replace uservalue with a virgin table, reset counters, but leave limit unchanged! fifo = (keeper_fifo*) lua_touserdata( L, -1); if( fifo != NULL) // might be NULL if we set a nonexistent key to nil { lua_newtable( L); // fifos fifo {} lua_setuservalue( L, -2); // fifos fifo fifo->first = 1; fifo->count = 0; } } return 0; }
void Serial_WriteByte(uint8_t writtenByte) { unsigned int i; if (fifo_push(&Serial.fifo_output, writtenByte)) { for (i = 0; i < Serial.OBOH_Amount; i++) Serial.OutBufOverHandlers[i](); } RunTransmission(); }
void *fifo_fill( void *nothing ) { int i = 0; for (i = 0; i < ELEMS; i++) { fifo_push( fifo, NULL ); #ifdef VALUE_LOG dna_log(DEBUG, "<< added %i to value fifo", i); #endif } return NULL; }
bool switch_unicast(Port* port, Packet* packet) { if(!port->out) return false; #ifdef NET_CONTROL if(!fifo_push(port->out->queue, packet)) return false; #else port->out->send(port->out, packet); #endif return true; }
void Serial_WriteFloat(float number) { int i, j; Serial._32Converter.RealNum = number; for (i = 3; i >= 0; i--) { if (fifo_push(&Serial.fifo_output, Serial._32Converter.Bytes[i])) { for (j = 0; j < Serial.OBOH_Amount; j++) Serial.OutBufOverHandlers[j](); } } RunTransmission(); }
int neighbour_list_scan_neighbour(void * data, void * user_data) { struct neighbour * n = (struct neighbour *)data; struct fifo * delete_list = (struct fifo *)user_data; if(n->ttl <= 0) { fifo_push(delete_list,n); } else { n->ttl -= 1; } return 0; }
void Serial_WriteInt16(uint16_t number) { int i, j; Serial.WordConverter.Word = number; for (i = 1; i >= 0; i--) { if (fifo_push(&Serial.fifo_output, Serial.WordConverter.Bytes[i])) { for (j = 0; j < Serial.OBOH_Amount; j++) Serial.OutBufOverHandlers[j](); } } RunTransmission(); }
void Serial_WriteLine(const char* line) { unsigned int j; uint16_t i = 0; while(line[i] != '\0') { if (fifo_push(&Serial.fifo_output, line[i])) { for (j = 0; j < Serial.OBOH_Amount; j++) Serial.OutBufOverHandlers[j](); } i++; } RunTransmission(); }