diff --git a/armsrc/felica.c b/armsrc/felica.c
index 084ca6eee..b7f8b01c0 100644
--- a/armsrc/felica.c
+++ b/armsrc/felica.c
@@ -241,8 +241,8 @@ static uint8_t felica_select_card(felica_card_select_t *card) {
     // We try 10 times, or if answer was received.
     int len = 25;
     do {
-        // end-of-reception response packet data, wait approx. 501μs
-        // end-of-transmission command packet data, wait approx. 197μs
+        // end-of-reception response packet data, wait approx. 501µs
+        // end-of-transmission command packet data, wait approx. 197µs
         // polling card
         TransmitFor18092_AsReader(poll, sizeof(poll), NULL, 1, 0);
 
diff --git a/armsrc/hitagu.c b/armsrc/hitagu.c
index 0b1216edf..d23dba6af 100644
--- a/armsrc/hitagu.c
+++ b/armsrc/hitagu.c
@@ -58,24 +58,24 @@ static void update_tag_max_page_by_icr(void) {
     switch (tag.icr) {
         case HITAGU_ICR_STANDARD:
             tag.max_page = HITAGU_MAX_PAGE_STANDARD;
-            DBG Dbprintf("Detected standard Hitag μ (ICR=0x%02X), max page: 0x%02X", tag.icr, tag.max_page);
+            DBG Dbprintf("Detected standard Hitag µ (ICR=0x%02X), max page: 0x%02X", tag.icr, tag.max_page);
             break;
         case HITAGU_ICR_ADVANCED:
             tag.max_page = HITAGU_MAX_PAGE_ADVANCED;
-            DBG Dbprintf("Detected Hitag μ advanced (ICR=0x%02X), max page: 0x%02X", tag.icr, tag.max_page);
+            DBG Dbprintf("Detected Hitag µ advanced (ICR=0x%02X), max page: 0x%02X", tag.icr, tag.max_page);
             break;
         case HITAGU_ICR_ADVANCED_PLUS:
             tag.max_page = HITAGU_MAX_PAGE_ADVANCED_PLUS;
-            DBG Dbprintf("Detected Hitag μ advanced+ (ICR=0x%02X), max page: 0x%02X", tag.icr, tag.max_page);
+            DBG Dbprintf("Detected Hitag µ advanced+ (ICR=0x%02X), max page: 0x%02X", tag.icr, tag.max_page);
             break;
         case HITAGU_ICR_8265:
             tag.max_page = HITAGU_MAX_PAGE_8265;
-            DBG Dbprintf("Detected Hitag μ 8265 (ICR=0x%02X), max page: 0x%02X", tag.icr, tag.max_page);
+            DBG Dbprintf("Detected Hitag µ 8265 (ICR=0x%02X), max page: 0x%02X", tag.icr, tag.max_page);
             break;
         default:
             // Unknown ICR, use standard size as fallback
             tag.max_page = HITAGU_MAX_PAGE_STANDARD;
-            DBG Dbprintf("Unknown Hitag μ ICR: 0x%02X, defaulting to max page: 0x%02X", tag.icr, tag.max_page);
+            DBG Dbprintf("Unknown Hitag µ ICR: 0x%02X, defaulting to max page: 0x%02X", tag.icr, tag.max_page);
             break;
     }
 }
diff --git a/armsrc/lfops.c b/armsrc/lfops.c
index 46c1e0d3f..bc9c28fd7 100644
--- a/armsrc/lfops.c
+++ b/armsrc/lfops.c
@@ -64,11 +64,11 @@ SAM7S has several timers, we will use the source TIMER_CLOCK1 (aka AT91C_TC_CLKS
  TIMER_CLOCK1 = MCK/2, MCK is running at 48 MHz, Timer is running at 48/2 = 24 MHz
 
 New timer implementation in ticks.c, which is used in LFOPS.c
-       1 μs = 1.5 ticks
- 1 fc = 8 μs = 12 ticks
+       1 µs = 1.5 ticks
+ 1 fc = 8 µs = 12 ticks
 
 Terms you find in different datasheets and how they match.
-1 Cycle = 8 microseconds (μs)  == 1 field clock (fc)
+1 Cycle = 8 microseconds (µs)  == 1 field clock (fc)
 
 Note about HITAG timing
 Hitag units (T0) have duration of 8 microseconds (us), which is 1/125000 per second (carrier)
@@ -80,7 +80,7 @@ Hitag units (T0) have duration of 8 microseconds (us), which is 1/125000 per sec
   ==========================================================================================================
 
     ATA5577 Downlink Protocol Timings.
-    Note: All absolute times assume TC = 1 / fC = 8 μs (fC = 125 kHz)
+    Note: All absolute times assume TC = 1 / fC = 8 µs (fC = 125 kHz)
 
     Note: These timings are from the datasheet and doesn't map the best to the features of the RVD4 LF antenna.
           RDV4 LF antenna has high voltage and the drop of power when turning off the rf field takes about 1-2 TC longer.
diff --git a/client/src/cmdlfhitagu.c b/client/src/cmdlfhitagu.c
index 0915037fa..da8594016 100644
--- a/client/src/cmdlfhitagu.c
+++ b/client/src/cmdlfhitagu.c
@@ -361,16 +361,16 @@ static int CmdLFHitagURead(const char *Cmd) {
 
     if (icr == HITAGU_ICR_STANDARD) {
         user_blocks = HITAGU_MAX_PAGE_STANDARD;
-        PrintAndLogEx(INFO, "Hitag μ Standard (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
+        PrintAndLogEx(INFO, "Hitag µ Standard (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
     } else if (icr == HITAGU_ICR_ADVANCED) {
         user_blocks = HITAGU_MAX_PAGE_ADVANCED;
-        PrintAndLogEx(INFO, "Hitag μ Advanced (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
+        PrintAndLogEx(INFO, "Hitag µ Advanced (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
     } else if (icr == HITAGU_ICR_ADVANCED_PLUS) {
         user_blocks = HITAGU_MAX_PAGE_ADVANCED_PLUS;
-        PrintAndLogEx(INFO, "Hitag μ Advanced+ (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
+        PrintAndLogEx(INFO, "Hitag µ Advanced+ (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
     } else if (icr == HITAGU_ICR_8265) {
         user_blocks = HITAGU_MAX_PAGE_8265;
-        PrintAndLogEx(INFO, "Hitag μ 8265 (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
+        PrintAndLogEx(INFO, "Hitag µ 8265 (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
     } else {
         user_blocks = HITAGU_MAX_PAGE_STANDARD;
         PrintAndLogEx(INFO, "Unknown ICR (0x%02X)", icr);
@@ -509,16 +509,16 @@ static int CmdLFHitagUDump(const char *Cmd) {
 
     if (icr == HITAGU_ICR_STANDARD) {
         user_blocks = HITAGU_MAX_PAGE_STANDARD;
-        PrintAndLogEx(INFO, "Hitag μ Standard (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
+        PrintAndLogEx(INFO, "Hitag µ Standard (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
     } else if (icr == HITAGU_ICR_ADVANCED) {
         user_blocks = HITAGU_MAX_PAGE_ADVANCED;
-        PrintAndLogEx(INFO, "Hitag μ Advanced (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
+        PrintAndLogEx(INFO, "Hitag µ Advanced (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
     } else if (icr == HITAGU_ICR_ADVANCED_PLUS) {
         user_blocks = HITAGU_MAX_PAGE_ADVANCED_PLUS;
-        PrintAndLogEx(INFO, "Hitag μ Advanced+ (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
+        PrintAndLogEx(INFO, "Hitag µ Advanced+ (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
     } else if (icr == HITAGU_ICR_8265) {
         user_blocks = HITAGU_MAX_PAGE_8265;
-        PrintAndLogEx(INFO, "Hitag μ 8265 (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
+        PrintAndLogEx(INFO, "Hitag µ 8265 (ICR=0x%02X), user blocks: 0x%02X", icr, user_blocks);
     } else {
         user_blocks = HITAGU_MAX_PAGE_STANDARD;
         PrintAndLogEx(INFO, "Unknown ICR (0x%02X)", icr);
diff --git a/doc/magic_cards_notes.md b/doc/magic_cards_notes.md
index 9c477a69a..a1d4e7350 100644
--- a/doc/magic_cards_notes.md
+++ b/doc/magic_cards_notes.md
@@ -155,7 +155,7 @@ This is the cheapest and most common ID82xx chip available. It is usually sold a
 
 #### Characteristics
 
-* Chip is likely a cut down version of Hitag μ (micro) clone
+* Chip is likely a cut down version of Hitag µ (micro) clone
 * UID `00 00 00 00 00 00`
 * Password protection (4b), usually "00000000"(default) or "9AC4999C"(FURUI)
 * Config block 0xFF
diff --git a/include/hitag.h b/include/hitag.h
index a8e64d452..efc854d90 100644
--- a/include/hitag.h
+++ b/include/hitag.h
@@ -47,16 +47,16 @@
 #define HITAGU_CONFIG_PADR      0xFF
 #define HITAGU_PASSWORD_PADR    0xFE
 
-// Hitag μ IC Revision (ICR) values
-#define HITAGU_ICR_STANDARD      0x10  // Standard Hitag μ
-#define HITAGU_ICR_ADVANCED      0x20  // Hitag μ advanced
-#define HITAGU_ICR_ADVANCED_PLUS 0x30  // Hitag μ advanced+
+// Hitag µ IC Revision (ICR) values
+#define HITAGU_ICR_STANDARD      0x10  // Standard Hitag µ
+#define HITAGU_ICR_ADVANCED      0x20  // Hitag µ advanced
+#define HITAGU_ICR_ADVANCED_PLUS 0x30  // Hitag µ advanced+
 #define HITAGU_ICR_8265          0x80  // 8265
 
-// Hitag μ memory sizes based on ICR
-#define HITAGU_MAX_PAGE_STANDARD      0x04  // 4 blocks (0x00-0x03) for standard Hitag μ
-#define HITAGU_MAX_PAGE_ADVANCED      0x10  // 16 blocks (0x00-0x0F) for Hitag μ advanced
-#define HITAGU_MAX_PAGE_ADVANCED_PLUS 0x37  // 56 blocks (0x00-0x36) for Hitag μ advanced+
+// Hitag µ memory sizes based on ICR
+#define HITAGU_MAX_PAGE_STANDARD      0x04  // 4 blocks (0x00-0x03) for standard Hitag µ
+#define HITAGU_MAX_PAGE_ADVANCED      0x10  // 16 blocks (0x00-0x0F) for Hitag µ advanced
+#define HITAGU_MAX_PAGE_ADVANCED_PLUS 0x37  // 56 blocks (0x00-0x36) for Hitag µ advanced+
 #define HITAGU_MAX_PAGE_8265          0x0F  // 15 blocks (0x00-0x0E) for 8265
 
 // need to see which limits these cards has
diff --git a/include/protocols.h b/include/protocols.h
index 70795fcd0..43cb94c29 100644
--- a/include/protocols.h
+++ b/include/protocols.h
@@ -950,7 +950,7 @@ ISO 7816-4 Basic interindustry commands. For command APDU's.
 #define HITAGS_WRITE_BLOCK              0x90    // 1001 WRITE BLOCK
 #define HITAGS_QUIET                    0x70    // 0111 QUIET
 
-// Hitag μ flags
+// Hitag µ flags
 #define HITAGU_FLAG_PEXT                0x01    // 0b00001 - Protocol EXTension flag
 #define HITAGU_FLAG_INV                 0x02    // 0b00010 - INVentory flag
 #define HITAGU_FLAG_CRCT                0x04    // 0b00100 - CRC Transponder flag
@@ -959,7 +959,7 @@ ISO 7816-4 Basic interindustry commands. For command APDU's.
 #define HITAGU_FLAG_RFU                 0x08    // 0b01000 - Reserved For Use flag (when INV=1, always 0)
 #define HITAGU_FLAG_NOS                 0x10    // 0b10000 - Number Of Slots flag (when INV=1)
 
-// Hitag μ commands (6-bit)
+// Hitag µ commands (6-bit)
 #define HITAGU_CMD_LOGIN                   0x28    // 0b101000 - Login command
 #define HITAGU_CMD_INVENTORY               0x00    // 0b000000 - Inventory command
 #define HITAGU_CMD_READ_MULTIPLE_BLOCK     0x12    // 0b010010 - Read multiple block command