devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用Java来开发物联网应用_物联网开发

作者：从前慢现在也慢 | 2024-04-01 15:55:20

赞

踩

物联网开发

这是Hello, Lithosphere Tutorials系列教程中的其中一篇。

感觉介绍用C/C++，用Python来开发物联网应用的文章比较多，用Java来做物联网的文章比较少。

这篇文章，介绍如何使用Java技术来开发一个物联网的简单例子。我们从手机App上，遥控硬件板上的LED灯亮灯、熄灯、闪灯。

我们学习如何将树莓派硬件板连接到服务器，并使用Java代码来控制硬件板的GPIO。

当一切连通，我们通过手机App来遥控硬件板LED灯。

我们使用100%的纯Java代码来完成这一切。

以下，为教程的具体内容。
 

Hello, Actuator!!!

欢迎进入IoT的世界！！！让我们来学习如何让硬件板上的LED灯闪起来


在这第一篇教程中，让我们使用一块树莓派硬件板，通过GPIO连接LED灯。


然后，我们使用Lithosphere IoT平台提供的Actuator插件，只需要做简单的开发，我们就可以用App遥控IoT硬件板设备来让LED闪灯了。


 

1 前置条件：

Java = 8（树莓派端）

Java >= 11（服务器端）

Granite Lite IoT XMPP Server

点击这里下载Granite Lite IoT XMPP Server

Raspberry Pi Zero W硬件板

LED模块

几颗杜邦线


下图是这个教程中使用到的硬件。


 

2 概念

这篇教程，会涉及到IoT设备的硬件控制接口，以及IoT终端设备的分发部署。简单介绍相关概念如下。


 

2.1 GPIO

GPIO是英文General-Purpose Input/Output的缩写。


简单来说，GPIO就是硬件板上一组引针，这些引针可以用来控制电信号输入输出。


由于这些引针是可以编程来控制的，从而可以实现和外部的电路模块板通讯。


下图是Raspberry Pi Zero W上的GPIO接口。

 





在本教程中，我们使用GPIO来连接外部的LED模块，从而实现LED小灯的程序控制。


 

2.2 设备注册

在真实的IoT应用中，当一个IoT设备从库房中拿出来时，它并不能接通电源后立马就开始工作。


基于安全性和利于管理的考虑，IoT设备要能够开始工作，需要经过一个“设备注册”的步骤。


在这个“设备注册”的过程中，应用一般会：

  • 检查设备的合法性
  • 检查设备是否在此时被允许进入网络
  • 登记设备相关信息到系统中
  • 配置设备 - 例如对设备进行网络配置；发放安全token等。




在不同的应用和不同标准中，“设备注册”可能会有不同的术语和叫法。


例如，在LoRaWAN标准中，“设备注册”被叫做"End Device Activation"。官方文档里，这样描述End Device Activation：

All end devices that participate in a LoRaWAN network must be activated. There are two methods of activation you can choose: over-the-air activation (OTAA) or activation by personalization (ABP).


Lithosphere IoT Platform基于XMPP通讯协议。在标准XMPP协议扩展XEP-0077 (In-Band Registration)里，定义了如何实现IM用户在线注册的功能。


遵从XMPP的习惯，Lithosphere IoT平台里的“设备注册”，被称为IBTR(In-Band Thing Registration)，即智能物件在线注册。


Lithosphere IoT平台，已经内置实现了IBTR功能。基于服务器端和客户端的IBTR插件，可以快速开发及灵活定制“设备注册”功能。


在本篇教程中，我们会看到相关的内容。


 

3 安装和配置Raspberry Pi

树莓派Zero W，我在淘宝上买153元RMB，记住要买一个SD卡来插上。


我们需要做的第一件事，是给树莓派装上系统。


在没有监视器和键盘的情况下，给树莓派装上OS。在Raspberry Pi的官方的文档里，把这叫做Headless Setting Up。可以参考下面的链接，了解如何做Headless Setting Up。

官方Headless Setting Up文档



如果你不想阅读英文，可以看XDongger这篇关于树莓派安装和配置的文章。

安装和配置树莓派
 

4 连接硬件

我们先来看看LED模块长啥样。
 


这个LED模块在淘宝上买，5块钱一个。



我们可以看到，它有3个引脚：

引脚名作用
GND地线
VCC5V电源
INLED控制




我们需要将LED模块，通过树莓派硬件板上的GPIO接口，连接到硬件板上。



如何对接呢？让我们我们来看看树莓派的GPIO接口。
 





我们将LED的VCC接口，接在GPIO的5V Powerd引脚上。
我们将LED的GND接口，接在GPIO的Ground引脚上。
我们将LED的IN接口，接在GPIO 8引脚上。



接好后，看上去是这样的。


 

5 配置硬件板基础软件环境

在2 安装和配置Raspberry Pi步骤中，我们只是得到了一个初始化版本的RaspBerry Pi OS操作系统。要想在上面能运行Lithosphere IoT平台的终端程序，还得做以下的配置。


 

5.1 安装OpenJDK

登录到树莓派硬件板。

ssh pi@192.168.1.180

注：

  • 192.168.1.180是树莓派板的网络地址。请改为你配置树莓派板时，指定的静态IP地址。
  • pi为树莓派用户。请改为你配置树莓派时，初始化创建的用户名。




执行以下指令安装OpenJDK 8。

sudo apt-get install openjdk-8-jdk

注：

  • 为何要安装OpenJDK 8版本？

Raspberry Pi OS默认自带的OpenJDK版本是OpenJDK 11。这意味着，如果你执行以下指令。系统会默认安装OpenJDK 11。

sudo apt-get install default-jdk

这个默认版本的JDK，在Raspberry Pi Zero W上不能正常工作。原因是因为Raspberry Zero W使用ARMv6版本CPU。而Raspberry Pi OS默认带的OPenJDK 11，仅适用于ARMv7和ARMv8版本的CPU。


当然，有一些其它办法可以在Raspberry Pi Zero W上来安装OpenJDK 11。


在这篇教程里，我选择改装OpenJDK 8的解决方案。看上去，这是一个简单有效的解决方案。


 

5.2 安装WiringPi

我们在后续开发中，会使用Pi4J库V1.3版本来控制GPIO。Pi4J是一个开源Java库，它使用JNI来调用C程序编写的WiringPi库来控制GPIO。



所以，我们需要安装WiringPi。



Raspberry Pi OS并没有自带WiringPi软件包。我们通过以下指令安装WiringPi。

  1. wget https://github.com/WiringPi/WiringPi/releases/download/2.61-1/wiringpi-2.61-1-armhf.deb
  2.  
  3. sudo dpkg -i wiringpi-2.61-1-armhf.deb


 

6 开发协议包

为何我们需要单独开发一个包含协议对象的协议包？


这是因为我们使用叫OXM（Object-XMPP Mapping）的技术。简单来说，我们希望在开发中，能够屏蔽掉XMPP协议实现的细节，简化开发过程。


关于OXM，可以参考概念文档中的OXM章节



使用OXM，我们会定义的协议对象，这些协议对象，在客户端和服务器端，都会被使用。协议对象是可复用的。


所以，我们最好开发一个单独的协议包，已便于在后面客户端和服务器端复用这些协议对象。


 

6.1 创建协议工程

创建hello-actuator-protocol工程，pom.xml如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. 	xmlns="http://maven.apache.org/POM/4.0.0"
  4. 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  5.  
  6. 	<modelVersion>4.0.0</modelVersion>
  7.  
  8. 	<parent>
  9. 		<groupId>com.thefirstlineofcode.basalt</groupId>
  10. 		<artifactId>com.thefirstlineofcode.basalt</artifactId>
  11. 		<version>1.1.0-RELEASE</version>
  12. 	</parent>
  13.  
  14. 	<groupId>com.thefirstlineofcode.lithosphere.tutorials.helloactuator</groupId>
  15. 	<artifactId>hello-actuator-protocol</artifactId>
  16. 	<name>Hello actuator protocol</name>
  17. 	<version>0.0.1-RELEASE</version>
  18. 	
  19. 	<dependencies>
  20. 		<dependency>
  21. 			<groupId>com.thefirstlineofcode.basalt</groupId>
  22. 			<artifactId>basalt-oxm</artifactId>
  23. 		</dependency>
  24. 	</dependencies>
  25. 	
  26. 	<repositories>
  27. 		<repository>
  28. 			<id>com.thefirstlineofcode.releases</id>
  29. 			<name>TheFirstLineOfCode Repository - Releases</name>
  30. 			<url>http://120.25.166.188:9090/repository/maven-releases/</url>
  31. 		</repository>
  32. 	</repositories>
  33. 	
  34. </project>

代码说明

  • 指定parent为com.thefirstlineofcode.basalt:com.thefirstlineofcode.basalt，这样可以直接引用basalt parent pom的依赖管理配置。

     
  • 因为要使用OXM(Object-XMPP Mapping)，所以依赖basalt-oxm库。

     
  • 目前，Lithosphere的开源库，仅被部署在TheFirstLineOfCode的私有的maven服务器上。为了构建时能够正确找到开源依赖库，需要配置com.thefirstlineofcode.releases的repository。
  1. <repositories>
  2. 	<repository>
  3. 	<id>com.thefirstlineofcode.releases</id>
  4. 	<name>TheFirstLineOfCode Repository - Releases</name>
  5. 	<url>http://120.25.166.188:9090/repository/maven-releases</url>
  6. 	</repository>
  7. </repositories>


 

6.2 定义协议对象

在Hello，Actuator例子里，我们想用App来遥控IoT设备上的LED灯。我们希望可以遥控LED执行：亮灯、熄灯、闪灯。


为此，我们使用以下3个协议对象：
TurnOn

  1. @ProtocolObject(namespace="urn:leps:things:simple-light", localName="turn-on")
  2. public class TurnOn {
  3. 	public static final Protocol PROTOCOL = new Protocol("urn:leps:things:simple-light", "turn-on");
  4. }




TurnOff

  1. @ProtocolObject(namespace="urn:leps:things:simple-light", localName="turn-off")
  2. public class TurnOff {
  3. 	public static final Protocol PROTOCOL = new Protocol("urn:leps:things:simple-light", "turn-off");
  4. }




Flash

  1. @ProtocolObject(namespace="urn:leps:things:simple-light", localName="flash")
  2. public class Flash {
  3. 	public static final Protocol PROTOCOL = new Protocol("urn:leps:things:simple-light", "flash");
  4. 	
  5. 	private int repeat;
  6. 	
  7. 	public Flash() {
  8. 		this(1);
  9. 	}
  10. 	
  11. 	public Flash(int repeat) {
  12. 		setRepeat(repeat);
  13. 	}
  14. 	
  15. 	public int getRepeat() {
  16. 		return repeat;
  17. 	}
  18.  
  19. 	public void setRepeat(int repeat) {
  20. 		if (repeat < 1)
  21. 			throw new IllegalArgumentException("Attribute repeat must be a non-zero positive integer.");
  22. 		
  23. 		this.repeat = repeat;
  24. 	}
  25. 	
  26. 	@Override
  27. 	public String toString() {
  28. 		return String.format("Flash[repeat=%d]", repeat);
  29. 	}
  30. }

代码说明

  • OXM框架会帮我们将Project Object转换成XMPP协议文档。当Flash对象的repeat属性值设置成5时，会生成下面的XMPP协议文档：
<flash xmlns="urn:leps:things:simple-light" repeat=5/>


 

  • 不需要担心"urn:leps:things:simple-light"字符串太长了，会带来传输效率的低下。在Lithosphere IoT平台下，如果使用BXMPP技术，ProtocolObject(namespace="urn:leps:things:simple-light", localName="flash")这段协议头信息，会被转化成3字节长度的二进制协议信息。

     
  • TurnOn和TurnOff，表达一个不带任何参数的指令，所以它们被设计成不带任何实例属性的空对象。


 

6.3 定义Model Descriptor

让我们来给要控制的IoT设备，定义一个Model Descriptor。


为何需要定义Model Descriptor？


这是因为Lithosphere完全基于插件架构。在插件架构下，系统功能并不是写死固化的。当一个插件被部署时，它为系统提供了一组应用功能。当这个插件被卸载掉后，它所提供的功能就消失了。


正是因为这种插件架构的特性，默认系统是不认识任何IoT设备的，也不能识别任何IoT控制/数据协议。


当我们基于插件技术，使用XMPP扩展协议，开发了某种IoT设备的一组应用功能。我们需要使用平台提供的扩展点，将插件提供的应用功能注册到系统中。我们需要明确的告知系统：现在，我们有这些功能了，相关功能由XXX插件提供。


最好是能有一个从设备维度专门描述IoT设备的对象，能够便利我们将相关信息提供给系统。


这个事说起来啰嗦，实操起来其实比较简单。我们需要在协议包里，定义一个Model Descriptor类。

  1. public class HatModelDescriptor extends SimpleThingModelDescriptor {
  2. 	public static final String MODEL_NAME = "HAT";
  3. 	public static final String DESCRIPTION = "Hello Acuator Thing";
  4. 	
  5. 	public HatModelDescriptor() {
  6. 		super(MODEL_NAME, DESCRIPTION, false, null, null, createSupportedActions());
  7. 	}
  8. 	
  9. 	private static Map<Protocol, Class<?>> createSupportedActions() {
  10. 		Map<Protocol, Class<?>> supportedActions = new HashMap<>();
  11. 		supportedActions.put(Flash.PROTOCOL, Flash.class);
  12. 		supportedActions.put(TurnOn.PROTOCOL, TurnOn.class);
  13. 		supportedActions.put(TurnOff.PROTOCOL, TurnOff.class);
  14. 		
  15. 		return supportedActions;
  16. 	}
  17. }

代码说明

  • 继承SimpleThingModelDescriptor，这个基类实现了IThingModelDescriptor接口，提供了一些复用代码，可以让我们编写Model Descriptor时更省事。

     
  • IoT设备的型号名。在这里，我们把这个被遥控闪灯的IoT设备型号叫做HAT，Hello Actuator Thing的缩写。

     
  • 这个IoT设备是一个Actuator（执行器）设备，它接受Action指令，然后执行指令对应的操作。它不是Sensor，不需要上报数据。它也不触发事件，不需要事件通知功能。所以构造器里的参数都是false，null。只有最后一个构造器参数，我们用createSupportedActions()，将这个Actuator设备支持的Action都登记到Model Descriptor中。当然，在这个例子里，IoT设备只支持3个指令，TurnOn，TurnOff，Flash。


 

6.4 构建安装协议包

因为需要在后续开发客户端和服务器端插件包时，引用协议包，所以我们在hello-actuator-protocol工程里，执行构建安装指令，把协议包安装到本地maven仓库。

  1. cd hello-actuator-protocol
  2. mvn clean install




协议包已经开发完成，你可以参考官方开源仓库代码hello-actuator-protocol协议包工程源码


 

7 开发服务器端插件

7.1 服务器端插件工程

创建hello-actuator-server目录，添加pom.xml文件。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2.  
  3. <project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. 	xmlns="http://maven.apache.org/POM/4.0.0"
  5. 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  6. 	<modelVersion>4.0.0</modelVersion>
  7. 	
  8. 	<parent>
  9. 		<groupId>com.thefirstlineofcode.sand</groupId>
  10. 		<artifactId>sand-server</artifactId>
  11. 		<version>1.0.0-BETA3</version>
  12. 	</parent>
  13.  
  14. 	<groupId>com.thefirstlineofcode.lithosphere.tutorials.helloactuator</groupId>
  15. 	<artifactId>hello-actuator-server</artifactId>
  16. 	<version>0.0.1-RELEASE</version>
  17. 	<name>Hello actuator server plugin</name>
  18.  
  19. 	<dependencies>
  20. 		<dependency>
  21. 			<groupId>com.thefirstlineofcode.sand.server</groupId>
  22. 			<artifactId>sand-server-things</artifactId>
  23. 		</dependency>
  24. 		<dependency>
  25. 			<groupId>com.thefirstlineofcode.lithosphere.tutorials.helloactuator</groupId>
  26. 			<artifactId>hello-actuator-protocol</artifactId>
  27. 			<version>0.0.1-RELEASE</version>
  28. 		</dependency>
  29. 	</dependencies>
  30. 	
  31. 	<repositories>
  32. 		<repository>
  33. 			<id>com.thefirstlineofcode.releases</id>
  34. 			<name>TheFirstLineOfCode Repository - Releases</name>
  35. 			<url>http://120.25.166.188:9090/repository/maven-releases/</url>
  36. 		</repository>
  37. 	</repositories>
  38. </project>

代码说明

  • parent设置为com.thefirstlineofcode.sand:sand-server，可引用parent POM里的以来配置管理。

     
  • 依赖com.thefirstlineofcode.sand.server:sand-server-things库，因为我们要使用这个库里的接口IThingProvider和IThingRegistrationCustomizer来实现相关功能。
  • 依赖hello-actuator-protocol协议包。


 

7.2 实现IThingProvider

  1. @Extension
  2. public class ThingModelsProvider implements IThingModelsProvider {
  3.  
  4. 	@Override
  5. 	public IThingModelDescriptor[] provide() {
  6. 		return new IThingModelDescriptor[] {
  7. 			new HatModelDescriptor()
  8. 		};
  9. 	}
  10.  
  11. }

代码说明

  • 实现IThingProvider接口，在接口方法里，我们将前面开发的HatModelDescripotor登记到服务器中。

     
  • 请注意@Extension标注，它申明了这个类是PF4J的插件扩展。


 

7.3 实现IThingRegistrationCustomizer

在这篇教程的前面章节，我们提到了“设备注册”。在Lithosphere平台里，“设备注册”被实现为IBTR（In-Band Thing Registration）协议。



Lithosphere IoT平台，提供一个IThingRegistrationCustomizer的接口，来允许开发人员定制设备注册的过程。


下面，我们来看看怎么使用IThingRegistrationCustomizer。

  1. @Extension
  2. public class ThingRegistrationCustomizer extends ThingRegistrationCustomizerAdapter {
  3. 	private static final String HARD_CODED_REGISTRATION_CODE = "abcdefghijkl";
  4. 	
  5. 	@Override
  6. 	public boolean isUnregisteredThing(String thingId, String registrationCode) {
  7. 		if (!super.isUnregisteredThing(thingId, registrationCode))
  8. 			return false;
  9. 		
  10. 		return HARD_CODED_REGISTRATION_CODE.equals(registrationCode);
  11. 	}
  12.  
  13. 	@Override
  14. 	public boolean isAuthorizationRequired() {
  15. 		return false;
  16. 	}
  17. }

代码说明

  • 继承ThingRegistrationCustomizerAdapter，这个类提供了IThingRegistrationCustomizer接口的默认实现。

     
  • 重载了isUnregisteredThing方法，这个方法检查IoT设备的 Thing ID和Registration Code的合法性。我们看到，实现检查一个硬编码写死的Registration Code。

     
  • isAuthorizationRequired()，返回false。我们在这个例子中，只检查Thing ID和Registration Code的合法性。不做人工的设备注册授权。所以我们关掉Authorization功能。

     
  • @Extension标注申明这个类是PF4J的插件扩展。


 

7.4 编写插件配置文件

在src/main/resources目录下，创建plugin.properties。

  1. plugin.id=hello-actuator-server
  2. plugin.provider=TheFirstLineOfCode
  3. plugin.version=0.0.1-RELEASE
  4. plugin.dependencies=sand-server-things
  5. non-plugin.dependencies=hello-actuator-protocol

代码说明

  • plugin.dependencies，依赖sand-server-things插件。

     
  • non-plugin.dependencies，依赖hello-actuator-protocol协议包（非插件格式jar）。


 

7.5 构建部署服务器端插件

构建hello-actuator-server插件包

  1. cd hello-actuator-server
  2. mvn clean package




将hello-actuator-server插件包和它依赖的hello-actuator-protocol包，把这两个jar包，copy到服务器的plugins目录下。

  1. cp hello-actuator-protocol/target/hello-actuator-protocol-0.0.1-RELEASE.jar granite-lite-iot-1.0.4-RELEASE/plugins
  2.  
  3. cp hello-actuator-server/target/hello-actuator-server-0.0.1-RELEASE.jar granite-lite-iot-1.0.4-RELEASE/plugins




服务器端插件已经开发完成，你可以参考官方开源仓库代码hello-actuator-server服务器端插件包工程源码


 

7.6 检查Granite Lite XMPP Server状态

启动Granite Lite XMPP Server

  1. cd granite-lite-iot-1.0.4
  2. java -jar granite-server-1.0.4-RELEASE.jar -console

带-console参数启动Granite Lite XMPP Server之后，能够看到Granite Server Console的界面。




我们可以在Console输入services命令来检查Granite XMPP Server的状态。

  1. $services
  2.

如果能看到所有的services的状态都是available，说明granite lite server已经被正常的启动了。
 





可以用plugins命令，来检查可用的plugins。

$plugins




我们可以看到，hello-actuator-server插件已经被部署。
 

7.7 创建测试用户

在这里，我们还需要解决一个问题。
 

我们想使用手机App来遥控IoT设备闪灯，我们使用XMPP技术来做这件事情。
 

在XMPP标准里，要在XMPP网络里进行通讯，你需要一个XMPP账户。无论你是人还是物，你都需要一个账户。你是人，需要一个User账户。你是物，你需要一个Thing（IoT）账户。


我们需要一个User账户，这样，我们才能够从手机App，连接到XMPP网络中，这才有可能通过XMPP网络去遥控IoT设备。


有一个简单的办法，可以创建User用户。


我们在Granite Lite IoT XMPP Server里，默认部署了sand-demo-server插件。这个插件用来支撑完整的sand-demo演示程序。使用plugins指令，可以看到Granite Lite IoT XMPP Server部署了sand-demo-server插件。
 





sand-demo-server插件，在Granite Server Console里提供了一个创建测试用户的指令，我们可以用它来创建测试用户。在Granite Server Console里，我们执行以下指令。

sand-demo create-test-users




我们会看到，测试用户已经被创建。




我们在这个教程后面，会使用测试用户sand-demo来登录手机App，进行遥控闪灯操作。




使用exit指令，可以退出Granite Server Console，并关闭Granite XMPP Server。

$exit


 

8 开发设备端程序

8.1 设备端工程

创建hello-actuator-thing目录，添加pom.xml文件。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2.  
  3. <project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. 	xmlns="http://maven.apache.org/POM/4.0.0"
  5. 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  6. 	<modelVersion>4.0.0</modelVersion>
  7. 	
  8. 	<parent>
  9. 		<groupId>com.thefirstlineofcode.sand</groupId>
  10. 		<artifactId>sand-client</artifactId>
  11. 		<version>1.0.0-BETA3</version>
  12. 	</parent>
  13.  
  14. 	<groupId>com.thefirstlineofcode.lithosphere.tutorials.helloactuator</groupId>
  15. 	<artifactId>hello-actuator-thing</artifactId>
  16. 	<version>0.0.1-RELEASE</version>
  17. 	<name>Hello actuator thing</name>
  18.  
  19. 	<dependencies>
  20. 		<dependency>
  21. 			<groupId>com.thefirstlineofcode.sand.client</groupId>
  22. 			<artifactId>sand-client-edge</artifactId>
  23. 		</dependency>
  24. 		<dependency>
  25. 			<groupId>com.pi4j</groupId>
  26. 			<artifactId>pi4j-core</artifactId>
  27. 			<version>1.3</version>
  28. 		</dependency>
  29. 		<dependency>
  30. 			<groupId>com.thefirstlineofcode.lithosphere.tutorials.helloactuator</groupId>
  31. 			<artifactId>hello-actuator-protocol</artifactId>
  32. 			<version>0.0.1-RELEASE</version>
  33. 		</dependency>
  34. 	</dependencies>
  35. 	
  36. 	<build>
  37. 		<plugins>
  38. 			<plugin>
  39. 				<groupId>org.apache.maven.plugins</groupId>
  40. 				<artifactId>maven-jar-plugin</artifactId>
  41. 				<version>2.4</version>
  42. 				<configuration>
  43. 					<archive>
  44. 						<manifest>
  45. 							<addClasspath>true</addClasspath>
  46. 							<classpathPrefix>libs/</classpathPrefix>
  47. 							<mainClass>com.thefirstlineofcode.lithosphere.tutorials.helloactuator.thing.Main</mainClass>
  48. 						</manifest>
  49. 					</archive>
  50. 				</configuration>
  51. 			</plugin>
  52. 			<plugin>
  53. 				<artifactId>maven-assembly-plugin</artifactId>
  54. 				<version>3.0.0</version>
  55. 				<configuration>
  56. 					<appendAssemblyId>false</appendAssemblyId>
  57. 					<descriptors>
  58. 						<descriptor>src/assembly/descriptor.xml</descriptor>
  59. 					</descriptors>
  60. 				</configuration>
  61. 				<executions>
  62. 					<execution>
  63. 						<id>make-assembly</id>
  64. 						<phase>package</phase>
  65. 						<goals>
  66. 							<goal>single</goal>
  67. 						</goals>
  68. 					</execution>
  69. 				</executions>
  70. 			</plugin>
  71. 		</plugins>
  72. 	</build>
  73. 	
  74. 	<repositories>
  75. 		<repository>
  76. 			<id>com.thefirstlineofcode.releases</id>
  77. 			<name>TheFirstLineOfCode Repository - Releases</name>
  78. 			<url>http://120.25.166.188:9090/repository/maven-releases/</url>
  79. 		</repository>
  80. 	</repositories>
  81. </project>

代码说明

  • POM继承com.thefirstlineofcode.sand:sand-client，以便复用父POM里的依赖配置管理。

     
  • hello-actuator-thing是一个独立运行的Java程序。我们使用maven-assembly-plugin和maven-jar-plugin来打包和配置可这个可运行程序。

     
  • 依赖com.thefirstlineofcode.sand.client:sand-client-edge库，我们使用Edge库来帮助终端设备进行设备注册和连接服务器。
  1. <dependency>
  2. 	<groupId>com.thefirstlineofcode.sand.client</groupId>
  3. 	<artifactId>sand-client-edge</artifactId>
  4. </dependency>


 

  • 依赖pi4j-core库。我们用Pi4J库来访问控制硬件板的GPIO接口。
  1. <dependency>
  2. 	<groupId>com.pi4j</groupId>
  3. 	<artifactId>pi4j-core</artifactId>
  4. 	<version>1.3</version>
  5. </dependency>

注：我们使用1.3版本Pi4J。因为Pi4J v1.4和Pi4J v2.x需要JDK 11。而我们在树莓派Zero W上，只安装了JDK 8。所以，我们使用Pi4J v1.3。

  • 依赖hello-actautor-protocol协议包。
  1. <dependency>
  2. 	<groupId>com.thefirstlineofcode.lithosphere.tutorials.helloactuator</groupId>
  3. 	<artifactId>hello-actuator-protocol</artifactId>
  4. 	<version>0.0.1-RELEASE</version>
  5. </dependency>


 

8.2 硬件控制

程序设计一个重要原则，责任原则。简单来说，我们将不同的责任划分到不同的接口和实现中，让它们各行其事。


在这里，我们也来划分责任。


我们先来关注硬件控制部分，我们想要控制IoT设备做亮灯、熄灯、闪灯。


Ok，先不管其它，我们来定义这个IoT设备的硬件控制的接口。
 

  1. public interface ISimpleLight {	
  2. 	void turnOn();
  3. 	void turnOff();
  4. 	void flash(int repeat) throws ExecutionException;
  5. }

注：
这种控制硬件的接口，在概念里，我们把它叫做Thing Controller，智能物件控制器。



hello-actuator-thing的核心类HelloActuatorThing，我们让它实现ISimpleLight接口。

  1. public class HelloActuatorThing implements ISimpleLight {
  2. 	private GpioController gpio;
  3. 	private GpioPinDigitalOutput ledPin;
  4. 	
  5. 	public HelloActuatorThing() {
  6. 		configureGpio();
  7. 	}
  8. 	
  9. 	private void configureGpio() {
  10. 		gpio = GpioFactory.getInstance();
  11. 		ledPin = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_08, "MyLED", PinState.LOW);
  12. 		ledPin.setShutdownOptions(true, PinState.LOW);
  13. 	}
  14. 	
  15. 	@Override
  16. 	public void turnOn() {
  17. 		ledPin.high();
  18. 	}
  19.  
  20. 	@Override
  21. 	public void turnOff() {
  22. 		ledPin.low();
  23. 	}
  24.  
  25. 	@Override
  26. 	public void flash(int repeat) throws ExecutionException {
  27. 		if (repeat <= 0 || repeat > 8)
  28. 			throw new ExecutionException(-1);
  29. 		
  30. 		for (int i = 0; i < repeat; i++) {			
  31. 			flash();
  32. 			
  33. 			try {
  34. 				Thread.sleep(500);
  35. 			} catch (InterruptedException e) {
  36. 				throw new ExecutionException(-2);
  37. 			}
  38. 		}
  39. 	}
  40. 	
  41. 	private void flash() throws ExecutionException {
  42. 		turnOn();
  43. 		
  44. 		try {
  45. 			Thread.sleep(200);
  46. 		} catch (InterruptedException e) {
  47. 			throw new ExecutionException(-2);
  48. 		}
  49. 		
  50. 		turnOff();
  51. 	}	
  52. }

**代码说明

  • 在configureGpio()方法里，我们使用Pi4J库对GPIO进行配置。我们配置使用ledPin变量来对LED灯的IN接口进行控制。

     
  • 在turnOn方法中，我们调用ledPin.high()，拉高GPIO引针电压，这会让LED灯亮灯。对应的，在turnOff方法中，我们调用ledPin.low()来让LED灯熄灯。




Ok，现在，我们已经实现硬件控制了。


 

8.3 IoT通讯

让我们来给IoT设备添加通讯能力。


我们使用sand-client-edge库，可以简化设备端程序的编写。


让HelloActuatorThing继承AbstractEdgeThing。

  1. public class HelloActuatorThing extends AbstractEdgeThing implements ISimpleLight {
  2. 	public static final String THING_MODEL = HatModelDescriptor.MODEL_NAME;
  3. 	public static final String SOFTWARE_VERSION = "0.0.1-RELEASE";
  4. 	
  5. 	private IActuator actuator;
  6. 	private GpioController gpio;
  7. 	private GpioPinDigitalOutput ledPin;
  8. 	
  9. 	public HelloActuatorThing() {
  10. 		super(THING_MODEL, streamConfig, true);
  11. 		
  12. 		configureGpio();
  13. 	}
  14. 	
  15. 	@Override
  16. 	public String getSoftwareVersion() {
  17. 		return SOFTWARE_VERSION;
  18. 	}
  19. 	
  20. 	@Override
  21. 	protected void registerIotPlugins() {
  22. 		chatClient.register(ActuatorPlugin.class);
  23. 	}
  24. 	
  25. 	@Override
  26. 	protected void startIotComponents() {
  27. 		startActuator();
  28. 	}
  29. 	
  30. 	private void configureGpio() {
  31. 		... ...
  32. 	}
  33.  
  34. 	private void startActuator() {
  35. 		if (actuator == null) {			
  36. 			actuator = chatClient.createApi(IActuator.class);
  37. 			registerExecutors(actuator);
  38. 		}
  39. 		
  40. 		actuator.start();
  41. 	}
  42. 	
  43. 	private void registerExecutors(IActuator actuator) {
  44. 		actuator.registerExecutor(TurnOn.class, TurnOnExecutor.class, this);
  45. 		actuator.registerExecutor(TurnOff.class, TurnOffExecutor.class, this);
  46. 		actuator.registerExecutorFactory(createFlashExecutorFactory());
  47. 	}
  48. 	
  49. 	private IExecutorFactory<?> createFlashExecutorFactory() {
  50. 		return new IExecutorFactory<Flash>() {
  51. 			@Override
  52. 			public Protocol getProtocol() {
  53. 				return Flash.PROTOCOL;
  54. 			}
  55. 			
  56. 			@Override
  57. 			public Class<Flash> getActionType() {
  58. 				return Flash.class;
  59. 			}
  60. 			
  61. 			@Override
  62. 			public IExecutor<Flash> create() {
  63. 				return new FlashExecutor(HelloActuatorThing.this);
  64. 			}
  65. 		};
  66. 	}
  67. 	
  68. 	@Override
  69. 	protected void stopIotComponents() {
  70. 		if (actuator != null) {			
  71. 			actuator.stop();
  72. 			actuator = null;
  73. 		}
  74. 	}
  75. 	
  76. 	@Override
  77. 	public void turnOn() {
  78. 		... ...
  79. 	}
  80.  
  81. 	@Override
  82. 	public void turnOff() {
  83. 		... ...
  84. 	}
  85.  
  86. 	@Override
  87. 	public void flash(int repeat) throws ExecutionException {
  88. 		... ...
  89. 	}
  90. 	
  91. 	private void flash() throws ExecutionException {
  92. 		... ...
  93. 	}
  94. 		
  95. 	@Override
  96. 	protected String loadThingId() {
  97. 		return THING_MODEL + "-" + ThingsUtils.generateRandomId(8);
  98. 	}
  99. 	
  100. 	@Override
  101. 	protected String loadRegistrationCode() {
  102. 		return "abcdefghijkl";
  103. 	}
  104. }

代码说明

  • AbstractEdgeThing留下了一些抽象方法给子类来实现。这些抽象方法名字很直白，我们遵从方法名给出对应实现细节即可。

     
  • registerIotPlugins()方法，在这里登记我们要使用的插件。因为这个IoT设备是一个可执行指令的Actuator。所以我们只需要注册ActuatorPlugin插件。
  1. protected void registerIotPlugins() {
  2. 	chatClient.register(ActuatorPlugin.class);
  3. }


 

  • startIotComponents()方法，Edge Thing连接到服务器后，会调用这个方法来启动设备。在这里，我们需要把Actuator组件启动起来，Actuator组件来自ActuatorPlugin。

    我们在startActuator()方法里，创建IActuator实例，并注册Executors，最后调用Actuator的start()方法。
  1. protected void startIotComponents() {
  2. 	startActuator();
  3. }
  4.  
  5. private void startActuator() {
  6. 	if (actuator == null) {			
  7. 		actuator = chatClient.createApi(IActuator.class);
  8. 		registerExecutors(actuator);
  9. 	}
  10. 	
  11. 	actuator.start();
  12. }


 

  • 在registerExecutors()方法里，我们给TurnOn，TurnOff，Flash指令，注册它们对应的执行器。


    有两种注册执行器的API。第一种API，我们直接将Action指令类，和Executor指令类，登记到Actuator。


    注：
    这里registerExecutor()方法的最后一个参数，是Thing Controller。


    依据设计原则中的责任原则，Thing Controller负责直接控制IoT设备的硬件接口。在这里，Thing Controller是ISimpleLigh。


    HelloActuatorThing实现了这个接口（ISimpleLight），提供控制硬件的turnOn()，TurnOff()，flash()方法。


    我们把HelloActuatorThing当做第三个参数传给Actuator，Thing Controller会被注入给Executor使用。
  1. actuator.registerExecutor(TurnOn.class, TurnOnExecutor.class, this);
  2. actuator.registerExecutor(TurnOff.class, TurnOffExecutor.class, this);


 

  • 第二种API，我们注册一个Executor Factory，由这个Factory来提供相关信息以及创建Executor，这样可以更灵活的处理Executor的创建。我们使用这种API来创建FlashExecutor。
  1. ... ...
  2. 	actuator.registerExecutorFactory(createFlashExecutorFactory());
  3. ... ...
  4.  
  5. private IExecutorFactory<?> createFlashExecutorFactory() {
  6. 	return new IExecutorFactory<Flash>() {
  7. 		@Override
  8. 		public Protocol getProtocol() {
  9. 			return Flash.PROTOCOL;
  10. 		}
  11.  
  12. 		@Override
  13. 		public Class<Flash> getActionType() {
  14. 			return Flash.class;
  15. 		}
  16. 	
  17. 		@Override
  18. 		public IExecutor<Flash> create() {
  19. 			return new FlashExecutor(HelloActuatorThing.this);
  20. 		}
  21. 	};
  22. }


 

  • 我们来处理一下设备注册的对应逻辑。还记得吗，我们在服务器端的Registration Customizer里，在检查Registration Code合法性时，使用的是一个硬编码的Registration Code。


    所以，在IoT设备端，我们需要使用这个硬编码的Registration Code去注册。


    我们重载loadRegistrationCode()方法，用写死的"abcdefghijkl"作为Registration Code去进行注册。
  1. protected String loadRegistrationCode() {
  2. 	return "abcdefghijkl";
  3. }


 

8.4 主程序

我们编写一个主程序来启动hello-actuator-thing。

  1. public class Main {
  2. 	private HelloActuatorThing simpleLight;
  3. 	
  4. 	public static void main(String[] args) {
  5. 		new Main().run(args);
  6. 	}
  7.  
  8. 	private void run(String[] args) {
  9. 		if (args.length == 1 && args[0].equals("--help")) {
  10. 			printUsage();
  11. 			
  12. 			return;
  13. 		}
  14. 		
  15. 		... ...
  16. 		
  17. 		try {
  18. 			simpleLight = new HelloActuatorThing();
  19. 		} catch (IllegalArgumentException e) {
  20. 			e.printStackTrace();
  21. 			printUsage();
  22. 			
  23. 			return;
  24. 		}
  25. 		
  26. 		... ...
  27. 		
  28. 		simpleLight.start();
  29. 	}
  30. 	
  31. 	... ...
  32. }

代码说明

  • 很简单直白的代码，重要的是调用HelloActuatorThing的start()方法，将Edge Thing启动起来。




设备端程序已经开发完成，你可以参考官方开源仓库代码hello-actuator-thing设备端程序工程源码


 

8.5 构建部署hello-actuator-thing

用maven构建hello-actuator-thing

  1. cd hello-actuator-thing
  2. mvn clean package




将构建成功的设备端程序，copy到树莓派硬件板上。

scp target/hello-actuator-thing-0.0.1-RELEASE.tar.gz pi@192.168.1.180:/home/pi

注：
请将pi用户名，和树莓派网络ip 192.168.1.180，改为你自己环境的配置值。


 

8.6 启动thing程序

登录到树莓派上

ssh pi@192.168.1.180




运行thing程序

  1. tar -xzvf hello-actuator-thing-0.0.1-RELEASE.tar.gz
  2. cd hello-actuator-thing-0.0.1-RELEASE
  3. java -jar hello-actuator-thing-0.0.1-RELEASE.jar --host=192.168.1.80

说明

  • 启动thing程序之前，记得要先启动Granite XMPP Server。
     
  • 第一次运行thing程序时，需要使用--host参数指定服务器地址。AbstractEdgeThing会记住程序启动参数，后续再启动thing程序，不需要再指定host。
     
  • 程序启动后，会连接到服务器进行设备注册，注册成功后，登录到服务器


    一切就绪后，可以看到Thing thing has started的提示。





    可以使用exit命令来退出hello-actuator-thing程序。


 

9 使用手机App遥控IoT设备

从头开发一个手机App比较繁琐，我们可以直接用Lithosphere平台提供的sand-demo App来遥控我们的IoT小灯。



你可以自己来构建sand-demo App，这是一个标准的Andriod工程，请用Andriod Studio来打开它。sand-demo App源码位于sand工程的demo/app-android子目录下。


你可以直接下载构建好的sand-demo App安装使用。



sand-demo App里大部分是常规的Android开发。创建菜单，画界面... ...



和IoT通讯相关的部分，是App使用Chalk的remoting插件来遥控IoT设备。



remoting插件的功能，是可以在远程设备上执行action指令。



remoting插件的使用较简单，以下代码，来自sand-demo App源码。

  1. ... ...
  2. 	public void turnOn(JabberId target) {
  3. 		logger.info("Turn on light {}.", target);
  4. 		controlThing(target, new TurnOn(), "Turn on");
  5. 	}
  6. ... ...
  7. 	private void controlThing(JabberId target, Object action, String actionDescription) {
  8. 		IChatClient chatClient = ChatClientSingleton.get(this);
  9. 		IRemoting remoting = chatClient.createApi(IRemoting.class);
  10. 		remoting.execute(target, action, new RemotingCallback(this, actionDescription));
  11. 	}
  12. ... ...
  13. private static class RemotingCallback implements IRemoting.Callback {
  14. 		private final Activity activity;
  15. 		private final String actionDescription;
  16.  
  17. 		public RemotingCallback(Activity activity, String actionDescription) {
  18. 			this.activity = activity;
  19. 			this.actionDescription = actionDescription;
  20. 		}
  21.  
  22. 		@Override
  23. 		public void executed(Object xep) {
  24. 			activity.runOnUiThread(() -> Toast.makeText(activity,
  25. 					actionDescription + " executed.",
  26. 					Toast.LENGTH_LONG).show());
  27. 		}
  28.  
  29. 		@Override
  30. 		public void occurred(StanzaError error) {
  31. 			String errorText = actionDescription + " execution error: " +
  32. 					(error.getText() == null ? error.toString() : error.getText().getText());
  33. 			remotingErrorOccurred(activity, error, errorText);
  34. 		}
  35.  
  36. 		@Override
  37. 		public void timeout() {
  38. 			activity.runOnUiThread(() -> Toast.makeText(activity,
  39. 					actionDescription + " execution timeout.",
  40. 					Toast.LENGTH_LONG).show());
  41. 		}
  42. 	}
  43. ... ...

代码说明

  • 用chatClient创建IRemoting实例，然后调用IRemoting的execute()方法。方法3个参数，第一个参数是远程设备的地址；第二个参数是要执行的action对象（Protocol Object）；第三个参数，是RemotingCallback，我们用这个回调接口来处理远程指令执行结果。
  1. IChatClient chatClient = ChatClientSingleton.get(this);
  2. IRemoting remoting = chatClient.createApi(IRemoting.class);
  3. remoting.execute(target, action, new RemotingCallback(this, actionDescription));


 

  • 在RemotingCallback里，如果远程指令正常执行，会回调executed()方法；远程指令执行出错，会回调occurred()方法；远程指令执行超时（执行端未返回响应，不能确认指令是否执行成功），会调用timeout()方法。我们在这些回调方法里，做对应的处理。
  1. ... ...
  2. @Override
  3. public void executed(Object xep) {
  4. 	activity.runOnUiThread(() -> Toast.makeText(activity,
  5. 			actionDescription + " executed.",
  6. 			Toast.LENGTH_LONG).show());
  7. }
  8.  
  9. @Override
  10. public void occurred(StanzaError error) {
  11. 	String errorText = actionDescription + " execution error: " +
  12. 			(error.getText() == null ? error.toString() error.getText().getText());
  13. 	remotingErrorOccurred(activity, error, errorText);
  14. }
  15.  
  16. @Override
  17. public void timeout() {
  18. 	activity.runOnUiThread(() -> Toast.makeText(activity,
  19. 			actionDescription + " execution timeout.",
  20. 			Toast.LENGTH_LONG).show());
  21. }
  22. ... ...




如果想了解sand-demo App更多细节，请参考开源仓库里的sand-demo App程序源码



将构建好或直接下载的sand-demo App安装到安卓手机上。



启动sand-demo App。点击配置传输通道链接，进入stream配置页面。

 





在传输通道配置页里，填写Granite XMPP Server的正确地址。

 





配置好传输通道后，回到登录页，使用sand-demo用户名来登录App。用户密码也是"sand-demo"。



登录后，可以看到注册成功后hello-actuator-thing。点击“控制这个智能物件”，会看到下拉菜单里，有Flash，Turn On，Turn Off三个子菜单。

 





现在可以用手机App来控制hello-actuator-thing了。


 

10 总结

通过这篇教程，我们可以了解到以下的内容：

  • 我们可以通过IoT硬件板上的GPIO接口，来控制IoT设备的外接硬件模块。
     
  • 开源的Pi4J库，可以帮助我们使用Java语言来访问树莓派上的GPIO接口。
     
  • 在IoT的世界里，有不同的通讯协议可以选择。在互联网端，XMPP协议是一个很好的选择。
     
  • 如果使用Lithosphere，基于OXM(Object/XMPP Mapping)技术，我们不需要去处理XML，也不需要了解XMPP协议的细节。我们简单的创建Protocol Object来表达通讯指令。
     
  • Lithosphere基于插件架构，我们可以通过创建服务器端插件，将我们要管理的IoT设备注册到系统中。我们还可以定制设备注册过程，以应对真实项目的需求。
     
  • 在IoT设备端，我们开发Thing程序。使用Sand的sand-client-edge库，可以简化设备注册，服务器连接过程。我们只要注册需要使用的插件，编写Thing端处理逻辑。
     
  • 对于Actuator（执行器）类型的IoT设备，我们使用actuator插件来简化开发。我们登记设备可执行的指令，并且注册指令所对应的Executor（执行器）。
     
  • 我们在手机App端，使用remoting插件来远程执行指令，遥控IoT设备。
     
  • 这篇教程里的内容，全部基于Java平台，只有Java，不涉及其它编程语言。
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/349541
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号