.woodpecker.yml

@@ -1,8 +0,0 @@
-pipeline:
-  build:
-    image: rust
-    commands:
-        - rustup override set nightly
-        - rustup target add thumbv7m-none-eabi
-        - cargo install flip-link
-        - cargo build --release

Cargo.toml

@@ -6,12 +6,12 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-embassy-sync = { version = "0.2.0", git = "https://github.com/embassy-rs/embassy.git", features = ["defmt"] }
-embassy-futures = { version = "0.1.0", git = "https://github.com/embassy-rs/embassy.git", features = ["defmt"] }
-embassy-executor = { version = "0.2.0", git = "https://github.com/embassy-rs/embassy.git", features = ["arch-cortex-m", "executor-thread", "defmt", "integrated-timers"] }
-embassy-time = { version = "0.1.1", git = "https://github.com/embassy-rs/embassy.git", features = ["defmt", "defmt-timestamp-uptime"] }
-embassy-stm32 = { version = "0.1.0", git = "https://github.com/embassy-rs/embassy.git", features = ["nightly", "defmt", "stm32f103c8", "unstable-pac", "memory-x", "time-driver-any", "unstable-traits"]  }
+embassy-util = { version = "0.1.0", git = "https://github.com/embassy-rs/embassy.git", features = ["defmt"] }
+embassy-executor = { version = "0.1.0", git = "https://github.com/embassy-rs/embassy.git", features = ["defmt", "integrated-timers"] }
+embassy-time = { version = "0.1.0", git = "https://github.com/embassy-rs/embassy.git", features = ["defmt", "defmt-timestamp-uptime", "tick-32768hz"] }
+embassy-stm32 = { version = "0.1.0", git = "https://github.com/embassy-rs/embassy.git", features = ["nightly", "defmt", "stm32f103c8", "unstable-pac", "memory-x", "time-driver-any"]  }
 embassy-usb = { version = "0.1.0", git = "https://github.com/embassy-rs/embassy.git", features = ["defmt"] }
+embassy-usb-serial = { version = "0.1.0", git = "https://github.com/embassy-rs/embassy.git", features = ["defmt"] }
 
 defmt = "0.3.2"
 defmt-rtt = "0.3.2"
@@ -19,8 +19,10 @@ panic-probe = { version = "0.3.0"}
 
 cortex-m = { version = "0.7.6", features = ["critical-section-single-core"] }
 cortex-m-rt = "0.7.0"
-
+embedded-hal = "0.2.6"
+futures = { version = "0.3.17", default-features = false, features = ["async-await"] }
 heapless = { version = "0.7.5", default-features = false, features = ['ufmt-impl']}
+nb = "1.0.0"
 ufmt = "0.2.0"
 
 ssd1306 = "0.7.1"

src/display.rs

@@ -1,14 +1,10 @@
 use embassy_stm32::i2c;
 use embassy_stm32::peripherals;
-use embassy_stm32::bind_interrupts;
-use embassy_stm32::dma::NoDma;
 use embassy_stm32::time::Hertz;
 use embassy_time::{Duration, Timer};
-use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
-use embassy_sync::channel::Receiver;
-use embassy_futures::select::{select, Either};
-
-
+use embassy_util::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_util::channel::mpmc::Receiver;
+use embassy_util::{select, Either};
 
 use embedded_graphics::{
     mono_font::{
@@ -28,10 +24,6 @@ use ssd1306::{prelude::*, I2CDisplayInterface, Ssd1306};
 
 use crate::{AzElPair, RotorState};
 
-bind_interrupts!(struct Irqs {
-    I2C1_EV => i2c::InterruptHandler<peripherals::I2C1>;
-});
-
 #[embassy_executor::task]
 pub async fn display_task(
     i2c1: peripherals::I2C1,
@@ -39,7 +31,7 @@ pub async fn display_task(
     scl: peripherals::PB7,
     cmd_receiver: Receiver<'static, ThreadModeRawMutex, RotorState, 1>,
 ) {
-    let i2c = i2c::I2c::new(i2c1, sda, scl, Irqs, NoDma, NoDma, Hertz(100_000), Default::default());
+    let i2c = i2c::I2c::new(i2c1, sda, scl, Hertz::hz(100_000), i2c::Config::default());
 
     let interface = I2CDisplayInterface::new(i2c);
 
@@ -58,11 +50,9 @@ pub async fn display_task(
     let mut rotor_state = RotorState {
         actual_pos: AzElPair { az: 0, el: 0 },
         setpoint_pos: AzElPair { az: 0, el: 0 },
-        stopped: true,
+        stopped: false,
     };
 
-    let mut activity_indicator = 0;
-
     loop {
         display.clear();
 
@@ -82,38 +72,23 @@ pub async fn display_task(
             .draw(&mut display)
             .unwrap();
 
-        if !rotor_state.stopped {
-            Rectangle::new(Point::new(0, 19), Size::new(128, 23))
-                .into_styled(style_filled)
-                .draw(&mut display)
-                .unwrap();
-        };
-
-        let setpoint_style = if !rotor_state.stopped {
-            text_large_inv
-        } else {
-            text_large
-        };
+        Rectangle::new(Point::new(0, 19), Size::new(128, 23))
+            .into_styled(style_filled)
+            .draw(&mut display)
+            .unwrap();
 
         tmp.clear();
         uwrite!(tmp, "AZ: {}", rotor_state.setpoint_pos.az).unwrap();
-        Text::new(&tmp, Point::new(1, 30), setpoint_style)
+        Text::new(&tmp, Point::new(1, 30), text_large_inv)
             .draw(&mut display)
             .unwrap();
 
         tmp.clear();
         uwrite!(tmp, "EL: {}", rotor_state.setpoint_pos.el).unwrap();
-        Text::new(&tmp, Point::new(64, 30), setpoint_style)
+        Text::new(&tmp, Point::new(64, 30), text_large_inv)
             .draw(&mut display)
             .unwrap();
 
-        if rotor_state.stopped || activity_indicator < 19 {
-            display.set_pixel(127, activity_indicator, true);
-        } else {
-            display.set_pixel(127, activity_indicator, false);
-        }
-        activity_indicator = (activity_indicator + 1) % 32;
-
         display.flush().unwrap();
 
         let result = select(

src/main.rs

@@ -2,7 +2,9 @@
 #![no_main]
 #![feature(type_alias_impl_trait)]
 
-use defmt::Format;
+use core::fmt::Write;
+
+use defmt::{panic, Format};
 use defmt_rtt as _;
 use panic_probe as _;
 
@@ -11,8 +13,9 @@ use embassy_stm32::gpio::{Level, Output, Speed};
 use embassy_stm32::time::Hertz;
 use embassy_stm32::Config;
 use embassy_time::{Duration, Timer};
-use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
-use embassy_sync::channel::Channel;
+use embassy_util::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_util::channel::mpmc::Channel;
+use embassy_util::Forever;
 
 mod display;
 use display::display_task;
@@ -71,13 +74,10 @@ async fn main(spawner: Spawner) {
 
     spawner
         .spawn(movement_task(
-            p.ADC1,
-            p.PA0,
-            p.PA1,
-            p.PA2,
             p.PA3,
             p.PA4,
             p.PA5,
+            p.PA6,
             CMD_CHAN.receiver(),
             POS_CHAN.sender(),
             STATE_CHAN.sender(),

src/movement.rs

@@ -1,189 +1,91 @@
-use embassy_stm32::adc::Adc;
 use embassy_stm32::gpio::{Level, Output, Speed};
 use embassy_stm32::peripherals;
-use embassy_time::{with_timeout, Delay, Duration, Timer};
-use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
-use embassy_sync::channel::{Receiver, Sender};
-use embassy_futures::select::{select, Either};
-use embassy_futures::join::join;
-use heapless::Vec;
+use embassy_time::{Duration, Instant, Timer};
+use embassy_util::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_util::channel::mpmc::{Receiver, Sender};
+use embassy_util::{select, Either};
+
+use futures::future::join;
 
 use crate::usb::Gs232Cmd;
 use crate::{AzElPair, RotorState};
 
-// ADC reading for azimuth 0°
-const AZ_MIN_READING: f32 = 0.0;
-// ADC reading for azimuth 360°
-const AZ_MAX_READING: f32 = 4096.0;
-// Range of motion for azimuth (0 to AZ_RANGE)
-const AZ_RANGE: f32 = 360.0;
-// Tolerance for the azimuth setpoint
-const AZ_SLOP : i16 = 1;
-
-// ADC reading for elevation 0°
-const EL_MIN_READING: f32 = 0.0;
-// ADC reading for elevation 360°
-const EL_MAX_READING: f32 = 4096.0;
-// Range of motion for elevantion (0 to EL_RANGE)
-const EL_RANGE: f32 = 180.0;
-// Tolerance for the elevation setpoint
-const EL_SLOP : i16 = 1;
-
 #[embassy_executor::task]
 pub async fn movement_task(
-    adc1: peripherals::ADC1,
-    mut az_pin: peripherals::PA0,
-    mut el_pin: peripherals::PA1,
-    cw_pin: peripherals::PA2,
-    ccw_pin: peripherals::PA3,
-    up_pin: peripherals::PA4,
-    down_pin: peripherals::PA5,
+    cw_pin: peripherals::PA3,
+    ccw_pin: peripherals::PA4,
+    up_pin: peripherals::PA5,
+    down_pin: peripherals::PA6,
     cmd_receiver: Receiver<'static, ThreadModeRawMutex, Gs232Cmd, 1>,
     pos_sender: Sender<'static, ThreadModeRawMutex, AzElPair, 1>,
     state_sender: Sender<'static, ThreadModeRawMutex, RotorState, 1>,
 ) {
-    // Initialize the rotor state
     let mut rotor_state = RotorState {
         actual_pos: AzElPair { az: 0, el: 0 },
         setpoint_pos: AzElPair { az: 0, el: 0 },
-        stopped: true,
+        stopped: false,
     };
 
-    // Setup output pins for moving the rotor
     let mut cw_pin = Output::new(cw_pin, Level::Low, Speed::Low);
     let mut ccw_pin = Output::new(ccw_pin, Level::Low, Speed::Low);
     let mut up_pin = Output::new(up_pin, Level::Low, Speed::Low);
     let mut down_pin = Output::new(down_pin, Level::Low, Speed::Low);
 
-    // Setup the ADC for reading the rotor positions
-    let mut adc = Adc::new(adc1, &mut Delay);
-
-    // Do an initial ADC reading to initialize the averages
-    let az_reading = adc.read(&mut az_pin) as f32;
-    let el_reading = adc.read(&mut el_pin) as f32;
-    let mut az_average = Average::new(az_reading);
-    let mut el_average = Average::new(el_reading);
-
     loop {
-        // Wait until either a new command has been received or 100ms have elapsed
         match select(
             cmd_receiver.recv(),
             Timer::after(Duration::from_millis(100)),
         )
         .await
         {
-            // A new command has been received. This task only cares about MoveTo and Stop.
             Either::First(cmd) => match cmd {
-                // Move to command. Update the setpoint pair in the rotor state
                 Gs232Cmd::MoveTo(pair) => {
                     rotor_state.setpoint_pos = pair;
                     rotor_state.stopped = false;
                 }
-                // Stop command. Set the stopped flag.
                 Gs232Cmd::Stop => {
                     rotor_state.stopped = true;
                 }
-                // Everthing elese is an noop.
                 _ => {}
             },
-
-            // Second case of the select statement. Timer has elapsed.
             Either::Second(_) => {
-                // First read the current rotor position
-                let az_reading = adc.read(&mut az_pin) as f32;
-                let el_reading = adc.read(&mut el_pin) as f32;
-
-                // Apply the averaging filters
-                az_average.add(az_reading);
-                el_average.add(el_reading);
-
-                // Calculate the position in degreee
-                let az_actual = (az_average.average() - AZ_MIN_READING)
-                    / (AZ_MAX_READING - AZ_MIN_READING)
-                    * AZ_RANGE;
-                let el_actual = (el_average.average() - EL_MIN_READING)
-                    / (EL_MAX_READING - EL_MIN_READING)
-                    * EL_RANGE;
-
-                // Update the rotor state
-                rotor_state.actual_pos.az = az_actual as u16;
-                rotor_state.actual_pos.el = el_actual as u16;
-
-                let delta_az =
-                    rotor_state.setpoint_pos.az as i16 - rotor_state.actual_pos.az as i16;
-                let delta_el =
-                    rotor_state.setpoint_pos.el as i16 - rotor_state.actual_pos.el as i16;
-
-                if !rotor_state.stopped && delta_az > AZ_SLOP {
-                    // Azimuth needs to move clockwise
+                if !rotor_state.stopped && rotor_state.actual_pos.az < rotor_state.setpoint_pos.az {
+                    rotor_state.actual_pos.az += 1;
                     cw_pin.set_high();
                     ccw_pin.set_low();
-                } else if !rotor_state.stopped && delta_az < -AZ_SLOP {
-                    // Azimuth needs to move counter clockwise
+                } else if !rotor_state.stopped
+                    && rotor_state.actual_pos.az > rotor_state.setpoint_pos.az
+                {
+                    rotor_state.actual_pos.az -= 1;
                     cw_pin.set_low();
                     ccw_pin.set_high();
                 } else {
-                    // Either azimuth is on the setpoint or the rotor has beend stopped.
                     cw_pin.set_low();
                     ccw_pin.set_low();
                 }
 
-                if !rotor_state.stopped && delta_el > EL_SLOP {
-                    // Elevation needs to move up
+                if !rotor_state.stopped && rotor_state.actual_pos.el < rotor_state.setpoint_pos.el {
+                    rotor_state.actual_pos.el += 1;
                     up_pin.set_high();
                     down_pin.set_low();
-                } else if !rotor_state.stopped && delta_el < -EL_SLOP {
-                    // Elevation needs to move down
+                } else if !rotor_state.stopped
+                    && rotor_state.actual_pos.el > rotor_state.setpoint_pos.el
+                {
+                    rotor_state.actual_pos.el -= 1;
                     up_pin.set_low();
                     down_pin.set_high();
                 } else {
-                    // Either elevation is on the setpoint or the rotor has beend stopped.
                     up_pin.set_low();
                     down_pin.set_low();
                 }
 
-                // Send the state to the display task and the position usb.
-                // Use timeouts to prevent blocking if display or usb task are unresponsive.
-                let _ = join(
-                    with_timeout(
-                        Duration::from_millis(100),
-                        pos_sender.send(rotor_state.actual_pos),
-                    ),
-                    with_timeout(Duration::from_millis(100), state_sender.send(rotor_state)),
+                join(
+                    pos_sender.send(rotor_state.actual_pos),
+                    state_sender.send(rotor_state),
                 )
                 .await;
+                //state_sender.send(rotor_state).await;
             }
         };
     }
 }
-
-// Simple sliding average filter
-struct Average {
-    pos: usize,
-    data: Vec<f32, 5>,
-}
-
-impl Average {
-    // Create a new filter and prefill the state using an initial value
-    fn new(initial: f32) -> Average {
-        let mut data: Vec<f32, 5> = Vec::new();
-        data.resize(5, initial).unwrap();
-        Average { pos: 0, data }
-    }
-
-    // Adds a new value to internal state
-    fn add(&mut self, sample: f32) {
-        self.data[self.pos] = sample;
-        self.pos = (self.pos + 1) % self.data.len();
-    }
-
-    // Calculate the average value from the internal state
-    fn average(&self) -> f32 {
-        let mut sum = 0.0;
-        for sample in &self.data {
-            sum += sample;
-        }
-
-        sum / self.data.len() as f32
-    }
-}

src/usb.rs

@@ -1,25 +1,21 @@
 use defmt::Format;
 
+use embassy_stm32::interrupt;
 use embassy_stm32::peripherals;
-use embassy_stm32::{bind_interrupts, usb};
 use embassy_stm32::usb::Driver;
 use embassy_usb::Builder;
-use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
-use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
-use embassy_sync::channel::{Receiver, Sender};
-use embassy_futures::select::{select, Either};
-use embassy_futures::join::join;
+use embassy_usb_serial::{CdcAcmClass, State};
+use embassy_util::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_util::channel::mpmc::{Receiver, Sender};
+use embassy_util::{select, Either};
+
+use futures::future::join;
 
 use heapless::String;
 use ufmt::uwrite;
 
 use crate::AzElPair;
 
-bind_interrupts!(struct Irqs {
-    USB_LP_CAN1_RX0 => usb::InterruptHandler<peripherals::USB>;
-});
-
-
 #[embassy_executor::task]
 pub async fn usb_task(
     usb: peripherals::USB,
@@ -28,10 +24,12 @@ pub async fn usb_task(
     cmd_sender: Sender<'static, ThreadModeRawMutex, Gs232Cmd, 1>,
     pos_receiver: Receiver<'static, ThreadModeRawMutex, AzElPair, 1>,
 ) {
-    let driver = Driver::new(usb, Irqs, dp_pin, dm_pin);
+    let irq = interrupt::take!(USB_LP_CAN1_RX0);
+    let driver = Driver::new(usb, irq, dp_pin, dm_pin);
 
     // Create embassy-usb Config
     let config = embassy_usb::Config::new(0xc0de, 0xcafe);
+    //config.max_packet_size_0 = 64;
 
     // Create embassy-usb DeviceBuilder using the driver and config.
     // It needs some buffers for building the descriptors.
@@ -40,7 +38,7 @@ pub async fn usb_task(
     let mut bos_descriptor = [0; 256];
     let mut control_buf = [0; 7];
 
-    let mut usb_state = State::new();
+    let mut state = State::new();
 
     let mut builder = Builder::new(
         driver,
@@ -48,51 +46,41 @@ pub async fn usb_task(
         &mut device_descriptor,
         &mut config_descriptor,
         &mut bos_descriptor,
-        &mut control_buf
+        &mut control_buf,
+        None,
     );
 
     // Create classes on the builder.
-    let mut class = CdcAcmClass::new(&mut builder, &mut usb_state, 64);
+    let mut class = CdcAcmClass::new(&mut builder, &mut state, 64);
 
     // Build the builder.
     let mut usb = builder.build();
 
-    // Create a future to handle incomming usb packets
+    // Do stuff with the class!
     let usb_handler_fut = async {
-        // Initialize the current position in case we get a B or C command,
-        // before we get the first the update via pos_receiver
         let mut current_pos = AzElPair { az: 0, el: 0 };
 
         loop {
-            // No much used doing anything until we have a usb connection
             class.wait_connection().await;
             defmt::info!("USB connected");
-            // Allocate a space for incomming usb data packets
             let mut packet = [0; 64];
-            // Allocate a string to act as buffer to pares the packets linewise
             let mut buffer: String<64> = String::new();
 
             loop {
                 let n = match select(class.read_packet(&mut packet), pos_receiver.recv()).await {
-                    // The read_packet furture returned either usb data or an error.
                     Either::First(res) => match res {
-                        // In case of an error break the loop and treat it like an usb disconnect
                         Ok(n) => n,
-                        // In case of an error break the loop and treat it like an usb disconnect
                         Err(err) => {
                             defmt::error!("Unable to read packet: {}", err);
                             break;
                         }
                     },
-                    // The pos_receiver future returned a position update from moment task.
-                    // Just update position and restart loop.
                     Either::Second(pair) => {
                         current_pos = pair;
                         continue;
                     }
                 };
 
-                // Append the data in the packet buffer to the buffer string
                 for byte in &packet[..n] {
                     if buffer.len() == 64 {
                         buffer.clear();
@@ -100,115 +88,91 @@ pub async fn usb_task(
                     buffer.push(*byte as char).unwrap();
                 }
 
-                // Check if the buffer string contains a '\r'
                 let line_end = match buffer.rfind('\r') {
-                    // Carriage return found, keep the index
                     Some(n) => n,
-                    // No carriage return, wait for the next package
                     _ => continue,
                 };
 
-                // The is a non-zero amount of characters before the carriage return
+                defmt::info!("Line buffer: {:x}", buffer.as_bytes());
+
                 if line_end > 0 {
-                    // Try the parse the slice leading up to linend as a GS323 command
                     let cmd = parse_command(&buffer.as_str()[..line_end]);
                     defmt::info!("Command: {}", cmd);
 
-                    // Reverse some space for a respose to the command
                     let mut resp: String<16> = String::new();
                     match cmd {
-                        // Get Azimuth command. Respond with last known azimuth
-                        Gs232Cmd::GetAz => {
+                        Gs232Cmd::GetAl => {
                             uwrite!(&mut resp, "AZ={}\r", current_pos.az).unwrap();
                         }
-                        // Get Elevation comman. Respond with last known elevation
-                        Gs232Cmd::GetEl => {
+                        Gs232Cmd::GetEz => {
                             uwrite!(&mut resp, "EL={}\r", current_pos.el).unwrap();
                         }
-                        // Get Azimuth and Elevation. Respond with last known pair
-                        Gs232Cmd::GetAzEl => {
+                        Gs232Cmd::GetAlEz => {
                             uwrite!(&mut resp, "AZ={} EL={}\r", current_pos.az, current_pos.el)
                                 .unwrap();
                         }
-                        // Move to command. Send to movement task. Respond with empty line.
                         Gs232Cmd::MoveTo(_) => {
                             cmd_sender.send(cmd).await;
                             resp.push_str("\r").unwrap();
                         }
-                        // Stop command. Send to movement task. Respond with empty line.
                         Gs232Cmd::Stop => {
                             cmd_sender.send(cmd).await;
                             resp.push_str("\r").unwrap();
                         }
-                        // Unknown command or parser error. Complain and do nothing.
                         _ => {
                             defmt::error!("Uknown command: {}", &buffer.as_str()[..line_end]);
                             resp.push_str("Unkown command!\r").unwrap();
                         }
                     }
 
-                    // Write the response back via USB
                     match class.write_packet(resp.as_bytes()).await {
                         Ok(_) => {}
-                        // Error treat like broken usb connection
                         Err(err) => {
                             defmt::error!("Unable to write packet: {}", err);
                             break;
                         }
                     };
                 }
-                // Drop the processed line from the buffer
                 buffer = String::from(&buffer.as_str()[line_end + 1..]);
             }
             defmt::info!("USB disconnected");
-            // USB connection is broken, so better stop the rotor.
-            cmd_sender.send(Gs232Cmd::Stop).await;
         }
     };
 
-    // Run the ubs and handler future both to completion.
-    // None of the ever completes, but they will still be polled continously.
     join(usb.run(), usb_handler_fut).await;
 }
 
-// Enum for the GS232 commands
 #[derive(Format, PartialEq)]
 pub enum Gs232Cmd {
     Unkown,
-    GetAz,
-    GetEl,
-    GetAzEl,
+    GetAl,
+    GetEz,
+    GetAlEz,
     MoveTo(AzElPair),
     Stop,
 }
 
-// Parse a GS232 commmand from a string slice
 fn parse_command(data: &str) -> Gs232Cmd {
     match data.chars().nth(0).unwrap() {
         'B' => {
-            // Get Az command. Format 'B\r'
             if data.len() == 1 {
-                Gs232Cmd::GetAz
+                Gs232Cmd::GetAl
             } else {
                 Gs232Cmd::Unkown
             }
         }
 
         'C' => {
-            // Get AZ and EL. Format 'C2\r'
             if data.len() == 2 && data.chars().nth(1).unwrap() as char == '2' {
-                Gs232Cmd::GetAzEl
-            // Get EL only 'C\r'
+                Gs232Cmd::GetAlEz
             } else if data.len() == 1 {
-                Gs232Cmd::GetEl
+                Gs232Cmd::GetEz
             } else {
                 Gs232Cmd::Unkown
             }
         }
 
         'W' => {
-            // Set position 'Waaa eee\r' with azimuth aaa and elevation eee.
-            // Fortunately rotcld will prepend zeros, so there will always be 3 digits per number.
             if data.len() == 8 {
                 if let Ok(az) = data[1..4].parse::<u16>() {
                     if let Ok(el) = data[5..].parse::<u16>() {
@@ -225,7 +189,6 @@ fn parse_command(data: &str) -> Gs232Cmd {
         }
 
         'S' => {
-            // Stop command. Format 'S\r'
             if data.len() == 1 {
                 Gs232Cmd::Stop
             } else {