Merge pull request #7949 from dok-net/hwserial

devyte · web-flow · commit 5ac64ffa2746 · 2021-03-28T19:48:18.000-03:00
HW Serial swap and pin setting work only on a few pins
diff --git a/cores/esp8266/HardwareSerial.h b/cores/esp8266/HardwareSerial.h
@@ -101,31 +101,31 @@ class HardwareSerial: public Stream
         return uart_get_rx_buffer_size(_uart);
     }
 
-    void swap()
+    bool swap()
     {
-        swap(1);
+        return swap(1);
     }
-    void swap(uint8_t tx_pin)    //toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX
+    bool swap(uint8_t tx_pin)    //toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX
     {
-        uart_swap(_uart, tx_pin);
+        return uart_swap(_uart, tx_pin);
     }
 
     /*
      * Toggle between use of GPIO1 and GPIO2 as TX on UART 0.
      * Note: UART 1 can't be used if GPIO2 is used with UART 0!
      */
-    void set_tx(uint8_t tx_pin)
+    bool set_tx(uint8_t tx_pin)
     {
-        uart_set_tx(_uart, tx_pin);
+        return uart_set_tx(_uart, tx_pin);
     }
 
     /*
      * UART 0 possible options are (1, 3), (2, 3) or (15, 13)
      * UART 1 allows only TX on 2 if UART 0 is not (2, 3)
      */
-    void pins(uint8_t tx, uint8_t rx)
+    bool pins(uint8_t tx, uint8_t rx)
     {
-        uart_set_pins(_uart, tx, rx);
+        return uart_set_pins(_uart, tx, rx);
     }
 
     int available(void) override;
diff --git a/cores/esp8266/uart.cpp b/cores/esp8266/uart.cpp
@@ -760,11 +760,11 @@ uart_uninit(uart_t* uart)
     free(uart);
 }
 
-void
+bool
 uart_swap(uart_t* uart, int tx_pin)
 {
     if(uart == NULL)
-        return;
+        return false;
 
     switch(uart->uart_nr)
     {
@@ -788,6 +788,7 @@ uart_swap(uart_t* uart, int tx_pin)
                 pinMode(uart->rx_pin, FUNCTION_4);    //RX
 
             IOSWAP |= (1 << IOSWAPU0);
+            return true;
         }
         else
         {
@@ -808,6 +809,7 @@ uart_swap(uart_t* uart, int tx_pin)
                 pinMode(3, SPECIAL);    //RX
 
             IOSWAP &= ~(1 << IOSWAPU0);
+            return true;
         }
         break;
     case UART1:
@@ -816,13 +818,14 @@ uart_swap(uart_t* uart, int tx_pin)
     default:
         break;
     }
+    return false;
 }
 
-void
+bool
 uart_set_tx(uart_t* uart, int tx_pin)
 {
     if(uart == NULL)
-        return;
+        return false;
 
     switch(uart->uart_nr)
     {
@@ -834,12 +837,14 @@ uart_set_tx(uart_t* uart, int tx_pin)
                 pinMode(uart->tx_pin, INPUT);
                 uart->tx_pin = 2;
                 pinMode(uart->tx_pin, FUNCTION_4);
+                return true;
             }
             else if (uart->tx_pin == 2 && tx_pin != 2)
             {
                 pinMode(uart->tx_pin, INPUT);
                 uart->tx_pin = 1;
                 pinMode(uart->tx_pin, SPECIAL);
+                return true;
             }
         }
 
@@ -850,33 +855,54 @@ uart_set_tx(uart_t* uart, int tx_pin)
     default:
         break;
     }
+    return false;
 }
 
-void
+bool
 uart_set_pins(uart_t* uart, int tx, int rx)
 {
     if(uart == NULL)
-        return;
+        return false;
+
+    if(uart->uart_nr != UART0) // Only UART0 allows pin changes
+        return false;
 
-    if(uart->uart_nr == UART0) // Only UART0 allows pin changes
+    if(uart->tx_enabled && uart->tx_pin != tx)
     {
-        if(uart->tx_enabled && uart->tx_pin != tx)
+        if( rx == 13 && tx == 15)
+        {
+            if (!uart_swap(uart, 15))
+                return false;
+        }
+        else if (rx == 3 && (tx == 1 || tx == 2))
         {
-            if( rx == 13 && tx == 15)
+            if (uart->rx_pin != rx)
             {
-                uart_swap(uart, 15);
+                if (!uart_swap(uart, tx))
+                    return false;
             }
-            else if (rx == 3 && (tx == 1 || tx == 2))
+            else
             {
-                if (uart->rx_pin != rx)
-                    uart_swap(uart, tx);
-                else
-                    uart_set_tx(uart, tx);
+                if (!uart_set_tx(uart, tx))
+                    return false;
             }
         }
-        if(uart->rx_enabled && uart->rx_pin != rx && rx == 13 && tx == 15)
-            uart_swap(uart, 15);
+        else
+            return false;
     }
+
+    if (uart->rx_enabled && uart->rx_pin != rx)
+    {
+        if (rx == 13 && tx == 15)
+        {
+            if (!uart_swap(uart, 15))
+                return false;
+        }
+        else
+            return false;
+    }
+
+    return true;
 }
 
 
diff --git a/cores/esp8266/uart.h b/cores/esp8266/uart.h
@@ -116,9 +116,9 @@ typedef struct uart_ uart_t;
 uart_t* uart_init(int uart_nr, int baudrate, int config, int mode, int tx_pin, size_t rx_size, bool invert);
 void uart_uninit(uart_t* uart);
 
-void uart_swap(uart_t* uart, int tx_pin);
-void uart_set_tx(uart_t* uart, int tx_pin);
-void uart_set_pins(uart_t* uart, int tx, int rx);
+bool uart_swap(uart_t* uart, int tx_pin);
+bool uart_set_tx(uart_t* uart, int tx_pin);
+bool uart_set_pins(uart_t* uart, int tx, int rx);
 bool uart_tx_enabled(uart_t* uart);
 bool uart_rx_enabled(uart_t* uart);
 
diff --git a/tests/host/common/MockUART.cpp b/tests/host/common/MockUART.cpp
@@ -407,26 +407,29 @@ uart_uninit(uart_t* uart)
 	free(uart);
 }
 
-void
+bool
 uart_swap(uart_t* uart, int tx_pin)
 {
 	(void) uart;
 	(void) tx_pin;
+	return true;
 }
 
-void
+bool
 uart_set_tx(uart_t* uart, int tx_pin)
 {
 	(void) uart;
 	(void) tx_pin;
+	return true;
 }
 
-void
+bool
 uart_set_pins(uart_t* uart, int tx, int rx)
 {
 	(void) uart;
 	(void) tx;
 	(void) rx;
+	return true;
 }
 
 bool

Original file line number	Diff line number	Diff line change
`@@ -101,31 +101,31 @@ class HardwareSerial: public Stream`
`101`	`101`	`return uart_get_rx_buffer_size(_uart);`
`102`	`102`	`}`
`103`	`103`
`104`		`- void swap()`
	`104`	`+ bool swap()`
`105`	`105`	`{`
`106`		`- swap(1);`
	`106`	`+ return swap(1);`
`107`	`107`	`}`
`108`		`- void swap(uint8_t tx_pin) //toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX`
	`108`	`+ bool swap(uint8_t tx_pin) //toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX`
`109`	`109`	`{`
`110`		`- uart_swap(_uart, tx_pin);`
	`110`	`+ return uart_swap(_uart, tx_pin);`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`/*`
`114`	`114`	`* Toggle between use of GPIO1 and GPIO2 as TX on UART 0.`
`115`	`115`	`* Note: UART 1 can't be used if GPIO2 is used with UART 0!`
`116`	`116`	`*/`
`117`		`- void set_tx(uint8_t tx_pin)`
	`117`	`+ bool set_tx(uint8_t tx_pin)`
`118`	`118`	`{`
`119`		`- uart_set_tx(_uart, tx_pin);`
	`119`	`+ return uart_set_tx(_uart, tx_pin);`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`/*`
`123`	`123`	`* UART 0 possible options are (1, 3), (2, 3) or (15, 13)`
`124`	`124`	`* UART 1 allows only TX on 2 if UART 0 is not (2, 3)`
`125`	`125`	`*/`
`126`		`- void pins(uint8_t tx, uint8_t rx)`
	`126`	`+ bool pins(uint8_t tx, uint8_t rx)`
`127`	`127`	`{`
`128`		`- uart_set_pins(_uart, tx, rx);`
	`128`	`+ return uart_set_pins(_uart, tx, rx);`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`int available(void) override;`
Original file line number	Diff line number	Diff line change
`@@ -760,11 +760,11 @@ uart_uninit(uart_t* uart)`
`760`	`760`	`free(uart);`
`761`	`761`	`}`
`762`	`762`
`763`		`-void`
	`763`	`+bool`
`764`	`764`	`uart_swap(uart_t* uart, int tx_pin)`
`765`	`765`	`{`
`766`	`766`	`if(uart == NULL)`
`767`		`- return;`
	`767`	`+ return false;`
`768`	`768`
`769`	`769`	`switch(uart->uart_nr)`
`770`	`770`	`{`
`@@ -788,6 +788,7 @@ uart_swap(uart_t* uart, int tx_pin)`
`788`	`788`	`pinMode(uart->rx_pin, FUNCTION_4); //RX`
`789`	`789`
`790`	`790`	`IOSWAP \|= (1 << IOSWAPU0);`
	`791`	`+ return true;`
`791`	`792`	`}`
`792`	`793`	`else`
`793`	`794`	`{`
`@@ -808,6 +809,7 @@ uart_swap(uart_t* uart, int tx_pin)`
`808`	`809`	`pinMode(3, SPECIAL); //RX`
`809`	`810`
`810`	`811`	`IOSWAP &= ~(1 << IOSWAPU0);`
	`812`	`+ return true;`
`811`	`813`	`}`
`812`	`814`	`break;`
`813`	`815`	`case UART1:`
`@@ -816,13 +818,14 @@ uart_swap(uart_t* uart, int tx_pin)`
`816`	`818`	`default:`
`817`	`819`	`break;`
`818`	`820`	`}`
	`821`	`+ return false;`
`819`	`822`	`}`
`820`	`823`
`821`		`-void`
	`824`	`+bool`
`822`	`825`	`uart_set_tx(uart_t* uart, int tx_pin)`
`823`	`826`	`{`
`824`	`827`	`if(uart == NULL)`
`825`		`- return;`
	`828`	`+ return false;`
`826`	`829`
`827`	`830`	`switch(uart->uart_nr)`
`828`	`831`	`{`
`@@ -834,12 +837,14 @@ uart_set_tx(uart_t* uart, int tx_pin)`
`834`	`837`	`pinMode(uart->tx_pin, INPUT);`
`835`	`838`	`uart->tx_pin = 2;`
`836`	`839`	`pinMode(uart->tx_pin, FUNCTION_4);`
	`840`	`+ return true;`
`837`	`841`	`}`
`838`	`842`	`else if (uart->tx_pin == 2 && tx_pin != 2)`
`839`	`843`	`{`
`840`	`844`	`pinMode(uart->tx_pin, INPUT);`
`841`	`845`	`uart->tx_pin = 1;`
`842`	`846`	`pinMode(uart->tx_pin, SPECIAL);`
	`847`	`+ return true;`
`843`	`848`	`}`
`844`	`849`	`}`
`845`	`850`
`@@ -850,33 +855,54 @@ uart_set_tx(uart_t* uart, int tx_pin)`
`850`	`855`	`default:`
`851`	`856`	`break;`
`852`	`857`	`}`
	`858`	`+ return false;`
`853`	`859`	`}`
`854`	`860`
`855`		`-void`
	`861`	`+bool`
`856`	`862`	`uart_set_pins(uart_t* uart, int tx, int rx)`
`857`	`863`	`{`
`858`	`864`	`if(uart == NULL)`
`859`		`- return;`
	`865`	`+ return false;`
	`866`	`+`
	`867`	`+ if(uart->uart_nr != UART0) // Only UART0 allows pin changes`
	`868`	`+ return false;`
`860`	`869`
`861`		`- if(uart->uart_nr == UART0) // Only UART0 allows pin changes`
	`870`	`+ if(uart->tx_enabled && uart->tx_pin != tx)`
`862`	`871`	`{`
`863`		`- if(uart->tx_enabled && uart->tx_pin != tx)`
	`872`	`+ if( rx == 13 && tx == 15)`
	`873`	`+ {`
	`874`	`+ if (!uart_swap(uart, 15))`
	`875`	`+ return false;`
	`876`	`+ }`
	`877`	`+ else if (rx == 3 && (tx == 1 \|\| tx == 2))`
`864`	`878`	`{`
`865`		`- if( rx == 13 && tx == 15)`
	`879`	`+ if (uart->rx_pin != rx)`
`866`	`880`	`{`
`867`		`- uart_swap(uart, 15);`
	`881`	`+ if (!uart_swap(uart, tx))`
	`882`	`+ return false;`
`868`	`883`	`}`
`869`		`- else if (rx == 3 && (tx == 1 \|\| tx == 2))`
	`884`	`+ else`
`870`	`885`	`{`
`871`		`- if (uart->rx_pin != rx)`
`872`		`- uart_swap(uart, tx);`
`873`		`- else`
`874`		`- uart_set_tx(uart, tx);`
	`886`	`+ if (!uart_set_tx(uart, tx))`
	`887`	`+ return false;`
`875`	`888`	`}`
`876`	`889`	`}`
`877`		`- if(uart->rx_enabled && uart->rx_pin != rx && rx == 13 && tx == 15)`
`878`		`- uart_swap(uart, 15);`
	`890`	`+ else`
	`891`	`+ return false;`
`879`	`892`	`}`
	`893`	`+`
	`894`	`+ if (uart->rx_enabled && uart->rx_pin != rx)`
	`895`	`+ {`
	`896`	`+ if (rx == 13 && tx == 15)`
	`897`	`+ {`
	`898`	`+ if (!uart_swap(uart, 15))`
	`899`	`+ return false;`
	`900`	`+ }`
	`901`	`+ else`
	`902`	`+ return false;`
	`903`	`+ }`
	`904`	`+`
	`905`	`+ return true;`
`880`	`906`	`}`
`881`	`907`
`882`	`908`
Original file line number	Diff line number	Diff line change
`@@ -407,26 +407,29 @@ uart_uninit(uart_t* uart)`
`407`	`407`	`free(uart);`
`408`	`408`	`}`
`409`	`409`
`410`		`-void`
	`410`	`+bool`
`411`	`411`	`uart_swap(uart_t* uart, int tx_pin)`
`412`	`412`	`{`
`413`	`413`	`(void) uart;`
`414`	`414`	`(void) tx_pin;`
	`415`	`+ return true;`
`415`	`416`	`}`
`416`	`417`
`417`		`-void`
	`418`	`+bool`
`418`	`419`	`uart_set_tx(uart_t* uart, int tx_pin)`
`419`	`420`	`{`
`420`	`421`	`(void) uart;`
`421`	`422`	`(void) tx_pin;`
	`423`	`+ return true;`
`422`	`424`	`}`
`423`	`425`
`424`		`-void`
	`426`	`+bool`
`425`	`427`	`uart_set_pins(uart_t* uart, int tx, int rx)`
`426`	`428`	`{`
`427`	`429`	`(void) uart;`
`428`	`430`	`(void) tx;`
`429`	`431`	`(void) rx;`
	`432`	`+ return true;`
`430`	`433`	`}`
`431`	`434`
`432`	`435`	`bool`