Macro/buffer/macro.c

   1 /* Copyright (C) 2011 by Jacob Alexander
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to deal
   5  * in the Software without restriction, including without limitation the rights
   6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7  * copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  19  * THE SOFTWARE.
  20  */
  21
  22 // ----- Includes -----
  23
  24 // AVR Includes
  25 #include <util/delay.h>
  26 #include <avr/interrupt.h>
  27
  28 // Project Includes
  29 #include <led.h>
  30 #include <print.h>
  31 #include <scan_loop.h>
  32 #include <usb_com.h>
  33
  34 // Keymaps
  35 #include <keymap.h>
  36 #include <usb_keys.h>
  37
  38 // Local Includes
  39 #include "macro.h"
  40
  41
  42
  43 // ----- Variables -----
  44
  45 // Keeps track of the sequence used to reflash the teensy in software
  46 static uint8_t Bootloader_ConditionSequence[] = {1,16,6,11};
  47        uint8_t Bootloader_ConditionState      = 0;
  48        uint8_t Bootloader_NextPositionReady   = 1;
  49        uint8_t Bootloader_KeyDetected         = 0;
  50
  51
  52
  53 // ----- Functions -----
  54
  55 inline void macro_finishedWithBuffer(void)
  56 {
  57         /* BudKeypad
  58         // Boot loader sequence state handler
  59         switch ( KeyIndex_BufferUsed )
  60         {
  61         // The next bootloader key can now be pressed, if there were no keys processed
  62         case 0:
  63                 Bootloader_NextPositionReady = 1;
  64                 break;
  65         // If keys were detected, and it wasn't in the sequence (or there was multiple keys detected), start bootloader sequence over
  66         // This case purposely falls through
  67         case 1:
  68                 if ( Bootloader_KeyDetected )
  69                         break;
  70         default:
  71                 Bootloader_ConditionState = 0;
  72                 break;
  73         }
  74
  75         Bootloader_KeyDetected = 0;
  76         */
  77 }
  78
  79 void jumpToBootloader(void)
  80 {
  81         cli();
  82         // disable watchdog, if enabled
  83         // disable all peripherals
  84         UDCON = 1;
  85         USBCON = (1<<FRZCLK);  // disable USB
  86         UCSR1B = 0;
  87         _delay_ms(5);
  88
  89 #if defined(__AVR_AT90USB162__)                // Teensy 1.0
  90         EIMSK = 0; PCICR = 0; SPCR = 0; ACSR = 0; EECR = 0;
  91         TIMSK0 = 0; TIMSK1 = 0; UCSR1B = 0;
  92         DDRB = 0; DDRC = 0; DDRD = 0;
  93         PORTB = 0; PORTC = 0; PORTD = 0;
  94         asm volatile("jmp 0x3E00");
  95 #elif defined(__AVR_ATmega32U4__)              // Teensy 2.0
  96         EIMSK = 0; PCICR = 0; SPCR = 0; ACSR = 0; EECR = 0; ADCSRA = 0;
  97         TIMSK0 = 0; TIMSK1 = 0; TIMSK3 = 0; TIMSK4 = 0; UCSR1B = 0; TWCR = 0;
  98         DDRB = 0; DDRC = 0; DDRD = 0; DDRE = 0; DDRF = 0; TWCR = 0;
  99         PORTB = 0; PORTC = 0; PORTD = 0; PORTE = 0; PORTF = 0;
 100         asm volatile("jmp 0x7E00");
 101 #elif defined(__AVR_AT90USB646__)              // Teensy++ 1.0
 102         EIMSK = 0; PCICR = 0; SPCR = 0; ACSR = 0; EECR = 0; ADCSRA = 0;
 103         TIMSK0 = 0; TIMSK1 = 0; TIMSK2 = 0; TIMSK3 = 0; UCSR1B = 0; TWCR = 0;
 104         DDRA = 0; DDRB = 0; DDRC = 0; DDRD = 0; DDRE = 0; DDRF = 0;
 105         PORTA = 0; PORTB = 0; PORTC = 0; PORTD = 0; PORTE = 0; PORTF = 0;
 106         asm volatile("jmp 0xFC00");
 107 #elif defined(__AVR_AT90USB1286__)             // Teensy++ 2.0
 108         EIMSK = 0; PCICR = 0; SPCR = 0; ACSR = 0; EECR = 0; ADCSRA = 0;
 109         TIMSK0 = 0; TIMSK1 = 0; TIMSK2 = 0; TIMSK3 = 0; UCSR1B = 0; TWCR = 0;
 110         DDRA = 0; DDRB = 0; DDRC = 0; DDRD = 0; DDRE = 0; DDRF = 0;
 111         PORTA = 0; PORTB = 0; PORTC = 0; PORTD = 0; PORTE = 0; PORTF = 0;
 112         asm volatile("jmp 0x1FC00");
 113 #endif
 114 }
 115
 116 // Given a sampling array, and the current number of detected keypress
 117 // Add as many keypresses from the sampling array to the USB key send array as possible.
 118 /*
 119 inline void keyPressDetection( uint8_t *keys, uint8_t numberOfKeys, uint8_t *modifiers, uint8_t numberOfModifiers, uint8_t *map )
 120 {
 121         uint8_t Bootloader_KeyDetected = 0;
 122         uint8_t processed_keys         = 0;
 123
 124         // Parse the detection array starting from 1 (all keys are purposefully mapped from 1 -> total as per typical PCB labels)
 125         for ( uint8_t key = 0; key < numberOfKeys + 1; key++ )
 126         {
 127                 if ( keys[key] & (1 << 7) )
 128                 {
 129                         processed_keys++;
 130
 131                         // Display the detected scancode
 132                         char tmpStr[4];
 133                         int8ToStr( key, tmpStr );
 134                         dPrintStrs( tmpStr, " " );
 135
 136                         // Is this a bootloader sequence key?
 137                         if ( !Bootloader_KeyDetected
 138                            && Bootloader_NextPositionReady
 139                            && key == Bootloader_ConditionSequence[Bootloader_ConditionState] )
 140                         {
 141                                 Bootloader_KeyDetected = 1;
 142                                 Bootloader_NextPositionReady = 0;
 143                                 Bootloader_ConditionState++;
 144                         }
 145                         else if ( Bootloader_ConditionState > 0 && key == Bootloader_ConditionSequence[Bootloader_ConditionState - 1] )
 146                         {
 147                                 Bootloader_KeyDetected = 1;
 148                         }
 149
 150                         // Determine if the key is a modifier
 151                         uint8_t modFound = 0;
 152                         for ( uint8_t mod = 0; mod < numberOfModifiers; mod++ ) {
 153                                 // Modifier found
 154                                 if ( modifiers[mod] == key ) {
 155                                         USBKeys_Modifiers |= map[key];
 156                                         modFound = 1;
 157                                         break;
 158                                 }
 159                         }
 160
 161                         // Modifier, already done this loop
 162                         if ( modFound )
 163                                 continue;
 164
 165                         // Too many keys
 166                         if ( USBKeys_Sent >= USBKeys_MaxSize )
 167                         {
 168                                 info_print("USB Key limit reached");
 169                                 errorLED( 1 );
 170                                 break;
 171                         }
 172
 173                         // Allow ignoring keys with 0's
 174                         if ( map[key] != 0 )
 175                                 USBKeys_Array[USBKeys_Sent++] = map[key];
 176                 }
 177         }
 178
 179         // Boot loader sequence state handler
 180         switch ( processed_keys )
 181         {
 182         // The next bootloader key can now be pressed, if there were no keys processed
 183         case 0:
 184                 Bootloader_NextPositionReady = 1;
 185                 break;
 186         // If keys were detected, and it wasn't in the sequence (or there was multiple keys detected), start bootloader sequence over
 187         // This case purposely falls through
 188         case 1:
 189                 if ( Bootloader_KeyDetected )
 190                         break;
 191         default:
 192                 Bootloader_ConditionState = 0;
 193                 break;
 194         }
 195
 196         // Add debug separator if keys sent via USB
 197         if ( USBKeys_Sent > 0 )
 198                 print("\033[1;32m|\033[0m\n");
 199 }
 200 */
 201
 202 // Scancode Macro Detection
 203 int scancodeMacro( uint8_t scanCode )
 204 {
 205         /*
 206         if ( scanCode == 0x7A )
 207         {
 208                 scan_resetKeyboard();
 209         }
 210         else
 211         {
 212                 scan_sendData( scanCode );
 213                 _delay_ms( 200 );
 214                 scan_sendData( 0x80 | scanCode );
 215         }
 216         return 1;
 217         */
 218         // BudKeypad
 219         // Is this a bootloader sequence key?
 220         if ( !Bootloader_KeyDetected
 221            && Bootloader_NextPositionReady
 222            && scanCode == Bootloader_ConditionSequence[Bootloader_ConditionState] )
 223         {
 224                 Bootloader_KeyDetected = 1;
 225                 Bootloader_NextPositionReady = 0;
 226                 Bootloader_ConditionState++;
 227                 erro_dPrint("detect");
 228         }
 229         else if ( Bootloader_ConditionState > 0 && scanCode == Bootloader_ConditionSequence[Bootloader_ConditionState - 1] )
 230         {
 231                 Bootloader_KeyDetected = 0;
 232                 Bootloader_NextPositionReady = 1;
 233                 erro_dPrint("detect-again!");
 234         }
 235         // Cancel sequence
 236         else
 237         {
 238                 Bootloader_KeyDetected = 0;
 239                 Bootloader_NextPositionReady = 1;
 240                 Bootloader_ConditionState = 0;
 241                 erro_dPrint("Arg");
 242         }
 243
 244         return 0;
 245 }
 246
 247 uint8_t sendCode = 0;
 248
 249 // USBCode Macro Detection
 250 int usbcodeMacro( uint8_t usbCode )
 251 {
 252         /*
 253         // Keyboard Input Test Macro
 254         switch ( usbCode )
 255         {
 256         case KEY_F1:
 257                 sendCode--;
 258                 scan_sendData( 0x90 );
 259                 scan_sendData( sendCode );
 260                 _delay_ms( 200 );
 261                 break;
 262
 263         case KEY_F2:
 264                 scan_sendData( 0x90 );
 265                 scan_sendData( sendCode );
 266                 _delay_ms( 200 );
 267                 break;
 268
 269         case KEY_F3:
 270                 sendCode++;
 271                 scan_sendData( 0x90 );
 272                 scan_sendData( sendCode );
 273                 _delay_ms( 200 );
 274                 break;
 275
 276         default:
 277                 return 0;
 278         }
 279
 280         return 1;
 281         */
 282         return 0;
 283 }
 284
 285
 286 // Given a list of keypresses, translate into the USB key codes
 287 // The buffer is cleared after running
 288 // If the buffer doesn't fit into the USB send array, the extra keys are dropped
 289 void keyPressBufferRead( uint8_t *modifiers, uint8_t numberOfModifiers, uint8_t *map )
 290 {
 291         // Loop through input buffer
 292         for ( uint8_t index = 0; index < KeyIndex_BufferUsed; index++ )
 293         {
 294                 // Get the keycode from the buffer
 295                 uint8_t key = KeyIndex_Buffer[index];
 296
 297                 // Check key for special usages using the scancode
 298                 // If non-zero return, ignore normal processing of the scancode
 299                 if ( scancodeMacro( key ) )
 300                         continue;
 301
 302                 // Check key for special usages using the usbcode
 303                 // If non-zero return, ignore normal processing of the usbcode
 304                 if ( usbcodeMacro( map[key] ) )
 305                         continue;
 306
 307                 // Determine if the key is a modifier
 308                 uint8_t modFound = 0;
 309                 for ( uint8_t mod = 0; mod < numberOfModifiers; mod++ ) {
 310                         // Modifier found
 311                         if ( modifiers[mod] == key ) {
 312                                 USBKeys_Modifiers |= map[key];
 313                                 modFound = 1;
 314                                 break;
 315                         }
 316                 }
 317
 318                 // Modifier, already done this loop
 319                 if ( modFound )
 320                         continue;
 321
 322                 // Too many keys
 323                 if ( USBKeys_Sent >= USBKeys_MaxSize )
 324                 {
 325                         info_print("USB Key limit reached");
 326                         errorLED( 1 );
 327                         break;
 328                 }
 329
 330                 // Allow ignoring keys with 0's
 331                 if ( map[key] != 0 )
 332                 {
 333                         USBKeys_Array[USBKeys_Sent++] = map[key];
 334                 }
 335                 else
 336                 {
 337                         // Key was not mapped
 338                         // TODO Add dead key map
 339                         char tmpStr[6];
 340                         hexToStr( key, tmpStr );
 341                         erro_dPrint( "Key not mapped... - ", tmpStr );
 342                         errorLED( 1 );
 343                 }
 344         }
 345
 346         // Signal Macro processor that all of the buffered keys have been processed
 347         macro_finishedWithBuffer();
 348
 349         // Signal buffer that we've used it
 350         scan_finishedWithBuffer();
 351 }
 352
 353 inline void process_macros(void)
 354 {
 355         // Online process macros once (if some were found), until the next USB send
 356         if ( USBKeys_Sent != 0 )
 357                 return;
 358
 359         // Query the input buffer for keypresses
 360         keyPressBufferRead( MODIFIER_MASK, sizeof(MODIFIER_MASK), KEYINDEX_MASK );
 361
 362         // Check for bootloader condition
 363         if ( Bootloader_ConditionState == sizeof( Bootloader_ConditionSequence ) )
 364                 jumpToBootloader();
 365 }
 366