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         }
 228         else if ( Bootloader_ConditionState > 0 && scanCode == Bootloader_ConditionSequence[Bootloader_ConditionState - 1] )
 229         {
 230                 Bootloader_KeyDetected = 1;
 231         }
 232         */
 233         return 0;
 234 }
 235
 236 uint8_t sendCode = 0;
 237
 238 // USBCode Macro Detection
 239 int usbcodeMacro( uint8_t usbCode )
 240 {
 241         /*
 242         // Keyboard Input Test Macro
 243         switch ( usbCode )
 244         {
 245         case KEY_F1:
 246                 sendCode--;
 247                 scan_sendData( 0x90 );
 248                 scan_sendData( sendCode );
 249                 _delay_ms( 200 );
 250                 break;
 251
 252         case KEY_F2:
 253                 scan_sendData( 0x90 );
 254                 scan_sendData( sendCode );
 255                 _delay_ms( 200 );
 256                 break;
 257
 258         case KEY_F3:
 259                 sendCode++;
 260                 scan_sendData( 0x90 );
 261                 scan_sendData( sendCode );
 262                 _delay_ms( 200 );
 263                 break;
 264
 265         default:
 266                 return 0;
 267         }
 268
 269         return 1;
 270         */
 271         return 0;
 272 }
 273
 274
 275 // Given a list of keypresses, translate into the USB key codes
 276 // The buffer is cleared after running
 277 // If the buffer doesn't fit into the USB send array, the extra keys are dropped
 278 void keyPressBufferRead( uint8_t *modifiers, uint8_t numberOfModifiers, uint8_t *map )
 279 {
 280         // Loop through input buffer
 281         for ( uint8_t index = 0; index < KeyIndex_BufferUsed; index++ )
 282         {
 283                 // Get the keycode from the buffer
 284                 uint8_t key = KeyIndex_Buffer[index];
 285
 286                 // Check key for special usages using the scancode
 287                 // If non-zero return, ignore normal processing of the scancode
 288                 if ( scancodeMacro( key ) )
 289                         continue;
 290
 291                 // Check key for special usages using the usbcode
 292                 // If non-zero return, ignore normal processing of the usbcode
 293                 if ( usbcodeMacro( map[key] ) )
 294                         continue;
 295
 296                 // Determine if the key is a modifier
 297                 uint8_t modFound = 0;
 298                 for ( uint8_t mod = 0; mod < numberOfModifiers; mod++ ) {
 299                         // Modifier found
 300                         if ( modifiers[mod] == key ) {
 301                                 USBKeys_Modifiers |= map[key];
 302                                 modFound = 1;
 303                                 break;
 304                         }
 305                 }
 306
 307                 // Modifier, already done this loop
 308                 if ( modFound )
 309                         continue;
 310
 311                 // Too many keys
 312                 if ( USBKeys_Sent >= USBKeys_MaxSize )
 313                 {
 314                         info_print("USB Key limit reached");
 315                         errorLED( 1 );
 316                         break;
 317                 }
 318
 319                 // Allow ignoring keys with 0's
 320                 if ( map[key] != 0 )
 321                 {
 322                         USBKeys_Array[USBKeys_Sent++] = map[key];
 323                 }
 324                 else
 325                 {
 326                         // Key was not mapped
 327                         // TODO Add dead key map
 328                         char tmpStr[6];
 329                         hexToStr( key, tmpStr );
 330                         erro_dPrint( "Key not mapped... - ", tmpStr );
 331                         errorLED( 1 );
 332                 }
 333         }
 334
 335         // Signal Macro processor that all of the buffered keys have been processed
 336         macro_finishedWithBuffer();
 337
 338         // Signal buffer that we've used it
 339         scan_finishedWithBuffer();
 340 }
 341
 342 inline void process_macros(void)
 343 {
 344         // Online process macros once (if some were found), until the next USB send
 345         if ( USBKeys_Sent != 0 )
 346                 return;
 347
 348         // Query the input buffer for keypresses
 349         keyPressBufferRead( MODIFIER_MASK, sizeof(MODIFIER_MASK), KEYINDEX_MASK );
 350
 351         // Check for bootloader condition
 352         //if ( Bootloader_ConditionState == sizeof( Bootloader_ConditionSequence ) )
 353         //      jumpToBootloader();
 354 }
 355