Bulldog: una biblioteca GPIO increíblemente rápida

Una de las características más interesantes de los ordenadores como la Raspberry Pi es la capacidad de interactuar con el mundo físico a través de contactos GPIO (E/S de propósito general).

Los pines GPIO pueden capturar entradas de múltiples fuentes, incluidos datos de temperatura, humedad o sensores uniaxiales, y registrar salidas que pueden variar desde LED para controlar motores de CC, LCD o convertidores D/A.

Índice

    ¿Qué es un buldog?

    En resumen, Bulldog es una biblioteca de Java que permite a los desarrolladores acceder a GPIO y otras IO de bajo nivel como yo.2C, SPI o PWM. Con él puede controlar LED, unidades, servos o recopilar datos de sensores.

    Debido a que es una biblioteca de Java, requiere que la JVM se ejecute en el dispositivo de destino. Sin embargo, también tiene un kernel nativo escrito en C (enlazado a Java a través de JNI). Su objetivo principal es cargar el contenido de la memoria (/dev/mem). Usando este enfoque nativo, podemos administrar GPIO mucho más rápido.

    Bulldog pretende ser una plataforma agnóstica, lo que significa que el código puede ejecutarse en múltiples plataformas. Actualmente es compatible con una variedad de ordenadores de placa única populares, incluidas Raspberry Pi, BeagleBoneBlack y CubieBoard.

    Integración

    También hay un componente para camello apache que concluye las funciones de la biblioteca Bulldog. Para aquellos que no han oído hablar de Apache Camel, este es un marco Java de código abierto que se enfoca en hacer que la integración sea más fácil y accesible para los desarrolladores. A través de la implementación específica de plantillas de integración empresarial (EIP), los desarrolladores pueden integrar SBC con una amplia variedad de vehículos y API. es compatible componentes como MQTT, HTTP, AMQP, ElasticSearch, servicios de Google, JDBC, Eclipse Kura, (S) FTP y más.

    Actualmente, el componente Camel-bulldog solo admite GPIO y yo2C. Sin embargo, el soporte para otras funciones de Bulldog estará disponible pronto.

    Con la ayuda de un bulldog

    Hay dos formas de empezar a usar Bulldog. El primero: poner la implementación de un tablero en función de Maven:

    <dependency>
      <groupId>io.silverspoon</groupId>
      <artifactId>bulldog-board-${board-name}</artifactId>
      <version>${version.bulldog}</version>
    </dependency>

    Para facilitar las cosas, puede agregar todas las implementaciones de la placa a la ruta de acceso a las clases. No se enfrentarán. El Bulldog elegirá automáticamente el correcto según la plataforma en la que se ejecute su código. Después de configurar las dependencias, puede crear un código Java simple para administrar el contacto GPIO. El siguiente fragmento está vinculado al primer contacto GPIO (según la plataforma real a la que se trata de un contacto físico):

    import io.silverspoon.bulldog.core.gpio.DigitalOutput;
    import io.silverspoon.bulldog.core.platform.Board;
    import io.silverspoon.bulldog.core.platform.Platform;
    import io.silverspoon.bulldog.core.util.BulldogUtil;

    public class BulldogLED {

      public static void main(String[] args) {
        // Detect the board we are running on
        Board board = Platform.createBoard();

        // Set up a digital output
        DigitalOutput output = board.getPins().get(0).as(DigitalOutput.class);

        // Blink the LED
        output.high();
        BulldogUtil.sleepMs(1000);
        output.low();
        }
    }

    Otra opción es utilizar el componente bulldog-camel. Nuevamente, debe agregar una nueva dependencia de Maven a su proyecto Apache Camel. Admitirá automáticamente todas las dependencias posibles en el bulldog:

    <dependencies>
      <dependency>
        <groupId>io.silverspoon</groupId>
        <artifactId>camel-bulldog</artifactId>
        <version>${version.bulldog}</version>
      </dependency>
    </dependencies>

    A continuación, puede crear una ruta Camel de la siguiente manera:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:camel="http://camel.apache.org/schema/spring"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd">

      <bean id="properties" class="org.apache.camel.component.properties.PropertiesComponent">
        <property name="location" value="classpath:gpio.properties" />
      </bean>

      <camelContext trace="false" xmlns="http://camel.apache.org/schema/spring">
        <restConfiguration bindingMode="auto" component="jetty" port="8080" />

        <rest path="/rest">
          <post uri="/led">
            <to uri="bulldog://gpio?pin={{pin}}" />
          </post>
        </rest>
      </camelContext>
    </beans>

    La ruta Camel anterior abre una interfaz RESTful para controlar el pin GPIO. Bastante rápido, ¿verdad?

    Rendimiento

    ¿Qué nos hace pensar que es tan rápido? Realizamos una breve comparación del rendimiento de nuestra biblioteca con una de las bibliotecas GPIO más populares, Pi4J. Usamos USB osciloscopio para medir la frecuencia con la que un programa Java puede establecer valores de pin GPIO en una Raspberry Pi 2 B +.

    El Bulldog puede registrar un valor GPIO de 1.080 MHz (un millón de veces por segundo), mientras que el Pi4J es de aproximadamente 1 kHz (1000 veces por segundo). No consideramos que esta sea una prueba de rendimiento oficial, pero la diferencia es fácil de notar. ¡Los bulldogs son más de mil veces más rápidos!

    El código fuente que usamos para las pruebas se puede encontrar en GitHub.

    Artículos de interés

    Subir