reset the card dispense, either soft or hard based on boolean 2nd arg
773895
def reset(self, hard=False):
        ''''''
        if hard:
            self.sendcommand(Vendapin.RESET, 1, 0x01)
            time.sleep(2)
        else:
            self.sendcommand(Vendapin.RESET)
            time.sleep(2)
            # parse the reply
            response = self.receivepacket()
            print('Vendapin.reset(soft): ' + str(response))
1275452
def Reset(self):
        '  '
        spi.SPI_write(self.CS, [0xC0, 0x60])      # reset
#        spi.SPI_write(self.CS, [0x14, 0x14])      # Stall Treshold setup
#        spi.SPI_write(self.CS, [0xFF, 0xFF])  
#        spi.SPI_write(self.CS, [0x13, 0x13])      # Over Current Treshold setup 
#        spi.SPI_write(self.CS, [0xFF, 0xFF])  
        spi.SPI_write(self.CS, [0x15, 0xFF])      # Full Step speed 
        spi.SPI_write(self.CS, [0xFF, 0xFF])
        spi.SPI_write(self.CS, [0xFF, 0xFF]) 
        spi.SPI_write(self.CS, [0x05, 0x05])      # ACC 
        spi.SPI_write(self.CS, [0x01, 0x01])
        spi.SPI_write(self.CS, [0xF5, 0xF5]) 
        spi.SPI_write(self.CS, [0x06, 0x06])      # DEC 
        spi.SPI_write(self.CS, [0x01, 0x01])
        spi.SPI_write(self.CS, [0xF5, 0xF5]) 
        spi.SPI_write(self.CS, [0x0A, 0x0A])      # KVAL_RUN
        spi.SPI_write(self.CS, [0x10, 0x10])
        spi.SPI_write(self.CS, [0x0B, 0x0B])      # KVAL_ACC
        spi.SPI_write(self.CS, [0x20, 0x20])
        spi.SPI_write(self.CS, [0x0C, 0x0C])      # KVAL_DEC
        spi.SPI_write(self.CS, [0x20, 0x20])
        spi.SPI_write(self.CS, [0x18, 0x18])      # CONFIG
        spi.SPI_write(self.CS, [0b00111000, 0b00111000])
        spi.SPI_write(self.CS, [0b00000000, 0b00000000])
1191984
def hard_reset(self):
        """"""
        if self.shuffle:
            self._shuffle_data()
        self.cursor = -self.batch_size
        self._cache_data = None
        self._cache_label = None
1161680
def reset_options(self, empty=True):
        
        if empty:
            self.gc = pd.DataFrame(columns=self.clmn)
        else:
            self.gc["value"] = self.gc["default"]
41434
def _reset(self):
    
    self.basis = np.random.randn(self.filterDim, self.outputDim)
    self.basis /= np.sqrt(np.sum(self.basis ** 2, axis=0))
    self._iteration = 0
    self.losses = {}
951571
def reset
      self.apikey = DEFAULT_APIKEY
      self.endpoint = DEFAULT_ENDPOINT
      self.sandbox_endpoint = DEFAULT_SANDBOX_ENDPOINT
      self.sandbox_enabled = DEFAULT_SANDBOX_ENABLED
      self.fmt = DEFAULT_FMT
    end
1260621
def reset(self, force_flush_cache: bool = False) -> None:
        
        super(LDAPwrapper, self).reset()
        if len(self._transactions) == 0:
            raise RuntimeError("reset called outside a transaction.")
        self._transactions[-1] = []
1188627
public function reset()
    {
        $this->cards = array_merge($this->cards, $this->cardsDrawn);
        $this->cardsDrawn = [];
    }
204583
def Reset(self):
        '  '
        spi.SPI_write_byte(self.CS, 0xC0)      # reset
#        spi.SPI_write_byte(self.CS, 0x14)      # Stall Treshold setup
#        spi.SPI_write_byte(self.CS, 0xFF)  
#        spi.SPI_write_byte(self.CS, 0x13)      # Over Current Treshold setup 
#        spi.SPI_write_byte(self.CS, 0xFF)  
        spi.SPI_write_byte(self.CS, 0x15)      # Full Step speed 
        spi.SPI_write_byte(self.CS, 0xFF)
        spi.SPI_write_byte(self.CS, 0xFF) 
        spi.SPI_write_byte(self.CS, 0x05)      # ACC 
        spi.SPI_write_byte(self.CS, 0x00)
        spi.SPI_write_byte(self.CS, 0x20) 
        spi.SPI_write_byte(self.CS, 0x06)      # DEC 
        spi.SPI_write_byte(self.CS, 0x00)
        spi.SPI_write_byte(self.CS, 0x20) 
        spi.SPI_write_byte(self.CS, 0x0A)      # KVAL_RUN
        spi.SPI_write_byte(self.CS, 0xd0)
        spi.SPI_write_byte(self.CS, 0x0B)      # KVAL_ACC
        spi.SPI_write_byte(self.CS, 0xd0)
        spi.SPI_write_byte(self.CS, 0x0C)      # KVAL_DEC
        spi.SPI_write_byte(self.CS, 0xd0)
        spi.SPI_write_byte(self.CS, 0x16)      # STEPPER
        spi.SPI_write_byte(self.CS, 0b00000000)
        spi.SPI_write_byte(self.CS, 0x18)      # CONFIG
        spi.SPI_write_byte(self.CS, 0b00111000)
        spi.SPI_write_byte(self.CS, 0b00000000)
844375
def resetn(self):
        
        #Regular reset will kick NRF out of DBG mode
        logging.debug("target_nrf51.reset: enable reset pin")
        self.write_memory(RESET, RESET_ENABLE)
        #reset
        logging.debug("target_nrf51.reset: trigger nRST pin")
        self.reset()
748961
def reset
      self.adapter          = DEFAULT_ADAPTER
      self.endpoint         = DEFAULT_ENDPOINT
      self.limit            = DEFAULT_LIMIT
      self.user_agent       = DEFAULT_USER_AGENT
      self.request_options  = nil
      self
    end
129954
def software_reset(i2c=None, **kwargs):
    """"""
    # Setup I2C interface for device 0x00 to talk to all of them.
    if i2c is None:
        import Adafruit_GPIO.I2C as I2C
        i2c = I2C
    self._device = i2c.get_i2c_device(0x00, **kwargs)
    self._device.writeRaw8(0x06)
820420
def reset(self):
        
        self.command_stack = []

        self.scripts = set()
        self.watches = []
        # clean up the other instance attributes
        self.watching = False
        self.explicit_transaction = False
233714
def reset(self):
        
        self.operations = []
        self._last_overflow = 'WRAP'
        self.overflow(self._default_overflow or self._last_overflow)
67917
def Reset(self):
        

        try:
            self._tc.SetValue(self.startValue)
        except TypeError:
            # Start value was None
            pass
        self._tc.SetInsertionPointEnd()
        # Update the Entry Line
        post_command_event(self.main_window, self.TableChangedMsg,
                           updated_cell=self.startValue)
1336559
void resetSequential() {
        seq = nextLong(prand, maxSeq);
        inc = minInc + nextLong(prand, maxInc - minInc);
    }
545555
def reset(self, lineno=None, offset=None, type_=None):
        
        self.lineno = self.lineno if lineno is None else lineno
        self.type_ = self.type_ if type_ is None else type_
        self.offset = self.offset if offset is None else offset

        self.callable = True
        self.params = SymbolPARAMLIST()
        self.body = SymbolBLOCK()
        self.__kind = KIND.unknown
        self.local_symbol_table = None