XPlane/HardwareAdapter
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

i2c communication

Browse Source 
use optic rotary encoder
This commit is contained in:
damage
2025-05-11 16:01:57 +02:00
parent 311c9ecdbb
commit 5cea555e77
2 changed files with 139 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
master/master.ino Normal file
View File

@ -0,0 +1,62 @@
#include <Wire.h>
#define READ_BYTES_FROM_WIRE 1
// needs global define
#define DATA_STOP_BYTE 0x00
#define HEADING_TRIGGER_BIT 1
#define HEADING_HIGH_BIT 2
#define ALTITUDE_TRIGGER_BIT 4
#define ALTITUDE_HIGH_BIT 8
struct device {
byte address;
String name;
};
struct device devices[] = {
{0x01, "althead"}
};
int numDevices = -1;
void setup() {
numDevices = sizeof(devices) / sizeof(device);
Wire.begin();
pinMode(LED_TX, OUTPUT);
digitalWrite(LED_TX, HIGH);
pinMode(LED_RX, OUTPUT);
digitalWrite(LED_RX, HIGH);
}
void loop() {
// loop through devices and ask for data
for (int i = 0; i < numDevices; i++) {
Wire.requestFrom(devices[i].address, READ_BYTES_FROM_WIRE);
while (Wire.available()) {
// device has data, ask as long for data as it sends
// if it never stops sending, we are fucked :)
byte data = Wire.read();
if (data != DATA_STOP_BYTE) {
if (data & ALTITUDE_TRIGGER_BIT) {
if (data & ALTITUDE_HIGH_BIT) {
Serial.println("Altitude up");
} else {
Serial.println("Altitude down");
}
} else if (data & HEADING_TRIGGER_BIT) {
if (data & HEADING_HIGH_BIT) {
Serial.println("Heading right");
} else {
Serial.println("Heading left");
}
} else {
// who are you?
}
Wire.requestFrom(devices[i].address, READ_BYTES_FROM_WIRE);
}
}
}
}

184
rotator/rotator.ino
View File

@ -1,142 +1,112 @@
#define PIN_HEADING_CLK D7 #include <Wire.h>
#define PIN_HEADING_DT D5
#define PIN_HEADING_SW D6
#define PIN_ALTITUDE_CLK D1 #define PIN_HEADING_WHITE PD3
#define PIN_ALTITUDE_DT D2 #define PIN_HEADING_RED PD6
#define PIN_ALTITUDE_SW D3
#define PIN_LED D4 #define PIN_ALTITUDE_WHITE PD2
#define PIN_ALTITUDE_RED PD5
#define VALUE_BUFFER 30 #define VALUE_BUFFER 30
#define HEADING_DT_TRIGGER 1 #define SKIP_ROTARY_INPUTS 50
#define HEADING_DT_HIGH 2
#define HEADING_SW_TRIGGER 2
#define ALTITUDE_DT_TRIGGER 4 // needs global define
#define ALTITUDE_DT_HIGH 8 #define DATA_STOP_BYTE 0x00
#define ALTITUDE_SW_TRIGGER 8 #define HEADING_TRIGGER_BIT 1
#define HEADING_HIGH_BIT 2
#define ALTITUDE_TRIGGER_BIT 4
#define ALTITUDE_HIGH_BIT 8
#define MIN_DT_INPUT_DELAY 1000 // 1ms int lastClk = HIGH;
#define MIN_SW_INPUT_DELAY 500000 // 500ms
const char PREFIX_HEADING[5] = "head";
const char PREFIX_ALTITUDE[5] = "altd";
uint8_t lastClk = HIGH;
// ringbuffer of trigger and direction values // ringbuffer of trigger and direction values
uint8_t valueBuffer[VALUE_BUFFER] = { 0 }; byte valueBuffer[VALUE_BUFFER] = { 0 };
uint8_t readerPos, writerPos = 0; uint8_t readerPos, writerPos = 0;
long lastInput = 0; void addValue(uint8_t value) {
valueBuffer[writerPos++] = value;
if (writerPos >= VALUE_BUFFER) {
writerPos = 0;
}
}
// prevent bouncing input void falling(uint8_t pin, byte triggerBit, byte highBit) {
bool useInput(long minInputDelay) { uint8_t dt = digitalRead(pin);
long now = micros(); byte value = triggerBit;
long diff = now - lastInput;
// < 0 because of long overruns // read direction of pin
bool ret = diff < 0 || diff > minInputDelay; if (dt) {
if (ret) { value |= highBit;
lastInput = now; } else {
// value is already "lowBit"
} }
return ret; if (useInput(value)) {
}
void addValue(uint8_t value) {
valueBuffer[writerPos++] = value;
if (writerPos >= VALUE_BUFFER) {
writerPos = 0;
}
}
void clkFalling(uint8_t PIN_DT, uint8_t DT_TRIGGER, uint8_t DT_HIGH) {
if (useInput(MIN_DT_INPUT_DELAY)) {
uint8_t dt = digitalRead(PIN_DT);
uint8_t value = DT_TRIGGER;
if (dt) {
value |= DT_HIGH;
} else {
// value is already "DT_LOW"
}
addValue(value); addValue(value);
} }
} }
void swFalling(uint8_t SW_TRIGGER) { void headingFalling() {
if (useInput(MIN_SW_INPUT_DELAY)) { falling(PIN_HEADING_RED, HEADING_TRIGGER_BIT, HEADING_HIGH_BIT);
addValue(SW_TRIGGER);
}
} }
void ICACHE_RAM_ATTR headingClkFalling(); void altitudeFalling() {
void headingClkFalling() { falling(PIN_ALTITUDE_RED, ALTITUDE_TRIGGER_BIT, ALTITUDE_HIGH_BIT);
clkFalling(PIN_HEADING_DT, HEADING_DT_TRIGGER, HEADING_DT_HIGH);
} }
void ICACHE_RAM_ATTR altitudeClkFalling(); int eventCount = 0;
void altitudeClkFalling() { byte lastValue = 0;
clkFalling(PIN_ALTITUDE_DT, ALTITUDE_DT_TRIGGER, ALTITUDE_DT_HIGH); bool useInput(byte value) {
} if (lastValue == value) {
// same event as last event
void ICACHE_RAM_ATTR headingSwFalling(); // check if already SKIP_ROTARY_INPUTS happend
void headingSwFalling() { if (eventCount > SKIP_ROTARY_INPUTS) {
swFalling(HEADING_SW_TRIGGER); eventCount = 0;
} return true;
} else {
void ICACHE_RAM_ATTR altitudeSwFalling(); eventCount++;
void altitudeSwFalling() { return false;
swFalling(ALTITUDE_SW_TRIGGER); }
}
void dtTriggered(uint8_t high, uint8_t fast, const char prefix[5]) {
Serial.print(prefix);
if (high) {
Serial.println(1);
} else { } else {
Serial.println(-1); // not same event as last event
// reset counter
lastValue = value;
eventCount = 0;
return false;
}
}
void i2cRequest() {
// if write is ahead, send data
if (writerPos != readerPos) {
byte value = valueBuffer[readerPos++];
if (readerPos >= VALUE_BUFFER) {
readerPos = 0;
}
Wire.write(value);
} else {
Wire.write(DATA_STOP_BYTE);
} }
} }
void setup() { void setup() {
Serial.begin(115200); Serial.begin(115200);
pinMode(PIN_HEADING_SW, INPUT_PULLUP); pinMode(PIN_HEADING_WHITE, INPUT_PULLUP);
pinMode(PIN_HEADING_DT, INPUT_PULLUP); pinMode(PIN_HEADING_RED, INPUT_PULLUP);
pinMode(PIN_HEADING_CLK, INPUT_PULLUP); pinMode(PIN_ALTITUDE_WHITE, INPUT_PULLUP);
pinMode(PIN_ALTITUDE_RED, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(PIN_HEADING_CLK), headingClkFalling, FALLING); attachInterrupt(digitalPinToInterrupt(PIN_ALTITUDE_WHITE), altitudeFalling, FALLING);
attachInterrupt(digitalPinToInterrupt(PIN_HEADING_SW), headingSwFalling, FALLING); attachInterrupt(digitalPinToInterrupt(PIN_HEADING_WHITE), headingFalling, FALLING);
attachInterrupt(digitalPinToInterrupt(PIN_ALTITUDE_CLK), altitudeClkFalling, FALLING);
attachInterrupt(digitalPinToInterrupt(PIN_ALTITUDE_SW), altitudeSwFalling, FALLING); Wire.begin(0x01);
Wire.onRequest(i2cRequest);
} }
void loop() { void loop() {
while (writerPos != readerPos) { delay(10000);
uint8_t value = valueBuffer[readerPos++];
if (readerPos >= VALUE_BUFFER) {
readerPos = 0;
}
if (value & HEADING_DT_TRIGGER) {
uint8_t dtHigh = value & HEADING_DT_HIGH;
dtTriggered(dtHigh, 5, PREFIX_HEADING);
} else if (value & HEADING_SW_TRIGGER) {
Serial.print(PREFIX_HEADING);
Serial.println("push");
} else if (value & ALTITUDE_DT_TRIGGER) {
uint8_t dtHigh = value & ALTITUDE_DT_HIGH;
dtTriggered(dtHigh, 5, PREFIX_ALTITUDE);
} else if (value & ALTITUDE_SW_TRIGGER) {
Serial.print(PREFIX_ALTITUDE);
Serial.println("push");
} else {
// never happen error...
}
}
} }