Makro Tastatur

Hallo zusammen.... Ich möchte mir gerne eine Makro Tastatur bauen. Hardware: Arduino LEO

Die Makros sollen im EEPROM gespeichert werden. dh.: ein Programm (VB.NET) sendet über Serial die Makros an den Arduino. Arduino speichert die Makros in den EEPROM.

wenn ein Button gedrückt wird, soll der inhalt vom EEPROM an PC mittles Keyboard.Print gesendet werden.

also so Ähnlich wie eine G13 Tastatur von Logitech...

Hat jemand lust mich bei diesem Projekt zu ünterstützen?

p-velo: Ich möchte mir gerne ...

Fang am besten damit an, dass Du die serielle Kommunikation und das Lesen/Schreiben aus dem bzw. in das EEPROM beherrschst. Bis Du das hast, kannst Du darüber nachdenken, ob das, was Du vorhast, wirklich sinnvoll ist. Makros oder Textbausteine usw. können vermutlich wesentlich komfortabler mit einer „Funktionstasten-Belegungs-App“ gespeichert und abgerufen werden.

p-velo: Hat jemand lust mich bei diesem Projekt zu ünterstützen?

An Lust mangelt's hier bestimmt nicht.

Gruß

Gregor

Ich finde auch daß irgend ein Hilfsprogrammchen auf dem PC diese Aufgabe gut lösen könnte. Ok man ist nicht plattformunabhängig aber vieleicht einfach in der Bediehnung, da Du ja wissen mußt welche String sich hinter welchem Kürzel / Taste verbirgt.

Ok, es ist mit einem Arduino Leonardo / MICRO machbar.

Grüße Uwe

(deleted)

Fang am besten damit an, dass Du die serielle Kommunikation und das Lesen/Schreiben aus dem bzw. in das EEPROM beherrschst.

Ich bin breits in der Lage Textbausteine in der EEPRM zu schreiben.

Makros oder Textbausteine usw. können vermutlich wesentlich komfortabler mit einer „Funktionstasten-Belegungs-App" gespeichert und abgerufen werden.

In meinem Job muss ich viele verschiede Passwörter sehr oft eingeben “das nervt”.
Deswegen die Idee so eine “Tastatur” zu bauen.
Apps kann jeder :slight_smile:

Vielleicht ist das was für dich
http://finalkey.net/

Danke… in Prinzip suche ich sowas… nur mit mehr Tasten;-)

anbei mein bisheriger code:

#include <EEPROM.h>
const int EEPROM_MIN_ADDR = 0;
const int EEPROM_MAX_ADDR = 511;
String inputString = "";
boolean stringComplete = false;
const int BUFSIZE = 100;
char buf[BUFSIZE];

void setup() {
  int i;
  Serial.begin(115200);
  inputString.reserve(500);
}

void erase_buffer() {
  int i;
  for (i = 0; i < BUFSIZE; i++) {
    buf[i] = 0;
  }
}
void eeprom_erase_all(byte b = 0xFF) {
  int i;
  for (i = EEPROM_MIN_ADDR; i <= EEPROM_MAX_ADDR; i++) {
    EEPROM.write(i, b);
  }
}

boolean eeprom_is_addr_ok(int addr) {
  return ((addr >= EEPROM_MIN_ADDR) && (addr <= EEPROM_MAX_ADDR));
}

boolean eeprom_write_bytes(int startAddr, const byte* array, int numBytes) {
  int i;
  if (!eeprom_is_addr_ok(startAddr) || !eeprom_is_addr_ok(startAddr + numBytes)) {
    return false;
  }

  for (i = 0; i < numBytes; i++) {
    EEPROM.write(startAddr + i, array[i]);
  }
  return true;
}
boolean eeprom_read_bytes(int startAddr, byte array[], int numBytes) {
  int i;
  if (!eeprom_is_addr_ok(startAddr) || !eeprom_is_addr_ok(startAddr + numBytes)) {
    return false;
  }
  for (i = 0; i < numBytes; i++) {
    array[i] = EEPROM.read(startAddr + i);
  }
  return true;
}
boolean eeprom_write_int(int addr, int value) {
  byte *ptr;

  ptr = (byte*)&value;
  return eeprom_write_bytes(addr, ptr, sizeof(value));
}
boolean eeprom_read_int(int addr, int* value) {
  return eeprom_read_bytes(addr, (byte*)value, sizeof(int));
}
boolean eeprom_write_string(int addr, const char* string) {
  int numBytes;
  numBytes = strlen(string) + 1;
  return eeprom_write_bytes(addr, (const byte*)string, numBytes);
}
boolean eeprom_read_string(int addr, char* buffer, int bufSize) {
  byte ch;
  int bytesRead;
  if (!eeprom_is_addr_ok(addr)) {
    return false;
  }
  if (bufSize == 0) {
    return false;
  }
  if (bufSize == 1) {
    buffer[0] = 0;
    return true;
  }
  bytesRead = 0;
  ch = EEPROM.read(addr + bytesRead);
  buffer[bytesRead] = ch;
  bytesRead++;
  while ( (ch != 0x00) && (bytesRead < bufSize) && ((addr + bytesRead) <= EEPROM_MAX_ADDR) ) {
    ch = EEPROM.read(addr + bytesRead);
    buffer[bytesRead] = ch;
    bytesRead++;
  }
  if ((ch != 0x00) && (bytesRead >= 1)) {
    buffer[bytesRead - 1] = 0;
  }
  return true;
}


void loop() {
  if (stringComplete) {
    erase_buffer();
    if (inputString.substring(0, 2) == "#1") {
      eeprom_erase_all();
    }
    else if (inputString.substring(0, 2) == "#2")
    {
      //WRITE
      String inString = "";
      inString = inputString.substring(0, inputString.length() - 2);
      String iString = "";
      iString = inString.substring(3, inString.length());
      strcpy(buf, iString.c_str());
      String adr1 = inString.substring(2,1);
      Serial.println(adr1.toInt());
      
      eeprom_write_string(adr1.toInt(), buf);
      
    }
    else if (inputString.substring(0, 2) == "#3")
    {
      //READ
      eeprom_read_string(0, buf, BUFSIZE);
      Serial.println(buf);
    }
    //alles bereinigen
    erase_buffer();
    inputString = "";
    stringComplete = false;
    Serial.println("#9");
  }
}

void serialEvent() {
  while (Serial.available()) {
    char inChar = (char)Serial.read();
    inputString += inChar;
    if (inChar == '\n') {
      stringComplete = true;
    }
  }
}

Nicht schlecht; dazu kann man aber gleich einen Leostick https://www.freetronics.com.au/products/leostick nehmen, der hat bereits den USB-Stecker dran.

Grüße Uwe

p-velo: Ich bin breits in der Lage Textbausteine in der EEPRM zu schreiben. In meinem Job muss ich viele verschiede Passwörter sehr oft eingeben "das nervt". Deswegen die Idee so eine "Tastatur" zu bauen.

Das ändert die Sache natürlich vollkommen. Nach dem Lesen des ersten Postings dachte ich, dass Du noch ziemlich ahnungslos am Anfang stehst.

Mir so eine Art „Tastatur-Faker“ zu bauen hatte ich auch mal angedacht. Aber da ich meine geschätzt 20 Passwörter auswendig kenne und Zehn-Finger-Tipper bin, kam ich zu dem Schluss, dass so ein Passwort-Eingebedingsda unpraktisch für mich wäre. Bis so ein Ding angestöpselt wäre, hätte ich schon drei verschiedene Passwörter eingegeben.

Was Uwe anbietet, scheint mir einen näheren Blick wert zu sein.

Gruß

Gregor

Die Tastatur ist zu 89% fertig. (zumindest die Software)

#include <EEPROM.h>
#include "Keyboard.h"
const int EEPROM_MIN_ADDR = 0;
const int EEPROM_MAX_ADDR = 493;
String inputString = "";
boolean stringComplete = false;
const int BUFSIZE = 100;
char buf[BUFSIZE];
const int buttonPin = 4;
int previousButtonState = HIGH;

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);
  Serial.begin(9600);
  Keyboard.begin();
  inputString.reserve(500);
  Serial.println("start");

}
void erase_buffer() {
  int i;
  for (i = 0; i < BUFSIZE; i++) {
    buf[i] = 0;
  }
}
void eeprom_erase_all(byte b = 0xFF) {
  int i;
  for (i = EEPROM_MIN_ADDR; i <= EEPROM_MAX_ADDR; i++) {
    EEPROM.write(i, b);
  }
}
boolean eeprom_is_addr_ok(int addr) {
  return ((addr >= EEPROM_MIN_ADDR) && (addr <= EEPROM_MAX_ADDR));
}
boolean eeprom_write_bytes(int startAddr, const byte* array, int numBytes) {
  int i;
  if (!eeprom_is_addr_ok(startAddr) || !eeprom_is_addr_ok(startAddr + numBytes)) {
    return false;
  }

  for (i = 0; i < numBytes; i++) {
    EEPROM.write(startAddr + i, array[i]);
  }
  return true;
}
boolean eeprom_read_bytes(int startAddr, byte array[], int numBytes) {
  int i;
  if (!eeprom_is_addr_ok(startAddr) || !eeprom_is_addr_ok(startAddr + numBytes)) {
    return false;
  }
  for (i = 0; i < numBytes; i++) {
    array[i] = EEPROM.read(startAddr + i);
  }
  return true;
}
boolean eeprom_write_int(int addr, int value) {
  byte *ptr;

  ptr = (byte*)&value;
  return eeprom_write_bytes(addr, ptr, sizeof(value));
}
boolean eeprom_read_int(int addr, int* value) {
  return eeprom_read_bytes(addr, (byte*)value, sizeof(int));
}
boolean eeprom_write_string(int addr, const char* string) {
  int numBytes;
  numBytes = strlen(string) + 1;
  return eeprom_write_bytes(addr, (const byte*)string, numBytes);
}
boolean eeprom_read_string(int addr, char* buffer, int bufSize) {
  byte ch;
  int bytesRead;
  if (!eeprom_is_addr_ok(addr)) {
    return false;
  }
  if (bufSize == 0) {
    return false;
  }
  if (bufSize == 1) {
    buffer[0] = 0;
    return true;
  }
  bytesRead = 0;
  ch = EEPROM.read(addr + bytesRead);
  buffer[bytesRead] = ch;
  bytesRead++;
  while ( (ch != 0x00) && (bytesRead < bufSize) && ((addr + bytesRead) <= EEPROM_MAX_ADDR) ) {
    ch = EEPROM.read(addr + bytesRead);
    buffer[bytesRead] = ch;
    bytesRead++;
  }
  if ((ch != 0x00) && (bytesRead >= 1)) {
    buffer[bytesRead - 1] = 0;
  }
  return true;
}
void serialEvent() {
  while (Serial.available()) {
    char inChar = (char)Serial.read();
    inputString += inChar;
    if (inChar == '\n') {
      stringComplete = true;
    }
  }
}
int get_adr(String passNR) {
  switch (passNR.toInt()) {
    case 1:
      return 0;
      break;
    case 2:
      return 31;
      break;
    case 3:
      return 62;
      break;
    case 4:
      return 93;
      break;
    case 5:
      return 123;
      break;
    case 6:
      return 153;
      break;
    case 7:
      return 184;
      break;
    case 8:
      return 215;
      break;
    case 9:
      return 246;
      break;
    default:
      break;

  }
}
void Serialcom()
{
  if (stringComplete) {
    erase_buffer();
    if (inputString.substring(0, 2) == "#1") {
      Keyboard.print("You pressed the button ");
      eeprom_erase_all();
    }
    else if (inputString.substring(0, 2) == "#2")
    {
      //WRITE
      String inString = inputString.substring(0, inputString.length() - 2);
      String DataString = inString.substring(3, inString.length());
      String AdrString = inString.substring(2, 3);
      int adr = get_adr(AdrString);
      strcpy(buf, DataString.c_str());
      eeprom_write_string(adr, buf);
    }

    else if (inputString.substring(0, 2) == "#3")
    {
      //READ
      String inString = inputString.substring(0, inputString.length() - 2);
      String AdrString = inString.substring(2, 3);
      int adr = get_adr(AdrString);
      eeprom_read_string(adr, buf, BUFSIZE);
      Serial.println(buf);
    }
    //alles bereinigen
    erase_buffer();
    inputString = "";
    stringComplete = false;
    Serial.println("#9");
  }
  if (Serial.available() > 0)
    serialEvent();
}

void loop() {
  Serialcom();
  int buttonState = digitalRead(buttonPin);
  if ((buttonState != previousButtonState) && (buttonState == HIGH)) {
    eeprom_read_string(0, buf, BUFSIZE);
    Serial.println(buf);
    Keyboard.println(buf);
    delay(1000);
  }
  previousButtonState = buttonState;
}

Befehle:
#1 wird der EEPROM geleert
#21passwort / #2 = befehl schreiben,1 passNr1(adresse 0), passwort = das passwort
#31 / #3 lesen, 1passNr