alpha
/
Kaleidoscope
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

astyle with current project style guidelines

Browse Source
pull/365/head
Jesse Vincent 8 years ago
parent e3dc58f384
commit a0b2d400db
No known key found for this signature in database
GPG Key ID: 122F5DF7108E4046
7 changed files with 198 additions and 198 deletions
Show Stats Download Patch File Download Diff File

58
examples/EEPROM-Settings/EEPROM-Settings.ino
Unescape View File

@ -20,41 +20,41 @@
#include <Kaleidoscope-EEPROM-Settings.h> #include <Kaleidoscope-EEPROM-Settings.h>
const Key keymaps[][ROWS][COLS] PROGMEM = { const Key keymaps[][ROWS][COLS] PROGMEM = {
[0] = KEYMAP_STACKED [0] = KEYMAP_STACKED
( (
Key_NoKey, Key_1, Key_2, Key_3, Key_4, Key_5, Key_NoKey, Key_NoKey, Key_1, Key_2, Key_3, Key_4, Key_5, Key_NoKey,
Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab, Key_Backtick, Key_Q, Key_W, Key_E, Key_R, Key_T, Key_Tab,
Key_PageUp, Key_A, Key_S, Key_D, Key_F, Key_G, Key_PageUp, Key_A, Key_S, Key_D, Key_F, Key_G,
Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape, Key_PageDown, Key_Z, Key_X, Key_C, Key_V, Key_B, Key_Escape,
Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift, Key_LeftControl, Key_Backspace, Key_LeftGui, Key_LeftShift,
Key_skip, Key_skip,
Key_skip, Key_6, Key_7, Key_8, Key_9, Key_0, Key_skip, Key_skip, Key_6, Key_7, Key_8, Key_9, Key_0, Key_skip,
Key_Enter, Key_Y, Key_U, Key_I, Key_O, Key_P, Key_Equals, Key_Enter, Key_Y, Key_U, Key_I, Key_O, Key_P, Key_Equals,
Key_H, Key_J, Key_K, Key_L, Key_Semicolon, Key_Quote, Key_H, Key_J, Key_K, Key_L, Key_Semicolon, Key_Quote,
Key_skip, Key_N, Key_M, Key_Comma, Key_Period, Key_Slash, Key_Minus, Key_skip, Key_N, Key_M, Key_Comma, Key_Period, Key_Slash, Key_Minus,
Key_RightShift, Key_RightAlt, Key_Spacebar, Key_RightControl, Key_RightShift, Key_RightAlt, Key_Spacebar, Key_RightControl,
Key_skip Key_skip
), ),
}; };
void setup () { void setup() {
Serial.begin (9600); Serial.begin(9600);
Kaleidoscope.setup (); Kaleidoscope.setup();
USE_PLUGINS (&EEPROMSettings); USE_PLUGINS(&EEPROMSettings);
while (!Serial) { while (!Serial) {
} }
Serial.println (EEPROMSettings.isValid () ? F("valid EEPROM settings") : F("invalid EEPROM settings")); Serial.println(EEPROMSettings.isValid() ? F("valid EEPROM settings") : F("invalid EEPROM settings"));
Serial.println (EEPROMSettings.crc (), HEX); Serial.println(EEPROMSettings.crc(), HEX);
Serial.println (EEPROMSettings.version ()); Serial.println(EEPROMSettings.version());
} }
void loop () { void loop() {
Kaleidoscope.loop (); Kaleidoscope.loop();
} }

128
src/Kaleidoscope/EEPROM-Settings-Focus.cpp
Unescape View File

@ -21,79 +21,79 @@
#include "crc.h" #include "crc.h"
namespace FocusHooks { namespace FocusHooks {
bool settings (const char *command) { bool settings(const char *command) {
enum { enum {
ISVALID, ISVALID,
GETVERSION, GETVERSION,
CRC, CRC,
} subCommand; } subCommand;
if (strncmp_P (command, PSTR ("settings."), 9) != 0) if (strncmp_P(command, PSTR("settings."), 9) != 0)
return false; return false;
if (strcmp_P (command + 9, PSTR ("valid?")) == 0) if (strcmp_P(command + 9, PSTR("valid?")) == 0)
subCommand = ISVALID; subCommand = ISVALID;
else if (strcmp_P (command + 9, PSTR ("version")) == 0) else if (strcmp_P(command + 9, PSTR("version")) == 0)
subCommand = GETVERSION; subCommand = GETVERSION;
else if (strcmp_P (command + 9, PSTR ("crc")) == 0) else if (strcmp_P(command + 9, PSTR("crc")) == 0)
subCommand = CRC; subCommand = CRC;
else else
return false; return false;
switch (subCommand) { switch (subCommand) {
case ISVALID: case ISVALID:
Focus.printBool (EEPROMSettings.isValid ()); Focus.printBool(EEPROMSettings.isValid());
Serial.println (); Serial.println();
break; break;
case GETVERSION: case GETVERSION:
Serial.println (EEPROMSettings.version ()); Serial.println(EEPROMSettings.version());
break; break;
case CRC: case CRC:
Serial.print (::CRC.crc, HEX); Serial.print(::CRC.crc, HEX);
Serial.print (F("/")); Serial.print(F("/"));
Serial.println (EEPROMSettings.crc (), HEX); Serial.println(EEPROMSettings.crc(), HEX);
break; break;
} }
return true; return true;
} }
bool eeprom (const char *command) { bool eeprom(const char *command) {
enum { enum {
CONTENTS, CONTENTS,
FREE, FREE,
} subCommand; } subCommand;
if (strcmp_P (command, PSTR ("eeprom.contents")) == 0)
subCommand = CONTENTS;
else if (strcmp_P (command, PSTR ("eeprom.free")) == 0)
subCommand = FREE;
else
return false;
switch (subCommand) { if (strcmp_P(command, PSTR("eeprom.contents")) == 0)
case CONTENTS: { subCommand = CONTENTS;
if (Serial.peek () == '\n') { else if (strcmp_P(command, PSTR("eeprom.free")) == 0)
for (uint16_t i = 0; i < EEPROM.length (); i++) { subCommand = FREE;
uint8_t d = EEPROM[i]; else
Focus.printNumber (d); return false;
Focus.printSpace ();
}
Serial.println ();
} else {
for (uint16_t i = 0; i < EEPROM.length () && Serial.peek () != '\n'; i++) {
uint8_t d = Serial.parseInt ();
EEPROM.update (i, d);
}
}
break; switch (subCommand) {
} case CONTENTS: {
case FREE: if (Serial.peek() == '\n') {
Serial.println (EEPROM.length () - EEPROMSettings.used ()); for (uint16_t i = 0; i < EEPROM.length(); i++) {
break; uint8_t d = EEPROM[i];
Focus.printNumber(d);
Focus.printSpace();
}
Serial.println();
} else {
for (uint16_t i = 0; i < EEPROM.length() && Serial.peek() != '\n'; i++) {
uint8_t d = Serial.parseInt();
EEPROM.update(i, d);
}
} }
return true; break;
}
case FREE:
Serial.println(EEPROM.length() - EEPROMSettings.used());
break;
}
return true;
} }
}; };

4
src/Kaleidoscope/EEPROM-Settings-Focus.h
Unescape View File

@ -21,8 +21,8 @@
#include <Kaleidoscope.h> #include <Kaleidoscope.h>
namespace FocusHooks { namespace FocusHooks {
bool settings (const char *command); bool settings(const char *command);
bool eeprom (const char *command); bool eeprom(const char *command);
}; };
#define FOCUS_HOOK_SETTINGS FOCUS_HOOK(FocusHooks::settings, \ #define FOCUS_HOOK_SETTINGS FOCUS_HOOK(FocusHooks::settings, \

84
src/Kaleidoscope/EEPROM-Settings.cpp
Unescape View File

@ -23,87 +23,87 @@ namespace KaleidoscopePlugins {
struct EEPROMSettings::settings EEPROMSettings::settings; struct EEPROMSettings::settings EEPROMSettings::settings;
bool EEPROMSettings::_isValid; bool EEPROMSettings::_isValid;
bool EEPROMSettings::sealed; bool EEPROMSettings::sealed;
uint16_t EEPROMSettings::nextStart = sizeof (EEPROMSettings::settings); uint16_t EEPROMSettings::nextStart = sizeof(EEPROMSettings::settings);
EEPROMSettings::EEPROMSettings (void) { EEPROMSettings::EEPROMSettings(void) {
} }
void void
EEPROMSettings::begin (void) { EEPROMSettings::begin(void) {
EEPROM.get (0, settings); EEPROM.get(0, settings);
} }
bool bool
EEPROMSettings::isValid (void) { EEPROMSettings::isValid(void) {
return _isValid; return _isValid;
} }
uint16_t uint16_t
EEPROMSettings::crc (void) { EEPROMSettings::crc(void) {
if (sealed) if (sealed)
return settings.crc; return settings.crc;
return 0; return 0;
} }
void void
EEPROMSettings::seal (void) { EEPROMSettings::seal(void) {
sealed = true; sealed = true;
CRC.finalize (); CRC.finalize();
if (settings.magic[0] != 'K' || settings.magic[1] != 'S') { if (settings.magic[0] != 'K' || settings.magic[1] != 'S') {
settings.magic[0] = 'K'; settings.magic[0] = 'K';
settings.magic[1] = 'S'; settings.magic[1] = 'S';
settings.version = 0; settings.version = 0;
settings.crc = CRC.crc; settings.crc = CRC.crc;
return update (); return update();
} }
if (settings.crc != CRC.crc) if (settings.crc != CRC.crc)
_isValid = false; _isValid = false;
} }
uint16_t uint16_t
EEPROMSettings::requestSlice (uint16_t size) { EEPROMSettings::requestSlice(uint16_t size) {
if (sealed) if (sealed)
return 0; return 0;
uint16_t start = nextStart; uint16_t start = nextStart;
nextStart += size; nextStart += size;
CRC.update ((const void *)&size, sizeof (size)); CRC.update((const void *)&size, sizeof(size));
return start; return start;
} }
void void
EEPROMSettings::invalidate (void) { EEPROMSettings::invalidate(void) {
_isValid = false; _isValid = false;
} }
uint16_t uint16_t
EEPROMSettings::used (void) { EEPROMSettings::used(void) {
return nextStart; return nextStart;
} }
void void
EEPROMSettings::update (void) { EEPROMSettings::update(void) {
settings.crc = CRC.crc; settings.crc = CRC.crc;
EEPROM.put (0, settings); EEPROM.put(0, settings);
_isValid = true; _isValid = true;
} }
uint8_t uint8_t
EEPROMSettings::version (void) { EEPROMSettings::version(void) {
return settings.version; return settings.version;
} }
void void
EEPROMSettings::version (uint8_t ver) { EEPROMSettings::version(uint8_t ver) {
settings.version = ver; settings.version = ver;
update (); update();
} }
}; };

52
src/Kaleidoscope/EEPROM-Settings.h
Unescape View File

@ -23,32 +23,32 @@
namespace KaleidoscopePlugins { namespace KaleidoscopePlugins {
class EEPROMSettings : public KaleidoscopePlugin { class EEPROMSettings : public KaleidoscopePlugin {
public: public:
EEPROMSettings (void); EEPROMSettings(void);
virtual void begin (void) final; virtual void begin(void) final;
static void update (void); static void update(void);
static bool isValid (void); static bool isValid(void);
static void invalidate (void); static void invalidate(void);
static uint8_t version (void); static uint8_t version(void);
static void version (uint8_t ver); static void version(uint8_t ver);
static uint16_t requestSlice (uint16_t size); static uint16_t requestSlice(uint16_t size);
static void seal (void); static void seal(void);
static uint16_t crc (void); static uint16_t crc(void);
static uint16_t used (void); static uint16_t used(void);
private: private:
static uint16_t nextStart; static uint16_t nextStart;
static bool _isValid; static bool _isValid;
static bool sealed; static bool sealed;
static struct settings { static struct settings {
char magic[2]; char magic[2];
uint8_t version; uint8_t version;
uint16_t crc; uint16_t crc;
} settings; } settings;
}; };
}; };

54
src/Kaleidoscope/crc.cpp
Unescape View File

@ -30,41 +30,41 @@
#include "crc.h" #include "crc.h"
void void
CRC_::reflect (uint8_t len) { CRC_::reflect(uint8_t len) {
uint8_t i; uint8_t i;
uint16_t newCRC; uint16_t newCRC;
newCRC = crc & 0x01; newCRC = crc & 0x01;
for (i = 1; i < len; i++) { for (i = 1; i < len; i++) {
crc >>= 1; crc >>= 1;
newCRC = (newCRC << 1) | (crc & 0x01); newCRC = (newCRC << 1) | (crc & 0x01);
} }
crc = newCRC; crc = newCRC;
} }
void void
CRC_::update (const void *data, uint8_t len) { CRC_::update(const void *data, uint8_t len) {
const uint8_t *d = (const uint8_t *)data; const uint8_t *d = (const uint8_t *)data;
uint8_t i; uint8_t i;
bool bit; bool bit;
uint8_t c; uint8_t c;
while (len--) { while (len--) {
c = *d++; c = *d++;
for (i = 0x01; i & 0xff; i <<= 1) { for (i = 0x01; i & 0xff; i <<= 1) {
bit = crc & 0x8000; bit = crc & 0x8000;
if (c & i) { if (c & i) {
bit = !bit; bit = !bit;
} }
crc <<= 1; crc <<= 1;
if (bit) { if (bit) {
crc ^= 0x8005; crc ^= 0x8005;
} }
}
crc &= 0xffff;
} }
crc &= 0xffff; crc &= 0xffff;
}
crc &= 0xffff;
} }
CRC_ CRC; CRC_ CRC;

16
src/Kaleidoscope/crc.h
Unescape View File

@ -32,16 +32,16 @@
#include <Arduino.h> #include <Arduino.h>
class CRC_ { class CRC_ {
public: public:
uint16_t crc = 0; uint16_t crc = 0;
CRC_ (void) {}; CRC_(void) {};
void update (const void *data, uint8_t len); void update(const void *data, uint8_t len);
void finalize (void) { void finalize(void) {
reflect (16); reflect(16);
}; };
void reflect (uint8_t len); void reflect(uint8_t len);
}; };
extern CRC_ CRC; extern CRC_ CRC;

Write Preview
Loading…
Cancel
Save