Sfoglia il codice sorgente

Opening brace tweaks

Scott Lahteine 7 anni fa
parent
commit
1a827d5b68

+ 10
- 19
Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_st7920_sw_spi.cpp Vedi File

@@ -61,13 +61,11 @@
61 61
   #include <Arduino.h>
62 62
   #include "../../core/macros.h"
63 63
 
64
-
65 64
   void u8g_SetPIOutput_DUE(u8g_t *u8g, uint8_t pin_index) {
66 65
      PIO_Configure(g_APinDescription[u8g->pin_list[pin_index]].pPort, PIO_OUTPUT_1,
67 66
        g_APinDescription[u8g->pin_list[pin_index]].ulPin, g_APinDescription[u8g->pin_list[pin_index]].ulPinConfiguration);  // OUTPUT
68 67
   }
69 68
 
70
-
71 69
   void u8g_SetPILevel_DUE(u8g_t *u8g, uint8_t pin_index, uint8_t level) {
72 70
     volatile Pio* port = g_APinDescription[u8g->pin_list[pin_index]].pPort;
73 71
     uint32_t mask = g_APinDescription[u8g->pin_list[pin_index]].ulPin;
@@ -75,7 +73,6 @@
75 73
     else port->PIO_CODR = mask;
76 74
   }
77 75
 
78
-
79 76
 #define nop() __asm__ __volatile__("nop;\n\t":::)
80 77
 
81 78
 void __delay_4cycles(uint32_t cy) __attribute__ ((weak));
@@ -102,8 +99,7 @@ FORCE_INLINE void __delay_4cycles(uint32_t cy) { // +1 cycle
102 99
   Pio *SCK_pPio, *MOSI_pPio;
103 100
   uint32_t SCK_dwMask, MOSI_dwMask;
104 101
 
105
-  static void spiSend_sw_DUE(uint8_t val)  // 800KHz
106
-  {
102
+  static void spiSend_sw_DUE(uint8_t val) { // 800KHz
107 103
     for (uint8_t i = 0; i < 8; i++) {
108 104
       if (val & 0x80)
109 105
         MOSI_pPio->PIO_SODR = MOSI_dwMask;
@@ -119,8 +115,7 @@ FORCE_INLINE void __delay_4cycles(uint32_t cy) { // +1 cycle
119 115
 
120 116
   static uint8_t rs_last_state = 255;
121 117
 
122
-  static void u8g_com_DUE_st7920_write_byte_sw_spi(uint8_t rs, uint8_t val)
123
-  {
118
+  static void u8g_com_DUE_st7920_write_byte_sw_spi(uint8_t rs, uint8_t val) {
124 119
     uint8_t i;
125 120
 
126 121
     if ( rs != rs_last_state) {  // time to send a command/data byte
@@ -142,10 +137,8 @@ FORCE_INLINE void __delay_4cycles(uint32_t cy) { // +1 cycle
142 137
   }
143 138
 
144 139
 
145
-  uint8_t u8g_com_HAL_DUE_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
146
-  {
147
-    switch(msg)
148
-    {
140
+  uint8_t u8g_com_HAL_DUE_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
141
+    switch (msg) {
149 142
       case U8G_COM_MSG_INIT:
150 143
         SCK_pPio = g_APinDescription[u8g->pin_list[U8G_PI_SCK]].pPort;
151 144
         SCK_dwMask = g_APinDescription[u8g->pin_list[U8G_PI_SCK]].ulPin;
@@ -184,22 +177,18 @@ FORCE_INLINE void __delay_4cycles(uint32_t cy) { // +1 cycle
184 177
         u8g_com_DUE_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val);
185 178
         break;
186 179
 
187
-      case U8G_COM_MSG_WRITE_SEQ:
188
-        {
180
+      case U8G_COM_MSG_WRITE_SEQ: {
189 181
           uint8_t *ptr = (uint8_t*) arg_ptr;
190
-          while( arg_val > 0 )
191
-          {
182
+          while (arg_val > 0) {
192 183
             u8g_com_DUE_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
193 184
             arg_val--;
194 185
           }
195 186
         }
196 187
         break;
197 188
 
198
-        case U8G_COM_MSG_WRITE_SEQ_P:
199
-        {
189
+        case U8G_COM_MSG_WRITE_SEQ_P: {
200 190
           uint8_t *ptr = (uint8_t*) arg_ptr;
201
-          while( arg_val > 0 )
202
-          {
191
+          while (arg_val > 0) {
203 192
             u8g_com_DUE_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
204 193
             arg_val--;
205 194
           }
@@ -208,5 +197,7 @@ FORCE_INLINE void __delay_4cycles(uint32_t cy) { // +1 cycle
208 197
     }
209 198
     return 1;
210 199
   }
200
+
211 201
 #pragma GCC reset_options
202
+
212 203
 #endif  //ARDUINO_ARCH_SAM

+ 4
- 8
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_hw_spi.cpp Vedi File

@@ -118,22 +118,18 @@
118 118
         spiSend((uint8_t)arg_val);
119 119
         break;
120 120
 
121
-      case U8G_COM_MSG_WRITE_SEQ:
122
-        {
121
+      case U8G_COM_MSG_WRITE_SEQ: {
123 122
           uint8_t *ptr = (uint8_t*) arg_ptr;
124
-          while( arg_val > 0 )
125
-          {
123
+          while (arg_val > 0) {
126 124
             spiSend(*ptr++);
127 125
             arg_val--;
128 126
           }
129 127
         }
130 128
         break;
131 129
 
132
-      case U8G_COM_MSG_WRITE_SEQ_P:
133
-        {
130
+      case U8G_COM_MSG_WRITE_SEQ_P: {
134 131
           uint8_t *ptr = (uint8_t*) arg_ptr;
135
-          while( arg_val > 0 )
136
-          {
132
+          while (arg_val > 0) {
137 133
             spiSend(*ptr++);
138 134
             arg_val--;
139 135
           }

+ 2
- 4
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_ssd_hw_i2c.cpp Vedi File

@@ -160,8 +160,7 @@
160 160
           return u8g_i2c_stop(), 0;
161 161
         {
162 162
           register uint8_t *ptr = (uint8_t *)arg_ptr;
163
-          while( arg_val > 0 )
164
-          {
163
+          while (arg_val > 0) {
165 164
             if ( u8g_i2c_send_byte(*ptr++) == 0 )
166 165
               return u8g_i2c_stop(), 0;
167 166
             arg_val--;
@@ -176,8 +175,7 @@
176 175
           return u8g_i2c_stop(), 0;
177 176
         {
178 177
           register uint8_t *ptr = (uint8_t *)arg_ptr;
179
-          while( arg_val > 0 )
180
-          {
178
+          while (arg_val > 0) {
181 179
             if ( u8g_i2c_send_byte(u8g_pgm_read(ptr)) == 0 )
182 180
               return 0;
183 181
             ptr++;

+ 2
- 4
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_ssd_sw_i2c.cpp under construction Vedi File

@@ -239,8 +239,7 @@ void u8g_i2c_init_sw(uint8_t clock_option) {
239 239
           return u8g_i2c_stop_sw(), 0;
240 240
         {
241 241
           register uint8_t *ptr = (uint8_t *)arg_ptr;
242
-          while( arg_val > 0 )
243
-          {
242
+          while (arg_val > 0) {
244 243
             if ( u8g_i2c_send_byte_sw(*ptr++) == 0 )
245 244
               return u8g_i2c_stop_sw(), 0;
246 245
             arg_val--;
@@ -255,8 +254,7 @@ void u8g_i2c_init_sw(uint8_t clock_option) {
255 254
           return u8g_i2c_stop_sw(), 0;
256 255
         {
257 256
           register uint8_t *ptr = (uint8_t *)arg_ptr;
258
-          while( arg_val > 0 )
259
-          {
257
+          while (arg_val > 0) {
260 258
             if ( u8g_i2c_send_byte_sw(u8g_pgm_read(ptr)) == 0 )
261 259
               return 0;
262 260
             ptr++;

+ 4
- 8
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_st7920_hw_spi.cpp Vedi File

@@ -136,22 +136,18 @@
136 136
         u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val);
137 137
         break;
138 138
 
139
-      case U8G_COM_MSG_WRITE_SEQ:
140
-        {
139
+      case U8G_COM_MSG_WRITE_SEQ: {
141 140
           uint8_t *ptr = (uint8_t*) arg_ptr;
142
-          while( arg_val > 0 )
143
-          {
141
+          while (arg_val > 0) {
144 142
             u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
145 143
             arg_val--;
146 144
           }
147 145
         }
148 146
         break;
149 147
 
150
-        case U8G_COM_MSG_WRITE_SEQ_P:
151
-        {
148
+        case U8G_COM_MSG_WRITE_SEQ_P: {
152 149
           uint8_t *ptr = (uint8_t*) arg_ptr;
153
-          while( arg_val > 0 )
154
-          {
150
+          while (arg_val > 0) {
155 151
             u8g_com_LPC1768_st7920_write_byte_hw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
156 152
             arg_val--;
157 153
           }

+ 4
- 8
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_st7920_sw_spi.cpp Vedi File

@@ -170,22 +170,18 @@
170 170
         u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val);
171 171
         break;
172 172
 
173
-      case U8G_COM_MSG_WRITE_SEQ:
174
-        {
173
+      case U8G_COM_MSG_WRITE_SEQ: {
175 174
           uint8_t *ptr = (uint8_t*) arg_ptr;
176
-          while( arg_val > 0 )
177
-          {
175
+          while (arg_val > 0) {
178 176
             u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
179 177
             arg_val--;
180 178
           }
181 179
         }
182 180
         break;
183 181
 
184
-        case U8G_COM_MSG_WRITE_SEQ_P:
185
-        {
182
+        case U8G_COM_MSG_WRITE_SEQ_P: {
186 183
           uint8_t *ptr = (uint8_t*) arg_ptr;
187
-          while( arg_val > 0 )
188
-          {
184
+          while (arg_val > 0) {
189 185
             u8g_com_LPC1768_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
190 186
             arg_val--;
191 187
           }

+ 4
- 8
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_sw_spi.cpp Vedi File

@@ -150,22 +150,18 @@ uint8_t u8g_com_HAL_LPC1768_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val,
150 150
       u8g_sw_spi_HAL_LPC1768_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], arg_val);
151 151
       break;
152 152
 
153
-    case U8G_COM_MSG_WRITE_SEQ:
154
-      {
153
+    case U8G_COM_MSG_WRITE_SEQ: {
155 154
         uint8_t *ptr = (uint8_t *)arg_ptr;
156
-        while( arg_val > 0 )
157
-        {
155
+        while (arg_val > 0) {
158 156
           u8g_sw_spi_HAL_LPC1768_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], *ptr++);
159 157
           arg_val--;
160 158
         }
161 159
       }
162 160
       break;
163 161
 
164
-      case U8G_COM_MSG_WRITE_SEQ_P:
165
-      {
162
+      case U8G_COM_MSG_WRITE_SEQ_P: {
166 163
         uint8_t *ptr = (uint8_t *)arg_ptr;
167
-        while( arg_val > 0 )
168
-        {
164
+        while (arg_val > 0) {
169 165
           u8g_sw_spi_HAL_LPC1768_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], u8g_pgm_read(ptr));
170 166
           ptr++;
171 167
           arg_val--;

+ 3
- 6
Marlin/src/gcode/feature/trinamic/M122.cpp Vedi File

@@ -110,8 +110,7 @@ static void drv_status_print_hex(const char name[], const uint32_t drv_status) {
110 110
 #if ENABLED(HAVE_TMC2208)
111 111
   static void tmc_status(TMC2208Stepper &st, const TMC_debug_enum i) {
112 112
     switch(i) {
113
-      case TMC_TSTEP:
114
-        {
113
+      case TMC_TSTEP: {
115 114
           uint32_t data = 0;
116 115
           st.TSTEP(&data);
117 116
           MYSERIAL.print(data);
@@ -159,14 +158,12 @@ static void tmc_status(TMC &st, TMC_AxisEnum axis, const TMC_debug_enum i, const
159 158
     case TMC_VSENSE: serialprintPGM(st.vsense() ? PSTR("1=.18") : PSTR("0=.325")); break;
160 159
 
161 160
     case TMC_MICROSTEPS: SERIAL_ECHO(st.microsteps()); break;
162
-    case TMC_TPWMTHRS:
163
-      {
161
+    case TMC_TPWMTHRS: {
164 162
         uint32_t tpwmthrs_val = st.TPWMTHRS();
165 163
         SERIAL_ECHO(tpwmthrs_val);
166 164
       }
167 165
       break;
168
-    case TMC_TPWMTHRS_MMS:
169
-      {
166
+    case TMC_TPWMTHRS_MMS: {
170 167
         uint32_t tpwmthrs_val = st.TPWMTHRS();
171 168
         tpwmthrs_val ? SERIAL_ECHO(12650000UL * st.microsteps() / (256 * tpwmthrs_val * spmm)) : SERIAL_ECHO('-');
172 169
       }

+ 2
- 4
Marlin/src/lcd/dogm/u8g_dev_ssd1306_sh1106_128x64_I2C.cpp Vedi File

@@ -128,8 +128,7 @@ uint8_t u8g_dev_sh1106_128x64_2x_2_wire_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t m
128 128
       break;
129 129
     case U8G_DEV_MSG_STOP:
130 130
       break;
131
-    case U8G_DEV_MSG_PAGE_NEXT:
132
-      {
131
+    case U8G_DEV_MSG_PAGE_NEXT: {
133 132
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
134 133
         u8g_SetAddress(u8g, dev, 0);           // instruction mode
135 134
         u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_sh1106_128x64_data_start_2_wire);
@@ -202,8 +201,7 @@ uint8_t u8g_dev_ssd1306_128x64_2x_2_wire_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t
202 201
       break;
203 202
     case U8G_DEV_MSG_STOP:
204 203
       break;
205
-    case U8G_DEV_MSG_PAGE_NEXT:
206
-      {
204
+    case U8G_DEV_MSG_PAGE_NEXT: {
207 205
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
208 206
         u8g_SetAddress(u8g, dev, 0);           // instruction mode
209 207
         u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_ssd1306_128x64_data_start_2_wire);

+ 2
- 4
Marlin/src/lcd/dogm/u8g_dev_st7565_64128n_HAL.cpp Vedi File

@@ -149,8 +149,7 @@ uint8_t u8g_dev_st7565_64128n_HAL_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, vo
149 149
       break;
150 150
     case U8G_DEV_MSG_STOP:
151 151
       break;
152
-    case U8G_DEV_MSG_PAGE_NEXT:
153
-      {
152
+    case U8G_DEV_MSG_PAGE_NEXT: {
154 153
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
155 154
         u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_HAL_data_start);
156 155
         u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */
@@ -187,8 +186,7 @@ uint8_t u8g_dev_st7565_64128n_HAL_2x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg,
187 186
       break;
188 187
     case U8G_DEV_MSG_STOP:
189 188
       break;
190
-    case U8G_DEV_MSG_PAGE_NEXT:
191
-      {
189
+    case U8G_DEV_MSG_PAGE_NEXT: {
192 190
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
193 191
 
194 192
         u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_HAL_data_start);

+ 2
- 4
Marlin/src/lcd/dogm/u8g_dev_st7920_128x64_HAL.cpp Vedi File

@@ -99,8 +99,7 @@ uint8_t u8g_dev_st7920_128x64_HAL_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, vo
99 99
       break;
100 100
     case U8G_DEV_MSG_STOP:
101 101
       break;
102
-    case U8G_DEV_MSG_PAGE_NEXT:
103
-      {
102
+    case U8G_DEV_MSG_PAGE_NEXT: {
104 103
         uint8_t y, i;
105 104
         uint8_t *ptr;
106 105
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
@@ -149,8 +148,7 @@ uint8_t u8g_dev_st7920_128x64_HAL_4x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg,
149 148
     case U8G_DEV_MSG_STOP:
150 149
       break;
151 150
 
152
-    case U8G_DEV_MSG_PAGE_NEXT:
153
-      {
151
+    case U8G_DEV_MSG_PAGE_NEXT: {
154 152
         uint8_t y, i;
155 153
         uint8_t *ptr;
156 154
         u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);

Loading…
Annulla
Salva