void nmea_reset(void)
{
rx_len = -1; /* wait for next $ */
nmea_err = 0; /* reset serial error flag */
serial_tx (13);
serial_tx (10);
}
//! Peek some blocks.
void spiflash_peek(unsigned char app,
unsigned char verb,
unsigned char len){
register char blocks=(len>3?cmddata[3]:1);
unsigned char i,j;
P5OUT&=~SS; //Drop !SS to begin transaction.
spitrans8(0x03);//Flash Read Command
len=3;//write 3 byte pointer
for(i=0;i<len;i++)
spitrans8(cmddata[i]);
//Send reply header
len=0x80;//128 byte chunk, repeated for each block
serial_tx(app);
serial_tx(verb);
serial_tx(len); //multiplied by block count.
while(blocks--){
for(i=0;i<len;i++)
serial_tx(spitrans8(0));
/* old fashioned
for(i=0;i<len;i++)
cmddata[i]=spitrans8(0);
txdata(app,verb,len);
*/
}
P5OUT|=SS; //Raise !SS to end transaction.
}
// return true is a command was read, false if a reset was requested
uint8_t receive_cmd(char *cmd)
{
uint8_t num = 0, ch;
dprintf(">");
*cmd = 0;
for(; !check_reset();)
{
for(;!check_reset() && !serial_rx_nb(&ch);)
idle();
if (check_reset())
return 0;
serial_tx(ch);
if (ch == '\r')
{
serial_tx('\n');
cmd[num] = 0;
return 1;
}
cmd[num] = ch;
num++;
}
return 0;
}
//! Transmit a header.
void txhead(unsigned char app,
unsigned char verb,
unsigned long len) {
serial_tx(app);
serial_tx(verb);
//serial_tx(len); //old protocol
txword(len);
}
//! Transmit a long.
void txlong(unsigned long l) {
serial_tx(l&0xFF);
l>>=8;
serial_tx(l&0xFF);
l>>=8;
serial_tx(l&0xFF);
l>>=8;
serial_tx(l&0xFF);
l>>=8;
}
uint8_t address_exchange(void)
{
uint8_t ch;
uint8_t id;
set_led_rgb(0, 0, 255);
id = eeprom_read_byte((uint8_t *)ee_pump_id_offset);
if (id == 0 || id == 255)
{
// we failed to get a unique number for the pump. just stop.
set_led_rgb(255, 0, 0);
for(;;);
}
for(;;)
{
for(;;)
{
if (serial_rx_nb(&ch))
break;
if (check_reset())
return 0xFF;
}
if (ch == 0xFF)
break;
if (ch == '?')
serial_tx(id);
}
set_led_rgb(0, 255, 0);
return id;
}
static void update_state_beacon(void)
{
dfu_packet_t* p_beacon = NULL;
uint16_t beacon_len = 0;
switch (m_transaction.type)
{
case DFU_TYPE_APP:
p_beacon = beacon_set(BEACON_TYPE_READY_APP);
beacon_len = DFU_PACKET_LEN_STATE_APP;
break;
case DFU_TYPE_SD:
p_beacon = beacon_set(BEACON_TYPE_READY_SD);
beacon_len = DFU_PACKET_LEN_STATE_SD;
break;
case DFU_TYPE_BOOTLOADER:
p_beacon = beacon_set(BEACON_TYPE_READY_BL);
beacon_len = DFU_PACKET_LEN_STATE_BL;
break;
default:
APP_ERROR_CHECK(NRF_ERROR_NOT_SUPPORTED);
}
if (p_beacon)
{
serial_tx(p_beacon, beacon_len);
}
}
int main(int argc, char ** argv) {
int error;
int cnt = 0;
int ind;
char* teststr = "cutaway\n\0";
error = setup_serial();
if (error < 0){
printf("serial setup error\n");
return -1;
}
while (cnt < strlen(teststr)){
//serputc(teststr[cnt],ser_fd);
serial_tx(teststr[cnt],ser_fd);
cnt++;
}
//ind = sergetc(ser_fd);
ind = serial_rx(ser_fd);
printf("sergetc\n");
printf("decimal incoming: %d\n",ind);
printf("char incoming: %c\n",(char)ind);
// Don't forget to clean up
close(ser_fd);
return 0;
}
void serial_api_tx_subscribe() {
serial_subscribe_ht request;
serial_subscribe_ack_ht response;
INT8U responseLen;
INT8U rc;
// create
request.filter = 0xffffffff;
request.unackFilter = 0xffffffff;
// send
rc = serial_tx(
PKT_TYPE_SUBSCRIBE, // packetType
(INT8U*)&request, // txPayload
sizeof(serial_subscribe_ht), // txPayloadLen
&response, // rxPayload
sizeof(serial_subscribe_ack_ht), // rxPayloadMaxLen
&responseLen // rxPayloadLen
);
if (
rc!=RC_OK ||
responseLen<sizeof(serial_subscribe_ack_ht) ||
response.rc!=RC_OK
) {
// print
dnm_ucli_printf("ERROR: subscription error\r\n");
// disconnect
OSSemPost(bridge_app_v.disconnectedSem);
}
}
void serial_tx_byte(uint8_t byte, volatile uint8_t* port, uint8_t index, bool newline){
char ch[4];
ch[0] = '0' + (byte / 100);
ch[1] = '0' + ((byte % 100) / 10);
ch[2] = '0' + (byte % 10);
ch[3] = '\0';
serial_tx(ch, port, index, newline);
}
//! Transmit a string.
void txstring(unsigned char app,
unsigned char verb,
const char *str) {
unsigned long len=strlen(str);
txhead(app,verb,len);
while(len--)
serial_tx(*(str++));
}
void txdata(unsigned char app, unsigned char verb, unsigned long len)
{
unsigned int i = 0;
// if(silent) return;
txhead(app, verb, len);
for (i = 0; i < len; i++) {
serial_tx(cmddata[i]);
}
}
void tx_inbuf(void)
{
if (rx_len > 0)
{
short i;
serial_tx ('$');
serial_tx ('E');
serial_tx ('E');
serial_tx ('E');
serial_tx ('E');
serial_tx ('E');
serial_tx (',');
for (i=0; i< rx_len; i++)
serial_tx (rx[i]);
serial_tx (13);
serial_tx (10);
}
}
/********** STATE MACHINE ENTRY POINTS ***********/
static void start_find_fwid(void)
{
dfu_packet_t* p_fwid = beacon_set(BEACON_TYPE_FWID);
set_timeout(STATE_TIMEOUT_FIND_FWID);
m_state = BL_STATE_FIND_FWID;
memset(&m_transaction, 0, sizeof(transaction_t));
serial_tx(p_fwid, DFU_PACKET_LEN_FWID);
}
void serial_tx_str(const char* val)
{
unsigned char i=0;
while(val[i])
{
serial_tx(val[i]);
i++;
}
}
void send_yasp_command(uint8_t cmd, uint8_t * payload, uint16_t length, uint8_t ack)
{
uint8_t out_buffer[2+2+1];
uint32_t crc_32 = 0x00;
uint8_t crc_buffer[sizeof(crc_32)];
uint16_t command_length = COMMAND_SIZE + COMMAND_LENGTH_SIZE + length;
out_buffer[SYNCH1_POS] = 0xFF;
out_buffer[SYNCH2_POS] = 0xFF;
out_buffer[LENGTH_POS] = (uint8_t)(command_length >> 8);
out_buffer[LENGTH_POS+1] = (uint8_t)(command_length);
out_buffer[COMMAND_POS] = ack ? (0x80 | cmd) : cmd;
serial_tx(out_buffer, 5);
crc_32 = crc32(crc_32, &out_buffer[2], 3);
if (length > 0)
{
crc_32 = crc32(crc_32, payload, length);
serial_tx(payload, length);
}
crc32_serialize(crc_32, crc_buffer);
serial_tx(crc_buffer, sizeof(crc_32));
}
void serial_tx_hex(uint8_t byte, volatile uint8_t* port, uint8_t index, bool newline){
char ch[3];
uint8_t _byte = byte >> 4;
if (_byte < 10)
ch[0] = '0' + _byte;
else
ch[0] = 'A' + (_byte - 10);
byte &= 0x0F;
if (byte < 10)
ch[1] = '0' + byte;
else
ch[1] = 'A' + (byte - 10);
ch[2] = '\0';
serial_tx(ch, port, index, newline);
}
//! Main loop.
int main(void)
{
volatile unsigned int i;
init();
PLEDOUT^=PLEDPIN; // Blink
//while(1) serial_tx(serial_rx());
while(1) serial_tx('G');
while(1){
i = 10000;
while(i--);
PLEDOUT^=PLEDPIN; // Blink
}
}
void serial_api_tx_hello() {
serial_hello_ht msg;
// create
msg.version = 4;
msg.cliSeqNo = bridge_app_v.seqNoTx;
msg.mode = 0x00;
// send
serial_tx(
PKT_TYPE_HELLO, // packetType
(INT8U*)&msg, // txPayload
sizeof(serial_hello_ht), // txPayloadLen
NULL, // rxPayload
0, // rxPayloadMaxLen
NULL // rxPayloadLen
);
}
static int logf_push(void *userp, unsigned char c)
{
(void)userp;
logfbuffer[logfindex++] = c;
check_logfindex();
#if defined(HAVE_SERIAL) && !defined(SIMULATOR) && defined(LOGF_SERIAL)
if(c != '\0')
{
char buf[2];
buf[0] = c;
buf[1] = '\0';
serial_tx(buf);
}
#endif
return true;
}
void _logf(const char *fmt, ...)
{
#ifdef USB_ENABLE_SERIAL
int old_logfindex = logfindex;
#endif
va_list ap;
va_start(ap, fmt);
#if (CONFIG_PLATFORM & PLATFORM_HOSTED)
char buf[1024];
vsnprintf(buf, sizeof buf, fmt, ap);
DEBUGF("%s\n", buf);
/* restart va_list otherwise the result if undefined when vuprintf is called */
va_end(ap);
va_start(ap, fmt);
#endif
vuprintf(logf_push, NULL, fmt, ap);
va_end(ap);
/* add trailing zero */
logf_push(NULL, '\0');
#if defined(HAVE_SERIAL) && !defined(SIMULATOR) && defined(LOGF_SERIAL)
serial_tx("\r\n");
#endif
#ifdef USB_ENABLE_SERIAL
if(logfindex < old_logfindex)
{
usb_serial_send(logfbuffer + old_logfindex, MAX_LOGF_SIZE - old_logfindex);
usb_serial_send(logfbuffer, logfindex - 1);
}
else
usb_serial_send(logfbuffer + old_logfindex, logfindex - old_logfindex - 1);
usb_serial_send("\r\n", 2);
#endif
displayremote();
}
/*
void isr() interrupt 0 {
}
*/
void main() {
unsigned char i,tmp;
CMCON=0x07;
TRISA=0x30;
TRISB=0xE7;
PORTA=0;
PORTB=0;
lcd_init();
serial_init();
//teste serial
lcd_cmd(L_CLR);
lcd_cmd(L_L1);
lcd_str("Teste Serial TX");
lcd_cmd(L_L2+2);
lcd_str("9600 8N1");
serial_tx_str("\r\n Picsimlab\r\n Teste Serial TX\r\n");
for(i=0;i<4;i++)
{
serial_tx(i+0x30);
serial_tx_str(" PicsimLab\r\n");
}
atraso_ms(1000);
lcd_cmd(L_CLR);
lcd_cmd(L_L1);
lcd_str("Teste Serial RX");
serial_tx_str(" Digite!\r\n");
for(i=0;i<32;i++)
{
if(!(i%16))
{
lcd_cmd(L_L2);
serial_tx_str("\r\n");
}
tmp=serial_rx(2000);
lcd_dat(tmp);
serial_tx(tmp);
}
atraso_ms(100);
lcd_cmd(L_CLR);
lcd_cmd(L_L1);
lcd_str("Teste Teclado TX");
serial_tx_str("\r\n Aguarde!\r\n");
for(i=0;i<32;i++)
{
if(!(i%16))
{
lcd_cmd(L_L2);
serial_tx_str("\r\n");
}
tmp=tc_tecla(2000)+0x30;
lcd_dat(tmp);
serial_tx(tmp);
}
atraso_ms(100);
//fim teste
lcd_cmd(L_CLR);
lcd_cmd(L_L1+4);
lcd_str("Fim");
lcd_cmd(L_L2+1);
lcd_str("Pressione RST");
serial_tx_str("\r\n FIM!\r\n");
while(1);
}
static void handle_data_req_packet(dfu_packet_t* p_packet)
{
if (p_packet->payload.data.transaction_id == m_transaction.transaction_id)
{
if (m_state == BL_STATE_RELAY)
{
/* only relay new packets, look for it in cache */
if (packet_cache_entry_get(p_packet) == NULL)
{
set_timeout(STATE_TIMEOUT_RELAY);
relay_packet(p_packet, 8);
}
}
else
{
req_cache_entry_t* p_req_entry = NULL;
/* check that we haven't served this request recently. */
for (uint32_t i = 0; i < REQ_CACHE_SIZE; ++i)
{
if (m_req_cache[i].segment == p_packet->payload.req_data.segment)
{
if (m_req_cache[i].rx_count++ < REQ_RX_COUNT_RETRY)
{
return;
}
p_req_entry = &m_req_cache[i];
break;
}
}
mesh_packet_t* p_rsp;
if (mesh_packet_acquire(&p_rsp))
{
dfu_packet_t* p_dfu_rsp = (dfu_packet_t*) &((ble_ad_t*) p_rsp->payload)->data[2];
/* serve request */
if (
dfu_has_entry(
(uint32_t*) SEGMENT_ADDR(p_packet->payload.req_data.segment, m_transaction.p_start_addr),
p_dfu_rsp->payload.rsp_data.data, SEGMENT_LENGTH)
)
{
p_dfu_rsp->packet_type = DFU_PACKET_TYPE_DATA_RSP;
p_dfu_rsp->payload.rsp_data.segment = p_packet->payload.req_data.segment;
p_dfu_rsp->payload.rsp_data.transaction_id = p_packet->payload.req_data.transaction_id;
bootloader_packet_set_local_fields(p_rsp, DFU_PACKET_LEN_DATA_RSP);
transport_tx(p_rsp, TX_REPEATS_RSP, TX_INTERVAL_TYPE_RSP, NULL);
serial_tx(p_dfu_rsp, DFU_PACKET_LEN_DATA_RSP);
}
mesh_packet_ref_count_dec(p_rsp);
/* log our attempt at responding */
if (!p_req_entry)
{
p_req_entry = &m_req_cache[(m_req_index++) & (REQ_CACHE_SIZE - 1)];
p_req_entry->segment = p_packet->payload.req_data.segment;
}
p_req_entry->rx_count = 0;
}
}
}
}
/*! \brief Transmit debug bytes.
Transmits bytes for debugging.
*/
void debugbytes(const char *bytes, unsigned int len) {
u16 i;
txhead(0xFF,0xFE,len);
for(i=0; i<len; i++)
serial_tx(bytes[i]);
}
//! Transmit a word.
void txword(unsigned int l) {
serial_tx(l&0xFF);
l>>=8;
serial_tx(l&0xFF);
l>>=8;
}
//! Handles MSP430X2 JTAG commands. Forwards others to JTAG.
void jtag430x2_handle_fn( uint8_t const app,
uint8_t const verb,
uint32_t const len)
{
unsigned int i,val;
unsigned long at, l;
//jtag430_resettap();
if(verb!=START && jtag430mode==MSP430MODE){
(*(jtag430_app.handle))(app,verb,len);
return;
}
switch(verb){
case START:
//Enter JTAG mode.
//do
cmddata[0]=jtag430x2_start();
//while(cmddata[0]==00 || cmddata[0]==0xFF);
//MSP430 or MSP430X
if(jtagid==MSP430JTAGID){
//debugstr("ERROR, using JTAG430X2 instead of JTAG430!");
jtag430mode=MSP430MODE;
/* So the way this works is that a width of 20 does some
backward-compatibility finagling, causing the correct value
to be exchanged for addresses on 16-bit chips as well as the
new MSP430X chips. (This has only been verified on the
MSP430F2xx family. TODO verify for others.)
*/
drwidth=20;
//Perform a reset and disable watchdog.
jtag430_por();
jtag430_writemem(0x120,0x5a80);//disable watchdog
jtag430_haltcpu();
jtag430_resettap();
txdata(app,verb,1);
return;
}else if(jtagid==MSP430X2JTAGID){
jtag430mode=MSP430X2MODE;
drwidth=20;
}else{
debugstr("JTAG version unknown.");
txdata(app,NOK,1);
return;
}
jtag430x2_fusecheck();
jtag430x2_syncpor();
jtag430_resettap();
txdata(app,verb,1);
break;
case JTAG430_READMEM:
case PEEK:
at=cmddatalong[0];
//Fetch large blocks for bulk fetches,
//small blocks for individual peeks.
if(len>5)
l=(cmddataword[2]);//always even.
else
l=2;
l&=~1;//clear lsbit
if(l<2) l=2;
txhead(app,verb,l);
for(i=0;i<l;i+=2){
//jtag430_resettap();
//delay(10);
val=jtag430x2_readmem(at);
at+=2;
serial_tx(val&0xFF);
serial_tx((val&0xFF00)>>8);
}
break;
case JTAG430_COREIP_ID:
cmddataword[0]=jtag430_coreid();
txdata(app,verb,2);
break;
case JTAG430_DEVICE_ID:
cmddatalong[0]=jtag430_deviceid();
txdata(app,verb,4);
break;
case JTAG430_WRITEFLASH:
case JTAG430_WRITEMEM:
case POKE:
jtag430x2_writemem(cmddatalong[0],
cmddataword[2]);
cmddataword[0]=jtag430x2_readmem(cmddatalong[0]);
txdata(app,verb,2);
break;
//unimplemented functions
case JTAG430_HALTCPU:
//jtag430x2_haltcpu();
debugstr("Warning, not trying to halt for lack of code.");
txdata(app,verb,0);
break;
case JTAG430_RELEASECPU:
case JTAG430_SETINSTRFETCH:
case JTAG430_ERASEFLASH:
case JTAG430_SETPC:
debugstr("This function is not yet implemented for MSP430X2.");
debughex(verb);
txdata(app,NOK,0);
break;
default:
(*(jtag_app.handle))(app,verb,len);
}
jtag430_resettap();
}
dn_error_t wirelessRxNotif(dn_api_loc_notif_received_t* rxFrame, INT8U length) {
serial_sendData_ht* serial_sendData;
serial_sendData_ack_ht serial_sendData_ack;
INT8U dataLen;
INT8U responseLen;
INT8U rc;
if (rxFrame->sourcePort==htons(MOM_UDP_PORT)) {
// request
if (length<sizeof(dn_api_loc_notif_received_t)+2) {
dnm_ucli_printf("ERROR: downstream request too short (%d bytes)\r\n",length);
return DN_ERR_NONE;
}
if (
rxFrame->data[0]==MOM_REQ_DISPATCH_RPC &&
rxFrame->data[1]==MOM_PROC_GETOPERATIONALMOTES
) {
mom_proc_getOperationalMotes();
}
} else {
// downstream data
if (length<=sizeof(dn_api_loc_notif_received_t)+8) {
dnm_ucli_printf("ERROR: downstream data too short (%d bytes)\r\n",length);
return DN_ERR_NONE;
}
// create serial frame
dataLen = length-sizeof(dn_api_loc_notif_received_t)-8;
serial_sendData = (serial_sendData_ht*)bridge_app_v.serialSendDataBuf;
memcpy(serial_sendData->macAddress,&rxFrame->data[0],8);
serial_sendData->priority = DN_API_PRIORITY_MED;
serial_sendData->srcPort = rxFrame->sourcePort;
serial_sendData->dstPort = rxFrame->sourcePort;
serial_sendData->options = 0x00;
memcpy(serial_sendData->data,&rxFrame->data[8],dataLen);
// send serial frame
rc = serial_tx(
PKT_TYPE_SENDDATA, // packetType
(INT8U*)serial_sendData, // txPayload
sizeof(serial_sendData_ht)+dataLen, // txPayloadLen
&serial_sendData_ack, // rxPayload
sizeof(serial_sendData_ack_ht), // rxPayloadMaxLen
&responseLen // rxPayloadLen
);
if (
rc!=RC_OK ||
responseLen<sizeof(serial_sendData_ack_ht) ||
serial_sendData_ack.rc!=RC_OK
) {
// print
dnm_ucli_printf("ERROR: sendData error\r\n");
// disconnect
OSSemPost(bridge_app_v.disconnectedSem);
}
}
return DN_ERR_NONE;
}
void txword(unsigned int l)
{
serial_tx(l & 0xFF); // lo byte
l >>= 8;
serial_tx(l & 0xFF); // hi byte
}
void main() {
unsigned char i,tmp;
CMCON=0x07;
TRISA=0x30;
TRISB=0xE7;
PORTA=0xFE;
PORTB=0x00;
lcd_init();
i2c_init();
serial_init();
//teste lcd
lcd_cmd(L_CLR);
lcd_cmd(L_L1);
for(i=0;i<16;i++)
{
lcd_dat('A'+i);
}
lcd_cmd(L_L2);
for(i=0;i<16;i++)
{
lcd_dat('a'+i);
}
atraso_ms(200);
lcd_cmd(L_CLR);
lcd_cmd(L_L1+3);
lcd_str("Teste LCD");
for(i=32;i<128;i++)
{
if((i%16) == 0)lcd_cmd(L_L2);
lcd_dat(i);
atraso_ms(50);
}
atraso_ms(100);
lcd_cmd(L_CLR);
lcd_cmd(L_L1+3);
lcd_str("Teste LCD");
lcd_cmd(L_L2+7);
lcd_str("Ok");
atraso_ms(500);
//teste LEDS
lcd_cmd(L_CLR);
lcd_cmd(L_L1+1);
lcd_str("Teste LEDs");
for(i=0;i<4;i++)
{
atraso_ms(100);
RA1^=1;
atraso_ms(100);
RA2^=1;
atraso_ms(100);
PORTA^=0x40; //RA6=1;
atraso_ms(100);
PORTA^=0x80; //RA7=1;
atraso_ms(100);
}
//teste Teclado
lcd_cmd(L_CLR);
lcd_cmd(L_L1+2);
lcd_str("Teste Teclado");
lcd_cmd(L_L2+1);
i=0;
while(i<14)
{
lcd_dat(tc_tecla(3000)+0x30);
i++;
}
//teste EEPROM EXT
lcd_cmd(L_CLR);
lcd_cmd(L_L1);
lcd_str("Teste EEPROM EXT");
// testar ?
lcd_cmd(L_L2);
lcd_str("Testar (1/0) ?");
if(tc_tecla(0) == 1)
{
tmp=e2pext_r(10);
lcd_dat(tmp);
e2pext_w(10,0xA5);
e2pext_w(10,0x5A);
i=e2pext_r(10);
e2pext_w(10,tmp);
lcd_cmd(L_CLR);
lcd_cmd(L_L1);
lcd_str("Teste EEPROM EXT");
lcd_cmd(L_L2);
if(i == 0x5A)
lcd_str(" OK");
else
lcd_str(" ERRO");
atraso_ms(1000);
}
//teste RTC
lcd_cmd(L_CLR);
lcd_cmd(L_L1);
lcd_str("Teste RTC");
//ajuste rtc_w();
// rtc_w();
rtc_r();
lcd_cmd(L_L2);
lcd_str((char *)date);
atraso_ms(1500);
for(i=0;i<16;i++)
{
rtc_r();
lcd_cmd(L_L2);;
lcd_str((char *)time);
atraso_ms(500);
}
//teste serial
//teste EEPROM EXT
lcd_cmd(L_CLR);
lcd_cmd(L_L1);
lcd_str("Teste Serial");
// testar ?
lcd_cmd(L_L2);
lcd_str("Testar (1/0) ?");
if(tc_tecla(0) == 1)
{
lcd_cmd(L_CLR);
lcd_cmd(L_L1);
lcd_str("Teste Serial TX");
lcd_cmd(L_L2+2);
lcd_str("9600 8N1");
serial_tx_str("\r\n Picsimlab\r\n Teste Serial TX\r\n");
for(i=0;i<4;i++)
{
serial_tx(i+0x30);
serial_tx_str(" PicsimLab\r\n");
}
atraso_ms(1000);
lcd_cmd(L_CLR);
lcd_cmd(L_L1);
lcd_str("Teste Serial RX");
serial_tx_str(" Digite!\r\n");
for(i=0;i<32;i++)
{
if(!(i%16))
{
lcd_cmd(L_L2);
serial_tx_str("\r\n");
}
tmp=serial_rx(3000);
lcd_dat(tmp);
serial_tx(tmp);
}
atraso_ms(100);
lcd_cmd(L_CLR);
lcd_cmd(L_L1);
lcd_str("Teste Teclado TX");
serial_tx_str("\r\n Aguarde!\r\n");
for(i=0;i<32;i++)
{
if(!(i%16))
{
lcd_cmd(L_L2);
serial_tx_str("\r\n");
}
tmp=tc_tecla(2000)+0x30;
lcd_dat(tmp);
serial_tx(tmp);
}
atraso_ms(100);
}
//fim teste
lcd_cmd(L_CLR);
lcd_cmd(L_L1+4);
lcd_str("Fim");
lcd_cmd(L_L2+1);
lcd_str("Pressione RST");
serial_tx_str("\r\n FIM!\r\n");
while(1);
}
INT8U discoverMotes(INT8U numMotesIn, INT8U* numMotesOut, INT8U* pkBuf, INT8U maxPayloadLen) {
INT8U lastWrittenMac[8];
INT8U firstMACwritten;
INT8U currentMac[8];
serial_getMoteConfig_ht request;
serial_getMoteConfig_ack_ht response;
INT8U responseLen;
INT8U rc;
INT8U lastMAC[8];
mom_response_ht* mom_response_h;
mom_response_rpc_ht* mom_response_rpc_h;
mom_motes_ht* mom_motes_h;
INT8U* payload;
INT8U payloadIdx;
INT8U moteidx;
INT8U i;
INT8U lenMAC;
// start with empty MAC address
memset(currentMac,0,8);
firstMACwritten = 1;
payload = ((loc_sendtoNW_t*)pkBuf)->locSendTo.payload;
payloadIdx = 0;
moteidx = 0;
while (1) {
// prepare next request
memcpy(request.macAddress,currentMac,8);
request.next = 0x01;
// send
rc = serial_tx(
PKT_TYPE_GETMOTECONFIG, // packetType
(INT8U*)&request, // txPayload
sizeof(serial_getMoteConfig_ht), // txPayloadLen
&response, // rxPayload
sizeof(serial_getMoteConfig_ack_ht), // rxPayloadMaxLen
&responseLen // rxPayloadLen
);
if (rc!=RC_OK || responseLen<1) {
// there was a problem communicating with the manager
// print
dnm_ucli_printf("ERROR: problem communicating with manager\r\n");
// disconnect
OSSemPost(bridge_app_v.disconnectedSem);
// abort, abort
return RC_WRITE_FAIL;
} else if (response.rc!=RC_OK) {
// end of list of motes
if (numMotesOut==NULL) {
// send remainder of buffer
if (payloadIdx>0) {
rc = sendDiscoveredMotes(pkBuf,payloadIdx);
if (rc!=RC_OK) {
return rc;
}
}
} else {
// write number of motes
*numMotesOut = moteidx;
}
// stop
return RC_OK;
} else {
// not the end of the list of motes
if (response.isAP==0x00 && response.state==MOTE_STATE_OPERATIONAL) {
// I have found a new mote
if (numMotesOut==NULL) {
// write motes
//===== start of packet
if (payloadIdx==0) {
// mom_response_ht
mom_response_h = (mom_response_ht*)&payload[payloadIdx];
mom_response_h->dispatch = MOM_RESP_DISPATCH_RPC;
payloadIdx += sizeof(mom_response_ht);
// mom_response_rpc_ht
mom_response_rpc_h = (mom_response_rpc_ht*)&payload[payloadIdx];
mom_response_rpc_h->procID= MOM_PROC_GETOPERATIONALMOTES;
payloadIdx += sizeof(mom_response_rpc_ht);
// motes header
mom_motes_h = (mom_motes_ht*)&payload[payloadIdx];
mom_motes_h->number = numMotesIn;
mom_motes_h->index = moteidx;
payloadIdx += sizeof(mom_motes_ht);
}
//===== body of packet
// determine how many bytes are different with previous MAC (delta encoding)
lenMAC=8;
if (firstMACwritten==1) {
firstMACwritten=0;
} else {
for (i=0;i<8;i++) {
if (response.macAddress[i]==lastWrittenMac[i]) {
lenMAC--;
} else {
break;
}
}
}
// write header
payload[payloadIdx] = lenMAC;
payloadIdx++;
// write lenMAC last address of MAC address
memcpy(&payload[payloadIdx],&response.macAddress[8-lenMAC],lenMAC);
payloadIdx += lenMAC;
// remember last written MAC address
memcpy(lastWrittenMac,response.macAddress,8);
//===== end of packet
if (payloadIdx+8>=maxPayloadLen) {
// not enough space to write another MAC address
// send buffer
rc = sendDiscoveredMotes(pkBuf,payloadIdx);
if (rc!=RC_OK) {
return rc;
}
// reset buffer
firstMACwritten = 1;
payloadIdx = 0;
}
}
// increment number of motes
moteidx++;
}
// store MAC address for next iteration
memcpy(currentMac,response.macAddress,8);
}
}
}
