Formatting and such

SpenceKonde · SpenceKonde · commit eeaaa260bf14 · 2021-01-11T21:52:16.000-05:00
diff --git a/megaavr/cores/megatinycore/UART.cpp b/megaavr/cores/megatinycore/UART.cpp
@@ -116,12 +116,6 @@ void UartClass::_tx_data_empty_irq(void) {
   if (_tx_buffer_head == _tx_buffer_tail) {
     // Buffer empty, so disable "data register empty" interrupt
     (*_hwserial_module).CTRLA &= (~USART_DREIE_bm);
-
-    //Take the DRE interrupt back no normal priority level if it has been elevated
-    //if (_hwserial_dre_interrupt_elevated) {
-    //  CPUINT.LVL1VEC = _prev_lvl1_interrupt_vect;
-    //  _hwserial_dre_interrupt_elevated = 0;
-    //}
   }
 }
 
@@ -196,10 +190,12 @@ void UartClass::begin(unsigned long baud, uint16_t config) {
   if(baud>=(38400*(F_CPU/1000000))) {
     rxmode = USART_RXMODE_CLK2X_gc;
     baud=baud>>1;
+  } /*
+  since this is the default, we don't need to set this, saving a bit of flash.
+  else {
+    rxmode = USART_RXMODE_NORMAL_gc;
   }
-  //else {
-  //  rxmode = USART_RXMODE_NORMAL_gc;
-  //}
+  */
   #else
   //if clocked at 1 or 2 MHz, always use CLK2X mode and save a bit of space, we correct for not shifting the baud value below, as it saves a bit of flash
     rxmode = USART_RXMODE_CLK2X_gc;
@@ -210,42 +206,42 @@ void UartClass::begin(unsigned long baud, uint16_t config) {
 
 
   //See #131 for more info on this
-  #if (CLOCK_SOURCE==0 && PROGMEM_SIZE>4096 && (defined(UARTBAUD3V)||UARTBAUD5V))
-  // if the flash is 2k or 4k, we really can't spare the flash for the baud rate correction...
-  // it's close enough to work under normal circumstances anyway.
-  #if (F_CPU==20000000UL || F_CPU==10000000UL || F_CPU==5000000UL) //this means we are on the 20MHz oscillator
-  #ifdef UARTBAUD3V
-  int8_t sigrow_val = SIGROW.OSC20ERR3V;
-  #else
-  int8_t sigrow_val = SIGROW.OSC20ERR5V;
-  #endif
-  #else //we are on 16MHz one
-  #ifdef UARTBAUD3V
-  int8_t sigrow_val = SIGROW.OSC16ERR3V;
-  #else
-  int8_t sigrow_val = SIGROW.OSC16ERR5V;
-  #endif
-  #endif
-  #if (F_CPU > 2000000)
-  //if we are above 2 MHz, baud was corrected above if CLK2X used.
-  baud_setting = ((8 * F_CPU) / baud);
-  #else
-  //if clocked at 1 or 2 MHz, always use CLK2X mode and save a bit of flash...
-  baud_setting = ((16 * F_CPU) / baud);
-  #endif
-  baud_setting *= (1024 + sigrow_val);
-  baud_setting /= 2048;
-  if (baud_setting>65535){
-    baud_setting=65535;
-  }
-  #else
-  #if (F_CPU > 2000000)
-  //if we are above 2 MHz, baud was corrected above if CLK2X used.
-  baud_setting = (((4 * F_CPU) / baud));
-  #else
-  //if clocked at 1 or 2 MHz, always use CLK2X mode and save a bit of flash...
-  baud_setting = (((8 * F_CPU) / baud));
-  #endif
+  #if (CLOCK_SOURCE==0 && PROGMEM_SIZE > 4096 && (defined(UARTBAUD3V) || defined(UARTBAUD5V)))
+    // if the flash is 2k or 4k, we really can't spare the flash for the baud rate correction...
+    // it's close enough to work under normal circumstances anyway.
+    #if (F_CPU==20000000UL || F_CPU==10000000UL || F_CPU==5000000UL) //this means we are on the 20MHz oscillator
+      #ifdef UARTBAUD3V
+        int8_t sigrow_val = SIGROW.OSC20ERR3V;
+      #else
+        int8_t sigrow_val = SIGROW.OSC20ERR5V;
+      #endif
+    #else //we are on 16MHz one
+      #ifdef UARTBAUD3V
+        int8_t sigrow_val = SIGROW.OSC16ERR3V;
+      #else
+        int8_t sigrow_val = SIGROW.OSC16ERR5V;
+      #endif
+    #endif
+    #if (F_CPU > 2000000)
+      //if we are above 2 MHz, baud was corrected above if CLK2X used.
+      baud_setting = ((8 * F_CPU) / baud);
+    #else
+      //if clocked at 1 or 2 MHz, always use CLK2X mode and save a bit of flash...
+      baud_setting = ((16 * F_CPU) / baud);
+    #endif
+    baud_setting *= (1024 + sigrow_val);
+    baud_setting /= 2048;
+    if (baud_setting>65535){
+      baud_setting=65535;
+    }
+    #else
+    #if (F_CPU > 2000000)
+      //if we are above 2 MHz, baud was corrected above if CLK2X used.
+      baud_setting = (((4 * F_CPU) / baud));
+    #else
+      //if clocked at 1 or 2 MHz, always use CLK2X mode and save a bit of flash...
+      baud_setting = (((8 * F_CPU) / baud));
+    #endif
   #endif
 
   // Make sure global interrupts are disabled during initialization
@@ -266,9 +262,9 @@ void UartClass::begin(unsigned long baud, uint16_t config) {
 
   // Let PORTMUX point to alternative UART pins as requested
   #ifdef PORTMUX_CTRLB
-  PORTMUX.CTRLB = set->mux | (PORTMUX.CTRLB & ~_hw_set[1].mux);
+    PORTMUX.CTRLB = set->mux | (PORTMUX.CTRLB & ~_hw_set[1].mux);
   #else
-  PORTMUX.USARTROUTEA = set->mux | (PORTMUX.USARTROUTEA & ~_hw_set[1].mux);
+    PORTMUX.USARTROUTEA = set->mux | (PORTMUX.USARTROUTEA & ~_hw_set[1].mux);
   #endif
 
   // Set pin state for swapped UART pins
@@ -341,7 +337,7 @@ void UartClass::flush() {
     return;
   }
 
-  //Check if we are inside an ISR already (e.g. connected to a different peripheral then UART), in which case the UART ISRs will not be called.
+  // Check if we are inside an ISR already (e.g. connected to a different peripheral then UART), in which case the UART ISRs will not be called.
   // Spence 10/23/20: Changed _poll_tx_data_empty() to instead call the ISR directly in this case too
   // Why elevate the interrupt if we're going to go into a busywait loop checking if the interrupt is disabled and if so, check for the bit and
   // manually call the ISR if the bit is set... *anyway*? Plus, in write(), this mode will be enabled upon a write of a single character from an ISR
@@ -350,16 +346,6 @@ void UartClass::flush() {
   // it's appropriate to use for applications where it has only very small benefits, and significant risk of surprising the user and causing
   // breakage of code that would otherwise work. Finally, the previous implementation didn't check if it was called from the current lvl1 ISR
   // and in that case flush(), and write() with full buffer would just straight up hang...
-  //
-  //Temporarily elevate the DRE interrupt to allow it to run.
-  //if (CPUINT.STATUS & CPUINT_LVL0EX_bm) {
-    //Elevate the priority level of the Data Register Empty Interrupt vector
-    //and copy whatever vector number that might be in the register already.
-  //  _prev_lvl1_interrupt_vect = CPUINT.LVL1VEC;
-  //  CPUINT.LVL1VEC = _hwserial_dre_interrupt_vect_num;
-
-  //  _hwserial_dre_interrupt_elevated = 1;
-  //}
 
   // Spin until the data-register-empty-interrupt is disabled and TX complete interrupt flag is raised
   while (((*_hwserial_module).CTRLA & USART_DREIE_bm) || (!((*_hwserial_module).STATUS & USART_TXCIF_bm))) {
@@ -368,10 +354,45 @@ void UartClass::flush() {
     // poll the "data register empty" interrupt flag to prevent deadlock
     _poll_tx_data_empty();
   }
-  // If we get here, nothing is queued anymore (DREIE is disabled) and
+  // When we get here, nothing is queued anymore (DREIE is disabled) and
   // the hardware finished transmission (TXCIF is set).
 }
 
+size_t UartClass::write(uint8_t c) {
+  _written = true;
+
+  // If the buffer and the data register is empty, just write the byte
+  // to the data register and be done. This shortcut helps
+  // significantly improve the effective data rate at high (>
+  // 500kbit/s) bit rates, where interrupt overhead becomes a slowdown.
+  if ((_tx_buffer_head == _tx_buffer_tail) && ((*_hwserial_module).STATUS & USART_DREIF_bm)) {
+    (*_hwserial_module).TXDATAL = c;
+    (*_hwserial_module).STATUS = USART_TXCIF_bm;
+
+    // Make sure data register empty interrupt is disabled to avoid
+    // that the interrupt handler is called in this situation
+    (*_hwserial_module).CTRLA &= (~USART_DREIE_bm);
+
+    return 1;
+  }
+
+  tx_buffer_index_t i = (_tx_buffer_head + 1) & (SERIAL_TX_BUFFER_SIZE-1); // % SERIAL_TX_BUFFER_SIZE;
+
+  //If the output buffer is full, there's nothing for it other than to
+  //wait for the interrupt handler to empty it a bit (or emulate interrupts)
+  while (i == _tx_buffer_tail) {
+    _poll_tx_data_empty();
+  }
+
+  _tx_buffer[_tx_buffer_head] = c;
+  _tx_buffer_head = i;
+
+  // Enable data "register empty interrupt"
+  (*_hwserial_module).CTRLA |= USART_DREIE_bm;
+
+  return 1;
+}
+
 void UartClass::printHex (const uint8_t b) {
   char x=(b>>4)|'0';
   if (x > '9')
@@ -425,51 +446,5 @@ uint16_t * UartClass::printHex(uint16_t* p, uint8_t len, char sep, bool swaporde
   }
   return p;
 }
-size_t UartClass::write(uint8_t c) {
-  _written = true;
-
-  // If the buffer and the data register is empty, just write the byte
-  // to the data register and be done. This shortcut helps
-  // significantly improve the effective data rate at high (>
-  // 500kbit/s) bit rates, where interrupt overhead becomes a slowdown.
-  if ((_tx_buffer_head == _tx_buffer_tail) && ((*_hwserial_module).STATUS & USART_DREIF_bm)) {
-    (*_hwserial_module).TXDATAL = c;
-    (*_hwserial_module).STATUS = USART_TXCIF_bm;
-
-    // Make sure data register empty interrupt is disabled to avoid
-    // that the interrupt handler is called in this situation
-    (*_hwserial_module).CTRLA &= (~USART_DREIE_bm);
 
-    return 1;
-  }
-  // See above for reasoning for disabling this functionality and moving the check
-  // to _poll_tx_data_empty()
-  //Check if we are inside an ISR already (could be from by a source other than UART),
-  // in which case the UART ISRs will be blocked.
-  //if (CPUINT.STATUS & CPUINT_LVL0EX_bm) {
-    //Elevate the priority level of the Data Register Empty Interrupt vector
-    //and copy whatever vector number that might be in the register already.
-  //  _prev_lvl1_interrupt_vect = CPUINT.LVL1VEC;
-  //  CPUINT.LVL1VEC = _hwserial_dre_interrupt_vect_num;
-
-  //  _hwserial_dre_interrupt_elevated = 1;
-  //}
-
-  tx_buffer_index_t i = (_tx_buffer_head + 1) & (SERIAL_TX_BUFFER_SIZE-1); // % SERIAL_TX_BUFFER_SIZE;
-
-  //If the output buffer is full, there's nothing for it other than to
-  //wait for the interrupt handler to empty it a bit (or emulate interrupts)
-  while (i == _tx_buffer_tail) {
-    _poll_tx_data_empty();
-  }
-
-  _tx_buffer[_tx_buffer_head] = c;
-  _tx_buffer_head = i;
-
-  // Enable data "register empty interrupt"
-  (*_hwserial_module).CTRLA |= USART_DREIE_bm;
-
-  return 1;
-}
-
-#endif // whole file
+#endif
diff --git a/megaavr/cores/megatinycore/wiring_analog.c b/megaavr/cores/megatinycore/wiring_analog.c
@@ -289,20 +289,20 @@ void analogWrite(uint8_t pin, int val) {
         #if defined(NO_GLITCH_TIMERD0)
           // We only support control of the TCD0 PWM functionality on PIN_PC0 and PIN_PC1 (on 20 and 24 pin parts )
           // so if we're here, we're acting on either PC0 or PC1.
-          if (set_inven==0){
+          if (set_inven == 0){
             // we are not setting invert to make the pin HIGH when not set; either was 0 (just set CMPxSET > CMPBCLR)
             // or somewhere in between.
-            if (bit_pos==0){
-              PORTC.PIN0CTRL&=~(PORT_INVEN_bm);
+            if (bit_pos == 0){
+              PORTC.PIN0CTRL &= ~(PORT_INVEN_bm);
             } else {
-              PORTC.PIN1CTRL&=~(PORT_INVEN_bm);
+              PORTC.PIN1CTRL &= ~(PORT_INVEN_bm);
             }
           } else {
             // we *are* turning off PWM while forcing pin high - analogwrite(pin,255) was called on TCD0 PWM pin...
-            if (bit_pos==0){
-              PORTC.PIN0CTRL|=PORT_INVEN_bm;
+            if (bit_pos == 0){
+              PORTC.PIN0CTRL |= PORT_INVEN_bm;
             } else {
-              PORTC.PIN1CTRL|=PORT_INVEN_bm;
+              PORTC.PIN1CTRL |= PORT_INVEN_bm;
             }
           }
         #endif
