diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000..b77b044
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+custom: ['https://paypal.me/NT7S', 'https://www.subscribestar.com/nt7s']
diff --git a/README.md b/README.md
index 92f22a4..10382f0 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@ This library sends Morse Code via toggling a specified output pin and/or togglin
 
 Thanks For Your Support!
 ------------------------
-If you would like to support my library development efforts, please consider a [PayPal donation](https://paypal.me/NT7S) or purchasing something from the [Etherkit Store](https://www.etherkit.com). Thank you!
+If you would like to support my library development efforts, please consider on-going support via my [SubscribeStar](https://www.subscribestar.com/nt7s) page, sending a one-time [PayPal donation](https://paypal.me/NT7S) or purchasing something from the [Etherkit Store](https://www.etherkit.com). Thank you!
 
 Library Installation
 ---------------------
@@ -22,7 +22,7 @@ Example
 -------
 First, install the Morse library into your instance of the Arduino IDE as described above.
 
-There two simple examples named **morse_example_avr.ino** and **morse_example_samd.ino** that are placed in your examples menu under the Etherkit Morse folder. Open one corresponding to the Arduino variant on which you will be running the example.
+There two simple examples named **morse_example_avr.ino** and **morse_example_samd.ino** that are placed in your examples menu under the Etherkit Morse folder. Open one corresponding to the Arduino variant on which you will be running the example. If you are using an AVR-based Arduino (such as an Uno), you'll want to also install the SimpleTimer library found (here)[https://playground.arduino.cc/Code/SimpleTimer].
 
 In order to use the Morse library in your sketch, you must first instantiate an object of class Morse:
 
@@ -98,7 +98,7 @@ void Morse::setWPM(float new_wpm)
 ### send()
 ```
 /*
- * void Morse::send(char * message)
+ * void Morse::send(const char * message)
  *
  * Send the specified message in Morse code on the output pin.
  *
@@ -107,6 +107,16 @@ void Morse::setWPM(float new_wpm)
  */
 void Morse::send(char * message)
 ```
+### reset()
+```
+/*
+ * Morse::reset()
+ *
+ * Halts any sending in progress, empties the message buffer, and resets the
+ * Morse state machine.
+ *
+ */
+```
 
 Public Variables
 ----------------
@@ -114,8 +124,11 @@ Public Variables
     bool tx;
     bool tx_enable;
     uint8_t output_pin;
+    uint8_t led_pin;
+    bool dfcw_mode = false;
     bool busy;
     bool preamble_enable;
+    uint8_t cur_char = 0;
 
 Valid Characters
 ----------------
@@ -130,6 +143,17 @@ The standard uppercase and lowercase letters 'A' through 'Z' and digits '0' thro
 
 Changelog
 ---------
+* v1.1.2
+
+    * Fix bug in sending first character, correct keywords.txt
+
+* v1.1.1
+
+    * Minor bug and documentation fixes.
+
+* v1.1.0
+
+    * Add DFCW mode, LED pin, current character position, and reset.
 
 * v1.0.1
 
diff --git a/examples/morse_example_avr/morse_example_avr.ino b/examples/morse_example_avr/morse_example_avr.ino
index 6772631..96fffb9 100644
--- a/examples/morse_example_avr/morse_example_avr.ino
+++ b/examples/morse_example_avr/morse_example_avr.ino
@@ -4,6 +4,9 @@
  *
  * Copyright (C) 2018 Jason Milldrum <milldrum@gmail.com>
  *
+ * Uses the SimpleTimer library which you can find here:
+ * https://playground.arduino.cc/Code/SimpleTimer
+ *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
diff --git a/keywords.txt b/keywords.txt
index 362760e..0335377 100644
--- a/keywords.txt
+++ b/keywords.txt
@@ -4,9 +4,13 @@ init	KEYWORD2
 update	KEYWORD2
 setWPM	KEYWORD2
 send	KEYWORD2
+reset	KEYWORD2
 wpm	KEYWORD2
 tx	KEYWORD2
 tx_enable	KEYWORD2
 output_pin	KEYWORD2
+led_pin	KEYWORD2
+dfcw_mode	KEYWORD2
 busy	KEYWORD2
 preamble_enable	KEYWORD2
+cur_char	KEYWORD2
diff --git a/library.properties b/library.properties
index 40b1c12..7dc9abb 100644
--- a/library.properties
+++ b/library.properties
@@ -1,5 +1,5 @@
 name=Etherkit Morse
-version=1.0.1
+version=1.1.2
 author=Jason Milldrum <milldrum@gmail.com>
 maintainer=Jason Milldrum <milldrum@gmail.com>
 sentence=Generate Morse Code for transmission on an digital I/O pin.
diff --git a/src/Morse.cpp b/src/Morse.cpp
index 4736da9..65040e3 100644
--- a/src/Morse.cpp
+++ b/src/Morse.cpp
@@ -41,15 +41,16 @@
  * init_wpm - Sending speed in words per minute.
  *
  */
-Morse::Morse(uint8_t tx_pin, float init_wpm) : output_pin(tx_pin)
+Morse::Morse(uint8_t tx_pin, float init_wpm) : output_pin(tx_pin), led_pin(tx_pin)
 {
 	tx = false;
 	tx_enable = true;
 	busy = false;
+	cur_character = 0;
 
 	setWPM(init_wpm);
 
-	if(output_pin)
+	if (output_pin)
 	{
 		pinMode(output_pin, OUTPUT);
 	}
@@ -70,250 +71,315 @@ Morse::Morse(uint8_t tx_pin, float init_wpm) : output_pin(tx_pin)
 void Morse::update()
 {
 	noInterrupts();
-  cur_timer++;
-  interrupts();
+	cur_timer++;
+	interrupts();
 
-	#ifdef DEBUG
-	if(cur_character != 0)
+#ifdef DEBUG
+	if (cur_character != 0)
 	{
 		//Serial.println(cur_timer);
 		//Serial.println(cur_character, HEX);
 	}
-	#endif
-
-	switch(cur_state)
-    {
-    case State::IDLE:
-      // TX off
-      //pa_enable = false;
-      tx = false;
-
-      if(tx_enable)
-      {
-        msg_delay_end = cur_timer + getMsgDelay(msg_delay);
-
-        // If this is the first time thru the message loop, get the first character
-        if((cur_msg_p == msg_buffer) && (cur_character == '\0'))
-        {
-					#if defined(__arm__)
-					cur_character = morsechar[(*cur_msg_p) - MORSE_CHAR_START];
-					#else
-          cur_character = pgm_read_byte(&morsechar[(*cur_msg_p) - MORSE_CHAR_START]);
-					#endif
-					#ifdef DEBUG
-					Serial.println("Start of message");
-					#endif
-					if(preamble_enable)
+#endif
+
+	switch (cur_state)
+	{
+	case State::IDLE:
+		// TX off
+		//pa_enable = false;
+		tx = false;
+
+		if (tx_enable)
+		{
+			msg_delay_end = cur_timer + getMsgDelay(msg_delay);
+
+			// If this is the first time thru the message loop, get the first character
+			if ((cur_msg_p == msg_buffer) && (cur_character == '\0'))
+			{
+#if defined(__arm__)
+				cur_character = morsechar[(*cur_msg_p) - MORSE_CHAR_START];
+#else
+				cur_character = pgm_read_byte(&morsechar[(*cur_msg_p) - MORSE_CHAR_START]);
+#endif
+#ifdef DEBUG
+				Serial.println("Start of message");
+#endif
+				if (preamble_enable)
+				{
+					cur_state = State::PREAMBLE;
+					cur_state_end = cur_state_end = cur_timer + (dit_length * MULT_WORDDELAY);
+					return;
+				}
+			}
+
+			// Get the current element in the current character
+			if (cur_character != '\0')
+			{
+				if (cur_character == 0b10000000 || cur_character == 0b11111111) // End of character marker or SPACE
+				{
+					// Set next state based on whether EOC or SPACE
+					if (cur_character == 0b10000000)
 					{
-						cur_state = State::PREAMBLE;
-						cur_state_end = cur_state_end = cur_timer + (dit_length * MULT_WORDDELAY);
-						return;
+#ifdef DEBUG
+						Serial.println("End of character");
+#endif
+						cur_state_end = cur_timer + (dit_length * MULT_DAH);
+						cur_state = State::DAHDELAY;
+
+						// Grab next character, set state to inter-character delay
+						cur_msg_p++;
+						cur_char++;
+
+						// If we read a NULL from the announce buffer, set cur_character to NULL,
+						// otherwise set to correct morse character
+						if ((*cur_msg_p) == '\0')
+						{
+							cur_character = '\0';
+						}
+						else
+						{
+#if defined(__arm__)
+							cur_character = morsechar[(*cur_msg_p) - MORSE_CHAR_START];
+#else
+							cur_character = pgm_read_byte(&morsechar[(*cur_msg_p) - MORSE_CHAR_START]);
+#endif
+						}
 					}
-        }
-
-        // Get the current element in the current character
-        if(cur_character != '\0')
-        {
-          if(cur_character == 0b10000000 || cur_character == 0b11111111)  // End of character marker or SPACE
-          {
-            // Set next state based on whether EOC or SPACE
-            if(cur_character == 0b10000000)
-            {
-							#ifdef DEBUG
-							Serial.println("End of character");
-							#endif
-              cur_state_end = cur_timer + (dit_length * MULT_DAH);
-              cur_state = State::DAHDELAY;
-
-              // Grab next character, set state to inter-character delay
-              cur_msg_p++;
-
-              // If we read a NULL from the announce buffer, set cur_character to NULL,
-              // otherwise set to correct morse character
-              if((*cur_msg_p) == '\0')
-              {
-                cur_character = '\0';
-              }
-              else
-              {
-								#if defined(__arm__)
-								cur_character = morsechar[(*cur_msg_p) - MORSE_CHAR_START];
-								#else
-			          cur_character = pgm_read_byte(&morsechar[(*cur_msg_p) - MORSE_CHAR_START]);
-								#endif
-              }
-            }
-            else
-            {
-              cur_state_end = cur_timer + (dit_length * MULT_WORDDELAY);
-              cur_state = State::WORDDELAY;
-							#ifdef DEBUG
-							Serial.println("Word delay");
-							#endif
-            }
-
-            // Grab next character, set state to inter-character delay
-            //cur_msg_p++;
-
-            // If we read a NULL from the announce buffer, set cur_character to NULL,
-            // otherwise set to correct morse character
-            // if((*cur_msg_p) == '\0')
-            // {
-            //   cur_character = '\0';
-            // }
-            // else
-            // {
-						// 	#if defined(__arm__)
-						// 	cur_character = morsechar[(*cur_msg_p) - MORSE_CHAR_START];
-						// 	#else
-						// 	cur_character = pgm_read_byte(&morsechar[(*cur_msg_p) - MORSE_CHAR_START]);
-						// 	#endif
-            // }
-          }
-          else
-          {
-            // Mask off MSb, set cur_element
-            if((cur_character & 0b10000000) == 0b10000000)
-            {
-              cur_state_end = cur_timer + (dit_length * MULT_DAH);
-              cur_state = State::DAH;
-							#ifdef DEBUG
-							Serial.print("DAH ");
-							Serial.println(cur_character, BIN);
-							#endif
-            }
-            else
-            {
-              cur_state_end = cur_timer + dit_length;
-              cur_state = State::DIT;
-							#ifdef DEBUG
-							Serial.print("DIT ");
-							Serial.println(cur_character, BIN);
-							#endif
-            }
-
-            // Shift left to get next element
-            cur_character = cur_character << 1;
-          }
-        }
-        else // End of message
-        {
-					#ifdef DEBUG
-					Serial.println("End of message");
-					#endif
-          // Reload the message buffer and set buffer pointer back to beginning
-					//strcpy(msg_buffer, tx_buffer);
-          //cur_msg_p = msg_buffer;
-          cur_character = '\0';
-
-          if(msg_delay == 0)
-          {
-            // If a constantly repeating message, put a word delay at the end of message
-            cur_state_end = cur_timer + (dit_length * MULT_WORDDELAY);
-            cur_state = State::EOMDELAY;
-          }
-          else
-          {
-            // Otherwise, set the message delay time
-            if(msg_delay_end < (cur_timer + (dit_length * MULT_WORDDELAY)))
-            {
-              cur_state_end = cur_timer + (dit_length * MULT_WORDDELAY);
-            }
-            else
-            {
-              cur_state_end = msg_delay_end;
-            }
-
-            cur_state = State::MSGDELAY;
-          }
-        }
-      }
-      break;
-
-    case State::PREAMBLE:
-      // Transmitter off
-      tx = false;
-			if(output_pin)
+					else
+					{
+						cur_state_end = cur_timer + (dit_length * MULT_WORDDELAY);
+						cur_state = State::WORDDELAY;
+#ifdef DEBUG
+						Serial.println("Word delay");
+#endif
+					}
+
+					// Grab next character, set state to inter-character delay
+					//cur_msg_p++;
+
+					// If we read a NULL from the announce buffer, set cur_character to NULL,
+					// otherwise set to correct morse character
+					// if((*cur_msg_p) == '\0')
+					// {
+					//   cur_character = '\0';
+					// }
+					// else
+					// {
+					// 	#if defined(__arm__)
+					// 	cur_character = morsechar[(*cur_msg_p) - MORSE_CHAR_START];
+					// 	#else
+					// 	cur_character = pgm_read_byte(&morsechar[(*cur_msg_p) - MORSE_CHAR_START]);
+					// 	#endif
+					// }
+				}
+				else
+				{
+					// Mask off MSb, set cur_element
+					if ((cur_character & 0b10000000) == 0b10000000)
+					{
+						cur_state_end = cur_timer + (dit_length * MULT_DAH);
+						cur_state = State::DAH;
+#ifdef DEBUG
+						Serial.print("DAH ");
+						Serial.println(cur_character, BIN);
+#endif
+					}
+					else
+					{
+						cur_state_end = cur_timer + dit_length;
+						cur_state = State::DIT;
+#ifdef DEBUG
+						Serial.print("DIT ");
+						Serial.println(cur_character, BIN);
+#endif
+					}
+
+					// Shift left to get next element
+					cur_character = cur_character << 1;
+				}
+			}
+			else // End of message
+			{
+#ifdef DEBUG
+				Serial.println("End of message");
+#endif
+				// Reload the message buffer and set buffer pointer back to beginning
+				//strcpy(msg_buffer, tx_buffer);
+				//cur_msg_p = msg_buffer;
+				cur_character = '\0';
+
+				if (msg_delay == 0)
+				{
+					// If a constantly repeating message, put a word delay at the end of message
+					cur_state_end = cur_timer + (dit_length * MULT_WORDDELAY);
+					cur_state = State::EOMDELAY;
+				}
+				else
+				{
+					// Otherwise, set the message delay time
+					if (msg_delay_end < (cur_timer + (dit_length * MULT_WORDDELAY)))
+					{
+						cur_state_end = cur_timer + (dit_length * MULT_WORDDELAY);
+					}
+					else
+					{
+						cur_state_end = msg_delay_end;
+					}
+
+					cur_state = State::MSGDELAY;
+				}
+			}
+		}
+		break;
+
+	case State::PREAMBLE:
+		// Transmitter off
+		tx = false;
+		if (dfcw_mode)
+		{
+			// if(output_pin)
+			// {
+			// 	digitalWrite(output_pin, LOW);
+			// }
+			digitalWrite(output_pin, HIGH);
+			digitalWrite(led_pin, HIGH);
+		}
+		else
+		{
+			if (output_pin)
 			{
 				digitalWrite(output_pin, LOW);
 			}
-
-      // When done waiting, go back to IDLE state to start the message
-      if(cur_timer > cur_state_end)
-      {
-				preamble_enable = false;
-        cur_state = State::IDLE;
-      }
-      break;
-
-    case State::DIT:
-    case State::DAH:
-      tx = true;
-			if(output_pin)
+			digitalWrite(led_pin, LOW);
+		}
+
+		// When done waiting, go back to IDLE state to start the message
+		if (cur_timer > cur_state_end)
+		{
+			preamble_enable = false;
+			cur_state = State::IDLE;
+		}
+		break;
+
+	case State::DIT:
+	case State::DAH:
+		tx = true;
+		if (dfcw_mode)
+		{
+			// if(output_pin)
+			// {
+			// 	digitalWrite(output_pin, LOW);
+			// }
+			digitalWrite(output_pin, HIGH);
+			digitalWrite(led_pin, HIGH);
+		}
+		else
+		{
+			if (output_pin)
 			{
 				digitalWrite(output_pin, HIGH);
 			}
+			digitalWrite(led_pin, HIGH);
+		}
 
-      if(cur_timer > cur_state_end)
-      {
-        tx = false;
-				if(output_pin)
+		if (cur_timer > cur_state_end)
+		{
+			tx = false;
+			if (dfcw_mode)
+			{
+				// if(output_pin)
+				// {
+				// 	digitalWrite(output_pin, LOW);
+				// }
+				digitalWrite(led_pin, HIGH);
+			}
+			else
+			{
+				if (output_pin)
 				{
 					digitalWrite(output_pin, LOW);
 				}
+				digitalWrite(led_pin, LOW);
+			}
 
-        cur_state_end = cur_timer + dit_length;
-        cur_state = State::DITDELAY;
-      }
-      break;
-    case State::DITDELAY:
-    case State::DAHDELAY:
-    case State::WORDDELAY:
-		case State::MSGDELAY:
-    case State::EOMDELAY:
-      tx = false;
-			if(output_pin)
+			cur_state_end = cur_timer + dit_length;
+			cur_state = State::DITDELAY;
+		}
+		break;
+	case State::DITDELAY:
+	case State::DAHDELAY:
+	case State::WORDDELAY:
+	case State::MSGDELAY:
+	case State::EOMDELAY:
+		tx = false;
+		if (dfcw_mode)
+		{
+			// if(output_pin)
+			// {
+			// 	digitalWrite(output_pin, LOW);
+			// }
+			digitalWrite(led_pin, HIGH);
+		}
+		else
+		{
+			if (output_pin)
 			{
 				digitalWrite(output_pin, LOW);
 			}
+			digitalWrite(led_pin, LOW);
+		}
 
-      if(cur_timer > cur_state_end)
-      {
-        if(cur_state == State::WORDDELAY)
-        {
-          // Grab next character
-          cur_msg_p++;
-
-          // If we read a NULL from the announce buffer, set cur_character to NULL,
-          // otherwise set to correct morse character
-          if((*cur_msg_p) == '\0')
-          {
-            cur_character = '\0';
-          }
-          else
-          {
-						// TODO
-						#if defined(__arm__)
-						cur_character = morsechar[(*cur_msg_p) - MORSE_CHAR_START];
-						#else
-	          cur_character = pgm_read_byte(&morsechar[(*cur_msg_p) - MORSE_CHAR_START]);
-						#endif
-          }
-        }
-				else if(cur_state == State::EOMDELAY)
+		if (cur_timer > cur_state_end)
+		{
+			if (cur_state == State::WORDDELAY)
+			{
+				// Grab next character
+				cur_msg_p++;
+				cur_char++;
+
+				// If we read a NULL from the announce buffer, set cur_character to NULL,
+				// otherwise set to correct morse character
+				if ((*cur_msg_p) == '\0')
+				{
+					cur_character = '\0';
+				}
+				else
+				{
+// TODO
+#if defined(__arm__)
+					cur_character = morsechar[(*cur_msg_p) - MORSE_CHAR_START];
+#else
+					cur_character = pgm_read_byte(&morsechar[(*cur_msg_p) - MORSE_CHAR_START]);
+#endif
+				}
+			}
+			else if (cur_state == State::EOMDELAY)
+			{
+				// Clear the message buffer when message sending is complete
+				memset(msg_buffer, 0, TX_BUFFER_SIZE + 1);
+				busy = false;
+				cur_char = 0;
+				if (dfcw_mode)
+				{
+					digitalWrite(led_pin, LOW);
+				}
+				else
 				{
-					// Clear the message buffer when message sending is complete
-					memset(msg_buffer, 0, TX_BUFFER_SIZE + 1);
-					busy = false;
+					if (output_pin)
+					{
+						digitalWrite(output_pin, LOW);
+					}
+					digitalWrite(led_pin, LOW);
 				}
+			}
 
-        cur_state = State::IDLE;
-      }
-      break;
+			cur_state = State::IDLE;
+		}
+		break;
 
-    default:
-      break;
-    }
+	default:
+		break;
+	}
 }
 
 /*
@@ -328,27 +394,48 @@ void Morse::setWPM(float new_wpm)
 {
 	wpm = new_wpm;
 	// This is converted to WPM * 1000 due to need for fractional WPM for slow modes
-  //
-  // Dit length in milliseconds is 1200 ms / WPM
-  dit_length = (1200000UL / (uint32_t)(new_wpm * 1000));
+	//
+	// Dit length in milliseconds is 1200 ms / WPM
+	dit_length = (1200000UL / (uint32_t)(new_wpm * 1000));
 }
 
 /*
- * Morse::send(char * message)
+ * Morse::send(const char * message)
  *
  * Send the specified message in Morse code on the output pin.
  *
  * message - String literal or zero-delimited string to transmit.
  *
  */
-void Morse::send(char * message)
+void Morse::send(const char *message)
 {
-	strcpy((char *)msg_buffer, message);
+	strcpy(msg_buffer, message);
 	cur_msg_p = msg_buffer;
+	cur_char = 0;
 	cur_state = State::IDLE;
+	cur_character = 0;
 	busy = true;
 }
 
+/*
+ * Morse::reset()
+ *
+ * Halts any sending in progress, empties the message buffer, and resets the
+ * Morse state machine.
+ *
+ */
+void Morse::reset()
+{
+	// strcpy((char *)msg_buffer, "");
+	memset(msg_buffer, 0, TX_BUFFER_SIZE + 1);
+	cur_msg_p = msg_buffer;
+	cur_char = 0;
+	cur_state = State::IDLE;
+	cur_character = 0;
+	busy = false;
+	digitalWrite(led_pin, LOW);
+}
+
 /*
  * Private class members
  */
@@ -364,12 +451,12 @@ void Morse::send(char * message)
  */
 uint32_t Morse::getMsgDelay(uint8_t delay_minutes)
 {
-  // The single function parameter is the message delay time in minutes
-  if(delay_minutes > MAX_MSG_DELAY)
-  {
-    delay_minutes = MAX_MSG_DELAY;
-  }
-
-  // Number of clock ticks is the number of minutes * 60000 ticks/per min
-  return delay_minutes * 60000UL;
+	// The single function parameter is the message delay time in minutes
+	if (delay_minutes > MAX_MSG_DELAY)
+	{
+		delay_minutes = MAX_MSG_DELAY;
+	}
+
+	// Number of clock ticks is the number of minutes * 60000 ticks/per min
+	return delay_minutes * 60000UL;
 }
diff --git a/src/Morse.h b/src/Morse.h
index 9ef6daa..c6d4826 100644
--- a/src/Morse.h
+++ b/src/Morse.h
@@ -30,6 +30,7 @@
 
 // Constants
 constexpr uint8_t DEFAULT_OUTPUT_PIN = LED_BUILTIN;
+constexpr uint8_t DEFAULT_LED_PIN = LED_BUILTIN;
 constexpr float DEFAULT_WPM = 25;
 constexpr uint8_t TX_BUFFER_SIZE = 100;
 constexpr uint8_t MULT_DAH = 3; // DAH is 3x a DIT
@@ -46,14 +47,18 @@ class Morse
   Morse(uint8_t tx_pin = DEFAULT_OUTPUT_PIN, float init_wpm = DEFAULT_WPM);
   void update();
   void setWPM(float);
-  void send(char *);
+  void send(const char *);
+  void reset();
 
   float wpm;
   bool tx = false;
   bool tx_enable = true;
   uint8_t output_pin;
+  uint8_t led_pin;
+  bool dfcw_mode = false;
   bool busy = true;
   bool preamble_enable = false;
+  uint8_t cur_char = 0;
 
 private:
   uint32_t getMsgDelay(uint8_t);
@@ -61,12 +66,12 @@ class Morse
   uint32_t dit_length;
   uint8_t msg_delay = 0;
   uint32_t msg_delay_end;
-  uint8_t * cur_msg_p = nullptr;
+  char * cur_msg_p = nullptr;
   uint8_t cur_character = 0;
 
   State cur_state, next_state;
   volatile uint32_t cur_timer, cur_state_end;
-  uint8_t msg_buffer[TX_BUFFER_SIZE + 1];
+  char msg_buffer[TX_BUFFER_SIZE + 1];
 };
 
 #endif // ETHERKIT_MORSE_H_
diff --git a/src/morsechar.h b/src/morsechar.h
index ca032ae..02400a6 100644
--- a/src/morsechar.h
+++ b/src/morsechar.h
@@ -47,7 +47,7 @@
 constexpr uint8_t MORSE_CHAR_START = 32;
 
 #if defined(__arm__)
-constexpr uint8_t morsechar[] =
+const uint8_t morsechar[] =
 #else
 const uint8_t morsechar[] PROGMEM =
 #endif
