Conversion clavier Amiga 600 en USB

Forum Amiga Hardware Conversion clavier Amiga 600 en USB

  • Ce sujet contient 4 réponses, 3 participants et a été mis à jour pour la dernière fois par Flop, le il y a 1 mois.
  • Créateur
    Sujet
  • #92611
    Flop
    • Level 1
    • Messages : 11

    Bonsoir,

    J’ai remis le nez dans le monde Amiga.
    J’avais lâché l’affaire la dernière fois en essayant de restaurer mon amiga 600.
    Carte mère rouillé inutilisable jetée, clavier dont certains contact de la membrane était HS.
    Mon frère à revitalisé son Amiga 600, le sien est en état de marche.
    Ça m’a redonné envie de faire quelque chose.
    Je suis parti sur un raspberry pi 2 avec Amibian puis un peu dégouté qu’il faille payer pour avoir la dernière version je suis passé sur un Amiberry avec raspbian buster.
    j’ai réussi à réparer physiquement mon clavier A600 en l’ouvrant et en arrachant ( sic ! ) la protection verte de la membrane grâce à du scotch très fort pour pouvoir refaire les 3 contact défectueux. ( j’avais déjà fait un essai il y a deux ans mais il y avait plein de faux contact ).

    Et après c’est parti pour l’adaptation en clavier USB avec un Arduino pro Micro ( arduino capable d’émuler un clavier USB ! ).
    Tout fonctionne y compris la gestion des leds du clavier Amiga ( activité floppy et disk ).

    Je ne sais pas encore comment poster des photos ici, mais si je trouve je vous montrerai ce que j’ai fait au niveau éléctronique et publierai le code source pour le leonardo.

    edit : j’ai trouvé l’ajout de photo !

    après réparation j’ai démonté le clavier pour nettoyer :

     

    Ensuite élaboration du schéma electronique de gestion des 5 lignes et 15 colonnes du clavier ainsi que les touches spéciales :

    Pendant les essais :

    Et en fonction :

    J’essaye de voir comment poster le code source sans que ça prenne trop de place sur le sujet.

4 réponses de 1 à 4 (sur un total de 4)

Partager sur vos réseaux sociaux préférés :
Facebooktwitterredditpinterestlinkedintumblrmail

  • Auteur
    Réponses
  • #93348
    KathleenKathleen
    • Level 6
    • Messages : 337

    @Flop,

    Oh mais c’est super ça. Donc avec un Mister ça fonctionne aussi alors.

    Je sens que je vais encore donner du travail à mon ami pour qu’il me réalise ça :-) (une fois que tu auras mis toutes les infos) car il me reste un clavier de A600

    Ah mince j’avais pas vu de suite pour Amibian à partir de la 1.5 ça devient payant apparemment. C’est de plus en plus le cas il me semble. Idem pour certains cores Mister qui étaient free au départ et qui passent en payant. J’aime pas du tout la formule être « supporter » en tout cas, qui fait qu’il faut payer tous les moins une certaine somme d’argent.

    En espérant que Amiberry ne suive pas le même chemin.

    En tout cas merci pour le partage de ce projet bien sympa.



    #93353
    Flop
    • Level 1
    • Messages : 11

    Bonjour,

    Je ne connaissais pas le Mister ( entre temps je l’ai résolu ! ).
    Vu ce que c’est il doit être possible pour des experts de coder sur le mister et de brancher le clavier en direct dessus.
    Mais on peut aussi utiliser ma conversion pour le brancher en usb.

    Je ne trouve pas comment mettre une pièce jointe de type texte ici.
    Je vais donc poster le code tel quel:

     

    Petite précision qu’on a pas sur le schéma puisque que modifié après , j’ai rajouté la connexion aux leds du claviers
    #define NUMLED A0 est connecté à la led Floppy
    #define SCROLLLED 15 est connecté à la led DISK

    Après il suffit dans Amiberry de définir numlock en Disk et ScrollLed en Floppy par exemple

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    // Conversion clavier AMIGA 600 en USB
    // Necessite les fichiers modifiés HID.c HID.cpp Keyboard.c keyboard.cpp
    // pour la gestion des leds Clavier.
    // Arduino IDE 1.8.4 sans mise à jour.
    // Arduino Leonardo ou Pro Micro (32U4)
    // Fichiers disponible ici : https://forum.arduino.cc/index.php?topic=173583.msg3447862#msg3447862
    // Par Flop 20/06/2020
    //
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    #define DEBUG 0

    #include <Wire.h> //i2c
    #include « Adafruit_MCP23017.h »
    #include « Keyboard.h »

    //definition des sorties de l’arduino utilisés par le HC595
    #define WRITE_CLOCK_PIN A3
    #define WRITE_DATA_PIN A1
    #define WRITE_LATCH_PIN A2

    //definition de la sortie pour les LEDs
    #define CAPSLED 4
    #define NUMLED A0
    #define SCROLLLED 15

    //definition des entréés pour chaque touche spéciales
    #define RIGHT_SHIFT 8
    #define RIGHT_ALT 9
    #define RIGHT_AMIGA 7
    #define CTRL 6
    #define LEFT_SHIFT 16
    #define LEFT_ALT 5
    #define LEFT_AMIGA 10

    // buffer clavier
    uint8_t buffer[]={0,0,0,0,0}; //contient les touches en cours d’appui lors du scan actuel
    uint8_t old_buffer[]={0,0,0,0,0}; //contient les touches appuyé du scan précédent
    uint8_t buffer_index=0;
    uint8_t old_buffer_index=0;

    //matrice contenant les codes touches universersels en fonction de l’emplacement sur le clavier amiga
    uint8_t keyb_matrix[5][15]={{0x29,0x00,0x3A,0x3B,0x3C,0x3D,0x3E,0x00,0x3F,0x00,0x40,0x41,0x42,0x43,0x45},
    {0x35,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x2D,0x2E,0x64,0x52},
    {0x2B,0x14,0x1A,0x08,0x15,0x17,0x1C,0x18,0x0C,0x12,0x13,0x2F,0x30,0x28,0x50},
    {0x39,0x04,0x16,0x07,0x09,0x0A,0x0B,0x0D,0x0E,0x0F,0x33,0x34,0x32,0x63,0x49},
    {0x64,0x1D,0x1B,0x06,0x19,0x05,0x11,0x10,0x36,0x37,0x2E,0x00,0x2C,0x2A,0x51}};

    uint8_t keyb_speciales[7]={KEY_RIGHT_SHIFT ,KEY_RIGHT_ALT ,KEY_RIGHT_GUI ,KEY_LEFT_CTRL,KEY_LEFT_SHIFT,KEY_LEFT_ALT ,KEY_LEFT_GUI }; // code touches des 7 touches spéciales gérées à part

    uint8_t ledstatus=0; // Contient le status des leds clavier

    Adafruit_MCP23017 mcp; //ajout du MCP23017

    uint16_t lastState = 0;
    uint16_t State=0;

    void Output_buffer(){
    Serial.print(« buffer: »);
    for (int i=0;i<=buffer_index;i++)
    {

    Serial.print(i);
    Serial.print(« : »);
    Serial.print(buffer,HEX);
    Serial.print( » : »);
    }
    Serial.println(« Q »);
    Serial.print(« oldbuffer: »);
    for (int i=0;i<=old_buffer_index;i++)
    {

    Serial.print(i);
    Serial.print(« : »);
    Serial.print(old_buffer,HEX);
    Serial.print( » : »);
    }
    Serial.println(« Q »);

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////////
    // SETUP
    //
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    void setup() {
    delay(5000);

    pinMode(14,INPUT);

    pinMode(WRITE_LATCH_PIN, OUTPUT);
    pinMode(WRITE_CLOCK_PIN, OUTPUT);
    pinMode(WRITE_DATA_PIN, OUTPUT);

    pinMode(CAPSLED,OUTPUT);
    digitalWrite(CAPSLED,LOW);
    pinMode(NUMLED,OUTPUT);
    digitalWrite(NUMLED,LOW);
    pinMode(SCROLLLED,OUTPUT);
    digitalWrite(SCROLLLED,LOW);

    pinMode(RIGHT_SHIFT,INPUT_PULLUP);
    pinMode(RIGHT_ALT,INPUT_PULLUP);
    pinMode(RIGHT_AMIGA,INPUT_PULLUP);
    pinMode(CTRL,INPUT_PULLUP);
    pinMode(LEFT_SHIFT,INPUT_PULLUP);
    pinMode(LEFT_ALT,INPUT_PULLUP);
    pinMode(LEFT_AMIGA,INPUT_PULLUP);

    if (DEBUG) Serial.begin(9600);

    //// mise en route MCP23017 et pin en input pullup
    mcp.begin();
    for (int i=0;i<16;i++)
    {
    mcp.pinMode(i, INPUT);
    mcp.pullUp(i,HIGH);
    }

    //// mise à zéro de toutes les sorties du HC595
    digitalWrite(WRITE_LATCH_PIN, LOW);
    shiftOut(WRITE_DATA_PIN, WRITE_CLOCK_PIN, LSBFIRST, 0x00);
    digitalWrite(WRITE_LATCH_PIN, HIGH);

    // On est pret, on active la fonction clavier
    buffer_index=0;
    old_buffer_index=0;
    Keyboard.begin();
    if (DEBUG) Serial.println(« Démarré »);
    }

    ////////////////////////////////////////////////////////////////////////////////////
    // Add_buffer
    //
    // Gère l’ajout d’appui de touche dans la liste des touches appuyées
    //
    /////////////////////////////////////////////////////////////////////////////////////
    void Add_buffer(uint8_t code_touche){

    boolean exist=false;

    if (buffer_index>4) // gestion dépassement buffer, si dépassement on ignore la touche
    exit;

    //vérification si touche déja présente dans buffer
    for (int i=0;i<buffer_index;i++)
    {
    if (buffer==code_touche) // touche déjà présente
    exist=true;
    }
    if (exist==false){ // la touche n’est pas présente dans le buffer
    buffer_index++;
    buffer[buffer_index]=code_touche; // on l’ajoute au buffer clavier
    // if (DEBUG) Serial.print(« Ajout buffer : »);
    // if (DEBUG) Serial.print(« pos: »);
    // if (DEBUG) Serial.print(buffer_index);
    // if (DEBUG) Serial.print( » valeur: »);
    // if (DEBUG) Serial.println(buffer[buffer_index]);
    }
    }

    /////////////////////////////////////////////////////////////////////////////////////////
    // comparaison_buffer
    // Compare les buffers entre deux scans consécutifs pour gérer l’appui ou relache
    // d’une touche
    //
    /////////////////////////////////////////////////////////////////////////////////////////

    void comparaison_buffer(){

    uint8_t val=0;
    boolean present=false;
    int i=0;
    int j=0;

    //if ( old_buffer_index==0 ) exit;

    for (j=0;j<=buffer_index;j++) // pour chaque touche présente dans le buffer on vérifie si elle vient d’arriver
    {
    present=false;
    for (i=0;i<=old_buffer_index;i++) // on compare avec chaque touche de l’ancien buffer si déjà présente
    {
    if (buffer[j]==old_buffer) present=true;
    }
    if (present==false){ // la touche en buffer[j] n’était pas présente dans l’ancien buffer, elle vient d’être appuyée
    Keyboard.press(buffer[j]); // alors on envoit le code touche appuyé
    if (DEBUG) Serial.print(« Appui : »);
    if (DEBUG) Serial.println(buffer[j]+136);
    }
    }

    for (j=0;j<=old_buffer_index;j++) // pour chaque touche présente dans l’ancien buffer
    {
    present=false;
    for (i=0;i<=buffer_index;i++) // on compare avec chaque touche du buffer actuel si la touche est encore appuyé
    {
    if (old_buffer[j]==buffer) present=true;
    }
    if (present==false){ // la touche en old_buffer[j] n’est plus présente dans le nouveau buffer, elle n’est plus appuyée
    Keyboard.release(old_buffer[j]); // alors on envoit le code touche appuyé
    if (DEBUG) Serial.print(« Relache : »);
    if (DEBUG) Serial.println(old_buffer[j]+136);
    }
    }

    copie_buffer(); // le nouveau buffer est copié en tant qu’ancien pour le prochain passage
    buffer_index=0; // on repart à zéro sur le buffer actuel

    }

    /////////////////////////////////////////////////////////////////////////////////////////
    // copie_buffer
    //
    // copie du buffer clavier actuel vers la sauvegarde
    //
    /////////////////////////////////////////////////////////////////////////////////////////

    void copie_buffer(){
    for (int i=0;i<=5;i++)
    old_buffer=buffer;
    old_buffer_index=buffer_index;
    buffer_index=0;
    }

    /////////////////////////////////////////////////////////////////////////////////////
    // SCAN
    // récupère l’état ( appuyé ou non ) des touches
    // et rempli le buffer avec les codes touches correspondantes
    //
    ////////////////////////////////////////////////////////////////////////////////////

    void scan(){

    // Lecture Touches spéciales
    if (digitalRead(RIGHT_SHIFT)==false) {
    // if (DEBUG) Serial.println(keyb_speciales[0],HEX);
    Add_buffer(keyb_speciales[0]);
    }
    if (digitalRead(RIGHT_ALT)==false) {
    // if (DEBUG) Serial.println(keyb_speciales[1],HEX);
    Add_buffer(keyb_speciales[1]);
    }
    if (digitalRead(RIGHT_AMIGA)==false){
    // if (DEBUG) Serial.println(keyb_speciales[2],HEX);
    Add_buffer(keyb_speciales[1]);
    }
    if (digitalRead(CTRL)==false) {
    // if (DEBUG) Serial.println(keyb_speciales[3],HEX);
    Add_buffer(keyb_speciales[3]);
    }
    if (digitalRead(LEFT_SHIFT)==false){
    // if (DEBUG) Serial.println(keyb_speciales[4],HEX);
    Add_buffer(keyb_speciales[4]);
    }
    if (digitalRead(LEFT_ALT)==false) {
    // if (DEBUG) Serial.println(keyb_speciales[5],HEX);
    Add_buffer(keyb_speciales[5]);
    }
    if (digitalRead(LEFT_AMIGA)==false) {
    // if (DEBUG) Serial.println(keyb_speciales[6],HEX);
    Add_buffer(keyb_speciales[6]);
    }

    // Lecture clavier
    for (int i=0;i<5;i++) // pour chaque ligne du clavier
    {
    //lecture Matrice
    digitalWrite(WRITE_LATCH_PIN, LOW);
    shiftOut(WRITE_DATA_PIN, WRITE_CLOCK_PIN, MSBFIRST, ~(1<<i)); // envoi de 00001 puis 00010 puis 00100 puis 01000 puis 10000
    digitalWrite(WRITE_LATCH_PIN, HIGH);
    State=mcp.readGPIOAB(); // lecture de la ligne

    for (uint16_t j=0;j<15;j++) // dans la ligne , pour chaque colonne
    {
    if ( ( (~State>>j ) & 1) == 1 ) // si la colonne est à 0 c’est que une touche à mis au gnd cette colonne
    {
    // if (DEBUG) Serial.print(i);
    // if (DEBUG) Serial.print(« : »);
    // if (DEBUG) Serial.print(j);
    // if (DEBUG) Serial.print(« : »);
    // if (DEBUG) Serial.println(keyb_matrix[j],HEX);
    Add_buffer(keyb_matrix[j]+136); // on rajoute cette touche à liste des touches appuyées
    // Keyboard.press(keyb_matrix[j]+136);
    // delay(100);
    // Keyboard.release(keyb_matrix[j]+136);

    }
    }
    }

    comparaison_buffer(); //comparaison des deux buffers pour gérer appui nouvelles touches et relache touche plus appuyées
    // Output_buffer();
    }

    void KeyboardLeds(){
    if (DEBUG){
    Serial.print(« CAPSLOCK : « );
    Serial.println(Keyboard.getLedStatus(LED_CAPS_LOCK));
    Serial.print(« NUMLED : « );
    Serial.println(Keyboard.getLedStatus(LED_NUM_LOCK));
    Serial.print(« SCROLLLED : « );
    Serial.println(Keyboard.getLedStatus(LED_SCROLL_LOCK));
    }

    digitalWrite(CAPSLED,Keyboard.getLedStatus(LED_CAPS_LOCK));
    digitalWrite(NUMLED,Keyboard.getLedStatus(LED_NUM_LOCK));
    digitalWrite(SCROLLLED,Keyboard.getLedStatus(LED_SCROLL_LOCK));
    }

    /////////////////////////////////////////////////////////////////////////////////////////
    // LOOP
    //
    /////////////////////////////////////////////////////////////////////////////////////////

    void loop() {

    scan();
    KeyboardLeds();
    //if (digitalRead(14)==0) Output_buffer();
    }

     

    #95699
    Staff
    JimJim
    • Level 20
    • Messages : 5240

    Sinon pour info il y a le Keyrah qui fait ca directement (Clavier+leds) avec des ports DB9 en prime pour jouer avec un vrai joystick histoire de garder l’immersion : On vend ca à peine 35€ sur la boutique. Je n’ai pas calculé le coût de ton montage mais pour celui qui n’a pas envie de se prendre la tête c’est peut être plus simple et rentable (au moins en temps ! ;-) )

    Mais j’avoue que pour celui qui aime bricoler c’est moins jouissif :yahoo:

    A500 - A500 Plus - A600 HD - A1200 - A2000 - A4000T - CD32 - C=64 - 1040STE - CPC6128
    Micromiga.com - Le Webshop Amiga

    #95749
    Flop
    • Level 1
    • Messages : 11

    Mais j’avoue que pour celui qui aime bricoler c’est moins jouissif :yahoo:

    C’est ça, J’avais tout sous la main et ça m’amuse donc pour moi c’était gratuit et fun :yes:

Partager sur vos réseaux sociaux préférés :
Facebooktwitterredditpinterestlinkedintumblrmail
4 réponses de 1 à 4 (sur un total de 4)
  • Vous devez être connecté pour répondre à ce sujet.