LMiC - first test

Users » tmulrooney » Code » LMiC

first test

lmic.cpp@7:29058a7ccf23, 2016-02-25 (annotated)

Committer:: tmulrooney
Date:: Thu Feb 25 21:28:23 2016 +0000
Revision:: 7:29058a7ccf23
Parent:: 6:eed5fd627a2b

first successful join

Who changed what in which revision?

User	Revision	Line number	New contents of line
mluis	0:62d1edcc13d1	1	/*******************************************************************************
mluis	1:d3b7bde3995c	2	* Copyright (c) 2014-2015 IBM Corporation.
mluis	0:62d1edcc13d1	3	* All rights reserved. This program and the accompanying materials
mluis	0:62d1edcc13d1	4	* are made available under the terms of the Eclipse Public License v1.0
mluis	0:62d1edcc13d1	5	* which accompanies this distribution, and is available at
mluis	0:62d1edcc13d1	6	* http://www.eclipse.org/legal/epl-v10.html
mluis	0:62d1edcc13d1	7	*
mluis	0:62d1edcc13d1	8	* Contributors:
mluis	0:62d1edcc13d1	9	* IBM Zurich Research Lab - initial API, implementation and documentation
mluis	0:62d1edcc13d1	10	*******************************************************************************/
mluis	0:62d1edcc13d1	11
mluis	1:d3b7bde3995c	12	//! \file
mluis	0:62d1edcc13d1	13	#include "lmic.h"
tmulrooney	5:464c1f2d6cbb	14	#include "debug.h"
mluis	0:62d1edcc13d1	15
mluis	1:d3b7bde3995c	16	#if !defined(MINRX_SYMS)
mluis	1:d3b7bde3995c	17	#define MINRX_SYMS 5
mluis	1:d3b7bde3995c	18	#endif // !defined(MINRX_SYMS)
mluis	0:62d1edcc13d1	19	#define PAMBL_SYMS 8
mluis	0:62d1edcc13d1	20	#define PAMBL_FSK 5
mluis	0:62d1edcc13d1	21	#define PRERX_FSK 1
mluis	0:62d1edcc13d1	22	#define RXLEN_FSK (1+5+2)
mluis	0:62d1edcc13d1	23
mluis	0:62d1edcc13d1	24	#define BCN_INTV_osticks sec2osticks(BCN_INTV_sec)
mluis	0:62d1edcc13d1	25	#define TXRX_GUARD_osticks ms2osticks(TXRX_GUARD_ms)
mluis	0:62d1edcc13d1	26	#define JOIN_GUARD_osticks ms2osticks(JOIN_GUARD_ms)
mluis	0:62d1edcc13d1	27	#define DELAY_DNW1_osticks sec2osticks(DELAY_DNW1)
mluis	0:62d1edcc13d1	28	#define DELAY_DNW2_osticks sec2osticks(DELAY_DNW2)
mluis	0:62d1edcc13d1	29	#define DELAY_JACC1_osticks sec2osticks(DELAY_JACC1)
mluis	0:62d1edcc13d1	30	#define DELAY_JACC2_osticks sec2osticks(DELAY_JACC2)
mluis	0:62d1edcc13d1	31	#define DELAY_EXTDNW2_osticks sec2osticks(DELAY_EXTDNW2)
mluis	0:62d1edcc13d1	32	#define BCN_RESERVE_osticks ms2osticks(BCN_RESERVE_ms)
mluis	0:62d1edcc13d1	33	#define BCN_GUARD_osticks ms2osticks(BCN_GUARD_ms)
mluis	0:62d1edcc13d1	34	#define BCN_WINDOW_osticks ms2osticks(BCN_WINDOW_ms)
mluis	0:62d1edcc13d1	35	#define AIRTIME_BCN_osticks us2osticks(AIRTIME_BCN)
mluis	1:d3b7bde3995c	36	#if defined(CFG_eu868)
mluis	1:d3b7bde3995c	37	#define DNW2_SAFETY_ZONE ms2osticks(3000)
mluis	1:d3b7bde3995c	38	#endif
mluis	1:d3b7bde3995c	39	#if defined(CFG_us915)
mluis	1:d3b7bde3995c	40	#define DNW2_SAFETY_ZONE ms2osticks(750)
mluis	1:d3b7bde3995c	41	#endif
mluis	1:d3b7bde3995c	42
mluis	1:d3b7bde3995c	43	// Special APIs - for development or testing
mluis	1:d3b7bde3995c	44	#define isTESTMODE() 0
mluis	0:62d1edcc13d1	45
mluis	0:62d1edcc13d1	46	DEFINE_LMIC;
mluis	0:62d1edcc13d1	47	DECL_ON_LMIC_EVENT;
mluis	0:62d1edcc13d1	48
mluis	0:62d1edcc13d1	49
mluis	0:62d1edcc13d1	50	// Fwd decls.
mluis	0:62d1edcc13d1	51	static void engineUpdate(void);
mluis	0:62d1edcc13d1	52	static void startScan (void);
mluis	0:62d1edcc13d1	53
mluis	0:62d1edcc13d1	54
mluis	0:62d1edcc13d1	55	// ================================================================================
mluis	0:62d1edcc13d1	56	// BEG OS - default implementations for certain OS suport functions
mluis	0:62d1edcc13d1	57
mluis	1:d3b7bde3995c	58	#if !defined(HAS_os_calls)
mluis	0:62d1edcc13d1	59
mluis	1:d3b7bde3995c	60	#if !defined(os_rlsbf2)
tmulrooney	6:eed5fd627a2b	61	u2_t os_rlsbf2 (xref2cu1_t buf)
tmulrooney	6:eed5fd627a2b	62	{
tmulrooney	6:eed5fd627a2b	63	debug("LMIC os_rlsbf2 enter\r\n");
mluis	0:62d1edcc13d1	64	return (u2_t)(buf[0] \| (buf[1]<<8));
mluis	0:62d1edcc13d1	65	}
mluis	0:62d1edcc13d1	66	#endif
mluis	0:62d1edcc13d1	67
mluis	1:d3b7bde3995c	68	#if !defined(os_rlsbf4)
tmulrooney	6:eed5fd627a2b	69	u4_t os_rlsbf4 (xref2cu1_t buf)
tmulrooney	6:eed5fd627a2b	70	{
tmulrooney	6:eed5fd627a2b	71	debug("LMIC os_rlsbf4 enter\r\n");
mluis	0:62d1edcc13d1	72	return (u4_t)(buf[0] \| (buf[1]<<8) \| ((u4_t)buf[2]<<16) \| ((u4_t)buf[3]<<24));
mluis	0:62d1edcc13d1	73	}
mluis	0:62d1edcc13d1	74	#endif
mluis	0:62d1edcc13d1	75
mluis	0:62d1edcc13d1	76
mluis	1:d3b7bde3995c	77	#if !defined(os_rmsbf4)
tmulrooney	6:eed5fd627a2b	78	u4_t os_rmsbf4 (xref2cu1_t buf)
tmulrooney	6:eed5fd627a2b	79	{
tmulrooney	6:eed5fd627a2b	80	debug("LMIC os_rmsbf4 enter\r\n");
mluis	0:62d1edcc13d1	81	return (u4_t)(buf[3] \| (buf[2]<<8) \| ((u4_t)buf[1]<<16) \| ((u4_t)buf[0]<<24));
mluis	0:62d1edcc13d1	82	}
mluis	0:62d1edcc13d1	83	#endif
mluis	0:62d1edcc13d1	84
mluis	0:62d1edcc13d1	85
mluis	1:d3b7bde3995c	86	#if !defined(os_wlsbf2)
tmulrooney	6:eed5fd627a2b	87	void os_wlsbf2 (xref2u1_t buf, u2_t v)
tmulrooney	6:eed5fd627a2b	88	{
tmulrooney	6:eed5fd627a2b	89	debug("LMIC os_wlsbf2 enter\r\n");
mluis	0:62d1edcc13d1	90	buf[0] = v;
mluis	0:62d1edcc13d1	91	buf[1] = v>>8;
mluis	0:62d1edcc13d1	92	}
mluis	0:62d1edcc13d1	93	#endif
mluis	0:62d1edcc13d1	94
mluis	1:d3b7bde3995c	95	#if !defined(os_wlsbf4)
tmulrooney	6:eed5fd627a2b	96	void os_wlsbf4 (xref2u1_t buf, u4_t v)
tmulrooney	6:eed5fd627a2b	97	{
tmulrooney	6:eed5fd627a2b	98	debug("LMIC os_wlsbf4 enter\r\n");
mluis	0:62d1edcc13d1	99	buf[0] = v;
mluis	0:62d1edcc13d1	100	buf[1] = v>>8;
mluis	0:62d1edcc13d1	101	buf[2] = v>>16;
mluis	0:62d1edcc13d1	102	buf[3] = v>>24;
mluis	0:62d1edcc13d1	103	}
mluis	0:62d1edcc13d1	104	#endif
mluis	0:62d1edcc13d1	105
mluis	1:d3b7bde3995c	106	#if !defined(os_wmsbf4)
tmulrooney	6:eed5fd627a2b	107	void os_wmsbf4 (xref2u1_t buf, u4_t v)
tmulrooney	6:eed5fd627a2b	108	{
tmulrooney	6:eed5fd627a2b	109	debug("LMIC os_wmsbf4 enter\r\n");
mluis	0:62d1edcc13d1	110	buf[3] = v;
mluis	0:62d1edcc13d1	111	buf[2] = v>>8;
mluis	0:62d1edcc13d1	112	buf[1] = v>>16;
mluis	0:62d1edcc13d1	113	buf[0] = v>>24;
mluis	0:62d1edcc13d1	114	}
mluis	0:62d1edcc13d1	115	#endif
mluis	0:62d1edcc13d1	116
mluis	1:d3b7bde3995c	117	#if !defined(os_getBattLevel)
tmulrooney	6:eed5fd627a2b	118	u1_t os_getBattLevel (void)
tmulrooney	6:eed5fd627a2b	119	{
tmulrooney	6:eed5fd627a2b	120	debug("LMIC os_getBattLevel enter\r\n");
mluis	0:62d1edcc13d1	121	return MCMD_DEVS_BATT_NOINFO;
mluis	0:62d1edcc13d1	122	}
mluis	0:62d1edcc13d1	123	#endif
mluis	0:62d1edcc13d1	124
mluis	1:d3b7bde3995c	125	#if !defined(os_crc16)
mluis	1:d3b7bde3995c	126	// New CRC-16 CCITT(XMODEM) checksum for beacons:
tmulrooney	6:eed5fd627a2b	127	u2_t os_crc16 (xref2u1_t data, uint len)
tmulrooney	6:eed5fd627a2b	128	{
tmulrooney	6:eed5fd627a2b	129	debug("LMIC os_crc16 enter\r\n");
mluis	1:d3b7bde3995c	130	u2_t remainder = 0;
mluis	1:d3b7bde3995c	131	u2_t polynomial = 0x1021;
tmulrooney	6:eed5fd627a2b	132	for( uint i = 0; i < len; i++ )
tmulrooney	6:eed5fd627a2b	133	{
mluis	1:d3b7bde3995c	134	remainder ^= data[i] << 8;
tmulrooney	6:eed5fd627a2b	135	for( u1_t bit = 8; bit > 0; bit--)
tmulrooney	6:eed5fd627a2b	136	{
mluis	1:d3b7bde3995c	137	if( (remainder & 0x8000) )
mluis	1:d3b7bde3995c	138	remainder = (remainder << 1) ^ polynomial;
mluis	1:d3b7bde3995c	139	else
mluis	1:d3b7bde3995c	140	remainder <<= 1;
mluis	1:d3b7bde3995c	141	}
mluis	0:62d1edcc13d1	142	}
mluis	1:d3b7bde3995c	143	return remainder;
mluis	0:62d1edcc13d1	144	}
mluis	0:62d1edcc13d1	145	#endif
mluis	0:62d1edcc13d1	146
mluis	0:62d1edcc13d1	147	#endif // !HAS_os_calls
mluis	0:62d1edcc13d1	148
mluis	0:62d1edcc13d1	149	// END OS - default implementations for certain OS suport functions
mluis	0:62d1edcc13d1	150	// ================================================================================
mluis	0:62d1edcc13d1	151
mluis	0:62d1edcc13d1	152	// ================================================================================
mluis	0:62d1edcc13d1	153	// BEG AES
mluis	0:62d1edcc13d1	154
tmulrooney	5:464c1f2d6cbb	155	static void micB0 (u4_t devaddr, u4_t seqno, int dndir, int len)
tmulrooney	5:464c1f2d6cbb	156	{
tmulrooney	6:eed5fd627a2b	157	debug("LMIC micB0 enter\r\n");
mluis	0:62d1edcc13d1	158	os_clearMem(AESaux,16);
mluis	0:62d1edcc13d1	159	AESaux[0] = 0x49;
mluis	0:62d1edcc13d1	160	AESaux[5] = dndir?1:0;
mluis	0:62d1edcc13d1	161	AESaux[15] = len;
mluis	0:62d1edcc13d1	162	os_wlsbf4(AESaux+ 6,devaddr);
mluis	0:62d1edcc13d1	163	os_wlsbf4(AESaux+10,seqno);
mluis	0:62d1edcc13d1	164	}
mluis	0:62d1edcc13d1	165
mluis	0:62d1edcc13d1	166
tmulrooney	5:464c1f2d6cbb	167	static int aes_verifyMic (xref2cu1_t key, u4_t devaddr, u4_t seqno, int dndir, xref2u1_t pdu, int len)
tmulrooney	5:464c1f2d6cbb	168	{
tmulrooney	6:eed5fd627a2b	169	debug("LMIC aes_verifyMic enter\r\n");
mluis	0:62d1edcc13d1	170	micB0(devaddr, seqno, dndir, len);
mluis	0:62d1edcc13d1	171	os_copyMem(AESkey,key,16);
mluis	0:62d1edcc13d1	172	return os_aes(AES_MIC, pdu, len) == os_rmsbf4(pdu+len);
mluis	0:62d1edcc13d1	173	}
mluis	0:62d1edcc13d1	174
mluis	0:62d1edcc13d1	175
tmulrooney	5:464c1f2d6cbb	176	static void aes_appendMic (xref2cu1_t key, u4_t devaddr, u4_t seqno, int dndir, xref2u1_t pdu, int len)
tmulrooney	5:464c1f2d6cbb	177	{
tmulrooney	6:eed5fd627a2b	178	debug("LMIC aes_appendMic enter\r\n");
mluis	0:62d1edcc13d1	179	micB0(devaddr, seqno, dndir, len);
mluis	0:62d1edcc13d1	180	os_copyMem(AESkey,key,16);
mluis	0:62d1edcc13d1	181	// MSB because of internal structure of AES
mluis	0:62d1edcc13d1	182	os_wmsbf4(pdu+len, os_aes(AES_MIC, pdu, len));
mluis	0:62d1edcc13d1	183	}
mluis	0:62d1edcc13d1	184
mluis	0:62d1edcc13d1	185
tmulrooney	5:464c1f2d6cbb	186	static void aes_appendMic0 (xref2u1_t pdu, int len)
tmulrooney	5:464c1f2d6cbb	187	{
tmulrooney	6:eed5fd627a2b	188	debug("LMIC aes_appendMic0 enter\r\n");
tmulrooney	5:464c1f2d6cbb	189	os_getDevKey(AESkey);
mluis	0:62d1edcc13d1	190	os_wmsbf4(pdu+len, os_aes(AES_MIC\|AES_MICNOAUX, pdu, len)); // MSB because of internal structure of AES
mluis	0:62d1edcc13d1	191	}
mluis	0:62d1edcc13d1	192
mluis	0:62d1edcc13d1	193
tmulrooney	5:464c1f2d6cbb	194	static int aes_verifyMic0 (xref2u1_t pdu, int len)
tmulrooney	5:464c1f2d6cbb	195	{
tmulrooney	6:eed5fd627a2b	196	debug("LMIC aes_verifyMic0 enter\r\n");
mluis	0:62d1edcc13d1	197	os_getDevKey(AESkey);
mluis	0:62d1edcc13d1	198	return os_aes(AES_MIC\|AES_MICNOAUX, pdu, len) == os_rmsbf4(pdu+len);
mluis	0:62d1edcc13d1	199	}
mluis	0:62d1edcc13d1	200
mluis	0:62d1edcc13d1	201
tmulrooney	5:464c1f2d6cbb	202	static void aes_encrypt (xref2u1_t pdu, int len)
tmulrooney	5:464c1f2d6cbb	203	{
tmulrooney	6:eed5fd627a2b	204	debug("LMIC aes_encrypt enter\r\n");
mluis	0:62d1edcc13d1	205	os_getDevKey(AESkey);
mluis	0:62d1edcc13d1	206	os_aes(AES_ENC, pdu, len);
mluis	0:62d1edcc13d1	207	}
mluis	0:62d1edcc13d1	208
mluis	0:62d1edcc13d1	209
tmulrooney	5:464c1f2d6cbb	210	static void aes_cipher (xref2cu1_t key, u4_t devaddr, u4_t seqno, int dndir, xref2u1_t payload, int len)
tmulrooney	5:464c1f2d6cbb	211	{
tmulrooney	6:eed5fd627a2b	212	debug("LMIC aes_cipher enter\r\n");
tmulrooney	5:464c1f2d6cbb	213	if( len <= 0 )
mluis	1:d3b7bde3995c	214	return;
mluis	0:62d1edcc13d1	215	os_clearMem(AESaux, 16);
mluis	0:62d1edcc13d1	216	AESaux[0] = AESaux[15] = 1; // mode=cipher / dir=down / block counter=1
mluis	0:62d1edcc13d1	217	AESaux[5] = dndir?1:0;
mluis	0:62d1edcc13d1	218	os_wlsbf4(AESaux+ 6,devaddr);
mluis	0:62d1edcc13d1	219	os_wlsbf4(AESaux+10,seqno);
mluis	0:62d1edcc13d1	220	os_copyMem(AESkey,key,16);
mluis	0:62d1edcc13d1	221	os_aes(AES_CTR, payload, len);
mluis	0:62d1edcc13d1	222	}
mluis	0:62d1edcc13d1	223
mluis	0:62d1edcc13d1	224
tmulrooney	5:464c1f2d6cbb	225	static void aes_sessKeys (u2_t devnonce, xref2cu1_t artnonce, xref2u1_t nwkkey, xref2u1_t artkey)
tmulrooney	5:464c1f2d6cbb	226	{
tmulrooney	6:eed5fd627a2b	227	debug("LMIC aes_sessKeys enter\r\n");
mluis	0:62d1edcc13d1	228	os_clearMem(nwkkey, 16);
mluis	0:62d1edcc13d1	229	nwkkey[0] = 0x01;
mluis	0:62d1edcc13d1	230	os_copyMem(nwkkey+1, artnonce, LEN_ARTNONCE+LEN_NETID);
mluis	0:62d1edcc13d1	231	os_wlsbf2(nwkkey+1+LEN_ARTNONCE+LEN_NETID, devnonce);
mluis	0:62d1edcc13d1	232	os_copyMem(artkey, nwkkey, 16);
mluis	0:62d1edcc13d1	233	artkey[0] = 0x02;
mluis	0:62d1edcc13d1	234
mluis	0:62d1edcc13d1	235	os_getDevKey(AESkey);
mluis	0:62d1edcc13d1	236	os_aes(AES_ENC, nwkkey, 16);
mluis	0:62d1edcc13d1	237	os_getDevKey(AESkey);
mluis	0:62d1edcc13d1	238	os_aes(AES_ENC, artkey, 16);
mluis	0:62d1edcc13d1	239	}
mluis	0:62d1edcc13d1	240
mluis	0:62d1edcc13d1	241	// END AES
mluis	0:62d1edcc13d1	242	// ================================================================================
mluis	0:62d1edcc13d1	243
mluis	0:62d1edcc13d1	244
mluis	0:62d1edcc13d1	245	// ================================================================================
mluis	0:62d1edcc13d1	246	// BEG LORA
mluis	0:62d1edcc13d1	247
mluis	1:d3b7bde3995c	248	#if defined(CFG_eu868) // ========================================
mluis	0:62d1edcc13d1	249
mluis	0:62d1edcc13d1	250	#define maxFrameLen(dr) ((dr)<=DR_SF9 ? maxFrameLens[(dr)] : 0xFF)
mluis	0:62d1edcc13d1	251	const u1_t maxFrameLens [] = { 64,64,64,123 };
mluis	0:62d1edcc13d1	252
mluis	0:62d1edcc13d1	253	const u1_t _DR2RPS_CRC[] = {
mluis	0:62d1edcc13d1	254	ILLEGAL_RPS,
mluis	0:62d1edcc13d1	255	(u1_t)MAKERPS(SF12, BW125, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	256	(u1_t)MAKERPS(SF11, BW125, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	257	(u1_t)MAKERPS(SF10, BW125, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	258	(u1_t)MAKERPS(SF9, BW125, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	259	(u1_t)MAKERPS(SF8, BW125, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	260	(u1_t)MAKERPS(SF7, BW125, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	261	(u1_t)MAKERPS(SF7, BW250, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	262	(u1_t)MAKERPS(FSK, BW125, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	263	ILLEGAL_RPS
mluis	0:62d1edcc13d1	264	};
mluis	0:62d1edcc13d1	265
mluis	0:62d1edcc13d1	266	static const s1_t TXPOWLEVELS[] = {
mluis	0:62d1edcc13d1	267	20, 14, 11, 8, 5, 2, 0,0, 0,0,0,0, 0,0,0,0
mluis	0:62d1edcc13d1	268	};
mluis	0:62d1edcc13d1	269	#define pow2dBm(mcmd_ladr_p1) (TXPOWLEVELS[(mcmd_ladr_p1&MCMD_LADR_POW_MASK)>>MCMD_LADR_POW_SHIFT])
mluis	0:62d1edcc13d1	270
mluis	1:d3b7bde3995c	271	#elif defined(CFG_us915) // ========================================
mluis	0:62d1edcc13d1	272
mluis	0:62d1edcc13d1	273	#define maxFrameLen(dr) ((dr)<=DR_SF11CR ? maxFrameLens[(dr)] : 0xFF)
dudmuck	2:974cafbfb159	274	//const u1_t maxFrameLens [] = { 24,66,142,255,255,255,255,255, 66,142 };
mluis	0:62d1edcc13d1	275
mluis	0:62d1edcc13d1	276	const u1_t _DR2RPS_CRC[] = {
mluis	0:62d1edcc13d1	277	ILLEGAL_RPS,
mluis	0:62d1edcc13d1	278	MAKERPS(SF10, BW125, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	279	MAKERPS(SF9 , BW125, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	280	MAKERPS(SF8 , BW125, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	281	MAKERPS(SF7 , BW125, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	282	MAKERPS(SF8 , BW500, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	283	ILLEGAL_RPS ,
mluis	0:62d1edcc13d1	284	ILLEGAL_RPS ,
mluis	0:62d1edcc13d1	285	ILLEGAL_RPS ,
mluis	0:62d1edcc13d1	286	MAKERPS(SF12, BW500, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	287	MAKERPS(SF11, BW500, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	288	MAKERPS(SF10, BW500, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	289	MAKERPS(SF9 , BW500, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	290	MAKERPS(SF8 , BW500, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	291	MAKERPS(SF7 , BW500, CR_4_5, 0, 0),
mluis	0:62d1edcc13d1	292	ILLEGAL_RPS
mluis	0:62d1edcc13d1	293	};
mluis	0:62d1edcc13d1	294
mluis	0:62d1edcc13d1	295	#define pow2dBm(mcmd_ladr_p1) ((s1_t)(30 - (((mcmd_ladr_p1)&MCMD_LADR_POW_MASK)<<1)))
mluis	0:62d1edcc13d1	296
mluis	0:62d1edcc13d1	297	#endif // ================================================
mluis	0:62d1edcc13d1	298
mluis	0:62d1edcc13d1	299	static const u1_t SENSITIVITY[7][3] = {
mluis	0:62d1edcc13d1	300	// ------------bw----------
mluis	0:62d1edcc13d1	301	// 125kHz 250kHz 500kHz
mluis	0:62d1edcc13d1	302	{ 141-109, 141-109, 141-109 }, // FSK
mluis	0:62d1edcc13d1	303	{ 141-127, 141-124, 141-121 }, // SF7
mluis	0:62d1edcc13d1	304	{ 141-129, 141-126, 141-123 }, // SF8
mluis	0:62d1edcc13d1	305	{ 141-132, 141-129, 141-126 }, // SF9
mluis	0:62d1edcc13d1	306	{ 141-135, 141-132, 141-129 }, // SF10
mluis	0:62d1edcc13d1	307	{ 141-138, 141-135, 141-132 }, // SF11
mluis	0:62d1edcc13d1	308	{ 141-141, 141-138, 141-135 } // SF12
mluis	0:62d1edcc13d1	309	};
mluis	0:62d1edcc13d1	310
tmulrooney	5:464c1f2d6cbb	311	int getSensitivity (rps_t rps)
tmulrooney	5:464c1f2d6cbb	312	{
tmulrooney	6:eed5fd627a2b	313	debug("LMIC getSensitivity enter\r\n");
mluis	0:62d1edcc13d1	314	return -141 + SENSITIVITY[getSf(rps)][getBw(rps)];
mluis	0:62d1edcc13d1	315	}
mluis	0:62d1edcc13d1	316
tmulrooney	5:464c1f2d6cbb	317	ostime_t calcAirTime (rps_t rps, u1_t plen)
tmulrooney	5:464c1f2d6cbb	318	{
tmulrooney	6:eed5fd627a2b	319	debug("LMIC calcAirTime enter\r\n");
tmulrooney	5:464c1f2d6cbb	320	u1_t bw = getBw(rps); // 0,1,2 = 125,250,500kHz
mluis	0:62d1edcc13d1	321	u1_t sf = getSf(rps); // 0=FSK, 1..6 = SF7..12
mluis	0:62d1edcc13d1	322	if( sf == FSK ) {
mluis	1:d3b7bde3995c	323	return (plen+/preamble/5+/syncword/3+/len/1+/crc/2) * /bits/byte/8
mluis	1:d3b7bde3995c	324	* (s4_t)OSTICKS_PER_SEC / /kbit/s/50000;
mluis	0:62d1edcc13d1	325	}
mluis	0:62d1edcc13d1	326	u1_t sfx = 4*(sf+(7-SF7));
mluis	0:62d1edcc13d1	327	u1_t q = sfx - (sf >= SF11 ? 8 : 0);
mluis	0:62d1edcc13d1	328	int tmp = 8*plen - sfx + 28 + (getNocrc(rps)?0:16) - (getIh(rps)?20:0);
mluis	0:62d1edcc13d1	329	if( tmp > 0 ) {
mluis	1:d3b7bde3995c	330	tmp = (tmp + q - 1) / q;
mluis	1:d3b7bde3995c	331	tmp *= getCr(rps)+5;
mluis	1:d3b7bde3995c	332	tmp += 8;
mluis	0:62d1edcc13d1	333	} else {
mluis	1:d3b7bde3995c	334	tmp = 8;
mluis	0:62d1edcc13d1	335	}
mluis	0:62d1edcc13d1	336	tmp = (tmp<<2) + /preamble/49 /* 4 * (8 + 4.25) */;
mluis	0:62d1edcc13d1	337	// bw = 125000 = 15625 * 2^3
mluis	0:62d1edcc13d1	338	// 250000 = 15625 * 2^4
mluis	0:62d1edcc13d1	339	// 500000 = 15625 * 2^5
mluis	0:62d1edcc13d1	340	// sf = 7..12
mluis	0:62d1edcc13d1	341	//
mluis	0:62d1edcc13d1	342	// osticks = tmp * OSTICKS_PER_SEC * 1<<sf / bw
mluis	0:62d1edcc13d1	343	//
mluis	0:62d1edcc13d1	344	// 3 => counter reduced divisor 125000/8 => 15625
mluis	0:62d1edcc13d1	345	// 2 => counter 2 shift on tmp
mluis	0:62d1edcc13d1	346	sfx = sf+(7-SF7) - (3+2) - bw;
mluis	0:62d1edcc13d1	347	int div = 15625;
mluis	0:62d1edcc13d1	348	if( sfx > 4 ) {
mluis	1:d3b7bde3995c	349	// prevent 32bit signed int overflow in last step
mluis	1:d3b7bde3995c	350	div >>= sfx-4;
mluis	1:d3b7bde3995c	351	sfx = 4;
mluis	0:62d1edcc13d1	352	}
mluis	0:62d1edcc13d1	353	// Need 32bit arithmetic for this last step
mluis	0:62d1edcc13d1	354	return (((ostime_t)tmp << sfx) * OSTICKS_PER_SEC + div/2) / div;
mluis	0:62d1edcc13d1	355	}
mluis	0:62d1edcc13d1	356
dudmuck	2:974cafbfb159	357	/*extern inline s1_t rssi2s1 (int v);
mluis	0:62d1edcc13d1	358	extern inline int s12rssi (s1_t v);
mluis	0:62d1edcc13d1	359	extern inline float s12snr (s1_t v);
dudmuck	2:974cafbfb159	360	extern inline s1_t snr2s1 (double v);*/
mluis	0:62d1edcc13d1	361
mluis	0:62d1edcc13d1	362	extern inline rps_t updr2rps (dr_t dr);
mluis	0:62d1edcc13d1	363	extern inline rps_t dndr2rps (dr_t dr);
mluis	0:62d1edcc13d1	364	extern inline int isFasterDR (dr_t dr1, dr_t dr2);
mluis	0:62d1edcc13d1	365	extern inline int isSlowerDR (dr_t dr1, dr_t dr2);
mluis	0:62d1edcc13d1	366	extern inline dr_t incDR (dr_t dr);
mluis	0:62d1edcc13d1	367	extern inline dr_t decDR (dr_t dr);
mluis	0:62d1edcc13d1	368	extern inline dr_t assertDR (dr_t dr);
mluis	0:62d1edcc13d1	369	extern inline dr_t validDR (dr_t dr);
mluis	0:62d1edcc13d1	370	extern inline dr_t lowerDR (dr_t dr, u1_t n);
mluis	0:62d1edcc13d1	371
mluis	0:62d1edcc13d1	372	extern inline sf_t getSf (rps_t params);
mluis	0:62d1edcc13d1	373	extern inline rps_t setSf (rps_t params, sf_t sf);
mluis	0:62d1edcc13d1	374	extern inline bw_t getBw (rps_t params);
mluis	0:62d1edcc13d1	375	extern inline rps_t setBw (rps_t params, bw_t cr);
mluis	0:62d1edcc13d1	376	extern inline cr_t getCr (rps_t params);
mluis	0:62d1edcc13d1	377	extern inline rps_t setCr (rps_t params, cr_t cr);
mluis	0:62d1edcc13d1	378	extern inline int getNocrc (rps_t params);
mluis	0:62d1edcc13d1	379	extern inline rps_t setNocrc (rps_t params, int nocrc);
mluis	0:62d1edcc13d1	380	extern inline int getIh (rps_t params);
mluis	0:62d1edcc13d1	381	extern inline rps_t setIh (rps_t params, int ih);
mluis	0:62d1edcc13d1	382	extern inline rps_t makeRps (sf_t sf, bw_t bw, cr_t cr, int ih, int nocrc);
mluis	0:62d1edcc13d1	383	extern inline int sameSfBw (rps_t r1, rps_t r2);
mluis	0:62d1edcc13d1	384
mluis	0:62d1edcc13d1	385	// END LORA
mluis	0:62d1edcc13d1	386	// ================================================================================
mluis	0:62d1edcc13d1	387
mluis	0:62d1edcc13d1	388
mluis	0:62d1edcc13d1	389	// Adjust DR for TX retries
mluis	0:62d1edcc13d1	390	// - indexed by retry count
mluis	0:62d1edcc13d1	391	// - return steps to lower DR
mluis	0:62d1edcc13d1	392	static const u1_t DRADJUST[2+TXCONF_ATTEMPTS] = {
mluis	0:62d1edcc13d1	393	// normal frames - 1st try / no retry
mluis	0:62d1edcc13d1	394	0,
mluis	0:62d1edcc13d1	395	// confirmed frames
mluis	1:d3b7bde3995c	396	0,0,1,0,1,0,1,0,0
mluis	0:62d1edcc13d1	397	};
mluis	0:62d1edcc13d1	398
mluis	0:62d1edcc13d1	399
mluis	0:62d1edcc13d1	400	// Table below defines the size of one symbol as
mluis	0:62d1edcc13d1	401	// symtime = 256us * 2^T(sf,bw)
mluis	0:62d1edcc13d1	402	// 256us is called one symunit.
mluis	1:d3b7bde3995c	403	// SF:
mluis	1:d3b7bde3995c	404	// BW: \|__7___8___9__10__11__12
mluis	1:d3b7bde3995c	405	// 125kHz \| 2 3 4 5 6 7
mluis	1:d3b7bde3995c	406	// 250kHz \| 1 2 3 4 5 6
mluis	1:d3b7bde3995c	407	// 500kHz \| 0 1 2 3 4 5
mluis	0:62d1edcc13d1	408	//
mluis	0:62d1edcc13d1	409	// Times for half symbol per DR
mluis	0:62d1edcc13d1	410	// Per DR table to minimize rounding errors
mluis	0:62d1edcc13d1	411	static const ostime_t DR2HSYM_osticks[] = {
mluis	1:d3b7bde3995c	412	#if defined(CFG_eu868)
mluis	0:62d1edcc13d1	413	#define dr2hsym(dr) (DR2HSYM_osticks[(dr)])
mluis	0:62d1edcc13d1	414	us2osticksRound(128<<7), // DR_SF12
mluis	0:62d1edcc13d1	415	us2osticksRound(128<<6), // DR_SF11
mluis	0:62d1edcc13d1	416	us2osticksRound(128<<5), // DR_SF10
mluis	0:62d1edcc13d1	417	us2osticksRound(128<<4), // DR_SF9
mluis	0:62d1edcc13d1	418	us2osticksRound(128<<3), // DR_SF8
mluis	0:62d1edcc13d1	419	us2osticksRound(128<<2), // DR_SF7
mluis	0:62d1edcc13d1	420	us2osticksRound(128<<1), // DR_SF7B
mluis	0:62d1edcc13d1	421	us2osticksRound(80) // FSK -- not used (time for 1/2 byte)
mluis	1:d3b7bde3995c	422	#elif defined(CFG_us915)
mluis	0:62d1edcc13d1	423	#define dr2hsym(dr) (DR2HSYM_osticks[(dr)&7]) // map DR_SFnCR -> 0-6
mluis	0:62d1edcc13d1	424	us2osticksRound(128<<5), // DR_SF10 DR_SF12CR
mluis	0:62d1edcc13d1	425	us2osticksRound(128<<4), // DR_SF9 DR_SF11CR
mluis	0:62d1edcc13d1	426	us2osticksRound(128<<3), // DR_SF8 DR_SF10CR
mluis	0:62d1edcc13d1	427	us2osticksRound(128<<2), // DR_SF7 DR_SF9CR
mluis	0:62d1edcc13d1	428	us2osticksRound(128<<1), // DR_SF8C DR_SF8CR
mluis	0:62d1edcc13d1	429	us2osticksRound(128<<0) // ------ DR_SF7CR
mluis	0:62d1edcc13d1	430	#endif
mluis	0:62d1edcc13d1	431	};
mluis	0:62d1edcc13d1	432
mluis	0:62d1edcc13d1	433
tmulrooney	5:464c1f2d6cbb	434	static ostime_t calcRxWindow (u1_t secs, dr_t dr)
tmulrooney	5:464c1f2d6cbb	435	{
tmulrooney	6:eed5fd627a2b	436	debug("LMIC calcRxWindow enter\r\n");
mluis	0:62d1edcc13d1	437	ostime_t rxoff, err;
mluis	0:62d1edcc13d1	438	if( secs==0 ) {
mluis	1:d3b7bde3995c	439	// aka 128 secs (next becaon)
mluis	1:d3b7bde3995c	440	rxoff = LMIC.drift;
mluis	1:d3b7bde3995c	441	err = LMIC.lastDriftDiff;
mluis	0:62d1edcc13d1	442	} else {
mluis	1:d3b7bde3995c	443	// scheduled RX window within secs into current beacon period
mluis	1:d3b7bde3995c	444	rxoff = (LMIC.drift * (ostime_t)secs) >> BCN_INTV_exp;
mluis	1:d3b7bde3995c	445	err = (LMIC.lastDriftDiff * (ostime_t)secs) >> BCN_INTV_exp;
mluis	0:62d1edcc13d1	446	}
mluis	0:62d1edcc13d1	447	u1_t rxsyms = MINRX_SYMS;
mluis	0:62d1edcc13d1	448	err += (ostime_t)LMIC.maxDriftDiff * LMIC.missedBcns;
mluis	0:62d1edcc13d1	449	LMIC.rxsyms = MINRX_SYMS + (err / dr2hsym(dr));
mluis	0:62d1edcc13d1	450
mluis	0:62d1edcc13d1	451	return (rxsyms-PAMBL_SYMS) * dr2hsym(dr) + rxoff;
mluis	0:62d1edcc13d1	452	}
mluis	0:62d1edcc13d1	453
mluis	0:62d1edcc13d1	454
mluis	0:62d1edcc13d1	455	// Setup beacon RX parameters assuming we have an error of ms (aka +/-(ms/2))
tmulrooney	5:464c1f2d6cbb	456	static void calcBcnRxWindowFromMillis (u1_t ms, bit_t ini)
tmulrooney	5:464c1f2d6cbb	457	{
tmulrooney	6:eed5fd627a2b	458	debug("LMIC calcBcnRxWindowFromMillis enter\r\n");
mluis	0:62d1edcc13d1	459	if( ini ) {
mluis	1:d3b7bde3995c	460	LMIC.drift = 0;
mluis	1:d3b7bde3995c	461	LMIC.maxDriftDiff = 0;
mluis	1:d3b7bde3995c	462	LMIC.missedBcns = 0;
mluis	1:d3b7bde3995c	463	LMIC.bcninfo.flags \|= BCN_NODRIFT\|BCN_NODDIFF;
mluis	0:62d1edcc13d1	464	}
mluis	0:62d1edcc13d1	465	ostime_t hsym = dr2hsym(DR_BCN);
mluis	0:62d1edcc13d1	466	LMIC.bcnRxsyms = MINRX_SYMS + ms2osticksCeil(ms) / hsym;
mluis	0:62d1edcc13d1	467	LMIC.bcnRxtime = LMIC.bcninfo.txtime + BCN_INTV_osticks - (LMIC.bcnRxsyms-PAMBL_SYMS) * hsym;
mluis	0:62d1edcc13d1	468	}
mluis	0:62d1edcc13d1	469
mluis	0:62d1edcc13d1	470
mluis	0:62d1edcc13d1	471	// Setup scheduled RX window (ping/multicast slot)
tmulrooney	5:464c1f2d6cbb	472	static void rxschedInit (xref2rxsched_t rxsched)
tmulrooney	5:464c1f2d6cbb	473	{
tmulrooney	6:eed5fd627a2b	474	debug("LMIC rxschedInit enter\r\n");
mluis	0:62d1edcc13d1	475	os_clearMem(AESkey,16);
mluis	0:62d1edcc13d1	476	os_clearMem(LMIC.frame+8,8);
mluis	0:62d1edcc13d1	477	os_wlsbf4(LMIC.frame, LMIC.bcninfo.time);
mluis	0:62d1edcc13d1	478	os_wlsbf4(LMIC.frame+4, LMIC.devaddr);
mluis	0:62d1edcc13d1	479	os_aes(AES_ENC,LMIC.frame,16);
mluis	0:62d1edcc13d1	480	u1_t intvExp = rxsched->intvExp;
mluis	0:62d1edcc13d1	481	ostime_t off = os_rlsbf2(LMIC.frame) & (0x0FFF >> (7 - intvExp)); // random offset (slot units)
mluis	0:62d1edcc13d1	482	rxsched->rxbase = (LMIC.bcninfo.txtime +
mluis	1:d3b7bde3995c	483	BCN_RESERVE_osticks +
mluis	1:d3b7bde3995c	484	ms2osticks(BCN_SLOT_SPAN_ms * off)); // random offset osticks
mluis	0:62d1edcc13d1	485	rxsched->slot = 0;
mluis	0:62d1edcc13d1	486	rxsched->rxtime = rxsched->rxbase - calcRxWindow(/secs BCN_RESERVE/2+(1<<intvExp),rxsched->dr);
mluis	0:62d1edcc13d1	487	rxsched->rxsyms = LMIC.rxsyms;
mluis	0:62d1edcc13d1	488	}
mluis	0:62d1edcc13d1	489
mluis	0:62d1edcc13d1	490
tmulrooney	5:464c1f2d6cbb	491	static bit_t rxschedNext (xref2rxsched_t rxsched, ostime_t cando)
tmulrooney	5:464c1f2d6cbb	492	{
tmulrooney	6:eed5fd627a2b	493	debug("LMIC rxschedNext enter\r\n");
mluis	0:62d1edcc13d1	494	again:
mluis	0:62d1edcc13d1	495	if( rxsched->rxtime - cando >= 0 )
mluis	1:d3b7bde3995c	496	return 1;
mluis	0:62d1edcc13d1	497	u1_t slot;
mluis	0:62d1edcc13d1	498	if( (slot=rxsched->slot) >= 128 )
mluis	1:d3b7bde3995c	499	return 0;
mluis	0:62d1edcc13d1	500	u1_t intv = 1<<rxsched->intvExp;
mluis	0:62d1edcc13d1	501	if( (rxsched->slot = (slot += (intv))) >= 128 )
mluis	1:d3b7bde3995c	502	return 0;
mluis	0:62d1edcc13d1	503	rxsched->rxtime = rxsched->rxbase
mluis	1:d3b7bde3995c	504	+ ((BCN_WINDOW_osticks * (ostime_t)slot) >> BCN_INTV_exp)
mluis	1:d3b7bde3995c	505	- calcRxWindow(/secs BCN_RESERVE/2+slot+intv,rxsched->dr);
mluis	0:62d1edcc13d1	506	rxsched->rxsyms = LMIC.rxsyms;
mluis	0:62d1edcc13d1	507	goto again;
mluis	0:62d1edcc13d1	508	}
mluis	0:62d1edcc13d1	509
mluis	0:62d1edcc13d1	510
tmulrooney	5:464c1f2d6cbb	511	static ostime_t rndDelay (u1_t secSpan)
tmulrooney	5:464c1f2d6cbb	512	{
tmulrooney	6:eed5fd627a2b	513	debug("LMIC rndDelay enter\r\n");
mluis	0:62d1edcc13d1	514	u2_t r = os_getRndU2();
mluis	0:62d1edcc13d1	515	ostime_t delay = r;
mluis	0:62d1edcc13d1	516	if( delay > OSTICKS_PER_SEC )
mluis	1:d3b7bde3995c	517	delay = r % (u2_t)OSTICKS_PER_SEC;
mluis	0:62d1edcc13d1	518	if( secSpan > 0 )
mluis	1:d3b7bde3995c	519	delay += ((u1_t)r % secSpan) * OSTICKS_PER_SEC;
mluis	0:62d1edcc13d1	520	return delay;
mluis	0:62d1edcc13d1	521	}
mluis	0:62d1edcc13d1	522
mluis	0:62d1edcc13d1	523
tmulrooney	5:464c1f2d6cbb	524	static void txDelay (ostime_t reftime, u1_t secSpan)
tmulrooney	5:464c1f2d6cbb	525	{
tmulrooney	6:eed5fd627a2b	526	debug("LMIC txDelay enter\r\n");
mluis	0:62d1edcc13d1	527	reftime += rndDelay(secSpan);
mluis	0:62d1edcc13d1	528	if( LMIC.globalDutyRate == 0 \|\| (reftime - LMIC.globalDutyAvail) > 0 ) {
mluis	1:d3b7bde3995c	529	LMIC.globalDutyAvail = reftime;
mluis	1:d3b7bde3995c	530	LMIC.opmode \|= OP_RNDTX;
mluis	0:62d1edcc13d1	531	}
mluis	0:62d1edcc13d1	532	}
mluis	0:62d1edcc13d1	533
mluis	0:62d1edcc13d1	534
tmulrooney	5:464c1f2d6cbb	535	static void setDrJoin (u1_t reason, u1_t dr)
tmulrooney	5:464c1f2d6cbb	536	{
tmulrooney	6:eed5fd627a2b	537	debug("LMIC setDrJoin enter\r\n");
mluis	0:62d1edcc13d1	538	EV(drChange, INFO, (e_.reason = reason,
mluis	1:d3b7bde3995c	539	e_.deveui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	540	e_.dr = dr\|DR_PAGE,
mluis	1:d3b7bde3995c	541	e_.txpow = LMIC.adrTxPow,
mluis	1:d3b7bde3995c	542	e_.prevdr = LMIC.datarate\|DR_PAGE,
mluis	1:d3b7bde3995c	543	e_.prevtxpow = LMIC.adrTxPow));
mluis	0:62d1edcc13d1	544	LMIC.datarate = dr;
mluis	1:d3b7bde3995c	545	DO_DEVDB(LMIC.datarate,datarate);
mluis	0:62d1edcc13d1	546	}
mluis	0:62d1edcc13d1	547
mluis	0:62d1edcc13d1	548
tmulrooney	5:464c1f2d6cbb	549	static void setDrTxpow (u1_t reason, u1_t dr, s1_t pow)
tmulrooney	5:464c1f2d6cbb	550	{
tmulrooney	6:eed5fd627a2b	551	debug("LMIC setDrTxpow enter\r\n");
tmulrooney	5:464c1f2d6cbb	552	EV(drChange, INFO, (e_.reason = reason,
mluis	1:d3b7bde3995c	553	e_.deveui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	554	e_.dr = dr\|DR_PAGE,
mluis	1:d3b7bde3995c	555	e_.txpow = pow,
mluis	1:d3b7bde3995c	556	e_.prevdr = LMIC.datarate\|DR_PAGE,
mluis	1:d3b7bde3995c	557	e_.prevtxpow = LMIC.adrTxPow));
mluis	1:d3b7bde3995c	558
dudmuck	2:974cafbfb159	559	if( pow != KEEP_TXPOW ) {
dudmuck	2:974cafbfb159	560	LMIC.adrTxPow = pow;
dudmuck	2:974cafbfb159	561	if (pow < LMIC.txpow_limit)
dudmuck	2:974cafbfb159	562	LMIC.txpow = pow;
dudmuck	2:974cafbfb159	563	}
mluis	1:d3b7bde3995c	564	if( LMIC.datarate != dr ) {
mluis	1:d3b7bde3995c	565	LMIC.datarate = dr;
mluis	1:d3b7bde3995c	566	DO_DEVDB(LMIC.datarate,datarate);
mluis	1:d3b7bde3995c	567	LMIC.opmode \|= OP_NEXTCHNL;
mluis	1:d3b7bde3995c	568	}
mluis	0:62d1edcc13d1	569	}
mluis	0:62d1edcc13d1	570
mluis	0:62d1edcc13d1	571
tmulrooney	5:464c1f2d6cbb	572	void LMIC_stopPingable (void)
tmulrooney	5:464c1f2d6cbb	573	{
tmulrooney	6:eed5fd627a2b	574	debug("LMIC LMIC_stopPingable enter\r\n");
tmulrooney	5:464c1f2d6cbb	575	LMIC.opmode &= ~(OP_PINGABLE\|OP_PINGINI);
mluis	0:62d1edcc13d1	576	}
mluis	0:62d1edcc13d1	577
mluis	0:62d1edcc13d1	578
tmulrooney	5:464c1f2d6cbb	579	void LMIC_setPingable (u1_t intvExp)
tmulrooney	5:464c1f2d6cbb	580	{
tmulrooney	6:eed5fd627a2b	581	debug("LMIC LMIC_setPingable enter\r\n");
mluis	0:62d1edcc13d1	582	// Change setting
mluis	0:62d1edcc13d1	583	LMIC.ping.intvExp = (intvExp & 0x7);
mluis	0:62d1edcc13d1	584	LMIC.opmode \|= OP_PINGABLE;
mluis	0:62d1edcc13d1	585	// App may call LMIC_enableTracking() explicitely before
mluis	0:62d1edcc13d1	586	// Otherwise tracking is implicitly enabled here
mluis	0:62d1edcc13d1	587	if( (LMIC.opmode & (OP_TRACK\|OP_SCAN)) == 0 && LMIC.bcninfoTries == 0 )
mluis	1:d3b7bde3995c	588	LMIC_enableTracking(0);
mluis	0:62d1edcc13d1	589	}
mluis	0:62d1edcc13d1	590
mluis	0:62d1edcc13d1	591
mluis	1:d3b7bde3995c	592	#if defined(CFG_eu868)
mluis	0:62d1edcc13d1	593	// ================================================================================
mluis	0:62d1edcc13d1	594	//
mluis	0:62d1edcc13d1	595	// BEG: EU868 related stuff
mluis	0:62d1edcc13d1	596	//
mluis	1:d3b7bde3995c	597	enum { NUM_DEFAULT_CHANNELS=6 };
mluis	0:62d1edcc13d1	598	static const u4_t iniChannelFreq[12] = {
mluis	0:62d1edcc13d1	599	// Join frequencies and duty cycle limit (0.1%)
mluis	1:d3b7bde3995c	600	EU868_F1\|BAND_MILLI, EU868_J4\|BAND_MILLI,
mluis	1:d3b7bde3995c	601	EU868_F2\|BAND_MILLI, EU868_J5\|BAND_MILLI,
mluis	1:d3b7bde3995c	602	EU868_F3\|BAND_MILLI, EU868_J6\|BAND_MILLI,
mluis	0:62d1edcc13d1	603	// Default operational frequencies
mluis	0:62d1edcc13d1	604	EU868_F1\|BAND_CENTI, EU868_F2\|BAND_CENTI, EU868_F3\|BAND_CENTI,
mluis	0:62d1edcc13d1	605	EU868_F4\|BAND_MILLI, EU868_F5\|BAND_MILLI, EU868_F6\|BAND_DECI
mluis	0:62d1edcc13d1	606	};
mluis	0:62d1edcc13d1	607
mluis	0:62d1edcc13d1	608	static void initDefaultChannels (bit_t join) {
mluis	1:d3b7bde3995c	609	os_clearMem(&LMIC.channelFreq, sizeof(LMIC.channelFreq));
mluis	1:d3b7bde3995c	610	os_clearMem(&LMIC.channelDrMap, sizeof(LMIC.channelDrMap));
mluis	1:d3b7bde3995c	611	os_clearMem(&LMIC.bands, sizeof(LMIC.bands));
mluis	1:d3b7bde3995c	612
dudmuck	2:974cafbfb159	613	LMIC.channelMap = 0x3;
mluis	0:62d1edcc13d1	614	u1_t su = join ? 0 : 6;
mluis	0:62d1edcc13d1	615	for( u1_t fu=0; fu<6; fu++,su++ ) {
mluis	1:d3b7bde3995c	616	LMIC.channelFreq[fu] = iniChannelFreq[su];
mluis	1:d3b7bde3995c	617	LMIC.channelDrMap[fu] = DR_RANGE_MAP(DR_SF12,DR_SF7);
mluis	0:62d1edcc13d1	618	}
mluis	1:d3b7bde3995c	619	if( !join ) {
mluis	1:d3b7bde3995c	620	LMIC.channelDrMap[5] = DR_RANGE_MAP(DR_SF12,DR_SF7);
mluis	1:d3b7bde3995c	621	LMIC.channelDrMap[1] = DR_RANGE_MAP(DR_SF12,DR_FSK);
mluis	1:d3b7bde3995c	622	}
mluis	0:62d1edcc13d1	623
mluis	1:d3b7bde3995c	624	LMIC.bands[BAND_MILLI].txcap = 1000; // 0.1%
mluis	1:d3b7bde3995c	625	LMIC.bands[BAND_MILLI].txpow = 14;
mluis	1:d3b7bde3995c	626	LMIC.bands[BAND_MILLI].lastchnl = os_getRndU1() % MAX_CHANNELS;
mluis	1:d3b7bde3995c	627	LMIC.bands[BAND_CENTI].txcap = 100; // 1%
mluis	1:d3b7bde3995c	628	LMIC.bands[BAND_CENTI].txpow = 14;
mluis	1:d3b7bde3995c	629	LMIC.bands[BAND_CENTI].lastchnl = os_getRndU1() % MAX_CHANNELS;
mluis	1:d3b7bde3995c	630	LMIC.bands[BAND_DECI ].txcap = 10; // 10%
mluis	1:d3b7bde3995c	631	LMIC.bands[BAND_DECI ].txpow = 27;
mluis	1:d3b7bde3995c	632	LMIC.bands[BAND_CENTI].lastchnl = os_getRndU1() % MAX_CHANNELS;
mluis	0:62d1edcc13d1	633	LMIC.bands[BAND_MILLI].avail =
mluis	0:62d1edcc13d1	634	LMIC.bands[BAND_CENTI].avail =
mluis	0:62d1edcc13d1	635	LMIC.bands[BAND_DECI ].avail = os_getTime();
mluis	0:62d1edcc13d1	636	}
mluis	0:62d1edcc13d1	637
mluis	1:d3b7bde3995c	638	bit_t LMIC_setupBand (u1_t bandidx, s1_t txpow, u2_t txcap) {
mluis	1:d3b7bde3995c	639	if( bandidx > BAND_AUX ) return 0;
mluis	1:d3b7bde3995c	640	band_t* b = &LMIC.bands[bandidx];
mluis	1:d3b7bde3995c	641	b->txpow = txpow;
mluis	1:d3b7bde3995c	642	b->txcap = txcap;
mluis	1:d3b7bde3995c	643	b->avail = os_getTime();
mluis	1:d3b7bde3995c	644	b->lastchnl = os_getRndU1() % MAX_CHANNELS;
mluis	1:d3b7bde3995c	645	return 1;
mluis	1:d3b7bde3995c	646	}
mluis	1:d3b7bde3995c	647
mluis	1:d3b7bde3995c	648	bit_t LMIC_setupChannel (u1_t chidx, u4_t freq, u2_t drmap, s1_t band) {
mluis	1:d3b7bde3995c	649	if( chidx >= MAX_CHANNELS )
mluis	1:d3b7bde3995c	650	return 0;
mluis	1:d3b7bde3995c	651	if( band == -1 ) {
mluis	1:d3b7bde3995c	652	if( freq >= 869400000 && freq <= 869650000 )
mluis	1:d3b7bde3995c	653	freq \|= BAND_DECI; // 10% 27dBm
mluis	1:d3b7bde3995c	654	else if( (freq >= 868000000 && freq <= 868600000) \|\|
mluis	1:d3b7bde3995c	655	(freq >= 869700000 && freq <= 870000000) )
mluis	1:d3b7bde3995c	656	freq \|= BAND_CENTI; // 1% 14dBm
mluis	1:d3b7bde3995c	657	else
mluis	1:d3b7bde3995c	658	freq \|= BAND_MILLI; // 0.1% 14dBm
mluis	1:d3b7bde3995c	659	} else {
mluis	1:d3b7bde3995c	660	if( band > BAND_AUX ) return 0;
mluis	1:d3b7bde3995c	661	freq = (freq&~3) \| band;
mluis	1:d3b7bde3995c	662	}
mluis	1:d3b7bde3995c	663	LMIC.channelFreq [chidx] = freq;
mluis	1:d3b7bde3995c	664	LMIC.channelDrMap[chidx] = drmap==0 ? DR_RANGE_MAP(DR_SF12,DR_SF7) : drmap;
mluis	1:d3b7bde3995c	665	LMIC.channelMap \|= 1<<chidx; // enabled right away
mluis	1:d3b7bde3995c	666	return 1;
mluis	1:d3b7bde3995c	667	}
mluis	1:d3b7bde3995c	668
mluis	1:d3b7bde3995c	669	void LMIC_disableChannel (u1_t channel) {
mluis	1:d3b7bde3995c	670	LMIC.channelFreq[channel] = 0;
mluis	1:d3b7bde3995c	671	LMIC.channelDrMap[channel] = 0;
mluis	1:d3b7bde3995c	672	LMIC.channelMap &= ~(1<<channel);
mluis	1:d3b7bde3995c	673	}
mluis	1:d3b7bde3995c	674
mluis	0:62d1edcc13d1	675	static u4_t convFreq (xref2u1_t ptr) {
mluis	0:62d1edcc13d1	676	u4_t freq = (os_rlsbf4(ptr-1) >> 8) * 100;
mluis	1:d3b7bde3995c	677	if( freq < EU868_FREQ_MIN \|\| freq > EU868_FREQ_MAX )
mluis	1:d3b7bde3995c	678	freq = 0;
mluis	0:62d1edcc13d1	679	return freq;
mluis	0:62d1edcc13d1	680	}
mluis	0:62d1edcc13d1	681
mluis	0:62d1edcc13d1	682	static u1_t mapChannels (u1_t chpage, u2_t chmap) {
mluis	1:d3b7bde3995c	683	// Bad page, disable all channel, enable non-existent
mluis	1:d3b7bde3995c	684	if( chpage != 0 \|\| chmap==0 \|\| (chmap & ~LMIC.channelMap) != 0 )
mluis	1:d3b7bde3995c	685	return 0; // illegal input
mluis	0:62d1edcc13d1	686	for( u1_t chnl=0; chnl<MAX_CHANNELS; chnl++ ) {
mluis	1:d3b7bde3995c	687	if( (chmap & (1<<chnl)) != 0 && LMIC.channelFreq[chnl] == 0 )
mluis	1:d3b7bde3995c	688	chmap &= ~(1<<chnl); // ignore - channel is not defined
mluis	0:62d1edcc13d1	689	}
mluis	0:62d1edcc13d1	690	LMIC.channelMap = chmap;
mluis	0:62d1edcc13d1	691	return 1;
mluis	0:62d1edcc13d1	692	}
mluis	0:62d1edcc13d1	693
mluis	0:62d1edcc13d1	694
mluis	0:62d1edcc13d1	695	static void updateTx (ostime_t txbeg) {
mluis	0:62d1edcc13d1	696	u4_t freq = LMIC.channelFreq[LMIC.txChnl];
mluis	0:62d1edcc13d1	697	// Update global/band specific duty cycle stats
mluis	0:62d1edcc13d1	698	ostime_t airtime = calcAirTime(LMIC.rps, LMIC.dataLen);
mluis	0:62d1edcc13d1	699	// Update channel/global duty cycle stats
mluis	0:62d1edcc13d1	700	xref2band_t band = &LMIC.bands[freq & 0x3];
mluis	0:62d1edcc13d1	701	LMIC.freq = freq & ~(u4_t)3;
mluis	0:62d1edcc13d1	702	LMIC.txpow = band->txpow;
mluis	0:62d1edcc13d1	703	band->avail = txbeg + airtime * band->txcap;
mluis	0:62d1edcc13d1	704	if( LMIC.globalDutyRate != 0 )
mluis	1:d3b7bde3995c	705	LMIC.globalDutyAvail = txbeg + (airtime<<LMIC.globalDutyRate);
mluis	0:62d1edcc13d1	706	}
mluis	0:62d1edcc13d1	707
mluis	0:62d1edcc13d1	708	static ostime_t nextTx (ostime_t now) {
mluis	1:d3b7bde3995c	709	u1_t bmap=0xF;
mluis	1:d3b7bde3995c	710	do {
mluis	1:d3b7bde3995c	711	ostime_t mintime = now + /10h/36000*OSTICKS_PER_SEC;
mluis	1:d3b7bde3995c	712	u1_t band=0;
mluis	1:d3b7bde3995c	713	for( u1_t bi=0; bi<4; bi++ ) {
mluis	1:d3b7bde3995c	714	if( (bmap & (1<<bi)) && mintime - LMIC.bands[bi].avail > 0 )
mluis	1:d3b7bde3995c	715	mintime = LMIC.bands[band = bi].avail;
mluis	0:62d1edcc13d1	716	}
mluis	1:d3b7bde3995c	717	// Find next channel in given band
mluis	1:d3b7bde3995c	718	u1_t chnl = LMIC.bands[band].lastchnl;
mluis	1:d3b7bde3995c	719	for( u1_t ci=0; ci<MAX_CHANNELS; ci++ ) {
mluis	1:d3b7bde3995c	720	if( (chnl = (chnl+1)) >= MAX_CHANNELS )
mluis	1:d3b7bde3995c	721	chnl -= MAX_CHANNELS;
mluis	1:d3b7bde3995c	722	if( (LMIC.channelMap & (1<<chnl)) != 0 && // channel enabled
mluis	1:d3b7bde3995c	723	(LMIC.channelDrMap[chnl] & (1<<(LMIC.datarate&0xF))) != 0 &&
mluis	1:d3b7bde3995c	724	band == (LMIC.channelFreq[chnl] & 0x3) ) { // in selected band
mluis	1:d3b7bde3995c	725	LMIC.txChnl = LMIC.bands[band].lastchnl = chnl;
mluis	1:d3b7bde3995c	726	return mintime;
mluis	1:d3b7bde3995c	727	}
mluis	0:62d1edcc13d1	728	}
mluis	1:d3b7bde3995c	729	if( (bmap &= ~(1<<band)) == 0 ) {
mluis	1:d3b7bde3995c	730	// No feasible channel found!
mluis	1:d3b7bde3995c	731	return mintime;
mluis	1:d3b7bde3995c	732	}
mluis	0:62d1edcc13d1	733	} while(1);
mluis	0:62d1edcc13d1	734	}
mluis	0:62d1edcc13d1	735
mluis	1:d3b7bde3995c	736
mluis	0:62d1edcc13d1	737	static void setBcnRxParams (void) {
mluis	0:62d1edcc13d1	738	LMIC.dataLen = 0;
mluis	0:62d1edcc13d1	739	LMIC.freq = LMIC.channelFreq[LMIC.bcnChnl] & ~(u4_t)3;
mluis	0:62d1edcc13d1	740	LMIC.rps = setIh(setNocrc(dndr2rps((dr_t)DR_BCN),1),LEN_BCN);
mluis	0:62d1edcc13d1	741	}
mluis	0:62d1edcc13d1	742
mluis	0:62d1edcc13d1	743	#define setRx1Params() /LMIC.freq/rps remain unchanged/
mluis	0:62d1edcc13d1	744
dudmuck	2:974cafbfb159	745	static void initJoinLoop (void) { // eu868
mluis	1:d3b7bde3995c	746	LMIC.txChnl = os_getRndU1() % 6;
mluis	0:62d1edcc13d1	747	LMIC.adrTxPow = 14;
mluis	0:62d1edcc13d1	748	setDrJoin(DRCHG_SET, DR_SF7);
mluis	0:62d1edcc13d1	749	initDefaultChannels(1);
mluis	0:62d1edcc13d1	750	ASSERT((LMIC.opmode & OP_NEXTCHNL)==0);
mluis	1:d3b7bde3995c	751	LMIC.txend = LMIC.bands[BAND_MILLI].avail + rndDelay(8);
mluis	0:62d1edcc13d1	752	}
mluis	0:62d1edcc13d1	753
mluis	0:62d1edcc13d1	754	static ostime_t nextJoinState (void) {
mluis	1:d3b7bde3995c	755	u1_t failed = 0;
mluis	1:d3b7bde3995c	756
mluis	0:62d1edcc13d1	757	// Try 869.x and then 864.x with same DR
mluis	0:62d1edcc13d1	758	// If both fail try next lower datarate
mluis	1:d3b7bde3995c	759	if( ++LMIC.txChnl == 6 )
mluis	1:d3b7bde3995c	760	LMIC.txChnl = 0;
mluis	1:d3b7bde3995c	761	if( (++LMIC.txCnt & 1) == 0 ) {
mluis	1:d3b7bde3995c	762	// Lower DR every 2nd try (having tried 868.x and 864.x with the same DR)
mluis	1:d3b7bde3995c	763	if( LMIC.datarate == DR_SF12 )
mluis	1:d3b7bde3995c	764	failed = 1; // we have tried all DR - signal EV_JOIN_FAILED
mluis	1:d3b7bde3995c	765	else
mluis	1:d3b7bde3995c	766	setDrJoin(DRCHG_NOJACC, decDR((dr_t)LMIC.datarate));
mluis	1:d3b7bde3995c	767	}
mluis	1:d3b7bde3995c	768	// Clear NEXTCHNL because join state engine controls channel hopping
mluis	0:62d1edcc13d1	769	LMIC.opmode &= ~OP_NEXTCHNL;
mluis	1:d3b7bde3995c	770	// Move txend to randomize synchronized concurrent joins.
mluis	1:d3b7bde3995c	771	// Duty cycle is based on txend.
mluis	1:d3b7bde3995c	772	ostime_t time = os_getTime();
mluis	1:d3b7bde3995c	773	if( time - LMIC.bands[BAND_MILLI].avail < 0 )
mluis	1:d3b7bde3995c	774	time = LMIC.bands[BAND_MILLI].avail;
mluis	1:d3b7bde3995c	775	LMIC.txend = time +
mluis	1:d3b7bde3995c	776	(isTESTMODE()
mluis	1:d3b7bde3995c	777	// Avoid collision with JOIN ACCEPT @ SF12 being sent by GW (but we missed it)
mluis	1:d3b7bde3995c	778	? DNW2_SAFETY_ZONE
mluis	1:d3b7bde3995c	779	// Otherwise: randomize join (street lamp case):
mluis	1:d3b7bde3995c	780	// SF12:255, SF11:127, .., SF7:8secs
mluis	1:d3b7bde3995c	781	: DNW2_SAFETY_ZONE+rndDelay(255>>LMIC.datarate));
mluis	1:d3b7bde3995c	782	// 1 - triggers EV_JOIN_FAILED event
mluis	1:d3b7bde3995c	783	return failed;
mluis	0:62d1edcc13d1	784	}
mluis	0:62d1edcc13d1	785
mluis	0:62d1edcc13d1	786	//
mluis	0:62d1edcc13d1	787	// END: EU868 related stuff
mluis	0:62d1edcc13d1	788	//
mluis	0:62d1edcc13d1	789	// ================================================================================
mluis	1:d3b7bde3995c	790	#elif defined(CFG_us915)
mluis	0:62d1edcc13d1	791	// ================================================================================
mluis	0:62d1edcc13d1	792	//
mluis	0:62d1edcc13d1	793	// BEG: US915 related stuff
mluis	0:62d1edcc13d1	794	//
mluis	0:62d1edcc13d1	795
dudmuck	2:974cafbfb159	796	static void initDefaultChannels (void)
dudmuck	2:974cafbfb159	797	{
tmulrooney	6:eed5fd627a2b	798	debug("LMIC initDefaultChannels enter\r\n");
dudmuck	2:974cafbfb159	799	#ifdef CHNL_HYBRID
dudmuck	2:974cafbfb159	800	int idx = CHNL_HYBRID >> 1;
dudmuck	2:974cafbfb159	801	LMIC.channelMap[0] = 0x0000;
dudmuck	2:974cafbfb159	802	LMIC.channelMap[1] = 0x0000;
dudmuck	2:974cafbfb159	803	LMIC.channelMap[2] = 0x0000;
dudmuck	2:974cafbfb159	804	LMIC.channelMap[3] = 0x0000;
dudmuck	2:974cafbfb159	805	if (CHNL_HYBRID & 1)
dudmuck	2:974cafbfb159	806	LMIC.channelMap[idx] = 0xff00;
dudmuck	2:974cafbfb159	807	else
dudmuck	2:974cafbfb159	808	LMIC.channelMap[idx] = 0x00ff;
dudmuck	2:974cafbfb159	809
dudmuck	2:974cafbfb159	810	LMIC.channelMap[4] = 1 << CHNL_HYBRID;
dudmuck	2:974cafbfb159	811	LMIC.txpow_limit = 20;
dudmuck	2:974cafbfb159	812	#else
mluis	0:62d1edcc13d1	813	for( u1_t i=0; i<4; i++ )
mluis	1:d3b7bde3995c	814	LMIC.channelMap[i] = 0xFFFF;
mluis	0:62d1edcc13d1	815	LMIC.channelMap[4] = 0x00FF;
dudmuck	2:974cafbfb159	816
dudmuck	2:974cafbfb159	817	LMIC.txpow_limit = 30;
dudmuck	2:974cafbfb159	818	#endif
dudmuck	2:974cafbfb159	819
dudmuck	2:974cafbfb159	820	LMIC.txpow = LMIC.txpow_limit;
dudmuck	2:974cafbfb159	821	LMIC.adrTxPow = LMIC.txpow_limit;
mluis	0:62d1edcc13d1	822	}
mluis	0:62d1edcc13d1	823
tmulrooney	5:464c1f2d6cbb	824	static u4_t convFreq (xref2u1_t ptr)
tmulrooney	5:464c1f2d6cbb	825	{
tmulrooney	6:eed5fd627a2b	826	debug("LMIC convFreq enter\r\n");
mluis	0:62d1edcc13d1	827	u4_t freq = (os_rlsbf4(ptr-1) >> 8) * 100;
dudmuck	2:974cafbfb159	828	if( freq < US915_FREQ_MIN \|\| freq > US915_FREQ_MAX )
mluis	1:d3b7bde3995c	829	freq = 0;
mluis	0:62d1edcc13d1	830	return freq;
mluis	0:62d1edcc13d1	831	}
mluis	0:62d1edcc13d1	832
mluis	3:519c71d29a06	833
tmulrooney	5:464c1f2d6cbb	834	bit_t LMIC_setupChannel (u1_t chidx, u4_t freq, u2_t drmap, s1_t band)
tmulrooney	5:464c1f2d6cbb	835	{
tmulrooney	6:eed5fd627a2b	836	debug("LMIC LMIC_setupChannel enter\r\n");
tmulrooney	5:464c1f2d6cbb	837	if( chidx < 72 \|\| chidx >= 72+MAX_XCHANNELS )
mluis	1:d3b7bde3995c	838	return 0; // channels 0..71 are hardwired
mluis	0:62d1edcc13d1	839	chidx -= 72;
mluis	0:62d1edcc13d1	840	LMIC.xchFreq[chidx] = freq;
mluis	1:d3b7bde3995c	841	LMIC.xchDrMap[chidx] = drmap==0 ? DR_RANGE_MAP(DR_SF10,DR_SF8C) : drmap;
mluis	0:62d1edcc13d1	842	LMIC.channelMap[chidx>>4] \|= (1<<(chidx&0xF));
mluis	0:62d1edcc13d1	843	return 1;
mluis	0:62d1edcc13d1	844	}
mluis	0:62d1edcc13d1	845
tmulrooney	5:464c1f2d6cbb	846	void LMIC_disableChannel (u1_t channel)
tmulrooney	5:464c1f2d6cbb	847	{
tmulrooney	5:464c1f2d6cbb	848	debug("LMIC_disableChannel enter\r\n");
tmulrooney	5:464c1f2d6cbb	849	if( channel < 72+MAX_XCHANNELS )
mluis	1:d3b7bde3995c	850	LMIC.channelMap[channel/4] &= ~(1<<(channel&0xF));
mluis	1:d3b7bde3995c	851	}
mluis	0:62d1edcc13d1	852
tmulrooney	5:464c1f2d6cbb	853	static u1_t mapChannels (u1_t chpage, u2_t chmap)
tmulrooney	5:464c1f2d6cbb	854	{
tmulrooney	6:eed5fd627a2b	855	debug("LMIC mapChannels enter\r\n");
tmulrooney	5:464c1f2d6cbb	856	if( chpage == MCMD_LADR_CHP_125ON \|\| chpage == MCMD_LADR_CHP_125OFF )
tmulrooney	5:464c1f2d6cbb	857	{
mluis	1:d3b7bde3995c	858	u2_t en125 = chpage == MCMD_LADR_CHP_125ON ? 0xFFFF : 0x0000;
mluis	1:d3b7bde3995c	859	for( u1_t u=0; u<4; u++ )
mluis	1:d3b7bde3995c	860	LMIC.channelMap[u] = en125;
mluis	1:d3b7bde3995c	861	LMIC.channelMap[64/16] = chmap;
mluis	0:62d1edcc13d1	862	} else {
mluis	1:d3b7bde3995c	863	if( chpage >= (72+MAX_XCHANNELS+15)/16 )
mluis	1:d3b7bde3995c	864	return 0;
mluis	1:d3b7bde3995c	865	LMIC.channelMap[chpage] = chmap;
mluis	0:62d1edcc13d1	866	}
mluis	0:62d1edcc13d1	867	return 1;
mluis	0:62d1edcc13d1	868	}
mluis	0:62d1edcc13d1	869
tmulrooney	5:464c1f2d6cbb	870	static void updateTx (ostime_t txbeg)
tmulrooney	5:464c1f2d6cbb	871	{
tmulrooney	6:eed5fd627a2b	872	debug("LMIC updateTx enter\r\n");
tmulrooney	6:eed5fd627a2b	873	u1_t chnl = LMIC.txChnl;
dudmuck	2:974cafbfb159	874	#ifdef JOIN_REQ_DEBUG
dudmuck	2:974cafbfb159	875	printf("chnl%d ", chnl);
dudmuck	2:974cafbfb159	876	#endif /* JOIN_REQ_DEBUG */
mluis	0:62d1edcc13d1	877	if( chnl < 64 ) {
mluis	1:d3b7bde3995c	878	LMIC.freq = US915_125kHz_UPFBASE + chnl*US915_125kHz_UPFSTEP;
dudmuck	2:974cafbfb159	879
dudmuck	2:974cafbfb159	880	if (LMIC.opmode & OP_JOINING) {
dudmuck	2:974cafbfb159	881	/* use max allowed power for joining */
dudmuck	2:974cafbfb159	882	if (LMIC.txpow < LMIC.txpow_limit)
dudmuck	2:974cafbfb159	883	LMIC.txpow = LMIC.txpow_limit;
dudmuck	2:974cafbfb159	884	}
dudmuck	2:974cafbfb159	885
dudmuck	2:974cafbfb159	886	#ifdef JOIN_REQ_DEBUG
dudmuck	2:974cafbfb159	887	printf("%d (125khz)\r\n", LMIC.freq);
dudmuck	2:974cafbfb159	888	#endif /* JOIN_REQ_DEBUG */
mluis	1:d3b7bde3995c	889	return;
mluis	0:62d1edcc13d1	890	}
dudmuck	2:974cafbfb159	891
dudmuck	2:974cafbfb159	892	/* using 500KHz channel */
dudmuck	2:974cafbfb159	893	if (LMIC.txpow_limit >= 26)
dudmuck	2:974cafbfb159	894	LMIC.txpow = 26;
dudmuck	2:974cafbfb159	895	else
dudmuck	2:974cafbfb159	896	LMIC.txpow = LMIC.txpow_limit;
dudmuck	2:974cafbfb159	897
mluis	0:62d1edcc13d1	898	if( chnl < 64+8 ) {
mluis	1:d3b7bde3995c	899	LMIC.freq = US915_500kHz_UPFBASE + (chnl-64)*US915_500kHz_UPFSTEP;
dudmuck	2:974cafbfb159	900	#ifdef JOIN_REQ_DEBUG
dudmuck	2:974cafbfb159	901	printf("%d (500k)\r\n", LMIC.freq);
dudmuck	2:974cafbfb159	902	#endif /* JOIN_REQ_DEBUG */
mluis	0:62d1edcc13d1	903	} else {
mluis	1:d3b7bde3995c	904	ASSERT(chnl < 64+8+MAX_XCHANNELS);
mluis	1:d3b7bde3995c	905	LMIC.freq = LMIC.xchFreq[chnl-72];
dudmuck	2:974cafbfb159	906	#ifdef JOIN_REQ_DEBUG
dudmuck	2:974cafbfb159	907	printf("%d (x)\r\n", LMIC.freq);
dudmuck	2:974cafbfb159	908	#endif /* JOIN_REQ_DEBUG */
mluis	0:62d1edcc13d1	909	}
mluis	0:62d1edcc13d1	910
mluis	0:62d1edcc13d1	911	// Update global duty cycle stats
mluis	0:62d1edcc13d1	912	if( LMIC.globalDutyRate != 0 ) {
mluis	1:d3b7bde3995c	913	ostime_t airtime = calcAirTime(LMIC.rps, LMIC.dataLen);
mluis	1:d3b7bde3995c	914	LMIC.globalDutyAvail = txbeg + (airtime<<LMIC.globalDutyRate);
mluis	0:62d1edcc13d1	915	}
mluis	0:62d1edcc13d1	916	}
mluis	0:62d1edcc13d1	917
dudmuck	2:974cafbfb159	918	int count_bits(u2_t v)
dudmuck	2:974cafbfb159	919	{
dudmuck	2:974cafbfb159	920	int c;
dudmuck	2:974cafbfb159	921
dudmuck	2:974cafbfb159	922	for (c = 0; v; c++) {
dudmuck	2:974cafbfb159	923	v &= v - 1; // clear the last significant bit set
dudmuck	2:974cafbfb159	924	}
dudmuck	2:974cafbfb159	925
dudmuck	2:974cafbfb159	926	return c;
dudmuck	2:974cafbfb159	927	}
dudmuck	2:974cafbfb159	928
mluis	0:62d1edcc13d1	929	// US does not have duty cycling - return now as earliest TX time
mluis	0:62d1edcc13d1	930	#define nextTx(now) (_nextTx(),(now))
tmulrooney	5:464c1f2d6cbb	931	static void _nextTx (void)
tmulrooney	5:464c1f2d6cbb	932	{
tmulrooney	6:eed5fd627a2b	933	debug("LMIC _nextTx enter\r\n");
dudmuck	2:974cafbfb159	934	u1_t prev_ch = LMIC.txChnl;
dudmuck	2:974cafbfb159	935	u1_t tries = 0;
dudmuck	2:974cafbfb159	936	u1_t en_cnt;
dudmuck	2:974cafbfb159	937
mluis	1:d3b7bde3995c	938	if( LMIC.datarate >= DR_SF8C ) { // 500kHz
dudmuck	2:974cafbfb159	939	#ifdef CHNL_HYBRID
dudmuck	2:974cafbfb159	940	LMIC.txChnl = 1 << CHNL_HYBRID; // only one channel possible
dudmuck	2:974cafbfb159	941	#else
dudmuck	2:974cafbfb159	942	en_cnt = count_bits(LMIC.channelMap[4]);
dudmuck	2:974cafbfb159	943	do {
dudmuck	2:974cafbfb159	944	do {
dudmuck	2:974cafbfb159	945	LMIC.chRnd = os_getRndU1() & 7;
dudmuck	2:974cafbfb159	946	if (++tries > 48)
dudmuck	2:974cafbfb159	947	return;
dudmuck	2:974cafbfb159	948	} while ( !(LMIC.channelMap[4] & (1 << LMIC.chRnd)) );
dudmuck	2:974cafbfb159	949	LMIC.txChnl = 64 + LMIC.chRnd;
dudmuck	2:974cafbfb159	950	if (en_cnt < 2)
dudmuck	2:974cafbfb159	951	prev_ch = LMIC.txChnl + 1; // not enough enabled, skip the following test
dudmuck	2:974cafbfb159	952
dudmuck	2:974cafbfb159	953	} while (prev_ch == LMIC.txChnl);
dudmuck	2:974cafbfb159	954	#endif
mluis	1:d3b7bde3995c	955	} else { // 125kHz
dudmuck	2:974cafbfb159	956	#ifdef CHNL_HYBRID
dudmuck	2:974cafbfb159	957	u1_t idx = CHNL_HYBRID >> 1;
dudmuck	2:974cafbfb159	958	en_cnt = count_bits(LMIC.channelMap[idx]);
dudmuck	2:974cafbfb159	959	do {
dudmuck	2:974cafbfb159	960	do {
dudmuck	2:974cafbfb159	961	LMIC.chRnd = os_getRndU1() & 15;
dudmuck	2:974cafbfb159	962	if (++tries > 96)
dudmuck	2:974cafbfb159	963	return;
dudmuck	2:974cafbfb159	964	} while ( !(LMIC.channelMap[idx] & (1 << LMIC.chRnd)) );
dudmuck	2:974cafbfb159	965	LMIC.txChnl = (idx << 4) + LMIC.chRnd;
dudmuck	2:974cafbfb159	966	if (en_cnt < 2)
dudmuck	2:974cafbfb159	967	prev_ch = LMIC.txChnl + 1; // not enough enabled, skip the following test
dudmuck	2:974cafbfb159	968
dudmuck	2:974cafbfb159	969	} while (prev_ch == LMIC.txChnl);
dudmuck	2:974cafbfb159	970	#else
dudmuck	2:974cafbfb159	971	en_cnt = count_bits(LMIC.channelMap[0]);
dudmuck	2:974cafbfb159	972	en_cnt += count_bits(LMIC.channelMap[1]);
dudmuck	2:974cafbfb159	973	en_cnt += count_bits(LMIC.channelMap[2]);
dudmuck	2:974cafbfb159	974	en_cnt += count_bits(LMIC.channelMap[3]);
dudmuck	2:974cafbfb159	975	do {
dudmuck	2:974cafbfb159	976	do {
dudmuck	2:974cafbfb159	977	LMIC.chRnd = os_getRndU1() & 63;
dudmuck	2:974cafbfb159	978	} while ( !(LMIC.channelMap[LMIC.chRnd >> 4] & (1 << (LMIC.chRnd & 15))) );
dudmuck	2:974cafbfb159	979	LMIC.txChnl = LMIC.chRnd;
dudmuck	2:974cafbfb159	980	if (en_cnt < 2)
dudmuck	2:974cafbfb159	981	prev_ch = LMIC.txChnl + 1; // not enough enabled, skip the following test
dudmuck	2:974cafbfb159	982
dudmuck	2:974cafbfb159	983	} while (prev_ch == LMIC.txChnl);
dudmuck	2:974cafbfb159	984	#endif
mluis	0:62d1edcc13d1	985	}
mluis	0:62d1edcc13d1	986	}
mluis	0:62d1edcc13d1	987
mluis	0:62d1edcc13d1	988	static void setBcnRxParams (void) {
mluis	0:62d1edcc13d1	989	LMIC.dataLen = 0;
mluis	1:d3b7bde3995c	990	LMIC.freq = US915_500kHz_DNFBASE + LMIC.bcnChnl * US915_500kHz_DNFSTEP;
mluis	0:62d1edcc13d1	991	LMIC.rps = setIh(setNocrc(dndr2rps((dr_t)DR_BCN),1),LEN_BCN);
mluis	0:62d1edcc13d1	992	}
mluis	0:62d1edcc13d1	993
mluis	1:d3b7bde3995c	994	#define setRx1Params() { \
mluis	0:62d1edcc13d1	995	LMIC.freq = US915_500kHz_DNFBASE + (LMIC.txChnl & 0x7) * US915_500kHz_DNFSTEP; \
mluis	1:d3b7bde3995c	996	if( /* TX datarate */LMIC.dndr < DR_SF8C ) \
mluis	1:d3b7bde3995c	997	LMIC.dndr += DR_SF10CR - DR_SF10; \
mluis	1:d3b7bde3995c	998	else if( LMIC.dndr == DR_SF8C ) \
mluis	1:d3b7bde3995c	999	LMIC.dndr = DR_SF7CR; \
mluis	1:d3b7bde3995c	1000	LMIC.rps = dndr2rps(LMIC.dndr); \
mluis	0:62d1edcc13d1	1001	}
mluis	0:62d1edcc13d1	1002
tmulrooney	5:464c1f2d6cbb	1003	static void initJoinLoop (void)
tmulrooney	5:464c1f2d6cbb	1004	{
tmulrooney	6:eed5fd627a2b	1005	debug("LMIC initJoinLoop enter\r\n");
mluis	1:d3b7bde3995c	1006	LMIC.chRnd = 0;
dudmuck	2:974cafbfb159	1007	#ifdef CHNL_HYBRID
dudmuck	2:974cafbfb159	1008	LMIC.joinBlockChnl = 0;
dudmuck	2:974cafbfb159	1009	LMIC.joinBlock = CHNL_HYBRID;
dudmuck	2:974cafbfb159	1010	LMIC.txChnl = LMIC.joinBlock << 3;
dudmuck	2:974cafbfb159	1011	#else
mluis	1:d3b7bde3995c	1012	LMIC.txChnl = 0;
dudmuck	2:974cafbfb159	1013	LMIC.joinBlockChnl = 0;
dudmuck	2:974cafbfb159	1014	LMIC.joinBlock = 0;
dudmuck	2:974cafbfb159	1015	#endif
dudmuck	2:974cafbfb159	1016	LMIC.datarate = DR_SF10;
dudmuck	2:974cafbfb159	1017	LMIC.adrTxPow = LMIC.txpow_limit;
mluis	0:62d1edcc13d1	1018	ASSERT((LMIC.opmode & OP_NEXTCHNL)==0);
mluis	0:62d1edcc13d1	1019	LMIC.txend = os_getTime();
mluis	0:62d1edcc13d1	1020	setDrJoin(DRCHG_SET, DR_SF7);
mluis	0:62d1edcc13d1	1021	}
mluis	0:62d1edcc13d1	1022
tmulrooney	5:464c1f2d6cbb	1023	static ostime_t nextJoinState (void)
tmulrooney	5:464c1f2d6cbb	1024	{
tmulrooney	6:eed5fd627a2b	1025	debug("LMIC nextJoinState enter\r\n");
tmulrooney	5:464c1f2d6cbb	1026	u1_t failed = 0;
dudmuck	2:974cafbfb159	1027
dudmuck	2:974cafbfb159	1028	if( LMIC.datarate == DR_SF8C ) {
dudmuck	2:974cafbfb159	1029	// attempted 500khz channel, try 125khz channel in next block
dudmuck	2:974cafbfb159	1030	LMIC.datarate = DR_SF10;
dudmuck	2:974cafbfb159	1031	if (++LMIC.joinBlock == 8) {
dudmuck	2:974cafbfb159	1032	LMIC.joinBlock = 0;
dudmuck	2:974cafbfb159	1033	if (++LMIC.joinBlockChnl == 8)
dudmuck	2:974cafbfb159	1034	LMIC.joinBlockChnl = 0;
dudmuck	2:974cafbfb159	1035	}
dudmuck	2:974cafbfb159	1036	LMIC.txChnl = (LMIC.joinBlock << 3) + LMIC.joinBlockChnl;
mluis	0:62d1edcc13d1	1037	} else {
dudmuck	2:974cafbfb159	1038	// attempted 125khz channel, try 500khz channel
dudmuck	2:974cafbfb159	1039	LMIC.datarate = DR_SF8C;
dudmuck	2:974cafbfb159	1040	LMIC.txChnl = LMIC.joinBlock + 64;
mluis	0:62d1edcc13d1	1041	}
dudmuck	2:974cafbfb159	1042	#ifdef JOIN_REQ_DEBUG
dudmuck	2:974cafbfb159	1043	printf("njs blk%d, dr%d, txChnl%d ", LMIC.joinBlock, LMIC.datarate, LMIC.txChnl); // crlf in updateTx()
dudmuck	2:974cafbfb159	1044	#endif /* JOIN_REQ_DEBUG */
dudmuck	2:974cafbfb159	1045
mluis	1:d3b7bde3995c	1046	LMIC.opmode &= ~OP_NEXTCHNL;
mluis	1:d3b7bde3995c	1047	LMIC.txend = os_getTime() +
mluis	1:d3b7bde3995c	1048	(isTESTMODE()
mluis	1:d3b7bde3995c	1049	// Avoid collision with JOIN ACCEPT being sent by GW (but we missed it - GW is still busy)
mluis	1:d3b7bde3995c	1050	? DNW2_SAFETY_ZONE
mluis	1:d3b7bde3995c	1051	// Otherwise: randomize join (street lamp case):
mluis	1:d3b7bde3995c	1052	// SF10:16, SF9=8,..SF8C:1secs
mluis	1:d3b7bde3995c	1053	: rndDelay(16>>LMIC.datarate));
mluis	1:d3b7bde3995c	1054	// 1 - triggers EV_JOIN_FAILED event
mluis	1:d3b7bde3995c	1055	return failed;
mluis	0:62d1edcc13d1	1056	}
mluis	0:62d1edcc13d1	1057
mluis	0:62d1edcc13d1	1058	//
mluis	0:62d1edcc13d1	1059	// END: US915 related stuff
mluis	0:62d1edcc13d1	1060	//
mluis	0:62d1edcc13d1	1061	// ================================================================================
mluis	0:62d1edcc13d1	1062	#else
mluis	0:62d1edcc13d1	1063	#error Unsupported frequency band!
mluis	0:62d1edcc13d1	1064	#endif
mluis	0:62d1edcc13d1	1065
mluis	0:62d1edcc13d1	1066
tmulrooney	5:464c1f2d6cbb	1067	static void runEngineUpdate (xref2osjob_t osjob)
tmulrooney	5:464c1f2d6cbb	1068	{
tmulrooney	6:eed5fd627a2b	1069	debug("LMIC runEngineUpdate enter\r\n");
mluis	0:62d1edcc13d1	1070	engineUpdate();
mluis	0:62d1edcc13d1	1071	}
mluis	0:62d1edcc13d1	1072
mluis	0:62d1edcc13d1	1073
tmulrooney	5:464c1f2d6cbb	1074	static void reportEvent (ev_t ev)
tmulrooney	5:464c1f2d6cbb	1075	{
tmulrooney	6:eed5fd627a2b	1076	debug("LMIC reportEvent enter %d\r\n",ev);
mluis	0:62d1edcc13d1	1077	EV(devCond, INFO, (e_.reason = EV::devCond_t::LMIC_EV,
mluis	1:d3b7bde3995c	1078	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1079	e_.info = ev));
mluis	0:62d1edcc13d1	1080	ON_LMIC_EVENT(ev);
mluis	0:62d1edcc13d1	1081	engineUpdate();
mluis	0:62d1edcc13d1	1082	}
mluis	0:62d1edcc13d1	1083
mluis	0:62d1edcc13d1	1084
tmulrooney	6:eed5fd627a2b	1085	static void runReset (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1086	{
tmulrooney	6:eed5fd627a2b	1087	debug("LMIC runReset enterr\n");
mluis	1:d3b7bde3995c	1088	// Disable session
mluis	1:d3b7bde3995c	1089	LMIC_reset();
mluis	1:d3b7bde3995c	1090	LMIC_startJoining();
mluis	1:d3b7bde3995c	1091	reportEvent(EV_RESET);
mluis	1:d3b7bde3995c	1092	}
mluis	1:d3b7bde3995c	1093
tmulrooney	6:eed5fd627a2b	1094	static void stateJustJoined (void)
tmulrooney	6:eed5fd627a2b	1095	{
tmulrooney	6:eed5fd627a2b	1096	debug("LMIC stateJustJoined enter\r\n");
mluis	0:62d1edcc13d1	1097	LMIC.seqnoDn = LMIC.seqnoUp = 0;
mluis	0:62d1edcc13d1	1098	LMIC.rejoinCnt = 0;
mluis	0:62d1edcc13d1	1099	LMIC.dnConf = LMIC.adrChanged = LMIC.ladrAns = LMIC.devsAns = 0;
mluis	0:62d1edcc13d1	1100	LMIC.moreData = LMIC.dn2Ans = LMIC.snchAns = LMIC.dutyCapAns = 0;
mluis	0:62d1edcc13d1	1101	LMIC.pingSetAns = 0;
mluis	0:62d1edcc13d1	1102	LMIC.upRepeat = 0;
mluis	0:62d1edcc13d1	1103	LMIC.adrAckReq = LINK_CHECK_INIT;
mluis	0:62d1edcc13d1	1104	LMIC.dn2Dr = DR_DNW2;
mluis	0:62d1edcc13d1	1105	LMIC.dn2Freq = FREQ_DNW2;
mluis	0:62d1edcc13d1	1106	LMIC.bcnChnl = CHNL_BCN;
mluis	0:62d1edcc13d1	1107	LMIC.ping.freq = FREQ_PING;
mluis	0:62d1edcc13d1	1108	LMIC.ping.dr = DR_PING;
mluis	0:62d1edcc13d1	1109	}
mluis	0:62d1edcc13d1	1110
mluis	0:62d1edcc13d1	1111
mluis	0:62d1edcc13d1	1112	// ================================================================================
mluis	0:62d1edcc13d1	1113	// Decoding frames
mluis	0:62d1edcc13d1	1114
mluis	0:62d1edcc13d1	1115
mluis	0:62d1edcc13d1	1116	// Decode beacon - do not overwrite bcninfo unless we have a match!
tmulrooney	6:eed5fd627a2b	1117	static int decodeBeacon (void)
tmulrooney	6:eed5fd627a2b	1118	{
tmulrooney	6:eed5fd627a2b	1119	debug("LMIC decodeBeacon enter\r\n");
mluis	0:62d1edcc13d1	1120	ASSERT(LMIC.dataLen == LEN_BCN); // implicit header RX guarantees this
mluis	0:62d1edcc13d1	1121	xref2u1_t d = LMIC.frame;
mluis	1:d3b7bde3995c	1122	if(
dudmuck	2:974cafbfb159	1123	#ifdef CFG_eu868
mluis	1:d3b7bde3995c	1124	d[OFF_BCN_CRC1] != (u1_t)os_crc16(d,OFF_BCN_CRC1)
dudmuck	2:974cafbfb159	1125	#elif defined(CFG_us915)
mluis	1:d3b7bde3995c	1126	os_rlsbf2(&d[OFF_BCN_CRC1]) != os_crc16(d,OFF_BCN_CRC1)
mluis	1:d3b7bde3995c	1127	#endif
mluis	1:d3b7bde3995c	1128	)
mluis	1:d3b7bde3995c	1129	return 0; // first (common) part fails CRC check
mluis	0:62d1edcc13d1	1130	// First set of fields is ok
mluis	0:62d1edcc13d1	1131	u4_t bcnnetid = os_rlsbf4(&d[OFF_BCN_NETID]) & 0xFFFFFF;
mluis	0:62d1edcc13d1	1132	if( bcnnetid != LMIC.netid )
mluis	1:d3b7bde3995c	1133	return -1; // not the beacon we're looking for
mluis	0:62d1edcc13d1	1134
mluis	0:62d1edcc13d1	1135	LMIC.bcninfo.flags &= ~(BCN_PARTIAL\|BCN_FULL);
mluis	0:62d1edcc13d1	1136	// Match - update bcninfo structure
mluis	1:d3b7bde3995c	1137	LMIC.bcninfo.snr = LMIC.snr;
mluis	1:d3b7bde3995c	1138	LMIC.bcninfo.rssi = LMIC.rssi;
mluis	0:62d1edcc13d1	1139	LMIC.bcninfo.txtime = LMIC.rxtime - AIRTIME_BCN_osticks;
mluis	0:62d1edcc13d1	1140	LMIC.bcninfo.time = os_rlsbf4(&d[OFF_BCN_TIME]);
mluis	0:62d1edcc13d1	1141	LMIC.bcninfo.flags \|= BCN_PARTIAL;
mluis	0:62d1edcc13d1	1142
mluis	0:62d1edcc13d1	1143	// Check 2nd set
mluis	0:62d1edcc13d1	1144	if( os_rlsbf2(&d[OFF_BCN_CRC2]) != os_crc16(d,OFF_BCN_CRC2) )
mluis	1:d3b7bde3995c	1145	return 1;
mluis	0:62d1edcc13d1	1146	// Second set of fields is ok
mluis	0:62d1edcc13d1	1147	LMIC.bcninfo.lat = (s4_t)os_rlsbf4(&d[OFF_BCN_LAT-1]) >> 8; // read as signed 24-bit
mluis	0:62d1edcc13d1	1148	LMIC.bcninfo.lon = (s4_t)os_rlsbf4(&d[OFF_BCN_LON-1]) >> 8; // ditto
mluis	0:62d1edcc13d1	1149	LMIC.bcninfo.info = d[OFF_BCN_INFO];
mluis	0:62d1edcc13d1	1150	LMIC.bcninfo.flags \|= BCN_FULL;
mluis	0:62d1edcc13d1	1151	return 2;
mluis	0:62d1edcc13d1	1152	}
mluis	0:62d1edcc13d1	1153
mluis	0:62d1edcc13d1	1154
tmulrooney	6:eed5fd627a2b	1155	static bit_t decodeFrame (void)
tmulrooney	6:eed5fd627a2b	1156	{
tmulrooney	6:eed5fd627a2b	1157	debug("LMIC decodeFrame enter\r\n");
mluis	0:62d1edcc13d1	1158	xref2u1_t d = LMIC.frame;
mluis	0:62d1edcc13d1	1159	u1_t hdr = d[0];
mluis	0:62d1edcc13d1	1160	u1_t ftype = hdr & HDR_FTYPE;
mluis	0:62d1edcc13d1	1161	int dlen = LMIC.dataLen;
mluis	0:62d1edcc13d1	1162	if( dlen < OFF_DAT_OPTS+4 \|\|
mluis	1:d3b7bde3995c	1163	(hdr & HDR_MAJOR) != HDR_MAJOR_V1 \|\|
mluis	1:d3b7bde3995c	1164	(ftype != HDR_FTYPE_DADN && ftype != HDR_FTYPE_DCDN) ) {
mluis	1:d3b7bde3995c	1165	// Basic sanity checks failed
mluis	1:d3b7bde3995c	1166	EV(specCond, WARN, (e_.reason = EV::specCond_t::UNEXPECTED_FRAME,
mluis	1:d3b7bde3995c	1167	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1168	e_.info = dlen < 4 ? 0 : os_rlsbf4(&d[dlen-4]),
mluis	1:d3b7bde3995c	1169	e_.info2 = hdr + (dlen<<8)));
mluis	0:62d1edcc13d1	1170	norx:
mluis	1:d3b7bde3995c	1171	LMIC.dataLen = 0;
mluis	1:d3b7bde3995c	1172	return 0;
mluis	0:62d1edcc13d1	1173	}
mluis	0:62d1edcc13d1	1174	// Validate exact frame length
mluis	0:62d1edcc13d1	1175	// Note: device address was already read+evaluated in order to arrive here.
mluis	0:62d1edcc13d1	1176	int fct = d[OFF_DAT_FCT];
mluis	0:62d1edcc13d1	1177	u4_t addr = os_rlsbf4(&d[OFF_DAT_ADDR]);
mluis	0:62d1edcc13d1	1178	u4_t seqno = os_rlsbf2(&d[OFF_DAT_SEQNO]);
mluis	0:62d1edcc13d1	1179	int olen = fct & FCT_OPTLEN;
mluis	0:62d1edcc13d1	1180	int ackup = (fct & FCT_ACK) != 0 ? 1 : 0; // ACK last up frame
mluis	0:62d1edcc13d1	1181	int poff = OFF_DAT_OPTS+olen;
mluis	0:62d1edcc13d1	1182	int pend = dlen-4; // MIC
mluis	0:62d1edcc13d1	1183
mluis	0:62d1edcc13d1	1184	if( addr != LMIC.devaddr ) {
mluis	1:d3b7bde3995c	1185	EV(specCond, WARN, (e_.reason = EV::specCond_t::ALIEN_ADDRESS,
mluis	1:d3b7bde3995c	1186	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1187	e_.info = addr,
mluis	1:d3b7bde3995c	1188	e_.info2 = LMIC.devaddr));
mluis	1:d3b7bde3995c	1189	goto norx;
mluis	0:62d1edcc13d1	1190	}
mluis	0:62d1edcc13d1	1191	if( poff > pend ) {
mluis	1:d3b7bde3995c	1192	EV(specCond, ERR, (e_.reason = EV::specCond_t::CORRUPTED_FRAME,
mluis	1:d3b7bde3995c	1193	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1194	e_.info = 0x1000000 + (poff-pend) + (fct<<8) + (dlen<<16)));
mluis	1:d3b7bde3995c	1195	goto norx;
mluis	0:62d1edcc13d1	1196	}
mluis	0:62d1edcc13d1	1197
mluis	0:62d1edcc13d1	1198	int port = -1;
mluis	0:62d1edcc13d1	1199	int replayConf = 0;
mluis	0:62d1edcc13d1	1200
mluis	0:62d1edcc13d1	1201	if( pend > poff )
mluis	1:d3b7bde3995c	1202	port = d[poff++];
mluis	0:62d1edcc13d1	1203
mluis	0:62d1edcc13d1	1204	seqno = LMIC.seqnoDn + (u2_t)(seqno - LMIC.seqnoDn);
mluis	0:62d1edcc13d1	1205
mluis	0:62d1edcc13d1	1206	if( !aes_verifyMic(LMIC.nwkKey, LMIC.devaddr, seqno, /dn/1, d, pend) ) {
mluis	1:d3b7bde3995c	1207	EV(spe3Cond, ERR, (e_.reason = EV::spe3Cond_t::CORRUPTED_MIC,
mluis	1:d3b7bde3995c	1208	e_.eui1 = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1209	e_.info1 = Base::lsbf4(&d[pend]),
mluis	1:d3b7bde3995c	1210	e_.info2 = seqno,
mluis	1:d3b7bde3995c	1211	e_.info3 = LMIC.devaddr));
mluis	0:62d1edcc13d1	1212	goto norx;
mluis	0:62d1edcc13d1	1213	}
mluis	1:d3b7bde3995c	1214	if( seqno < LMIC.seqnoDn ) {
mluis	1:d3b7bde3995c	1215	if( (s4_t)seqno > (s4_t)LMIC.seqnoDn ) {
mluis	1:d3b7bde3995c	1216	EV(specCond, INFO, (e_.reason = EV::specCond_t::DNSEQNO_ROLL_OVER,
mluis	1:d3b7bde3995c	1217	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1218	e_.info = LMIC.seqnoDn,
mluis	1:d3b7bde3995c	1219	e_.info2 = seqno));
mluis	1:d3b7bde3995c	1220	goto norx;
mluis	1:d3b7bde3995c	1221	}
mluis	1:d3b7bde3995c	1222	if( seqno != LMIC.seqnoDn-1 \|\| !LMIC.dnConf \|\| ftype != HDR_FTYPE_DCDN ) {
mluis	1:d3b7bde3995c	1223	EV(specCond, INFO, (e_.reason = EV::specCond_t::DNSEQNO_OBSOLETE,
mluis	1:d3b7bde3995c	1224	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1225	e_.info = LMIC.seqnoDn,
mluis	1:d3b7bde3995c	1226	e_.info2 = seqno));
mluis	1:d3b7bde3995c	1227	goto norx;
mluis	1:d3b7bde3995c	1228	}
mluis	1:d3b7bde3995c	1229	// Replay of previous sequence number allowed only if
mluis	1:d3b7bde3995c	1230	// previous frame and repeated both requested confirmation
mluis	1:d3b7bde3995c	1231	replayConf = 1;
mluis	0:62d1edcc13d1	1232	}
mluis	0:62d1edcc13d1	1233	else {
mluis	1:d3b7bde3995c	1234	if( seqno > LMIC.seqnoDn ) {
mluis	1:d3b7bde3995c	1235	EV(specCond, INFO, (e_.reason = EV::specCond_t::DNSEQNO_SKIP,
mluis	1:d3b7bde3995c	1236	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1237	e_.info = LMIC.seqnoDn,
mluis	1:d3b7bde3995c	1238	e_.info2 = seqno));
mluis	1:d3b7bde3995c	1239	}
mluis	1:d3b7bde3995c	1240	LMIC.seqnoDn = seqno+1; // next number to be expected
mluis	1:d3b7bde3995c	1241	DO_DEVDB(LMIC.seqnoDn,seqnoDn);
mluis	1:d3b7bde3995c	1242	// DN frame requested confirmation - provide ACK once with next UP frame
mluis	1:d3b7bde3995c	1243	LMIC.dnConf = (ftype == HDR_FTYPE_DCDN ? FCT_ACK : 0);
mluis	0:62d1edcc13d1	1244	}
mluis	0:62d1edcc13d1	1245
mluis	0:62d1edcc13d1	1246	if( LMIC.dnConf \|\| (fct & FCT_MORE) )
mluis	1:d3b7bde3995c	1247	LMIC.opmode \|= OP_POLL;
mluis	0:62d1edcc13d1	1248
mluis	0:62d1edcc13d1	1249	// We heard from network
mluis	1:d3b7bde3995c	1250	LMIC.adrChanged = LMIC.rejoinCnt = 0;
mluis	1:d3b7bde3995c	1251	if( LMIC.adrAckReq != LINK_CHECK_OFF )
mluis	1:d3b7bde3995c	1252	LMIC.adrAckReq = LINK_CHECK_INIT;
mluis	0:62d1edcc13d1	1253
mluis	0:62d1edcc13d1	1254	// Process OPTS
mluis	1:d3b7bde3995c	1255	int m = LMIC.rssi - RSSI_OFF - getSensitivity(LMIC.rps);
mluis	0:62d1edcc13d1	1256	LMIC.margin = m < 0 ? 0 : m > 254 ? 254 : m;
mluis	0:62d1edcc13d1	1257
mluis	0:62d1edcc13d1	1258	xref2u1_t opts = &d[OFF_DAT_OPTS];
mluis	0:62d1edcc13d1	1259	int oidx = 0;
mluis	0:62d1edcc13d1	1260	while( oidx < olen ) {
mluis	1:d3b7bde3995c	1261	switch( opts[oidx] ) {
mluis	1:d3b7bde3995c	1262	case MCMD_LCHK_ANS: {
mluis	1:d3b7bde3995c	1263	//int gwmargin = opts[oidx+1];
mluis	1:d3b7bde3995c	1264	//int ngws = opts[oidx+2];
mluis	1:d3b7bde3995c	1265	oidx += 3;
mluis	1:d3b7bde3995c	1266	continue;
mluis	1:d3b7bde3995c	1267	}
mluis	1:d3b7bde3995c	1268	case MCMD_LADR_REQ: {
mluis	1:d3b7bde3995c	1269	u1_t p1 = opts[oidx+1]; // txpow + DR
mluis	1:d3b7bde3995c	1270	u2_t chmap = os_rlsbf2(&opts[oidx+2]);// list of enabled channels
mluis	1:d3b7bde3995c	1271	u1_t chpage = opts[oidx+4] & MCMD_LADR_CHPAGE_MASK; // channel page
mluis	1:d3b7bde3995c	1272	u1_t uprpt = opts[oidx+4] & MCMD_LADR_REPEAT_MASK; // up repeat count
mluis	1:d3b7bde3995c	1273	oidx += 5;
mluis	0:62d1edcc13d1	1274
mluis	1:d3b7bde3995c	1275	LMIC.ladrAns = 0x80 \| // Include an answer into next frame up
mluis	1:d3b7bde3995c	1276	MCMD_LADR_ANS_POWACK \| MCMD_LADR_ANS_CHACK \| MCMD_LADR_ANS_DRACK;
mluis	1:d3b7bde3995c	1277	if( !mapChannels(chpage, chmap) )
mluis	1:d3b7bde3995c	1278	LMIC.ladrAns &= ~MCMD_LADR_ANS_CHACK;
mluis	1:d3b7bde3995c	1279	dr_t dr = (dr_t)(p1>>MCMD_LADR_DR_SHIFT);
mluis	1:d3b7bde3995c	1280	if( !validDR(dr) ) {
mluis	1:d3b7bde3995c	1281	LMIC.ladrAns &= ~MCMD_LADR_ANS_DRACK;
mluis	1:d3b7bde3995c	1282	EV(specCond, ERR, (e_.reason = EV::specCond_t::BAD_MAC_CMD,
mluis	1:d3b7bde3995c	1283	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1284	e_.info = Base::lsbf4(&d[pend]),
mluis	1:d3b7bde3995c	1285	e_.info2 = Base::msbf4(&opts[oidx-4])));
mluis	1:d3b7bde3995c	1286	}
mluis	1:d3b7bde3995c	1287	if( (LMIC.ladrAns & 0x7F) == (MCMD_LADR_ANS_POWACK \| MCMD_LADR_ANS_CHACK \| MCMD_LADR_ANS_DRACK) ) {
mluis	1:d3b7bde3995c	1288	// Nothing went wrong - use settings
mluis	1:d3b7bde3995c	1289	LMIC.upRepeat = uprpt;
mluis	1:d3b7bde3995c	1290	setDrTxpow(DRCHG_NWKCMD, dr, pow2dBm(p1));
mluis	1:d3b7bde3995c	1291	}
mluis	1:d3b7bde3995c	1292	LMIC.adrChanged = 1; // Trigger an ACK to NWK
mluis	1:d3b7bde3995c	1293	continue;
mluis	0:62d1edcc13d1	1294	}
mluis	1:d3b7bde3995c	1295	case MCMD_DEVS_REQ: {
mluis	1:d3b7bde3995c	1296	LMIC.devsAns = 1;
mluis	1:d3b7bde3995c	1297	oidx += 1;
mluis	1:d3b7bde3995c	1298	continue;
mluis	1:d3b7bde3995c	1299	}
mluis	1:d3b7bde3995c	1300	case MCMD_DN2P_SET: {
mluis	1:d3b7bde3995c	1301	dr_t dr = (dr_t)(opts[oidx+1] & 0x0F);
mluis	1:d3b7bde3995c	1302	u4_t freq = convFreq(&opts[oidx+2]);
mluis	1:d3b7bde3995c	1303	oidx += 5;
mluis	1:d3b7bde3995c	1304	LMIC.dn2Ans = 0x80; // answer pending
mluis	1:d3b7bde3995c	1305	if( validDR(dr) )
mluis	1:d3b7bde3995c	1306	LMIC.dn2Ans \|= MCMD_DN2P_ANS_DRACK;
mluis	1:d3b7bde3995c	1307	if( freq != 0 )
mluis	1:d3b7bde3995c	1308	LMIC.dn2Ans \|= MCMD_DN2P_ANS_CHACK;
mluis	1:d3b7bde3995c	1309	if( LMIC.dn2Ans == (0x80\|MCMD_DN2P_ANS_DRACK\|MCMD_DN2P_ANS_CHACK) ) {
mluis	1:d3b7bde3995c	1310	LMIC.dn2Dr = dr;
mluis	1:d3b7bde3995c	1311	LMIC.dn2Freq = freq;
mluis	1:d3b7bde3995c	1312	DO_DEVDB(LMIC.dn2Dr,dn2Dr);
mluis	1:d3b7bde3995c	1313	DO_DEVDB(LMIC.dn2Freq,dn2Freq);
mluis	1:d3b7bde3995c	1314	}
mluis	1:d3b7bde3995c	1315	continue;
mluis	0:62d1edcc13d1	1316	}
mluis	1:d3b7bde3995c	1317	case MCMD_DCAP_REQ: {
mluis	1:d3b7bde3995c	1318	u1_t cap = opts[oidx+1];
mluis	1:d3b7bde3995c	1319	oidx += 2;
mluis	1:d3b7bde3995c	1320	// A value cap=0xFF means device is OFF unless enabled again manually.
mluis	1:d3b7bde3995c	1321	if( cap==0xFF )
mluis	1:d3b7bde3995c	1322	LMIC.opmode \|= OP_SHUTDOWN; // stop any sending
mluis	1:d3b7bde3995c	1323	LMIC.globalDutyRate = cap & 0xF;
mluis	1:d3b7bde3995c	1324	LMIC.globalDutyAvail = os_getTime();
mluis	1:d3b7bde3995c	1325	DO_DEVDB(cap,dutyCap);
mluis	1:d3b7bde3995c	1326	LMIC.dutyCapAns = 1;
mluis	1:d3b7bde3995c	1327	continue;
mluis	1:d3b7bde3995c	1328	}
mluis	1:d3b7bde3995c	1329	case MCMD_SNCH_REQ: {
mluis	1:d3b7bde3995c	1330	u1_t chidx = opts[oidx+1]; // channel
mluis	1:d3b7bde3995c	1331	u4_t freq = convFreq(&opts[oidx+2]); // freq
mluis	1:d3b7bde3995c	1332	u1_t drs = opts[oidx+5]; // datarate span
mluis	1:d3b7bde3995c	1333	LMIC.snchAns = 0x80;
mluis	1:d3b7bde3995c	1334	if( freq != 0 && LMIC_setupChannel(chidx, freq, DR_RANGE_MAP(drs&0xF,drs>>4), -1) )
mluis	1:d3b7bde3995c	1335	LMIC.snchAns \|= MCMD_SNCH_ANS_DRACK\|MCMD_SNCH_ANS_FQACK;
mluis	1:d3b7bde3995c	1336	oidx += 6;
mluis	1:d3b7bde3995c	1337	continue;
mluis	0:62d1edcc13d1	1338	}
mluis	1:d3b7bde3995c	1339	case MCMD_PING_SET: {
mluis	1:d3b7bde3995c	1340	u4_t freq = convFreq(&opts[oidx+1]);
mluis	1:d3b7bde3995c	1341	oidx += 4;
mluis	1:d3b7bde3995c	1342	u1_t flags = 0x80;
mluis	1:d3b7bde3995c	1343	if( freq != 0 ) {
mluis	1:d3b7bde3995c	1344	flags \|= MCMD_PING_ANS_FQACK;
mluis	1:d3b7bde3995c	1345	LMIC.ping.freq = freq;
mluis	1:d3b7bde3995c	1346	DO_DEVDB(LMIC.ping.intvExp, pingIntvExp);
mluis	1:d3b7bde3995c	1347	DO_DEVDB(LMIC.ping.freq, pingFreq);
mluis	1:d3b7bde3995c	1348	DO_DEVDB(LMIC.ping.dr, pingDr);
mluis	1:d3b7bde3995c	1349	}
mluis	1:d3b7bde3995c	1350	LMIC.pingSetAns = flags;
mluis	1:d3b7bde3995c	1351	continue;
mluis	1:d3b7bde3995c	1352	}
mluis	1:d3b7bde3995c	1353	case MCMD_BCNI_ANS: {
mluis	1:d3b7bde3995c	1354	// Ignore if tracking already enabled
mluis	1:d3b7bde3995c	1355	if( (LMIC.opmode & OP_TRACK) == 0 ) {
mluis	1:d3b7bde3995c	1356	LMIC.bcnChnl = opts[oidx+3];
mluis	1:d3b7bde3995c	1357	// Enable tracking - bcninfoTries
mluis	1:d3b7bde3995c	1358	LMIC.opmode \|= OP_TRACK;
mluis	1:d3b7bde3995c	1359	// Cleared later in txComplete handling - triggers EV_BEACON_FOUND
mluis	1:d3b7bde3995c	1360	ASSERT(LMIC.bcninfoTries!=0);
mluis	1:d3b7bde3995c	1361	// Setup RX parameters
mluis	1:d3b7bde3995c	1362	LMIC.bcninfo.txtime = (LMIC.rxtime
mluis	1:d3b7bde3995c	1363	+ ms2osticks(os_rlsbf2(&opts[oidx+1]) * MCMD_BCNI_TUNIT)
mluis	1:d3b7bde3995c	1364	+ ms2osticksCeil(MCMD_BCNI_TUNIT/2)
mluis	1:d3b7bde3995c	1365	- BCN_INTV_osticks);
mluis	1:d3b7bde3995c	1366	LMIC.bcninfo.flags = 0; // txtime above cannot be used as reference (BCN_PARTIAL\|BCN_FULL cleared)
mluis	1:d3b7bde3995c	1367	calcBcnRxWindowFromMillis(MCMD_BCNI_TUNIT,1); // error of +/-N ms
mluis	0:62d1edcc13d1	1368
mluis	1:d3b7bde3995c	1369	EV(lostFrame, INFO, (e_.reason = EV::lostFrame_t::MCMD_BCNI_ANS,
mluis	1:d3b7bde3995c	1370	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1371	e_.lostmic = Base::lsbf4(&d[pend]),
mluis	1:d3b7bde3995c	1372	e_.info = (LMIC.missedBcns \|
mluis	1:d3b7bde3995c	1373	(osticks2us(LMIC.bcninfo.txtime + BCN_INTV_osticks
mluis	1:d3b7bde3995c	1374	- LMIC.bcnRxtime) << 8)),
mluis	1:d3b7bde3995c	1375	e_.time = MAIN::CDEV->ostime2ustime(LMIC.bcninfo.txtime + BCN_INTV_osticks)));
mluis	1:d3b7bde3995c	1376	}
mluis	1:d3b7bde3995c	1377	oidx += 4;
mluis	1:d3b7bde3995c	1378	continue;
mluis	0:62d1edcc13d1	1379	}
mluis	1:d3b7bde3995c	1380	}
mluis	1:d3b7bde3995c	1381	EV(specCond, ERR, (e_.reason = EV::specCond_t::BAD_MAC_CMD,
mluis	1:d3b7bde3995c	1382	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1383	e_.info = Base::lsbf4(&d[pend]),
mluis	1:d3b7bde3995c	1384	e_.info2 = Base::msbf4(&opts[oidx])));
mluis	1:d3b7bde3995c	1385	break;
mluis	0:62d1edcc13d1	1386	}
mluis	0:62d1edcc13d1	1387	if( oidx != olen ) {
mluis	1:d3b7bde3995c	1388	EV(specCond, ERR, (e_.reason = EV::specCond_t::CORRUPTED_FRAME,
mluis	1:d3b7bde3995c	1389	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1390	e_.info = 0x1000000 + (oidx) + (olen<<8)));
mluis	0:62d1edcc13d1	1391	}
mluis	0:62d1edcc13d1	1392
mluis	0:62d1edcc13d1	1393	if( !replayConf ) {
mluis	1:d3b7bde3995c	1394	// Handle payload only if not a replay
mluis	1:d3b7bde3995c	1395	// Decrypt payload - if any
mluis	1:d3b7bde3995c	1396	if( port >= 0 && pend-poff > 0 )
mluis	1:d3b7bde3995c	1397	aes_cipher(port <= 0 ? LMIC.nwkKey : LMIC.artKey, LMIC.devaddr, seqno, /dn/1, d+poff, pend-poff);
mluis	0:62d1edcc13d1	1398
mluis	1:d3b7bde3995c	1399	EV(dfinfo, DEBUG, (e_.deveui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1400	e_.devaddr = LMIC.devaddr,
mluis	1:d3b7bde3995c	1401	e_.seqno = seqno,
mluis	1:d3b7bde3995c	1402	e_.flags = (port < 0 ? EV::dfinfo_t::NOPORT : 0) \| EV::dfinfo_t::DN,
mluis	1:d3b7bde3995c	1403	e_.mic = Base::lsbf4(&d[pend]),
mluis	1:d3b7bde3995c	1404	e_.hdr = d[LORA::OFF_DAT_HDR],
mluis	1:d3b7bde3995c	1405	e_.fct = d[LORA::OFF_DAT_FCT],
mluis	1:d3b7bde3995c	1406	e_.port = port,
mluis	1:d3b7bde3995c	1407	e_.plen = dlen,
mluis	1:d3b7bde3995c	1408	e_.opts.length = olen,
mluis	1:d3b7bde3995c	1409	memcpy(&e_.opts[0], opts, olen)));
mluis	0:62d1edcc13d1	1410	} else {
mluis	1:d3b7bde3995c	1411	EV(specCond, INFO, (e_.reason = EV::specCond_t::DNSEQNO_REPLAY,
mluis	1:d3b7bde3995c	1412	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1413	e_.info = Base::lsbf4(&d[pend]),
mluis	1:d3b7bde3995c	1414	e_.info2 = seqno));
mluis	0:62d1edcc13d1	1415	}
mluis	0:62d1edcc13d1	1416
mluis	0:62d1edcc13d1	1417	if( // NWK acks but we don't have a frame pending
mluis	1:d3b7bde3995c	1418	(ackup && LMIC.txCnt == 0) \|\|
mluis	1:d3b7bde3995c	1419	// We sent up confirmed and we got a response in DNW1/DNW2
mluis	1:d3b7bde3995c	1420	// BUT it did not carry an ACK - this should never happen
mluis	1:d3b7bde3995c	1421	// Do not resend and assume frame was not ACKed.
mluis	1:d3b7bde3995c	1422	(!ackup && LMIC.txCnt != 0) ) {
mluis	1:d3b7bde3995c	1423	EV(specCond, ERR, (e_.reason = EV::specCond_t::SPURIOUS_ACK,
mluis	1:d3b7bde3995c	1424	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1425	e_.info = seqno,
mluis	1:d3b7bde3995c	1426	e_.info2 = ackup));
mluis	0:62d1edcc13d1	1427	}
mluis	0:62d1edcc13d1	1428
mluis	0:62d1edcc13d1	1429	if( LMIC.txCnt != 0 ) // we requested an ACK
mluis	1:d3b7bde3995c	1430	LMIC.txrxFlags \|= ackup ? TXRX_ACK : TXRX_NACK;
mluis	0:62d1edcc13d1	1431
mluis	0:62d1edcc13d1	1432	if( port < 0 ) {
mluis	1:d3b7bde3995c	1433	LMIC.txrxFlags \|= TXRX_NOPORT;
mluis	1:d3b7bde3995c	1434	LMIC.dataBeg = poff;
mluis	1:d3b7bde3995c	1435	LMIC.dataLen = 0;
mluis	0:62d1edcc13d1	1436	} else {
mluis	1:d3b7bde3995c	1437	LMIC.txrxFlags \|= TXRX_PORT;
mluis	1:d3b7bde3995c	1438	LMIC.dataBeg = poff;
mluis	1:d3b7bde3995c	1439	LMIC.dataLen = pend-poff;
mluis	0:62d1edcc13d1	1440	}
mluis	0:62d1edcc13d1	1441	return 1;
mluis	0:62d1edcc13d1	1442	}
mluis	0:62d1edcc13d1	1443
mluis	0:62d1edcc13d1	1444
mluis	0:62d1edcc13d1	1445	// ================================================================================
mluis	0:62d1edcc13d1	1446	// TX/RX transaction support
mluis	0:62d1edcc13d1	1447
mluis	0:62d1edcc13d1	1448
tmulrooney	6:eed5fd627a2b	1449	static void setupRx2 (void)
tmulrooney	6:eed5fd627a2b	1450	{
tmulrooney	6:eed5fd627a2b	1451	debug("LMIC setupRx2 enter\r\n");
mluis	0:62d1edcc13d1	1452	LMIC.txrxFlags = TXRX_DNW2;
mluis	0:62d1edcc13d1	1453	LMIC.rps = dndr2rps(LMIC.dn2Dr);
mluis	0:62d1edcc13d1	1454	LMIC.freq = LMIC.dn2Freq;
mluis	0:62d1edcc13d1	1455	LMIC.dataLen = 0;
mluis	0:62d1edcc13d1	1456	os_radio(RADIO_RX);
mluis	0:62d1edcc13d1	1457	}
mluis	0:62d1edcc13d1	1458
mluis	0:62d1edcc13d1	1459
tmulrooney	6:eed5fd627a2b	1460	static void schedRx2 (ostime_t delay, osjobcb_t func)
tmulrooney	6:eed5fd627a2b	1461	{
tmulrooney	6:eed5fd627a2b	1462	debug("LMIC schedRx2 enter\r\n");
mluis	0:62d1edcc13d1	1463	// Add 1.5 symbols we need 5 out of 8. Try to sync 1.5 symbols into the preamble.
tmulrooney	7:29058a7ccf23	1464	LMIC.rxtime = LMIC.txend + delay + (PAMBL_SYMS-MINRX_SYMS)*dr2hsym(LMIC.dn2Dr);
tmulrooney	7:29058a7ccf23	1465	// LMIC.rxtime = LMIC.txend + delay;
mluis	0:62d1edcc13d1	1466	os_setTimedCallback(&LMIC.osjob, LMIC.rxtime - RX_RAMPUP, func);
mluis	0:62d1edcc13d1	1467	}
mluis	0:62d1edcc13d1	1468
tmulrooney	6:eed5fd627a2b	1469	static void setupRx1 (osjobcb_t func)
tmulrooney	6:eed5fd627a2b	1470	{
tmulrooney	6:eed5fd627a2b	1471	debug("LMIC setupRx1 enter\r\n");
mluis	0:62d1edcc13d1	1472	LMIC.txrxFlags = TXRX_DNW1;
mluis	0:62d1edcc13d1	1473	// Turn LMIC.rps from TX over to RX
mluis	0:62d1edcc13d1	1474	LMIC.rps = setNocrc(LMIC.rps,1);
mluis	0:62d1edcc13d1	1475	LMIC.dataLen = 0;
mluis	0:62d1edcc13d1	1476	LMIC.osjob.func = func;
mluis	0:62d1edcc13d1	1477	os_radio(RADIO_RX);
mluis	0:62d1edcc13d1	1478	}
mluis	0:62d1edcc13d1	1479
mluis	0:62d1edcc13d1	1480
mluis	0:62d1edcc13d1	1481	// Called by HAL once TX complete and delivers exact end of TX time stamp in LMIC.rxtime
tmulrooney	6:eed5fd627a2b	1482	static void txDone (ostime_t delay, osjobcb_t func)
tmulrooney	6:eed5fd627a2b	1483	{
tmulrooney	6:eed5fd627a2b	1484	debug("LMIC txDone enter\r\n");
tmulrooney	6:eed5fd627a2b	1485	if( (LMIC.opmode & (OP_TRACK\|OP_PINGABLE\|OP_PINGINI)) == (OP_TRACK\|OP_PINGABLE) )
tmulrooney	6:eed5fd627a2b	1486	{
mluis	1:d3b7bde3995c	1487	rxschedInit(&LMIC.ping); // note: reuses LMIC.frame buffer!
mluis	1:d3b7bde3995c	1488	LMIC.opmode \|= OP_PINGINI;
mluis	0:62d1edcc13d1	1489	}
mluis	0:62d1edcc13d1	1490	// Change RX frequency / rps (US only) before we increment txChnl
mluis	0:62d1edcc13d1	1491	setRx1Params();
mluis	0:62d1edcc13d1	1492	// LMIC.rxsyms carries the TX datarate (can be != LMIC.datarate [confirm retries etc.])
mluis	0:62d1edcc13d1	1493	// Setup receive - LMIC.rxtime is preloaded with 1.5 symbols offset to tune
mluis	0:62d1edcc13d1	1494	// into the middle of the 8 symbols preamble.
mluis	1:d3b7bde3995c	1495	#if defined(CFG_eu868)
tmulrooney	6:eed5fd627a2b	1496	if( /* TX datarate */LMIC.rxsyms == DR_FSK )
tmulrooney	6:eed5fd627a2b	1497	{
mluis	1:d3b7bde3995c	1498	LMIC.rxtime = LMIC.txend + delay - PRERX_FSK*us2osticksRound(160);
mluis	1:d3b7bde3995c	1499	LMIC.rxsyms = RXLEN_FSK;
mluis	0:62d1edcc13d1	1500	}
mluis	0:62d1edcc13d1	1501	else
mluis	0:62d1edcc13d1	1502	#endif
mluis	0:62d1edcc13d1	1503	{
tmulrooney	7:29058a7ccf23	1504	LMIC.rxtime = LMIC.txend + delay + (PAMBL_SYMS-MINRX_SYMS)*dr2hsym(LMIC.dndr);
tmulrooney	7:29058a7ccf23	1505	// LMIC.rxtime = LMIC.txend + delay;
mluis	1:d3b7bde3995c	1506	LMIC.rxsyms = MINRX_SYMS;
mluis	0:62d1edcc13d1	1507	}
mluis	0:62d1edcc13d1	1508	os_setTimedCallback(&LMIC.osjob, LMIC.rxtime - RX_RAMPUP, func);
mluis	0:62d1edcc13d1	1509	}
mluis	0:62d1edcc13d1	1510
mluis	0:62d1edcc13d1	1511
mluis	0:62d1edcc13d1	1512	// ======================================== Join frames
mluis	0:62d1edcc13d1	1513
mluis	0:62d1edcc13d1	1514
tmulrooney	6:eed5fd627a2b	1515	static void onJoinFailed (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1516	{
tmulrooney	6:eed5fd627a2b	1517	debug("LMIC onJoinFailed enter\r\n");
mluis	0:62d1edcc13d1	1518	// Notify app - must call LMIC_reset() to stop joining
mluis	0:62d1edcc13d1	1519	// otherwise join procedure continues.
mluis	0:62d1edcc13d1	1520	reportEvent(EV_JOIN_FAILED);
mluis	0:62d1edcc13d1	1521	}
mluis	0:62d1edcc13d1	1522
mluis	0:62d1edcc13d1	1523
tmulrooney	6:eed5fd627a2b	1524	static bit_t processJoinAccept (void)
tmulrooney	6:eed5fd627a2b	1525	{
tmulrooney	6:eed5fd627a2b	1526	debug("LMIC processJoinAccept enter\r\n");
mluis	0:62d1edcc13d1	1527	ASSERT(LMIC.txrxFlags != TXRX_DNW1 \|\| LMIC.dataLen != 0);
mluis	0:62d1edcc13d1	1528	ASSERT((LMIC.opmode & OP_TXRXPEND)!=0);
mluis	0:62d1edcc13d1	1529
tmulrooney	6:eed5fd627a2b	1530	if( LMIC.dataLen == 0 )
tmulrooney	6:eed5fd627a2b	1531	{
mluis	0:62d1edcc13d1	1532	nojoinframe:
dudmuck	2:974cafbfb159	1533	/* keep retrying -- if( (LMIC.opmode & OP_JOINING) == 0 ) {
mluis	1:d3b7bde3995c	1534	ASSERT((LMIC.opmode & OP_REJOIN) != 0);
mluis	1:d3b7bde3995c	1535	// REJOIN attempt for roaming
mluis	1:d3b7bde3995c	1536	LMIC.opmode &= ~(OP_REJOIN\|OP_TXRXPEND);
mluis	1:d3b7bde3995c	1537	if( LMIC.rejoinCnt < 10 )
mluis	1:d3b7bde3995c	1538	LMIC.rejoinCnt++;
mluis	1:d3b7bde3995c	1539	reportEvent(EV_REJOIN_FAILED);
mluis	1:d3b7bde3995c	1540	return 1;
dudmuck	2:974cafbfb159	1541	}*/
mluis	1:d3b7bde3995c	1542	LMIC.opmode &= ~OP_TXRXPEND;
mluis	1:d3b7bde3995c	1543	ostime_t delay = nextJoinState();
mluis	1:d3b7bde3995c	1544	EV(devCond, DEBUG, (e_.reason = EV::devCond_t::NO_JACC,
mluis	1:d3b7bde3995c	1545	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1546	e_.info = LMIC.datarate\|DR_PAGE,
mluis	1:d3b7bde3995c	1547	e_.info2 = osticks2ms(delay)));
mluis	1:d3b7bde3995c	1548	// Build next JOIN REQUEST with next engineUpdate call
mluis	1:d3b7bde3995c	1549	// Optionally, report join failed.
mluis	1:d3b7bde3995c	1550	// Both after a random/chosen amount of ticks.
mluis	1:d3b7bde3995c	1551	os_setTimedCallback(&LMIC.osjob, os_getTime()+delay,
mluis	1:d3b7bde3995c	1552	(delay&1) != 0
mluis	1:d3b7bde3995c	1553	? FUNC_ADDR(onJoinFailed) // one JOIN iteration done and failed
mluis	1:d3b7bde3995c	1554	: FUNC_ADDR(runEngineUpdate)); // next step to be delayed
mluis	0:62d1edcc13d1	1555	return 1;
mluis	0:62d1edcc13d1	1556	}
mluis	0:62d1edcc13d1	1557	u1_t hdr = LMIC.frame[0];
mluis	0:62d1edcc13d1	1558	u1_t dlen = LMIC.dataLen;
mluis	0:62d1edcc13d1	1559	u4_t mic = os_rlsbf4(&LMIC.frame[dlen-4]); // safe before modified by encrypt!
mluis	0:62d1edcc13d1	1560	if( (dlen != LEN_JA && dlen != LEN_JAEXT)
mluis	1:d3b7bde3995c	1561	\|\| (hdr & (HDR_FTYPE\|HDR_MAJOR)) != (HDR_FTYPE_JACC\|HDR_MAJOR_V1) ) {
mluis	1:d3b7bde3995c	1562	EV(specCond, ERR, (e_.reason = EV::specCond_t::UNEXPECTED_FRAME,
mluis	1:d3b7bde3995c	1563	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1564	e_.info = dlen < 4 ? 0 : mic,
mluis	1:d3b7bde3995c	1565	e_.info2 = hdr + (dlen<<8)));
mluis	0:62d1edcc13d1	1566	badframe:
mluis	1:d3b7bde3995c	1567	if( (LMIC.txrxFlags & TXRX_DNW1) != 0 )
mluis	1:d3b7bde3995c	1568	return 0;
mluis	1:d3b7bde3995c	1569	goto nojoinframe;
mluis	0:62d1edcc13d1	1570	}
mluis	0:62d1edcc13d1	1571	aes_encrypt(LMIC.frame+1, dlen-1);
mluis	0:62d1edcc13d1	1572	if( !aes_verifyMic0(LMIC.frame, dlen-4) ) {
mluis	1:d3b7bde3995c	1573	EV(specCond, ERR, (e_.reason = EV::specCond_t::JOIN_BAD_MIC,
mluis	1:d3b7bde3995c	1574	e_.info = mic));
mluis	1:d3b7bde3995c	1575	goto badframe;
mluis	0:62d1edcc13d1	1576	}
mluis	0:62d1edcc13d1	1577
mluis	0:62d1edcc13d1	1578	u4_t addr = os_rlsbf4(LMIC.frame+OFF_JA_DEVADDR);
mluis	0:62d1edcc13d1	1579	LMIC.devaddr = addr;
mluis	1:d3b7bde3995c	1580	LMIC.netid = os_rlsbf4(&LMIC.frame[OFF_JA_NETID]) & 0xFFFFFF;
mluis	0:62d1edcc13d1	1581
mluis	1:d3b7bde3995c	1582	#if defined(CFG_eu868)
mluis	0:62d1edcc13d1	1583	initDefaultChannels(0);
mluis	0:62d1edcc13d1	1584	#endif
mluis	0:62d1edcc13d1	1585	if( dlen > LEN_JA ) {
mluis	1:d3b7bde3995c	1586	dlen = OFF_CFLIST;
mluis	1:d3b7bde3995c	1587	#if defined(CFG_eu868)
mluis	1:d3b7bde3995c	1588	u1_t chidx=3;
mluis	1:d3b7bde3995c	1589	#elif defined(CFG_us915)
mluis	1:d3b7bde3995c	1590	u1_t chidx=72;
mluis	0:62d1edcc13d1	1591	#endif
mluis	1:d3b7bde3995c	1592	for( ; chidx<8; chidx++, dlen+=3 )
mluis	3:519c71d29a06	1593	LMIC_setupChannel(chidx, convFreq(&LMIC.frame[dlen]), 0, -1);
mluis	0:62d1edcc13d1	1594	}
mluis	0:62d1edcc13d1	1595
mluis	0:62d1edcc13d1	1596	// already incremented when JOIN REQ got sent off
mluis	0:62d1edcc13d1	1597	aes_sessKeys(LMIC.devNonce-1, &LMIC.frame[OFF_JA_ARTNONCE], LMIC.nwkKey, LMIC.artKey);
mluis	1:d3b7bde3995c	1598	DO_DEVDB(LMIC.netid, netid);
mluis	1:d3b7bde3995c	1599	DO_DEVDB(LMIC.devaddr, devaddr);
mluis	1:d3b7bde3995c	1600	DO_DEVDB(LMIC.nwkKey, nwkkey);
mluis	1:d3b7bde3995c	1601	DO_DEVDB(LMIC.artKey, artkey);
mluis	0:62d1edcc13d1	1602
mluis	0:62d1edcc13d1	1603	EV(joininfo, INFO, (e_.arteui = MAIN::CDEV->getArtEui(),
mluis	1:d3b7bde3995c	1604	e_.deveui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1605	e_.devaddr = LMIC.devaddr,
mluis	1:d3b7bde3995c	1606	e_.oldaddr = oldaddr,
mluis	1:d3b7bde3995c	1607	e_.nonce = LMIC.devNonce-1,
mluis	1:d3b7bde3995c	1608	e_.mic = mic,
mluis	1:d3b7bde3995c	1609	e_.reason = ((LMIC.opmode & OP_REJOIN) != 0
mluis	1:d3b7bde3995c	1610	? EV::joininfo_t::REJOIN_ACCEPT
mluis	1:d3b7bde3995c	1611	: EV::joininfo_t::ACCEPT)));
mluis	0:62d1edcc13d1	1612
mluis	0:62d1edcc13d1	1613	ASSERT((LMIC.opmode & (OP_JOINING\|OP_REJOIN))!=0);
mluis	0:62d1edcc13d1	1614	if( (LMIC.opmode & OP_REJOIN) != 0 ) {
mluis	1:d3b7bde3995c	1615	// Lower DR every try below current UP DR
mluis	1:d3b7bde3995c	1616	LMIC.datarate = lowerDR(LMIC.datarate, LMIC.rejoinCnt);
mluis	0:62d1edcc13d1	1617	}
mluis	0:62d1edcc13d1	1618	LMIC.opmode &= ~(OP_JOINING\|OP_TRACK\|OP_REJOIN\|OP_TXRXPEND\|OP_PINGINI) \| OP_NEXTCHNL;
mluis	0:62d1edcc13d1	1619	stateJustJoined();
mluis	0:62d1edcc13d1	1620	reportEvent(EV_JOINED);
mluis	0:62d1edcc13d1	1621	return 1;
mluis	0:62d1edcc13d1	1622	}
mluis	0:62d1edcc13d1	1623
mluis	1:d3b7bde3995c	1624
tmulrooney	6:eed5fd627a2b	1625	static void processRx2Jacc (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1626	{
tmulrooney	6:eed5fd627a2b	1627	debug("LMIC processRx2Jacc enter\r\n");
mluis	0:62d1edcc13d1	1628	if( LMIC.dataLen == 0 )
mluis	1:d3b7bde3995c	1629	LMIC.txrxFlags = 0; // nothing in 1st/2nd DN slot
mluis	0:62d1edcc13d1	1630	processJoinAccept();
mluis	0:62d1edcc13d1	1631	}
mluis	0:62d1edcc13d1	1632
mluis	1:d3b7bde3995c	1633
tmulrooney	6:eed5fd627a2b	1634	static void setupRx2Jacc (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1635	{
tmulrooney	6:eed5fd627a2b	1636	debug("LMIC setupRx2Jacc enter\r\n");
mluis	1:d3b7bde3995c	1637	LMIC.osjob.func = FUNC_ADDR(processRx2Jacc);
mluis	1:d3b7bde3995c	1638	setupRx2();
mluis	1:d3b7bde3995c	1639	}
mluis	1:d3b7bde3995c	1640
mluis	1:d3b7bde3995c	1641
tmulrooney	6:eed5fd627a2b	1642	static void processRx1Jacc (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1643	{
tmulrooney	6:eed5fd627a2b	1644	debug("LMIC processRx1Jacc enter\r\n");
mluis	1:d3b7bde3995c	1645	if( LMIC.dataLen == 0 \|\| !processJoinAccept() )
mluis	1:d3b7bde3995c	1646	schedRx2(DELAY_JACC2_osticks, FUNC_ADDR(setupRx2Jacc));
mluis	1:d3b7bde3995c	1647	}
mluis	1:d3b7bde3995c	1648
mluis	1:d3b7bde3995c	1649
tmulrooney	6:eed5fd627a2b	1650	static void setupRx1Jacc (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1651	{
tmulrooney	6:eed5fd627a2b	1652	debug("LMIC setupRx1Jacc enter\r\n");
mluis	0:62d1edcc13d1	1653	setupRx1(FUNC_ADDR(processRx1Jacc));
mluis	0:62d1edcc13d1	1654	}
mluis	0:62d1edcc13d1	1655
mluis	0:62d1edcc13d1	1656
tmulrooney	6:eed5fd627a2b	1657	static void jreqDone (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1658	{
tmulrooney	6:eed5fd627a2b	1659	debug("LMIC jreqDone enter\r\n");
mluis	0:62d1edcc13d1	1660	txDone(DELAY_JACC1_osticks, FUNC_ADDR(setupRx1Jacc));
mluis	0:62d1edcc13d1	1661	}
mluis	0:62d1edcc13d1	1662
mluis	0:62d1edcc13d1	1663	// ======================================== Data frames
mluis	0:62d1edcc13d1	1664
mluis	0:62d1edcc13d1	1665	// Fwd decl.
mluis	0:62d1edcc13d1	1666	static bit_t processDnData(void);
mluis	0:62d1edcc13d1	1667
tmulrooney	6:eed5fd627a2b	1668	static void processRx2DnDataDelay (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1669	{
tmulrooney	6:eed5fd627a2b	1670	debug("LMIC processRx2DnDataDelay enter\r\n");
mluis	1:d3b7bde3995c	1671	processDnData();
mluis	1:d3b7bde3995c	1672	}
mluis	1:d3b7bde3995c	1673
tmulrooney	6:eed5fd627a2b	1674	static void processRx2DnData (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1675	{
tmulrooney	6:eed5fd627a2b	1676	debug("LMIC processRx2DnData enter\r\n");
mluis	1:d3b7bde3995c	1677	if( LMIC.dataLen == 0 ) {
mluis	1:d3b7bde3995c	1678	LMIC.txrxFlags = 0; // nothing in 1st/2nd DN slot
mluis	1:d3b7bde3995c	1679	// Delay callback processing to avoid up TX while gateway is txing our missed frame!
mluis	1:d3b7bde3995c	1680	// Since DNW2 uses SF12 by default we wait 3 secs.
mluis	1:d3b7bde3995c	1681	os_setTimedCallback(&LMIC.osjob,
mluis	1:d3b7bde3995c	1682	(os_getTime() + DNW2_SAFETY_ZONE + rndDelay(2)),
mluis	1:d3b7bde3995c	1683	processRx2DnDataDelay);
mluis	1:d3b7bde3995c	1684	return;
mluis	1:d3b7bde3995c	1685	}
mluis	0:62d1edcc13d1	1686	processDnData();
mluis	0:62d1edcc13d1	1687	}
mluis	0:62d1edcc13d1	1688
mluis	0:62d1edcc13d1	1689
tmulrooney	6:eed5fd627a2b	1690	static void setupRx2DnData (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1691	{
tmulrooney	6:eed5fd627a2b	1692	debug("LMIC setupRx2DnData enter\r\n");
mluis	0:62d1edcc13d1	1693	LMIC.osjob.func = FUNC_ADDR(processRx2DnData);
mluis	0:62d1edcc13d1	1694	setupRx2();
mluis	0:62d1edcc13d1	1695	}
mluis	0:62d1edcc13d1	1696
mluis	0:62d1edcc13d1	1697
tmulrooney	6:eed5fd627a2b	1698	static void processRx1DnData (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1699	{
tmulrooney	6:eed5fd627a2b	1700	debug("LMIC processRx1DnData enter\r\n");
mluis	0:62d1edcc13d1	1701	if( LMIC.dataLen == 0 \|\| !processDnData() )
mluis	1:d3b7bde3995c	1702	schedRx2(DELAY_DNW2_osticks, FUNC_ADDR(setupRx2DnData));
mluis	0:62d1edcc13d1	1703	}
mluis	0:62d1edcc13d1	1704
mluis	0:62d1edcc13d1	1705
tmulrooney	6:eed5fd627a2b	1706	static void setupRx1DnData (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1707	{
tmulrooney	6:eed5fd627a2b	1708	debug("LMIC setupRx1DnData enter\r\n");
mluis	0:62d1edcc13d1	1709	setupRx1(FUNC_ADDR(processRx1DnData));
mluis	0:62d1edcc13d1	1710	}
mluis	0:62d1edcc13d1	1711
mluis	0:62d1edcc13d1	1712
tmulrooney	6:eed5fd627a2b	1713	static void updataDone (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1714	{
tmulrooney	6:eed5fd627a2b	1715	debug("LMIC updataDone enter\r\n");
mluis	0:62d1edcc13d1	1716	txDone(DELAY_DNW1_osticks, FUNC_ADDR(setupRx1DnData));
mluis	0:62d1edcc13d1	1717	}
mluis	0:62d1edcc13d1	1718
mluis	0:62d1edcc13d1	1719	// ========================================
mluis	0:62d1edcc13d1	1720
mluis	0:62d1edcc13d1	1721
tmulrooney	6:eed5fd627a2b	1722	static void buildDataFrame (void)
tmulrooney	6:eed5fd627a2b	1723	{
tmulrooney	6:eed5fd627a2b	1724	debug("LMIC buildDataFrame enter\r\n");
mluis	0:62d1edcc13d1	1725	bit_t txdata = ((LMIC.opmode & (OP_TXDATA\|OP_POLL)) != OP_POLL);
mluis	0:62d1edcc13d1	1726	u1_t dlen = txdata ? LMIC.pendTxLen : 0;
mluis	0:62d1edcc13d1	1727
mluis	0:62d1edcc13d1	1728	// Piggyback MAC options
mluis	0:62d1edcc13d1	1729	// Prioritize by importance
mluis	0:62d1edcc13d1	1730	int end = OFF_DAT_OPTS;
mluis	0:62d1edcc13d1	1731	if( (LMIC.opmode & (OP_TRACK\|OP_PINGABLE)) == (OP_TRACK\|OP_PINGABLE) ) {
mluis	1:d3b7bde3995c	1732	// Indicate pingability in every UP frame
mluis	1:d3b7bde3995c	1733	LMIC.frame[end] = MCMD_PING_IND;
mluis	1:d3b7bde3995c	1734	LMIC.frame[end+1] = LMIC.ping.dr \| (LMIC.ping.intvExp<<4);
mluis	1:d3b7bde3995c	1735	end += 2;
mluis	0:62d1edcc13d1	1736	}
mluis	0:62d1edcc13d1	1737	if( LMIC.dutyCapAns ) {
mluis	1:d3b7bde3995c	1738	LMIC.frame[end] = MCMD_DCAP_ANS;
mluis	1:d3b7bde3995c	1739	end += 1;
mluis	1:d3b7bde3995c	1740	LMIC.dutyCapAns = 0;
mluis	0:62d1edcc13d1	1741	}
mluis	0:62d1edcc13d1	1742	if( LMIC.dn2Ans ) {
mluis	1:d3b7bde3995c	1743	LMIC.frame[end+0] = MCMD_DN2P_ANS;
mluis	1:d3b7bde3995c	1744	LMIC.frame[end+1] = LMIC.dn2Ans & ~MCMD_DN2P_ANS_RFU;
mluis	1:d3b7bde3995c	1745	end += 2;
mluis	1:d3b7bde3995c	1746	LMIC.dn2Ans = 0;
mluis	0:62d1edcc13d1	1747	}
mluis	0:62d1edcc13d1	1748	if( LMIC.devsAns ) { // answer to device status
mluis	1:d3b7bde3995c	1749	LMIC.frame[end+0] = MCMD_DEVS_ANS;
mluis	1:d3b7bde3995c	1750	LMIC.frame[end+1] = LMIC.margin;
mluis	1:d3b7bde3995c	1751	LMIC.frame[end+2] = os_getBattLevel();
mluis	1:d3b7bde3995c	1752	end += 3;
mluis	1:d3b7bde3995c	1753	LMIC.devsAns = 0;
mluis	0:62d1edcc13d1	1754	}
mluis	0:62d1edcc13d1	1755	if( LMIC.ladrAns ) { // answer to ADR change
mluis	1:d3b7bde3995c	1756	LMIC.frame[end+0] = MCMD_LADR_ANS;
mluis	1:d3b7bde3995c	1757	LMIC.frame[end+1] = LMIC.ladrAns & ~MCMD_LADR_ANS_RFU;
mluis	1:d3b7bde3995c	1758	end += 2;
mluis	1:d3b7bde3995c	1759	LMIC.ladrAns = 0;
mluis	0:62d1edcc13d1	1760	}
mluis	0:62d1edcc13d1	1761	if( LMIC.bcninfoTries > 0 ) {
mluis	1:d3b7bde3995c	1762	LMIC.frame[end] = MCMD_BCNI_REQ;
mluis	1:d3b7bde3995c	1763	end += 1;
mluis	0:62d1edcc13d1	1764	}
mluis	0:62d1edcc13d1	1765	if( LMIC.adrChanged ) {
mluis	1:d3b7bde3995c	1766	if( LMIC.adrAckReq < 0 )
mluis	1:d3b7bde3995c	1767	LMIC.adrAckReq = 0;
mluis	1:d3b7bde3995c	1768	LMIC.adrChanged = 0;
mluis	0:62d1edcc13d1	1769	}
mluis	0:62d1edcc13d1	1770	if( LMIC.pingSetAns != 0 ) {
mluis	1:d3b7bde3995c	1771	LMIC.frame[end+0] = MCMD_PING_ANS;
mluis	1:d3b7bde3995c	1772	LMIC.frame[end+1] = LMIC.pingSetAns & ~MCMD_PING_ANS_RFU;
mluis	1:d3b7bde3995c	1773	end += 2;
mluis	1:d3b7bde3995c	1774	LMIC.pingSetAns = 0;
mluis	0:62d1edcc13d1	1775	}
mluis	0:62d1edcc13d1	1776	if( LMIC.snchAns ) {
mluis	1:d3b7bde3995c	1777	LMIC.frame[end+0] = MCMD_SNCH_ANS;
mluis	1:d3b7bde3995c	1778	LMIC.frame[end+1] = LMIC.snchAns & ~MCMD_SNCH_ANS_RFU;
mluis	1:d3b7bde3995c	1779	end += 2;
mluis	1:d3b7bde3995c	1780	LMIC.snchAns = 0;
mluis	0:62d1edcc13d1	1781	}
mluis	0:62d1edcc13d1	1782	ASSERT(end <= OFF_DAT_OPTS+16);
mluis	0:62d1edcc13d1	1783
mluis	0:62d1edcc13d1	1784	u1_t flen = end + (txdata ? 5+dlen : 4);
mluis	0:62d1edcc13d1	1785	if( flen > MAX_LEN_FRAME ) {
mluis	1:d3b7bde3995c	1786	// Options and payload too big - delay payload
mluis	1:d3b7bde3995c	1787	txdata = 0;
mluis	1:d3b7bde3995c	1788	flen = end+4;
mluis	0:62d1edcc13d1	1789	}
mluis	0:62d1edcc13d1	1790	LMIC.frame[OFF_DAT_HDR] = HDR_FTYPE_DAUP \| HDR_MAJOR_V1;
mluis	0:62d1edcc13d1	1791	LMIC.frame[OFF_DAT_FCT] = (LMIC.dnConf \| LMIC.adrEnabled
mluis	1:d3b7bde3995c	1792	\| (LMIC.adrAckReq >= 0 ? FCT_ADRARQ : 0)
mluis	1:d3b7bde3995c	1793	\| (end-OFF_DAT_OPTS));
mluis	0:62d1edcc13d1	1794	os_wlsbf4(LMIC.frame+OFF_DAT_ADDR, LMIC.devaddr);
mluis	0:62d1edcc13d1	1795
mluis	0:62d1edcc13d1	1796	if( LMIC.txCnt == 0 ) {
mluis	1:d3b7bde3995c	1797	LMIC.seqnoUp += 1;
mluis	1:d3b7bde3995c	1798	DO_DEVDB(LMIC.seqnoUp,seqnoUp);
mluis	0:62d1edcc13d1	1799	} else {
mluis	1:d3b7bde3995c	1800	EV(devCond, INFO, (e_.reason = EV::devCond_t::RE_TX,
mluis	1:d3b7bde3995c	1801	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1802	e_.info = LMIC.seqnoUp-1,
mluis	1:d3b7bde3995c	1803	e_.info2 = ((LMIC.txCnt+1) \|
mluis	1:d3b7bde3995c	1804	(DRADJUST[LMIC.txCnt+1] << 8) \|
mluis	1:d3b7bde3995c	1805	((LMIC.datarate\|DR_PAGE)<<16))));
mluis	0:62d1edcc13d1	1806	}
mluis	0:62d1edcc13d1	1807	os_wlsbf2(LMIC.frame+OFF_DAT_SEQNO, LMIC.seqnoUp-1);
mluis	0:62d1edcc13d1	1808
mluis	0:62d1edcc13d1	1809	// Clear pending DN confirmation
mluis	0:62d1edcc13d1	1810	LMIC.dnConf = 0;
mluis	0:62d1edcc13d1	1811
mluis	0:62d1edcc13d1	1812	if( txdata ) {
mluis	1:d3b7bde3995c	1813	if( LMIC.pendTxConf ) {
mluis	1:d3b7bde3995c	1814	// Confirmed only makes sense if we have a payload (or at least a port)
mluis	1:d3b7bde3995c	1815	LMIC.frame[OFF_DAT_HDR] = HDR_FTYPE_DCUP \| HDR_MAJOR_V1;
mluis	1:d3b7bde3995c	1816	if( LMIC.txCnt == 0 ) LMIC.txCnt = 1;
mluis	1:d3b7bde3995c	1817	}
mluis	1:d3b7bde3995c	1818	LMIC.frame[end] = LMIC.pendTxPort;
mluis	1:d3b7bde3995c	1819	os_copyMem(LMIC.frame+end+1, LMIC.pendTxData, dlen);
mluis	1:d3b7bde3995c	1820	aes_cipher(LMIC.pendTxPort==0 ? LMIC.nwkKey : LMIC.artKey,
mluis	1:d3b7bde3995c	1821	LMIC.devaddr, LMIC.seqnoUp-1,
mluis	1:d3b7bde3995c	1822	/up/0, LMIC.frame+end+1, dlen);
mluis	0:62d1edcc13d1	1823	}
mluis	0:62d1edcc13d1	1824	aes_appendMic(LMIC.nwkKey, LMIC.devaddr, LMIC.seqnoUp-1, /up/0, LMIC.frame, flen-4);
mluis	0:62d1edcc13d1	1825
mluis	0:62d1edcc13d1	1826	EV(dfinfo, DEBUG, (e_.deveui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1827	e_.devaddr = LMIC.devaddr,
mluis	1:d3b7bde3995c	1828	e_.seqno = LMIC.seqnoUp-1,
mluis	1:d3b7bde3995c	1829	e_.flags = (LMIC.pendTxPort < 0 ? EV::dfinfo_t::NOPORT : EV::dfinfo_t::NOP),
mluis	1:d3b7bde3995c	1830	e_.mic = Base::lsbf4(&LMIC.frame[flen-4]),
mluis	1:d3b7bde3995c	1831	e_.hdr = LMIC.frame[LORA::OFF_DAT_HDR],
mluis	1:d3b7bde3995c	1832	e_.fct = LMIC.frame[LORA::OFF_DAT_FCT],
mluis	1:d3b7bde3995c	1833	e_.port = LMIC.pendTxPort,
mluis	1:d3b7bde3995c	1834	e_.plen = txdata ? dlen : 0,
mluis	1:d3b7bde3995c	1835	e_.opts.length = end-LORA::OFF_DAT_OPTS,
mluis	1:d3b7bde3995c	1836	memcpy(&e_.opts[0], LMIC.frame+LORA::OFF_DAT_OPTS, end-LORA::OFF_DAT_OPTS)));
mluis	0:62d1edcc13d1	1837	LMIC.dataLen = flen;
mluis	0:62d1edcc13d1	1838	}
mluis	0:62d1edcc13d1	1839
mluis	0:62d1edcc13d1	1840
mluis	0:62d1edcc13d1	1841	// Callback from HAL during scan mode or when job timer expires.
tmulrooney	6:eed5fd627a2b	1842	static void onBcnRx (xref2osjob_t job)
tmulrooney	6:eed5fd627a2b	1843	{
tmulrooney	6:eed5fd627a2b	1844	debug("LMIC onBcnRx enter\r\n");
mluis	0:62d1edcc13d1	1845	// If we arrive via job timer make sure to put radio to rest.
mluis	0:62d1edcc13d1	1846	os_radio(RADIO_RST);
mluis	0:62d1edcc13d1	1847	os_clearCallback(&LMIC.osjob);
mluis	0:62d1edcc13d1	1848	if( LMIC.dataLen == 0 ) {
mluis	1:d3b7bde3995c	1849	// Nothing received - timeout
mluis	1:d3b7bde3995c	1850	LMIC.opmode &= ~(OP_SCAN \| OP_TRACK);
mluis	1:d3b7bde3995c	1851	reportEvent(EV_SCAN_TIMEOUT);
mluis	1:d3b7bde3995c	1852	return;
mluis	0:62d1edcc13d1	1853	}
mluis	0:62d1edcc13d1	1854	if( decodeBeacon() <= 0 ) {
mluis	1:d3b7bde3995c	1855	// Something is wrong with the beacon - continue scan
mluis	1:d3b7bde3995c	1856	LMIC.dataLen = 0;
mluis	1:d3b7bde3995c	1857	os_radio(RADIO_RXON);
mluis	1:d3b7bde3995c	1858	os_setTimedCallback(&LMIC.osjob, LMIC.bcninfo.txtime, FUNC_ADDR(onBcnRx));
mluis	1:d3b7bde3995c	1859	return;
mluis	0:62d1edcc13d1	1860	}
mluis	0:62d1edcc13d1	1861	// Found our 1st beacon
mluis	0:62d1edcc13d1	1862	// We don't have a previous beacon to calc some drift - assume
mluis	0:62d1edcc13d1	1863	// an max error of 13ms = 128sec*100ppm which is roughly +/-100ppm
mluis	0:62d1edcc13d1	1864	calcBcnRxWindowFromMillis(13,1);
mluis	0:62d1edcc13d1	1865	LMIC.opmode &= ~OP_SCAN; // turn SCAN off
mluis	0:62d1edcc13d1	1866	LMIC.opmode \|= OP_TRACK; // auto enable tracking
mluis	0:62d1edcc13d1	1867	reportEvent(EV_BEACON_FOUND); // can be disabled in callback
mluis	0:62d1edcc13d1	1868	}
mluis	0:62d1edcc13d1	1869
mluis	0:62d1edcc13d1	1870
mluis	0:62d1edcc13d1	1871	// Enable receiver to listen to incoming beacons
mluis	0:62d1edcc13d1	1872	// netid defines when scan stops (any or specific beacon)
mluis	0:62d1edcc13d1	1873	// This mode ends with events: EV_SCAN_TIMEOUT/EV_SCAN_BEACON
mluis	0:62d1edcc13d1	1874	// Implicitely cancels any pending TX/RX transaction.
mluis	0:62d1edcc13d1	1875	// Also cancels an onpoing joining procedure.
tmulrooney	6:eed5fd627a2b	1876	static void startScan (void)
tmulrooney	6:eed5fd627a2b	1877	{
tmulrooney	6:eed5fd627a2b	1878	debug("LMIC startScan enter\r\n");
mluis	0:62d1edcc13d1	1879	ASSERT(LMIC.devaddr!=0 && (LMIC.opmode & OP_JOINING)==0);
mluis	0:62d1edcc13d1	1880	if( (LMIC.opmode & OP_SHUTDOWN) != 0 )
mluis	1:d3b7bde3995c	1881	return;
mluis	0:62d1edcc13d1	1882	// Cancel onging TX/RX transaction
mluis	0:62d1edcc13d1	1883	LMIC.txCnt = LMIC.dnConf = LMIC.bcninfo.flags = 0;
mluis	0:62d1edcc13d1	1884	LMIC.opmode = (LMIC.opmode \| OP_SCAN) & ~(OP_TXRXPEND);
mluis	0:62d1edcc13d1	1885	setBcnRxParams();
mluis	0:62d1edcc13d1	1886	LMIC.rxtime = LMIC.bcninfo.txtime = os_getTime() + sec2osticks(BCN_INTV_sec+1);
mluis	0:62d1edcc13d1	1887	os_setTimedCallback(&LMIC.osjob, LMIC.rxtime, FUNC_ADDR(onBcnRx));
mluis	0:62d1edcc13d1	1888	os_radio(RADIO_RXON);
mluis	0:62d1edcc13d1	1889	}
mluis	0:62d1edcc13d1	1890
mluis	0:62d1edcc13d1	1891
tmulrooney	6:eed5fd627a2b	1892	bit_t LMIC_enableTracking (u1_t tryBcnInfo)
tmulrooney	6:eed5fd627a2b	1893	{
tmulrooney	6:eed5fd627a2b	1894	debug("LMIC LMIC_enableTracking enter\r\n");
mluis	0:62d1edcc13d1	1895	if( (LMIC.opmode & (OP_SCAN\|OP_TRACK\|OP_SHUTDOWN)) != 0 )
mluis	1:d3b7bde3995c	1896	return 0; // already in progress or failed to enable
mluis	0:62d1edcc13d1	1897	// If BCN info requested from NWK then app has to take are
mluis	0:62d1edcc13d1	1898	// of sending data up so that MCMD_BCNI_REQ can be attached.
mluis	0:62d1edcc13d1	1899	if( (LMIC.bcninfoTries = tryBcnInfo) == 0 )
mluis	1:d3b7bde3995c	1900	startScan();
mluis	0:62d1edcc13d1	1901	return 1; // enabled
mluis	0:62d1edcc13d1	1902	}
mluis	0:62d1edcc13d1	1903
mluis	0:62d1edcc13d1	1904
tmulrooney	6:eed5fd627a2b	1905	void LMIC_disableTracking (void)
tmulrooney	6:eed5fd627a2b	1906	{
tmulrooney	6:eed5fd627a2b	1907	debug("LMIC LMIC_disableTracking enter\r\n");
mluis	0:62d1edcc13d1	1908	LMIC.opmode &= ~(OP_SCAN\|OP_TRACK);
mluis	0:62d1edcc13d1	1909	LMIC.bcninfoTries = 0;
mluis	0:62d1edcc13d1	1910	engineUpdate();
mluis	0:62d1edcc13d1	1911	}
mluis	0:62d1edcc13d1	1912
mluis	0:62d1edcc13d1	1913
mluis	0:62d1edcc13d1	1914	// ================================================================================
mluis	0:62d1edcc13d1	1915	//
mluis	0:62d1edcc13d1	1916	// Join stuff
mluis	0:62d1edcc13d1	1917	//
mluis	0:62d1edcc13d1	1918	// ================================================================================
mluis	0:62d1edcc13d1	1919
tmulrooney	6:eed5fd627a2b	1920	static void buildJoinRequest (u1_t ftype)
tmulrooney	6:eed5fd627a2b	1921	{
tmulrooney	6:eed5fd627a2b	1922	debug("LMIC buildJoinRequest enter\r\n");
mluis	0:62d1edcc13d1	1923	// Do not use pendTxData since we might have a pending
mluis	0:62d1edcc13d1	1924	// user level frame in there. Use RX holding area instead.
mluis	0:62d1edcc13d1	1925	xref2u1_t d = LMIC.frame;
mluis	0:62d1edcc13d1	1926	d[OFF_JR_HDR] = ftype;
mluis	0:62d1edcc13d1	1927	os_getArtEui(d + OFF_JR_ARTEUI);
mluis	0:62d1edcc13d1	1928	os_getDevEui(d + OFF_JR_DEVEUI);
mluis	0:62d1edcc13d1	1929	os_wlsbf2(d + OFF_JR_DEVNONCE, LMIC.devNonce);
mluis	0:62d1edcc13d1	1930	aes_appendMic0(d, OFF_JR_MIC);
mluis	0:62d1edcc13d1	1931
mluis	0:62d1edcc13d1	1932	EV(joininfo,INFO,(e_.deveui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	1933	e_.arteui = MAIN::CDEV->getArtEui(),
mluis	1:d3b7bde3995c	1934	e_.nonce = LMIC.devNonce,
mluis	1:d3b7bde3995c	1935	e_.oldaddr = LMIC.devaddr,
mluis	1:d3b7bde3995c	1936	e_.mic = Base::lsbf4(&d[LORA::OFF_JR_MIC]),
mluis	1:d3b7bde3995c	1937	e_.reason = ((LMIC.opmode & OP_REJOIN) != 0
mluis	1:d3b7bde3995c	1938	? EV::joininfo_t::REJOIN_REQUEST
mluis	1:d3b7bde3995c	1939	: EV::joininfo_t::REQUEST)));
mluis	0:62d1edcc13d1	1940	LMIC.dataLen = LEN_JR;
mluis	0:62d1edcc13d1	1941	LMIC.devNonce++;
mluis	1:d3b7bde3995c	1942	DO_DEVDB(LMIC.devNonce,devNonce);
mluis	0:62d1edcc13d1	1943	}
mluis	0:62d1edcc13d1	1944
tmulrooney	6:eed5fd627a2b	1945	static void startJoining (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1946	{
tmulrooney	6:eed5fd627a2b	1947	debug("LMIC startJoining enter\r\n");
mluis	0:62d1edcc13d1	1948	reportEvent(EV_JOINING);
mluis	0:62d1edcc13d1	1949	}
mluis	0:62d1edcc13d1	1950
mluis	0:62d1edcc13d1	1951	// Start join procedure if not already joined.
tmulrooney	6:eed5fd627a2b	1952	bit_t LMIC_startJoining (void)
tmulrooney	6:eed5fd627a2b	1953	{
tmulrooney	6:eed5fd627a2b	1954	debug("LMIC LMIC_startJoining enter\r\n");
tmulrooney	6:eed5fd627a2b	1955	if( LMIC.devaddr == 0 )
tmulrooney	6:eed5fd627a2b	1956	{
mluis	1:d3b7bde3995c	1957	// There should be no TX/RX going on
mluis	1:d3b7bde3995c	1958	ASSERT((LMIC.opmode & (OP_POLL\|OP_TXRXPEND)) == 0);
mluis	1:d3b7bde3995c	1959	// Lift any previous duty limitation
mluis	1:d3b7bde3995c	1960	LMIC.globalDutyRate = 0;
mluis	1:d3b7bde3995c	1961	// Cancel scanning
mluis	1:d3b7bde3995c	1962	LMIC.opmode &= ~(OP_SCAN\|OP_REJOIN\|OP_LINKDEAD\|OP_NEXTCHNL);
mluis	1:d3b7bde3995c	1963	// Setup state
mluis	1:d3b7bde3995c	1964	LMIC.rejoinCnt = LMIC.txCnt = LMIC.pendTxConf = 0;
mluis	1:d3b7bde3995c	1965	initJoinLoop();
mluis	1:d3b7bde3995c	1966	LMIC.opmode \|= OP_JOINING;
mluis	1:d3b7bde3995c	1967	// reportEvent will call engineUpdate which then starts sending JOIN REQUESTS
mluis	1:d3b7bde3995c	1968	os_setCallback(&LMIC.osjob, FUNC_ADDR(startJoining));
mluis	1:d3b7bde3995c	1969	return 1;
mluis	0:62d1edcc13d1	1970	}
mluis	1:d3b7bde3995c	1971	return 0; // already joined
mluis	0:62d1edcc13d1	1972	}
mluis	0:62d1edcc13d1	1973
mluis	0:62d1edcc13d1	1974
mluis	0:62d1edcc13d1	1975	// ================================================================================
mluis	0:62d1edcc13d1	1976	//
mluis	0:62d1edcc13d1	1977	//
mluis	0:62d1edcc13d1	1978	//
mluis	0:62d1edcc13d1	1979	// ================================================================================
mluis	0:62d1edcc13d1	1980
tmulrooney	6:eed5fd627a2b	1981	static void processPingRx (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	1982	{
tmulrooney	6:eed5fd627a2b	1983	debug("LMIC processPingRx enter\r\n");
mluis	0:62d1edcc13d1	1984	if( LMIC.dataLen != 0 ) {
mluis	1:d3b7bde3995c	1985	LMIC.txrxFlags = TXRX_PING;
mluis	1:d3b7bde3995c	1986	if( decodeFrame() ) {
mluis	1:d3b7bde3995c	1987	reportEvent(EV_RXCOMPLETE);
mluis	1:d3b7bde3995c	1988	return;
mluis	1:d3b7bde3995c	1989	}
mluis	0:62d1edcc13d1	1990	}
mluis	0:62d1edcc13d1	1991	// Pick next ping slot
mluis	0:62d1edcc13d1	1992	engineUpdate();
mluis	0:62d1edcc13d1	1993	}
mluis	0:62d1edcc13d1	1994
mluis	0:62d1edcc13d1	1995
tmulrooney	6:eed5fd627a2b	1996	static bit_t processDnData (void)
tmulrooney	6:eed5fd627a2b	1997	{
tmulrooney	6:eed5fd627a2b	1998	debug("LMIC processDnData enter\r\n");
mluis	0:62d1edcc13d1	1999	ASSERT((LMIC.opmode & OP_TXRXPEND)!=0);
mluis	0:62d1edcc13d1	2000
mluis	0:62d1edcc13d1	2001	if( LMIC.dataLen == 0 ) {
mluis	0:62d1edcc13d1	2002	norx:
mluis	1:d3b7bde3995c	2003	if( LMIC.txCnt != 0 ) {
mluis	1:d3b7bde3995c	2004	if( LMIC.txCnt < TXCONF_ATTEMPTS ) {
mluis	1:d3b7bde3995c	2005	LMIC.txCnt += 1;
mluis	1:d3b7bde3995c	2006	setDrTxpow(DRCHG_NOACK, lowerDR(LMIC.datarate, DRADJUST[LMIC.txCnt]), KEEP_TXPOW);
mluis	1:d3b7bde3995c	2007	// Schedule another retransmission
mluis	1:d3b7bde3995c	2008	txDelay(LMIC.rxtime, RETRY_PERIOD_secs);
mluis	1:d3b7bde3995c	2009	LMIC.opmode &= ~OP_TXRXPEND;
mluis	1:d3b7bde3995c	2010	engineUpdate();
mluis	1:d3b7bde3995c	2011	return 1;
mluis	1:d3b7bde3995c	2012	}
mluis	1:d3b7bde3995c	2013	LMIC.txrxFlags = TXRX_NACK \| TXRX_NOPORT;
mluis	1:d3b7bde3995c	2014	} else {
mluis	1:d3b7bde3995c	2015	// Nothing received - implies no port
mluis	1:d3b7bde3995c	2016	LMIC.txrxFlags = TXRX_NOPORT;
mluis	0:62d1edcc13d1	2017	}
mluis	1:d3b7bde3995c	2018	if( LMIC.adrAckReq != LINK_CHECK_OFF )
mluis	1:d3b7bde3995c	2019	LMIC.adrAckReq += 1;
mluis	1:d3b7bde3995c	2020	LMIC.dataBeg = LMIC.dataLen = 0;
mluis	0:62d1edcc13d1	2021	txcomplete:
mluis	1:d3b7bde3995c	2022	LMIC.opmode &= ~(OP_TXDATA\|OP_TXRXPEND);
mluis	1:d3b7bde3995c	2023	if( (LMIC.txrxFlags & (TXRX_DNW1\|TXRX_DNW2\|TXRX_PING)) != 0 && (LMIC.opmode & OP_LINKDEAD) != 0 ) {
mluis	1:d3b7bde3995c	2024	LMIC.opmode &= ~OP_LINKDEAD;
mluis	1:d3b7bde3995c	2025	reportEvent(EV_LINK_ALIVE);
mluis	1:d3b7bde3995c	2026	}
mluis	1:d3b7bde3995c	2027	reportEvent(EV_TXCOMPLETE);
mluis	1:d3b7bde3995c	2028	// If we haven't heard from NWK in a while although we asked for a sign
mluis	1:d3b7bde3995c	2029	// assume link is dead - notify application and keep going
mluis	1:d3b7bde3995c	2030	if( LMIC.adrAckReq > LINK_CHECK_DEAD ) {
mluis	1:d3b7bde3995c	2031	// We haven't heard from NWK for some time although we
mluis	1:d3b7bde3995c	2032	// asked for a response for some time - assume we're disconnected. Lower DR one notch.
mluis	1:d3b7bde3995c	2033	EV(devCond, ERR, (e_.reason = EV::devCond_t::LINK_DEAD,
mluis	1:d3b7bde3995c	2034	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	2035	e_.info = LMIC.adrAckReq));
mluis	1:d3b7bde3995c	2036	setDrTxpow(DRCHG_NOADRACK, decDR((dr_t)LMIC.datarate), KEEP_TXPOW);
mluis	1:d3b7bde3995c	2037	LMIC.adrAckReq = LINK_CHECK_CONT;
mluis	0:62d1edcc13d1	2038	LMIC.opmode \|= OP_REJOIN\|OP_LINKDEAD;
mluis	1:d3b7bde3995c	2039	reportEvent(EV_LINK_DEAD);
mluis	0:62d1edcc13d1	2040	}
mluis	1:d3b7bde3995c	2041	// If this falls to zero the NWK did not answer our MCMD_BCNI_REQ commands - try full scan
mluis	1:d3b7bde3995c	2042	if( LMIC.bcninfoTries > 0 ) {
mluis	1:d3b7bde3995c	2043	if( (LMIC.opmode & OP_TRACK) != 0 ) {
mluis	1:d3b7bde3995c	2044	reportEvent(EV_BEACON_FOUND);
mluis	1:d3b7bde3995c	2045	LMIC.bcninfoTries = 0;
mluis	1:d3b7bde3995c	2046	}
mluis	1:d3b7bde3995c	2047	else if( --LMIC.bcninfoTries == 0 ) {
mluis	1:d3b7bde3995c	2048	startScan(); // NWK did not answer - try scan
mluis	1:d3b7bde3995c	2049	}
mluis	0:62d1edcc13d1	2050	}
mluis	1:d3b7bde3995c	2051	return 1;
mluis	0:62d1edcc13d1	2052	}
mluis	0:62d1edcc13d1	2053	if( !decodeFrame() ) {
mluis	1:d3b7bde3995c	2054	if( (LMIC.txrxFlags & TXRX_DNW1) != 0 )
mluis	1:d3b7bde3995c	2055	return 0;
mluis	1:d3b7bde3995c	2056	goto norx;
mluis	0:62d1edcc13d1	2057	}
mluis	0:62d1edcc13d1	2058	goto txcomplete;
mluis	0:62d1edcc13d1	2059	}
mluis	0:62d1edcc13d1	2060
mluis	0:62d1edcc13d1	2061
tmulrooney	6:eed5fd627a2b	2062	static void processBeacon (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	2063	{
tmulrooney	6:eed5fd627a2b	2064	debug("LMIC processBeacon enter\r\n");
mluis	0:62d1edcc13d1	2065	ostime_t lasttx = LMIC.bcninfo.txtime; // save here - decodeBeacon might overwrite
mluis	0:62d1edcc13d1	2066	u1_t flags = LMIC.bcninfo.flags;
mluis	0:62d1edcc13d1	2067	ev_t ev;
mluis	0:62d1edcc13d1	2068
mluis	0:62d1edcc13d1	2069	if( LMIC.dataLen != 0 && decodeBeacon() >= 1 ) {
mluis	1:d3b7bde3995c	2070	ev = EV_BEACON_TRACKED;
mluis	1:d3b7bde3995c	2071	if( (flags & (BCN_PARTIAL\|BCN_FULL)) == 0 ) {
mluis	1:d3b7bde3995c	2072	// We don't have a previous beacon to calc some drift - assume
mluis	1:d3b7bde3995c	2073	// an max error of 13ms = 128sec*100ppm which is roughly +/-100ppm
mluis	1:d3b7bde3995c	2074	calcBcnRxWindowFromMillis(13,0);
mluis	1:d3b7bde3995c	2075	goto rev;
mluis	1:d3b7bde3995c	2076	}
mluis	1:d3b7bde3995c	2077	// We have a previous BEACON to calculate some drift
mluis	1:d3b7bde3995c	2078	s2_t drift = BCN_INTV_osticks - (LMIC.bcninfo.txtime - lasttx);
mluis	1:d3b7bde3995c	2079	if( LMIC.missedBcns > 0 ) {
mluis	1:d3b7bde3995c	2080	drift = LMIC.drift + (drift - LMIC.drift) / (LMIC.missedBcns+1);
mluis	1:d3b7bde3995c	2081	}
mluis	1:d3b7bde3995c	2082	if( (LMIC.bcninfo.flags & BCN_NODRIFT) == 0 ) {
mluis	1:d3b7bde3995c	2083	s2_t diff = LMIC.drift - drift;
mluis	1:d3b7bde3995c	2084	if( diff < 0 ) diff = -diff;
mluis	1:d3b7bde3995c	2085	LMIC.lastDriftDiff = diff;
mluis	1:d3b7bde3995c	2086	if( LMIC.maxDriftDiff < diff )
mluis	1:d3b7bde3995c	2087	LMIC.maxDriftDiff = diff;
mluis	1:d3b7bde3995c	2088	LMIC.bcninfo.flags &= ~BCN_NODDIFF;
mluis	1:d3b7bde3995c	2089	}
mluis	1:d3b7bde3995c	2090	LMIC.drift = drift;
mluis	1:d3b7bde3995c	2091	LMIC.missedBcns = LMIC.rejoinCnt = 0;
mluis	1:d3b7bde3995c	2092	LMIC.bcninfo.flags &= ~BCN_NODRIFT;
mluis	1:d3b7bde3995c	2093	EV(devCond,INFO,(e_.reason = EV::devCond_t::CLOCK_DRIFT,
mluis	1:d3b7bde3995c	2094	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	2095	e_.info = drift,
mluis	1:d3b7bde3995c	2096	e_.info2 = /occasion BEACON/0));
mluis	1:d3b7bde3995c	2097	ASSERT((LMIC.bcninfo.flags & (BCN_PARTIAL\|BCN_FULL)) != 0);
mluis	0:62d1edcc13d1	2098	} else {
mluis	1:d3b7bde3995c	2099	ev = EV_BEACON_MISSED;
mluis	1:d3b7bde3995c	2100	LMIC.bcninfo.txtime += BCN_INTV_osticks - LMIC.drift;
mluis	1:d3b7bde3995c	2101	LMIC.bcninfo.time += BCN_INTV_sec;
mluis	1:d3b7bde3995c	2102	LMIC.missedBcns++;
mluis	1:d3b7bde3995c	2103	// Delay any possible TX after surmised beacon - it's there although we missed it
mluis	1:d3b7bde3995c	2104	txDelay(LMIC.bcninfo.txtime + BCN_RESERVE_osticks, 4);
mluis	1:d3b7bde3995c	2105	if( LMIC.missedBcns > MAX_MISSED_BCNS )
mluis	1:d3b7bde3995c	2106	LMIC.opmode \|= OP_REJOIN; // try if we can roam to another network
mluis	1:d3b7bde3995c	2107	if( LMIC.bcnRxsyms > MAX_RXSYMS ) {
mluis	1:d3b7bde3995c	2108	LMIC.opmode &= ~(OP_TRACK\|OP_PINGABLE\|OP_PINGINI\|OP_REJOIN);
mluis	1:d3b7bde3995c	2109	reportEvent(EV_LOST_TSYNC);
mluis	1:d3b7bde3995c	2110	return;
mluis	1:d3b7bde3995c	2111	}
mluis	0:62d1edcc13d1	2112	}
mluis	0:62d1edcc13d1	2113	LMIC.bcnRxtime = LMIC.bcninfo.txtime + BCN_INTV_osticks - calcRxWindow(0,DR_BCN);
mluis	0:62d1edcc13d1	2114	LMIC.bcnRxsyms = LMIC.rxsyms;
mluis	0:62d1edcc13d1	2115	rev:
dudmuck	2:974cafbfb159	2116	#ifdef CFG_us915
mluis	1:d3b7bde3995c	2117	LMIC.bcnChnl = (LMIC.bcnChnl+1) & 7;
mluis	1:d3b7bde3995c	2118	#endif
mluis	0:62d1edcc13d1	2119	if( (LMIC.opmode & OP_PINGINI) != 0 )
mluis	1:d3b7bde3995c	2120	rxschedInit(&LMIC.ping); // note: reuses LMIC.frame buffer!
mluis	0:62d1edcc13d1	2121	reportEvent(ev);
mluis	0:62d1edcc13d1	2122	}
mluis	0:62d1edcc13d1	2123
mluis	0:62d1edcc13d1	2124
tmulrooney	6:eed5fd627a2b	2125	static void startRxBcn (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	2126	{
tmulrooney	6:eed5fd627a2b	2127	debug("LMIC startRxBcn enter\r\n");
mluis	0:62d1edcc13d1	2128	LMIC.osjob.func = FUNC_ADDR(processBeacon);
mluis	0:62d1edcc13d1	2129	os_radio(RADIO_RX);
mluis	0:62d1edcc13d1	2130	}
mluis	0:62d1edcc13d1	2131
mluis	0:62d1edcc13d1	2132
tmulrooney	6:eed5fd627a2b	2133	static void startRxPing (xref2osjob_t osjob)
tmulrooney	6:eed5fd627a2b	2134	{
tmulrooney	6:eed5fd627a2b	2135	debug("LMIC startRxPing enter\r\n");
mluis	0:62d1edcc13d1	2136	LMIC.osjob.func = FUNC_ADDR(processPingRx);
mluis	0:62d1edcc13d1	2137	os_radio(RADIO_RX);
mluis	0:62d1edcc13d1	2138	}
mluis	0:62d1edcc13d1	2139
mluis	0:62d1edcc13d1	2140
mluis	0:62d1edcc13d1	2141	// Decide what to do next for the MAC layer of a device
tmulrooney	6:eed5fd627a2b	2142	static void engineUpdate (void)
tmulrooney	6:eed5fd627a2b	2143	{
tmulrooney	6:eed5fd627a2b	2144	debug("LMIC engineUpdate enter\r\n");
mluis	0:62d1edcc13d1	2145	// Check for ongoing state: scan or TX/RX transaction
mluis	0:62d1edcc13d1	2146	if( (LMIC.opmode & (OP_SCAN\|OP_TXRXPEND\|OP_SHUTDOWN)) != 0 )
mluis	1:d3b7bde3995c	2147	return;
mluis	0:62d1edcc13d1	2148
mluis	0:62d1edcc13d1	2149	if( LMIC.devaddr == 0 && (LMIC.opmode & OP_JOINING) == 0 ) {
mluis	1:d3b7bde3995c	2150	LMIC_startJoining();
mluis	1:d3b7bde3995c	2151	return;
mluis	0:62d1edcc13d1	2152	}
mluis	0:62d1edcc13d1	2153
mluis	0:62d1edcc13d1	2154	ostime_t now = os_getTime();
mluis	0:62d1edcc13d1	2155	ostime_t rxtime = 0;
mluis	0:62d1edcc13d1	2156	ostime_t txbeg = 0;
mluis	0:62d1edcc13d1	2157
mluis	0:62d1edcc13d1	2158	if( (LMIC.opmode & OP_TRACK) != 0 ) {
mluis	1:d3b7bde3995c	2159	// We are tracking a beacon
mluis	1:d3b7bde3995c	2160	ASSERT( now + RX_RAMPUP - LMIC.bcnRxtime <= 0 );
mluis	1:d3b7bde3995c	2161	rxtime = LMIC.bcnRxtime - RX_RAMPUP;
mluis	0:62d1edcc13d1	2162	}
mluis	0:62d1edcc13d1	2163
mluis	0:62d1edcc13d1	2164	if( (LMIC.opmode & (OP_JOINING\|OP_REJOIN\|OP_TXDATA\|OP_POLL)) != 0 ) {
mluis	1:d3b7bde3995c	2165	// Need to TX some data...
mluis	1:d3b7bde3995c	2166	// Assuming txChnl points to channel which first becomes available again.
mluis	1:d3b7bde3995c	2167	bit_t jacc = ((LMIC.opmode & (OP_JOINING\|OP_REJOIN)) != 0 ? 1 : 0);
mluis	1:d3b7bde3995c	2168	// Find next suitable channel and return availability time
mluis	1:d3b7bde3995c	2169	if( (LMIC.opmode & OP_NEXTCHNL) != 0 ) {
mluis	1:d3b7bde3995c	2170	txbeg = LMIC.txend = nextTx(now);
mluis	1:d3b7bde3995c	2171	LMIC.opmode &= ~OP_NEXTCHNL;
mluis	0:62d1edcc13d1	2172	} else {
mluis	1:d3b7bde3995c	2173	txbeg = LMIC.txend;
mluis	1:d3b7bde3995c	2174	}
mluis	1:d3b7bde3995c	2175	// Delayed TX or waiting for duty cycle?
mluis	1:d3b7bde3995c	2176	if( (LMIC.globalDutyRate != 0 \|\| (LMIC.opmode & OP_RNDTX) != 0) && (txbeg - LMIC.globalDutyAvail) < 0 )
mluis	1:d3b7bde3995c	2177	txbeg = LMIC.globalDutyAvail;
mluis	1:d3b7bde3995c	2178	// If we're tracking a beacon...
mluis	1:d3b7bde3995c	2179	// then make sure TX-RX transaction is complete before beacon
mluis	1:d3b7bde3995c	2180	if( (LMIC.opmode & OP_TRACK) != 0 &&
mluis	1:d3b7bde3995c	2181	txbeg + (jacc ? JOIN_GUARD_osticks : TXRX_GUARD_osticks) - rxtime > 0 ) {
mluis	1:d3b7bde3995c	2182	// Not enough time to complete TX-RX before beacon - postpone after beacon.
mluis	1:d3b7bde3995c	2183	// In order to avoid clustering of postponed TX right after beacon randomize start!
mluis	1:d3b7bde3995c	2184	txDelay(rxtime + BCN_RESERVE_osticks, 16);
mluis	1:d3b7bde3995c	2185	txbeg = 0;
mluis	1:d3b7bde3995c	2186	goto checkrx;
mluis	0:62d1edcc13d1	2187	}
mluis	1:d3b7bde3995c	2188	// Earliest possible time vs overhead to setup radio
mluis	1:d3b7bde3995c	2189	if( txbeg - (now + TX_RAMPUP) < 0 ) {
mluis	1:d3b7bde3995c	2190	// We could send right now!
mluis	1:d3b7bde3995c	2191	dr_t txdr = (dr_t)LMIC.datarate;
dudmuck	2:974cafbfb159	2192	txbeg = now;
mluis	1:d3b7bde3995c	2193	if( jacc ) {
mluis	1:d3b7bde3995c	2194	u1_t ftype;
mluis	1:d3b7bde3995c	2195	if( (LMIC.opmode & OP_REJOIN) != 0 ) {
mluis	1:d3b7bde3995c	2196	txdr = lowerDR(txdr, LMIC.rejoinCnt);
dudmuck	2:974cafbfb159	2197	//ftype = HDR_FTYPE_REJOIN;
dudmuck	2:974cafbfb159	2198	ftype = HDR_FTYPE_JREQ;
mluis	1:d3b7bde3995c	2199	} else {
mluis	1:d3b7bde3995c	2200	ftype = HDR_FTYPE_JREQ;
mluis	1:d3b7bde3995c	2201	}
mluis	1:d3b7bde3995c	2202	buildJoinRequest(ftype);
mluis	1:d3b7bde3995c	2203	LMIC.osjob.func = FUNC_ADDR(jreqDone);
mluis	1:d3b7bde3995c	2204	} else {
mluis	1:d3b7bde3995c	2205	if( LMIC.seqnoDn >= 0xFFFFFF80 ) {
mluis	1:d3b7bde3995c	2206	// Imminent roll over - proactively reset MAC
mluis	1:d3b7bde3995c	2207	EV(specCond, INFO, (e_.reason = EV::specCond_t::DNSEQNO_ROLL_OVER,
mluis	1:d3b7bde3995c	2208	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	2209	e_.info = LMIC.seqnoDn,
mluis	1:d3b7bde3995c	2210	e_.info2 = 0));
mluis	1:d3b7bde3995c	2211	// Device has to react! NWK will not roll over and just stop sending.
mluis	1:d3b7bde3995c	2212	// Thus, we have N frames to detect a possible lock up.
mluis	1:d3b7bde3995c	2213	reset:
mluis	1:d3b7bde3995c	2214	os_setCallback(&LMIC.osjob, FUNC_ADDR(runReset));
mluis	1:d3b7bde3995c	2215	return;
mluis	1:d3b7bde3995c	2216	}
mluis	1:d3b7bde3995c	2217	if( (LMIC.txCnt==0 && LMIC.seqnoUp == 0xFFFFFFFF) ) {
mluis	1:d3b7bde3995c	2218	// Roll over of up seq counter
mluis	1:d3b7bde3995c	2219	EV(specCond, ERR, (e_.reason = EV::specCond_t::UPSEQNO_ROLL_OVER,
mluis	1:d3b7bde3995c	2220	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	2221	e_.info2 = LMIC.seqnoUp));
mluis	1:d3b7bde3995c	2222	// Do not run RESET event callback from here!
mluis	1:d3b7bde3995c	2223	// App code might do some stuff after send unaware of RESET.
mluis	1:d3b7bde3995c	2224	goto reset;
mluis	1:d3b7bde3995c	2225	}
mluis	1:d3b7bde3995c	2226	buildDataFrame();
mluis	1:d3b7bde3995c	2227	LMIC.osjob.func = FUNC_ADDR(updataDone);
mluis	1:d3b7bde3995c	2228	}
mluis	1:d3b7bde3995c	2229	LMIC.rps = setCr(updr2rps(txdr), (cr_t)LMIC.errcr);
mluis	1:d3b7bde3995c	2230	LMIC.dndr = txdr; // carry TX datarate (can be != LMIC.datarate) over to txDone/setupRx1
mluis	1:d3b7bde3995c	2231	LMIC.opmode = (LMIC.opmode & ~(OP_POLL\|OP_RNDTX)) \| OP_TXRXPEND \| OP_NEXTCHNL;
mluis	1:d3b7bde3995c	2232	updateTx(txbeg);
mluis	1:d3b7bde3995c	2233	os_radio(RADIO_TX);
mluis	0:62d1edcc13d1	2234	return;
mluis	0:62d1edcc13d1	2235	}
mluis	1:d3b7bde3995c	2236	// Cannot yet TX
mluis	1:d3b7bde3995c	2237	if( (LMIC.opmode & OP_TRACK) == 0 )
mluis	1:d3b7bde3995c	2238	goto txdelay; // We don't track the beacon - nothing else to do - so wait for the time to TX
mluis	1:d3b7bde3995c	2239	// Consider RX tasks
mluis	1:d3b7bde3995c	2240	if( txbeg == 0 ) // zero indicates no TX pending
mluis	1:d3b7bde3995c	2241	txbeg += 1; // TX delayed by one tick (insignificant amount of time)
mluis	0:62d1edcc13d1	2242	} else {
mluis	1:d3b7bde3995c	2243	// No TX pending - no scheduled RX
mluis	1:d3b7bde3995c	2244	if( (LMIC.opmode & OP_TRACK) == 0 )
mluis	1:d3b7bde3995c	2245	return;
mluis	0:62d1edcc13d1	2246	}
mluis	0:62d1edcc13d1	2247
mluis	0:62d1edcc13d1	2248	// Are we pingable?
mluis	0:62d1edcc13d1	2249	checkrx:
mluis	0:62d1edcc13d1	2250	if( (LMIC.opmode & OP_PINGINI) != 0 ) {
mluis	1:d3b7bde3995c	2251	// One more RX slot in this beacon period?
mluis	1:d3b7bde3995c	2252	if( rxschedNext(&LMIC.ping, now+RX_RAMPUP) ) {
mluis	1:d3b7bde3995c	2253	if( txbeg != 0 && (txbeg - LMIC.ping.rxtime) < 0 )
mluis	1:d3b7bde3995c	2254	goto txdelay;
mluis	1:d3b7bde3995c	2255	LMIC.rxsyms = LMIC.ping.rxsyms;
mluis	1:d3b7bde3995c	2256	LMIC.rxtime = LMIC.ping.rxtime;
mluis	1:d3b7bde3995c	2257	LMIC.freq = LMIC.ping.freq;
mluis	1:d3b7bde3995c	2258	LMIC.rps = dndr2rps(LMIC.ping.dr);
mluis	1:d3b7bde3995c	2259	LMIC.dataLen = 0;
mluis	1:d3b7bde3995c	2260	ASSERT(LMIC.rxtime - now+RX_RAMPUP >= 0 );
mluis	1:d3b7bde3995c	2261	os_setTimedCallback(&LMIC.osjob, LMIC.rxtime - RX_RAMPUP, FUNC_ADDR(startRxPing));
mluis	1:d3b7bde3995c	2262	return;
mluis	1:d3b7bde3995c	2263	}
mluis	1:d3b7bde3995c	2264	// no - just wait for the beacon
mluis	0:62d1edcc13d1	2265	}
mluis	0:62d1edcc13d1	2266
mluis	0:62d1edcc13d1	2267	if( txbeg != 0 && (txbeg - rxtime) < 0 )
mluis	1:d3b7bde3995c	2268	goto txdelay;
mluis	0:62d1edcc13d1	2269
mluis	0:62d1edcc13d1	2270	setBcnRxParams();
mluis	0:62d1edcc13d1	2271	LMIC.rxsyms = LMIC.bcnRxsyms;
mluis	0:62d1edcc13d1	2272	LMIC.rxtime = LMIC.bcnRxtime;
mluis	0:62d1edcc13d1	2273	if( now - rxtime >= 0 ) {
mluis	1:d3b7bde3995c	2274	LMIC.osjob.func = FUNC_ADDR(processBeacon);
mluis	1:d3b7bde3995c	2275	os_radio(RADIO_RX);
mluis	1:d3b7bde3995c	2276	return;
mluis	0:62d1edcc13d1	2277	}
mluis	0:62d1edcc13d1	2278	os_setTimedCallback(&LMIC.osjob, rxtime, FUNC_ADDR(startRxBcn));
mluis	0:62d1edcc13d1	2279	return;
mluis	0:62d1edcc13d1	2280
mluis	0:62d1edcc13d1	2281	txdelay:
mluis	0:62d1edcc13d1	2282	EV(devCond, INFO, (e_.reason = EV::devCond_t::TX_DELAY,
mluis	1:d3b7bde3995c	2283	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	2284	e_.info = osticks2ms(txbeg-now),
mluis	1:d3b7bde3995c	2285	e_.info2 = LMIC.seqnoUp-1));
mluis	0:62d1edcc13d1	2286	os_setTimedCallback(&LMIC.osjob, txbeg-TX_RAMPUP, FUNC_ADDR(runEngineUpdate));
mluis	0:62d1edcc13d1	2287	}
mluis	0:62d1edcc13d1	2288
mluis	0:62d1edcc13d1	2289
tmulrooney	6:eed5fd627a2b	2290	void LMIC_setAdrMode (bit_t enabled)
tmulrooney	6:eed5fd627a2b	2291	{
tmulrooney	6:eed5fd627a2b	2292	debug("LMIC LMIC_setAdrMode enter\r\n");
mluis	0:62d1edcc13d1	2293	LMIC.adrEnabled = enabled ? FCT_ADREN : 0;
mluis	0:62d1edcc13d1	2294	}
mluis	0:62d1edcc13d1	2295
mluis	0:62d1edcc13d1	2296
mluis	0:62d1edcc13d1	2297	// Should we have/need an ext. API like this?
tmulrooney	6:eed5fd627a2b	2298	void LMIC_setDrTxpow (dr_t dr, s1_t txpow)
tmulrooney	6:eed5fd627a2b	2299	{
tmulrooney	6:eed5fd627a2b	2300	debug("LMIC LMIC_setDrTxpow enter\r\n");
mluis	0:62d1edcc13d1	2301	setDrTxpow(DRCHG_SET, dr, txpow);
mluis	0:62d1edcc13d1	2302	}
mluis	0:62d1edcc13d1	2303
mluis	0:62d1edcc13d1	2304
tmulrooney	6:eed5fd627a2b	2305	void LMIC_shutdown (void)
tmulrooney	6:eed5fd627a2b	2306	{
tmulrooney	6:eed5fd627a2b	2307	debug("LMIC LMIC_shutdown enter\r\n");
mluis	0:62d1edcc13d1	2308	os_clearCallback(&LMIC.osjob);
mluis	0:62d1edcc13d1	2309	os_radio(RADIO_RST);
mluis	0:62d1edcc13d1	2310	LMIC.opmode \|= OP_SHUTDOWN;
mluis	0:62d1edcc13d1	2311	}
mluis	0:62d1edcc13d1	2312
mluis	0:62d1edcc13d1	2313
tmulrooney	6:eed5fd627a2b	2314	void LMIC_reset (void)
tmulrooney	6:eed5fd627a2b	2315	{
tmulrooney	6:eed5fd627a2b	2316	debug("LMIC LMIC_reset enter\r\n");
mluis	0:62d1edcc13d1	2317	EV(devCond, INFO, (e_.reason = EV::devCond_t::LMIC_EV,
mluis	1:d3b7bde3995c	2318	e_.eui = MAIN::CDEV->getEui(),
mluis	1:d3b7bde3995c	2319	e_.info = EV_RESET));
mluis	0:62d1edcc13d1	2320	os_radio(RADIO_RST);
mluis	0:62d1edcc13d1	2321	os_clearCallback(&LMIC.osjob);
mluis	0:62d1edcc13d1	2322
mluis	0:62d1edcc13d1	2323	os_clearMem((xref2u1_t)&LMIC,SIZEOFEXPR(LMIC));
mluis	1:d3b7bde3995c	2324	LMIC.devaddr = 0;
mluis	1:d3b7bde3995c	2325	LMIC.devNonce = os_getRndU2();
mluis	1:d3b7bde3995c	2326	LMIC.opmode = OP_NONE;
mluis	1:d3b7bde3995c	2327	LMIC.errcr = CR_4_5;
mluis	1:d3b7bde3995c	2328	LMIC.adrEnabled = FCT_ADREN;
mluis	1:d3b7bde3995c	2329	LMIC.dn2Dr = DR_DNW2; // we need this for 2nd DN window of join accept
mluis	1:d3b7bde3995c	2330	LMIC.dn2Freq = FREQ_DNW2; // ditto
mluis	1:d3b7bde3995c	2331	LMIC.ping.freq = FREQ_PING; // defaults for ping
mluis	1:d3b7bde3995c	2332	LMIC.ping.dr = DR_PING; // ditto
mluis	1:d3b7bde3995c	2333	LMIC.ping.intvExp = 0xFF;
mluis	1:d3b7bde3995c	2334	#if defined(CFG_us915)
mluis	0:62d1edcc13d1	2335	initDefaultChannels();
mluis	0:62d1edcc13d1	2336	#endif
mluis	1:d3b7bde3995c	2337	DO_DEVDB(LMIC.devaddr, devaddr);
mluis	1:d3b7bde3995c	2338	DO_DEVDB(LMIC.devNonce, devNonce);
mluis	1:d3b7bde3995c	2339	DO_DEVDB(LMIC.dn2Dr, dn2Dr);
mluis	1:d3b7bde3995c	2340	DO_DEVDB(LMIC.dn2Freq, dn2Freq);
mluis	1:d3b7bde3995c	2341	DO_DEVDB(LMIC.ping.freq, pingFreq);
mluis	1:d3b7bde3995c	2342	DO_DEVDB(LMIC.ping.dr, pingDr);
mluis	1:d3b7bde3995c	2343	DO_DEVDB(LMIC.ping.intvExp, pingIntvExp);
mluis	0:62d1edcc13d1	2344	}
mluis	0:62d1edcc13d1	2345
mluis	0:62d1edcc13d1	2346
mluis	0:62d1edcc13d1	2347	void LMIC_init (void) {
tmulrooney	5:464c1f2d6cbb	2348	debug("LMIC_init enter\r\n");
mluis	0:62d1edcc13d1	2349	LMIC.opmode = OP_SHUTDOWN;
mluis	0:62d1edcc13d1	2350	}
mluis	0:62d1edcc13d1	2351
mluis	0:62d1edcc13d1	2352
tmulrooney	6:eed5fd627a2b	2353	void LMIC_clrTxData (void)
tmulrooney	6:eed5fd627a2b	2354	{
tmulrooney	6:eed5fd627a2b	2355	debug("LMIC LMIC_clrTxData enter\r\n");
mluis	0:62d1edcc13d1	2356	LMIC.opmode &= ~(OP_TXDATA\|OP_TXRXPEND\|OP_POLL);
mluis	0:62d1edcc13d1	2357	LMIC.pendTxLen = 0;
mluis	0:62d1edcc13d1	2358	if( (LMIC.opmode & (OP_JOINING\|OP_SCAN)) != 0 ) // do not interfere with JOINING
mluis	1:d3b7bde3995c	2359	return;
mluis	0:62d1edcc13d1	2360	os_clearCallback(&LMIC.osjob);
mluis	0:62d1edcc13d1	2361	os_radio(RADIO_RST);
mluis	0:62d1edcc13d1	2362	engineUpdate();
mluis	0:62d1edcc13d1	2363	}
mluis	0:62d1edcc13d1	2364
mluis	0:62d1edcc13d1	2365
tmulrooney	6:eed5fd627a2b	2366	void LMIC_setTxData (void)
tmulrooney	6:eed5fd627a2b	2367	{
tmulrooney	6:eed5fd627a2b	2368	debug("LMIC LMIC_setTxData enter\r\n");
mluis	0:62d1edcc13d1	2369	LMIC.opmode \|= OP_TXDATA;
mluis	0:62d1edcc13d1	2370	if( (LMIC.opmode & OP_JOINING) == 0 )
mluis	1:d3b7bde3995c	2371	LMIC.txCnt = 0; // cancel any ongoing TX/RX retries
mluis	0:62d1edcc13d1	2372	engineUpdate();
mluis	0:62d1edcc13d1	2373	}
mluis	0:62d1edcc13d1	2374
mluis	0:62d1edcc13d1	2375
mluis	0:62d1edcc13d1	2376	//
tmulrooney	6:eed5fd627a2b	2377	int LMIC_setTxData2 (u1_t port, xref2u1_t data, u1_t dlen, u1_t confirmed)
tmulrooney	6:eed5fd627a2b	2378	{
tmulrooney	6:eed5fd627a2b	2379	debug("LMIC LMIC_setTxData2 enter\r\n");
mluis	0:62d1edcc13d1	2380	if( dlen > SIZEOFEXPR(LMIC.pendTxData) )
mluis	1:d3b7bde3995c	2381	return -2;
mluis	0:62d1edcc13d1	2382	if( data != (xref2u1_t)0 )
mluis	1:d3b7bde3995c	2383	os_copyMem(LMIC.pendTxData, data, dlen);
mluis	0:62d1edcc13d1	2384	LMIC.pendTxConf = confirmed;
mluis	0:62d1edcc13d1	2385	LMIC.pendTxPort = port;
mluis	0:62d1edcc13d1	2386	LMIC.pendTxLen = dlen;
mluis	0:62d1edcc13d1	2387	LMIC_setTxData();
mluis	0:62d1edcc13d1	2388	return 0;
mluis	0:62d1edcc13d1	2389	}
mluis	0:62d1edcc13d1	2390
mluis	0:62d1edcc13d1	2391
mluis	0:62d1edcc13d1	2392	// Send a payload-less message to signal device is alive
tmulrooney	6:eed5fd627a2b	2393	void LMIC_sendAlive (void)
tmulrooney	6:eed5fd627a2b	2394	{
tmulrooney	6:eed5fd627a2b	2395	debug("LMIC LMIC_sendAlive enter\r\n");
mluis	0:62d1edcc13d1	2396	LMIC.opmode \|= OP_POLL;
mluis	0:62d1edcc13d1	2397	engineUpdate();
mluis	0:62d1edcc13d1	2398	}
mluis	0:62d1edcc13d1	2399
mluis	0:62d1edcc13d1	2400
mluis	0:62d1edcc13d1	2401	// Check if other networks are around.
tmulrooney	6:eed5fd627a2b	2402	void LMIC_tryRejoin (void)
tmulrooney	6:eed5fd627a2b	2403	{
tmulrooney	6:eed5fd627a2b	2404	debug("LMIC LMIC_tryRejoin enter\r\n");
mluis	0:62d1edcc13d1	2405	LMIC.opmode \|= OP_REJOIN;
mluis	0:62d1edcc13d1	2406	engineUpdate();
mluis	0:62d1edcc13d1	2407	}
mluis	0:62d1edcc13d1	2408
mluis	1:d3b7bde3995c	2409	//! \brief Setup given session keys
mluis	1:d3b7bde3995c	2410	//! and put the MAC in a state as if
mluis	1:d3b7bde3995c	2411	//! a join request/accept would have negotiated just these keys.
mluis	1:d3b7bde3995c	2412	//! It is crucial that the combinations `devaddr/nwkkey` and `devaddr/artkey`
mluis	1:d3b7bde3995c	2413	//! are unique within the network identified by `netid`.
mluis	1:d3b7bde3995c	2414	//! NOTE: on Harvard architectures when session keys are in flash:
mluis	1:d3b7bde3995c	2415	//! Caller has to fill in LMIC.{nwk,art}Key before and pass {nwk,art}Key are NULL
mluis	1:d3b7bde3995c	2416	//! \param netid a 24 bit number describing the network id this device is using
mluis	1:d3b7bde3995c	2417	//! \param devaddr the 32 bit session address of the device. It is strongly recommended
mluis	1:d3b7bde3995c	2418	//! to ensure that different devices use different numbers with high probability.
mluis	1:d3b7bde3995c	2419	//! \param nwkKey the 16 byte network session key used for message integrity.
mluis	1:d3b7bde3995c	2420	//! If NULL the caller has copied the key into `LMIC.nwkKey` before.
mluis	1:d3b7bde3995c	2421	//! \param artKey the 16 byte application router session key used for message confidentiality.
mluis	1:d3b7bde3995c	2422	//! If NULL the caller has copied the key into `LMIC.artKey` before.
tmulrooney	6:eed5fd627a2b	2423	void LMIC_setSession (u4_t netid, devaddr_t devaddr, xref2u1_t nwkKey, xref2u1_t artKey)
tmulrooney	6:eed5fd627a2b	2424	{
tmulrooney	6:eed5fd627a2b	2425	debug("LMIC LMIC_setSession enter\r\n");
mluis	0:62d1edcc13d1	2426	LMIC.netid = netid;
mluis	0:62d1edcc13d1	2427	LMIC.devaddr = devaddr;
mluis	1:d3b7bde3995c	2428	if( nwkKey != (xref2u1_t)0 )
mluis	1:d3b7bde3995c	2429	os_copyMem(LMIC.nwkKey, nwkKey, 16);
mluis	1:d3b7bde3995c	2430	if( artKey != (xref2u1_t)0 )
mluis	1:d3b7bde3995c	2431	os_copyMem(LMIC.artKey, artKey, 16);
mluis	0:62d1edcc13d1	2432
mluis	1:d3b7bde3995c	2433	#if defined(CFG_eu868)
mluis	0:62d1edcc13d1	2434	initDefaultChannels(0);
mluis	0:62d1edcc13d1	2435	#endif
mluis	1:d3b7bde3995c	2436
mluis	1:d3b7bde3995c	2437	LMIC.opmode &= ~(OP_JOINING\|OP_TRACK\|OP_REJOIN\|OP_TXRXPEND\|OP_PINGINI);
mluis	1:d3b7bde3995c	2438	LMIC.opmode \|= OP_NEXTCHNL;
mluis	0:62d1edcc13d1	2439	stateJustJoined();
mluis	0:62d1edcc13d1	2440	}
mluis	1:d3b7bde3995c	2441
mluis	1:d3b7bde3995c	2442	// Enable/disable link check validation.
mluis	1:d3b7bde3995c	2443	// LMIC sets the ADRACKREQ bit in UP frames if there were no DN frames
mluis	1:d3b7bde3995c	2444	// for a while. It expects the network to provide a DN message to prove
mluis	1:d3b7bde3995c	2445	// connectivity with a span of UP frames. If this no such prove is coming
mluis	1:d3b7bde3995c	2446	// then the datarate is lowered and a LINK_DEAD event is generated.
mluis	1:d3b7bde3995c	2447	// This mode can be disabled and no connectivity prove (ADRACKREQ) is requested
mluis	1:d3b7bde3995c	2448	// nor is the datarate changed.
mluis	1:d3b7bde3995c	2449	// This must be called only if a session is established (e.g. after EV_JOINED)
tmulrooney	6:eed5fd627a2b	2450	void LMIC_setLinkCheckMode (bit_t enabled)
tmulrooney	6:eed5fd627a2b	2451	{
tmulrooney	6:eed5fd627a2b	2452	debug("LMIC LMIC_setLinkCheckMode enter\r\n");
mluis	1:d3b7bde3995c	2453	LMIC.adrChanged = 0;
mluis	1:d3b7bde3995c	2454	LMIC.adrAckReq = enabled ? LINK_CHECK_INIT : LINK_CHECK_OFF;
mluis	1:d3b7bde3995c	2455	}
mluis	1:d3b7bde3995c	2456
dudmuck	2:974cafbfb159	2457	void LMIC_reverse_memcpy(u1_t dst, const u1_t src, size_t n)
dudmuck	2:974cafbfb159	2458	{
dudmuck	2:974cafbfb159	2459	size_t i;
dudmuck	2:974cafbfb159	2460
dudmuck	2:974cafbfb159	2461	for (i=0; i < n; ++i)
dudmuck	2:974cafbfb159	2462	dst[n-1-i] = src[i];
dudmuck	2:974cafbfb159	2463	}

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	23 Feb 2016
Imports:	0
Forks:	1
Commits:	8
Dependents:	1
Dependencies:	0
Followers:	1

lmic.cpp@7:29058a7ccf23, 2016-02-25 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning