Add FlightSimData and FlightSimEvent data types

teensy3/usb_flightsim.cpp

 FlightSimInteger * FlightSimInteger::last = NULL;
 FlightSimFloat * FlightSimFloat::first = NULL;
 FlightSimFloat * FlightSimFloat::last = NULL;
+/// JB
+FlightSimEvent * FlightSimEvent::first = NULL;
+FlightSimEvent * FlightSimEvent::last = NULL;
+FlightSimData * FlightSimData::first = NULL;
+FlightSimData * FlightSimData::last = NULL;
+/// JB End
 
 uint8_t FlightSimClass::enabled = 0;
 uint8_t FlightSimClass::request_id_messages = 0;
 	FlightSimClass::xmit(buf, 4, NULL, 0);
 }
 
+/// JB
+FlightSimEvent::FlightSimEvent()
+{
+	id = unassigned_id++;
+	if (!first) {
+		first = this;
+	} else {
+		last->next = this;
+	}
+	last = this;
+	name = NULL;
+	next = NULL;
+	occur_callback = NULL;
+	occurredFlag = 0;
+	callbackInfo = NULL;
+	hasCallbackInfo = 0;
+	value = 0;
+	FlightSimClass::request_id_messages = 1;
+}
+
+void FlightSimEvent::identify(void)
+{
+	uint8_t len, buf[6];
+
+	if (!FlightSim.enabled || !name) return;
+	len = strlen((const char *)name);
+	buf[0] = len + 6;
+	buf[1] = 1;
+	buf[2] = id;
+	buf[3] = id >> 8;
+	buf[4] = 3;
+	buf[5] = 0;
+	FlightSimClass::xmit(buf, 6, name, len);
+}
+
+void FlightSimEvent::send(unsigned int data, unsigned int flags)
+{
+	uint8_t buf[4];
+	uint32_t txData[2];
+
+	if (!FlightSim.enabled || !name) return;
+	buf[0] = 12;
+	buf[1] = 7;
+	buf[2] = id;
+	buf[3] = id >> 8;
+	value = data;
+	txData[0] = data;
+	txData[1] = flags;
+	FlightSimClass::xmit(buf, 4, (uint8_t *)&txData, 8);
+}
+
+void FlightSimEvent::update(long val)
+{
+	value = (unsigned int) val;
+	occurredFlag = true;
+	if (occur_callback) {
+		if (!hasCallbackInfo) {
+			(*occur_callback)(val);
+		} else {
+			(*(void(*)(long,void*))occur_callback)(val,callbackInfo);
+		}
+	}
+}
+
+FlightSimEvent * FlightSimEvent::find(unsigned int n)
+{
+	for (FlightSimEvent *p = first; p; p = p->next) {
+		if (p->id == n) return p;
+	}
+	return NULL;
+}
+
+
+FlightSimData::FlightSimData()
+{
+	id = unassigned_id++;
+	if (!first) {
+		first = this;
+	} else {
+		last->next = this;
+	}
+	last = this;
+	name = NULL;
+	next = NULL;
+	valueLen = 0;
+	hasCallbackInfo = 0;
+	callbackWithObject = 0;
+	callbackInfo = NULL;
+	change_callback = NULL;
+	FlightSimClass::request_id_messages = 1;
+}
+
+void FlightSimData::identify(void)
+{
+	uint8_t len, buf[6];
+
+	if (!FlightSim.enabled || !name) return;
+	len = strlen((const char *)name);
+	buf[0] = len + 6;
+	buf[1] = 1;
+	buf[2] = id;
+	buf[3] = id >> 8;
+	buf[4] = 4;
+	buf[5] = 0;
+	FlightSimClass::xmit(buf, 6, name, len);
+}
+
+void FlightSimData::update(char *val, size_t len)
+{
+	valueLen = len;
+	memcpy(value, val, len);
+	if (len<FLIGHTSIM_DATA_MAXLEN) {
+		memset(value+len,0,FLIGHTSIM_DATA_MAXLEN-len);
+	}
+	if (change_callback) {
+		if (!callbackWithObject) {
+			if (!hasCallbackInfo) {
+				(*change_callback)(value);
+			} else {
+				(*(void(*)(char*,void*))change_callback)(value,callbackInfo);
+			}
+		} else {
+			if (!hasCallbackInfo) {
+				(*(void(*)(FlightSimData*))change_callback)(this);
+			} else {
+				(*(void(*)(FlightSimData*,void*))change_callback)(this,callbackInfo);
+			}
+		}
+	}
+}
+
+FlightSimData * FlightSimData::find(unsigned int n)
+{
+	for (FlightSimData *p = first; p; p = p->next) {
+		if (p->id == n) return p;
+	}
+	return NULL;
+}
+/// JB End
+
 
 FlightSimInteger::FlightSimInteger()
 {
 					data.b[3] = p[9];
 					#endif
 					item->update(data.f);
+/// JB
+				} else if (type == 3) {
+					FlightSimEvent *item = FlightSimEvent::find(id);
+					if (!item) break;
+					#ifdef KINETISK
+					data.l = *(long *)(p + 6);
+					#else
+					data.b[0] = p[6];
+					data.b[1] = p[7];
+					data.b[2] = p[8];
+					data.b[3] = p[9];
+					#endif
+					item->update(data.f);
+				} else if (type == 4) {
+					FlightSimData *item = FlightSimData::find(id);
+					if (!item) break;
+					item->update(((char*)p)+6,len-6);
+/// JB End
 				}
 				break;
 			  case 0x03: // enable/disable
 		for (FlightSimCommand *p = FlightSimCommand::first; p; p = p->next) {
 			p->identify();
 		}
+/// JB
+		for (FlightSimEvent *p = FlightSimEvent::first; p; p = p->next) {
+			p->identify();
+		}
+		for (FlightSimData *p = FlightSimData::first; p; p=p->next) {
+			p->identify();
+		}
+/// JB End
 		for (FlightSimInteger *p = FlightSimInteger::first; p; p = p->next) {
 			p->identify();
 			// TODO: send any dirty data

teensy3/usb_flightsim.h

 	friend class FlightSimCommand;
 	friend class FlightSimInteger;
 	friend class FlightSimFloat;
+/// JB
+	friend class FlightSimEvent;
+	friend class FlightSimData;
+/// JB End
 };
 
 
 	friend class FlightSimClass;
 };
 
+/// JB
+class FlightSimEvent
+{
+public:
+	FlightSimEvent();
+	void assign(const _XpRefStr_ *s) { name = s; if (FlightSimClass::enabled) identify(); }
+	FlightSimEvent & operator = (const _XpRefStr_ *s) { assign(s); return *this; }
+	void send() { send(0,0); }
+	void send(int data) { send(data,0); }
+	void sendOnce() { send(0,0); }
+	void sendOnce(int data) { send(data,0); }
+	void sendRepeat(int data, uint16_t initialDelay, uint16_t repeatDelay) { send(data, initialDelay<<16 | repeatDelay); }
+	void sendRepeat(uint16_t initialDelay, uint16_t repeatDelay) { send(0, initialDelay<<16 | repeatDelay); }
+	void stopRepeat() { send(0,-1); }
+	FlightSimEvent & operator = (int n) { send(n,0); return *this; }	
+	bool occurred() { bool hasOccurred = occurredFlag; occurredFlag = 0; return hasOccurred; }
+	void identify();
+	static FlightSimEvent * find(unsigned int n);
+	void update(long val);
+	void onOccur(void (*fptr)(long)) { 
+		hasCallbackInfo=false;
+		occur_callback = fptr; 
+	}
+	void onOccur(void (*fptr)(long,void*), void* info) {
+		hasCallbackInfo=true;
+		occur_callback = (void (*)(long))fptr;
+		callbackInfo = info;
+	}
+private:
+	void send(unsigned int data, unsigned int flags);
+	unsigned int id;
+	const _XpRefStr_ *name;
+	bool occurredFlag;
+	unsigned int value;
+	FlightSimEvent *next;
+	
+	void (*occur_callback)(long);
+	void* callbackInfo;
+	bool  hasCallbackInfo;
+	
+	static FlightSimEvent *first;
+	static FlightSimEvent *last;
+	friend class FlightSimClass;
+};
+
+#define FLIGHTSIM_DATA_MAXLEN 58
+
+class FlightSimData
+{
+public:
+	FlightSimData();
+	void assign(const _XpRefStr_ *s) { name = s; if (FlightSimClass::enabled) identify(); }
+	FlightSimData & operator = (const _XpRefStr_ *s) { assign(s); return *this; }
+	char *read()  { return value; }
+	operator char* () { return value; }
+	void identify();
+	void update(char *val, size_t len);
+	size_t len() { return valueLen; }
+	static FlightSimData * find(unsigned int n);
+	void onChange(void (*fptr)(char *)) {
+		hasCallbackInfo = false;
+		change_callback = fptr;
+	}
+	void onChange(void (*fptr)(char *,void *), void *info) {
+		hasCallbackInfo = true;
+		change_callback = (void (*)(char*)) fptr;
+		callbackInfo = info;
+	}
+	void onChange(void (*fptr)(FlightSimData *)) {
+		callbackWithObject = true;
+		hasCallbackInfo = false;
+		change_callback = (void (*)(char*)) fptr;
+	}
+	void onChange(void (*fptr)(FlightSimData *, void*), void* info) {
+		callbackWithObject = true;
+		hasCallbackInfo = true;
+		change_callback = (void (*)(char*)) fptr;
+		callbackInfo = info;
+	}
+private:
+	unsigned int id;
+	const _XpRefStr_ *name;
+	char value[FLIGHTSIM_DATA_MAXLEN];
+	size_t valueLen;
+	void (*change_callback)(char *);
+	void* callbackInfo;
+	bool  hasCallbackInfo;
+	bool  callbackWithObject;
+	FlightSimData *next;
+	static FlightSimData *first;
+	static FlightSimData *last;
+	friend class FlightSimClass;
+};
+/// JB End
+
 
 class FlightSimInteger
 {