While the program was running, I found a piece of code that could not be reached, suspected of a bug?

async fn client_get_data(ip_port: &String) -> Result<Option<Vec<i64>>, Box<dyn Error>> {
    let address: String = (*ip_port.clone()).to_string();
    match TcpStream::connect(address).await {
        Ok(stream) => {
            let mut transport = Framed::new(stream, TcpClientCodec);
            let frame = Frame::tcp();
            let request = frame.read_multiple_holding_registers_request(1, 0, 100);
            debug!("request:{}", request);
            let res = transport.send(request).await;
            debug!("res:{:?}", res);
            let mut result: Vec<i64> = Vec::new();
            while let Some(response) = transport.next().await {
                match response {
                    Ok(response) => {
                        debug!("Response:\t{}", response);
                        match response {
                            Response::ReadMultipleHoldingRegisters(_, res) => {
                                let a = res.get_values();
                                let mut b: bool = true;
                                debug!("0..a.len() - 1 :{}", a.len());
                                for i in 0..a.len() {
                                    debug!("i:{}", i);
                                    if b {
                                        let value = ((a[i] as u16 * 256) + a[i + 1] as u16) as i64;
                                        debug!("value {}", value);
                                        result.push(value);
                                        b = false;
                                    } else {
                                        b = true;
                                    }
                                }
                                debug!("r :{:?}", result);
                            }
                            _ =>{debug!("1");}
                        };
                        debug!("r1 :{:?}", result);
                    },
                    Err(e) => {
                        info!("err:{:?}", e);
                        // return Ok(Some(result));
                    }
                };
                debug!("r2 :{:?}", result);
            };
            debug!("r3 :{:?}", result);
            return Ok(Some(result));
        }
        Err(err) => {
            return Err(Box::new(err));
        }
    }
}

This code cannot be executed to debug! ("r3 :{:?}", result); But debug! ("r2 :{:?}", result); This section has been executed and output

I'm not sure what you're asking. If you say debug!("r3 :{:?}", result cannot be reached, please provide your reasoning.

1 Like

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.