[参考译文] CCS/CC3220SF-LAUNCHXL：密码和 Usernam Watson IOT

尊敬的 Chris：

您是否根据我在链接线程中所做的所有要点检查了代码？ 您无法成功连接到 IBM Watson IoT 的原因有很多、将客户端配置与服务器的期望相匹配至关重要。

此外、您能否从插件中发布对 IBM Watson 示例所做的所有修改？ 插件示例应能够连接到您的自定义 IBM Watson 组织、前提是您添加了正确的服务器地址、客户端 ID 和密码。

如果您查看设备云中保存的日志、IBM 是否会看到您的连接尝试？ 如果是、它是否提到断开原因？

此致、
Michael

我确保在应用程序中设置的器件是网关、因此在开始时具有"g"是正确的。 下面是一些屏幕截图：

它似乎没有尝试连接。 我确实知道、它应该与防火墙无关、因为当我运行快速启动示例时、它可以正常工作。

尊敬的 Chris：

查看您所做的修改、我看到恒温器的器件类型在 IBM 云端为"CC32220"。 这意味着您应该调整代码中使用的客户端 ID 以使用该设备类型、而不是您当前拥有的"CC3220"。 您可以更正此问题并重试吗？

此致、
Michael

我修复了 IBM 端的名称、现在它显示为"CC3220"、我收到了相同的错误

有什么关于解决办法的想法吗？

尊敬的 Chris：

您是否尝试使用 TLS 或不使用 TLS 连接到 IBM 云上的组织？

如果您不使用 TLS、则需要更改组织的安全设置、以便 TLS 为可选。 默认情况下、从器件到 IBM Watson IoT 的所有连接都需要 TLS。

如果您使用 TLS、那么您是否修改了 MQTTClient_ConnParams、以便提供所需的根 CA 证书？ 该结构是什么样子的？

此致、

Michael

我正在使用 TLS、因此我必须编辑我的 connParams。 但是、我不确定如何编辑结构以确保 TLS 已启用。 这是否仅涉及在结构中添加"SLNETSOCK_SEC_METHOD_SSLv3_TLSv1_2"？

尊敬的 Chris：

首先、尝试在 IBM 中将 TLS 设置为可选、并使用默认 MQTT_ClientCtx 进行连接。 这将确保其余设置(如 clientID、服务器地址等)都正确无误。 如果这不起作用、则您的代码中存在其他问题、我们需要首先解决这些问题。

要获得正确的安全 MQTT_ClientCtx、只需取消注释 MQTT_CLIENT_APP.C 顶部的#define SECURE_CLIENT 这将选择其他上下文、该上下文应该已经具有正确的 IBM 设置。 在您的终端上、您唯一需要做的就是提供验证 IBM Watson IoT 服务器证书所需的 ca-cert.pem 文件。 您可以按照链接的帖子中的说明来识别、获取和刷写所需的证书：
e2e.ti.com/.../2531683
e2e.ti.com/.../2478357

此致、
Michael

您好、Michael、

我在闪烁时遇到问题、或者至少我认为我是。 要使用 uniflash 将新的 ca-root-cert 刷写到电路板上、我需要使用 MCU 映像、还是可以将其留空？ 如果我确实需要 MCU 映像、如果我使用的是 Code Composer Studio Cloud 版本、在哪里可以找到它？

我在没有 MCU img 的情况下继续并刷写它、然后运行代码、现在我收到一个新的错误代码：

您好、Christopher、

您可以将 uniflash 项目刷写到 CC3220中、而无需 MCU 映像。 这不应该是您看到的问题的根源。

您看到的错误很可能是由于您使用的证书文件不正确，而不是 IBM 服务器证书链的根 CA。 您是否添加了我在这篇文章 e2e.ti.com/.../2531683中提供的代码
要处理 NWP 发出的 sl_SSL_notification_wrong_root_CA 通知？

此致、
Michael

我尝试添加代码、但似乎更新后的 Watson_mqttclient 缺少器件、所以我最后只做了以下部分："UART_PRINT"("sl_socket_ASYNC_EVENT：错误-错误根 CA\n"r)；

        UART_PRINT ("请安装以下根证书：\n\n");

        UART_PRINT (" %s\n\r\n、pSock->SocketEvent.Sockdata.pExtraInfo)；

        SignalEvent (APP_EVENT_RESTART)；"

void SimpleLinkSockEventHandler (SlSockEvent_t * pSock)
｛
/*此应用程序不能与套接字一起工作-不需要事件 *
switch (pSock->Event)
｛
案例 sl_socket_TX_FAILED_EVENT：
交换机(pSock->Socket19观 Event.SockTxFailData.Status)
｛
案例 SL_ERROR_BSD_ECLOSE：
UART_PRINT (
"[sock error]-关闭套接字(%d)操作"
"未能传输所有排队的数据包\n\r"、
pSock->SocketAppoixEvent.SockTxFailData.SD)；
中断；
默认值：
UART_PRINT (
"[sock error]- TX 失败：套接字%d，"
"原因(%d)\n\n"、
pSock->SocketAppoixEvent.SockTxFailData.SD、
pSock->SocketAppoixEvent.SockTxFailData.Status)；
中断；
｝
中断；
案例 SL_SOCKET_ASYNC_EVENT：
｛
UART_PRINT ("[sock error]套接字%d\r\n"上收到事件、
pSock->SocketAppoed.Sock.Appoan3 Data.SD)；
switch (pSock->Socket003.Sock20数据类型)
｛
案例 SL_SSL_notification_connected 安全：
UART_PRINT ("[sock error] SSL 握手完成")；
中断；
案例 SL_SSL_notification_shake_failed：
UART_PRINT ("[sock error] SSL 握手失败、错误%d\r\n"、
pSock->SocketAppoed.Sock.Appoan3 Data.Val)；
中断；
案例 SL_SSL_ACCEPT：
UART_PRINT (
"[sock error]发生了可恢复的错误"
"在握手%d\r\n 期间"、
pSock->SocketAppoed.Sock.Appoan3 Data.Val)；
中断；
案例 sl_Other_Side _Close_SSL_DATA_not _encrypted：
UART_PRINT ("[sock error]其他对等设备终止了 SSL 层。\r\n)；
中断；
案例 SL_SSL_notification_wrong_root_CA：
UART_PRINT ("[sock error]使用了错误的 CA 来验证对等项。\r\n)；
UART_PRINT ("请安装以下根证书：\n\n");
UART_PRINT ("%s\n\r\n、pSock->SocketEvent.Sockdata.pExtraInfo)；
中断；
默认值：
中断；
｝
中断；
｝
默认值：
UART_PRINT ("[sock event]-意外事件[%x0x]\n\n"、pSock->Event)；
中断；
｝
｝ 

由于收到"sl_SSL_notification_shake_failed"错误、因此它仍然没有告诉我正确的根证书。

您好、Christopher、

我可以使用"DigiCert 全局根 CA"证书连接到我的 IBM Watson IoT 组织。 请按照此帖子中的说明将其从您的 PC 复制到文件中：
e2e.ti.com/.../2478357
然后、将其刷写到 CC3220中、并再次尝试运行您的程序。

此致、
Michael

您好、Michael、

使用 "DigiCert 全局根 CA"证书时、我仍然无法连接。 我按照您在上述主题上发布的说明进行了操作。 我将包括我的源代码以及 Uniflash 和 PuTTY 的屏幕截图、以便您可以检查我是否做了错误的操作。 此外、我还遇到了新的错误"-5"

//
// 本地定义
//*************
/*启用安全客户端 */
#define SECURE_CLIENT

//启用服务器的客户端身份验证 //
#define CLNT_USR_PWD

//
*启用订阅以允许切换 LED，例如通过
* Node-RED 应用
程序*/
//#define subscribe

#define client_init_State (0x01)
#define MQTT_INIT_STATE (0x04)

#define application_version "1.0.0"
#define application_name "Tel Tru Thermostat (Watson IOT)"

#define SLNET_IF_WIFI_PRIO (5)

/*在 MQTT 3.1模式下操作 Lib。 */
#define MQTT_3_1_1 false
#define MQTT_3_1 true

#define will _topic "物 联网-2/evt/status/fmt/json"
#define will _MSG "｛"d\"：｛\"状态\"：\" WillLastAndTestames\"｝"
#define WIT_QoS MQTT_QOS_0
#define will _retain false

/*定义代理 IP 地址和端口号 */
#define SERVER_ADDRESS "6ggtke.messaging.internetofthings.ibmcloud.com"
//#define SERVER_ADDRESS "quickstart.messaging.internetofthings.ibmcloud.com"
//#define SERVER_IP_ADDRESS "192.168.178.67"#define
PORT_NUMBER 1883
#define secured_port_number 8883
#define loopback_port 1882

/*清除会话标志 */
#define CLEAR_SESSION True

/*保留标志。 用于发布消息。 */
#define RETAIN_ENABLE 1


/*定义订阅主题的数量 */
#define SUBSCRIPT_COUNT 1/*

定义"订购"主题值 */
#define subscription_TOPIC0 "IoT-2/cmd/led/fmt/json"

//定义发布主题值 */
#define publish_TOPIC0 "物 联网-2/evt/status/fmt/json"

/*生成任务优先级以及任务和线程栈大小 */
#define TASKSTACKSIZE 2048
#define RXTASKSIZE 4096
#define MQTTTHREADSIZE 2048
#define sawn_task_priority 9

/*安全客户端需要时间配置，以便验证服务器 */
*证书有效期(日期)。 //

//*月中某天(DD 格式)范围1-31 */
#define day 4
/*月(mm 格式)、范围为1-12 */
#define Month 3
/*年(YYYY 格式) */
#define 年份 2019
年/*小时、范围为0-23 */
#define Hour 2
/*分钟，范围为0-59 */
#define Minutes 4
/*秒，范围为0-59 */
#define SEC 用于

安全连接的32 /*文件数 //
#define CLIENT_NUM_SECURE_FILES 1

//用于切换 LED 的计时器的过期值。 */
#define TIMER_EXPILOAD_VALUE 100 * 1000000

//*********
// 本地函数原型
//*********
void pushButtonInterruptHandler2 (uint_least8_t 索引)；
void pushButtonInterruptHandler3 (uint_least8_t 索引)；
void TimerPeriodicIntHandler (siginitval)；
void LedTimerConfigNStart ()；
void LedTimerDeStop ()；
静态空 DisplayBanner (char * AppName)；
void * MqttClient (void * pvParameters)；
void MQTT_ClientStop (uint8_t disconnect)；
void MQTT_Stop ()；
void MQTT_START ()；
Int32_t MQTT_IF_Connect ()；
int32_t MqttClient_start()；
int32_t MQTT_SendMsgToQueue (struct msgQueue * queueElement)；

//***************
// 全局变量
//*********

/*连接状态：(0)-已连接，(负)-已断开连接 //
int32_t gAppConnectionState =-1；
uint32_t gInitState = 0；
uint32_t memPtrCounterfree = 0；
bool gResetApplication = false；
静态 MQTTClient_handle gMqttClient；
MQTTClient_Params MqttClientExample_params；
unsigned short g_usTimerts；

*无符号接收任务处理任务 //
pthread_t g_rx_task_hndl =(pthread_t) NULL；
uint32_t gUiConnFlag = 0；

// AP 安全参数 //
SlWlanSecParams_t SecurityParams =｛0｝；

//客户端 ID //
//*如果未设置 ClientID，设备的 MAC 地址将被复制到*/
/* ClientID 参数中。 */
/*客户端用户名和密码 */
// char ClientID[64]=｛'\0'｝；
//const char * ClientUsername ="use-token-auth"；
//const char * ClientPassword ="qwert123"；


const char * ClientUsername ="use-token-auth"；
//char ClientID[64]="d：6ggtke：CC3220SF：Thermometer"；
//const char * ClientPassword ="5uaQwYi4+n33oB-V3E"；
char ClientID[64]="g:6ggtke：CC3220：Thermostat"；
const char * ClientPassword ="gpv1PKU)v！0sgUns1U"；

/*订阅主题和 QoS 值 */
char * topic[subscription_topic_count]=
｛subscription_TOPIC0｝；

无符号字符 QoS[subscription_topic_count]=
｛MQTT_QOS_2｝；

//发布主题和消息 //
const char * publish_topic =｛publish_TOPIC0｝；
静态 char publish_data[1024]；

//消息队列 //
mqd_t g_PBQueue；
pthread_t mqttThread =(pthread_t) NULL；
pthread_t appThread =(pthread_t) NULL；
timer_t g_timer；

//打印新行 */
char lineBreak[]="\n"\}；

//*********
// 横幅变量
//*********
#ifdef SECURE_CLIENT

//char * MQTT_Client_SECURE_FILES[client_NUM_SECURE_FILES]=｛"ca-cert.cer"｝；
char * MQTT_Client_SECURE_FILES[client_NUM_SECURE_FILE]=｛"Digicer-global-root-ca.Cert"｝；

/*与 MQTT_Int API 配合使用的初始化结构。 为了*/
/*使用安全套接字方法、标志 MQTTCLIENT_NETCONN_SEC、cipher、 必须
配置*/*n_files 和 secure_files。 此外
，还必须对*/*certificates 进行编程("ca-cert.pem")。 */
*第一个参数是配置服务器地址类型和*/
*安全模式的位掩码。 */
*/*服务器地址类型：IPv4、IPv6和 URL 必须使用声明 */*
相应的标志。 //
/*安全模式：标志 MQTTCLIENT_NETCONN_SEC 启用安全(TLS)*/
/*，其中包括域名验证和证书目录 //
/*验证，可以通过添加到位掩码来禁用这些验证*/
/*MQTCLIENT_NETCONN_SKIP_DOMAIN_NAME_VERIFY 和 //
/* MQTCLIENT_NETCONN_SKIP_CERTIFICATE_catalog_verification 标志 //
*示例：MQTTCLIENT_NETCONN_IP6 | MQTTCLIENT_NETCONN_SEC | //
/* MQTCLIENT_NETCONN_SKIP_CERTIFICATE_catalog_verification //
*对于此位掩码，IPv6地址类型将被使用，安全性 将
启用*/**功能，并且证书目录验证将被*/
*/跳过。 */
*注：域名验证需要 URL 服务器地址类型 */
* 否则、此验证将被禁用。 */
MQTTClient_ConnParams MQTT_ClientCtx =
｛
MQTTCLIENT_NETCONN_URL | MQTCLIENT_NETCONN_SEC |
MQTCLIENT_NETCONN_SKIP_CERTIFICATE_CATALE_VERIFICATION |
MQTTCLIENT_NETCONN_SKIP_DOMAIN_NAME_VERIFICATION、
服务器地址、
Secured_port_number、// port_number
SLNETSOCK_SEC_METHOD_SSLv3_TLSv1_2、
SLNETSOCK_SEC_Cip_full_list、
client_NUM_SECURE_FILES、
MQTT_Client_SECURE_FILES
｝；

void setTime()
{
slDateTime_t DateTime =｛0｝；
DateTimeTM_Day =(uint32_t)天；
DateTimeTM_mon =(uint32_t)个月；
DateTimeTM_year =(uint32_t)年；
DateTimeTM_Hour =(uint32_t)小时；
DateTimeTM_min =(uint32_t)分钟；
DateTimeTM_sec =(uint32_t) SEC；
SL_DeviceSet (SL_DEVICE_General、SL_DEVICE_General_DATE_TIME、
sizeof (slDateTim_t)、(uint8_t *)(&DateTime)；
｝
#else
MQTTClient_ConnParams MQTT_ClientCtx =
｛
MQTCLIENT_NETCONN_URL、
服务器地址、
PORT_NUMBER、0、0、0、
空
}；
#endif

//初始化将 will _param 结构设置为默认的 will 参数 */
MQTTClient_Will _param =
｛
will _topic、
WIT_MSG、
will _QoS、
Will _retain
｝；

//*********
//
//！ MQTT_SendMsgToQueue -接收 msgQueue 参数和
//！ 尝试以最小的超时时间将其推入队列0。
//！ 如果队列未满、则将存储参数、函数
//！ 将返回0。
//！ 如果队列已满且超时已过期(因为超时参数
//！ 为0时、它将立即过期)、参数被丢弃、
//！ 函数将返回-1作为完整队列的错误。
//！
//！ \param[in] struct msgQueue *queueElement
//！
//！ 成功时返回0、错误时返回-1
//
/*********
int32_t MQTT_SendMsgToQueue (struct msgQueue * queueElement)
｛
struct timespec abstime =｛0｝；

Clock_gettime (clock_realtime、abstime)；

if (g_PBQueue)
｛
/*向队列发送消息 *
if (mq_timedsend (g_PBQueue、(char *) queueElement、
sizeof (struct msgQueue)、0、&abstime)==0)
｛
返回(0)；
}
｝
return (-1)；
｝

//*********
//
//！ 按钮操作器1 (GPIOSW2)。 每当用户
//！时按按钮1 (GPIOSW2) 希望发布消息。 将消息写入消息队列、以发送
//！ 事件发布消息
//！
//！ \param none
//！
//！ 返回无
//
//
void pushButtonInterruptHandler2 (uint_least8_t INDEX)
｛
struct msgQueue queueElement；

/*禁用 SW2中断*/
GPIO_DisableInt (Board_GPIO_BUTTON0)；// SW2

queueElement.event = publish_push_button_pressed；
queueElement.msgPtr =空；

/*编写指示发布消息的消息 *
if (MQTT_SendMsgToQueue (queueElement))
｛
UART_PRINT ("\n\n\r 队列已满\n\r\n");
｝
}

//*********
//
//！ 按钮操作器2 (GPIOSW3)。 只要用户想要
//！ 断开与远程代理的连接。 将消息写入消息队列
//！ 指示与代理断开连接。
//！
//！ \param none
//！
//！ 返回无
//
//
void pushButtonInterruptHandler3 (uint_least8_t INDEX)
｛
struct msgQueue queueElement；
struct msgQueue queueElemRecv；

queueElement.event = disc_push_button_pressed；
queueElement.msgPtr =空；

/*写入指示已按下断开按钮的消息 *
if (MQTT_SendMsgToQueue (queueElement))
｛
UART_PRINT (
"\n\n\r 队列已满、先抛出 msg 并发送新的消息\n\r\n");
MQ_Receive (g_PBQueue、(char*)&queueElemRecv、sizeof (struct msgQueue)、
null)；
MQTT_SendMsgToQueue (queueElement)；
｝
}

//*********
//
//！ 周期定时器中断处理程序
//！
//！ \param 无
//！
//！ \无返回
//
//*********
void TimerPeriodicIntHandler (sigval)
｛
/*递增中断计数器。 *
G_usTimerInts++；

if (！(g_usTimerInts & 0x1))
｛
/*关闭 LED 指示灯 *
GPIO_WRITE (Board_GPIO_LED0、Board_GPIO_LED_OFF)；
｝
其他
｛
/*打开指示灯 *
GPIO_WRITE (Board_GPIO_LED0、Board_GPIO_LED_ON)；
｝
}

//*********
//
//！ 用于配置和启动计时器以在器件为
//时使 LED 闪烁的函数！ 尝试连接到 AP
//！
//！ \param none
//！
//！ 返回无
//
//
空 LedTimerConfigNStart()
{
struct itimerspec 值；
sigevent sev；

/*创建计时器 *
sev.sigev_notify = SIGEV_SIGNAL；
SEV.sigev_notify_function =&TimerPeriodicIntHandler；
Timer_create (2、sev、&g_timer)；

/*启动计时器 *
value.it_interval.tv_sec = 0；
value.it_interval.tv_nsec = TIMER_EXPIRE_VALUE；
value.it_value.tv_sec = 0；
value.it_value.tv_nsec = TIMER_EXPIRE_VALUE；

Timer_settime (g_timer、0、&value、NULL)；
｝

//*********
//
//！ 器件连接到 AP
时禁用 LED 闪烁计时器//！
//！ \param none
//！
//！ 返回无
//
//
void LedTimerDeinitStop()
{
/*在设备连接到 AP 时禁用 LED 闪烁计时器。 *
Timer_delete (g_timer)；
｝

//*********
//
//！ UART 上的应用启动显示
//！
//！ \param none
//！
//！ \无返回
//！
//
静态空 DisplayBanner (char * AppName)
｛
UART_PRINT ("\n\n\r\n"\})；
UART_PRINT ("\t ********) \n\n");
UART_PRINT ("\t CC32xx %s 应用\n", AppName")；
UART_PRINT ("\t ********) \n\n");
UART_PRINT ("\n\n\r\n\r\n");
｝

void * MqttClientThread (void * pvParameters)
｛
struct msgQueue queueElement；
struct msgQueue queueElemRecv；

MQTTClient_run (((MQTTClient_handle) pvParameters)；

queueElement.event = local_client_DISCONNECNINNECT;
queueElement.msgPtr =空；

/*写入指示断开连接代理消息的消息。 *
if (MQTT_SendMsgToQueue (queueElement))
｛
UART_PRINT (
"\n\n\r 队列已满、先抛出 msg 并发送新的消息\n\r\n");
MQ_Receive (g_PBQueue、(char*)&queueElemRecv、sizeof (struct msgQueue)、
null)；
MQTT_SendMsgToQueue (queueElement)；
｝

pthread_exit (0)；

return (NULL)；
｝

//*********
//
//！ 任务实施 MQTT 服务器和客户端桥
//！
//！ 此函数
//！ 1.初始化网络驱动程序并连接到默认 AP
//！ 2.初始化 MQTT 客户端 AN 服务器库并设置 MQTT
//！ 远程代理。
//！ 3.设置按钮事件及其回调(用于发布)
//！ 4.处理回调信号
//！
//！ \param none
//！
//！ \无返回
//！
//
void * MqttClient (void * pvParameters)
｛
struct msgQueue queueElemRecv；
long lRetVal =-1；
char * tmpBuff；

/*初始化客户程序并订阅中介程序。 *
if (gApConnectionState >= 0)
｛
lRetVal = MqttClient_start()；
if (lRetVal =-1)
｛
UART_PRINT ("MQTT 客户端库初始化失败\n\r\n)；
pthread_exit (0)；
return (NULL)；
｝
｝

/*处理来自各种回调的信号，包括按钮*/
/*提示客户在 pub_topic 上发布消息或*/收到的消息
/*注册主题上的服务器(其机载客户端已注册)*/
/*从本地客户端(将由发布到远程代理 *
/*CLIENT)或由客户端从远程代理接收的 msg (需要*/
/*发送到服务器以查看是否有任何本地客户端已在*/上订阅
/*相同主题)。 *
for (；)
｛
/*等待信号 *
MQ_Receive (g_PBQueue、(char*)&queueElemRecv、sizeof (struct msgQueue)、
null)；
开关(queueElemRecv.event)
｛
案例 publish_push_button_pressed：
while (1)｛
kellerMeasure()；
//tempFunction()；
sprintf (publish_data、(const char *)"｛\"d\"：｛\" Temperature\"：%f｝｝"、
temp_p)；\
//sprintf (publish_data、(const char *)"｛\"d\"：｛\"Pressure\"：%f｝"、
// Pres_p)；

/*发送发布消息 *
//lRetVal = MQTTClient_publish (gMqttClient、(char*) publish_topic、
// strlen((char*)publish_topic)、(char*)publish_data、
// strlen((char*) publish_data)、
// MQTT_QOS_0 | MQTT_publish_retain )；

UART_PRINT ("\n\r CC32xx 发布以下消息\n\r")；
UART_PRINT ("主题：%s\n\r\n、publish_topic)；
UART_PRINT ("数据：%s\n\r\n、publish_data)；

/*清除并再次启用 SW2中断*/
GPIO_clearInt (Board_GPIO_BUTTON0)；// SW2
GPIO_enableInt (Board_GPIO_BUTTON0)；// SW2
｝
中断；

/*客户端从远程代理接收的消息(主题) *
/*由本地客户端订阅) *
案例 MSG_RECV_BY_CLIENT：
tmpBuff =(char *)((char *) queueElemRecv.msgPtr + 12)；
if (strncmp (tmpBuff、subscription_TOPIC0、queueElemRecv.topLen)
= 0)
｛
GPIO_TOGGLE (Board_GPIO_LED0)；
｝

FREE (queueElemRecv.msgPtr)；
中断；

/*仅从远程代理断开的板载客户端 *
/*本地 MQTT 网络将正常工作 *
case local_client_DISCONNINNINNINNIN
UART_PRINT ("\n\conn-board Client Disconnected)\n\n\r\n"\}；
gUiConnFlag = 0；
中断；

/*用于完全重新启动检查的按钮 *
case disc_push_button_pressed：
gResetApplication = true；
中断；

case thread_terminate_Req：
gUiConnFlag = 0；
pthread_exit (0)；
返回空；

默认值：
睡眠(1)；
中断；
｝
}


//*********
//
//！ 此函数将 MQTT 器件连接到 SSID 为
//的 AP！ 在 SSID_NAME 定义中配置、可在 Network_if.h 文件中找到、
//！ 如果器件无法连接到此 AP、则用户请求其他
//！ 将出现 SSID。
//！
//！ \param none
//！
//！ \无返回
//！
//
int32_t MQTT_IF_Connect ()
｛
int32_t lRetVal；
char SSID_Remote_Name[32]；
INT8_t Str_Length；

memset (SSID_Remote_Name、'\0'、sizeof (SSID_Remote_Name))；
STR_Length = strlen (SSID_NAME)；

IF (StR_Length)
｛
/*将默认 SSID 复制到局部变量 *
strncpy (SSID_Remote_Name、SSID_NAME、Str_Length)；
｝

/*显示应用程序横幅 *
DisplayBanner (application_name)；

GPIO_WRITE (Board_GPIO_LED0、Board_GPIO_LED_OFF)；
GPIO_WRITE (Board_GPIO_LED1、Board_GPIO_LED_OFF)；
GPIO_WRITE (Board_GPIO_LED2、Board_GPIO_LED_OFF)；

/*重置机器的状态 *
network_if_ResetMCUStateMachine()；

/*启动驱动程序 *
lRetVal = Network_IF_InitDriver (Role_STA)；
如果(lRetVal < 0)
｛
UART_PRINT ("启动 SimpleLink 器件失败\n\r"、lRetVal)；
return(-1)；
}

/*打开绿色 LED 指示 SimpleLink 已正确启动。 *
GPIO_WRITE (Board_GPIO_LED2、Board_GPIO_LED_ON)；

/*启动计时器使红色 LED 闪烁，直至接入点连接 *
LedTimerConfigNStart()；

/*初始化 AP 安全参数 *
SecurityParams.Key =(signed char *) security_key；
SecurityParams.KeyLen = strlen (security_key)；
SecurityParams.Type = SECURITY_TYPE；

/*连接到接入点 *
lRetVal = Network_IF_ConnectAP (SSID_Remote_Name、SecurityParams)；
如果(lRetVal < 0)
｛
UART_PRINT ("连接到 AP 失败\n\r\n)；
return(-1)；
}

/*在设备连接到 AP 时禁用 LED 闪烁计时器。 *
LedTimerDeinitStop()；

/*打开红色 LED 指示灯，表示设备已获取 IP。 *
GPIO_WRITE (Board_GPIO_LED0、Board_GPIO_LED_ON)；

睡眠(1)；

GPIO_WRITE (Board_GPIO_LED0、Board_GPIO_LED_OFF)；
GPIO_WRITE (Board_GPIO_LED1、Board_GPIO_LED_OFF)；
GPIO_WRITE (Board_GPIO_LED2、Board_GPIO_LED_OFF)；

退货(0)；
｝

//*********
//！
//！ MQTT 开始-初始化并创建运行 MQTT 所需的所有项目
//！ 协议
//！
//！ \param none
//！
//！ \无返回
//！
//
void MQTT_START()
{
int32_t threadArg=100；
pthread_attr_t pAttrs；
struct sched_param primParam；
int32_t retc = 0；
mq_attr 属性；
无符号模式 = 0；

/*sync 对象，用于线程间通信 *
ATTR.MQ_maxmsg = 10；
attr.mq_msgsize = sizeof (struct msgQueue)；
G_PBQueue = MQ_open ("g_PBQueue"、O_creat、mode、&attr)；

if (g_PBQueue ==空)
｛
UART_PRINT ("MQTT 消息队列创建失败\n\r\n)；
gInitState &=~MQTT_INIT_STATE；
返回；
｝

/*设置优先级和堆栈大小属性 *
pthread_attr_init (&pAttrs)；
priParam.sched_priority = 2；
retc = pthread_attr_setschedparam (&pAttrs、&priParam)；
retc |= pthread_attr_setstacksize (&pAttrs、MQTTTHREADSIZE)；
retc |= pthread_attr_setdetachstate (&pAttrs、pthread_create_detachstate)；

如果(retc！= 0)
｛
gInitState &=~MQTT_INIT_STATE；
UART_PRINT ("MQTT 线程创建失败\n\r\n)；
返回；
｝

retc = pthread_create (&mqttThread、&pAttrs、MqttClient、(void *)&threadArg)；
如果(retc！= 0)
｛
gInitState &=~MQTT_INIT_STATE；
UART_PRINT ("MQTT 线程创建失败\n\r\n)；
返回；
｝

/*启用 GPIO 13 (SW3)和 GPIO 22 (SW2)的中断。 *
GPIO_setCallback (Board_GPIO_BUTTON0、pushButtonInterruptHandler2)；
GPIO_enableInt (Board_GPIO_BUTTON0)；// SW2

GPIO_setCallback (Board_GPIO_Button1、pushButtonInterruptHandler3)；
GPIO_enableInt (Board_GPIO_Button1)；// SW3

gInitState &=~MQTT_INIT_STATE；
｝

//*********
//！
//！ MQTT 停止-关闭客户端实例并释放
//！ 运行 MQTT 协议
//！
//！ \param none
//！
//！ \无返回
//！
//

void MQTT_Stop()
{
struct msgQueue queueElement；
struct msgQueue queueElemRecv；

if (gApConnectionState >= 0)
｛
MQTT_ClientStop(1)；
}

queueElement.event = thread_terminate_Req；
queueElement.msgPtr =空；

/*编写指示发布消息的消息 *
if (MQTT_SendMsgToQueue (queueElement))
｛
UART_PRINT (
"\n\n\r 队列已满、先抛出 msg 并发送新的消息\n\r\n");
MQ_Receive (g_PBQueue、(char*)&queueElemRecv、sizeof (struct msgQueue)、
null)；
MQTT_SendMsgToQueue (queueElement)；
｝

睡眠(2)；

MQ_Close (g_PBQueue)；
G_PBQueue =空；

sl_Stop (sl_stop_timeout)；
UART_PRINT ("\n\nr Client Stop Completed \r\n")；

/*禁用 SW2和 SW3中断*/
GPIO_DisableInt (Board_GPIO_BUTTON0)；// SW2
GPIO_DisableInt (Board_GPIO_Button1)；// SW3
｝

Int32_t MqttClient_start ()
｛
int32_t lRetVal =-1；

int32_t threadArg=100；
pthread_attr_t pAttrs；
struct sched_param primParam；

MqttClientExample_params.clientId = ClientID；
MqttClientExample_params.connParams =&MQTT_ClientCtx；
MqttClientExample_params.mqttMode31 = MQTT_3_1；
MqttClientExample_params.blockingSend = true；

gInitState |= client_init_State；

/*初始化 MQTT 客户端库 *
gMqttClient = MQTTClient_create (MqttClientCallback、
&MqttClientExample_params)；
if (gMqttClient =NULL)
｛
/*lib 初始化失败 *
gInitState &=~client_init_State；
return(-1)；
}

/*打开客户机接收线程启动接收任务。 设置优先级和*/
/*stack size 属性 *
pthread_attr_init (&pAttrs)；
priParam.sched_priority = 2；
lRetVal = pthread_attr_setschedparam (&pAttrs、&priParam)；
lRetVal |= pthread_attr_setstacksize (&pAttrs、RXTASKSIZE)；
lRetVal |= pthread_attr_setdetachstate (&pAttrs、pthread_create_detached)；
lRetVal |=
pthread_create (&G rx_task_hndl、&pAttrs、MqttClientThread、
(void *)螺纹线阵列(&R)；
if (lRetVal！= 0)
｛
UART_PRINT ("客户端线程创建失败\n\r\n)；
gInitState &=~client_init_State；
return(-1)；
}
#ifdef SECURE_CLIENT
settime()；
#endif

/*设置将参数 *
MQTTClient_set (gMqttClient、MQTTClient_Will 参数、will _param、&will _param、
sizeof (wo_param)；

#ifdef CLNT_USR_PWD
/*设置客户端连接的用户名 *
MQTTClient_set (gMqttClient、MQTTClient_user_name、(void *)客户端用户名、
strlen(
(char*)ClientUsername))；

/*设置密码 *
MQTTClient_set (gMqttClient、MQTTClient_password、(void *) ClientPassword、
strlen(
(char*) ClientPassword)；
#endif
/*启动 MQTT 连接 *
if (gApConnectionState >= 0)
｛
#if clean_session = false
bool clean = clear_session；
MQTTClient_set (gMqttClient、MQTTClient_clean_connect、(void *)&clean、
sizeof (bool))；
#endif
/* MQTTClient_connect 的返回代码是 ConnACK 值
从服务器返回*/
lRetVal = MQTTClient_connect (gMqttClient)；

/*负 lRetVal 表示错误，
0表示在没有服务器存储会话的情况下连接成功、
大于0表示与存储的会话成功连接
服务器*/
如果(0 > lRetVal)
｛
/*lib 初始化失败 *
UART_PRINT ("\n 连接到代理失败、错误代码：%d\n\r\n、
lRetVal)；

gUiConnFlag = 0；
｝
其他
｛
UART_PRINT ("与代理的连接成功\n\r")；
gUiConnFlag = 1；
｝

#ifdef 订阅
/*在服务器未存储会话时订阅主题 *
if ((gUiConnFlag ==1)&&(0==lRetVal))
｛
uint8_t 子索引；
int32_t iCount；
MQTTClient_SubscribeParams 下标信息[
subscription_topic_count]；

for (子索引= 0；子索引< subIndex_topic_count；子索引++)
｛
subscriptionInfo[subIndex].topic = topic[subIndex]；
subscriptionInfo[subIndex].QoS = QOS[subIndex]；
｝

if (MQTTClient_subscribe (gMqttClient、下标信息、
subscription_topic_count)< 0)
｛
UART_PRINT ("\n\r 订阅错误\n\r")；
MQTTClient_DISCONNECT (gMqttClient)；
gUiConnFlag = 0；
｝
其他
｛
对于(iCount = 0；iCount < subscription_topic_count；iCount++)
｛
UART_PRINT ("已在%s\n\r 上订阅客户端"、Topic[iCount])；
｝
}

#endif
｝

gInitState &=~client_init_State；

退货(0)；
｝

//*********
//！
//！ MQTT 客户端停止-取消订阅主题并退出
//！ MQTT 客户端库。
//！
//！ \param none
//！
//！ \无返回
//！
//

void MQTT_ClientStop (uint8_t disconnect)
｛
#ifdef subscribe
uint32_t iCount；

MQTTClient_UnsubscribeParams subscriptionInfo[subscribe_topic_count]；

对于(iCount = 0；iCount < subscription_topic_count；iCount++)
｛
subscriptionInfo[iCount].topic = topic[iCount]；
｝

MQTTClient_unsubscribe (gMqttClient、下标信息、
subscription_topic_count)；
对于(iCount = 0；iCount < subscription_topic_count；iCount++)
｛
UART_PRINT ("取消订阅主题%s\r\n、主题[iCount])；
｝
#endif
gUiConnFlag = 0；

/*退出客户端库 *
MQTTClient_delete (gMqttClient)；
｝

//*************
//！
//！ 打印边框的实用程序//
！
//！ \param[in] ch -按住边框的字符。
//！ \param[in] n -保留边框的大小。
//！
//！ \不返回任何内容。
//！
//

void printBorder (char ch、
int n)
｛
int i = 0；

对于(i = 0；i < n；i++)
｛
putch (ch)；
｝
}

//*********
//！
//！ 显示应用横幅
//！的实用程序功能
//！ \param[in] appName -保留应用程序名称。
//！ \param[in] appVersion -保存应用程序版本。
//！
//！ \不返回任何内容。
//！
//

int32_t DisplayAppBanner (char* appName、
char* appVersion)
｛

int32_t ret = 0；
uint8_t macAddress[sl_MAC_ADDR_LEN]；
uint16_t macAddressLen = sl_MAC_ADDR_LEN；
uint16_t ConfigSize = 0；
uint8_t ConfigOpt = sl_device_General_version；
SlDeviceVersion_t ver =｛0｝；

ConfigSize = sizeof (slDeviceVersion_t)；

/*打印设备版本信息。 *
RET =
SL_DeviceGet (SL_DEVICE_General、&ConfigOpt、&ConfigSize、
(uint8_t*)(&V))；

/*打印设备 Mac 地址*/
RET = sl_NetCfgGet (sl_netcfg_MAC_address_get、0、&macAddressLen、
macAddress[0])；

UART_PRINT (lineBreak）；
UART_PRINT ("\t")；
printBorder ('=',44)；
UART_PRINT (lineBreak）；
UART_PRINT ("\t %s"、appName)；
UART_PRINT (lineBreak）；
UART_PRINT ("\t")；
printBorder ('=',44)；
UART_PRINT (lineBreak）；
UART_PRINT (lineBreak）；
UART_PRINT ("\t 芯片：0x%x"、ver.ChipId)；
UART_PRINT (lineBreak）；
UART_PRINT ("\t MAC：%d.%d.%d.%d"、ver.FwVersion[0]、ver.FwVersion[1]、
Ver.FwVersion[2]、
ver.FwVersion[3])；
UART_PRINT (lineBreak）；
UART_PRINT ("\t PHY：%d.%d.%d.%d"、ver.PhyVersion[0]、ver.PhyVersion[1]、
Ver.PhyVersion[2]、
ver.PhyVersion[3])；
UART_PRINT (lineBreak）；
UART_PRINT ("\t NWP：%d.%d.%d.%d"、ver.NwpVersion[0]、ver.NwpVersion[1]、
Ver.NwpVersion[2]、
ver.NwpVersion[3])；
UART_PRINT (lineBreak）；
UART_PRINT ("\t ROM：%d"、ver.RomVersion)；
UART_PRINT (lineBreak）；
UART_PRINT ("\t host：%s"、sl_driver_version)；
UART_PRINT (lineBreak）；
UART_PRINT ("\t MAC 地址：%02x：%02x：%02x：%02x：%02x：%02x"、macAddress[0]、
MacAddress[1]、macAddress[2]、macAddress[3]、macAddress[4]、
MacAddress[5])；
UART_PRINT (lineBreak）；
UART_PRINT (lineBreak）；
UART_PRINT ("\t")；
printBorder ('=',44)；
UART_PRINT (lineBreak）；
UART_PRINT (lineBreak）；

/*使用 MAC 地址格式化 ClientID */
sprintf (ClientID、"d：quickstart：ti-simplelink：%02x%02x%02x%02x%02x%02x%02x%02x"、
MacAddress[0]、macAddress[1]、macAddress[2]、
MacAddress[3]、macAddress[4]、macAddress[5])；

UART_PRINT (" MQTT ClientID：%s"、ClientID)；
UART_PRINT (lineBreak）；

return (ret)；
｝



void mainThread (void * args)
｛
uint32_t count = 0；
pthread_t spawn_thread =(pthread_t) NULL；
pthread_attr_t pAttrs_spawn；
struct sched_param primParam；
int32_t retc = 0；
UART_Handle tUartHnstle；

/*使用 CC31xx/CC32xx 接口初始化 SlNetSock 层*/
SlNetIf 初始化(0)；
SlNetIf_add (SLNETIF_ID_1、"CC32xx"、
(const SlNetIf _Config_t *) SlNetIfConfigWifi、
SLNET_IF_WIFI_PRIO)；

SlNetSock_init (0)；
SlNetUtil_init (0)；
GPIO_init()；
spi_init()；

/*配置 UART *
tUartHalfl = InitTerm ()；
/*从 LPDS 依赖项中删除 UART 接收 *
UART_CONTROL (tUartHnLD、UART_CMD_RXDISABLE、空)；

/*创建 sl_Task *
pthread_attr_init (&pAttrs_spawn)；
priParam.sched_priority = sawn_task_priority；
retc = pthread_attr_setschedparam (&pAttrs_spawn、&priParam)；
retc |= pthread_attr_setstacksize (&pAttrs_sprawn、TASKSTACKSIZE)；
retc |= pthread_attr_setdetachstate
(&P) Attrs_spawn、pthread_create_detached)；

retc = pthread_create (&spawn_thread、&pAttrs_spawn、sl_Task、NULL)；

如果(retc！= 0)
｛
UART_PRINT ("无法创建 SimpleLink 任务\n\r")；
while (1)；
｝

retc = sl_Start (0、0、0)；
如果(retc < 0)
｛
/*句柄错误*/
UART_PRINT ("\n sl_Start Failed\n")；
while (1)；
｝

/*将设备信息输出到 UART 终端*/
retc = DisplayAppBanner (application_name、application_version)；

retc = sl_Stop (sl_stop_timeout)；
如果(retc < 0)
｛
/*句柄错误*/
UART_PRINT ("\n SL_Stop 失败\n"）；
while (1)；
｝

if (retc < 0)
｛
/*句柄错误*/
UART_PRINT ("MQTT_CLIENT -无法检索设备信息\n")；
while (1)；
｝


while (1)
｛
gResetApplication = false；
topic[0]= subscription_TOPIC0；
gInitState = 0；

/*连接到 AP *
gApConnectionState = MQTT_IF_Connect ()；

gInitState |= MQTT_init_State；
/*运行 MQTT 主线程(它将打开客户端和服务器) *
MQTT_START()；

/*等待初始化完成！！！ *
while (gInitState！= 0)
｛
UART_PRINT (".")；
睡眠(1)；
}
UART_PRINT ("../r\n"）；

while (gResetApplication == false)；

UART_PRINT ("要完成-关闭所有线程和资源\r\n)；

/*停止 MQTT 进程 *
MQTT_Stop()；

UART_PRINT ("重新打开 MQTT #%d \r\n、++COUNT)；
｝

｝ 

感谢你的帮助。 我删除了我的 IBM IOT 服务、并与设备一起重新创建了该服务、然后将信息添加到提供的代码中、并且我已成功创建连接。

我认为我的发言太快了。 在断开设备连接并尝试重新连接时，遇到与"-5"相同的错误

您好、Christopher、

如果您至少可以成功连接一次、则 CC3220项目中的配置是正确的。
您在云端看到了什么类型的错误？ 如果您查看设备的连接日志、是否有任何线索知道为什么第一次连接成功、但后续连接不成功？

此致、
Michael

我的白色列出了器件的 IP 地址、即使启用了 TLS、也可以根据我的需要进行多次连接。 但是、如果我添加更多器件、这对于将来的使用是不实用的。 您知道如何更好地解决问题、或者代码中是否有阻止其重新连接的内容。

您好、Christopher、

您在云端使用哪种设备白名单设置？ 您如何设置白名单？ 我在 IBM org 上看不到这样的选项。 由于我不熟悉该选项、您需要浏览 IBM 的文档以了解您为何需要它。 我无需为我的组织设置任何此类白名单、即可成功连接 CC3220。

只是为了澄清一点、当您提到无法重新连接到 IBM 时、您是否无法在设备重置后重新连接到 IBM 代理、或者如果您在 CC3220上失去互联网连接、您是否无法重新连接？

此致、
Michael

因此、在打开 TLS 并禁用白名单后、我可以重新连接、而不会出现任何问题

我之前的问题是在设备重置后重新连接。 我将包括白名单选项所在位置的屏幕截图。

您好、Christopher、

我的 IBM 组织中似乎没有该选项。 几年前我创建了 IBM Watson 组织、因此我的组织可能保留了一些配置、但不包括使用黑名单或白名单的功能。 无论如何、我很高兴您能找到并解决您的问题。

此致、
Michael