Wątek: Kontrolery Arduino

[Marcin_B]

I2C używam do podłączenia wyświetlaczy LCD. Potrzebny jest tylko konwerter np. taki:
https://botland.com.pl/konwertery-pozostale/2352-konwerter-i2c-dla-wyswietlacza-lcd-hd44780.html

[shopiK]

Widocznie jakieś nowsze rozwiązanie się pojawiło, bo wygląda również ciekawie i jest prostsze w instalacji niż to co używałem. Ciekawe tylko, czy po uruchomieniu programu jako joystick działa również serial port (przydatne do debugowania).

[vito_zm]

Maciej, shopiK czy możecie opisać co należy kolejno wykonać aby uruchomić Leonardo jako joystick. Mam IDE Arduino gdzie uruchamiam swoje przykłady na UNO. Zamówiłem Leonardo i chciałbym go testować programem o którym napisaliście.
Równolegle testuję ProMicro w programie MMJoy2. Tutaj mam już kilka wniosków, ale do końca jeszcze daleko. Chcę porównać z sobą te dwie aplikacje jedną MMJoy2 na Pro i drugą na Leonardo.

[Sparrowhawk]

A udało się wam zmienić nazwę w MMJoy2? Tę, która pojawia się w kontrolerach gier.

[vito_zm]

Postaram się w skrócie przedstawić moje wnioski na podstawie testów.  Mnie głównie interesowały możliwości MMJoy2 związane z przyciskami, przełącznikami oraz dekoderami. Kolejnym etapem mają by analogi. Testowałem MMJoy2 w konfiguracjach: matryca z przyciskami 4x3, 3 rejestry CD 4021 oraz jeden enkoder (dobrej jakości).
Wniosek pierwszy dotyczy budowania fizycznej matrycy w powiązaniu z mapą 1-96. Ponieważ autor projektu przewidział program setup dla różnych kontrolerów to mamy pełny wybór kolumn oraz wierszy. W ProMicro jest ograniczenie do B1-B6, C6, D0-D4, E6 oraz F4-F7. Nie wiadomo co jest kolumną a co wierszem. Na załączonym obrazku widać, że matryca zajęła 01-12 pozycji a rejestry 13-36, dla mojej konfiguracji. U Damosa są wyraźnie określone kolumny oraz wiersze w relacji do pinów uP. MMJoy2 jest zawsze widziany jako joystick nawet gdy konfigurujemy w tabeli Mouse and keyboard. W opcji joystick mamy osie oraz 32 przyciski. Możemy przypisać pozostałe przyciski od 32 do 96 w tabeli Mouse and keyboard. Są one widziane jako klawiatura. Jest pewne ograniczenie polegające na tym, że możemy przypisać klawisz ale bez modyfikatorów, chociaż na dole jest okienko Keyboard modifier, nie wiem jak to działa. Są także okienka dla 3 Shift oraz pozycji 1-96, też nie wiem jak to działa. Najgorzej wygląda sprawa enkoderów, czego można było się spodziewać. Brak podstawowej opcji konfiguracji enkoderów tzn. jaki to jest typ. Mamy 3 typy enkoderów 1:1, 1:2 oraz 1:4. U Damosa oraz codeking jest ta opcja. Na zdjęciu widać złe działanie enkodera w programie DIView. Powinny być albo same 1-i ruch pokrętła w prawo albo 4-i ruch w lewo. Timery dają opóźnienie jeśli jest taka potrzeba w symulatorze.
Reasumując, gdybym miał zastosować MMJy2 w kokpicie to tylko jako joystick bez dodatkowych opcji typu keyboard. Tutaj projekt Damosa jest bezkonkurencyjny.
Teraz czekam na Leonardo w którym chciałbym zaimplementować program o którym napisał shopiK oraz maciej. Chciałbym go przetestować, ale potrzebuję pomoc od wspomnianych kolegów. Nie chcę znowu odkrywać coś co już jest sprawdzone.

[shopiK]

To czekamy na konkretne pytania. Jeśli bedę umiał to pomogę.
Maciej zaproponował bardzo proste rozwiązanie: https://github.com/MHeironimus/ArduinoJoystickLibrary    Tutaj większej filozofii nie ma. Jeśli jest jakiekolwiek doświadczenie z arduino. Dołącza się bibliotekę i uruchamia program.

Ja wspominałem coś o bootloaderach. I wprowadziłem trochę niepokoju. Miałem rację o tyle, że bawiąc sie tym pewnie już będzie ze dwa lata temu, korzystałem z rozwiązania: https://github.com/NicoHood/HID
Które poprzez zmianę firmware'u umożliwiało uruchomienie funkcji HID nawet na arduino uno, czy mega. W leonardo jest to już niepotrzebne.

W razie czego mogę pokazać mój program do leonardo/micro:

Kod: [Zaznacz]

#include <PCF8574.h>
#include <Wire.h>
#include <EEPROM.h>


PCF8574 exp1;
PCF8574 exp2;
PCF8574 exp3;


long hallxSuma;
long hallySuma;
long hallzSuma;
long hallx;
long hally;
long hallz;
long hallxMin;
long hallxMax;
long hallyMin;
long hallyMax;
long hallzMin;
long hallzMax;

int xMinAddress=0;
int xMaxAddress=4;
int yMinAddress=8;
int yMaxAddress=12;
int zMinAddress=16;
int zMaxAddress=20;
int offsetXAddress=24;
int offsetYAddress=28;



long offsetX;
long offsetY;
long roznicaX;
long roznicaY;

int os_x;
int os_y;
int os_z;

void setup() {
  analogReference(EXTERNAL);
   
   exp1.begin(0x20);
  exp2.begin(0x21);
  exp3.begin(0x22);
   pinMode(A1, INPUT);
   pinMode(A2, INPUT);
   pinMode(A3, INPUT);

   exp1.pinMode(0,INPUT);
   exp1.pullUp(0);
   exp1.pinMode(1,INPUT);
   exp1.pullUp(1);
   exp1.pinMode(2,INPUT);
   exp1.pullUp(2);
   exp1.pinMode(3,INPUT);
   exp1.pullUp(3);
   exp1.pinMode(4,INPUT);
   exp1.pullUp(4);
   exp1.pinMode(5,INPUT);
   exp1.pullUp(5);
   exp1.pinMode(6,INPUT);
   exp1.pullUp(6);
   exp1.pinMode(7,INPUT);
   exp1.pullUp(7);
 
   exp2.pinMode(0,INPUT);
   exp2.pullUp(0);
    exp2.pinMode(1,INPUT);
   exp2.pullUp(1);
    exp2.pinMode(2,INPUT);
   exp2.pullUp(2);
    exp2.pinMode(3,INPUT);
   exp2.pullUp(3);
    exp2.pinMode(4,INPUT);
   exp2.pullUp(4);
    exp2.pinMode(5,INPUT);
   exp2.pullUp(5);
    exp2.pinMode(6,INPUT);
   exp2.pullUp(6);
    exp2.pinMode(7,INPUT);
   exp2.pullUp(7);

    exp3.pinMode(0,INPUT);
   exp3.pullUp(0);
    exp3.pinMode(1,INPUT);
   exp3.pullUp(1);
    exp2.pinMode(2,INPUT);
   exp3.pullUp(2);
    exp3.pinMode(3,INPUT);
   exp3.pullUp(3);
    exp3.pinMode(4,INPUT);
   exp3.pullUp(4);
    exp3.pinMode(5,INPUT);
   exp3.pullUp(5);
    exp3.pinMode(6,INPUT);
   exp3.pullUp(6);
    exp3.pinMode(7,INPUT);
   exp3.pullUp(7);

hallxMin= EEPROMReadlong(xMinAddress);
hallxMax= EEPROMReadlong(xMaxAddress);
hallyMin= EEPROMReadlong(yMinAddress);
hallyMax= EEPROMReadlong(yMaxAddress);
hallzMin= EEPROMReadlong(zMinAddress);
hallzMax= EEPROMReadlong(zMaxAddress);
offsetX= EEPROMReadlong(offsetXAddress);
offsetY= EEPROMReadlong(offsetYAddress);

   
 Serial.begin(9600);
  Gamepad.begin();
 
}

void loop() {
// -----------  odczyt z czujników i uśrednianianie
// -----------  w celu eliminacji skoków (zakłóceń)
for ( int i=0; i<=99; i++){
 
  hallxSuma= hallxSuma + analogRead(A2);
  hallySuma= hallySuma + analogRead(A1);
  hallzSuma= hallzSuma + analogRead(A3);
}
hallx= hallxSuma/100;
hally= hallySuma/100;
hallz= hallzSuma/100;


// ------------  proste centrowanie (gdyby cyclic nie wrócił fizycznie
// ------------  do punktu centralnego - można go wycentrować wciskając PINKIE
// ------------  i hat switchem wytrymować
if (exp3.digitalRead(2)==LOW & exp1.digitalRead(0)==LOW) offsetX=offsetX-10;   
if (exp3.digitalRead(2)==LOW & exp1.digitalRead(2)==LOW) offsetX=offsetX+10;
if (exp3.digitalRead(2)==LOW & exp1.digitalRead(1)==LOW) offsetY=offsetY-10;
if (exp3.digitalRead(2)==LOW & exp1.digitalRead(3)==LOW) offsetY=offsetY+10;


if (exp2.digitalRead(4)==LOW & exp2.digitalRead(5)==LOW) autokalibracja();
if (exp2.digitalRead(5)==LOW & exp3.digitalRead(2)==LOW) centrowanie();

// mapowanie pozycji z czujników halla na dane directX

os_y= map(hally, hallyMin,hallyMax,-32000,32000);   //,32766
os_x= map(hallx, hallxMin,hallxMax,32000,-32000);
os_z= map(hallz,hallzMin,hallzMax,-127, 127);

// -------- dodawanie poprawki z ręcznego centrowania
os_x=os_x+offsetX;
os_y=os_y+offsetY;

hallxSuma=0;
hallySuma=0;
hallzSuma=0;

//---------- zabezpieczenie gdyby oś wyskoczyła poza zakres

if (os_x>=32000) os_x=32000;
if (os_x<=-32000) os_x=-32000;
if (os_y>=32000) os_y=32000;
if (os_y<=-32000) os_y=-32000;
if (os_z>=127) os_z=127;
if (os_z<=-127) os_z=-127;



// -------- wysyłka danych do kontrolera gier windows
Gamepad.yAxis(os_y);
Gamepad.xAxis(os_x);
Gamepad.zAxis(os_z);

//przyciski na froncie
if (exp2.digitalRead(0)==LOW) Gamepad.press(7);
if (exp2.digitalRead(1)==LOW) Gamepad.press(6);
if (exp2.digitalRead(2)==LOW) Gamepad.press(2);
if (exp2.digitalRead(3)==LOW) Gamepad.press(3);
if (exp2.digitalRead(4)==LOW) Gamepad.press(5);
if (exp2.digitalRead(5)==LOW) Gamepad.press(4);
if (exp2.digitalRead(6)==LOW) Gamepad.press(8);
if (exp2.digitalRead(7)==LOW) Gamepad.press(1);


if (exp3.digitalRead(0)==LOW) Gamepad.press(10);
if (exp3.digitalRead(1)==LOW) Gamepad.press(12);
if (exp3.digitalRead(2)==LOW) Gamepad.press(11);
if (exp3.digitalRead(3)==LOW) Gamepad.press(9);
if (exp3.digitalRead(4)==LOW) Gamepad.press(13);
if (exp3.digitalRead(5)==LOW) Gamepad.press(14);
if (exp3.digitalRead(6)==LOW) Gamepad.press(15);
if (exp3.digitalRead(7)==LOW) Gamepad.press(16);

// hat switche
if (exp1.digitalRead(0)==LOW) Gamepad.dPad1(7); //pov LEFT
if (exp1.digitalRead(1)==LOW) Gamepad.dPad1(1); // pov UP
if (exp1.digitalRead(2)==LOW) Gamepad.dPad1(3); //pov RIGHT
if (exp1.digitalRead(3)==LOW) Gamepad.dPad1(5); //pov DOWN

if (exp1.digitalRead(4)==LOW) Gamepad.dPad2(7);
if (exp1.digitalRead(5)==LOW) Gamepad.dPad2(1);
if (exp1.digitalRead(6)==LOW) Gamepad.dPad2(3);
if (exp1.digitalRead(7)==LOW) Gamepad.dPad2(5);



    // functions above only set the values
    // this writes the report to the host
    Gamepad.write();
Gamepad.releaseAll();
   
   
    //delay(10);
    Serial.flush();
   
    Serial.print("Os x:");
    Serial.print(os_x);
    Serial.print("   hallx:");
    Serial.print(hallx);
    Serial.print("   Os y:");
    Serial.print(os_y);
    Serial.print("   hallY:");
    Serial.print(hally);
    Serial.print("   os_z:");
    Serial.print(os_z);
    Serial.print("   hallZ:");
    Serial.print(hallz);
    Serial.print("   offsetX:");
    Serial.print(offsetX);
    Serial.print("   offsetY:");
    Serial.println(offsetY);
    Serial.print("hallxMin:");
    Serial.print(hallxMin);
     Serial.print("  hallxMax:");
    Serial.print(hallxMax);
    Serial.print("   hallyMin:");
    Serial.print(hallyMin);
     Serial.print("  hallyMax:");
    Serial.print(hallyMax);
    Serial.print("   hallzMin:");
    Serial.print(hallzMin);
     Serial.print("  hallzMax:");
    Serial.print(hallzMax);
      Serial.println();
      Serial.println();
      Serial.println();
      Serial.println();
      Serial.println();
      Serial.println();
       Serial.println();
      Serial.println();
      Serial.println();

}

void autokalibracja(){
 hallxMax=analogRead(A2);
 hallyMax=analogRead(A1);
 hallzMax=analogRead(A3);
 hallxMin=analogRead(A2);
 hallyMin=analogRead(A1);
 hallzMin=analogRead(A3);

 offsetX=0;
 offsetY=0;
  Serial.print("KALIBRACJA");
for ( int i=0; i<=99; i++){
 if (analogRead(A2)> hallxMax) hallxMax=analogRead(A2);
 if (analogRead(A1)> hallyMax) hallyMax=analogRead(A1);
 if (analogRead(A3)> hallzMax) hallzMax=analogRead(A3);
 if (analogRead(A2)< hallxMin) hallxMin=analogRead(A2);
 if (analogRead(A1)< hallyMin) hallyMin=analogRead(A1);
 if (analogRead(A3)< hallzMin) hallzMin=analogRead(A3);


 
delay(100);
}
//dodawanie marginesu błędu
hallxMax+=2;
hallyMax+=5;
hallzMax+=5;
hallxMin-=2;
hallyMin-=5;
hallzMin-=5;

EEPROMWritelong(xMinAddress, hallxMin);
EEPROMWritelong(xMaxAddress, hallxMax);
EEPROMWritelong(yMinAddress, hallyMin);
EEPROMWritelong(yMaxAddress, hallyMax);
EEPROMWritelong(zMinAddress, hallzMin);
EEPROMWritelong(zMaxAddress, hallzMax);
EEPROMWritelong(offsetXAddress, offsetX);
EEPROMWritelong(offsetYAddress, offsetY);
  Serial.println(" ZAKOŃCZONA");
  delay(1000);
}

void centrowanie(){
  Serial.print("CENTROWANIE   ");
  delay(2000);
 
  offsetX=-os_x;
  offsetY=-os_y;
  EEPROMWritelong(offsetXAddress, offsetX);
  EEPROMWritelong(offsetYAddress, offsetY);
  Serial.println("CENTROWANIE ZAKOŃCZONE");
}

long EEPROMReadlong(long address)
      {
      //Read the 4 bytes from the eeprom memory.
      long four = EEPROM.read(address);
      long three = EEPROM.read(address + 1);
      long two = EEPROM.read(address + 2);
      long one = EEPROM.read(address + 3);

      //Return the recomposed long by using bitshift.
      return ((four << 0) & 0xFF) + ((three << 8) & 0xFFFF) + ((two << 16) & 0xFFFFFF) + ((one << 24) & 0xFFFFFFFF);
      }


  //This function will write a 4 byte (32bit) long to the eeprom at
//the specified address to address + 3.
void EEPROMWritelong(int address, long value)
      {
      //Decomposition from a long to 4 bytes by using bitshift.
      //One = Most significant -> Four = Least significant byte
      byte four = (value & 0xFF);
      byte three = ((value >> 8) & 0xFF);
      byte two = ((value >> 16) & 0xFF);
      byte one = ((value >> 24) & 0xFF);

      //Write the 4 bytes into the eeprom memory.
      EEPROM.write(address, four);
      EEPROM.write(address + 1, three);
      EEPROM.write(address + 2, two);
      EEPROM.write(address + 3, one);
      }


z tym, że jak widać, ja mam już nieco zmodyfikowane środowisko i nie muszę dodawać biblioteki w kodzie... ale jak to zrobiłem nie pamiętam. Stosując rozwiązanie zaproponowane przez Macieja. Trzeba dołaczyć bibliotekę <Joystick.h> i tam gdzie u mnie jest gamepad.cośtam zamienić odpowiednie funkcje.
Będa pytania, będziemy myćleć.
Btw. Mój kod pewnie nie jest zoptymalizowany. tzn. dla mnie działa wystarczająco, ale programiści mogą mieć uwagi. Obecnie pracuję nad obsługą ręcznego centrowania. Joystick niestety nie zawsze wraca fizycznie na pozycję zero (rozciągliwe gumy i sprężyny), dlatego tworzę sobie funkcję, która mimo przesunięcia drągala po odpowiedniej kombinacji przycisków wytrymuje mi sygnał wyjściowy do zera.

[maciej]

Serial działa i z niego korzystałem do podpatrywania co mi wyskakuje na portach
Tak wygląda mój kod. Też nie jest optymalizowany ale spełnia funkcje jakich potrzebuje i co najważniejsze działa.

Kod: [Zaznacz]

#include <Joystick.h>

#include <Wire.h>
int c;
int d;
int f;
void setup() {
  Serial.begin(9600);
  Joystick.begin();
  Wire.begin();
  Wire.beginTransmission(0x20);
Wire.write(0x01); // IODIRB register
Wire.write(0xFF); // set all of port B to inputs
Wire.endTransmission();

Wire.beginTransmission(0x20);
Wire.write(0x0D); // GPPUB register
Wire.write(0xFF); // set all of port B pull-up enable
Wire.endTransmission();

 
 Wire.beginTransmission(0x20);
Wire.write(0x00); // IODIRA register
Wire.write(0xFF); // set all of port A to inputs
Wire.endTransmission();

Wire.beginTransmission(0x20);
Wire.write(0x0C); // GPPUA register
Wire.write(0xFF); // set all of port A pull-up enable
Wire.endTransmission();

 Wire.beginTransmission(0x27);
Wire.write(0x01); // IODIRB register
Wire.write(0xFF); // set all of port B to inputs
Wire.endTransmission();

Wire.beginTransmission(0x27);
Wire.write(0x0D); // GPPUB register
Wire.write(0xFF); // set all of port B pull-up enable
Wire.endTransmission();

}

void loop() {
 

Wire.beginTransmission(0x20);
Wire.write(0x13); // read from port B
Wire.endTransmission();
Wire.beginTransmission(0x20);
Wire.requestFrom(0x20,1);
c = Wire.read();
Wire.endTransmission();

 Wire.beginTransmission(0x20);
 Wire.write(0x12); // read from port A
 Wire.endTransmission();
 Wire.beginTransmission(0x20);
 Wire.requestFrom(0x20,1);
 d = Wire.read();
Wire.endTransmission();
 
 Wire.beginTransmission(0x27);
 Wire.write(0x13); // read from port B
 Wire.endTransmission();
 Wire.beginTransmission(0x27);
 Wire.requestFrom(0x27,1);
 f = Wire.read();



 Serial.print("d: ");
 Serial.print(d, BIN);
 Serial.print("\n");

 Serial.print("c: ");
 Serial.print(c, BIN);
 Serial.print("\n");

 Serial.print("f: ");
 Serial.print(f, BIN);
 Serial.print("\n");




if(bitRead(c,0)==0)
{
Joystick.setButton(0,1);
}
else
{
 Joystick.setButton(0,0);
  }

  if(bitRead(c,1)==0)
{
Joystick.setButton(1,1); 
}
else
{
 Joystick.setButton(1,0);
  }

if(bitRead(c,2)==0)
{
Joystick.setButton(2,1);
}
else
{
 Joystick.setButton(2,0);
  }

 
if(bitRead(c,3)==0)
{
Joystick.setButton(3,1);
}
else
{
 Joystick.setButton(3,0);
  }


if(bitRead(c,4)==0)
{
Joystick.setButton(4,1);
}
else
{
 Joystick.setButton(4,0);
  }

 
if(bitRead(c,5)==0)
{
Joystick.setButton(5,1);
}
else
{
 Joystick.setButton(5,0);
  }
 
if(bitRead(c,6)==0)
{
Joystick.setButton(6,1);
}
else
{
 Joystick.setButton(6,0);
  }
 
if(bitRead(c,7)==0)
{
Joystick.setButton(7,1);
}
else
{
 Joystick.setButton(7,0);
  }
// HAT SWITCH 1
if(bitRead(f,4)==0)
{
Joystick.setButton(8,1);
}
else
{
Joystick.setButton(8,0);
  }

if(bitRead(f,5)==0)
{
Joystick.setButton(9,1);

}
else
{
Joystick.setButton(9,0);
  }

  if(bitRead(f,6)==0)
{
Joystick.setButton(10,1);
}
else
{
Joystick.setButton(10,0);
  }

  if(bitRead(f,7)==0)
{
Joystick.setButton(11,1);
}
else
{
Joystick.setButton(11,0);
  }

//HAT SWITCH 2

  if(bitRead(f,0)==0)
{
Joystick.setButton(12,1);
}
else
{
Joystick.setButton(12,0);
  }

if(bitRead(f,1)==0)
{
Joystick.setButton(13,1);
}
else
{
Joystick.setButton(13,0);
  }

  if(bitRead(f,2)==0)
{
Joystick.setButton(14,1);
}
else
{
Joystick.setButton(14,0);
  }

  if(bitRead(f,3)==0)
{
Joystick.setButton(15,1);
}
else
{
 Joystick.setButton(15,0);
  }

    if(bitRead(d,6)==0)
{
Joystick.setButton(16,1);
}
else
{
 Joystick.setButton(16,0);
  }

      if(bitRead(d,0)==0)
{
Joystick.setButton(16,1);
}
else
{
 Joystick.setButton(16,0);
  }
 
      if(bitRead(d,3)==0)
{
Joystick.setButton(17,1);
}
else
{
 Joystick.setButton(17,0);
  }


        if(bitRead(d,4)==0)
{
Joystick.setButton(18,1);
}
else
{
 Joystick.setButton(18,0);
  }

          if(bitRead(d,5)==0)
{
Joystick.setButton(19,1);
}
else
{
Joystick.setButton(19,0);
  }
            if(bitRead(d,6)==0)
{
Joystick.setButton(20,1);
}
else
{
Joystick.setButton(20,0);
  }
            if(bitRead(d,7)==0)
{
Joystick.setButton(21,1);
}
else
{
Joystick.setButton(21,0);
  }
 
}




[vito_zm]

Dzięki za kody. Czekam na Leonardo i będę testować oraz raportować. Co do MMJoy2 to trzeba go dobrze poznać i testować. Z informacji w Internecie wynika, że ma dużo zwolenników. Dla mnie istotne było poznanie jego możliwości jako wsparcie joysticka czyli opcja  Mouse and keyboard i tutaj dla enkoderów jest problem, chociaż z Internetu wynika, że są stosowane.
Przypomnę tylko, że  Damos poświęcił dużo czasu na poprawne działanie różnych typów enkoderów w swoim DMKeys8 i osiągnął dobry rezultat. Testowanie całościowe kontrolera jest dosyć kłopotliwe. W przypadku DMKeys8 musiałem zbudować pełną matrycę 160 pozycji aby znaleźć przesłuch na jednym z wierszy, to tak przy okazji tego tematu. Gdybym chciał testować wszystkie możliwości MMJoy2 to musiałbym zrobić coś podobnego, dlatego uprościłem testy skupiając się na Mouse and keyboard oraz enkoderach.

[vito_zm]

Przejrzałem skrypt macieja i porównałem do swojego. Obydwa realizują to samo zadanie czyli odczyt przycisków w drążku Cougara oraz ich prezentację. Macieja dodatkowo ma przypisania do joysticka i jest widziany w pc. Różnice projektów polegają na zastosowaniu innych rejestrów. W moim przypadku zastosowałem CD 4021 takie jakie są w drążku Cougara. Maciej zastosował MCP23017, które pracują w I2C a moje w SPI. MCP23017 mają opcję pullup, dlatego nie potrzebujemy rezystorów na wejściach rejestrów. Dodatkowa korzyść to biblioteka Wire.h w której są bardzo dobre funkcje, które ułatwiają pisanie skryptu. Skrypt macieja umożliwia realizację drążka Cougara. Pozostałe sprawy czyli osie x, y oraz przepustnicę trzeba dopisać do programu.
Wracając do MMJoy2 to myślę, że dla budowniczych swoich własnych joysticków jest to dobre rozwiązanie pod warunkiem, że realizują tylko joystick. Setup MMJoy2 umożliwia konfigurowanie, nie ma potrzeby pisania skryptów. Dodatkowe funkcje są atrakcyjne tzn. "emulacja klawiatury", ale ryzykowne. Tutaj mogę wspomnieć o moich testach z enkoderem. Może ktoś na forum zrobi takie testy u siebie, będzie możliwość porównania.
Myślę, że projekt zrobienia czegoś podobnego do MMJoy2 jest bardzo atrakcyjny, ale trudny w realizacji. Na poparcie mojej tezy wspomnę o projektach Damosa DMKeys8 oraz DMJoy. Stosuje te same uP co w Leonardo. Problem polega między innymi na małej pamięci tych uP. Damos chciał zrobić DMJoy z możliwością programowania klawiatury, ale nie jest to takie proste. Były problemy z enkoderami, ale zostało to rozwiązane. Dostępne na rynku  tanie enkodery są złej jakości i trudno zrobić program, który to uwzględnia.
Co do mnie to będę dalej zajmował się Arduino w różnych jego zastosowaniach. Ponieważ mam kokpit zrobiony pod BMS4 to próbuję znaleźć zastosowanie dla tego symulatora i  tu jest problem, ale może znajdę na forum informacje jak przechwytywać dane z symulatora i je realizować w Arduino.

[vito_zm]

Maciej zapomniałem zapytać czy Twoje MCP23017 są ustawione na adresy 20 oraz 27 h czyli w jednym A0-A2 na gnd a w drugim A0-A2 na VCC.  Podobnie zegary oraz dane MCP23017 są połączone do SCL oraz SDA Leonardo. Możesz to potwierdzić.

[maciej]

Zgadza się w jednym złącza adresowe są pod GND w drugim pod VCC.

[vito_zm]

Dzięki maciej.
Przejrzałem skrypt shopiK i jestem pod wrażeniem. Nie mam wystarczającej wiedzy aby zrozumieć ten program, ale tylko pewne fragmenty są dla mnie rozumiałe. Program realizuje całościowo joystick czyli uwzględnia także analogi. Rejestry są inne PCF8574, ale także I2C oraz z pullup. Jest natomiast dołączona biblioteka EEPROM.h czyli ingerencja w pamięć . Najciekawsze jest programowanie analogów, ale tutaj jestem niekompetentny.
Myślę, że wrócę do MMJoy2 i do testowania analogów, zobaczymy jak to tam wygląda.

[shopiK]

Nie interesowałem się wcześniej programem mmjoy. Stąd mój program obsługuje joystick w sposób całościowy. to znaczy: po podpięciu do portu usb ma działać jako joystick bez żadnych dodatkowych aplikacji zewnętrznych. Z tej różnicy podejścia z kolei ja jeszcze nie rozumiem, do czego używacie mmjoy. Muszę jeszcze o tym poczytać.

Mój program wbrew pozorom nie jest jakiś specjalnie trudny. Do pamięci eeprom odwołuje się dlatego, że zastosowałem swoją własną kalibrację. Po wcisnięciu odpowiedniej kombinacji przycisków włącza się tryb kalibracji. Program czeka, aż zakręcę joyem jak w kalibratorze windows i do pamięci zapisuje wartości minimalne i maksymalne. Pamięć eeprom jest nieulotna - po odłączeniu zasilania zapis nie znika, więc nie trzeba kalibrować za każdym razem.

Dodatkowo kombinuję trochę z funkcją auto centrowania. Mój joystick, ze względu na amatorską konstrukcję nie zawsze fizycznie wraca do absolutnego zera. I znowu odpowiednia funkcja - autocentrowanie - pozwala ustawić pozycje joya w windows dokładnie na środku (mimo, iż tak fizycznie do absolutnego środka nie wrócił). Ta funkcja jest jeszcze niedopracowana.

Aha. Mówisz, że ciekawe jest oprogramowanie analogów. Jest to bardzo prosta aplikacja. Odczytuję wartość czujnika i mapuję to na wartości wymagane dla direct Input windowsa. Problem jaki zaistniał to szum z czujników. Czyli minimalne skoki odczytywanej wartości. W grze, czy okienku kontrolera gier windowsa - krzyżyk joysticka trochę skakał. dlatego zastosowałem bardzo proste uśrednianie wartości. W odstępie kilkudziesięciu milisekund zczytuję 100 wartości czujnika i wyciągam średnią arytmetyczną. dla mnie to rozwiązanie wystarczy. Próbowałem walczyć z filtrem kalmana, ale niestety potrzebuje on chyba danych z kilku czujników. A my mamy przecież tylko jeden czujnik na oś.

[vito_zm]

Dzięki za wyjaśnienia. Ja także dopiero poznaję MMJoy2. Jest tam dużo możliwości między innym możliwość podłączenia zewnętrzego  przetwornika ac. Chcę wrócić do tego programu i poznać jego możliwości pod kątem analogów. Z drugiej strony takie uniwersalne programy jak MMJoy2 są dla mnie podejrzane, ponieważ możliwości uP (pamięci) są ograniczone i trudno napisać dobry program. Dlatego Damos zrobił 2 specjalistyczne  kontrolery DMKeys8 dla elementów "cyfrowych" i DMJoy dla analogów. Nie jestem programistą, dlatego trudno mnie to obiektywnie ocenić.
Podziwiam Twoje podejście do problemu i sposób jego rozwiązania. To wymaga niestety trochę więcej wiedzy. W moim przypadku zainteresowałem się Arduino od niedawna i jestem pod wrażeniem. Projektowałem tzw. hardware tradycyjnie. Teraz widzę, że wystarczy poznać możliwości bibliotek i można projektować na układach bardziej złożonych to jest duży postęp.

[shopiK]

Teraz widzę, że wystarczy poznać możliwości bibliotek i można projektować na układach bardziej złożonych to jest duży postęp.

Tak. Dobry przykład to funkcje eepromWriteLong i readlong w moim kodzie. Służą do odczytywania i zapisywania wartości wiekszych niż 255 w komórkach pamięci... Absolutnie nie wiem jak działają te funkcje, bo nawet nie czytałem specjalnie ich kodu. Tylko wkleiłem i używam To jest potęga społeczności arduino. Masa problemów, które napotykamy, ma już swoje rozwiązanie w sieci. Z bazy przykładów bierzemy co potrzebne i w drogę.