void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
switch (ev) {
case MG_EV_ACCEPT: {
char addr[32];
mg_sock_addr_to_str(&nc->sa, addr, sizeof(addr),
MG_SOCK_STRINGIFY_IP | MG_SOCK_STRINGIFY_PORT);
SYS_PRINT("%p: Connection from %s\r\n", nc, addr);
break;
}
case MG_EV_HTTP_REQUEST: {
struct http_message *hm = (struct http_message *) ev_data;
char addr[32];
mg_sock_addr_to_str(&nc->sa, addr, sizeof(addr),
MG_SOCK_STRINGIFY_IP | MG_SOCK_STRINGIFY_PORT);
SYS_PRINT("%p: %.*s %.*s\r\n", nc, (int) hm->method.len, hm->method.p,
(int) hm->uri.len, hm->uri.p);
mg_send_response_line(nc, 200,
"Content-Type: text/html\r\n"
"Connection: close");
mg_printf(nc,
"\r\n<h1>Hello, %s!</h1>\r\n"
"You asked for %.*s\r\n",
addr, (int) hm->uri.len, hm->uri.p);
nc->flags |= MG_F_SEND_AND_CLOSE;
break;
}
case MG_EV_CLOSE: {
SYS_PRINT("%p: Connection closed\r\n", nc);
break;
}
}
}
void SimpleLinkNetAppEventHandler(SlNetAppEvent_t *pNetAppEvent) {
switch (pNetAppEvent->Event) {
case SL_NETAPP_IPV4_IPACQUIRED_EVENT:
SYS_PRINT("Got IP\r\n");
appData.state = APP_STATE_CONNECT_BROKER;
break;
default:
SYS_PRINT("Got NetApp Event: %d\r\n", pNetAppEvent->Event);
break;
}
}
static void ev_handler(struct mg_connection *nc, int ev, void *p) {
struct mg_mqtt_message *msg = (struct mg_mqtt_message *) p;
static int count1 = 0;
switch (ev) {
case MG_EV_CONNECT:
if (*(int *) p != 0) {
SYS_PRINT("Failed to connect to %s\r\n", MQTT_BROKER_ADDRESS);
} else {
SYS_PRINT("Connected to %s\r\n", MQTT_BROKER_ADDRESS);
}
struct mg_send_mqtt_handshake_opts opts;
memset(&opts, 0, sizeof(opts));
opts.user_name = MQTT_USER_NAME;
opts.password = MQTT_USER_PWD;
mg_set_protocol_mqtt(nc);
mg_send_mqtt_handshake_opt(nc, "PIC32", opts);
break;
case MG_EV_MQTT_CONNACK:
if (msg->connack_ret_code != MG_EV_MQTT_CONNACK_ACCEPTED) {
SYS_PRINT("Got mqtt connection error %d\n\r", msg->connack_ret_code);
} else {
SYS_PRINT("Connected to broker\n\r");
}
SYS_PRINT("Subscribing to /test\n\r");
mg_mqtt_subscribe(nc, topic_expressions,
sizeof(topic_expressions) / sizeof(*topic_expressions),
++msg_id);
nc->flags |= MG_F_USER_1;
break;
case MG_EV_MQTT_SUBACK:
SYS_PRINT("Subscription acknowledged\r\n");
break;
case MG_EV_MQTT_PUBLISH:
SYS_PRINT("Got incoming message %s: %.*s\r\n", msg->topic,
(int) msg->payload.len, msg->payload.p);
break;
case MG_EV_POLL: {
if (nc->flags & MG_F_USER_1) {
char msg[100];
static uint32_t prev_send = 0;
uint32_t now = DRV_RTCC_TimeGet();
if (now - prev_send > 1000) {
int len = snprintf(msg, sizeof(msg), "Current RTC value: %u", now);
SYS_PRINT("Publishing message with RTC value=%u\r\n", now);
mg_mqtt_publish(nc, "/stuff", ++msg_id, MG_MQTT_QOS(0), msg, len);
prev_send = now;
}
}
break;
}
case MG_EV_CLOSE:
SYS_PRINT("Connection to broker is closed\r\n");
appData.state = APP_STATE_DONE;
break;
default:
break;
}
}
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent) {
switch (pWlanEvent->Event) {
case SL_WLAN_CONNECT_EVENT:
SYS_PRINT("Connected to WiFi\r\n");
break;
case SL_WLAN_DISCONNECT_EVENT:
SYS_PRINT("Disconnected WiFi\r\n");
break;
default:
SYS_PRINT("Got Wlan event %d\r\n", pWlanEvent->Event);
break;
}
}
/**
* Start the next readout, depending on availability
*/
static void _changeState(STATE_t newState)
{
SYS_PRINT("\r\nCNFG: Load online user config state change to %d\r\n", newState);
switch(newState)
{
case STATE_ACTIVATING:
APP_Activation_Initialize();
SYS_PRINT("\r\nCNFG: Activating gateway\r\n");
break;
case STATE_ERASING_ACTIVATION_KEY:
APP_SERIALFLASH_EraseActivationData();
break;
case STATE_STORING_ACTIVATION_KEY:
APP_SERIALFLASH_SaveActivationData(
(char*)&appGWActivationData.configuration.id, (char*)&appGWActivationData.configuration.key,
(char*)&appGWActivationData.configuration.account_server_url,
false); // Only lock it after first time successful downloading LoRa config
break;
case STATE_DOWNLOAD_LORA_CONFIG:
APP_Configuration_Initialize();
reconnectDelayStartTick = SYS_TMR_TickCountGet();
break;
case STATE_LOCK_ACTIVATION:
appGWActivationData.locked = true;
APP_SERIALFLASH_LockActivationData();
break;
case STATE_DOWNLOAD_FREQPLAN:
APP_FreqPlan_Initialize();
freqDelayStartTick = SYS_TMR_TickCountGet();
break;
case STATE_START_LORA_MODULE:
SYS_PRINT("\r\nCNFG: Configuring LoRa module\r\n");
APP_LORA_SetStartEvent();
break;
case STATE_COMMUNICATION_ERROR:
SYS_PRINT("\r\nCNFG: Communication ERROR\r\n");
break;
default:
break;
}
_state = newState;
}
uint8_t readMsgBufID(uint32_t *ID, uint8_t *len, uint8_t buf[]) {
uint8_t ret = CAN_FAIL;
CAN_CHANNEL_EVENT channelEvent;
channelEvent = PLIB_CAN_ChannelEventGet(CAN_ID_1, CAN_CHANNEL1);
//if (channelEvent != 0)
// SYS_PRINT("\r\nCAN EVENT:%d", channelEvent);
if((channelEvent & (CAN_RX_CHANNEL_NOT_EMPTY | CAN_RX_CHANNEL_FULL)) != 0)
{
// This means that either Receive Channel is not empty
// or the Channel is full.
int i;
CAN_RX_MSG_BUFFER *RxMessage;
RxMessage = (CAN_RX_MSG_BUFFER *)PLIB_CAN_ReceivedMessageGet(CAN_ID_1, CAN_CHANNEL1);
if(RxMessage != NULL)
{
#ifdef TRACE
SYS_PRINT("\r\nSID:%04X L=%d ", RxMessage->msgSID.sid, RxMessage->msgEID.data_length_code);
#endif
*ID = RxMessage->msgSID.sid;
*len = RxMessage->msgEID.data_length_code;
for (i=0; i<RxMessage->msgEID.data_length_code; i++) {
buf[i] = RxMessage->data[i];
#ifdef TRACE
SYS_PRINT("%02X",buf[i]);
#endif
}
#ifdef TRACE
SYS_PRINT("\r\n");
#endif
//Process the message received
/* Call the PLIB_CAN_ChannelUpdate function to let
the CAN module know that the message processing
is done. */
PLIB_CAN_ChannelUpdate(CAN_ID_1, CAN_CHANNEL1);
ret = CAN_OK;
}
PLIB_CAN_ChannelEventClear(CAN_ID_1, CAN_CHANNEL1, channelEvent);
}
return ret;
}
/**
* Start the next readout, depending on availability
*/
static void _changeState(STATE_t newState)
{
SYS_PRINT("INET: State change to %d\r\n", newState);
// onEnter
switch(newState)
{
case STATE_WAIT_FOR_NETWORK:
if(appWifiData.valid)
{
APP_WIFI_INFRA_MODE();
}
break;
case STATE_AP_ONLY:
wifiRetryStartTick = SYS_TMR_TickCountGet();
APP_WIFI_AP_MODE();
firstTimeAPReconnectTimeout = true;
break;
case STATE_SETTLE:
SYS_PRINT("INET: Connected to a network, waiting for DHCP lease, checking validity with ping\r\n");
settleStartTick = SYS_TMR_TickCountGet();
break;
case STATE_PING_PROBE:
ping_probe_reply_received = false;
ping_probe_sent = false;
ping_retry = 0;
pingStartTick = SYS_TMR_TickCountGet();
break;
case STATE_WAIT_FOR_NTP:
ntpStartTick = SYS_TMR_TickCountGet();
break;
default:
break;
}
_state = newState;
}
void APP_Initialize(void)
{
/* Place the App state machine in its initial state. */
appData.state = APP_STATE_INIT;
DBINIT();
SYS_PRINT("=== Initializing wolfMQTT ===\n");
mqtt_init_ctx(&mqttCtx);
mqttCtx.app_name = "mqttclient";
mqttCtx.qos = MQTT_QOS_2;
mqttCtx.use_tls = 1;
/* TODO: Add any additional custom args here.
See MQTTCtx struct in mqttexample.h */
}
/*
parse a tring into '*argv[]', delimitor is space or tab
param pRawString, the whole line of command string
param argv, parsed argument string array
return number of parsed argument
*/
static int StringToArgs(char *pRawString, char *argv[]) {
int argc = 0, i = 0, strsize = 0;
if(pRawString == NULL)
return 0;
strsize = strlen(pRawString);
while(argc < MAX_CMD_ARGS) {
// skip white space characters of string head
while ((*pRawString == ' ') || (*pRawString == '\t')) {
++pRawString;
if (++i >= strsize) {
return (argc);
}
}
if (*pRawString == '\0') {
argv[argc] = NULL;
return (argc);
}
argv[argc++] = pRawString;
// find end of string
while (*pRawString && (*pRawString != ' ') && (*pRawString != '\t')) {
++pRawString;
}
if (*pRawString == '\0') {
argv[argc] = NULL;
return (argc);
}
*pRawString++ = '\0';
}
SYS_PRINT("\n\r Too many arguments. Maximum argus supported is %d!\r\n", MAX_CMD_ARGS);
return (0);
}
void SSMLoadOnlineConfig_Tasks(void)
{
switch(_state)
{
case STATE_NEEDS_MORE_CONFIG:
// TODO: what do we do then? Display on status page?
break;
case STATE_ACTIVATING:
{
if(APP_SERIALFLASH_IsReady())
{
APP_Activation_Tasks();
switch(APP_Activation_State())
{ // REVIEW: don't check internal state, but via test function
case APP_ACTIVATION_BARE_DONE:
if(strcmp(appGWActivationData.configuration.key, "") == 0)
{
FATAL("Activation done, but key not filled");
}
SYS_PRINT("\r\nCNFG: Valid key, proceeding\r\n");
_changeState(STATE_ERASING_ACTIVATION_KEY);
break;
case APP_ACTIVATION_BARE_WAS_ACTIVATED:
// invalid gateway id, wipe id, start over.
SYS_PRINT("\r\nCNFG: Was already activated, wait for a key to be configured\r\n");
_changeState(STATE_NEEDS_MORE_CONFIG);
break;
case APP_ACTIVATION_BARE_NON_EXISTING_ID:
SYS_PRINT("\r\nCNFG: Non existing ID, please register this ID with The Things Network\r\n");
_changeState(STATE_NEEDS_MORE_CONFIG);
break;
case APP_ACTIVATION_BARE_ERROR:
SYS_PRINT("\r\nCNFG: Activation failed\r\n");
ErrorMessageWarning_Set(ERROR_MESSAGE_WARNING_HTTP_COMMUNICATION_FAILURE_ACTIVATION);
_changeState(STATE_COMMUNICATION_ERROR);
break;
}
}
break;
}
case STATE_ERASING_ACTIVATION_KEY:
if(APP_SERIALFLASH_IsReady())
{
_changeState(STATE_STORING_ACTIVATION_KEY);
}
break;
case STATE_STORING_ACTIVATION_KEY:
if(APP_SERIALFLASH_IsReady())
{
SYS_PRINT("\r\nCNFG: Gateway Activated\r\n");
_changeState(STATE_DOWNLOAD_LORA_CONFIG);
}
break;
case STATE_DOWNLOAD_LORA_CONFIG:
APP_Configuration_Tasks();
switch(APP_Configuration_State())
{ // REVIEW: don't check internal state, but via test function
case APP_CONFIGURATION_DONE:
if(appGWActivationData.locked)
{
_changeState(STATE_DOWNLOAD_FREQPLAN);
}
else
{
_changeState(STATE_LOCK_ACTIVATION);
}
break;
case APP_CONFIGURATION_INCOMPLETE:
_changeState(STATE_NEEDS_MORE_CONFIG);
break;
case APP_CONFIGURATION_NON_EXISTING_ID:
// invalid gateway id, wipe id, start over.
SYS_PRINT("\r\nCNFG: Non existing gateway ID, wiping and starting over\r\n");
appGWActivationData.configuration.id[0] = '\0';
appGWActivationData.configuration.key[0] = '\0';
_changeState(STATE_NEEDS_MORE_CONFIG);
break;
case APP_CONFIGURATION_KEY_FAILURE:
// invalid gateway key, wipe key start over.
SYS_PRINT("\r\nCNFG: Invalid gateway key, wiping and starting over\r\n");
appGWActivationData.configuration.key[0] = '\0';
_changeState(STATE_ACTIVATING);
break;
case APP_CONFIGURATION_SERVER_BUSY:
if(SYS_TMR_TickCountGet() - reconnectDelayStartTick >=
SYS_TMR_TickCounterFrequencyGet() *
RECONNECT_DELAY_TIMEOUT) // REVIEW: use something like isElapsed function
{
SYS_PRINT("\r\nCNFG: Server busy, retry\r\n");
_changeState(STATE_DOWNLOAD_LORA_CONFIG);
}
break;
case APP_CONFIGURATION_ERROR:
SYS_PRINT("\r\nCNFG: Downloading gateway configuration failed\r\n");
_changeState(STATE_COMMUNICATION_ERROR);
ErrorMessageWarning_Set(ERROR_MESSAGE_WARNING_HTTP_COMMUNICATION_FAILURE_CONFIGURATION);
break;
default:
break;
}
break;
case STATE_LOCK_ACTIVATION:
if(APP_SERIALFLASH_IsReady())
{
SYS_PRINT("\r\nCNFG: Gateway activation locked\r\n");
_changeState(STATE_DOWNLOAD_FREQPLAN);
}
break;
case STATE_DOWNLOAD_FREQPLAN:
// Fetch lora module configuration
if(SYS_TMR_TickCountGet() - freqDelayStartTick <= SYS_TMR_TickCounterFrequencyGet() * 2)
{
break; // take a little break after the settings fetch to be nice on the TTN server
}
APP_FreqPlan_Tasks();
switch(APP_FreqPlan_State())
{ // REVIEW: don't check internal state, but via test function
case APP_FREQPLAN_DONE:
_changeState(STATE_START_LORA_MODULE);
break;
case APP_FREQPLAN_FAILURE:
case APP_FREQPLAN_SERVER_BUSY:
SYS_PRINT("\r\nCNFG: Server busy/failure, retry\r\n");
_changeState(STATE_DOWNLOAD_FREQPLAN);
break;
case APP_FREQPLAN_ERROR:
SYS_PRINT("\r\nCNFG: Downloading frequency plan failed\r\n");
ErrorMessageWarning_Set(ERROR_MESSAGE_WARNING_HTTP_COMMUNICATION_FAILURE_FREQPLAN);
_changeState(STATE_COMMUNICATION_ERROR);
break;
}
break;
case STATE_START_LORA_MODULE:
if(APP_LORA_GET_APP_STATE() ==
APP_LORA_POLL_UART) // REVIEW: don't check internal state, but via test function
{
_changeState(STATE_DONE);
}
case STATE_COMMUNICATION_ERROR:
break;
case STATE_DONE:
break;
}
}
//==============================================================================
// Parses and executes a command
// Returns: LW232_OK in case of success, otherwise - specific error code
//------------------------------------------------------------------------------
void CAN232_Command(char * command) {
//SYS_PRINT(">%s", command);
uint8_t ret = LW232_OK;
uint8_t idx = 0;
uint8_t err = 0;
lw232_LastErr = LW232_OK;
switch (command[0]) {
case LW232_CMD_SETUP:
// Sn[CR] Setup with standard CAN bit-rates where n is 0-9.
if (lw232_CanChannelMode == LW232_STATUS_CAN_CLOSED) {
idx = parseNibbleWithLimit(command[1], LW232_CAN_BAUD_NUM);
lw232_CanSpeedSelection = lw232_CanBaudRates[idx];
}
else {
ret = LW232_ERR;
}
break;
case LW232_CMD_SETUP_BTR:
// sxxyy[CR] Setup with BTR0/BTR1 CAN bit-rates where xx and yy is a hex value.
ret = LW232_ERR; break;
case LW232_CMD_OPEN:
// O[CR] Open the CAN channel in normal mode (sending & receiving).
if (lw232_CanChannelMode == LW232_STATUS_CAN_CLOSED) {
lw232_CanChannelMode = LW232_STATUS_CAN_OPEN_NORMAL;
ret = openCanBus();
}
else {
ret = LW232_ERR;
}
break;
case LW232_CMD_LISTEN:
// L[CR] Open the CAN channel in listen only mode (receiving).
if (lw232_CanChannelMode == LW232_STATUS_CAN_CLOSED) {
lw232_CanChannelMode = LW232_STATUS_CAN_OPEN_LISTEN;
ret = openCanBus();
}
else {
ret = LW232_ERR;
}
break;
case LW232_CMD_CLOSE:
// C[CR] Close the CAN channel.
if (lw232_CanChannelMode != LW232_STATUS_CAN_CLOSED) {
lw232_CanChannelMode = LW232_STATUS_CAN_CLOSED;
closeCanBus();
}
else {
ret = LW232_ERR;
}
break;
case LW232_CMD_TX11:
// tiiildd...[CR] Transmit a standard (11bit) CAN frame.
if (lw232_CanChannelMode == LW232_STATUS_CAN_OPEN_NORMAL) {
lw232_CanId = parseCanStdId(command);
lw232_PacketLen = parseNibbleWithLimit(command[LW232_OFFSET_STD_PKT_LEN], LW232_FRAME_MAX_LENGTH);
for (idx=0; idx < lw232_PacketLen; idx++) {
lw232_Buffer[idx] = parseFullByte(command[LW232_OFFSET_STD_PKT_DATA + idx * 2],
command[LW232_OFFSET_STD_PKT_DATA + idx * 2 + 1]);
}
if (CAN_OK != sendMsgBuf(lw232_CanId, 0, 0, lw232_PacketLen, lw232_Buffer)) {
ret = LW232_ERR;
}
else if (lw232_AutoPoll) {
ret = LW232_OK_SMALL;
}
}
else {
ret = LW232_ERR;
}
break;
case LW232_CMD_TX29:
// Tiiiiiiiildd...[CR] Transmit an extended (29bit) CAN frame
if (lw232_CanChannelMode == LW232_STATUS_CAN_OPEN_NORMAL) {
lw232_CanId = parseCanExtId(command);
lw232_PacketLen = parseNibbleWithLimit(command[LW232_OFFSET_EXT_PKT_LEN], LW232_FRAME_MAX_LENGTH);
for (idx=0; idx < lw232_PacketLen; idx++) {
lw232_Buffer[idx] = parseFullByte(command[LW232_OFFSET_EXT_PKT_DATA + idx * 2],
command[LW232_OFFSET_EXT_PKT_DATA + idx * 2 + 1]);
}
if (CAN_OK != sendMsgBuf(lw232_CanId, 1, 0, lw232_PacketLen, lw232_Buffer)) {
ret = LW232_ERR;
} else if (lw232_AutoPoll) {
ret = LW232_OK_BIG;
}
}
break;
case LW232_CMD_RTR11:
// riiil[CR] Transmit an standard RTR (11bit) CAN frame.
if (lw232_CanChannelMode == LW232_STATUS_CAN_OPEN_NORMAL) {
parseCanStdId(command);
lw232_PacketLen = parseNibbleWithLimit(command[LW232_OFFSET_STD_PKT_LEN], LW232_FRAME_MAX_LENGTH);
if (CAN_OK != sendMsgBuf(lw232_CanId, 0, 1, lw232_PacketLen, lw232_Buffer)) {
ret = LW232_ERR;
}
else if (lw232_AutoPoll) {
ret = LW232_OK_SMALL;
}
}
else {
ret = LW232_ERR;
}
break;
case LW232_CMD_RTR29:
// Riiiiiiiil[CR] Transmit an extended RTR (29bit) CAN frame.
if (lw232_CanChannelMode == LW232_STATUS_CAN_OPEN_NORMAL) {
parseCanExtId(command);
lw232_PacketLen = parseNibbleWithLimit(command[LW232_OFFSET_EXT_PKT_LEN], LW232_FRAME_MAX_LENGTH);
if (CAN_OK != sendMsgBuf(lw232_CanId, 1, 1, lw232_PacketLen, lw232_Buffer)) {
ret = LW232_ERR;
}
else if (lw232_AutoPoll) {
ret = LW232_OK_SMALL; // not a typo. strangely can232_v3.pdf tells to return "z[CR]", not "Z[CR]" as in 29bit. todo: check if it is error in pdf???
}
} else {
ret = LW232_ERR;
}
break;
case LW232_CMD_POLL_ONE:
// P[CR] Poll incomming FIFO for CAN frames (single poll)
if (lw232_CanChannelMode != LW232_STATUS_CAN_CLOSED && lw232_AutoPoll == LW232_AUTOPOLL_OFF) {
if (CAN_MSGAVAIL == checkReceive()) {
ret = receiveSingleFrame();
}
} else {
ret = LW232_ERR;
}
break;
case LW232_CMD_POLL_MANY:
// A[CR] Polls incomming FIFO for CAN frames (all pending frames)
if (lw232_CanChannelMode != LW232_STATUS_CAN_CLOSED && lw232_AutoPoll == LW232_AUTOPOLL_OFF) {
while (CAN_MSGAVAIL == checkReceive()) {
ret = ret ^ receiveSingleFrame();
if (ret != CAN_OK)
break;
printChar(LW232_CR);
}
if (ret == CAN_OK)
printChar(LW232_ALL);
} else {
ret = LW232_ERR;
}
break;
case LW232_CMD_FLAGS:
// F[CR] Read Status Flags.
// LAWICEL CAN232 and CANUSB have some specific errors which differ from MCP2515/MCP2551 errors. We just return MCP2515 error.
printChar(LW232_FLAG);
if (checkError(&err) == CAN_OK)
err = 0;
printFullByte(err & 0xFF); //MCP_EFLG_ERRORMASK);
break;
case LW232_CMD_AUTOPOLL:
// Xn[CR] Sets Auto Poll/Send ON/OFF for received frames.
if (lw232_CanChannelMode == LW232_STATUS_CAN_CLOSED) {
lw232_AutoPoll = (command[1] == LW232_ON_ONE) ? LW232_AUTOPOLL_ON : LW232_AUTOPOLL_OFF;
//todo: save to eeprom
} else {
ret = LW232_ERR;
}
break;
case LW232_CMD_FILTER:
// Wn[CR] Filter mode setting. By default CAN232 works in dual filter mode (0) and is backwards compatible with previous CAN232 versions.
ret = LW232_ERR_NOT_IMPLEMENTED; break;
case LW232_CMD_ACC_CODE:
// Mxxxxxxxx[CR] Sets Acceptance Code Register (ACn Register of SJA1000). // we use MCP2515,
ret = LW232_ERR_NOT_IMPLEMENTED; break;
case LW232_CMD_ACC_MASK:
// mxxxxxxxx[CR] Sets Acceptance Mask Register (AMn Register of SJA1000).
ret = LW232_ERR_NOT_IMPLEMENTED; break;
case LW232_CMD_UART:
// Un[CR] Setup UART with a new baud rate where n is 0-6.
idx = parseNibbleWithLimit(command[1], LW232_UART_BAUD_NUM);
SYS_PRINT("%d",lw232_SerialBaudRates[idx]);
break;
case LW232_CMD_VERSION1:
case LW232_CMD_VERSION2:
// V[CR] Get Version number of both CAN232 hardware and software
SYS_PRINT(LW232_LAWICEL_VERSION_STR);
break;
case LW232_CMD_SERIAL:
// N[CR] Get Serial number of the CAN232.
SYS_PRINT(LW232_LAWICEL_SERIAL_NUM);
break;
case LW232_CMD_TIMESTAMP:
// Zn[CR] Sets Time Stamp ON/OFF for received frames only. Z0 - OFF, Z1 - Lawicel's timestamp 2 bytes, Z2 - arduino timestamp 4 bytes.
if (lw232_CanChannelMode == LW232_STATUS_CAN_CLOSED) {
// lw232_TimeStamp = (command[1] == LW232_ON_ONE);
if (command[1] == LW232_ON_ONE) {
lw232_TimeStamp = LW232_TIMESTAMP_ON_NORMAL;
}
else if (command[1] == LW232_ON_TWO) {
lw232_TimeStamp = LW232_TIMESTAMP_ON_EXTENDED;
}
else {
lw232_TimeStamp = LW232_TIMESTAMP_OFF;
}
}
else {
ret = LW232_ERR;
}
break;
case LW232_CMD_AUTOSTART:
// Qn[CR] Auto Startup feature (from power on).
if (lw232_CanChannelMode != LW232_STATUS_CAN_CLOSED) {
if (command[1] == LW232_ON_ONE) {
lw232_AutoStart = LW232_AUTOSTART_ON_NORMAL;
}
else if (command[1] == LW232_ON_TWO) {
lw232_AutoStart = LW232_AUTOSTART_ON_LISTEN;
}
else {
lw232_AutoStart = LW232_AUTOSTART_OFF;
}
//todo: save to eeprom
}
else {
ret = LW232_ERR;
}
break;
default:
ret = LW232_ERR_UNKNOWN_CMD;
}
lw232_LastErr = ret; //parseAndRunCommand();
switch (lw232_LastErr) {
case LW232_OK:
printChar(LW232_RET_ASCII_OK);
break;
case LW232_OK_SMALL:
printChar(LW232_RET_ASCII_OK_SMALL);
printChar(LW232_RET_ASCII_OK);
break;
case LW232_OK_BIG:
printChar(LW232_RET_ASCII_OK_BIG);
printChar(LW232_RET_ASCII_OK);
break;
case LW232_ERR_NOT_IMPLEMENTED:
// Choose behavior: will it fail or not when not implemented command comes in. Some can monitors might be affected by this selection.
printChar(LW232_RET_ASCII_ERROR);
//SYS_PRINT(LW232_RET_ASCII_OK);
break;
default:
printChar(LW232_RET_ASCII_ERROR);
}
}
void SSMWaitForInternet_Tasks(void)
{
switch(_state)
{
case STATE_WAIT_FOR_NETWORK:
if(APP_ETH_Has_Link())
{
SYS_PRINT("INET: Gateway has Ethernet\r\n");
_changeState(STATE_SETTLE);
}
else if(!appWifiData.valid)
{
SYS_PRINT("INET: No Ethernet and no WiFi config\r\n");
_changeState(STATE_AP_ONLY);
}
if(APP_WIFI_Has_LinkINFRA())
{
SYS_PRINT("INET: Gateway has WiFi\r\n");
_changeState(STATE_SETTLE);
}
break;
case STATE_AP_ONLY:
if(APP_ETH_Has_Link())
{
_changeState(STATE_WAIT_FOR_NETWORK);
}
else if(appWifiData.valid && ((SYS_TMR_TickCountGet() - wifiRetryStartTick) >=
(SYS_TMR_TickCounterFrequencyGet() * WIFI_RETRY_TIMEOUT)))
{ // REVIEW: Use isElapsed kind of function
if(APP_WIFI_Has_LinkAP())
{
if(firstTimeAPReconnectTimeout)
{
SYS_PRINT("INET: Not trying to connect to WiFi router again because client is connected (after "
"%d seconds)\r\n",
(SYS_TMR_TickCountGet() - wifiRetryStartTick) / SYS_TMR_TickCounterFrequencyGet());
firstTimeAPReconnectTimeout = false;
}
}
else
{
SYS_PRINT("INET: Trying to connect to WiFi router again (after %d seconds)\r\n",
(SYS_TMR_TickCountGet() - wifiRetryStartTick) / SYS_TMR_TickCounterFrequencyGet());
_changeState(STATE_WAIT_FOR_NETWORK);
}
}
break;
case STATE_SETTLE:
if((SYS_TMR_TickCountGet() - settleStartTick) >= (SYS_TMR_TickCounterFrequencyGet() * 5))
{
_changeState(STATE_PING_PROBE);
}
break;
case STATE_PING_PROBE:
if(!ping_probe_sent)
{
IPV4_ADDR googledns = {0};
googledns.v[0] = 8;
googledns.v[1] = 8;
googledns.v[2] = 4;
googledns.v[3] = 4;
ping_probe_reply_received = false;
SYS_PRINT("INET: Ping probe\r\n");
if(TCPIP_ICMP_EchoRequestSend(TCPIP_STACK_IndexToNet(WIFI_INTERFACE_NUM), &googledns, 0, 0x1234) !=
ICMP_ECHO_OK)
{
SYS_PRINT("INET: Error sending probe on WiFi\r\n");
}
if(TCPIP_ICMP_EchoRequestSend(TCPIP_STACK_IndexToNet(ETH_INTERFACE_NUM), &googledns, 0, 0x1234) !=
ICMP_ECHO_OK)
{
SYS_PRINT("INET: Error sending probe on Eth\r\n");
}
ping_probe_sent = true;
}
else if(ping_probe_reply_received)
{
SYS_PRINT("INET: Ping response from %s, set as default\r\n",
TCPIP_STACK_NetNameGet(TCPIP_STACK_NetDefaultGet()));
if(ntpEverSynchronized)
{
_changeState(STATE_DONE);
}
else
{
_changeState(STATE_WAIT_FOR_NTP);
}
break;
}
else
{
if((SYS_TMR_TickCountGet() - pingStartTick) >=
(SYS_TMR_TickCounterFrequencyGet() * PING_TIMEOUT)) // REVIEW: Use isElapsed kind of function
{
SYS_PRINT("INET: Ping Timeout of :%d seconds\r\n", PING_TIMEOUT);
pingStartTick = SYS_TMR_TickCountGet();
ping_probe_sent = false;
ping_probe_reply_received = false;
if(ping_retry >= PING_RETRIES)
{
// TODO: find a proper recovery -> _changeState(STATE_WAIT_FOR_NETWORK);
RebootWithMessage("Ping timeout %d retries, rebooting", PING_RETRIES);
}
ping_retry++;
}
}
break;
case STATE_WAIT_FOR_NTP:
{
uint32_t lastUpdate = 0;
TCPIP_SNTP_TimeStampGet(NULL, &lastUpdate);
if(lastUpdate != 0)
{ // If at least once NTP succeeded
ntpEverSynchronized = true;
_changeState(STATE_DONE);
}
else
{
if((SYS_TMR_TickCountGet() - ntpStartTick) >= (SYS_TMR_TickCounterFrequencyGet() * NTP_TIMEOUT))
{ // REVIEW: Use isElapsed kind of function
SYS_PRINT("INET: Not received any NTP response. Wait for network again (after %d seconds).\r\n",
(SYS_TMR_TickCountGet() - ntpStartTick) / SYS_TMR_TickCounterFrequencyGet());
_changeState(STATE_WAIT_FOR_NETWORK);
}
else if(TCPIP_SNTP_ConnectionInitiate() == SNTP_RES_OK)
{
SYS_PRINT("INET: Initiated NTP request.\r\n");
}
}
break;
}
case STATE_DONE:
break;
}
}
void APP_Tasks ( void )
{
/* Check the application's current state. */
switch ( appData.state )
{
/* Application's initial state. */
case APP_STATE_INIT:
{
SYS_CONSOLE_Flush( SYS_CONSOLE_INDEX_0 );
//ssize_t nr;
//char myBuffer[] = "\r\npic-CAN-mon";
//nr = SYS_CONSOLE_Write( SYS_CONSOLE_INDEX_0, STDOUT_FILENO, myBuffer, strlen(myBuffer) );
//if (nr != strlen(myBuffer))
//{
// // Handle error
//}
SYS_PRINT("\r\npicCANmon");
appData.state = APP_STATE_IDLE;
break;
}
case APP_STATE_IDLE:
{
PLIB_PORTS_PinToggle(PORTS_ID_0, PORT_CHANNEL_G,
PORTS_BIT_POS_14);
/*
CAN_CHANNEL_EVENT channelEvent;
channelEvent = PLIB_CAN_ChannelEventGet(CAN_ID_1, CAN_CHANNEL1);
if((channelEvent & (CAN_RX_CHANNEL_NOT_EMPTY | CAN_RX_CHANNEL_FULL)) != 0) {
SYS_MESSAGE("\r\nCAN RX\r\n");
PLIB_PORTS_PinToggle(PORTS_ID_0, PORT_CHANNEL_G,
PORTS_BIT_POS_12);
}
*/
CAN232_Tasks();
ssize_t nr = 0;
do {
nr = SYS_CONSOLE_ReadX( SYS_CONSOLE_INDEX_0, STDIN_FILENO,
&cmdBuffer[cmdTail], 0 );
if (nr > 0)
{
cmdTail += nr;
if (cmdTail >= sizeof(cmdBuffer))
cmdTail = 0;
//cmdBuffer[cmdTail] = 0;
appData.state = APP_STATE_INPUT;
PLIB_PORTS_PinToggle(PORTS_ID_0, PORT_CHANNEL_G,
PORTS_BIT_POS_15);
}
} while (nr > 0);
break;
}
case APP_STATE_INPUT:
{
appData.state = APP_STATE_IDLE;
if (cmdTail > 0) {
PLIB_PORTS_PinToggle(PORTS_ID_0, PORT_CHANNEL_G,
PORTS_BIT_POS_13);
char ch = cmdBuffer[cmdTail-1];
if (ch < ' ') {
if (ch == '\r' || ch == '\n') {
cmdBuffer[cmdTail] = 0;
appData.state = APP_STATE_COMMAND;
}
cmdTail = 0;
}
else
{
// echo back
if (echoInput)
SYS_CONSOLE_Write( SYS_CONSOLE_INDEX_0, STDOUT_FILENO,
&cmdBuffer[cmdTail-1], 1);
}
}
break;
}
case APP_STATE_COMMAND: {
//SYS_PRINT("\r\nCMD:%s", cmdBuffer);
CAN232_Command(cmdBuffer);
cmdBuffer[0] = 0; // Reset command buffer
cmdTail = 0;
appData.state = APP_STATE_IDLE;
break;
}
/* TODO: implement your application state machine.*/
/* The default state should never be executed. */
default:
{
/* TODO: Handle error in application's state machine. */
break;
}
}
}
void printChar(char c) {
SYS_PRINT("%c", c);
}
void APP_Tasks(void) {
/*
* Processing CC3100 Tasks
* It looks like SYS task and might be processed in SYS_Tasks
* But for this demo it is here to make this call
* visible
*/
_SlNonOsMainLoopTask();
/* Check the application's current state. */
switch (appData.state) {
/* Application's initial state. */
case APP_STATE_INIT: {
SYS_PRINT("\n\r*** PIC32 MQTT CLIENT ***\n\r");
SYS_PRINT("\n\rInitializing CC3100\n\r");
int res = sl_Start(NULL, NULL, NULL);
if (res != 0) {
SYS_PRINT("FAILED\n\r");
appData.state = APP_STATE_DONE;
break;
}
SlSecParams_t sec_params;
memset(&sec_params, 0, sizeof(sec_params));
sec_params.Key = NET_PWD;
sec_params.KeyLen = sizeof(NET_PWD) - 1;
sec_params.Type = NET_SECURITY;
SYS_PRINT("Connecting to WiFi\n\r");
sl_WlanConnect(NET_SSID, sizeof(NET_SSID) - 1, 0, &sec_params, NULL);
SYS_PRINT("Initialization done\n\r");
appData.state = APP_STATE_SERVICE_TASKS;
break;
}
case APP_STATE_CONNECT_BROKER: {
if (mg_connect(&mgr, MQTT_BROKER_ADDRESS, ev_handler) == NULL) {
SYS_PRINT("Failed to create connection\n\r");
appData.state = APP_STATE_DONE;
} else {
appData.state = APP_STATE_SERVICE_TASKS;
}
break;
}
case APP_STATE_SERVICE_TASKS: {
static uint32_t prev_poll_time = 0;
uint32_t now = DRV_RTCC_TimeGet();
if (now - prev_poll_time > 100) {
/*
* We cannot call mg_mgr_poll every cycle
* it leads to SPI overload (internaly mg_mgr_poll calls
* CC3100 via SPI
*/
mg_mgr_poll(&mgr, 1);
prev_poll_time = now;
}
break;
}
case APP_STATE_DONE: {
/* Do nothing here */
break;
}
default: {
/* TODO: Handle error in application's state machine. */
break;
}
}
}
void printFullByte(uint8_t b) {
SYS_PRINT("%02X", b);
}
void printNibble(uint8_t b) {
SYS_PRINT("%1X", b & 0x0F);
}
