コード例 #1
0
ファイル: mp-v1.c プロジェクト: scanner-darkly/mod
static void handler_KeyTimer(s32 data) {
	static u16 i1;

	if(front_timer) {
		if(front_timer == 1) {
			static event_t e;
			e.type = kEventSaveFlash;
			event_post(&e);

			preset_mode = 0;
			front_timer--;
		}
		else front_timer--;
	}

	for(i1=0;i1<key_count;i1++) {
		if(key_times[held_keys[i1]])
		if(--key_times[held_keys[i1]]==0) {
			if(preset_mode == 1) {
				if(held_keys[i1] % 16 == 0) {
					preset_select = held_keys[i1] / 16;
					// flash_write();
					static event_t e;
					e.type = kEventSaveFlash;
					event_post(&e);
					preset_mode = 0;
				}
			}

			// print_dbg("\rlong press: "); 
			// print_dbg_ulong(held_keys[i1]);
		}
	}
}
コード例 #2
0
ファイル: init_ansible.c プロジェクト: bpcmusic/libavr32
static void irq_port1_line1(void) {
    // print_dbg("\r\ninterrupt on PB08-PB15.");

    // clock norm
    // if(gpio_get_pin_interrupt_flag(B10)) {

    //   static event_t e;
    //   e.type = kEventTrNormal;
    //   e.data = !gpio_get_pin_value(B10);
    //   event_post(&e);
    //   gpio_clear_pin_interrupt_flag(B10);
    // }

    // clock in
    if(gpio_get_pin_interrupt_flag(B08)) {
      static event_t e;
      e.type = kEventTr;
      e.data = gpio_get_pin_value(B08);
      event_post(&e);
      gpio_clear_pin_interrupt_flag(B08);
    }

    // tr in
    if(gpio_get_pin_interrupt_flag(B09)) {
      static event_t e;
      e.type = kEventTr;
      e.data = gpio_get_pin_value(B09) + 2;
      event_post(&e);
      gpio_clear_pin_interrupt_flag(B09);
    }

}
コード例 #3
0
ファイル: adc.c プロジェクト: Someone101/aleph
// perform conversion, check for changes, and post events
void adc_poll(void) {
#if 1
#else
  static u16 adcVal[4] = {0, 0, 0, 0};
  static event_t e;
  u8 i;

  adc_convert(&adcVal);

#if 0
  for(i=0; i<4; i++) {        
    // TODO:
    /// probably want more filtering before posting events?? i dunno
    //    if(adcVal[i] != adcOldVal[i]) {
    /// this is a dirty way! but the two lower bits are pretty noisy.
    valMask = adcVal[i] & 0xff8;
    if( valMask != adcOldVal[i] ) {
      adcOldVal[i] = valMask;
      e.type = adctypes[i];
      // use the data without the mask
      e.data = (S16)(adcVal[i]);
      event_post(&e);
    }
  }
#else 
  /// test with no filtering.. maybe this is fine
  for(i=0; i<4; i++) {        
    e.type = adctypes[i];
    e.data = (S16)(adcVal[i]);
    event_post(&e);
  }
#endif

#endif
}
コード例 #4
0
ファイル: init_trilogy.c プロジェクト: pq/libavr32
static void irq_port1_line1(void) {
    // print_dbg("\r\ninterrupt on PB08-PB15.");

    // static event_t e;   
    // e.type = kSwitchEvents[swIdx];
    // e.data = gpio_get_pin_value(kSwitchPins[swIdx]); 
    // event_post(&e);

    // clock norm
    if(gpio_get_pin_interrupt_flag(B09)) {

      static event_t e;
      e.type = kEventClockNormal;
      e.data = !gpio_get_pin_value(B09);
      event_post(&e);

      gpio_clear_pin_interrupt_flag(B09);
    }

    // clock in
    if(gpio_get_pin_interrupt_flag(B08)) {
      // CLOCK BOUNCY WITHOUT THESE PRINTS
      // print_dbg("\rclk: ");
      // print_dbg_ulong(gpio_get_pin_value(B08));
      // (*clock_pulse)(gpio_get_pin_value(B08));
      static event_t e;
      e.type = kEventClockExt;
      e.data = gpio_get_pin_value(B08);
      event_post(&e);
      gpio_clear_pin_interrupt_flag(B08);
    }
}
コード例 #5
0
ファイル: main.c プロジェクト: jthacker/RIOT
int main(void)
{
    puts("[START] event test application.\n");

    event_queue_t queue = { .waiter = (thread_t *)sched_active_thread };
    printf("posting 0x%08x\n", (unsigned)&event);
    event_post(&queue, &event);

    printf("posting 0x%08x\n", (unsigned)&event2);
    event_post(&queue, &event2);
    printf("canceling 0x%08x\n", (unsigned)&event2);
    event_cancel(&queue, &event2);

    printf("posting custom event\n");
    event_post(&queue, (event_t *)&custom_event);

    event_timeout_t event_timeout;

    printf("posting timed callback with timeout 1sec\n");
    event_timeout_init(&event_timeout, &queue, (event_t *)&event_callback);
    before = xtimer_now_usec();
    event_timeout_set(&event_timeout, 100000LU);

    printf("launching event queue\n");
    event_loop(&queue);

    return 0;
}
コード例 #6
0
ファイル: main.c プロジェクト: jpfender/openlab
static void alarm(handler_arg_t arg)
{
    if (leds_active)
        leds_toggle(LED_0 | LED_1 | LED_2);

    /* Print help before getting first real \n */
    if (print_help) {
        event_post(EVENT_QUEUE_APPLI, handle_cmd, (handler_arg_t) 'h');
        event_post(EVENT_QUEUE_APPLI, handle_cmd, (handler_arg_t) '\n');
    }
}
コード例 #7
0
static void rx_done(phy_status_t status)
{
    switch (status)
    {
        case PHY_SUCCESS:
            event_post(EVENT_QUEUE_APPLI, process_rx_packet, NULL);
            break;
        default:
            // Bad packet
            event_post(EVENT_QUEUE_APPLI, enter_rx, NULL);
            break;
    }
}
コード例 #8
0
ファイル: mpi_event_loop.c プロジェクト: Meijuh/ltsmin
void event_wait(event_queue_t queue,MPI_Request *request,MPI_Status *status){
    struct event_status e_stat;
    e_stat.pending=1;
    e_stat.status=status;
    event_post(queue,request,copy_status,&e_stat);
    event_while(queue,&e_stat.pending);
}
コード例 #9
0
ファイル: scanf_stack_usage.c プロジェクト: adjih/openlab
static void test_task(void *param)
{
    static unsigned int stack1, stack2, stack3;

    static int a;
    static char str[128];
    static float pi;

    stack = uxTaskGetStackHighWaterMark( NULL );

    sscanf("", "");
    stack1 = uxTaskGetStackHighWaterMark( NULL );
    sscanf("1", "%d", &a);
    stack2 = uxTaskGetStackHighWaterMark( NULL );
    sscanf("1 string 3.14", "%d", &a, str, &pi);
    stack3 = uxTaskGetStackHighWaterMark( NULL );


    printf("\n");
    printf("Base stack %u\n", stack);
    printf("Post empty scanf   %u diff %u\n", stack1, stack - stack1);
    printf("Post simple scanf  %u diff %u\n", stack2, stack - stack2);
    printf("Post complex scanf %u diff %u\n", stack3, stack - stack3);
    printf("\n");

    event_post(EVENT_QUEUE_APPLI, print_queue_stack, NULL);

    while (1)
        asm("wfi");
}
コード例 #10
0
ファイル: mp-v1.c プロジェクト: scanner-darkly/mod
// monome refresh callback
static void monome_refresh_timer_callback(void* obj) {
	if(monomeFrameDirty > 0) {
		static event_t e;
		e.type = kEventMonomeRefresh;
		event_post(&e);
	}
}
コード例 #11
0
ファイル: init_teletype.c プロジェクト: monome/libavr32
static void irq_port0_line1(void) {
    if(gpio_get_pin_interrupt_flag(NMI)) {
      // print_dbg("\r\n ### NMI ### ");
      event_t e = { .type = kEventFront, .data = gpio_get_pin_value(NMI) };
      event_post(&e);
      gpio_clear_pin_interrupt_flag(NMI);
    }
}
コード例 #12
0
ファイル: switches.c プロジェクト: Someone101/aleph
// generate events from switch interrupts
void process_sw( const U8 swIdx )  {
  static event_t e;   
  e.type = kSwitchEvents[swIdx];
  e.data = gpio_get_pin_value(kSwitchPins[swIdx]); 
  event_post(&e);
  //  print_dbg("\r\n posted switch event ");
  //  print_dbg_ulong(swIdx);
}
コード例 #13
0
ファイル: net_http.c プロジェクト: htc550605125/http-proxy
static int net_connect_req_handler(struct net_handle_cxt* cxt,
                                   struct net_req* req) {
    PLOGD("Entering CONNECT handler!");
    struct strbuf* buf = &req->data->buf;
    PLOGD("HTTP/%d.%d", req->ver_major, req->ver_minor);
    req->host = req->path;
    PLOGD("Host: %s", buf->p + req->host);
    PLOGD("Port: %d", req->port);

    struct conn* client = cxt->client;
    PLOGD("From client: %s", ep_tostring(&client->ep));
    
    struct conn* server = net_connect_to_server(cxt, buf->p + req->host, 
                                                htons(req->port));
    
    if (server == NULL) {
        // No server available
        net_bad_gateway(client);
        return -1;
    }
    
    struct net_handle_list* p = mem_alloc(sizeof(struct net_handle_list));
    p->server = server;
    mem_incref(server);
    p->next = NULL;
    p->req = req;
    mem_incref(req);
    
    if (cxt->head == NULL)
        cxt->head = cxt->tail = p;
    else {
        cxt->tail->next = p;
        cxt->tail = p;
    }
    
    event_post(cxt->ev_notice_rsp, (void*)1);
    
    static char msg[] = "HTTP/1.1 200 OK\r\n\r\n";
    int ret = conn_write(client, msg, strlen(msg));
    
    if (ret) {
        net_bad_gateway(client);
        mem_decref(server, conn_done);
        return -1;
    }
    
    while (1) {
        ret = conn_copy(server, client, 64*1024);
        if (ret)
            break;
    }
    
    PLOGI("%s CONNECT %s %d", ep_tostring(client), 
                              buf->p + req->host,
                              client->tx);
    mem_decref(server, conn_done);
    return ret;
}
コード例 #14
0
ファイル: init_teletype.c プロジェクト: monome/libavr32
static void irq_port0_line0(void) {
  for(int i=0;i<8;i++) {
    if(gpio_get_pin_interrupt_flag(i)) {
      // print_dbg("\r\n # A00");
      event_t e = { .type = kEventTrigger, .data = i };
      event_post(&e);
      gpio_clear_pin_interrupt_flag(i);
    }
  }
}
コード例 #15
0
ファイル: hid.c プロジェクト: bensteinberg/mod
// HID device was plugged or unplugged
extern void hid_change(uhc_device_t* dev, u8 plug) {
  event_t e;
  if(plug) { 
    e.type = kEventHidConnect; 
  } else {
    e.type = kEventHidDisconnect;
  }
  // posting an event so the main loop can respond
  event_post(&e); 
}
コード例 #16
0
ファイル: midi.c プロジェクト: bensteinberg/aleph
// MIDI device was plugged or unplugged
extern void midi_change(uhc_device_t* dev, u8 plug) {
  event_t e;
  if(plug) { 
    e.type = kEventMidiConnect; 
  } else {
    e.type = kEventMidiDisconnect;
  }
  // posting an event so the main loop can respond
  event_post(&e); 
  //  midiConnect = plug;
}
コード例 #17
0
ファイル: main.c プロジェクト: Ysum/monome-mods
// handler to detect front panel button long press
static void handler_KeyTimer(s32 data) {
	if(front_timer) {
		if(front_timer == 1) {
			static event_t e;
			// long press happened - here it fires up the event for SaveFlash
			e.type = kEventSaveFlash;
			event_post(&e);
			front_timer--;
		}
		else front_timer--;
	}
}
コード例 #18
0
ファイル: KeyScan.c プロジェクト: joe3501/BTPrinter
extern void KeyScanProc(void)
{
	if(KEY_FEED())		// FEED key up
	{
		if((keyStatus & KEY_FEED_DB_SHIFT) == 0)	// status no changed
		{
			if(keyStatus & KEY_FEED_SHIFT)	// previous mode key up
			{
				event_post(evtKeyUpFeed); // mode key up
				keyStatus &= ~KEY_FEED_SHIFT;
			}
		}
		else
		{
			keyStatus &= ~KEY_FEED_DB_SHIFT;//keyStatus = xxx0
		}
	}
	else
	{
		if(keyStatus & KEY_FEED_DB_SHIFT)	// status no changed
		{
			if((keyStatus & KEY_FEED_SHIFT) == 0)	// previous mode key down
			{
				event_post(evtKeyDownFeed);	// mode key down
				keyStatus |= KEY_FEED_SHIFT;//
			}
		}
		else
		{
			keyStatus |= KEY_FEED_DB_SHIFT;//keyStatus =xxx1
		}
	}

	//for burning test,auto post key event
        if (IsPrinterFree())
        {
			event_post(evtKeyDownFeed);
        }
        
}
コード例 #19
0
ファイル: rt.cpp プロジェクト: misterboyle/rtxi
int RT::System::setPeriod(long long period) {
	::Event::Object event_pre(::Event::RT_PREPERIOD_EVENT);
	event_pre.setParam("period",&period);
	::Event::Manager::getInstance()->postEvent(&event_pre);

	SetPeriodEvent event(period);
	int retval = postEvent(&event);

	::Event::Object event_post(::Event::RT_POSTPERIOD_EVENT);
	event_post.setParam("period",&period);
	::Event::Manager::getInstance()->postEvent(&event_post);

	return retval;
}
コード例 #20
0
ファイル: app_timers.c プロジェクト: bbnickell/aleph
// encoder accumulator polling callback
// the encoder class is defined in avr32_lib.
// each encoder object has an accumulator
static void enc_timer_callback(void* obj) {
  static s16 val, valAbs;
  u8 i;

  for(i=0; i<NUM_ENC; i++) {
    val = enc[i].val;
    valAbs = (val & 0x8000 ? (val ^ 0xffff) + 1 : val);    
    if(valAbs > enc[i].thresh) {
      e.type = enc[i].event;
      e.data = val;
      enc[i].val = 0;
      event_post(&e);
    }
  }
}
コード例 #21
0
ファイル: raw_idle_event.c プロジェクト: chinesebear/raw-os
/*
************************************************************************************************************************
*                                      Post an event (LIFO) to idle task
*
* Description: This function is called to post an event to idle task, it might be called in interrupt.
*
* Arguments  :me is the address of ACTIVE_EVENT_STRUCT
*                    -----
*                    sig is the signal which want to be posted to idle task
*		         -----
*                    para is the parameter which want to be posted to idle task. 
*
* Returns	RAW_SUCCESS: raw os return success		
*                   RAW_IDLE_EVENT_EXHAUSTED: No more msg to me.
*						
* Note(s)    	
*
*             
************************************************************************************************************************
*/
RAW_OS_ERROR idle_event_front_post(ACTIVE_EVENT_STRUCT *me, RAW_U16 sig, void *para)
{

	#if (CONFIG_RAW_ZERO_INTERRUPT > 0)

	if (raw_int_nesting && raw_sched_lock) {
		
		return int_msg_post(RAW_TYPE_IDLE_FRONT_EVENT_POST, me, para, sig, 0, 0);
	}
	
	#endif
	
	return event_post(me, sig, para, SEND_TO_FRONT);

}
コード例 #22
0
ファイル: accelero.c プロジェクト: adjih/openlab
static void handle_event(handler_arg_t ignored)
{
	int16_t a[3] = { 0, 0 ,0 };
	while (lsm303dlhc_acc_get_drdy_int1_pin_value())
		lsm303dlhc_read_acc(a);

	uint32_t accel = a[0]*a[0] + a[1]*a[1] + a[2]*a[2];
	if (accel > 800000)
		return;

	event_post(
		EVENT_QUEUE_APPLI,
		(handler_t)event_handler,
		(handler_arg_t)accel);
}
コード例 #23
0
int main()
{
    // Initialize the platform
    platform_init();

    event_init();
    soft_timer_init();

    // Begin with RX
    event_post(EVENT_QUEUE_APPLI, enter_rx, NULL);

    // Create a periodic packet sending
    soft_timer_set_handler(&tx_timer, send_packet, NULL);
    soft_timer_start(&tx_timer, TX_PERIOD, 1);

    // Run
    platform_run();
    return 0;
}
コード例 #24
0
ファイル: iotlab-radio.c プロジェクト: Liambeguin/openlab
static void sniff_rx(phy_status_t status)
{
    // Switch packets
    phy_packet_t *rx_packet = radio.sniff.pkt_buf + radio.sniff.pkt_index;
    radio.sniff.pkt_index = (radio.sniff.pkt_index + 1) % 2;

    // Enter RX again
    phy_status_t ret = phy_rx(platform_phy, 0,
            soft_timer_time() + soft_timer_ms_to_ticks(500),
            radio.sniff.pkt_buf + radio.sniff.pkt_index, sniff_rx);

    if (ret != PHY_SUCCESS)
    {
        log_error("PHY RX Failed");
    }

    if (status == PHY_SUCCESS)
    {
        // Send packet to serial
        packet_t *serial_pkt = packet_alloc(IOTLAB_SERIAL_PACKET_OFFSET);
        if (serial_pkt == NULL)
        {
            log_error("Failed to get a packet for sniffed RX");
            return;
        }

        uint8_t *data = serial_pkt->data;

        // Place timestamp, channel, RSSI, LQI, captured length, as header
        data = packer_uint32_pack(data,
                packer_uint32_hton(
                        iotlab_control_convert_time(rx_packet->timestamp)));
        *data++ = radio.current_channel;
        *data++ = rx_packet->rssi;
        *data++ = rx_packet->lqi;
        *data++ = rx_packet->length;
        memcpy(data, rx_packet->data, rx_packet->length);
        data += rx_packet->length;
        serial_pkt->length = data - serial_pkt->data;

        event_post(EVENT_QUEUE_APPLI, sniff_send_to_serial, serial_pkt);
    }
}
コード例 #25
0
ファイル: hid.c プロジェクト: Ysum/mod
// parse frame and spawn events
void hid_parse_frame(u8* data, u8 size) {
  u8 i;
  // one event per frame changed.
  // event data is bitfield indicating bytes changed.
  for(i=0; i<size; i++) {
    hid_set_byte_flag( (u32*)&(ev.data), i, data[i] != frame[i] );
  }
  event_post(&ev);

  /* // one event per byte changed. */
  /* for(i=0; i<size; i++) { */
  /*   if(data[i] != frame[i]) { */
  /*     frame[i] = data[i]; */
  /*     ev.type = kEventHidPacket; */
      
  /*     /\* ev.data = frame[i]; *\/ */
  /*     /\* ev.data |= (i << 8); *\/ */
  /*     event_post(&ev); */
  /*   } */
  /* } */
}
コード例 #26
0
ファイル: main.c プロジェクト: apprisi/foundation_lib
static void* producer_thread( object_t thread, void* arg )
{
	uint8_t buffer[256] = {0};
	producer_thread_arg_t* args = arg;
	unsigned int produced = 0;
	tick_t timestamp = 0;

	do
	{
		if( args->sleep_time )
			thread_sleep( (int)args->sleep_time );
		else
			thread_yield();
		timestamp = args->max_delay ? time_current() + random64_range( 0, args->max_delay ) : 0;
		memcpy( buffer, &timestamp, sizeof( tick_t ) );
		event_post( args->stream, random32_range( 1, 65535 ), random32_range( timestamp ? 8 : 0, 256 ), args->id, buffer, timestamp );
		++produced;
	} while( !thread_should_terminate( thread ) && ( time_current() < args->end_time ) );

	return (void*)((uintptr_t)produced);
}
コード例 #27
0
ファイル: eventdem.c プロジェクト: svn2github/freedos-32
int main (int argc, char *argv[])
{
  DWORD sp1, sp2;
  struct ll_initparms parms;
  void *mbi;
  struct timespec time1, time2, time3, time4, time5;
  struct timespec time6, time7, time8, time9;
  int par[10];
  int i, secs;
  DWORD oldt, t;

  sp1 = get_sp();
  cli();

#ifdef PERIODIC
  parms.mode = LL_PERIODIC;
  parms.tick = T;
#else
  parms.mode = LL_ONESHOT;
#endif

  mbi = ll_init();
  event_init(&parms);

  if (mbi == NULL) {
    message("Error in LowLevel initialization code...\n");
    sti();
    l1_exit(-1);
  }
  sti();

  message("LowLevel started...\n");

/*  cli(); */
  NULL_TIMESPEC(&time1);
  NULL_TIMESPEC(&time2);
  NULL_TIMESPEC(&time3);
  NULL_TIMESPEC(&time4);
  NULL_TIMESPEC(&time5);
  NULL_TIMESPEC(&time6);
  NULL_TIMESPEC(&time7);
  NULL_TIMESPEC(&time8);
  NULL_TIMESPEC(&time9);

  ADDNANO2TIMESPEC(1000000, &time1);        /* Time1: 1 ms */
  ADDNANO2TIMESPEC(5000000, &time2);        /* Time2: 5 ms */
  ADDNANO2TIMESPEC(10000000, &time3);        /* Time 3: 10 ms */
  ADDNANO2TIMESPEC(3000000, &time4);        /* Time 4: 3 ms */
  ADDNANO2TIMESPEC(7500000, &time5);        /* Time 5: 7.5 ms */
  ADDNANO2TIMESPEC(7000000, &time6);        /* Time 6: 7 ms */
  ADDNANO2TIMESPEC(500000000, &time7);
  ADDNANO2TIMESPEC(500000000, &time7);
  ADDNANO2TIMESPEC(500000000, &time7);
  ADDNANO2TIMESPEC(500000000, &time7);
  ADDNANO2TIMESPEC(500000000, &time7);
  ADDNANO2TIMESPEC(500000000, &time7);        /* Time 7: 6*500 ms = 3 Sec*/
  ADDNANO2TIMESPEC(51700000, &time8);        /* Time 8: 51.7 ms */
  ADDNANO2TIMESPEC(51500000, &time9);        /* Time 9: 51.5 ms */

cli();
t = ll_gettime(TIME_NEW, NULL);
sti();
  
  for (i = 0; i < 10; i++) {
    par[i] = i + 1;
  }
  canEnd = 0;

  cli();

  event_post(time1, evtHandler, &(par[0]));
  event_post(time2, evtHandler, &(par[1]));
  event_post(time3, evtHandler, &(par[2]));
  event_post(time4, evtHandler, &(par[3]));
  event_post(time5, evtHandler, &(par[4]));
  i = event_post(time6, evtHandler, &(par[5]));
  event_post(time7, evtHandler, &(par[6]));
  event_post(time8, evtHandler, &(par[7]));
  event_post(time9, evtHandler, &(par[8]));

  event_delete(i);
  event_post(time5, evtHandler, &(par[5]));
    
  message("Now time is %lu\n", t);
  
  secs = 0;
  oldt = 0;
  canEnd = 0;
  while((canEnd == 0) && (secs < 6)) {
    cli();
    t = ll_gettime(TIME_NEW, NULL);
    sti();
    if (t < oldt) {
      error("Time goes back???\n");
      message("ARGGGGG! %lu %lu\n", t, oldt);
      ll_abort(100);
    }
    oldt = t;
    if ((t  / 1000000) > secs) {
      secs++;
      message("           %d     %lu\n", secs, t);
    }
  }
  cli();
  message("Can End detected\n");
  ll_end();
  sp2 = get_sp();
  for (i = 1; i < 10; i++) {
    message("Event %d called at time %lu    ==    %lu\n", id[i],
	    t1[i], t2[i]);
  }
  message("End reached!\n");
  message("Actual stack : %lx - ", sp2);
  message("Begin stack : %lx\n", sp1);
  message("Check if same : %s\n",sp1 == sp2 ? "Ok :-)" : "No :-(");

  return 1;
}
コード例 #28
0
ファイル: mp-v1.c プロジェクト: scanner-darkly/mod
static void adcTimer_callback(void* o) {  
	static event_t e;
	e.type = kEventPollADC;
	e.data = 0;
	event_post(&e);
}
コード例 #29
0
ファイル: system.c プロジェクト: DanielTillett/foundation_lib
void system_post_event( foundation_event_id event )
{
	event_post( _system_event_stream, event, 0, 0, 0, 0 );
}
コード例 #30
0
ファイル: system.c プロジェクト: NocturnDragon/foundation_lib
void system_post_event( foundation_event_id event )
{
	event_post( _system_event_stream, SYSTEM_FOUNDATION, event, 0, 0, 0, 0 );
}