[C, C ++, Python, JavaScript] L Chika avec Edison

S'il s'agit d'un er intégré, commencez par L Chika.

programme

Introduction de la bibliothèque MRAA

Pour contrôler les E / S d'Edison, Intel fournit une bibliothèque abstraite appelée MRAA. Cliquez ici pour le code source. Cette bibliothèque est déjà installée immédiatement après l'achat ou lorsque vous écrivez un binaire émis par Intel, et vous pouvez l'utiliser sans l'installer. Si vous avez installé Linux vous-même, tel que ubilinux, ** installez d'abord la dernière version de swig depuis GitHub, ** puis mraa Se il vous plaît installer.

(\ # Est une commande à exécuter avec les privilèges d'administrateur) \ # opkg install git cmake # Pour Yocto Linux \ # apt-get install git cmake autoconf byacc yodl # Pour Debian $ git clone https://github.com/swig/swig.git $ cd swig $ ./autogen.sh $ ./configure $ make # make install $ cd ../../

$ git clone https://github.com/intel-iot-devkit/mraa.git $ cd mraa $ mkdir build $ cd build $ cmake -DBUILDSWIGNODE=OFF .. $ make # make install

L Chika en langage C

L'explication de l'API est ici. L'exemple est ici.

led_c.c

#include <stdio.h>
#include <unistd.h>
#include <mraa.h>

int main(int argc, char *argv[])
{
	mraa_result_t ret;

	//Processus d'initialisation MRAA (identification du matériel)
	mraa_init();

	//Sortie de la version MRAA
	fprintf(stdout, "Hello mraa.\nVersion: %s\n", mraa_get_version());

	//Port 20 MRAA(=Carte de dérivation J18-7 broches)Initialisation
	mraa_gpio_context gpio;
	gpio = mraa_gpio_init(20);
	if(gpio == NULL){
		return 1;
	}

	//Définir le port sur la sortie
	ret = mraa_gpio_dir(gpio, MRAA_GPIO_OUT);
	if(ret != MRAA_SUCCESS){
		return 1;
	}

	int i;
	for(i=0;i<10;i++){
		//1 sur le port(Tension H)Production
		mraa_gpio_write(gpio, 1);
		usleep(1000*1000);

		//0 sur le port(Tension L)Production
		mraa_gpio_write(gpio, 0);
		usleep(1000*1000);
	}

	//Définir le port sur l'entrée
	mraa_gpio_dir(gpio, MRAA_GPIO_IN);

	//Processus de résiliation du MRAA
	mraa_deinit();

	return ret;
}

Construisez-le avec le Makefile suivant.

Makefile

CC = g++
MRAALIBS = -lmraa

.PHONY: all clean led_c led_cpp

all: led_c led_cpp

clean:
	rm -f ./*.o
	rm -f led_c led_cpp

led_c: led_c.o
	$(CC) -O4 $(MRAALIBS) -o $@ $^

led_cpp: led_cpp.o
	$(CC) -O4 $(MRAALIBS) -o $@ $^

%.o: %.c
	$(CC) -Wall -g -c $<

L'exécution de ** make ** générera un fichier exécutable appelé led_c.

# ./led_c Exécutez avec. (Nécessite des droits d'administrateur)

L Chika en C ++

L'explication de l'API est ici. L'exemple est ici. Ce que nous faisons à l'intérieur est presque le même que celui du langage C.

led_cpp.cpp

#include <stdio.h>
#include <unistd.h>
#include <mraa/gpio.hpp>
#include <mraa/common.hpp>

int main(int argc, char *argv[])
{
	mraa_result_t ret;

	fprintf(stdout, "Hello mraa.\nVersion: %s\n", mraa_get_version());

	mraa::Gpio *gpio = new mraa::Gpio(20);
	if(gpio == NULL){
		return MRAA_ERROR_UNSPECIFIED;
	}

	ret = gpio->dir(mraa::DIR_OUT);
	if(ret != MRAA_SUCCESS){
		mraa::printError(ret);
		return 1;
	}

	for(int i=0;i<5;i++){
		gpio->write(1);
		usleep(1000*1000);

		gpio->write(0);
		usleep(1000*1000);
	}

	gpio->dir(mraa::DIR_IN);

	delete gpio;

	return ret;
}

Makefile est le même que celui du langage C. Un fichier exécutable appelé led_cpp est généré.

# ./led_cpp Exécutez avec. (Nécessite des droits d'administrateur)

L Chika en Python

L'exemple est ici. Ce que nous faisons à l'intérieur est presque le même que celui de C / C ++.

led_py.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import mraa
import time

print("Hello mraa\nVersion: %s" % mraa.getVersion())

gpio = mraa.Gpio(20)
gpio.dir(mraa.DIR_OUT)

for i in range(5):
	gpio.write(1)
	time.sleep(1)

	gpio.write(0)
	time.sleep(1)

gpio.dir(mraa.DIR_IN)

Après avoir créé le fichier $ chmod +x ./led_py.py

Ensuite, donnez l'autorisation d'exécution.

# ./led_py.py Vous pouvez le faire avec.

L Chika avec JavaScript

L'exemple est ici. Ce que nous faisons à l'intérieur est presque le même que celui de C / C ++ / Python.

led_js.js

var m = require("mraa");
console.log("Hello mraa.\nVersion: " + m.getVersion());

var gpio = new m.Gpio(20);
gpio.dir(m.DIR_OUT);

var state = true;
var counter = 20;
                   
periodicActivity();
                            
function periodicActivity(){  
        gpio.write(state?1:0);
        state = !state;                   
        if(counter--)                     
                setTimeout(periodicActivity, 1000)
}

# node ./led_js.js Vous pouvez le faire avec.

circuit

La broche GND d'Edison (J19-3) semble être connectée à la couche interne GND, il est donc très difficile à souder. Il est recommandé d'utiliser un fer à souder coopératif de 30 [W] ou plus.

Expérience

Maintenant, câblons et expérimentons. Par souci de clarté, j'ai soudé les cordons directement sur la carte Breakout (découpée). Lorsque vous faites une expérience de suivi, c'est dangereux, alors soudez-la correctement! !!

Maintenant, quand j'exécute le programme précédent ...

Vidéo

cette? C'est un peu sombre ...

Cela devrait être le cas, Edison ne peut émettre que des signaux avec un niveau de tension de 1,8 [V]. Les LED de couleurs telles que le rouge et le vert s'allument faiblement parce que la tension d'effet direct (VF) est faible, mais les LED bleues et blanches ne peuvent pas être beaucoup pilotées. La vidéo suivante est celle que j'ai réellement expérimentée.

Vidéo

Oh, j'ai des ennuis.

Circuit refait

Si vous ne pouvez sortir que 1,8 [V] avec une tension H, créez un circuit. Le circuit précédent s'appelait Active High, qui est un circuit dans lequel le courant circule vers la charge (LED dans ce cas) lorsque 1 est émis vers le port, mais cela s'appelle Active Low, et lorsque 0 est émis vers le port, le courant est appliqué à la charge. Changer pour un circuit où

De cette façon, tout en émettant 1 sur le port, la LED recevra 1,5 [V] de 3,3-1,8, et si elle est inférieure à la tension directe de la LED, la LED s'allumera à peine. Ensuite, lorsque 0 est émis vers le port, une tension de 3,3 [V] est appliquée à la LED et la LED s'allume.

L'état de l'expérience réelle est le suivant.

Vidéo

Résumé

• Utilisez la bibliothèque MRAA pour activer / désactiver le port dans Edison,
• La bibliothèque MRAA a une API qui peut être consultée à partir de C / C ++ / Python / JavaScript.
• La tension qui peut être fournie par la broche Edison est de 1,8 [V].
• Avec Active High, piloter la LED est difficile, mais avec Active Low, cela peut être géré.