diff --git a/CMakeLists.txt b/CMakeLists.txt index 4ec941c..7cae1d3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -21,8 +21,8 @@ set( CHIP # "atmega32u4" # Teensy 2.0 (avr) # "at90usb646" # Teensy++ 1.0 (avr) # "at90usb1286" # Teensy++ 2.0 (avr) -# "mk20dx128" # Teensy 3.0 (arm) - "mk20dx128vlf5" # McHCK mk20dx128vlf5 + "mk20dx128" # Teensy 3.0 (arm) +# "mk20dx128vlf5" # McHCK mk20dx128vlf5 # "mk20dx256" # Teensy 3.1 (arm) ) @@ -53,7 +53,7 @@ set( ScanModule "MDPure" ) set( MacroModule "PartialMap" ) ##| Sends the current list of usb key codes through USB HID -set( OutputModule "pjrcUSB" ) +set( OutputModule "uartOut" ) ##| Debugging source to use, each module has it's own set of defines that it sets set( DebugModule "full" ) diff --git a/Output/pjrcUSB/arm/usb_dev.c b/Output/pjrcUSB/arm/usb_dev.c index b3ac2e0..f4bf2fc 100644 --- a/Output/pjrcUSB/arm/usb_dev.c +++ b/Output/pjrcUSB/arm/usb_dev.c @@ -669,21 +669,12 @@ void usb_tx(uint32_t endpoint, usb_packet_t *packet) } - void usb_device_reload() { asm volatile("bkpt"); } -void _reboot_Teensyduino_(void) -{ - // TODO: initialize R0 with a code.... - asm volatile("bkpt"); -} - - - void usb_isr(void) { uint8_t status, stat, t; @@ -700,7 +691,7 @@ void usb_isr(void) t = usb_reboot_timer; if (t) { usb_reboot_timer = --t; - if (!t) _reboot_Teensyduino_(); + if (!t) usb_device_reload(); } #ifdef CDC_DATA_INTERFACE t = usb_cdc_transmit_flush_timer; diff --git a/Output/pjrcUSB/output_com.c b/Output/pjrcUSB/output_com.c index addb918..dea6a3d 100644 --- a/Output/pjrcUSB/output_com.c +++ b/Output/pjrcUSB/output_com.c @@ -105,6 +105,10 @@ inline void Output_setup() // If the Teensy is powered without a PC connected to the USB port, // this will wait forever. usb_init(); +#include +init_errorLED(); +errorLED( 1 ); +while(1); while ( !usb_configured() ) /* wait */ ; // Register USB Output CLI dictionary @@ -119,19 +123,19 @@ inline void Output_setup() // USB Data Send inline void Output_send(void) { - // TODO undo potentially old keys - for ( uint8_t c = USBKeys_Sent; c < USBKeys_MaxSize; c++ ) - USBKeys_Array[c] = 0; + // TODO undo potentially old keys + for ( uint8_t c = USBKeys_Sent; c < USBKeys_MaxSize; c++ ) + USBKeys_Array[c] = 0; - // Send keypresses - usb_keyboard_send(); + // Send keypresses + usb_keyboard_send(); - // Clear modifiers and keys - USBKeys_Modifiers = 0; - USBKeys_Sent = 0; + // Clear modifiers and keys + USBKeys_Modifiers = 0; + USBKeys_Sent = 0; - // Signal Scan Module we are finishedA - Scan_finishedWithUSBBuffer( USBKeys_Sent <= USBKeys_MaxSize ? USBKeys_Sent : USBKeys_MaxSize ); + // Signal Scan Module we are finishedA + Scan_finishedWithUSBBuffer( USBKeys_Sent <= USBKeys_MaxSize ? USBKeys_Sent : USBKeys_MaxSize ); } diff --git a/Output/uartOut/arm/uart_serial.c b/Output/uartOut/arm/uart_serial.c new file mode 100644 index 0000000..cd1502e --- /dev/null +++ b/Output/uartOut/arm/uart_serial.c @@ -0,0 +1,195 @@ +/* Copyright (C) 2014 by Jacob Alexander + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "uart_serial.h" +#include +#include +#include // For memcpy + +// ----- Variables ----- + +#define uart0_buffer_size 32 // 32 byte buffer +volatile uint8_t uart0_buffer_head = 0; +volatile uint8_t uart0_buffer_tail = 0; +volatile uint8_t uart0_buffer_items = 0; +volatile uint8_t uart0_buffer[uart0_buffer_size]; + + +// ----- Interrupt Functions ----- + +void uart0_status_isr() +{ + cli(); // Disable Interrupts + + // UART0_S1 must be read for the interrupt to be cleared + if ( UART0_S1 & UART_S1_RDRF ) + { + // Read UART0 into buffer until FIFO is empty + while ( !( UART0_SFIFO & UART_SFIFO_RXEMPT ) ) + { + uart0_buffer[uart0_buffer_tail++] = UART0_D; + uart0_buffer_items++; + + // Wrap-around of tail pointer + if ( uart0_buffer_tail >= uart0_buffer_size ) + { + uart0_buffer_tail = 0; + } + + // Make sure the head pointer also moves if circular buffer is overwritten + if ( uart0_buffer_head == uart0_buffer_tail ) + { + uart0_buffer_head++; + } + + // Wrap-around of head pointer + if ( uart0_buffer_head >= uart0_buffer_size ) + { + uart0_buffer_head = 0; + } + + } + } + + sei(); // Re-enable Interrupts +} + + +// ----- Functions ----- + +void uart_serial_setup() +{ + // Setup the the UART interface for keyboard data input + SIM_SCGC4 |= SIM_SCGC4_UART0; // Disable clock gating + + // Pin Setup for UART0 + PORTB_PCR16 = PORT_PCR_PE | PORT_PCR_PS | PORT_PCR_PFE | PORT_PCR_MUX(3); // RX Pin + PORTB_PCR17 = PORT_PCR_DSE | PORT_PCR_SRE | PORT_PCR_MUX(3); // TX Pin + + // Setup baud rate - 9600 Baud + // 48 MHz / ( 16 * Baud ) = BDH/L + // Baud: 9600 -> 48 MHz / ( 16 * 9600 ) = 312.5 + // Thus baud setting = 313 + // NOTE: If finer baud adjustment is needed see UARTx_C4 -> BRFA in the datasheet + uint16_t baud = 313; // Max setting of 8191 + UART0_BDH = (uint8_t)(baud >> 8); + UART0_BDL = (uint8_t)baud; + + // 8 bit, No Parity, Idle Character bit after stop + UART0_C1 = UART_C1_ILT; + + // TX FIFO Disabled, TX FIFO Size 1 (Max 8 datawords), RX FIFO Enabled, RX FIFO Size 1 (Max 8 datawords) + // TX/RX FIFO Size: + // 0x0 - 1 dataword + // 0x1 - 4 dataword + // 0x2 - 8 dataword + UART0_PFIFO = UART_PFIFO_TXFE | UART_PFIFO_RXFE; + + // Reciever Inversion Disabled, LSBF + // UART_S2_RXINV UART_S2_MSBF + UART0_S2 |= 0x00; + + // Transmit Inversion Disabled + // UART_C3_TXINV + UART0_C3 |= 0x00; + + // TX Disabled, RX Enabled, RX Interrupt Enabled + // UART_C2_TE UART_C2_RE UART_C2_RIE + UART0_C2 = UART_C2_TE | UART_C2_RE | UART_C2_RIE; + + // Add interrupt to the vector table + NVIC_ENABLE_IRQ( IRQ_UART0_STATUS ); +} + + +// Get the next character, or -1 if nothing received +int uart_serial_getchar() +{ + unsigned int value = -1; + + // Check to see if the FIFO has characters + if ( uart0_buffer_items > 0 ) + { + value = uart0_buffer[uart0_buffer_head++]; + uart0_buffer_items--; + + // Wrap-around of head pointer + if ( uart0_buffer_head >= uart0_buffer_size ) + { + uart0_buffer_head = 0; + } + } + + return value; +} + + +// Number of bytes available in the receive buffer +int uart_serial_available() +{ + return uart0_buffer_items; +} + + +// Discard any buffered input +void uart_serial_flush_input() +{ + uart0_buffer_head = 0; + uart0_buffer_tail = 0; + uart0_buffer_items = 0; +} + + +// Transmit a character. 0 returned on success, -1 on error +int uart_serial_putchar( uint8_t c ) +{ + return uart_serial_write( &c, 1 ); +} + + +int uart_serial_write( const void *buffer, uint32_t size ) +{ + const uint8_t *data = (const uint8_t *)buffer; + uint32_t position = 0; + + // While buffer is not empty and transmit buffer is + while ( position < size ) + { + while ( !( UART0_SFIFO & UART_SFIFO_TXEMPT ) ); // Wait till there is room to send + UART0_D = data[position++]; + } + + return 0; +} + + +void uart_serial_flush_output() +{ + // Delay until buffer has been sent + while ( !( UART0_SFIFO & UART_SFIFO_TXEMPT ) ); // Wait till there is room to send +} + + +void uart_device_reload() +{ + asm volatile("bkpt"); +} + diff --git a/Output/uartOut/arm/uart_serial.h b/Output/uartOut/arm/uart_serial.h new file mode 100644 index 0000000..1a0a2b6 --- /dev/null +++ b/Output/uartOut/arm/uart_serial.h @@ -0,0 +1,40 @@ +/* Copyright (C) 2014 by Jacob Alexander + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef __uart_serial_h_ +#define __uart_serial_h_ + +#include + +int uart_serial_getchar(); +int uart_serial_available(); +int uart_serial_putchar( uint8_t c ); +int uart_serial_write( const void *buffer, uint32_t size ); + +void uart_serial_flush_input(); +void uart_serial_flush_output(); + +void uart_serial_setup(); + +void uart_device_reload(); + +#endif // __uart_serial_h_ + diff --git a/Output/uartOut/output_com.c b/Output/uartOut/output_com.c new file mode 100644 index 0000000..37cadc5 --- /dev/null +++ b/Output/uartOut/output_com.c @@ -0,0 +1,245 @@ +/* Copyright (C) 2014 by Jacob Alexander + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +// ----- Includes ----- + +// Compiler Includes +#include + +// Project Includes +#include +#include +#include + +// USB Includes +#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_) +#include "avr/uart_serial.h" +#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_) +#include "arm/uart_serial.h" +#endif + +// Local Includes +#include "output_com.h" + + + +// ----- Function Declarations ----- + +void cliFunc_kbdProtocol( char* args ); +void cliFunc_readLEDs ( char* args ); +void cliFunc_sendKeys ( char* args ); +void cliFunc_setKeys ( char* args ); +void cliFunc_setMod ( char* args ); + + +// ----- Variables ----- + +// Output Module command dictionary +char* outputCLIDictName = "USB Module Commands - NOT WORKING"; +CLIDictItem outputCLIDict[] = { + { "kbdProtocol", "Keyboard Protocol Mode: 0 - Boot, 1 - OS/NKRO Mode", cliFunc_kbdProtocol }, + { "readLEDs", "Read LED byte:" NL "\t\t1 NumLck, 2 CapsLck, 4 ScrlLck, 16 Kana, etc.", cliFunc_readLEDs }, + { "sendKeys", "Send the prepared list of USB codes and modifier byte.", cliFunc_sendKeys }, + { "setKeys", "Prepare a space separated list of USB codes (decimal). Waits until \033[35msendKeys\033[0m.", cliFunc_setKeys }, + { "setMod", "Set the modfier byte:" NL "\t\t1 LCtrl, 2 LShft, 4 LAlt, 8 LGUI, 16 RCtrl, 32 RShft, 64 RAlt, 128 RGUI", cliFunc_setMod }, + { 0, 0, 0 } // Null entry for dictionary end +}; + + +// Which modifier keys are currently pressed +// 1=left ctrl, 2=left shift, 4=left alt, 8=left gui +// 16=right ctrl, 32=right shift, 64=right alt, 128=right gui + uint8_t USBKeys_Modifiers = 0; + uint8_t USBKeys_ModifiersCLI = 0; // Separate CLI send buffer + +// Currently pressed keys, max is defined by USB_MAX_KEY_SEND + uint8_t USBKeys_Array [USB_MAX_KEY_SEND]; + uint8_t USBKeys_ArrayCLI[USB_MAX_KEY_SEND]; // Separate CLI send buffer + +// The number of keys sent to the usb in the array + uint8_t USBKeys_Sent = 0; + uint8_t USBKeys_SentCLI = 0; + +// 1=num lock, 2=caps lock, 4=scroll lock, 8=compose, 16=kana +volatile uint8_t USBKeys_LEDs = 0; + +// Protocol setting from the host. +// 0 - Boot Mode (Default, until set by the host) +// 1 - NKRO Mode +volatile uint8_t USBKeys_Protocol = 1; + +// the idle configuration, how often we send the report to the +// host (ms * 4) even when it hasn't changed + uint8_t USBKeys_Idle_Config = 125; + +// count until idle timeout + uint8_t USBKeys_Idle_Count = 0; + + +// ----- Functions ----- + +// USB Module Setup +inline void Output_setup() +{ + // Setup UART + uart_serial_setup(); + + // Register USB Output CLI dictionary + CLI_registerDictionary( outputCLIDict, outputCLIDictName ); +} + + +// USB Data Send +inline void Output_send(void) +{ + // TODO +} + + +// Sets the device into firmware reload mode +inline void Output_firmwareReload() +{ +#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_) + uart_debug_reload(); +#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_) + uart_device_reload(); +#endif +} + + +// USB Input buffer available +inline unsigned int Output_availablechar() +{ + return uart_serial_available(); +} + + +// USB Get Character from input buffer +inline int Output_getchar() +{ +#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_) + // XXX Make sure to check output_availablechar() first! Information is lost with the cast (error codes) + return (int)uart_serial_getchar(); +#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_) + return uart_serial_getchar(); +#endif +} + + +// USB Send Character to output buffer +inline int Output_putchar( char c ) +{ + return uart_serial_putchar( c ); +} + + +// USB Send String to output buffer, null terminated +inline int Output_putstr( char* str ) +{ +#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_) // AVR + uint16_t count = 0; +#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_) // ARM + uint32_t count = 0; +#endif + // Count characters until NULL character, then send the amount counted + while ( str[count] != '\0' ) + count++; + + return uart_serial_write( str, count ); +} + + +// Soft Chip Reset +inline void Output_softReset() +{ +#if defined(_at90usb162_) || defined(_atmega32u4_) || defined(_at90usb646_) || defined(_at90usb1286_) + uart_debug_software_reset(); +#elif defined(_mk20dx128_) || defined(_mk20dx128vlf5_) || defined(_mk20dx256_) + SOFTWARE_RESET(); +#endif +} + + +// ----- CLI Command Functions ----- + +void cliFunc_kbdProtocol( char* args ) +{ + print( NL ); + info_msg("Keyboard Protocol: "); + printInt8( USBKeys_Protocol ); +} + + +void cliFunc_readLEDs( char* args ) +{ + print( NL ); + info_msg("LED State (This doesn't work yet...): "); + printInt8( USBKeys_LEDs ); +} + + +void cliFunc_sendKeys( char* args ) +{ + // Copy USBKeys_ArrayCLI to USBKeys_Array + for ( uint8_t key = 0; key < USBKeys_SentCLI; ++key ) + { + USBKeys_Array[key] = USBKeys_ArrayCLI[key]; + } + USBKeys_Sent = USBKeys_SentCLI; + + // Set modifier byte + USBKeys_Modifiers = USBKeys_ModifiersCLI; +} + + +void cliFunc_setKeys( char* args ) +{ + char* curArgs; + char* arg1Ptr; + char* arg2Ptr = args; + + // Parse up to USBKeys_MaxSize args (whichever is least) + for ( USBKeys_SentCLI = 0; USBKeys_SentCLI < USBKeys_MaxSize; ++USBKeys_SentCLI ) + { + curArgs = arg2Ptr; + CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr ); + + // Stop processing args if no more are found + if ( *arg1Ptr == '\0' ) + break; + + // Add the USB code to be sent + USBKeys_ArrayCLI[USBKeys_SentCLI] = decToInt( arg1Ptr ); + } +} + + +void cliFunc_setMod( char* args ) +{ + // Parse number from argument + // NOTE: Only first argument is used + char* arg1Ptr; + char* arg2Ptr; + CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr ); + + USBKeys_ModifiersCLI = decToInt( arg1Ptr ); +} + diff --git a/Output/uartOut/output_com.h b/Output/uartOut/output_com.h new file mode 100644 index 0000000..84b22ae --- /dev/null +++ b/Output/uartOut/output_com.h @@ -0,0 +1,76 @@ +/* Copyright (C) 2013-2014 by Jacob Alexander + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef __output_com_h +#define __output_com_h + +// ----- Includes ----- + +// Compiler Includes +#include + +// Local Includes +#include // Defines USB Parameters, partially generated by CMake + + + +// ----- Defines ----- + +// Indicator for other modules through USBKeys_MaxSize for how capable the USB module is when sending large number of keypresses +#define USB_MAX_KEY_SEND 6 + + + +// ----- Variables ----- + +// Variables used to communciate to the output module +// XXX Even if the output module is not USB, this is internally understood keymapping scheme +extern uint8_t USBKeys_Modifiers; +extern uint8_t USBKeys_Array[USB_MAX_KEY_SEND]; +extern uint8_t USBKeys_Sent; +extern volatile uint8_t USBKeys_LEDs; + + static const uint8_t USBKeys_MaxSize = USB_MAX_KEY_SEND; +extern volatile uint8_t USBKeys_Protocol; // 0 - Boot Mode, 1 - NKRO Mode + +// Misc variables (XXX Some are only properly utilized using AVR) +extern uint8_t USBKeys_Idle_Config; +extern uint8_t USBKeys_Idle_Count; + + + +// ----- Functions ----- + +void Output_setup(); +void Output_send(); + +void Output_firmwareReload(); +void Output_softReset(); + +// Relies on USB serial module +unsigned int Output_availablechar(); + +int Output_getchar(); +int Output_putchar( char c ); +int Output_putstr( char* str ); + +#endif + diff --git a/Output/uartOut/setup.cmake b/Output/uartOut/setup.cmake new file mode 100644 index 0000000..66eec96 --- /dev/null +++ b/Output/uartOut/setup.cmake @@ -0,0 +1,45 @@ +###| CMake Kiibohd Controller UART Output Module |### +# +# Written by Jacob Alexander in 2014 for the Kiibohd Controller +# +# Released into the Public Domain +# +### + + +### +# Module C files +# + + +#| AVR Compiler +if ( ${COMPILER_FAMILY} MATCHES "avr" ) + + set( OUTPUT_SRCS + output_com.c + avr/uart_serial.c + ) + +#| ARM Compiler +elseif ( ${COMPILER_FAMILY} MATCHES "arm" ) + + set( OUTPUT_SRCS + output_com.c + arm/uart_serial.c + ) + +endif () + + +### +# Module Specific Options +# + +### +# Compiler Family Compatibility +# +set( OutputModuleCompatibility + arm +# avr # TODO +) +