developer
/
xiuos
forked from xuos/xiuos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add e18 of zigbee connection

This commit is contained in:
Wang_Weigen 2021-09-24 15:22:19 +08:00
parent d14ec3cb12
commit 6be676af78
12 changed files with 712 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
APP_Framework/Applications/framework_init.c
View File

@ -18,6 +18,7 @@ extern int AdapterFrameworkInit(void);
extern int Adapter4GInit(void);
extern int AdapterWifiInit(void);
extern int AdapterZigbeeInit(void);
extern int D124VoiceInit(void);
extern int Hs300xTemperatureInit(void);
@ -92,6 +93,9 @@ static struct InitDesc connection_desc[] =
#ifdef ADAPTER_4G
{ "4G adpter", Adapter4GInit},
#endif
#ifdef CONNECTION_ADAPTER_ZIGBEE
{ "zigbee adpter", AdapterZigbeeInit},
#endif
#ifdef ADAPTER_WIFI
{ "Wifi adpter", AdapterWifiInit},
#endif

2
APP_Framework/Framework/connection/Makefile
View File

@ -24,7 +24,7 @@ ifeq ($(CONFIG_ADAPTER_BLUETOOTH),y)
SRC_DIR += bluetooth
endif
ifeq ($(CONFIG_ADAPTER_ZIGBEE),y)
ifeq ($(CONFIG_CONNECTION_ADAPTER_ZIGBEE),y)
SRC_DIR += zigbee
endif

6
APP_Framework/Framework/connection/adapter.h
View File

@ -90,6 +90,9 @@ enum NetRoleType
SERVER,
MASTER,
SLAVE,
COORDINATOR,
ROUTER,
END_DEVICE,
ROLE_NONE,
};
@ -112,6 +115,7 @@ struct AdapterProductInfo
uint32_t functions;
const char *vendor_name;
const char *model_name;
uint32_t work_mode;
void *model_done;
};
@ -154,7 +158,7 @@ struct PrivProtocolDone
struct Adapter
{
char *name;
char name[32];
int fd;
int product_info_flag;

48
APP_Framework/Framework/connection/zigbee/E18/Kconfig
View File

@ -0,0 +1,48 @@
config ADAPTER_ZIGBEE_E18
string "E18 adapter name"
default "e18"
choice
prompt "E18 adapter select net role type "
default AS_END_DEVICE_ROLE
config AS_COORDINATOR_ROLE
bool "config as a coordinator"
config AS_ROUTER_ROLE
bool "config as a router"
config AS_END_DEVICE_ROLE
bool "config as an end device"
endchoice
if ADD_XIUOS_FETURES
config ADAPTER_E18_DRIVER_EXTUART
bool "Using extra uart to support zigbee"
default n
config ADAPTER_E18_DRIVER
string "E18 device uart driver path"
default "/dev/uart2_dev2"
depends on !ADAPTER_E18_DRIVER_EXTUART
if ADAPTER_E18_DRIVER_EXTUART
config ADAPTER_E18_DRIVER
string "E18 device extra uart driver path"
default "/dev/extuart_dev0"
config ADAPTER_E18_DRIVER_EXT_PORT
int "if E18 device using extuart, choose port"
default "0"
endif
endif
if ADD_NUTTX_FETURES
endif
if ADD_RTTHREAD_FETURES
endif

3
APP_Framework/Framework/connection/zigbee/E18/Makefile
View File

@ -0,0 +1,3 @@
SRC_FILES := e18.c
include $(KERNEL_ROOT)/compiler.mk

456
APP_Framework/Framework/connection/zigbee/E18/e18.c
View File

@ -0,0 +1,456 @@
/*
* Copyright (c) 2020 AIIT XUOS Lab
* XiUOS is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
/**
* @file e18.c
* @brief Implement the connection zigbee adapter function, using E18 device
* @version 1.1
* @author AIIT XUOS Lab
* @date 2021.09.15
*/
#include <adapter.h>
#include <at_agent.h>
#include "../adapter_zigbee.h"
#include "e18.h"
char *cmd_hex2at = "+++";
char *cmd_exit = "AT+EXIT";
char *cmd_ask_panid = "AT+PANID=?";
char *cmd_set_panid = "AT+PANID=A1B2";
char *cmd_ask_mode = "AT+MODE=?";
char *cmd_mode_as_tt = "AT+MODE=1"; /*mode 1:transparent transmission*/
char *cmd_mode_as_stt = "AT+MODE=2"; /*mode 2:Semi transparent transmission*/
char *cmd_mode_as_protocol = "AT+MODE=3"; /*mode 3:Protocol mode*/
char *cmd_ask_role = "AT+DEV=?";
char *cmd_role_as_c = "AT+DEV=C"; /*set device type for coordinater*/
char *cmd_role_as_e = "AT+DEV=E"; /*set device type for end device*/
char *cmd_role_as_r = "AT+DEV=R"; /*set device type for router*/
char *cmd_set_ch = "AT+CH=11"; /*set channel as 11*/
static int E18UartOpen(struct Adapter *adapter)
{
if (NULL == adapter) {
return -1;
}
/* Open device in read-write mode */
adapter->fd = PrivOpen(ADAPTER_E18_DRIVER,O_RDWR);
if (adapter->fd < 0) {
printf("E18UartSetUp get serial %s fd error\n", ADAPTER_E18_DRIVER);
return -1;
}
/* set serial config, serial_baud_rate = 115200 */
struct SerialDataCfg cfg;
memset(&cfg, 0 ,sizeof(struct SerialDataCfg));
cfg.serial_baud_rate = BAUD_RATE_115200;
cfg.serial_data_bits = DATA_BITS_8;
cfg.serial_stop_bits = STOP_BITS_1;
cfg.serial_parity_mode = PARITY_NONE;
cfg.serial_bit_order = BIT_ORDER_LSB;
cfg.serial_invert_mode = NRZ_NORMAL;
cfg.serial_buffer_size = SERIAL_RB_BUFSZ;
/*aiit board use ch438, so it needs more serial configuration*/
#ifdef ADAPTER_E18_DRIVER_EXTUART
cfg.ext_uart_no = ADAPTER_E18_DRIVER_EXT_PORT;
cfg.port_configure = PORT_CFG_INIT;
#endif
struct PrivIoctlCfg ioctl_cfg;
ioctl_cfg.ioctl_driver_type = SERIAL_TYPE;
ioctl_cfg.args = &cfg;
PrivIoctl(adapter->fd, OPE_INT, &ioctl_cfg);
PrivTaskDelay(1000);
printf("Zigbee uart config ready\n");
return 0;
}
static int AtCmdConfigAndCheck(ATAgentType agent, char *cmd, char *check)
{
char *result = NULL;
if (NULL == agent || NULL == cmd || NULL == check ) {
return -1;
}
ATReplyType reply = CreateATReply(64);
if (NULL == reply) {
printf("%s %d at_create_resp failed!\n",__func__,__LINE__);
return -1;
}
ATOrderSend(agent, REPLY_TIME_OUT, reply, cmd);
PrivTaskDelay(3000);
result = GetReplyText(reply);
if (!result) {
printf("%s %n get reply failed.\n",__func__,__LINE__);
goto __exit;
}
if(0 != strncmp(result, check, strlen(check))) {
printf("%s %d check[%s] reply[%s] failed.\n",__func__,__LINE__,check,result);
goto __exit;
}
return 0;
__exit:
DeleteATReply(reply);
return -1;
}
static int E18NetworkModeConfig(struct Adapter *adapter)
{
int ret = 0;
if (NULL == adapter) {
return -1;
}
ret = AtCmdConfigAndCheck(adapter->agent, cmd_hex2at, "+OK");
if(ret < 0) {
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,cmd_hex2at);
ret = -1;
goto out;
}
switch (adapter->info->work_mode)
{
case TT_MODE1:
ret = AtCmdConfigAndCheck(adapter->agent, cmd_mode_as_tt, "+OK");
ret |= AtCmdConfigAndCheck(adapter->agent, cmd_ask_mode, "MODE=1");
if(ret < 0) {
printf("%s %d config net mode as transparent transmission failed!\n",__func__,__LINE__);
ret = -1;
goto out;
}
break;
case STT_MODE2:
ret = AtCmdConfigAndCheck(adapter->agent, cmd_mode_as_stt, "+OK");
ret |= AtCmdConfigAndCheck(adapter->agent, cmd_ask_mode, "MODE=2");
if(ret < 0) {
printf("%s %d config net mode as semi transparent transmission failed!\n",__func__,__LINE__);
ret = -1;
goto out;
}
break;
case PROTOCOL_MODE3:
ret = AtCmdConfigAndCheck(adapter->agent, cmd_mode_as_protocol, "+OK");
ret |= AtCmdConfigAndCheck(adapter->agent, cmd_ask_mode, "MODE=3");
if(ret < 0) {
printf("%s %d config net mode as protocol failed!\n",__func__,__LINE__);
ret = -1;
goto out;
}
break;
default :
ret = -1;
break;
}
if(!ret){
ret = AtCmdConfigAndCheck(adapter->agent, cmd_exit, "+OK");
if(ret < 0) {
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,cmd_exit);
ret = -1;
}
}
out:
return ret;
}
static int E18NetRoleConfig(struct Adapter *adapter)
{
int ret = 0;
if (NULL == adapter) {
printf("%s %d adapter is null!\n",__func__,__LINE__);
ret = -1;
goto out;
}
ret = AtCmdConfigAndCheck(adapter->agent, cmd_hex2at, "+OK");
if(ret < 0) {
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,cmd_hex2at);
ret = -1;
goto out;
}
switch (adapter->net_role)
{
case COORDINATOR:
ret = AtCmdConfigAndCheck(adapter->agent, cmd_role_as_c, "+OK");
ret |= AtCmdConfigAndCheck(adapter->agent, cmd_ask_role, "DEV=C");
if(ret < 0) {
printf("%s %d config net role as coordinator failed!\n",__func__,__LINE__);
ret = -1;
goto out;
}
break;
case ROUTER:
ret = AtCmdConfigAndCheck(adapter->agent, cmd_role_as_r, "+OK");
ret |= AtCmdConfigAndCheck(adapter->agent, cmd_role_as_r, "DEV=R");
if(ret < 0) {
printf("%s %d config net role as router failed!\n",__func__,__LINE__);
ret = -1;
goto out;
}
break;
case END_DEVICE:
ret = AtCmdConfigAndCheck(adapter->agent, cmd_role_as_e, "+OK");
ret |= AtCmdConfigAndCheck(adapter->agent, cmd_ask_role, "DEV=E");
if(ret < 0) {
printf("%s %d config net role as device failed!\n",__func__,__LINE__);
ret = -1;
goto out;
}
break;
default :
ret = -1;
break;
}
if(!ret){
ret = AtCmdConfigAndCheck(adapter->agent, cmd_exit, "+OK");
if(ret < 0) {
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,cmd_exit);
ret = -1;
}
}
out:
return ret;
}
static int E18Open(struct Adapter *adapter)
{
int ret = 0;
if (NULL == adapter) {
return -1;
}
/*step1: open e18 serial port*/
ret = E18UartOpen(adapter);
if (ret < 0) {
printf("e18 setup failed.\n");
return -1;
}
/*step2: init AT agent*/
if (!adapter->agent) {
char *agent_name = "zigbee_device";
if (EOK != InitATAgent(agent_name, adapter->fd, 512)) {
printf("at agent init failed !\n");
return -1;
}
ATAgentType at_agent = GetATAgent(agent_name);
adapter->agent = at_agent;
}
ret = E18NetRoleConfig(adapter);
if(ret < 0){
printf("E18NetRoleConfig failed\n");
return -1;
}
printf("Zigbee E18 open successful\n");
return 0;
}
static int E18Close(struct Adapter *adapter)
{
PrivClose(adapter->fd);
return 0;
}
static int E18Ioctl(struct Adapter *adapter, int cmd, void *args)
{
int ret = 0;
switch (cmd)
{
case CONFIG_ZIGBEE_NET_ROLE: /* config E18 net role */
ret = E18NetRoleConfig(adapter);
break;
case CONFIG_ZIGBEE_NET_MODE: /* config E18 network mode */
ret = E18NetworkModeConfig(adapter);
break;
default:
ret = -1;
break;
}
return ret;
}
static int E18Join(struct Adapter *adapter, const char *priv_net_group)
{
int ret = 0;
ret = AtCmdConfigAndCheck(adapter->agent, cmd_hex2at, "+OK");
if(ret < 0) {
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,cmd_hex2at);
ret = -1;
goto out;
}
switch (adapter->net_role)
{
case COORDINATOR:
case ROUTER:
case END_DEVICE:
/* config panid */
ret = AtCmdConfigAndCheck(adapter->agent, cmd_set_panid, "+OK");
ret |= AtCmdConfigAndCheck(adapter->agent, cmd_ask_panid, "PANID=A1B2");
if(ret < 0) {
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,cmd_set_panid);
ret = -1;
goto out;
}
/* config channel*/
ret = AtCmdConfigAndCheck(adapter->agent, cmd_set_ch, "+OK");
if(ret < 0) {
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,cmd_set_ch);
ret = -1;
goto out;
}
break;
default :
ret = -1;
break;
}
// switch (adapter->info->work_mode)
// {
// case TT_MODE1:
// break;
// case STT_MODE2:
// /* need to do */
// ret = 0;
// break;
// case PROTOCOL_MODE3:
// /* need to do */
// ret = 0;
// break;
// default:
// ret = -1;
// break;
// }
if(!ret){
ret = AtCmdConfigAndCheck(adapter->agent, cmd_exit, "+OK");
if(ret < 0) {
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,cmd_exit);
ret = -1;
}
}
out:
return ret;
}
static int E18Send(struct Adapter *adapter, const void *buf, size_t len)
{
int ret = 0;
switch (adapter->info->work_mode)
{
case TT_MODE1:
PrivWrite(adapter->fd, buf, len);
break;
case STT_MODE2:
/* need to do */
ret = 0;
break;
case PROTOCOL_MODE3:
/* need to do */
ret = 0;
break;
default:
ret = -1;
break;
}
return 0;
}
static int E18Recv(struct Adapter *adapter, void *buf, size_t len)
{
int ret = 0;
switch (adapter->info->work_mode)
{
case TT_MODE1:
if(!adapter->agent){
PrivRead(adapter->fd, buf, len);
} else {
// while(1){
if(adapter->agent->temp_recv_len > 0){
memcpy(buf,adapter->agent->temp_recv_buf,adapter->agent->temp_recv_len);
break;
}
// }
}
break;
case STT_MODE2:
/* need to do */
ret = 0;
break;
case PROTOCOL_MODE3:
/* need to do */
ret = 0;
break;
default:
ret = -1;
break;
}
return 0;
}
static int E18Quit(struct Adapter *adapter)
{
return 0;
}
static const struct PrivProtocolDone E18_done =
{
.open = E18Open,
.close = E18Close,
.ioctl = E18Ioctl,
.setup = NULL,
.setdown = NULL,
.setaddr = NULL,
.setdns = NULL,
.setdhcp = NULL,
.ping = NULL,
.netstat = NULL,
.join = E18Join,
.send = E18Send,
.recv = E18Recv,
.quit = E18Quit,
};
AdapterProductInfoType E18Attach(struct Adapter *adapter)
{
struct AdapterProductInfo *product_info = malloc(sizeof(struct AdapterProductInfo));
if (!product_info) {
printf("E18Attach malloc product_info error\n");
return NULL;
}
product_info->model_name = ADAPTER_ZIGBEE_E18;
product_info->model_done = (void *)&E18_done;
return product_info;
}

12
APP_Framework/Framework/connection/zigbee/E18/e18.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef E18_H
#define E18_H
enum ZigbeeE18WorkModeType
{
TT_MODE1 = 1,
STT_MODE2,
PROTOCOL_MODE3,
MODE_NONE,
};
#endif

10
APP_Framework/Framework/connection/zigbee/Kconfig
View File

@ -0,0 +1,10 @@
if CONNECTION_ADAPTER_ZIGBEE
config ADAPTER_E18
bool "Using zigbee adapter device E18"
default y
if ADAPTER_E18
source "$APP_DIR/Framework/connection/zigbee/E18/Kconfig"
endif
endif

4
APP_Framework/Framework/connection/zigbee/Makefile
View File

@ -1,3 +1,7 @@
SRC_FILES := adapter_zigbee.c
ifeq ($(CONFIG_ADAPTER_E18),y)
SRC_DIR += E18
endif
include $(KERNEL_ROOT)/compiler.mk

160
APP_Framework/Framework/connection/zigbee/adapter_zigbee.c
View File

@ -15,5 +15,163 @@
* @brief Implement the connection zigbee adapter function
* @version 1.1
* @author AIIT XUOS Lab
* @date 2021.06.25
* @date 2021.09.15
*/
#include <adapter.h>
#include "adapter_zigbee.h"
#ifdef ADAPTER_E18
extern AdapterProductInfoType E18Attach(struct Adapter *adapter);
#endif
#define ADAPTER_ZIGBEE_NAME "zigbee"
static int AdapterZigbeeRegister(struct Adapter *adapter)
{
int ret = 0;
strncpy(adapter->name, ADAPTER_ZIGBEE_NAME, NAME_NUM_MAX);
/* config adapter net protocol as network mode */
adapter->net_protocol = PRIVATE_PROTOCOL;
/* config adapter net role as coordinator/router/end_device */
#ifdef AS_COORDINATOR_ROLE
adapter->net_role = COORDINATOR;
#endif
#ifdef AS_ROUTER_ROLE
adapter->net_role = ROUTER;
#endif
#ifdef AS_END_DEVICE_ROLE
adapter->net_role = END_DEVICE;
#endif
adapter->adapter_status = UNREGISTERED;
ret = AdapterDeviceRegister(adapter);
if (ret < 0) {
printf("AdapterZigbee register error\n");
return -1;
}
return ret;
}
int AdapterZigbeeInit(void)
{
int ret = 0;
struct Adapter *adapter = malloc(sizeof(struct Adapter));
if (!adapter) {
printf("malloc adapter failed.\n");
return -1;
}
memset(adapter, 0, sizeof(struct Adapter));
ret = AdapterZigbeeRegister(adapter);
if (ret < 0) {
printf("AdapterZigbeeRegister register zigbee adapter error\n");
free(adapter);
return -1;
}
#ifdef ADAPTER_E18
AdapterProductInfoType product_info = E18Attach(adapter);
if (!product_info) {
printf("AdapterZigbeeRegister e18 attach error\n");
free(adapter);
return -1;
}
adapter->product_info_flag = 1;
adapter->info = product_info;
adapter->done = product_info->model_done;
#endif
return ret;
}
/******************4G TEST*********************/
int openzigbee(void)
{
const char *send_msg = "SendHeart";
char recv_msg[128];
int ret = 0;
struct Adapter* adapter = AdapterDeviceFindByName(ADAPTER_ZIGBEE_NAME);
#ifdef ADAPTER_E18
ret = AdapterDeviceOpen(adapter);
if(ret < 0){
printf("open adapter failed\n");
return -1;
}
adapter->info->work_mode = 1;
ret = AdapterDeviceControl(adapter, CONFIG_ZIGBEE_NET_MODE,NULL);
if(ret < 0){
printf("control adapter failed\n");
return -1;
}
ret = AdapterDeviceJoin(adapter, NULL);
if(ret < 0){
printf("join adapter failed\n");
return -1;
}
adapter->net_role = COORDINATOR;
ret = AdapterDeviceControl(adapter, CONFIG_ZIGBEE_NET_ROLE, NULL);
if(ret < 0){
printf("control adapter failed\n");
return -1;
}
// while (1) {
// ret = AdapterDeviceSend(adapter, send_msg, strlen(send_msg));
// if(ret < 0){
// printf(" adapter send failed\n");
// break;
// }
// printf("zigbee send msg %s\n", send_msg);
// AdapterDeviceRecv(adapter, recv_msg, 128);
// printf("zigbee recv msg %s\n", recv_msg);
// }
#endif
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_PARAM_NUM(0)|SHELL_CMD_DISABLE_RETURN, openzigbee, openzigbee, show adapter zigbee information);
int sendzigbee(int argc, char *argv[])
{
const char *send_msg = argv[1];
int ret = 0;
struct Adapter* adapter = AdapterDeviceFindByName(ADAPTER_ZIGBEE_NAME);
printf("send argv1 %s\n",argv[1]);
ret = AdapterDeviceSend(adapter, send_msg, strlen(send_msg));
if(ret < 0){
printf(" adapter send failed\n");
return -1;
}
printf("zigbee send msg %s\n", send_msg);
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN)|SHELL_CMD_PARAM_NUM(2)|SHELL_CMD_DISABLE_RETURN, sendzigbee, sendzigbee, show adapter zigbee information);
int recvzigbee(void)
{
char recv_msg[128];
struct Adapter* adapter = AdapterDeviceFindByName(ADAPTER_ZIGBEE_NAME);
memset(recv_msg,0,128);
AdapterDeviceRecv(adapter, recv_msg, 128);
PrivTaskDelay(2000);
printf("zigbee recv msg %s\n", recv_msg);
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_FUNC)|SHELL_CMD_PARAM_NUM(0)|SHELL_CMD_DISABLE_RETURN, recvzigbee, recvzigbee, show adapter zigbee information);

9
APP_Framework/Framework/connection/zigbee/adapter_zigbee.h Normal file
View File

@ -0,0 +1,9 @@
#ifndef ADAPTER_ZIGBEE_H
#define ADAPTER_ZIGBEE_H
#define CONFIG_ZIGBEE_NET_ROLE (1)
#define CONFIG_ZIGBEE_NET_MODE (2)
#endif

1
Ubiquitous/XiUOS/path_kernel.mk
View File

@ -188,6 +188,7 @@ endif
ifeq ($(CONFIG_SUPPORT_CONNECTION_FRAMEWORK), y)
KERNELPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/connection #
KERNELPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/connection/zigbee #
endif
ifeq ($(CONFIG_SUPPORT_KNOWING_FRAMEWORK), y)