diff --git a/src/main.rs b/src/main.rs
index f101552..42e8be7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -120,7 +120,7 @@ async fn main() -> Result<()>{
     match &command {
         Commands::ListDevices => {
             println!("{}", tokio_serial::available_ports()
-                .unwrap()
+                .context("Failed to list available ports")?
                 .iter()
                 .map(|serialport| serialport.port_name.clone())
                 .fold(String::new(), |a, b| a + &b + &String::from("\n")));
@@ -130,18 +130,18 @@ async fn main() -> Result<()>{
                 DeviceCommands::State => {
                     let request_current_state_packet = RequestCurrentStateCommand {};
 
-                    let mut serial_interface = serial::SerialInterface::new(path, *baud_rate).expect("Couldn't init serial interface");
+                    let mut serial_interface = serial::SerialInterface::new(path, *baud_rate).context("Couldn't init serial interface")?;
 
-                    serial_interface.send(&request_current_state_packet).expect("Failed to send improv packet");
+                    serial_interface.send(&request_current_state_packet).context("Failed to send improv packet")?;
 
-                    let result_bytes = serial_interface.recv_bytes().expect("Couldn't receive any improv packet");
-                    let raw_packet = RawPacket::try_from_bytes(&result_bytes).unwrap();
+                    let result_bytes = serial_interface.recv_bytes().context("Couldn't receive any improv packet")?;
+                    let raw_packet = RawPacket::try_from_bytes(&result_bytes).context("Failed to deserialize packet")?;
 
-                    if let ImprovPacket::CurrentStateResponse(current_state_response) = ImprovPacket::try_from_raw_packet(&raw_packet).unwrap() {
+                    if let ImprovPacket::CurrentStateResponse(current_state_response) = ImprovPacket::try_from_raw_packet(&raw_packet).context("Failed to read packet")? {
                         println!("Current state: {}", &current_state_response.current_state);
                     }
 
-                    if let ImprovPacket::ErrorState(error_state) = ImprovPacket::try_from_raw_packet(&raw_packet).unwrap() {
+                    if let ImprovPacket::ErrorState(error_state) = ImprovPacket::try_from_raw_packet(&raw_packet).context("Failed to read packet")? {
                         println!("Error state: {}", &error_state.error_state);
                     }
                 },
@@ -151,14 +151,14 @@ async fn main() -> Result<()>{
                 DeviceCommands::Info => {
                     let request_device_information_packet = RequestDeviceInformationPacket {};
 
-                    let mut serial_interface = serial::SerialInterface::new(path, *baud_rate).expect("Couldn't init serial interface");
+                    let mut serial_interface = serial::SerialInterface::new(path, *baud_rate).context("Couldn't init serial interface")?;
 
-                    serial_interface.send(&request_device_information_packet).expect("Failed to send improv packet");
+                    serial_interface.send(&request_device_information_packet).context("Failed to send improv packet")?;
 
-                    let result_bytes = serial_interface.recv_bytes().expect("Couldn't receive any improv packet");
-                    let raw_packet = RawPacket::try_from_bytes(&result_bytes).unwrap();
+                    let result_bytes = serial_interface.recv_bytes().context("Couldn't receive any improv packet")?;
+                    let raw_packet = RawPacket::try_from_bytes(&result_bytes).context("Failed to deserialize packet")?;
 
-                    if let ImprovPacket::RPCResult(rpc_result) = ImprovPacket::try_from_raw_packet(&raw_packet).unwrap() {
+                    if let ImprovPacket::RPCResult(rpc_result) = ImprovPacket::try_from_raw_packet(&raw_packet).context("Failed to read packet")? {
                         for r in rpc_result.results {
                             println!("{}", &r);
                         }