// called to send the first/next chunk of a command to another scout
static void leadCommandChunk() {
  int len = leadCommandChunks.length() - leadCommandChunksAt;
  if (len > 100) {
    len = 100;
  } else {
    len++; // null terminator at end
  }

  leadCommandReq.dstAddr = leadCommandTo;
  leadCommandReq.dstEndpoint = 2;
  leadCommandReq.srcEndpoint = 3;
  leadCommandReq.options = NWK_OPT_ENABLE_SECURITY;
  leadCommandReq.data = (uint8_t*)leadCommandChunks.c_str() + leadCommandChunksAt;
  leadCommandReq.size = len;
  leadCommandReq.confirm = leadCommandChunkConfirm;
  NWK_DataReq(&leadCommandReq);
  //RgbLed.blinkCyan(200);

  if (hqVerboseOutput) {
    Serial.print(leadCommandTo);
    Serial.print(F(" len "));
    Serial.print(len);
    Serial.println(F("->chunk"));
  }
}
Ejemplo n.º 2
0
static void appSendData(void)
{
#ifdef NWK_ENABLE_ROUTING
  appMsg.parentShortAddr = NWK_RouteNextHop(0, 0);
#else
  appMsg.parentShortAddr = 0;
#endif

  appMsg.sensors.battery     = rand() & 0xffff;
  appMsg.sensors.temperature = rand() & 0x7f;
  appMsg.sensors.light       = rand() & 0xff;

#if APP_COORDINATOR
  appSendMessage((uint8_t *)&appMsg, sizeof(appMsg));
  SYS_TimerStart(&appDataSendingTimer);
  appState = APP_STATE_WAIT_SEND_TIMER;
#else
  nwkDataReq.dstAddr = 0;
  nwkDataReq.dstEndpoint = APP_ENDPOINT;
  nwkDataReq.srcEndpoint = APP_ENDPOINT;
  nwkDataReq.options = NWK_OPT_ACK_REQUEST | NWK_OPT_ENABLE_SECURITY;
  nwkDataReq.data = (uint8_t *)&appMsg;
  nwkDataReq.size = sizeof(appMsg);
  nwkDataReq.confirm = appDataConf;

  LED_On(LED_DATA);
  NWK_DataReq(&nwkDataReq);

  appState = APP_STATE_WAIT_CONF;
#endif
}
Ejemplo n.º 3
0
// mesh callback when sending command chunks
static void leadCommandChunkConfirm(NWK_DataReq_t *req) {
  if (hqVerboseOutput) {
    Serial.print(F("  Message confirmation - "));
  }
  if (req->status == NWK_SUCCESS_STATUS) {
    if (hqVerboseOutput) {
      Serial.println(F("success"));
    }
    if (leadCommandChunks.length() - leadCommandChunksAt > 100) {
      leadCommandChunksAt += 100;
      leadCommandChunk();
      return; // don't free yet
    }
  } else {
    leadCommandRetries++;
    if (leadCommandRetries > 3) {
      if (hqVerboseOutput) {
        Serial.print(F("error: "));
        Serial.println(req->status);
      }
      leadCommandError(leadCommandTo, leadAnswerID, "no response");
    } else {
      if (hqVerboseOutput) {
        Serial.println(F("RETRY"));
      }
      NWK_DataReq(req);
      return; // don't free yet
    }
  }
  leadCommandTo = 0;
  leadCommandChunks = (char*)NULL;
}
Ejemplo n.º 4
0
static void fieldAnswerChunkConfirm(NWK_DataReq_t *req) {
  if (hqVerboseOutput) {
    sp("  Message confirmation - ");
  }
  if (req->status == NWK_SUCCESS_STATUS) {
    if (hqVerboseOutput) {
      speol("success");
    }
    if (strlen(fieldAnswerChunks + fieldAnswerChunksAt) > 100) {
      fieldAnswerChunksAt += 100;
      fieldAnswerChunk();
      return; // don't free yet
    }
  } else {
    fieldAnswerRetries++;
    if (fieldAnswerRetries > 3) {
      if (hqVerboseOutput) {
        sp("error: ");
        speol(req->status);
      }
    } else {
      if (hqVerboseOutput) {
        speol("RETRY");
      }
      NWK_DataReq(req);
      return; // don't free yet
    }
  }
  fieldAnswerTo = 0;
  free(fieldAnswerChunks);
}
Ejemplo n.º 5
0
// called to send the first/next chunk of a command to another scout
static void leadCommandChunk() {
  int len = strlen(leadCommandChunks + leadCommandChunksAt);
  if (len > 100) {
    len = 100;
  } else {
    len++; // null terminator at end
  }

  leadCommandReq.dstAddr = leadCommandTo;
  leadCommandReq.dstEndpoint = 2;
  leadCommandReq.srcEndpoint = 3;
  leadCommandReq.options = NWK_OPT_ENABLE_SECURITY;
  leadCommandReq.data = (uint8_t*)(leadCommandChunks+leadCommandChunksAt);
  leadCommandReq.size = len;
  leadCommandReq.confirm = leadCommandChunkConfirm;
  NWK_DataReq(&leadCommandReq);
  //RgbLed.blinkCyan(200);

  if (hqVerboseOutput) {
    sp(leadCommandTo);
    sp(" len ");
    sp(len);
    speol("->chunk");
  }
}
Ejemplo n.º 6
0
void radioSendData(uint8_t *data, uint8_t size)
{

/*
	if (appDataReqBusy || 0 == appChannelBufferPtr) {
		return;
	}
*/
	if (radioDataReqBusy) {
//		puts("radio busy");
		return;
	}

	//memcpy(appDataReqBuffer, appUartBuffer, appUartBufferPtr);

	radioDataReq.dstAddr = 1 - APP_ADDR;
	radioDataReq.dstEndpoint = APP_ENDPOINT;
	radioDataReq.srcEndpoint = APP_ENDPOINT;
	radioDataReq.options = NWK_OPT_ENABLE_SECURITY;
	radioDataReq.data = data; //appDataReqBuffer; //
	radioDataReq.size = size;//sizeof(data); //appUartBufferPtr; //
	radioDataReq.confirm = radioDataConf;
	NWK_DataReq(&radioDataReq);
	
	printf("sending \n\r channel 0 value = %u\n\r channel 1 value = %u\n\r", data[0],data[1]);

	//appUartBufferPtr = 0;
	radioDataReqBusy = true;
	port_pin_toggle_output_level(LED_0_PIN);
}
Ejemplo n.º 7
0
// mesh callback when sending command chunks
static void leadCommandChunkConfirm(NWK_DataReq_t *req) {
  if (hqVerboseOutput) {
    sp("  Message confirmation - ");
  }
  if (req->status == NWK_SUCCESS_STATUS) {
    if (hqVerboseOutput) {
      speol("success");
    }
    if (strlen(leadCommandChunks+leadCommandChunksAt) > 100) {
      leadCommandChunksAt += 100;
      leadCommandChunk();
      return; // don't free yet
    }
  } else {
    leadCommandRetries++;
    if (leadCommandRetries > 3) {
      if (hqVerboseOutput) {
        sp("error: ");
        speol(req->status);
      }
      leadCommandError(leadCommandTo, leadAnswerID, "no response");
    } else {
      if (hqVerboseOutput) {
        speol("RETRY");
      }
      NWK_DataReq(req);
      return; // don't free yet
    }
  }
  leadCommandTo = 0;
  free(leadCommandChunks);
}
Ejemplo n.º 8
0
/*************************************************************************//**
*****************************************************************************/
void OTA_ServerSendBlock(uint8_t *data)
{
  uint8_t size;

  if (OTA_SERVER_STATE_READY != otaServer.state)
    return;

  if (otaServer.size > OTA_MAX_BLOCK_SIZE)
    size = OTA_MAX_BLOCK_SIZE;
  else
    size = otaServer.size;

  otaServer.state = OTA_SERVER_STATE_BLOCK_REQ_SENT;
  otaServer.size -= size;

  for (uint8_t i = 0; i < size; i++)
    otaServer.crc = otaCrcUpdateCcitt(otaServer.crc, data[i]);

  otaDataReq.dstAddr = otaServer.client;
  otaDataReq.size = sizeof(OtaBlockReqHeader_t) + size;
  otaDataReq.options = 0;

  otaCommand.block.commandId = OTA_BLOCK_REQ_COMMAND_ID;
  otaCommand.block.sessionId = otaServer.sessionId;
  otaCommand.block.crc = otaServer.crc;
  otaCommand.block.size = size;

  memcpy(otaCommand.block.data, data, size);

  NWK_DataReq(&otaDataReq);
}
Ejemplo n.º 9
0
static void fieldAnswerChunkConfirm(NWK_DataReq_t *req) {
  if (hqVerboseOutput) {
    Serial.print(F("  Message confirmation - "));
  }
  if (req->status == NWK_SUCCESS_STATUS) {
    if (hqVerboseOutput) {
      Serial.println(F("success"));
    }
    if (fieldCommandOutput.length() - fieldAnswerChunksAt > 100) {
      fieldAnswerChunksAt += 100;
      fieldAnswerChunk();
      return; // don't free yet
    }
  } else {
    fieldAnswerRetries++;
    if (fieldAnswerRetries > 3) {
      if (hqVerboseOutput) {
        Serial.print(F("error: "));
        Serial.println(req->status);
      }
    } else {
      if (hqVerboseOutput) {
        Serial.println(F("RETRY"));
      }
      NWK_DataReq(req);
      return; // don't free yet
    }
  }
  fieldAnswerTo = 0;
  // Free memory used by Stringbuffer
  fieldCommandOutput = (char*)NULL;
}
Ejemplo n.º 10
0
/*************************************************************************//**
*****************************************************************************/
static void appCmdDataRequest(AppCmdPendingTableEntry_t *entry)
{
	appCmdInProgress = entry;

	appCmdDataReq.dstAddr = entry->addr;
	appCmdDataReq.data = &entry->payload;
	appCmdDataReq.size = entry->size;
	NWK_DataReq(&appCmdDataReq);
}
Ejemplo n.º 11
0
static void announceConfirm(NWK_DataReq_t *req) {
//if (hqVerboseOutput) speol("announce confirmed");
  struct announceQ_t *next = announceQ->next;
  free(req->data);
  free(announceQ);
  announceQ = next;
  if (next) {
    NWK_DataReq(&(next->req));
  }
}
Ejemplo n.º 12
0
/*************************************************************************//**
*****************************************************************************/
static AppStatus_t appProcessDataReq(AppCommandDataReq_t *req)
{
	NWK_DataReq_t *dataReq = NULL;
	uint8_t size;

	for (uint8_t i = 0; i < APP_NUMBER_OF_REQUEST_BUFFERS; i++) {
		if (false == appRequestBuffer[i].busy) {
			appRequestBuffer[i].busy = true;
			appRequestBuffer[i].handle = req->handle;
			dataReq = &appRequestBuffer[i].req;
			break;
		}
	}

	if (NULL == dataReq) {
		return APP_STATUS_OUT_OF_MEMORY;
	}

	size = NWK_MAX_PAYLOAD_SIZE;

#ifdef NWK_ENABLE_SECURITY
	if (req->options & NWK_OPT_ENABLE_SECURITY) {
		size -= NWK_SECURITY_MIC_SIZE;
	}

#endif

#ifdef NWK_ENABLE_MULTICAST
	if (req->options & NWK_OPT_MULTICAST) {
		size -= NWK_MULTICAST_HEADER_SIZE;
	}

#endif

	if (req->size > size) {
		return APP_STATUS_INVALID_PARAMETERS;
	}

	dataReq->dstAddr = req->dstAddr;
	dataReq->dstEndpoint = req->dstEndpoint;
	dataReq->srcEndpoint = req->srcEndpoint;
	dataReq->options = req->options;
#ifdef NWK_ENABLE_MULTICAST
	dataReq->memberRadius = req->memberRadius;
	dataReq->nonMemberRadius = req->nonMemberRadius;
#endif
	dataReq->size = req->size;
	memcpy(dataReq->data, &req->data, req->size);
	dataReq->confirm = appDataConf;

	NWK_DataReq(dataReq);

	return APP_STATUS_SUCESS;
}
Ejemplo n.º 13
0
void announceQSend(void){
  if(!announceQ[0]) return;
  Scout.meshJoinGroup(announceQG[0]);
  announceReq.dstAddr = announceQG[0];
  announceReq.dstEndpoint = 4;
  announceReq.srcEndpoint = Scout.getAddress();
  announceReq.options = NWK_OPT_MULTICAST|NWK_OPT_ENABLE_SECURITY;
  announceReq.data = (uint8_t*)announceQ[0];
  announceReq.size = strlen(announceQ[0]) + 1; // include NUL byte
  announceReq.confirm = announceConfirm;
  NWK_DataReq(&announceReq);
}
Ejemplo n.º 14
0
/*************************************************************************//**
*****************************************************************************/
static void otaRequestRetry(void)
{
  if (0 == --otaServer.retries)
  {
    otaServer.state = OTA_SERVER_STATE_IDLE;
    OTA_ServerNotification(OTA_NO_RESPONSE_STATUS);
  }
  else
  {
    otaServer.state &= ~OTA_SERVER_STATE_WAIT_RESP_MASK;
    NWK_DataReq(&otaDataReq);
  }
}
Ejemplo n.º 15
0
static void unitDataReq(void)
{
	NWK_DataReq_t nwkDataReq;
	uint8_t appMsg[10] = "UnitTest\n\r";
	nwkDataReq.dstAddr = 0;
	nwkDataReq.dstEndpoint = APP_ENDPOINT;
	nwkDataReq.srcEndpoint = APP_ENDPOINT;
	nwkDataReq.data = (uint8_t *)&appMsg;
	nwkDataReq.size = sizeof(appMsg);
	nwkDataReq.confirm = unitDataConf;
	NWK_DataReq(&nwkDataReq);
	NetworkStatusTimer.interval = 2000;
	NetworkStatusTimer.mode = SYS_TIMER_PERIODIC_MODE;
	NetworkStatusTimer.handler = NetworkStatusTimerHandler;
	SYS_TimerStart(&NetworkStatusTimer);
}
Ejemplo n.º 16
0
static void appSendData(void)
{
  if (appDataReqBusy)
    return;

  appDataReq.dstAddr = 1;
  appDataReq.dstEndpoint = APP_ENDPOINT;
  appDataReq.srcEndpoint = APP_ENDPOINT;
  appDataReq.options = NWK_OPT_ENABLE_SECURITY;
  appDataReq.data = &appPingCounter;
  appDataReq.size = sizeof(appPingCounter);
  appDataReq.confirm = appSendDataConf;
  NWK_DataReq(&appDataReq);

  appPingCounter++;
  appDataReqBusy = true;
}
Ejemplo n.º 17
0
static void appSendData(void){
	if (appDataReqBusy || 0 == appUartBufferPtr)
	return;

	memcpy(appDataReqBuffer, appUartBuffer, appUartBufferPtr);

	appDataReq.dstAddr = 1-APP_ADDR;
	appDataReq.dstEndpoint = APP_ENDPOINT;
	appDataReq.srcEndpoint = APP_ENDPOINT;
	appDataReq.options = NWK_OPT_ENABLE_SECURITY;
	appDataReq.data = appDataReqBuffer;
	appDataReq.size = appUartBufferPtr;
	appDataReq.confirm = appDataConf;
	NWK_DataReq(&appDataReq);

	appUartBufferPtr = 0;
	appDataReqBusy = true;
}
Ejemplo n.º 18
0
void PinoccioScoutHandler::announce(uint16_t group, char *message) {
  if (hqVerboseOutput) {
    sp("announcing to ");
    sp(group);
    sp(" ");
    speol(message);
  }

  // when lead scout, shortcut
  if (Scout.isLeadScout()) {
    leadAnnouncementSend(group, Scout.getAddress(), message);
  }

  char *data = strdup(message);
  if (!data) {
    return;
  }

  struct announceQ_t *r = (struct announceQ_t*)malloc(sizeof(struct announceQ_t));
  if (!r) {
    return;
  }

  Scout.meshJoinGroup(group); // must be joined to send
  memset(r, 0, sizeof(struct announceQ_t));
  r->req.dstAddr = group;
  r->req.dstEndpoint = 4;
  r->req.srcEndpoint = Scout.getAddress();
  r->req.options = NWK_OPT_MULTICAST|NWK_OPT_ENABLE_SECURITY;
  r->req.data = (uint8_t*)data;
  r->req.size = strlen(data)+1;
  r->req.confirm = announceConfirm;
  if (!announceQ) {
    announceQ = r;
    NWK_DataReq(&(r->req));
  } else {
    struct announceQ_t *last = announceQ;
    while(last->next) last = last->next;
    last->next = r;
  }
}
Ejemplo n.º 19
0
void timeoutTimerHandler(SYS_Timer_t *timer)
{
	if (!NWK_Busy())
		{
			frame[0] = 0x06;
			frame[1] = 0xBB;
			frame[2] = 0xBB;
			frame[3] = 0xBB;
			frame[4] = 0xBB;

			nwkDataReq.dstAddr = 0x389C;
			nwkDataReq.dstEndpoint = 1;
			nwkDataReq.srcEndpoint = 1;
			nwkDataReq.size = sizeof(frame);
			nwkDataReq.data = frame;
			nwkDataReq.confirm = appDataConf;

			NWK_DataReq(&nwkDataReq);
		}
	startTimeoutTimer();
}
Ejemplo n.º 20
0
/*************************************************************************//**
*****************************************************************************/
static bool appResponderDataInd(NWK_DataInd_t *ind)
{
	NWK_DataReq_t *dataReq = NULL;
	uint8_t options = 0;

	if (ind->data[0] == 0xff) {
		return true;
	}

	for (uint8_t i = 0; i < APP_NUMBER_OF_REQUEST_BUFFERS; i++) {
		if (false == appRequestBuffer[i].busy) {
			appRequestBuffer[i].busy = true;
			dataReq = &appRequestBuffer[i].req;
			break;
		}
	}

	if (NULL == dataReq) {
		return false;
	}

	options
		|= (ind->options &
			NWK_IND_OPT_ACK_REQUESTED) ? NWK_OPT_ACK_REQUEST : 0;
	options
		|= (ind->options &
			NWK_IND_OPT_SECURED) ? NWK_OPT_ENABLE_SECURITY : 0;

	dataReq->dstAddr = ind->srcAddr;
	dataReq->dstEndpoint = ind->srcEndpoint;
	dataReq->srcEndpoint = ind->dstEndpoint;
	dataReq->options = options;
	dataReq->size = ind->size;
	memcpy(dataReq->data, ind->data, ind->size);
	dataReq->confirm = appResponderDataConf;

	NWK_DataReq(dataReq);

	return true;
}
Ejemplo n.º 21
0
/*************************************************************************//**
*****************************************************************************/
void OTA_ServerStartUpdrade(uint16_t addr, uint32_t size)
{
  SYS_TimerStop(&otaResponseTimer);
  SYS_TimerStop(&otaFrameSpacingTimer);

  otaServer.state = OTA_SERVER_STATE_START_REQ_SENT;
  otaServer.sessionId = rand();
  otaServer.client = addr;
  otaServer.size = size;
  otaServer.crc = 0;
  otaServer.retries = OTA_MAX_RETRIES;

  otaDataReq.dstAddr = addr;
  otaDataReq.size = sizeof(OtaStartReqCommand_t);
  otaDataReq.options = NWK_OPT_ACK_REQUEST;

  otaCommand.start.commandId = OTA_START_REQ_COMMAND_ID;
  otaCommand.start.sessionId = otaServer.sessionId;
  otaCommand.start.size = size;

  NWK_DataReq(&otaDataReq);
}
Ejemplo n.º 22
0
static void fieldAnswerChunk() {
  int len = fieldCommandOutput.length() - fieldAnswerChunksAt;
  if (len > 100) {
    len = 100;
  } else {
    len++; // null terminator at end
  }

  fieldAnswerReq.dstAddr = fieldAnswerTo;
  fieldAnswerReq.dstEndpoint = 3;
  fieldAnswerReq.srcEndpoint = 2;
  fieldAnswerReq.options = NWK_OPT_ENABLE_SECURITY;
  fieldAnswerReq.data = (uint8_t*)fieldCommandOutput.c_str() + fieldAnswerChunksAt;
  fieldAnswerReq.size = len;
  fieldAnswerReq.confirm = fieldAnswerChunkConfirm;
  NWK_DataReq(&fieldAnswerReq);

  if (hqVerboseOutput) {
    Serial.print(fieldAnswerTo);
    Serial.print(F(" len "));
    Serial.print(len);
    Serial.println(F("->chunk"));
  }
}
Ejemplo n.º 23
0
static void fieldAnswerChunk() {
  int len = strlen(fieldAnswerChunks+fieldAnswerChunksAt);
  if (len > 100) {
    len = 100;
  } else {
    len++; // null terminator at end
  }

  fieldAnswerReq.dstAddr = fieldAnswerTo;
  fieldAnswerReq.dstEndpoint = 3;
  fieldAnswerReq.srcEndpoint = 2;
  fieldAnswerReq.options = NWK_OPT_ENABLE_SECURITY;
  fieldAnswerReq.data = (uint8_t*)(fieldAnswerChunks + fieldAnswerChunksAt);
  fieldAnswerReq.size = len;
  fieldAnswerReq.confirm = fieldAnswerChunkConfirm;
  NWK_DataReq(&fieldAnswerReq);

  if (hqVerboseOutput) {
    sp(fieldAnswerTo);
    sp(" len ");
    sp(len);
    speol("->chunk");
  }
}
Ejemplo n.º 24
0
int main(void) {
	SYS_Init(); // Init Atmel Lightweight Mesh stack

	SYS_TaskHandler(); // Call the system task handler once before we configure the radio
	NWK_SetAddr(eeprom_read_word((uint16_t*)0));
	NWK_SetPanId(0); // Default PAN ID will be 0, can be changed using the set PAN command
	PHY_SetChannel(APP_CHANNEL);
	//NWK_SetSecurityKey(APP_SECURITY_KEY);
	PHY_SetRxState(true);
	NWK_OpenEndpoint(APP_ENDPOINT, rfReceivePacket);
	PHY_SetTxPower(0);

	// Seed the pseudorandom number generator
	srand(eeprom_read_word((uint16_t*)0));

	// Read eeprom data
	eeprom_read_block(&deviceCalibration, (void*)8, sizeof(deviceCalibration));
	if (eeprom_read_byte((uint8_t*)26)) { // There is valid data in the network information struct
		eeprom_read_block(baseStationList, (void*)27, sizeof(struct baseStation));
		uint8_t ch = 17;
		while ((baseStationList[0].name[ch] == ' ') || (baseStationList[0].name[ch] == '\0') || (baseStationList[0].name[ch] == 0xFF)) {
			baseStationList[0].name[ch] = ' ';
			ch -= 1;
		}
		baseStationList[0].nameLen = ch+1;
		baseStationListLength += 1;

		for (int cnt = 0; cnt < BASESTATION_LIST_SIZE; cnt++) {
			baseStationList[cnt].name[16] = ' ';
			baseStationList[cnt].name[17] = ' ';
		}
		sendConnectionRequest(0, &deviceCalibration);
	}	

	initDataAck();
	initLCD(display_cmd_buffer, 64);
	initUI();

	TCCR0B |= (1<<CS01);
	TCCR3B |= (1<<CS32) | (1<<CS30);

	sei();
	startDataAck();

	while (1) {
		SYS_TaskHandler();

		if (receivedDataRequest) {
			handleDataRequest();
			receivedDataRequest = false;
		}

		if (receivedColdStart) {
			if (connectedBaseStation == -1)
				sendConnectionRequest(0, &deviceCalibration);
			else
				sendConnectionRequest(connectedBaseStation, &deviceCalibration);
			ui_baseStationDisconnected();
			receivedColdStart = false;
		}

		updateUI();

		if (sampleCount > 40000) {
			if (dataPacket.sampleCount != 0)
				removeSamples(&dataPacket); // If the last transmitted data has not been acked then first remove the old data.
			getData(&dataPacket); // Sample new data
			ui_updatePowerValues(&dataPacket); // Update display
			removeSamples(&dataPacket); // Get rid of these samples now
		}
		
		if (TCNT0 > 80) {
			serviceLCD();
			TCNT0 = 0;
		}

		TCCR3B &= ~((1<<CS32) | (1<<CS30));
		if (TCNT3 != 0) {
			for (uint8_t cnt = 0; cnt < DATA_REQ_BUFFER_CNT; cnt++) {
				if (dataReqBusy[cnt] && (retransmit_time[cnt] != 0)) {
					if (retransmit_time[cnt] <= TCNT3) {
						NWK_DataReq(&(nwkPacket[cnt]));
						retransmit_time[cnt] = 0;
					}
					else
						retransmit_time[cnt] -= TCNT3;
				}
			}
		}
		TCNT3 = 0;
		TCCR3B |= (1<<CS32) | (1<<CS30);
	}
}