initGPIO(pinNr:byte, mode:byte)
Initialise le GPIO sélectionné (analog pinMode) avec l’un des modes suivants:
OUTPUT
INPUT
INPUT_PULLUP
INPUT_PULLDOWN
Constantes pinNr disponibles:
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(pinNr:byte, state:bool)
Définit l’état d’un GPIO préalablement initialisé en tant que OUTPUT.
initGPIO(32, OUTPUT)
writeGPIO(32, 1) # HIGH
writeGPIO(32, 0) # LOW
readGPIO(pinNr:byte)->bool
Lit l’état d’un GPIO préalablement initialisé comme INPUT(_PULLUP/DOWN).
initGPIO(32, INPUT_PULLDOWN)
readGPIO(32) # false (0)
readGPIO(32) # true (1) si connecté à 3.3V
readADC(pinNr:byte, nSamples:long)->int
Lit la valeur analogique de pinNr 32 ou 33 plusieurs fois (nSamples) et fait une moyenne.
La tension de référence réglée est de ~2600mV (11dB d’atténuation).
La valeur renvoyée se situe entre 0 et 4095 (12 bits).
readADC(32, 100)
readADC(33, 1000)
writeDAC(pinNr:byte, value:byte)
Uniquement Oxocard-Connect
Émet un signal de tension analogique entre 0 (0) et 3,3V (255) sur le GPIO sélectionné (C_PIN_02 ou C_PIN_03).
writeDAC(C_PIN_02, 127)
writePWM(pinNr:byte, dutyCycleValue:long)
Délivre sur le GPIO sélectionné un signal PWM de 500Hz avec une valeur dutyCycle définie de 0 (0%) à 4096 (100% à 12bit).
writePWM(C_PIN_01, 2048) # 50%
setPWMFrequency(freq:long)
Définit la fréquence PWM utilisée: 10… 9765 Hz (13bit) ou 19… 19531 Hz (12bit) ou 38… 39062 Hz (11bit) etc. (par défaut: 500Hz)
setPWMFrequency(1000)
setPWMDutyCycleResolution(res:byte)
Définit la résolution PWM utilisée: 0… 20bit (par défaut: 12bit)
setPWMDutyCycleResolution(12)
checkI2CAddress(slaveAddr:byte)->bool
Renvoie true si un appareil avec un slaveAddr défini a été trouvé et false sinon.
writeI2CByte(slaveAddr:byte, byteAddr:int, data:byte)
Ecrit un Byte d’un esclave I2C défini (7bit slaveAddr) et du registre (byteAddr).
writeI2CByte(0x4C, 0x08, 0x13) # accel sample rate = 100Hz
writeI2CInt(slaveAddr:byte, byteAddr:int, data:int)
Ecrit un entier (2 bytes) d’un esclave I2C défini (7bit slaveAddr) et d’un registre (byteAddr).
writeI2CInt(0x2C, 0x05, 0x1337)
writeI2CLong(slaveAddr:byte, byteAddr:int, data:long)
Ecrit un long (4 bytes) d’un esclave I2C défini (7bit slaveAddr) et d’un registre (byteAddr).
writeI2CLong(0x2C, 0x05, 0x42133742)
writeI2C(slaveAddr:byte, byteAddr:int, size:int, data:byte[])
Ecrit un nombre quelconque des bytes (size) d’un esclave I2C défini (7bit slaveAddr) et d’un registre (byteAddr).
data = [0x11, 0x22, 0x33]
writeI2C(0x2C, 0x05,3, data)
readI2CByte(slaveAddr:byte, byteAddr:int)->byte
Lit un byte d’un esclave I2C défini (7bit slaveAddr) et du registre (byteAddr).
Si byteAddr est -1, le data est lu directement après la transmission de slaveAddr.
readI2CByte(0x4C, 0x18) # accel ID => 164
readI2CInt(slaveAddr:byte, byteAddr:int)->int
Lit un entier (2 bytes) d’un esclave I2C défini (7bit slaveAddr) et d’un registre (byteAddr).
Si byteAddr est -1, le data est lu directement après la transmission de slaveAddr.
readI2CInt(0x4C, 0x0D) # accel raw X axis (16bit)
readI2CLong(slaveAddr:byte, byteAddr:int)->long
Lit un long (4 bytes) d’un esclave I2C défini (7bit slaveAddr) et d’un registre (byteAddr).
Si byteAddr est -1, le data est lu directement après la transmission de slaveAddr.
ir = readI2CLong(0x52, 0x0A) # valeur IR (3 bytes + 1 inutilisé)
ir = ir & 0x00FFFFFF # Masquage des 3 premiers octets
readI2C(slaveAddr:byte, byteAddr:int, size:int)
Lit un nombre quelconque des bytes (size) d’un esclave I2C défini (7bit slaveAddr) et d’un registre (byteAddr).
Si byteAddr est -1, le data est lu directement après la transmission de slaveAddr.
Les fonctions getI2C permettent ensuite de renvoyer les données lues.
readI2C(0x4C, 0x0D, 6) # accel raw X, Y & Z axis
xRaw = getI2CInt()
yRaw = getI2CInt()
zRaw = getI2CInt()
getI2CByte()->byte
Renvoie un byte lu précédemment avec readI2C().
L’index interne readBufferIndex est augmenté de 1.
getI2CInt()->int
Renvoie un integer lu précédemment avec readI2C().
L’index interne readBufferIndex est augmenté de 2.
getI2CLong()->long
Renvoie un long précédemment lu avec readI2C().
L’index interne readBufferIndex est augmenté de 4.
setI2CReadBufferIndex(index:int)
Définit le readBufferIndex interne sur la valeur souhaitée.
Cela permet de relire une valeur lue précédemment.
readI2C(0x4C, 0x0D, 6) # accel raw X, Y & Z axis
xRaw = getI2CInt()
setI2CReadBufferIndex(0)
xRaw = getI2CInt()
yRaw = getI2CInt()
zRaw = getI2CInt()
setI2CByteAddrSize(size:byte)
Définit la taille du type de données du byteAddr utilisé pour les fonctions I2C. Elle est généralement de 1 (0… 255), mais peut aussi être de 2 (0… 65535) pour certains appareils.
getI2CByteAddrSize()->byte
Renvoie la taille du type de données actuellement utilisé pour le byteAddr.
setI2CBigEndian()
Cette fonction permet de régler les fonctions I2C int ou long sur big endian.
Une valeur de 16 bits 0xAABB sera égale au tableau [0xAA, 0xBB] et vice versa.
setI2CLittleEndian()
Cette fonction permet de régler les fonctions I2C int ou long sur little endian.
Une valeur de 16 bits 0xAABB sera égale au tableau [0xBB, 0xAA] et vice versa.
initDigitalLeds(pinNr:byte, ledsCount:byte, ledType:byte)
Initialise le pin sélectionné de manière à ce qu’un nombre défini de LED numériques du type souhaité (par exemple NeoPixels) puisse être placé.
Types de DEL:
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
C_LED_TYPE_SK6812W (RGBW LED)
initDigitalLeds(C_PIN_01, 12, C_LED_TYPE_WS2812B)
setDigitalLedMode(mode:byte)
Ce paramètre permet de modifier l’ordre des couleurs. setDigitalLedMode(C_LED_MODE_RGB) définit le mode RGB normal, setDigitalLedMode(C_LED_MODE_GRB) est utilisé lorsque les LED RGB ont inversé le rouge et le vert.
setDigitalLed(ledNr:byte, r:byte, g:byte, b:byte)
Définit la valeur de couleur (RVB) de la LED numérique sélectionnée.
setDigitalLed(0, 50, 255, 10)
Règle la valeur de la couleur (RGBW) de la LED numérique sélectionnée.
setDigitalLed2(0, 0, 0, 0, 255)
applyDigitalLeds()
Donne les valeurs de couleur définies précédemment avec setDigitalLed() sur la broche sélectionnée avec initDigitalLeds().
applyDigitalLeds()
deinitDigitalLeds()
Utilisé pour supprimer l’interface LED numérique si elle n’est plus utilisée
initDigitalLeds(C_PIN_01, 25, C_LED_TYPE_SK6812) # Init LEDs
# Set LEDs
# ...
deinitDigitalLeds() # Supprime les LEDs numériques
initUART(pinNrTx:byte, pinNrRx:byte, baudrate:long)
Initialise l’interface UART.
Exemple de fonctionnement:
# UART echo exemple
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) # renvoie les mêmes données
#writeUART(len, data)
clear()
drawText(10, 10, data)
update()
print(data)
delay(10)
if getButton():
if returnToMenu():
return
Initialise l’interface UART en mode half duplex.
Exemple: ``pythonp’’:
# Exemple d'écho UART
initUARTHalfDuplex(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()
si len > 0:
data = readLineUART()
#data = readUART(len)
writeLineUART(data) # renvoie les mêmes données
#writeUART(len, data)
clear()
drawText(10, 10, data)
update()
print(data)
delay(10)
if getButton():
if returnToMenu():
return
configUART(byte dataBits, byte parity, byte stopBits)
Configurations UART en option.
Bits de données disponibles:
C_UART_DATA_BITS_5
C_UART_DATA_BITS_6
C_UART_DATA_BITS_7
C_UART_DATA_BITS_8 // par défaut
Options de parité disponibles:
C_UART_PARITY_DISABLE // par défaut
C_UART_PARITY_EVEN
C_UART_PARITY_ODD
stopBits disponibles:
C_UART_STOP_BITS_1 // par défaut
C_UART_STOP_BITS_1_5
C_UART_STOP_BITS_2
getUARTDataLength()->int
Renvoie la longueur des données reçues.
readUART(size:int)->byte[256]
Lit une longueur définie en octets et la renvoie sous forme de tableau d’octets.
Attention !
Un maximum de 256 octets peut être renvoyé par appel.
readLineUART()->byte[256]
Lit une ligne entière (jusqu’à ‘\n’) et la renvoie sous forme de tableau d’octets.
Notez que:
Un maximum de 256 octets peut être renvoyé par appel.
writeUART(size:int, data:byte[])
Ecrit un nombre quelconque d’octets (size).
data = [0x11, 0x22, 0x33]
writeUART(3, data)
writeLineUART(data:byte[])
Écrit une chaîne et ajoute un ‘\n’ à la fin.
initSPI(mode:byte, speed:long)
Initialise l’interface SPI.
Modes disponibles:
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
Exemple:
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(size:int, data:byte[])
Ecrit un nombre quelconque d’octets (size).
data = [0x11, 0x22, 0x33]
writeSPI(3, data)
readSPI(size:int)
Lit un nombre quelconque d’octets (size) et les stocke dans le SPI-ReadBuffer interne.
Les fonctions getSPI permettent ensuite de renvoyer les données lues.
readSPI(7)
myByte = getSPIByte()
myInt = getSPIInt()
myLong = getSPILong()
transferSPI(size:int, txData:byte[])
Transmet et lit un nombre quelconque d’octets (size) et les stocke dans le SPI-ReadBuffer interne.
Les fonctions getSPI permettent ensuite de renvoyer les données lues.
txData = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
transferSPI(7, txData)
myByte = getSPIByte()
myInt = getSPIInt()
myLong = getSPILong()
getSPIByte()->byte
Renvoie un octet précédemment lu avec readSPI().
L’index interne readBufferIndex est augmenté de 1.
getSPIInt()->int
Renvoie un entier lu précédemment avec readSPI().
L’index interne readBufferIndex est augmenté de 2.
getSPILong()->long
Renvoie un long précédemment lu avec readSPI().
L’index interne readBufferIndex est augmenté de 4.
setSPIReadBufferIndex(index:int)
Définit le readBufferIndex interne sur la valeur souhaitée.
Cela permet de relire une valeur lue précédemment.
initPulseCounter(pinNr:byte)
Le compteur d’impulsions peut être utilisé pour compter les impulsions sur la pin spécifiée. La fonction initPulseCounter permet d’initialiser et de démarrer le compteur pour une pin.
initPulseCounter(C_PIN_06)
La valeur peut être lue avec la fonction readPulseCounter.
const ENCODER_PIN = C_PIN_06 # Pin à utiliser avec le compteur
initPulseCounter(ENCODER_PIN)
while true:
value = readPulseCounter(ENCODER_PIN)
clear()
drawText(10, 10, "value " + value)
update()
Le compteur peut compter jusqu’à 32767 et recommence à 0.
Si le compteur doit être remis à zéro manuellement, la fonction resetPulseCounter peut être utilisée.
Fonctions apparentées:
readPulseCounter(pinNr:byte)
La fonction readPulseCounter permet de lire la valeur actuelle du compteur d’impulsions.
value = readPulseCounter(C_PIN_06)
Fonctions apparentées:
resetPulseCounter(pinNr:byte)
Le compteur d’impulsions peut être remis à 0 à l’aide de la fonction resetPulseCounter.
resetPulseCounter(C_PIN_06)
Fonctions apparentées:
Nous prenons en charge le protocole de communication standard NEC pour les transmissions infrarouges. Les fonctions peuvent à la fois envoyer et recevoir des données. Les cartes d’interface IR standard peuvent être utilisées comme matériel.
Les fonctions initIrNecTx et sendIrNecData sont fournies pour l’envoi. Le protocole permet de transmettre une adresse et une valeur de données (2 octets chacune):
initIrNecTx(C_PIN_01)
clear()
drawTextCentered(120, 100, "Appuyer sur le bouton")
drawTextCentered(120, 140, "envoyer")
update()
while true:
b = getButtons()
if(b.middle):
# envoie les données d'adresse NEC
sendIrNecData(0xFC00, 0x7F80)
Envoie des données avec le protocole NEC. Lire la suite de “initIrNecTx” (en anglais)
deinitIrNecTx()
Utilisé pour supprimer l’émetteur NEC s’il n’est plus utilisé
initIrNecTx(C_PIN_01) # Init NEC sender
# Envoi des données NEC
# ...
deinitIrNecTx() # Supprimer si plus utilisé
Nous prenons en charge le protocole de communication standard NEC pour les transmissions infrarouges. Les fonctions peuvent à la fois envoyer et recevoir des données. Les cartes d’interface IR standard peuvent être utilisées comme matériel.
Les fonctions initIrNecRx et readIrNecData sont nécessaires pour la réception. La fonction renvoie les données reçues sous la forme d’un tableau d’octets.
initIrNecRx(C_PIN_06)
while true:
delay(50)
res = readIrNecData() # renvoie [addr H bite, addr L byte, cmd H byte, cmd L byte]
clear()
drawTextCentered(120, 40, "Adresse:")
drawTextCentered(120, 80, "0x" + byteToHex(res[0]) + byteToHex(res[1]))
drawTextCentered(120, 140, "Commande:")
drawTextCentered(120, 180, "0x" + byteToHex(res[2]) + byteToHex(res[3]))
update()
Reçoit des données avec le protocole NEC. Lire la suite de “initIrNecRx” (en anglais)
deinitIrNecRx()
Utilisé pour retirer le récepteur NEC s’il n’est plus utilisé
initIrNecRx(C_PIN_01) # Init NEC receiver
# Receive NEC data
# ...
deinitIrNecRx() # Supprimer si plus utilisé