Start the digital output task that serves as the acquistion trigger
515810
def start_timer(self, reprate):
        """"""
        print 'starting digital output at rate {} Hz'.format(reprate)
        self.trigger_task = DigitalOutTask(self.trigger_src, reprate)
        self.trigger_task.start()
639049
def start(self) -> None:
        

        self._shutdown = False

        # Start listening (if server) / Open connection (if client)
        if isinstance(self._protocol, Server):
            self.create_task(self._async_listen)
        elif isinstance(self._protocol, Client):
            self.create_task(self._async_open)
        else:
            raise NotImplementedError
991506
def _trigger_rpc(self, device_info):
        """"""

        method = device_info.rpc_trigger
        if isinstance(method, devices.RPCTriggerViaSWI):
            self._jlink.memory_write32(method.register, [1 << method.bit])
        else:
            raise HardwareError("Unknown RPC trigger method", method=method)
1332635
void triggerCheckpoint(boolean uncompressed) throws IOException {
    String pref = "Standby: Checkpoint - ";
    LOG.info(pref + "triggering checkpoint manually");

    // check error conditions
    if (uncompressed) {
      throwIOException(pref + " uncompressed option not supported", null);
    }
    if (manualCheckpointLatch.getCount() > 0) {
      throwIOException(pref + "Another manual checkpoint is in progress", null);
    }
    
    // set the manual checkpoint latch
    manualCheckpointLatch = new CountDownLatch(2);
    lastCheckpointTime = delayedScheduledCheckpointTime = 0;
    try {
      manualCheckpointLatch.await();
    } catch (InterruptedException e) {
      throwIOException(pref + "interrupted when performing manual checkpoint",
          e);
    }
    
    // check if checkpoint succeeded
    if (checkpointFailures > 0) {
      throwIOException(pref + "manual checkpoint failed", null);
    }
    LOG.info(pref + "manual checkpoint done");
  }
599901
def trigger(proxy_action_name, input)
      response = begin
                   proxy.trigger_task(proxy_action_name, input).merge('result' => 'success')
                 rescue RestClient::Exception => e
                   logger.warn "Could not trigger task on the smart proxy: #{e.message}"
                   {}
                 end
      update_from_batch_trigger(response)
      save!
    end
523450
def switch_to_output(self, value=False, **kwargs):
        
        self.direction = digitalio.Direction.OUTPUT
        self.value = value
910884
def start_output (self):
        """"""
        super(GMLLogger, self).start_output()
        if self.has_part("intro"):
            self.write_intro()
            self.writeln()
        self.writeln(u"graph [")
        self.writeln(u"  directed 1")
        self.flush()
1308029
def _pulse_enable(self):
        """"""
        GPIO.output(self.pins.e, 0)
        c.usleep(1)
        GPIO.output(self.pins.e, 1)
        c.usleep(1)
        GPIO.output(self.pins.e, 0)
        c.usleep(100)
277017
function() {
            if (_.size(this.tasks) > 0) {
                this.empty = false;
                var task = this.tasks.shift();
                this.startTask(task);
                this.trigger("tasks:next");
            } else {
                this.empty = true;
                this.trigger("tasks:finish");
            }      
        }
1276641
def start(self):
        
        self._events_to_write = []
        self._new_contracts_to_write = []

        @events.on(SmartContractEvent.CONTRACT_CREATED)
        @events.on(SmartContractEvent.CONTRACT_MIGRATED)
        def call_on_success_event(sc_event: SmartContractEvent):
            self.on_smart_contract_created(sc_event)

        @events.on(SmartContractEvent.RUNTIME_NOTIFY)
        def call_on_event(sc_event: NotifyEvent):
            self.on_smart_contract_event(sc_event)

        Blockchain.Default().PersistCompleted.on_change += self.on_persist_completed
240167
def start_event(self):
        
        # create object pool for each output
        if self.with_outframe_pool:
            self.update_config()
            for name in self.outputs:
                self.outframe_pool[name] = ObjectPool(
                    Frame, self.new_frame, self.config['outframe_pool_len'])
        try:
            self.on_start()
        except Exception as ex:
            self.logger.exception(ex)
            raise StopIteration()
1329889
def start_log_task(task, logger=logging, level='info'):
    
    getattr(logger, level)(START_TASK_TRIGGER_MSG % task)
966870
def trigger(self, event: str, **kwargs: Any) -> None:
        """"""
        event = event.upper()
        for func in self._event_handlers[event]:
            self.loop.create_task(func(**kwargs))
        # This will unblock anyone that is awaiting on the next loop update,
        # while still ensuring the next `await client.wait(event)` doesn't
        # immediately fire.
        async_event = self._events[event]
        async_event.set()
        async_event.clear()
837640
function start_output() {
        $this->started_output = true;
        if ($this->exportclass!==null) {
            $this->exportclass->start_table($this->sheettitle);
            $this->exportclass->output_headers($this->headers);
        } else {
            $this->start_html();
            $this->print_headers();
            echo html_writer::start_tag('tbody');
        }
    }
573729
@Override
    public void run() {
        Date actualExecutionTime = new Date();
        super.run();
        Date completionTime = new Date();
        synchronized (this.triggerContextMonitor) {
            this.triggerContext.update(this.scheduledExecutionTime, actualExecutionTime, completionTime);
            if (!this.currentFuture.isCancelled()) {
                schedule();
            }
        }
    }
162497
def switch_to_input(self, pull=None, **kwargs):
        
        self.direction = digitalio.Direction.INPUT
        self.pull = pull
14806
def on_taskend(self, task):
        
        key = 'timer' if task.elapsed else 'end'
        filename = self.files.get(key)

        if filename:
            self._play_sound(filename)