Aus Oxoscript wird NanoPy - mehr Infos

IO-Funktionen

initGPIO

  initGPIO(pinNr:byte, mode:byte)

Initialisiert das gewählte GPIO (analog pinMode) mit einem der folgenen Modi:

OUTPUT
INPUT
INPUT_PULLUP
INPUT_PULLDOWN

Verfügbare pinNr-Konstanten:

C_PIN_01 (20*)
C_PIN_02 (25*)
C_PIN_03 (26*)
C_PIN_04 (32)
C_PIN_05 (33)
C_PIN_06 (34*)
C_PIN_07 (35*)
C_PIN_MISO (8)
C_PIN_MOSI (5)
C_PIN_SCK (7)
C_PIN_SDA (21*)
C_PIN_SCL (22*)

writeGPIO

  writeGPIO(pinNr:byte, state:bool)

Setzt den Zustand eines zuvor als OUTPUT initialisierten GPIOs (analog digitalWrite).

initGPIO(32, OUTPUT)
writeGPIO(32, 1) # HIGH
writeGPIO(32, 0) # LOW

readGPIO

  readGPIO(pinNr:byte)->bool

Liest den Zustand eines zuvor als INPUT(_PULLUP/DOWN) initialisierten GPIOs (analog digitalRead).

initGPIO(32, INPUT_PULLDOWN)
readGPIO(32) # false (0)
readGPIO(32) # true (1) wenn mit 3.3V verbunden

readADC

  readADC(pinNr:byte, nSamples:long)->int

Liest den analogen Wert (analog analogRead) von entweder pinNr 32 oder 33 mehrere Male (nSamples) und bildet einen Durchschnittswert.
Die eingestellte Referenzspannung beträgt ~3300mV (11dB Dämpfung).
Der zurückgegebene Wert bewegt sich zwischen 0 und 4095 (12bit).

readADC(32, 100)
readADC(33, 1000)

writeDAC

  writeDAC(pinNr:byte, value:byte)

Nur Oxocard-Connect

Gibt auf dem ausgewählten GPIO (C_PIN_02 oder C_PIN_03) ein analoges Spannungssignal zwischen 0 (0) und 3.3V (255) aus.

writeDAC(C_PIN_02, 127)

writePWM

  writePWM(pinNr:byte, dutyCycleValue:long)

Gibt auf dem ausgewählten GPIO ein PWM-Signal mit 500Hz und definiertem dutyCycle-Wert von 0 (0%) bis 4096 (100% bei 12bit) aus.

writePWM(C_PIN_01, 2048) # 50%

setPWMFrequency

  setPWMFrequency(freq:long)

Setzt die verwendete PWM-Frequenz: 10… 9765 Hz (13bit) oder 19… 19531 Hz (12bit) oder 38… 39062 Hz (11bit) usw. (Default: 500Hz)

setPWMFrequency(1000)

setPWMDutyCycleResolution

  setPWMDutyCycleResolution(res:byte)

Setzt die verwendete PWM-Auflösung: 0… 20bit (Default: 12bit)

setPWMDutyCycleResolution(12)

checkI2CAddress

  checkI2CAddress(slaveAddr:byte)->bool

Gibt true zurück, wenn ein Gerät mit definierter slaveAddr gefunden wurde und sonst false.

writeI2CByte

  writeI2CByte(slaveAddr:byte, byteAddr:int, data:byte)

Schreibt ein Byte eines definierten I2C-Slaves (7bit slaveAddr) und Registers (byteAddr).

writeI2CByte(0x4C, 0x08, 0x13) # accel sample rate = 100Hz

writeI2CInt

  writeI2CInt(slaveAddr:byte, byteAddr:int, data:int)

Schreibt ein Integer (2 Bytes) eines definierten I2C-Slaves (7bit slaveAddr) und Registers (byteAddr).

writeI2CInt(0x2C, 0x05, 0x1337)

writeI2CLong

  writeI2CLong(slaveAddr:byte, byteAddr:int, data:long)

Schreibt ein Long (4 Bytes) eines definierten I2C-Slaves (7bit slaveAddr) und Registers (byteAddr).

writeI2CLong(0x2C, 0x05, 0x42133742)

writeI2C

  writeI2C(slaveAddr:byte, byteAddr:int, size:int, data:byte[])

Schreibt eine beliebige Anzahl Bytes (size) eines definierten I2C-Slaves (7bit slaveAddr) und Registers (byteAddr).

data = [0x11, 0x22, 0x33]
writeI2C(0x2C, 0x05, 3, data)

readI2CByte

  readI2CByte(slaveAddr:byte, byteAddr:int)->byte

Liest ein Byte eines definierten I2C-Slaves (7bit slaveAddr) und Registers (byteAddr).

Wenn byteAddr -1 ist, wird nach der Übertragung der slaveAddr direkt gelesen.

readI2CByte(0x4C, 0x18) # accel ID => 164

readI2CInt

  readI2CInt(slaveAddr:byte, byteAddr:int)->int

Liest ein Integer (2 Bytes) eines definierten I2C-Slaves (7bit slaveAddr) und Registers (byteAddr).

Wenn byteAddr -1 ist, wird nach der Übertragung der slaveAddr direkt gelesen.

readI2CInt(0x4C, 0x0D) # accel raw X axis (16bit)

readI2CLong

  readI2CLong(slaveAddr:byte, byteAddr:int)->long

Liest ein Long (4 Bytes) eines definierten I2C-Slaves (7bit slaveAddr) und Registers (byteAddr).

Wenn byteAddr -1 ist, wird nach der Übertragung der slaveAddr direkt gelesen.

ir = readI2CLong(0x52, 0x0A) # IR value (3 bytes + 1 unused)
ir = ir & 0x00FFFFFF # Maskierung der ersten 3 bytes

readI2C

  readI2C(slaveAddr:byte, byteAddr:int, size:int)

Liest eine beliebige Anzahl Bytes (size) eines definierten I2C-Slaves (7bit slaveAddr) und Registers (byteAddr).

Wenn byteAddr -1 ist, wird nach der Übertragung der slaveAddr direkt gelesen.

Mit den getI2C-Funktionen können anschliessend die gelesenen Daten zurückgegeben werden.

readI2C(0x4C, 0x0D, 6) # accel raw X, Y & Z axis
xRaw = getI2CInt()
yRaw = getI2CInt()
zRaw = getI2CInt()

getI2CByte

  getI2CByte()->byte

Gibt ein zuvor mit readI2C() gelesenes Byte zurück.

Der interne readBufferIndex wird um 1 erhöht.

getI2CInt

  getI2CInt()->int

Gibt ein zuvor mit readI2C() gelesener Integer zurück.

Der interne readBufferIndex wird um 2 erhöht.

getI2CLong

  getI2CLong()->long

Gibt ein zuvor mit readI2C() gelesener Long zurück.

Der interne readBufferIndex wird um 4 erhöht.

setI2CReadBufferIndex

  setI2CReadBufferIndex(index:int)

Setzt den internen readBufferIndex auf den gewünschten Wert.
Dies erlaubt es ein zuvor gelesener Wert noch einmal zu lesen.

readI2C(0x4C, 0x0D, 6) # accel raw X, Y & Z axis
xRaw = getI2CInt()
setI2CReadBufferIndex(0)
xRaw = getI2CInt()
yRaw = getI2CInt()
zRaw = getI2CInt()

setI2CByteAddrSize

  setI2CByteAddrSize(size:byte)

Setzt die bei I2C-Funktionen verwendete Datentyp-Grösse der byteAddr. Diese ist meist 1 (0… 255), kann bei bestimmten Geräten aber auch 2 (0… 65535) sein.

getI2CByteAddrSize

  getI2CByteAddrSize()->byte

Gibt die im Moment verwendete Datentyp-Grösse der byteAddr zurück.

setI2CBigEndian

  setI2CBigEndian()

Verwende diese Funktion, um die int oder long I2C-Funktionen auf Big Endian zu setzen.

Ein 16-Bit-Wert 0xAABB wird dem Array [0xAA, 0xBB] entsprechen und umgekehrt

setI2CLittleEndian

  setI2CLittleEndian()

Verwende diese Funktion, um die int oder long I2C-Funktionen auf Little Endian zu setzen.

Ein 16-Bit-Wert 0xAABB wird dem Array [0xBB, 0xAA] entsprechen und umgekehrt

initDigitalLeds

  initDigitalLeds(pinNr:byte, ledsCount:byte, ledType:byte)

Initialisiert das ausgewählte pin so, dass eine definierte Anzahl digitale LEDs (z.B. NeoPixels) vom gewünschten Typ gesetzt werden können.

LED types:

C_LED_TYPE_WS2812
C_LED_TYPE_WS2812B
C_LED_TYPE_WS2812B_MINI
C_LED_TYPE_WS2813
C_LED_TYPE_WS2814
C_LED_TYPE_SK6812

initDigitalLeds(C_PIN_01, 12, C_LED_TYPE_WS2812B)

setDigitalLedMode

  setDigitalLedMode(mode:byte)

Mit diesem Parameter kann die Reihenfolge der Farben geändert werden kann. setDigitalLedMode(C_LED_MODE_RGB) setzt den normalen RGB-Modus, setDigitalLedMode(C_LED_MODE_GRB) wird verwendet, wenn die RGB-LEDs rot und grün vertauscht haben.

setDigitalLed

  setDigitalLed(ledNr:byte, r:byte, g:byte, b:byte)

Setzt den Farbwert (RGB) des ausgewählten digitalen LEDs.

setDigitalLed(0, 50, 255, 10)

applyDigitalLeds

  applyDigitalLeds()

Gibt die zuvor mit setDigitalLed() definierten Farbwerte auf dem mit initDigitalLeds() ausgewähltem Pin aus.

applyDigitalLeds()

initUART

  initUART(byte pinNrTx, byte pinNrRx, long baudrate)

Initialisiert die UART-Schnittstelle.

Beispiel:

# UART echo example
initUART(C_PIN_04, C_PIN_05, 115200) # TX, RX, BAUDRATE
#configUART(C_UART_DATA_BITS_8, C_UART_PARITY_DISABLE, C_UART_STOP_BITS_1)
def onDraw():
    len = getUARTDataLength()
    if len > 0:
        data = readLineUART()
        #data = readUART(len)
        writeLineUART(data) # send the same data back
        #writeUART(len, data)
        clear()
        drawText(10, 10, data)
        update()
        print(data)
    delay(10)
	if getButton():
		if returnToMenu():
			return

configUART

  configUART(byte dataBits, byte parity, byte stopBits)

Optionale UART-Konfigurationen.

Verfügbare dataBits:

C_UART_DATA_BITS_5
C_UART_DATA_BITS_6
C_UART_DATA_BITS_7
C_UART_DATA_BITS_8 // default

Verfügbare parity-Optionen:

C_UART_PARITY_DISABLE // default
C_UART_PARITY_EVEN
C_UART_PARITY_ODD

Verfügbare stopBits:

C_UART_STOP_BITS_1 // default
C_UART_STOP_BITS_1_5
C_UART_STOP_BITS_2

getUARTDataLength

  getUARTDataLength()->int

Gibt die empfangene Datenlänge zurück.

readUART

  readUART(int size)->byte[256]

Liest eine definierte Länge in Bytes und gibt diese als Byte-Array zurück.

Beachte:
Es können maximal 256 Bytes pro Aufruf zurückgegeben werden.

readLineUART

  readLineUART()->byte[256]

Liest eine ganze Zeile (bis zum ‘\n’) und gibt diese als byte-Array zurück.

Beachte:
Es können maximal 256 Bytes pro Aufruf zurückgegeben werden.

writeUART

  writeUART(int size, byte[] data)

Schreibt eine beliebige Anzahl Bytes (size).

data = [0x11, 0x22, 0x33]
writeUART(3, data)

writeLineUART

  writeLineUART(byte[] data)

Schreibt einen String und hängt am Ende ein ‘\n’ an.

initSPI

  initSPI(byte mode, long speed)

Initialisiert die SPI-Schnittstelle.

Verfügbare Modes:

C_SPI_MODE_0 // CPOL=0; CPHA=0
C_SPI_MODE_1 // CPOL=0; CPHA=1
C_SPI_MODE_2 // CPOL=1; CPHA=0
C_SPI_MODE_3 // CPOL=1; CPHA=1

Beispiel:

initSPI(C_SPI_MODE_3, 1000000)

initGPIO(C_PIN_01, OUTPUT)
writeGPIO(C_PIN_01, 1) # resetCS

def onDraw():
    len = 2
    txData = [0x00, 0x00]
    writeGPIO(C_PIN_01, 0) # setCS
    writeSPI(len, txData)
    readSPI(1)
    writeGPIO(C_PIN_01, 1) # resetCS

    rxData = getSPIByte()
    print(rxData)
    delay(1000)
	if getButton():
		if returnToMenu():
			return

writeSPI

  writeSPI(int size, byte[] data)

Schreibt eine beliebige Anzahl Bytes (size).

data = [0x11, 0x22, 0x33]
writeSPI(3, data)

readSPI

  readSPI(int size)

Liest eine beliebige Anzahl Bytes (size) und speichert sie im internen SPI-ReadBuffer.

Mit den getSPI-Funktionen können anschliessend die gelesenen Daten zurückgegeben werden.

readSPI(7)
myByte = getSPIByte()
myInt = getSPIInt()
myLong = getSPILong()

transferSPI

  transferSPI(int size, byte[] txData)

Überträgt und liest eine beliebige Anzahl Bytes (size) und speichert sie im internen SPI-ReadBuffer.

Mit den getSPI-Funktionen können anschliessend die gelesenen Daten zurückgegeben werden.

txData = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
transferSPI(7, txData)
myByte = getSPIByte()
myInt = getSPIInt()
myLong = getSPILong()

getSPIByte

  getSPIByte()->byte

Gibt ein zuvor mit readSPI() gelesenes Byte zurück.

Der interne readBufferIndex wird um 1 erhöht.

getSPIInt

  getSPIInt()->int

Gibt ein zuvor mit readSPI() gelesener Integer zurück.

Der interne readBufferIndex wird um 2 erhöht.

getSPILong

  getSPILong()->long

Gibt ein zuvor mit readSPI() gelesener Long zurück.

Der interne readBufferIndex wird um 4 erhöht.

setSPIReadBufferIndex

  setSPIReadBufferIndex(int index)

Setzt den internen readBufferIndex auf den gewünschten Wert.

Dies erlaubt es ein zuvor gelesener Wert noch einmal zu lesen.

initPulseCounter

  initPulseCounter(pinNr:byte)

Mit dem Pulse Counter können Impulse am angegebenen Pin gezählt werden. Mit der Funktion initPulseCounter kann der Zähler für ein Pin initialisiert und gestartet werden.

initPulseCounter(C_PIN_06)

Mit der Funktion readPulseCounter kann der Wert ausgelesen werden.

const ENCODER_PIN = C_PIN_06     # Pin to use with the counter

initPulseCounter(ENCODER_PIN)

while true:
    value = readPulseCounter(ENCODER_PIN)

    clear()
    drawText(10, 10, "Value " + value)
    update()


Der Zähler kann bis 32767 hoch zählen und beginnt danach wieder bei 0.

Muss der Zähler manuell zurück gesetzt werden kann die Funktion resetPulseCounter verwendet werden.

Verwandte Funktionen:

readPulseCounter

  readPulseCounter(pinNr:byte)

Mit der Funktion readPulseCounter kann der aktuelle Wert des Pluse Counters ausgelesen werden.

value = readPulseCounter(C_PIN_06)

Verwandte Funktionen:

resetPulseCounter

  resetPulseCounter(pinNr:byte)

Mit der Funktion resetPulseCounter kann der Pulse Counter auf 0 zurückgesetzt werden.

resetPulseCounter(C_PIN_06)

Verwandte Funktionen: