From 4d9147bd1bced5ce2254e258946557ca9098b9e0 Mon Sep 17 00:00:00 2001 From: Imanol-Mikel Barba Sabariego Date: Wed, 21 May 2014 12:55:55 +0000 Subject: [PATCH] --- DUREX/Em/DUREX-STUBS.c | 46 ++++++++++++++++++++++++++++++++++++++++++++++ DUREX/Em/DUREX.c | 540 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ DUREX/Em/DUREX.h | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ DUREX/Em/Em_Message.h | 182 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ DUREX/Em/Em_Types.h | 17 +++++++++++++++++ DUREX/Em/durex.json | 247 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ DUREX/Schema-Imports/system@emmoco.com/System.ems | 72 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ DUREXLaunchpad/.externalToolBuilders/DUREX LaunchPad Builder.launch | 14 ++++++++++++++ DUREXLaunchpad/.externalToolBuilders/DUREX LaunchPad Cleaner.launch | 10 ++++++++++ 9 files changed, 1196 insertions(+), 0 deletions(-) create mode 100644 DUREX/Em/DUREX-STUBS.c create mode 100644 DUREX/Em/DUREX.c create mode 100644 DUREX/Em/DUREX.h create mode 100644 DUREX/Em/Em_Message.h create mode 100644 DUREX/Em/Em_Types.h create mode 100644 DUREX/Em/durex.json create mode 100644 DUREX/Schema-Imports/system@emmoco.com/System.ems create mode 100644 DUREXLaunchpad/.externalToolBuilders/DUREX LaunchPad Builder.launch create mode 100644 DUREXLaunchpad/.externalToolBuilders/DUREX LaunchPad Cleaner.launch diff --git a/DUREX/Em/DUREX-STUBS.c b/DUREX/Em/DUREX-STUBS.c new file mode 100644 index 0000000..4d12809 --- /dev/null +++ b/DUREX/Em/DUREX-STUBS.c @@ -0,0 +1,46 @@ +/**** DO NOT EDIT -- this file has been automatically generated from @emmoco.com.DUREX on 2014-05-14T16:44:10T ****/ +/**** protocolLevel = 13, toolsVersion = 13.4.1.201311121909 ****/ + +#include "DUREX.h" + +#ifdef DUREX_STUBS_ /* enables optional inclusion of application stubs */ + +/* Copy the function skeletons below into your own application source file */ + +void DUREX_connectHandler(void) { + /* TODO: application is now connected */ +} + +void DUREX_disconnectHandler(void) { + /* TODO: application is now disconnected */ +} + +void DUREX_numBytes_fetch(DUREX_numBytes_t* output) { + /* TODO: read resource 'numBytes' into 'output' */ +} + +void DUREX_numBytes_store(DUREX_numBytes_t* input) { + /* TODO: write resource 'numBytes' from 'input' */ +} + +void DUREX_data_fetch(DUREX_data_t output) { + /* TODO: read resource 'data' into 'output' */ +} + +void DUREX_data_store(DUREX_data_t input) { + /* TODO: write resource 'data' from 'input' */ +} + +void DUREX_numPackets_fetch(DUREX_numPackets_t* output) { + /* TODO: read resource 'numPackets' into 'output' */ +} + +void DUREX_numPackets_store(DUREX_numPackets_t* input) { + /* TODO: write resource 'numPackets' from 'input' */ +} + +void DUREX_messageAvailable_fetch(DUREX_messageAvailable_t* output) { + /* TODO: read resource 'messageAvailable' into 'output' */ +} + +#endif /* application stubs */ diff --git a/DUREX/Em/DUREX.c b/DUREX/Em/DUREX.c new file mode 100644 index 0000000..8ee047a --- /dev/null +++ b/DUREX/Em/DUREX.c @@ -0,0 +1,540 @@ +/**** DO NOT EDIT -- this file has been automatically generated from @emmoco.com.DUREX on 2014-05-14T16:44:10T ****/ +/**** protocolLevel = 13, toolsVersion = 13.4.1.201311121909 ****/ + +#include "Em_Message.h" +#include "DUREX.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define Em_Message_protocolLevel 13 + +typedef struct Em_App_Message { + uint8_t dummy[3]; + uint8_t sot; + Em_Message_Header hdr; + uint8_t data[229]; +} Em_App_Message; + +const uint8_t Em_App_hash[] = {28, 106, 83, 11, 248, 159, 192, 243, 66, 193, 233, 148, 55, 208, 191, 77, 13, 0, ((sizeof(struct{uint8_t f1; uint16_t f2;}) - sizeof(uint16_t)) << 4) | (sizeof(struct{uint8_t f1; uint32_t f2;}) - sizeof(uint32_t))}; + +const uint8_t Em_App_build[] = {208, 202, 48, 251, 69, 1, 0, 0}; + +#define Em_App_APP_RESOURCE_COUNT 4 +#define Em_App_SYS_RESOURCE_COUNT 9 + +#define Em_App_ACCEPT DUREX_accept +#define Em_App_ACTIVATEPARAMETERS DUREX_activateParameters +#define Em_App_BROADCASTOFF DUREX_broadcastOff +#define Em_App_DISCONNECT DUREX_disconnect +#define Em_App_PAIRINGON DUREX_pairingOn +#define Em_App_PAIRINGOFF DUREX_pairingOff +#define Em_App_RESET DUREX_reset +#define Em_App_SETDEVICENAME DUREX_setDeviceName +#define Em_App_START DUREX_start + +#define Em_App_CONNECTHANDLER DUREX_connectHandler +#define Em_App_DISCONNECTHANDLER DUREX_disconnectHandler + +#define Em_App_MAX_INDICATOR 2 + +/* BEGIN common code */ + +enum {Em_App_IDLE, Em_App_STARTING, Em_App_DISCONNECTED, Em_App_CONNECTED}; + +typedef struct Em_App_Indicator { + uint8_t dummy[3]; + uint8_t sot; + Em_Message_Header hdr; + uint8_t data[Em_Message_INDSIZE]; +} Em_App_Indicator; + +union { uint32_t align; Em_App_Message msg; } Em_App_msg_u; +union { uint32_t align; Em_App_Indicator ind; } Em_App_ind_u; +#define Em_App_msg Em_App_msg_u.msg +#define Em_App_ind Em_App_ind_u.ind + +void (*Em_App_pdHdlr)(void); + +const uint16_t Em_App_endian = 0x0100; + +Em_Message_Size Em_App_recvIdx; +Em_Message_Size Em_App_recvSize; +Em_Message_Size Em_App_xmitIdx; +Em_Message_Size Em_App_xmitSize; + +uint8_t Em_App_state = Em_App_IDLE; +int32_t Em_App_fileIndex = 0; +uint32_t Em_App_xmitMask = 0; + +uint8_t* Em_App_valp; +uint8_t* Em_App_bufp; +const char* Em_App_desc; + +uint8_t* Em_App_inBuf = (uint8_t*)&Em_App_msg.hdr; +uint8_t* Em_App_outBuf = 0; + +uint8_t* _Em_Message_rxBuf = 0; +uint8_t _Em_Message_rxCnt = 0; + +uint8_t* _Em_Message_txBuf = 0; +uint8_t _Em_Message_txCnt = 0; + +#define Em_App_DEVNAME_LEN 9 +const char* Em_App_devName = 0; + +void Em_App_fetchDispatch(void); +void Em_Message_marshallToBuf(uint8_t* valp, uint8_t* bufp, const char* desc); +void Em_Message_marshallToVal(uint8_t* valp, uint8_t* bufp, const char* desc); +void Em_App_storeDispatch(void); +void Em_App_sendIndicator(Em_Message_ResId indId); +void Em_App_sendResponse(Em_Message_Kind kind, Em_Message_Size size); +void Em_App_startIndSend(void); +void Em_App_startResSend(void); +void Em_App_sysFetchDispatch(void); +void Em_App_sysStoreDispatch(void); +bool Em_App_xmitReady(Em_Message_ResId indId); + +void Em_Message_nextXmit(void) { + uint8_t key = Em_Hal_lock(); + if (Em_App_xmitMask != 0) { + uint8_t i; + uint32_t m; + for (i = 0, m = 0x1; i < Em_App_MAX_INDICATOR; i++, m <<= 1) { + if (Em_App_xmitMask & m) { + Em_App_xmitMask &= ~m; + if (i == 0) { + Em_App_startResSend(); + } + else { + Em_App_sendIndicator(i - 1); + } + break; + } + } + } + Em_Hal_unlock(key); +} + +void Em_Message_restart(void) { + Em_App_START(); +} + +void Em_App_ACCEPT(bool enable) { + if (Em_App_state == Em_App_CONNECTED) { + return; + } + Em_App_ind.sot = 0; + Em_App_ind.hdr.kind = Em_Message_ACCEPT; + Em_App_ind.hdr.size = sizeof (Em_Message_Header); + Em_App_ind.hdr.resId = enable; + Em_App_startIndSend(); +} + +void Em_App_ACTIVATEPARAMETERS(uint8_t group) { + if (Em_App_state == Em_App_IDLE || Em_App_state == Em_App_STARTING) { + return; + } + Em_App_ind.sot = 0; + Em_App_ind.hdr.kind = Em_Message_ACTIVE_PARAMS; + Em_App_ind.hdr.size = sizeof (Em_Message_Header); + Em_App_ind.hdr.resId = group; + Em_App_startIndSend(); +} + +void Em_App_BROADCASTOFF(void) { + Em_App_ind.sot = 0; + Em_App_ind.hdr.kind = Em_Message_INDICATOR; + Em_App_ind.hdr.size = sizeof (Em_Message_Header); + Em_App_ind.hdr.resId = 0; + Em_App_startIndSend(); +} + +void Em_App_DISCONNECT(void) { + if (Em_App_state != Em_App_CONNECTED) { + return; + } + Em_App_state = Em_App_DISCONNECTED; + Em_App_ind.sot = 0; + Em_App_ind.hdr.kind = Em_Message_DISCONNECT; + Em_App_ind.hdr.size = sizeof (Em_Message_Header); + Em_App_ind.hdr.resId = 0; + Em_App_startIndSend(); +} + +void Em_Message_dispatch(void) { + if (Em_App_state == Em_App_IDLE) { + return; + } + switch (Em_App_msg.hdr.kind) { + case Em_Message_CONNECT: + Em_App_state = Em_App_CONNECTED; + Em_App_CONNECTHANDLER(); + break; + case Em_Message_DISCONNECT: + Em_App_state = Em_App_DISCONNECTED; + Em_App_DISCONNECTHANDLER(); + break; + case Em_Message_PAIRING_DONE: + if (Em_App_pdHdlr) { + (*Em_App_pdHdlr)(); + } + break; + case Em_Message_FETCH: + if (Em_App_msg.hdr.resId < 0x80) { + Em_App_fetchDispatch(); + } + else { + Em_App_sysFetchDispatch(); + } + break; + case Em_Message_STORE: + if (Em_App_msg.hdr.resId < 0x80) { + Em_App_storeDispatch(); + } + else { + Em_App_sysStoreDispatch(); + } + break; + } +} + +void Em_App_marshallToBuf() { + char ch; + while ((ch = *Em_App_desc++)) { + switch (ch) { + case '0' : { + *Em_App_bufp++ = 0; + break; + } + case '1' : { + *Em_App_bufp++ = *Em_App_valp & 0xFF; + break; + } + case '2' : { + uint16_t v16 = *(uint16_t*)Em_App_valp; + *Em_App_bufp++ = v16 & 0xFF; + *Em_App_bufp++ = (v16 >> 8) & 0xFF; + break; + } + case '4' : { + if (((uint32_t)Em_App_valp & 0x1)) Em_App_valp++; + uint32_t v32 = *(uint32_t*)Em_App_valp++; + *Em_App_bufp++ = v32 & 0xFF; + *Em_App_bufp++ = (v32 >> 8) & 0xFF; + *Em_App_bufp++ = (v32 >> 16) & 0xFF; + *Em_App_bufp++ = (v32 >> 24) & 0xFF; + break; + } + } + Em_App_valp += 1; + } +} + +void Em_App_marshallToVal() { + char ch; + while ((ch = *Em_App_desc++)) { + switch (ch) { + case '0' : { + *Em_App_valp = 0; + Em_App_bufp += 1; + break; + } + case '1' : { + *Em_App_valp = *Em_App_bufp++ & 0xFF; + break; + } + case '2' : { + uint16_t v16 = *Em_App_bufp++ & 0xFF; + v16 |= (*Em_App_bufp++ << 8); + *(uint16_t*)Em_App_valp = v16; + break; + } + case '4' : { + if (((uint32_t)Em_App_valp & 0x1)) Em_App_valp++; + uint32_t v32 = (uint32_t)*Em_App_bufp++ & 0xFF; + v32 |= ((uint32_t)*Em_App_bufp++ << 8); + v32 |= ((uint32_t)*Em_App_bufp++ << 16); + v32 |= ((uint32_t)*Em_App_bufp++ << 24); + *(uint32_t*)Em_App_valp++ = v32; + break; + } + } + Em_App_valp += 1; + } +} + +void Em_App_PAIRINGOFF(void(*handler)(void)) { + Em_App_PAIRINGON(0, handler); +} + +void Em_App_PAIRINGON(uint8_t secs, void(*handler)(void)) { + if (Em_App_state != Em_App_DISCONNECTED) { + return; + } + Em_App_pdHdlr = handler; + Em_App_ind.sot = 0; + Em_App_ind.hdr.kind = Em_Message_PAIRING; + Em_App_ind.hdr.size = sizeof (Em_Message_Header); + Em_App_ind.hdr.resId = secs; + Em_App_startIndSend(); +} + +void Em_App_RESET(void) { + Em_Hal_reset(); + _Em_Message_rxBuf = _Em_Message_txBuf = 0; + _Em_Message_rxCnt = _Em_Message_txCnt = 0; + Em_App_recvIdx = Em_App_recvSize = Em_App_xmitIdx = Em_App_xmitSize = 0; + Em_App_state = Em_App_IDLE; + Em_App_fileIndex = 0; + Em_App_xmitMask = 0; +} + +void Em_App_SETDEVICENAME(const char* name) { + Em_App_devName = name; +} + +void Em_App_START(void) { + Em_App_RESET(); + Em_App_state = Em_App_STARTING; +} + +void Em_App_sendResponse(Em_Message_Kind kind, Em_Message_Size size) { + if (Em_App_state != Em_App_IDLE) { + Em_App_msg.sot = 0; + Em_App_msg.hdr.kind = kind; + Em_App_msg.hdr.size = size + sizeof (Em_Message_Header); + if (Em_App_xmitReady(0)) { + Em_App_startResSend(); + } + } +} + +void Em_App_startIndSend(void) { + Em_App_outBuf = (uint8_t*)&Em_App_ind.sot; + Em_App_xmitSize = Em_App_ind.hdr.size + 1; + Em_App_xmitIdx = 0; + Em_Hal_startSend(); +} + +void Em_App_startResSend(void) { + Em_App_outBuf = (uint8_t*)&Em_App_msg.sot; + Em_App_xmitSize = Em_App_msg.hdr.size + 1; + Em_App_xmitIdx = 0; + Em_Hal_startSend(); +} + +void Em_App_sysFetchDispatch(void) { + uint8_t size = 0; + int i, j; + switch (Em_App_msg.hdr.resId) { + case Em_Message_SYS_SCHEMA_HASH: + for (i = 0; i < sizeof (Em_App_hash); i++) { + Em_App_msg.data[i] = Em_App_hash[i]; + } + Em_App_msg.data[sizeof (Em_App_hash)] = *((uint8_t*)&Em_App_endian); + size = sizeof (Em_App_hash) + 1; + break; + case Em_Message_SYS_MCM_NAME: + if (Em_App_devName) { + for (i = 0; i < Em_App_DEVNAME_LEN; i++) { + if ((Em_App_msg.data[i] = Em_App_devName[i]) == 0) { + break; + } + } + for (j = i; j < Em_App_DEVNAME_LEN; j++) { + Em_App_msg.data[j] = 0; + } + size = Em_App_DEVNAME_LEN; + } + break; + case Em_Message_SYS_EAP_PROTOCOL_LEVEL: + *((Em_Message_protocolLevel_t*)Em_App_msg.data) = Em_Message_protocolLevel; + size = sizeof (Em_Message_protocolLevel_t); + break; + case Em_Message_SYS_EAP_BUILD_DATE: + for (i = 0; i < sizeof (Em_App_build); i++) { + Em_App_msg.data[i] = Em_App_build[i]; + } + size = sizeof (Em_App_build); + break; + case Em_Message_SYS_RESOURCE_COUNT: + Em_App_msg.data[0] = Em_App_APP_RESOURCE_COUNT; + Em_App_msg.data[1] = Em_App_SYS_RESOURCE_COUNT; + size = 2; + break; + } + Em_App_sendResponse(Em_Message_FETCH_DONE, size); +} + +void Em_App_sysStoreDispatch(void) { + switch (Em_App_msg.hdr.resId) { + case Em_Message_SYS_FILE_INDEX_RESET: + Em_App_fileIndex = 0; + break; + } + Em_App_sendResponse(Em_Message_STORE_DONE, 0); +} + +bool Em_App_xmitReady(Em_Message_ResId indId) { + uint8_t key = Em_Hal_lock(); + bool res = _Em_Message_txBuf == 0 && Em_App_xmitMask == 0; + if (!res) { + Em_App_xmitMask |= (1 << indId); + } + Em_Hal_unlock(key); + return res; +} + +/* END common code */ + +void Em_App_fetchDispatch(void) { + uint8_t size = 0; + switch (Em_App_msg.hdr.resId) { + case 0: { + break; + } + case 1: { +#ifdef Em_16BIT + DUREX_numBytes_t val; + Em_App_valp = (uint8_t*)&val; + Em_App_bufp = Em_App_msg.data; + Em_App_desc = "1"; + DUREX_numBytes_fetch(&val); + Em_App_marshallToBuf(); +#else + DUREX_numBytes_fetch((void*)Em_App_msg.data); +#endif + size = 1; + break; + } + case 2: { +#ifdef Em_16BIT + DUREX_data_t val; + Em_App_valp = (uint8_t*)&val; + Em_App_bufp = Em_App_msg.data; + Em_App_desc = "*\xe5[1]"; + DUREX_data_fetch(&val); + Em_App_marshallToBuf(); +#else + DUREX_data_fetch((void*)Em_App_msg.data); +#endif + size = 229; + break; + } + case 3: { +#ifdef Em_16BIT + DUREX_numPackets_t val; + Em_App_valp = (uint8_t*)&val; + Em_App_bufp = Em_App_msg.data; + Em_App_desc = "1"; + DUREX_numPackets_fetch(&val); + Em_App_marshallToBuf(); +#else + DUREX_numPackets_fetch((void*)Em_App_msg.data); +#endif + size = 1; + break; + } + case 4: { +#ifdef Em_16BIT + DUREX_messageAvailable_t val; + Em_App_valp = (uint8_t*)&val; + Em_App_bufp = Em_App_msg.data; + Em_App_desc = "1"; + DUREX_messageAvailable_fetch(&val); + Em_App_marshallToBuf(); +#else + DUREX_messageAvailable_fetch((void*)Em_App_msg.data); +#endif + size = 1; + break; + } + } + Em_App_sendResponse(Em_Message_FETCH_DONE, size); +} + +void Em_App_storeDispatch(void) { + switch (Em_App_msg.hdr.resId) { + case 0: { + break; + } + case 1: { +#ifdef Em_16BIT + DUREX_numBytes_t val; + Em_App_valp = (uint8_t*)&val; + Em_App_bufp = Em_App_msg.data; + Em_App_desc = "1"; + Em_App_marshallToVal(); + DUREX_numBytes_store(&val); +#else + DUREX_numBytes_store((void*)Em_App_msg.data); +#endif + break; + } + case 2: { +#ifdef Em_16BIT + DUREX_data_t val; + Em_App_valp = (uint8_t*)&val; + Em_App_bufp = Em_App_msg.data; + Em_App_desc = "*\xe5[1]"; + Em_App_marshallToVal(); + DUREX_data_store(&val); +#else + DUREX_data_store((void*)Em_App_msg.data); +#endif + break; + } + case 3: { +#ifdef Em_16BIT + DUREX_numPackets_t val; + Em_App_valp = (uint8_t*)&val; + Em_App_bufp = Em_App_msg.data; + Em_App_desc = "1"; + Em_App_marshallToVal(); + DUREX_numPackets_store(&val); +#else + DUREX_numPackets_store((void*)Em_App_msg.data); +#endif + break; + } + } + Em_App_sendResponse(Em_Message_STORE_DONE, 0); +} + +void Em_App_sendIndicator(Em_Message_ResId indId) { + Em_Message_Size resId = 0; + Em_Message_Size size = 0; + switch (indId) { + case 1: { +#ifdef Em_16BIT + DUREX_messageAvailable_t val; + Em_App_valp = (uint8_t*)&val; + Em_App_bufp = Em_App_ind.data; + Em_App_desc = "1"; + DUREX_messageAvailable_fetch(&val); + Em_App_marshallToBuf(); +#else + DUREX_messageAvailable_fetch((DUREX_messageAvailable_t*)&Em_App_ind.data); +#endif + resId = 4; + size = 1; + break; + } + } + Em_App_ind.sot = 0; + Em_App_ind.hdr.kind = Em_Message_INDICATOR; + Em_App_ind.hdr.size = sizeof (Em_Message_Header) + size; + Em_App_ind.hdr.resId = resId; + Em_App_startIndSend(); +} + +void DUREX_messageAvailable_indicate(void) { + if (Em_App_state == Em_App_CONNECTED && Em_App_xmitReady(1 + 1)) Em_App_sendIndicator(1); +} + +#ifdef __cplusplus +} +#endif + diff --git a/DUREX/Em/DUREX.h b/DUREX/Em/DUREX.h new file mode 100644 index 0000000..44e6eda --- /dev/null +++ b/DUREX/Em/DUREX.h @@ -0,0 +1,68 @@ +/**** DO NOT EDIT -- this file has been automatically generated from @emmoco.com.DUREX on 2014-05-14T16:44:10T ****/ +/**** protocolLevel = 13, toolsVersion = 13.4.1.201311121909 ****/ + +#ifndef DUREX__H +#define DUREX__H + +#include "Em_Types.h" +#include "Em_Message.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* -------- connection callback functions implemented by the application -------- */ + +void DUREX_connectHandler(void); +void DUREX_disconnectHandler(void); + +/* -------- resource types defined in the schema -------- */ + +/* typedef String */ +typedef char DUREX_String[229]; +#define DUREX_String_length 229 + +/* enum BOOLEAN */ +typedef uint8_t DUREX_BOOLEAN; +#define DUREX_TRUE 0 +#define DUREX_FALSE 1 + +/* -------- resource callback functions implemented by the application -------- */ + +/* resource numBytes */ +typedef uint8_t DUREX_numBytes_t; +extern void DUREX_numBytes_fetch(DUREX_numBytes_t* output); +extern void DUREX_numBytes_store(DUREX_numBytes_t* input); + +/* resource data */ +typedef DUREX_String DUREX_data_t; +extern void DUREX_data_fetch(DUREX_data_t output); +extern void DUREX_data_store(DUREX_data_t input); + +/* resource numPackets */ +typedef uint8_t DUREX_numPackets_t; +extern void DUREX_numPackets_fetch(DUREX_numPackets_t* output); +extern void DUREX_numPackets_store(DUREX_numPackets_t* input); + +/* resource messageAvailable */ +typedef DUREX_BOOLEAN DUREX_messageAvailable_t; +extern void DUREX_messageAvailable_fetch(DUREX_messageAvailable_t* output); +extern void DUREX_messageAvailable_indicate(void); /* called by the application */ + +/* -------- application functions implemented in DUREX.c -------- */ + +void DUREX_accept(bool enable); +void DUREX_activateParameters(uint8_t group); +void DUREX_broadcastOff(void); +void DUREX_disconnect(void); +void DUREX_pairingOn(uint8_t secs, void(*handler)(void)); +void DUREX_pairingOff(void(*handler)(void)); +void DUREX_reset(void); +void DUREX_setDeviceName(const char* name); +void DUREX_start(void); + +#ifdef __cplusplus +} +#endif + +#endif /* DUREX__H */ diff --git a/DUREX/Em/Em_Message.h b/DUREX/Em/Em_Message.h new file mode 100644 index 0000000..3bd0d58 --- /dev/null +++ b/DUREX/Em/Em_Message.h @@ -0,0 +1,182 @@ +#ifndef Em_Message_H_ +#define Em_Message_H_ + +#include "Em_Types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* -------- SRT FUNCTIONS CALLED BY HAL -------- */ + +static inline bool Em_Message_addByte(uint8_t b); +extern void Em_Message_dispatch(void); +static inline bool Em_Message_getByte(uint8_t* bp); +extern void Em_Message_restart(void); +static inline bool Em_Message_startRx(void); +static inline uint8_t Em_Message_startTx(void); + + +/* -------- HAL FUNCTIONS CALLED BY SRT -------- */ + +extern uint8_t Em_Hal_lock(void); +extern void Em_Hal_reset(void); +extern void Em_Hal_startSend(void); +extern void Em_Hal_unlock(uint8_t key); +extern void Em_Hal_watchOff(void); +extern void Em_Hal_watchOn(void); + + +/* -------- MESSAGE FORMAT -------- */ + +/* protocolLevel #4 */ +#define Em_Message_INDSIZE 4 + +typedef uint8_t Em_Message_Size; +typedef uint8_t Em_Message_Kind; +/* protocolLevel #12 -- split 16-bit resId into */ +typedef uint8_t Em_Message_ResId; +typedef uint8_t Em_Message_Chan; + +#define Em_Message_NOP 0 +#define Em_Message_FETCH 1 +#define Em_Message_FETCH_DONE 2 +#define Em_Message_STORE 3 +#define Em_Message_STORE_DONE 4 +#define Em_Message_INDICATOR 5 +#define Em_Message_CONNECT 6 +#define Em_Message_DISCONNECT 7 +#define Em_Message_ECHO 8 +/* protocolLevel #3 */ +/* protocolLevel #6 -- rename from BROADCAST to PAIRING */ +#define Em_Message_PAIRING 9 +#define Em_Message_PAIRING_DONE 10 +/* protocolLevel #7 */ +#define Em_Message_OFFLINE 11 +/* protocolLevel #8 */ +#define Em_Message_ACCEPT 12 +/* protocolLevel #13 */ +#define Em_Message_START 13 +#define Em_Message_ACTIVE_PARAMS 14 + +typedef struct Em_Message_Header { + Em_Message_Size size; + Em_Message_Kind kind; + Em_Message_ResId resId; + Em_Message_Chan chan; +} Em_Message_Header; + +typedef uint16_t Em_Message_protocolLevel_t; + +/* protocolLevel #1 */ + +/* protocolLevel #10 */ +/* #define Em_Message_SYS_SCHEMA_UUID 0xFF */ + +#define Em_Message_SYS_MCM_PROTOCOL_LEVEL 0xFE +#define Em_Message_SYS_EAP_PROTOCOL_LEVEL 0xFD +#define Em_Message_SYS_EAP_BUILD_DATE 0xFC + +/* protocolLevel #2 */ +#define Em_Message_SYS_FILE_INDEX_RESET 0xFB + +/* protocolLevel #5 */ +#define Em_Message_SYS_SCHEMA_HASH 0xFA + +/* protocolLevel #7 */ +#define Em_Message_SYS_RESOURCE_COUNT 0xF9 + +/* protocolLevel #9 */ +#define Em_Message_SYS_MOBILE_RSSI 0xF8 + +/* protocolLevel #11 */ +#define Em_Message_SYS_MCM_DISCONNECT 0xF7 + +/* protocolLevel #13a */ +#define Em_Message_SYS_MCM_NAME 0xF5 + + +/* -------- PRIVATE -------- */ + +extern void Em_Message_nextXmit(void); + +extern uint8_t* Em_App_inBuf; +extern uint8_t* Em_App_outBuf; +extern Em_Message_Size Em_App_xmitSize; + +extern uint8_t* _Em_Message_rxBuf; +extern uint8_t _Em_Message_rxCnt; + +extern uint8_t* _Em_Message_txBuf; +extern uint8_t _Em_Message_txCnt; + +static inline bool Em_Message_addByte(uint8_t b) { + if (_Em_Message_rxCnt == 0) { + if (b == 0) { + return false; + } + _Em_Message_rxCnt = b; + } + *_Em_Message_rxBuf++ = b; + if (--_Em_Message_rxCnt == 0) { + _Em_Message_rxBuf = 0; + if (_Em_Message_txBuf == 0) { + Em_Hal_watchOff(); + } + return true; + } + else { + return false; + } +} + +static inline bool Em_Message_getByte(uint8_t* bp) { + if (_Em_Message_txBuf == 0) { + return false; + } + if (_Em_Message_txCnt == 0) { + _Em_Message_txCnt = *_Em_Message_txBuf + 1; + } + if (--_Em_Message_txCnt > 0) { + *bp = *_Em_Message_txBuf++; + return true; + } + else { + _Em_Message_txBuf = 0; + Em_App_xmitSize = 0; + Em_Message_nextXmit(); + if (_Em_Message_rxBuf == 0) { + Em_Hal_watchOff(); + } + return false; + } +} + +static inline bool Em_Message_startRx(void) { + if (_Em_Message_rxBuf == 0) { + _Em_Message_rxBuf = Em_App_inBuf; + if (_Em_Message_txBuf == 0) { + Em_Hal_watchOn(); + } + return true; + } + else { + return false; + } +} + +static inline uint8_t Em_Message_startTx(void) { + _Em_Message_txBuf = Em_App_outBuf + 1; + _Em_Message_txCnt = 0; + if (_Em_Message_rxBuf == 0) { + Em_Hal_watchOn(); + } + return 0; +} + + +#ifdef __cplusplus +} +#endif + +#endif /*Em_Message_H_*/ diff --git a/DUREX/Em/Em_Types.h b/DUREX/Em/Em_Types.h new file mode 100644 index 0000000..d002306 --- /dev/null +++ b/DUREX/Em/Em_Types.h @@ -0,0 +1,17 @@ +#ifndef Em_Types_H_ +#define Em_Types_H_ + +#ifndef Em_NOSTDBOOL +#include +#endif + +#ifndef Em_NOSTDINT +#include +#endif + +#ifdef Em_16BIT +typedef signed char int8_t; +typedef unsigned char uint8_t; +#endif + +#endif /*Em_Types_H_*/ diff --git a/DUREX/Em/durex.json b/DUREX/Em/durex.json new file mode 100644 index 0000000..855e86c --- /dev/null +++ b/DUREX/Em/durex.json @@ -0,0 +1,247 @@ +{ + "resources": { + "$eapProtocolLevel": { + "id": -3, + "align": 2, + "attributes": {"readonly": true}, + "type": "u2", + "access": "r", + "size": 2 + }, + "numBytes": { + "id": 1, + "align": 1, + "attributes": {}, + "type": "u1", + "access": "rw", + "size": 1 + }, + "data": { + "id": 2, + "align": 1, + "attributes": {}, + "type": "C:229", + "access": "rw", + "size": 229 + }, + "$activeGroup": { + "id": -10, + "align": 1, + "pack": 1, + "attributes": {"readwrite": true}, + "type": "E:system@emmoco.com.System/ParameterGroup", + "access": "rw", + "size": 1 + }, + "$mcmDisconnect": { + "id": -9, + "align": 1, + "attributes": {"writeonly": true}, + "type": "u1", + "access": "w", + "size": 1 + }, + "$eapBuildDate": { + "dim": 8, + "id": -4, + "align": 1, + "attributes": {"readonly": true}, + "type": "A8:u1", + "access": "r", + "size": 8 + }, + "numPackets": { + "id": 3, + "align": 1, + "attributes": {}, + "type": "u1", + "access": "rw", + "size": 1 + }, + "$resourceCount": { + "id": -7, + "align": 1, + "attributes": {"readonly": true}, + "type": "S:system@emmoco.com.System/ResourceCount", + "access": "r", + "size": 2 + }, + "$schemaHash": { + "dim": 20, + "id": -6, + "align": 1, + "attributes": {"readonly": true}, + "type": "A20:u1", + "access": "r", + "size": 20 + }, + "messageAvailable": { + "id": 4, + "align": 1, + "pack": 1, + "attributes": {"indicator": true}, + "type": "E:@emmoco.com.DUREX/BOOLEAN", + "access": "ir", + "size": 1 + }, + "$mcmProtocolLevel": { + "id": -2, + "align": 2, + "attributes": {"readonly": true}, + "type": "u2", + "access": "r", + "size": 2 + }, + "$mobileRssi": { + "id": -8, + "align": 1, + "attributes": {"readonly": true}, + "type": "i1", + "access": "r", + "size": 1 + }, + "$fileIndexReset": { + "id": -5, + "align": 2, + "attributes": {"writeonly": true}, + "type": "i2", + "access": "w", + "size": 2 + } + }, + "resourceNamesSys": [ + "$activeGroup", + "$eapBuildDate", + "$eapProtocolLevel", + "$fileIndexReset", + "$mcmDisconnect", + "$mcmProtocolLevel", + "$mobileRssi", + "$resourceCount", + "$schemaHash" + ], + "manifest": { + "protocolLevel": 13, + "hash": [ + 28, + 106, + 83, + 11, + 248, + 159, + 192, + 243, + 66, + 193, + 233, + 148, + 55, + 208, + 191, + 77 + ], + "toolVersion": "13.4.1.201311121909", + "name": "DUREX", + "$$md5": "1c6a530bf89fc0f342c1e99437d0bf4d", + "build": [ + 208, + 202, + 48, + 251, + 69, + 1, + 0, + 0 + ], + "date": "2014-05-14T16:44:10T", + "maxAlign": 2, + "maxSize": 229, + "version": "1.0.0" + }, + "resourceNames": [ + "numBytes", + "data", + "numPackets", + "messageAvailable", + "$mcmProtocolLevel", + "$eapProtocolLevel", + "$eapBuildDate", + "$fileIndexReset", + "$schemaHash", + "$resourceCount", + "$mobileRssi", + "$mcmDisconnect", + "$activeGroup" + ], + "attributes": { + "description": "", + "version": "1.0.0" + }, + "resourceNamesApp": [ + "numBytes", + "data", + "numPackets", + "messageAvailable" + ], + "types": { + "system@emmoco.com.System/ResourceCount": { + "packed": false, + "align": 1, + "type": "S:system@emmoco.com.System/ResourceCount", + "size": 2, + "fields": [ + { + "pad": 0, + "align": 1, + "name": "app", + "type": "u1", + "size": 1 + }, + { + "pad": 0, + "align": 1, + "name": "sys", + "type": "u1", + "size": 1 + } + ] + }, + "std:i2": { + "align": 2, + "size": 2 + }, + "std:i1": { + "align": 1, + "size": 1 + }, + "std:u1": { + "align": 1, + "size": 1 + }, + "@emmoco.com.DUREX/BOOLEAN": { + "values": [ + "TRUE", + "FALSE" + ], + "align": 1, + "pack": 1, + "type": "E:@emmoco.com.DUREX/BOOLEAN", + "size": 1 + }, + "system@emmoco.com.System/ParameterGroup": { + "values": [ + "GROUP_A", + "GROUP_B" + ], + "align": 1, + "pack": 1, + "type": "E:system@emmoco.com.System/ParameterGroup", + "size": 1 + }, + "std:u2": { + "align": 2, + "size": 2 + } + }, + "imports": {"@emmoco.com.DUREX": true} +} \ No newline at end of file diff --git a/DUREX/Schema-Imports/system@emmoco.com/System.ems b/DUREX/Schema-Imports/system@emmoco.com/System.ems new file mode 100644 index 0000000..9601635 --- /dev/null +++ b/DUREX/Schema-Imports/system@emmoco.com/System.ems @@ -0,0 +1,72 @@ +owner = "system@emmoco.com" + +schema System { + + // protocolLevel #13 + + enum ParameterGroup { + GROUP_A, GROUP_B + } + + // protocolLevel #1 + + uint8 $schemaUuid[16] { // protocolLevel #10 -- invisible to applications + readonly + } + + uint16 $mcmProtocolLevel { + readonly + } + + uint16 $eapProtocolLevel { + readonly + } + + uint8 $eapBuildDate[8] { // protocolLevel #5 -- rename from $eapBuildNumber + readonly + } + + // protocolLevel #2 + + int16 $fileIndexReset { + writeonly + } + + // protocolLevel #5 + + // protocolLevel #12 -- increase size to 20 + + uint8 $schemaHash[20] { + readonly + } + + // protocolLevel #7 + + struct ResourceCount { + uint8 app + uint8 sys + } + + ResourceCount $resourceCount { + readonly + } + + // protocolLevel #9 + + int8 $mobileRssi { + readonly + } + + // protocolLevel #11 + + uint8 $mcmDisconnect { + writeonly + } + + // protocolLevel #13 + + ParameterGroup $activeGroup { + readwrite + } + +} diff --git a/DUREXLaunchpad/.externalToolBuilders/DUREX LaunchPad Builder.launch b/DUREXLaunchpad/.externalToolBuilders/DUREX LaunchPad Builder.launch new file mode 100644 index 0000000..5d24391 --- /dev/null +++ b/DUREXLaunchpad/.externalToolBuilders/DUREX LaunchPad Builder.launch @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/DUREXLaunchpad/.externalToolBuilders/DUREX LaunchPad Cleaner.launch b/DUREXLaunchpad/.externalToolBuilders/DUREX LaunchPad Cleaner.launch new file mode 100644 index 0000000..0a85be5 --- /dev/null +++ b/DUREXLaunchpad/.externalToolBuilders/DUREX LaunchPad Cleaner.launch @@ -0,0 +1,10 @@ + + + + + + + + + + -- libgit2 0.22.2