コード例 #1
0
ファイル: fifotest.c プロジェクト: DanielO/oslec-min
int
main(int argc, char **argv) {
    struct fifo	*f;
    uint8_t	i, count, d[5], d2[6];
    
    assert((f = fifo_alloc(8)) != NULL);


    for (count = 0; fifo_put(f, &count, 1) == 1; count++)
	;
    
    printf("Wrote %d items into the FIFO\n", count);
    fifo_dump(f);

    for (i = 0; i < sizeof(d); i++)
	d[i] = i;
    
    printf("Wrote %d bytes [0..4]\n", fifo_put(f, d, sizeof(d)));
    printf("Wrote %d bytes [0..2]\n", fifo_put(f, d, sizeof(d)));
    printf("Read %d bytes\n", fifo_get(f, d2, sizeof(d2)));
    for (i = 0; i < sizeof(d2); i++)
	printf("Got %d\n", d2[i]);
    
    printf("Unread %d bytes\n", fifo_unget(f, d2, sizeof(d2)));
    fifo_dump(f);
    
    exit(0);
}
コード例 #2
0
ファイル: __stdio_flush.c プロジェクト: IngenicC/xboot
int __stdio_write_flush(FILE * f)
{
	unsigned char * p;
	size_t size;
	ssize_t ret;

	if(!f)
		return -1;

	p = f->buf;
	size = fifo_get(f->fifo_write, p, f->bufsz);

	while(size > 0)
	{
		ret = f->write(f, p, size);

		if(ret <= 0)
		{
			f->error = 1;
			fifo_put(f->fifo_write, p, size);
			return -1;
		}

		size -= ret;
		p += ret;
	};


	f->rwflush = &__stdio_no_flush;
	return 0;
}
コード例 #3
0
void alp_append_write_file_data_action(fifo_t* fifo, uint8_t file_id, uint32_t offset, uint32_t length, uint8_t* data, bool resp, bool group) {
  uint8_t op = ALP_OP_WRITE_FILE_DATA | (resp << 6) | (group << 7);
  assert(fifo_put_byte(fifo, op) == SUCCESS);
  alp_append_file_offset_operand(fifo, file_id, offset);
  alp_append_length_operand(fifo, length);
  assert(fifo_put(fifo, data, length) == SUCCESS);
}
コード例 #4
0
ファイル: interrupt.c プロジェクト: MJason23/Self-made-OS
void inthandler21(int *esp)
{
	unsigned char data;
	data = io_in8(PORT_KEYDATA);		//键盘输入的信息从0x0060传入一个字节,由data接收到(键盘电路设计一次只能传入一个字节)
	io_out8(PIC0_OCW2,0x61);			//CPU通知PIC0“IRQ1已经受理完毕”
	fifo_put(&keyFIFO, data);
}
コード例 #5
0
void alp_append_return_file_data_action(fifo_t* fifo, uint8_t file_id, uint32_t offset, uint32_t length, uint8_t* data) {
  assert(fifo_put_byte(fifo, ALP_OP_RETURN_FILE_DATA) == SUCCESS);
  assert(fifo_put_byte(fifo, file_id) == SUCCESS);
  alp_append_length_operand(fifo, offset);
  alp_append_length_operand(fifo, length);
  assert(fifo_put(fifo, data, length) == SUCCESS);
}
コード例 #6
0
void uart_rx_cb(uint8_t data)
{
    error_t err;
    err = fifo_put(&uart_rx_fifo, &data, 1); assert(err == SUCCESS);
    // parse command in read_rssi() task
    use_manual_channel_switching = true;
}
コード例 #7
0
ファイル: timer.c プロジェクト: tyfkda/haribote
// IRQ-20 : Timer interrupt.
void inthandler20(int* esp) {
  (void)esp;
  char switch_task = FALSE;
  io_out8(PIC0_OCW2, 0x60);  // Notify IRQ-00 recv to PIC
  ++timerctl.count;
  if (timerctl.next_time > timerctl.count)
    return;
  TIMER* timer = timerctl.t0;
  for (;;) {
    if (timer->timeout > timerctl.count)
      break;
    timer->flags = TIMER_FLAGS_ALLOCATED;
    if (timer != task_timer) {
      fifo_put(timer->fifo, timer->data);
    } else {
      switch_task = TRUE;
    }
    timer = timer->next_timer;
  }
  timerctl.t0 = timer;
  timerctl.next_time = timerctl.t0->timeout;

  if (switch_task)
    task_switch();
}
コード例 #8
0
ファイル: data.c プロジェクト: magsilva/messaging-server
int user_logoff( unsigned int userId ) {
        struct user_t *user, *search;
        struct list_t *change;
        struct message_t message;
                                 
                        
        user = users;
        while ( user != NULL ) {
                if ( user->id == userId ) {
                        user->status = 0;
                        free( user->address );
                 
                        search = users;
                        while ( search != NULL ) {
                                change = search->list;
                                while (change != NULL) {
                                        if (change->id == userId) {
                                                message.from = userId;
                                                message.to = search->id;
                                                message.type = 6;
                                                fifo_put(&messages,&message);
                                        }
                                change = change->next;
                                }
                        search = search->next;
                        }
                         // Notifica a alteração de estados para todos os usuários que
                        // incluem este usuário em sua lista  // TODO
                        return 1;
                }
                user = user->next;
        }
                                
        return -1;
}      
コード例 #9
0
ファイル: lwb.c プロジェクト: ETHZ-TEC/LWB
/* store a received message in the incoming queue, returns 1 if successful, 
 * 0 otherwise */
uint8_t 
lwb_in_buffer_put(const uint8_t * const data, uint8_t len)
{  
  if(len > LWB_CONF_MAX_DATA_PKT_LEN) {
    len = LWB_CONF_MAX_DATA_PKT_LEN;
    DEBUG_PRINT_WARNING("received data packet is too big"); 
  }
  /* received messages will have the max. length LWB_CONF_MAX_DATA_PKT_LEN */
  uint32_t pkt_addr = fifo_put(&in_buffer);
  if(FIFO_ERROR != pkt_addr) {
#if !LWB_CONF_USE_XMEM
    /* copy the data into the queue */
    memcpy((uint8_t*)(uint16_t)pkt_addr, data, len);
    /* last byte holds the payload length */
    *(uint8_t*)((uint16_t)pkt_addr + LWB_CONF_MAX_DATA_PKT_LEN) = len;    
#else /* LWB_CONF_USE_XMEM */
    /* write the data into the queue in the external memory */
    xmem_write(pkt_addr, len, data);
    xmem_write(pkt_addr + LWB_CONF_MAX_DATA_PKT_LEN, 1, &len);
#endif /* LWB_CONF_USE_XMEM */
    return 1;
  }
  stats.rxbuf_drop++;
  DEBUG_PRINT_VERBOSE("in queue full");
  return 0;
}
コード例 #10
0
ファイル: lwb.c プロジェクト: ETHZ-TEC/LWB
/* puts a message into the outgoing queue, returns 1 if successful, 
 * 0 otherwise */
uint8_t
lwb_send_pkt(uint16_t recipient,
             uint8_t stream_id, 
             const uint8_t * const data, 
             uint8_t len)
{
  /* data has the max. length LWB_DATA_PKT_PAYLOAD_LEN, lwb header needs 
   * to be added before the data is inserted into the queue */
  if(len > LWB_DATA_PKT_PAYLOAD_LEN || !data) {
    DEBUG_PRINT_ERROR("invalid payload length");
    return 0;
  }
  uint32_t pkt_addr = fifo_put(&out_buffer);
  if(FIFO_ERROR != pkt_addr) {
#if !LWB_CONF_USE_XMEM
    /* assume pointers are 16-bit */
    uint8_t* next_msg = (uint8_t*)(uint16_t)pkt_addr;  
    *(next_msg) = (uint8_t)recipient;   /* recipient L */  
    *(next_msg + 1) = recipient >> 8;   /* recipient H */  
    *(next_msg + 2) = stream_id; 
    *(next_msg + LWB_CONF_MAX_DATA_PKT_LEN) = len + LWB_CONF_HEADER_LEN;
    memcpy(next_msg + LWB_CONF_HEADER_LEN, data, len);
#else /* LWB_CONF_USE_XMEM */
    *(data_buffer) = (uint8_t)recipient;   /* recipient L */  
    *(data_buffer + 1) = recipient >> 8;   /* recipient H */
    *(data_buffer + 2) = stream_id;
    *(data_buffer + LWB_CONF_MAX_DATA_PKT_LEN) = len + LWB_CONF_HEADER_LEN;
    memcpy(data_buffer + LWB_CONF_HEADER_LEN, data, len);
    /* always read the max length since we don't know how long the packet is */
    xmem_write(pkt_addr, LWB_CONF_MAX_DATA_PKT_LEN + 1, data_buffer);
#endif /* LWB_CONF_USE_XMEM */
    return 1;
  }
コード例 #11
0
ファイル: app_fifo.c プロジェクト: etx/Espruino
uint32_t app_fifo_write(app_fifo_t * p_fifo, uint8_t const * p_byte_array, uint32_t * p_size)
{
    VERIFY_PARAM_NOT_NULL(p_fifo);
    VERIFY_PARAM_NOT_NULL(p_size);

    const uint32_t available_count = p_fifo->buf_size_mask - fifo_length(p_fifo) + 1;
    const uint32_t requested_len   = (*p_size);
    uint32_t       index           = 0;
    uint32_t       write_size      = MIN(requested_len, available_count);

    (*p_size) = available_count;

    // Check if the FIFO is FULL.
    if (available_count == 0)
    {
        return NRF_ERROR_NO_MEM;
    }

    // Check if application has requested only the size.
    if (p_byte_array == NULL)
    {
        return NRF_SUCCESS;
    }

    //Fetch bytes from the FIFO.
    while (index < write_size)
    {
        fifo_put(p_fifo, p_byte_array[index++]);
    }

    (*p_size) = write_size;

    return NRF_SUCCESS;
}
コード例 #12
0
/**
 * @fn void interrupt ISR_handle(void)
 * @brief
 *
 * @param none
 * @return nothing
 */
void interrupt ISR_handle(void) {
	uint8_t ui8_slave_state = 0;
	uint8_t ui8_i2c_value = 0;
	if(SSPIF == 1) {
		SSPIF = 0; // Reset IRQ flag
		i2c_slave_state(&ui8_slave_state);
		if((ui8_slave_state == 1) || (ui8_slave_state == 3)) {
			i2c_slave_read(); // Read SSPBUF to clear BF bit but don't care about returned value
			gui8_recv_byte_idx = 0;
			gui8_frame_recv_size = 0;
		}
		else if(ui8_slave_state == 2) {
			ui8_i2c_value = i2c_slave_read(); // Read SSPBUF to clear BF bit and read data from master
			fifo_put(ui8_i2c_value);

			// copy frame size byte
			if(gui8_recv_byte_idx == 1) {
				gui8_frame_recv_size = ui8_i2c_value - 1;
			}
			/* else nothing to do */

			// indicate that is the last byte received
			if((gui8_frame_recv_size == gui8_recv_byte_idx) && 
			   (gui8_recv_byte_idx != 0)) {
				gui8_token ++; // increase the number of frames received
			}
			/* else nothing to do */

			gui8_recv_byte_idx ++;
		}
		/* else nothing to do */
		CKP = 1;
	}
	/* else nothing to do */
}
コード例 #13
0
ファイル: shell.c プロジェクト: WangDongfang/DfewOS
int C_put_fifo (int argc, char **argv)
{
    int value = 0;
    int i = 1; /* value start index in argv */

    if (_G_p_fifo == NULL) {
        _G_p_fifo = fifo_create (_FIFO_NUM, sizeof (int));
    }

    /* create FIFO failed */
    if (_G_p_fifo == NULL) {
        serial_printf("Create FIFO failed!");
        return CMD_ERROR;
    }

    /* read the put values */
    for (; i < argc; i++) {
        value = 0;
        sscanf (argv[i], "%d", (unsigned int *)&value);
        if (fifo_put (_G_p_fifo, &value) == OS_STATUS_ERROR) {
            serial_printf("The FIFO is full!");
            return CMD_ERROR;
        }
        serial_printf("Put: %d\n", value);
    }

    serial_printf("The put operation is Done.");
    return CMD_OK;
}
コード例 #14
0
ファイル: serial.c プロジェクト: HarryR/sanos
static int serial_write(struct dev *dev, void *buffer, size_t count, blkno_t blkno, int flags) {
  struct serial_port *sp = (struct serial_port *) dev->privdata;
  unsigned int n;
  unsigned char *bufp;

  if (wait_for_object(&sp->tx_lock, sp->cfg.tx_timeout) < 0) return -ETIMEOUT;

  bufp = (unsigned char *) buffer;
  for (n = 0; n < count; n++) {
    // Wait until tx queue is not full
    if (wait_for_object(&sp->tx_sem, sp->cfg.tx_timeout) < 0) break;

    // Insert next char in transmit queue
    cli();
    fifo_put(&sp->txq, *bufp++);
    sti();

    //kprintf("serial: write %02X\n", bufp[-1]);
    //kprintf("fifo put: h:%d t:%d c:%d\n", sp->txq.head, sp->txq.tail, sp->txq.count);

    // If transmitter idle then queue a DPC to restart transmission
    //if (!sp->tx_busy) queue_dpc(&sp->dpc, serial_dpc, sp);

    // If transmitter idle then restart transmission
    if (!sp->tx_busy) drain_tx_queue(sp);
  }

  release_mutex(&sp->tx_lock);
  return count;
}
コード例 #15
0
ファイル: test_fifo.c プロジェクト: vyacht/stm32
int main(int argc, char * argv[]) {

  unsigned int i = 0;
  char b[32];
  int ret = 0;

  fifo_t fifo;
  fifo_init(&fifo);

  for(i = 0; i < 2600; i++) {
   if(!fifo_put(&fifo, i + 'a')) {
     printf("buffer full at %d\n", i);
     break;
   }
  }

  unsigned int out = -1;
  unsigned int in  = out + 10;
  printf("%u - %u = %u\n", in, out, in - out);

  

  ret = fifo_out(&fifo, b, 7);
  b[ret] = 0;

  printf("%d - %s\n", ret, b);
}
コード例 #16
0
ファイル: timer.c プロジェクト: songtzu/study
void 
interrupt_handler20(int* esp)
{
  timer_t* timer;
  char ts = 0;

  io_out8(PIC0_OCW2, 0x60); /* send sign to PIC from IRQ-00 */
  ++g_timerctl.count;
  if (g_timerctl.next > g_timerctl.count)
    return;   /* not the next timeout timer, break */

  timer = g_timerctl.timer0;
  for ( ; ; ) {
    /* timers are all using, donot need to check flags */
    if (timer->timeout > g_timerctl.count)
      break;

    /* timeout */
    timer->flags = TIMER_FLAGS_ALLOC;
    if (timer != g_task_timer)
      fifo_put(timer->fifo, timer->data);
    else 
      ts = 1; /* g_task_timer timeout */
    timer = timer->next;
  }

  g_timerctl.timer0 = timer;
  g_timerctl.next   = timer->timeout;

  /* task switch */
  if (0 != ts) 
    task_switch();
}
コード例 #17
0
void fifo__write(fifo_t *fifo,const uint8_t *p_dat,int len)
{
  int i;
  for(i=0;i<len;i++)
  {
    fifo_put(fifo,*(p_dat+i));
  }
}
コード例 #18
0
ファイル: ccnsrc.c プロジェクト: Emat12/gstreamer-ccnx
/**
 * Moves the data into an internal buffer and sends it out on the fifo queue
 *
 * Here we deal with the difference in buffer sizes between what comes in from the
 * network, and what we use internally on the gst pipeline [via the fifo queue].
 * We keep track of space available, and partially filled buffers as needed.
 *
 * \param me		source context for the bytes coming in to this element
 * \param data		pointer to the new buffer of data
 * \param data_size	number of bytes to transfer
 * \param b_last	flag telling us that this is the last block of data
 */
static void
process_segment (Gstccnxsrc * me, const guchar * data, const size_t data_size,
    const gboolean b_last)
{
  size_t start_offset = 0;

  if (data_size > 0) {
    start_offset = me->i_pos % CCN_CHUNK_SIZE;
    if (start_offset > data_size) {
      GST_LOG_OBJECT (me, "start_offset %zu > data_size %zu", start_offset,
          data_size);
    } else {
      if ((data_size - start_offset) + me->i_bufoffset > CCN_FIFO_BLOCK_SIZE) {
        /* won't fit in buffer, release the buffer upstream via the fifo queue */
        GST_DEBUG ("pushing data");
        GST_BUFFER_SIZE (me->buf) = me->i_bufoffset;
        fifo_put (me, me->buf);
        me->buf = gst_buffer_new_and_alloc (CCN_FIFO_BLOCK_SIZE);
        me->i_bufoffset = 0;
      }
      /* will fit in buffer */
      memcpy (GST_BUFFER_DATA (me->buf) + me->i_bufoffset, data + start_offset,
          data_size - start_offset);
      me->i_bufoffset += (data_size - start_offset);
    }
  }

  /* if we're done, indicate so with a 0-byte block, release any buffered data upstream,
   * and don't express an interest
   */
  if (b_last) {
    GST_DEBUG ("handling last block");
    if (me->i_bufoffset > 0) {  // flush out any last bits we had
      GST_BUFFER_SIZE (me->buf) = me->i_bufoffset;
      fifo_put (me, me->buf);
      me->buf = gst_buffer_new_and_alloc (CCN_FIFO_BLOCK_SIZE);
      me->i_bufoffset = 0;
    }
/*
 * \todo should emit an eos here instead of the empty buffer
 */
    GST_BUFFER_SIZE (me->buf) = 0;
    fifo_put (me, me->buf);
    me->i_bufoffset = 0;
  }
}
コード例 #19
0
ファイル: interrupt.c プロジェクト: MJason23/Self-made-OS
void inthandler2c(int *esp)
{
	unsigned char data;
	data = io_in8(PORT_KEYDATA);		//读取数据方式与键盘一样,所以只能到主程序中通过各自的缓冲区判断是鼠标的数据还是键盘的数据
	io_out8(PIC1_OCW2,0x64);			//必须先通知从PIC的IRQ12已经处理完毕,然后再通知主PIC(从PIC控制IRQ8到15,IRQ12是第4个,所以是0x64)
	io_out8(PIC0_OCW2,0x62);			//因为主从PIC的协调不能靠自己完成,必须由主程序教给他们怎么做
	fifo_put(&mouseFIFO, data);
}
コード例 #20
0
ファイル: usbn960x.c プロジェクト: DerGenaue/usbprog
// ********************************************************************
// copy data to fifo for sending 
// ********************************************************************
/// copy mem to software fifo for endpoint
void _USBNMemFIFO(fifo_t *fifo,char* data,int size)
{  
  int i;
  for(i=0;i<size;i++)
  {
    fifo_put (fifo, (char)data[i]); 
  } 
}
コード例 #21
0
ファイル: fifo.c プロジェクト: shackspace/light-control
int fifo_roll (fifo_t *f, uint8_t len)
{
	uint8_t i;
	for (i=0;i<len;i++)
		fifo_put( f, fifo_get(f) ); 

	return 0;
}
コード例 #22
0
ファイル: usart.cpp プロジェクト: twam/dcf77decode
// send a char on line
int usartPutchar(char c, FILE* f)
{
	uint8_t ret = 0;
	while (!ret) {
		ret= fifo_put(&usartTxFifo, c);
	}
	UCSR0B |= _BV(UDRIE0);
	return ret;
}
コード例 #23
0
ファイル: main.c プロジェクト: threader/Mac-On-Linux
static InterruptMemberNumber
hard_irq( InterruptSetMember ISTmember, void *ref_con, UInt32 the_int_count )
{
	channel_t *ch = channels;	/* fixme */
	int running, compl_cnt, event;
	request_t *r;
	
	/* Note: Q & A DV 34 explicitly forbids the usage of secondary
	 * interrupts on the page-fault path (it leads to deadlocks).
	 */
	/* Note: The OSI call _always_ modifies the return arguments */
	if( !OSI_ABlkIRQAck( ch->channel, &compl_cnt, &running, &event ) )
		return kIsrIsNotComplete;

	ch->running = running;

	if( event )
		handle_events( ch );

	/* handle overflow buffer */
	if( ch->obuf_cnt && compl_cnt - ch->obuf_completion >= 0 ) {
		if( ch->obuf_dest ) {
			char *dest = ch->obuf_dest, *src = ch->obuf;
			int cnt = ch->obuf_cnt;
			while( cnt-- )
				*dest++ = *src++;
		}
		/* XXX: insert optimization barrier here */
		*(volatile int*)&ch->obuf_cnt = 0;
	}

	/* process completions */
	while( (r=(request_t*)dequeue(&ch->compl_queue)) ) {
		IOCommandID cmdID;

		if( r->req_num - compl_cnt > 0 ) {
			enqueue_tail( &ch->compl_queue, (queue_el_t*)r );
			break;
		}
		/* free resources... */
		if( r->mem_prepared )
			CheckpointIO( r->ioprep.preparationID, 0 );

		if( r->ablk_req & (ABLK_READ_REQ | ABLK_WRITE_REQ) )
			((IOParam*)r->pb)->ioActCount = r->xfer_cnt;
		
		cmdID = r->cmdID;
		fifo_put( &ch->free_fifo, (fifo_el_t*)r );

		/* ...and complete */
		IOCommandIsComplete( cmdID, noErr );
	}
	process_request_queue( ch );

	return kIsrIsComplete;
}
コード例 #24
0
static void add_interface_status_action(fifo_t* alp_response_fifo, d7ap_session_result_t* d7asp_result)
{
  fifo_put_byte(alp_response_fifo, ALP_OP_RETURN_STATUS + (1 << 6));
  fifo_put_byte(alp_response_fifo, ALP_ITF_ID_D7ASP);
  fifo_put_byte(alp_response_fifo, d7asp_result->channel.channel_header_raw);
  uint16_t center_freq_index_be = __builtin_bswap16(d7asp_result->channel.center_freq_index);
  fifo_put(alp_response_fifo, (uint8_t*)&center_freq_index_be, 2);
  fifo_put_byte(alp_response_fifo, d7asp_result->rx_level);
  fifo_put_byte(alp_response_fifo, d7asp_result->link_budget);
  fifo_put_byte(alp_response_fifo, d7asp_result->target_rx_level);
  fifo_put_byte(alp_response_fifo, d7asp_result->status.raw);
  fifo_put_byte(alp_response_fifo, d7asp_result->fifo_token);
  fifo_put_byte(alp_response_fifo, d7asp_result->seqnr);
  fifo_put_byte(alp_response_fifo, d7asp_result->response_to);
  fifo_put_byte(alp_response_fifo, d7asp_result->addressee.ctrl.raw);
  fifo_put_byte(alp_response_fifo, d7asp_result->addressee.access_class);
  uint8_t address_len = alp_addressee_id_length(d7asp_result->addressee.ctrl.id_type);
  fifo_put(alp_response_fifo, d7asp_result->addressee.id, address_len);
}
コード例 #25
0
ファイル: keyboard.c プロジェクト: dalent/myos
void do_kb_interupt()
{
	char data;
	PIC_sendEOI(1);
	//outb(0x61, 0x20);
	data = inb(KB_DATA);

	fifo_put(kbFIFO, offset + data);
	//draw_char(0xe0000000, 1024, 15, 0,0, data);
}
コード例 #26
0
ファイル: fifo.c プロジェクト: shackspace/light-control
uint8_t fifo_transfer (fifo_t *f1, fifo_t *f2, uint8_t len)
{
	uint8_t real_len = f2->count;
	if (real_len < len) len = real_len;

	uint8_t i;
	for (i=0;i<len;i++)
		fifo_put( f1, fifo_get(f2) ); 
	return len;
}
コード例 #27
0
ファイル: pic.c プロジェクト: hbfhaapy/study
void 
interrupt_handler21(int* esp)
{
  unsigned char data;

  io_out8(PIC0_OCW2, 0x61); /* call PIC that IRQ-01 is finished */
  data = io_in8(PORT_KEYDATA);

  fifo_put(&g_keybuf, data);
}
コード例 #28
0
ファイル: app_fifo.c プロジェクト: etx/Espruino
uint32_t app_fifo_put(app_fifo_t * p_fifo, uint8_t byte)
{
    if (FIFO_LENGTH() <= p_fifo->buf_size_mask)
    {
        fifo_put(p_fifo, byte);
        return NRF_SUCCESS;
    }

    return NRF_ERROR_NO_MEM;
}
コード例 #29
0
ファイル: bootpack.c プロジェクト: MJason23/Self-made-OS
void keywindow_off(LAYER *key_to_window)
{
	//先改变这个窗口的标题栏的状态
	change_titlebar(key_to_window, 0);
	//如果是应用窗口的话,它的flags的0x20位设置成1了;应用窗口是不需要显示光标的
	if(0 != (key_to_window->flags & 0x20))
	{
		fifo_put(&key_to_window->task->fifo, 3);			//命令行窗口的光标OFF掉,因为当前是应用程序窗口在接收键盘输入
	}
	return ;
}
コード例 #30
0
ファイル: fifo.c プロジェクト: shackspace/light-control
uint8_t fifo_put_var_p (fifo_t *f, const uint8_t *data, uint8_t len)
{
	uint8_t i, ret = 0;
	for (i=0;i < len; i++) {
		ret = fifo_put (f, pgm_read_byte(data++));
		if (ret == 0)
			return ret;
	}
	
	return ret;
}