Back to All
Project

QCA4020 Zigbee Lamp

Created by
Thunder Software Technology (Shenzhen) Co., Ltd.
Nov 1, 2018

Skill Level Area of Focus Operating System Platform/Hardware Cloud Services/Platform
Intermediate IoT, Smart Home RTOS QCA 402x WiFi/BLE/ZigBee Microsoft Azure IoT

This project is designed to use the QCA4020 development kit to control the Sengled Zigbee bulb using an Android mobile phone and demonstrates Home Automation. You can control the bulb, turn it on/off, change the color temperature and dim via the app ”Home_Console”.

Objective

The main objective of this demo is to create intelligent lighting using the QCA4020 development kit. This is done by using an application on the mobile phone, running Android O, to connect to the QCA4020 via Zigbee and control the Sengled bulb.

Materials Required / Parts List / Tools

Source Code / Source Examples / Application Executable

Build / Assembly Instructions

Parts used

Below are the items used in this project.

Parts
  1. Mobile Phone with Android O operating system.
  2. QCA4020 development board
  3. Zigbee Lamp
  4. Transformer/power supply to turn on the Zigbee Lamp.

Deploying the project

  1. Download code from the github repository.
  2. Compile the code and flash the image as described in “QCLI_demo with QCA4020 Development Kit” project.
  3. Install the application found in the Github repository on the Android phone.

How does it work?

The QCA4020 development board is designed to control the on/off status, color temperature and intensity of the bulb via Zigbee protocol. The sections below will show you how the various controls and interfaces in this demo have been implemented, and how the QCA4020 development kit can control the bulb via these interfaces.

Initialize Zigbee protocol and build Zigbee network.
Global variable "flag_form" is used to judge whether the Zigbee network is successful or not. Add the following code to the file

“/quartz/demo/QCLI_demo/src/qcli/pal.c”

int flag_form = 0;
void init_Zigbee()
{
d_cmd_ZB_Initialize(0,NULL);
QCLI_Parameter_t param_setBIB[4];
param_setBIB[0].Integer_Value = 0x100f;
param_setBIB[0].Integer_Is_Valid = true;
param_setBIB[1].Integer_Value = 1;
param_setBIB[1].Integer_Is_Valid = true;
param_setBIB[2].Integer_Value = 4;
param_setBIB[2].Integer_Is_Valid = true;
param_setBIB[3].Integer_Value = 0;
param_setBIB[3].Integer_Is_Valid = true;
d_cmd_ZB_SetBIB(4, param_setBIB);
QCLI_Parameter_t param_CE[2];
param_CE[0].Integer_Value = 1;
param_CE[0].Integer_Is_Valid = true;
param_CE[1].Integer_Value = 6;
param_CE[1].Integer_Is_Valid = true;
d_cmd_ZB_CL_CreateEndpoint(2, param_CE);
QCLI_Parameter_t param_form[1];
param_form[0].Integer_Value = 1;
param_form[0].Integer_Is_Valid = true;
d_cmd_ZB_Form(1, param_form);
while(true)
{
if(flag_form == 1)
{
zigbee_printf("Form Zigbee network success!");
break;
}
qurt_thread_sleep(50);
zigbee_printf("wait for forming Zigbee network!");
}
}

 

Zigbee devices connection

The function "Connect_ZigbeeDevice()" is to wait for connection of Zigbee bulb, "flag_connect" is used to judge whether the bulb joins into the network successfully or not. Add the following code to the file “/quartz/demo/QCLI_demo/src/qcli/pal.c”.


int flag_connect = 0;
void Connect_ZigbeeDevice()
{
while(true)
{
if(flag_connect == 1)
{
zigbee_printf("Device join success!");
break;
}
qurt_thread_sleep(50);
zigbee_printf("wait that blub join in Zigbee network!");
}
}

 

Building the Zigbee network

"flag_form" is set to 1 after the network architecture is built successfully.
Add the following code to the file “/quartz/demo/QCLI_demo/src/ zigbee/zigbee_demo.c”.


extern int flag_form;
static void ZB_Event_CB()
{
          flag_form = 1;
}

 

Zigbee network devices connection

We can set "flag_form" to 1 after the devices connect successfully.

Add the following code to the file “/quartz/demo/QCLI_demo/src/zigbee/zdp_demo.c”.

extern int flag_connect;
static void ZB_ZDP_Event_CB(qapi_ZB_Handle_t ZB_Handle, const qapi_ZB_ZDP_Event_t *ZDP_Event_Data, uint32_t CB_Param)
{
QCLI_Parameter_t param[3];
param[0].Integer_Value = 2;
param[0].Integer_Is_Valid = true;
param[1].Integer_Value = ZDP_Event_Data?
Event_Data.Device_Annce.NwkAddr;
device_addr = ZDP_Event_Data?
Event_Data.Device_Annce.NwkAddr;
QCLI_Printf(ZDP_Demo_Context.QCLI_Handle, NetworkAddress: %d\n", ZDP_Event_Data?Event_Data.Device_Annce.NwkAddr);
param[1].Integer_Is_Valid = true;
param[2].Integer_Value = 1;
param[2].Integer_Is_Valid = true;
d_cmd_ZB_AddDevice(3, param);
flag_connect = 1;
}

 

Turning the Zigbee bulb on/off

Add the function "Control_ZigbeeLightOnOff" to turn the bulb on/off in the file “/quartz/demo/QCLI_demo/src/qcli/pal.c”.


int Control_ZigbeeLightOnOff(int on)
{
if(on > 1)
{
QCLI_Parameter_t param_on[2];
param_on[0].Integer_Value = 1;
param_on[0].Integer_Is_Valid = true;
param_on[1].Integer_Value = 1;
param_on[1].Integer_Is_Valid = true;
d_cmd_ZCL_OnOff_On(2, param_on);
}
else{
QCLI_Parameter_t param_off[2];
param_off[0].Integer_Value = 1;
param_off[0].Integer_Is_Valid = true;
param_off[1].Integer_Value = 1;
param_off[1].Integer_Is_Valid = true;
d_cmd_ZCL_OnOff_Off(2, param_off);
}
return 0;
}

 

Adjust the intensity of the light bulb

To dim the light bulb, add the function "Control_ZigbeeLightLevel" to the file “/quartz/demo/QCLI_demo/src/qcli/pal.c”.


int Control_ZigbeeLightLevel(int level)
{
QCLI_Parameter_t param_level[5];
param_level[0].Integer_Value = 1;
param_level[0].Integer_Is_Valid = true;
param_level[1].Integer_Value = 1;
param_level[1].Integer_Is_Valid = true;
param_level[2].Integer_Value = 1;
param_level[2].Integer_Is_Valid = true;
param_level[3].Integer_Value = level;
param_level[3].Integer_Is_Valid = true;
param_level[4].Integer_Value = 5;
param_level[4].Integer_Is_Valid = true;
d_cmd_ZCL_LevelControl_MoveToLevel(5, param_level);
return 0;
}

 

Adjust color temperature of the light bulb

To control the color temperature of the bulb, add the function "Control_ZigbeeColorTemperature" to the file “/quartz/demo/QCLI_demo/src/qcli/pal.c”.


int Control_ZigbeeColorTemperaturn(int temp)
{
QCLI_Parameter_t param_temp[4];
param_temp[0].Integer_Value = 1;
param_temp[0].Integer_Is_Valid = true;
param_temp[1].Integer_Value = 1;
param_temp[1].Integer_Is_Valid = true;
param_temp[2].Integer_Value = temp;
param_temp[2].Integer_Is_Valid = true;
param_temp[3].Integer_Value = 5;
param_temp[3].Integer_Is_Valid = true;
d_cmd_ZCL_ColorControl_MoveToColorTemp(4, param_temp);
return 0;
}

 

Saving Internet address of bulb

Here is how to save the network address of the bulb, the code is located in the file "/quartz/demo/QCLI_demo/src/zigbee/zigbee_demo.c".


uint64_t device_addr = 0;
static QCLI_Command_Status_t cmd_ZB_AddDevice(uint32_t Parameter_Count,QCLI_Parameter_t *Parameter_List)
{
(Verify_Integer_Parameter(&Parameter_List[0], QAPI_ZB_ADDRESS_MODE_GROUP_ADDRESS_E, QAPI_ZB_ADDRESS_MODE_EXTENDED_ADDRESS_E)) &&
(Hex_String_To_ULL(Parameter_List[1].String_Value, &DevAddr)))
(Verify_Integer_Parameter(&Parameter_List[0], QAPI_ZB_ADDRESS_MODE_GROUP_ADDRESS_E,API_ZB_ADDRESS_MODE_EXTENDED_ADDRESS_E))/*&&(Hex_String_To_ULL(Parameter_List[1].String_Value, &DevAddr))*/)
{
 DevAddr = device_addr;   
 }
}

 

Function encapsulation

Finally, we need to do function encapsulation process. The code related to color temperature is located in the file "/quartz/demo/QCLI_demo/src/zigbee/clusters/zcl_colorcontrol_demo.c".


QCLI_Command_Status_t d_cmd_ZCL_ColorControl_MoveToColorTemp(uint32_t Parameter_Count, QCLI_Parameter_t *Parameter_List);
QCLI_Command_Status_t d_cmd_ZCL_ColorControl_MoveToColorTemp(uint32_t Parameter_Count, QCLI_Parameter_t *Parameter_List)
{
return cmd_ZCL_ColorControl_MoveToColorTemp(Parameter_Count, Parameter_List);
}

The code related to level control is located in the file "/quartz/demo/QCLI_demo/src/zigbee/clusters/zcl_levelcontrol_demo.c".


QCLI_Command_Status_t d_cmd_ZCL_LevelControl_MoveToLevel(uint32_t Parameter_Count, QCLI_Parameter_t *Parameter_List);
QCLI_Command_Status_t d_cmd_ZCL_LevelControl_MoveToLevel(uint32_t Parameter_Count, QCLI_Parameter_t *Parameter_List)
{
return cmd_ZCL_LevelControl_MoveToLevel(Parameter_Count, Parameter_List);
}
param_temp[3].Integer_Is_Valid = true;
d_cmd_ZCL_ColorControl_MoveToColorTemp(4, param_temp);
return 0;

The code related to color on or off status is located in the file "/quartz/demo/QCLI_demo/src/zigbee/clusters/zcl_onoff_demo.c"


QCLI_Command_Status_td_cmd_ZCL_OnOff_On(uint32_tParameter_Count, QCLI_Parameter_t *Parameter_List);
QCLI_Command_Status_td_cmd_ZCL_OnOff_Off(uint32_tParameter_Count, QCLI_Parameter_t *Parameter_List);
QCLI_Command_Status_td_cmd_ZCL_OnOff_On(uint32_tParameter_Count, QCLI_Parameter_t *Parameter_List)
{
 
return cmd_ZCL_OnOff_On(Parameter_Count, Parameter_List);
}
QCLI_Command_Status_td_cmd_ZCL_OnOff_Off(uint32_tParameter_Count, QCLI_Parameter_t *Parameter_List)
{
return cmd_ZCL_OnOff_Off(Parameter_Count, Parameter_List);
}

The code related to endpoint creation is located at "/quartz/demo/QCLI_demo/src/zigbee/zcl_demo.c".


QCLI_Command_Status_t d_cmd_ZB_CL_CreateEndpoint(uint32_t Parameter_Count, QCLI_Parameter_t *Parameter_List);
QCLI_Command_Status_t d_cmd_ZB_CL_CreateEndpoint(uint32_t Parameter_Count, QCLI_Parameter_t *Parameter_List)
{
return cmd_ZB_CL_CreateEndpoint(Parameter_Count, Parameter_List);
}

Encapsulate below functions "d_cmd_ZB_AddDevice", “d_cmd_ZB_AddDevice", "d_cmd_ZB_SetBIB", "d_cmd_ZB_Initialize".


QCLI_Command_Status_t d_cmd_ZB_AddDevice(uint32_t Parameter_Count, QCLI_Parameter_t *Parameter_List);
QCLI_Command_Status_t d_cmd_ZB_AddDevice(uint32_t Parameter_Count, QCLI_Parameter_t *Parameter_List);
QCLI_Command_Status_t d_cmd_ZB_SetBIB(uint32_t Parameter_Count, QCLI_Parameter_t *Parameter_List);
QCLI_Command_Status_t d_cmd_ZB_Initialize(uint32_t Parameter_Count,
QCLI_Parameter_t *Parameter_List);
QCLI_Command_Status_t d_cmd_ZB_Initialize(uint32_t Parameter_Count,
QCLI_Parameter_t *Parameter_List)
{
return cmd_ZB_Initialize(Parameter_Count, Parameter_List);
}
QCLI_Command_Status_t d_cmd_ZB_AddDevice(uint32_t Parameter_Count, QCLI_Parameter_t *Parameter_List)
{
return cmd_ZB_AddDevice(Parameter_Count, Parameter_List);
}
QCLI_Command_Status_t d_cmd_ZB_Form(uint32_t Parameter_Count, QCLI_Parameter_t *Parameter_List)
{
return cmd_ZB_Form(Parameter_Count, Parameter_List);
}
QCLI_Command_Status_t d_cmd_ZB_SetBIB(uint32_t Parameter_Count, QCLI_Parameter_t *Parameter_List)
{
return cmd_ZB_SetBIB(Parameter_Count, Parameter_List);
}

Now that you understand how controlling the light bulb is implemented in the project, below are some usage instructions to test the project.

Usage Instructions

  1. Power on the QCA4020 via the power button, and the QCA4020 will build the Zigbee network automatically.
  2. Power on the Zigbee bulb, and it will join the Zigbee network automatically.
  3. Use the “Azure_console” app on the mobile phone to:
    1. Control on or off status of bulb via clicking “Open” or “Close” button
    2. Control color temperature via setting the values ranged from “0x0000~0xFFFF”
    3. Control dim via setting the values ranged from “0~255”

Opinions expressed in the content posted here are the personal opinions of the original authors, and do not necessarily reflect those of Qualcomm Incorporated or its subsidiaries ("Qualcomm"). The content is provided for informational purposes only and is not meant to be an endorsement or representation by Qualcomm or any other party. This site may also provide links or references to non-Qualcomm sites and resources. Qualcomm makes no representations, warranties, or other commitments whatsoever about any non-Qualcomm sites or third-party resources that may be referenced, accessible from, or linked to this site.

Project Authors
Thunder Software Technology (Shenzhen) Co., Ltd.
Shenzhen
Scott
Yang
Jay
Related Projects

Sign up for the Developer Newsletter.

Get software and hardware tool resources to help optimize your development delivered to your inbox weekly.

Qualcomm relentlessly innovates to deliver intelligent computing everywhere, helping the world tackle some of its most important challenges. Our leading-edge AI, high performance, low-power computing, and unrivaled connectivity deliver proven solutions that transform major industries. At Qualcomm, we are engineering human progress.

Stay connected

Get the latest Qualcomm and industry information delivered to your inbox.

Subscribe
Manage your subscription
Also of Interest

© Qualcomm Technologies, Inc. and/or its affiliated companies.

Snapdragon and Qualcomm branded products are products of Qualcomm Technologies, Inc. and/or its subsidiaries. Qualcomm patented technologies are licensed by Qualcomm Incorporated.

Note: Certain services and materials may require you to accept additional terms and conditions before accessing or using those items.

References to "Qualcomm" may mean Qualcomm Incorporated, or subsidiaries or business units within the Qualcomm corporate structure, as applicable.

Qualcomm Incorporated includes our licensing business, QTL, and the vast majority of our patent portfolio. Qualcomm Technologies, Inc., a subsidiary of Qualcomm Incorporated, operates, along with its subsidiaries, substantially all of our engineering, research and development functions, and substantially all of our products and services businesses, including our QCT semiconductor business.

Materials that are as of a specific date, including but not limited to press releases, presentations, blog posts and webcasts, may have been superseded by subsequent events or disclosures.

Nothing in these materials is an offer to sell or license any of the services or materials referenced herein.