Rust web server transferring data to the program - beginner

1

Hi,
I'm learning programming in Rust and I have the following problem: I started a web server in which I enter data using HTML forms. I would like these values ​​to be passed on to the program, and then the program would perform the rest of the task. Below is the program code.

use actix_web::{web, App, HttpResponse, HttpServer};
use tokio_serial::SerialStream;
use tokio_modbus::prelude::*;
use std::io;
use std::{thread, time};
use std::fs::File;
use std::io::Write;
use std::io::BufWriter;

//#[tokio::main]
fn main() {

serwer();
tester();

}

//SERWER
//#############################################################################################
#[actix_web::main]
async fn serwer() {
let server = HttpServer::new(|| {
App::new()
.route("/", web::get().to(get_index))
.route("/gcd", web::post().to(post_gcd))
});

println!("Serving on http://localhost:7878...");

server
    .bind("127.0.0.1:7878").expect("zły adres serwera")
    .run()
    .await
    .expect("serwer nie uruchomiony...");

}

//#############################################################################################
async fn get_index() -> HttpResponse {
HttpResponse::Ok()
.content_type("text/html")
.body(
r#"
Tester



Zapisz

"#,
)
}

//#############################################################################################
use serde::Deserialize;
#[derive(Deserialize)]
struct Struktura {
sl: u8,
nnn: u8,
}

fn gcd(mut sl: u8, mut nnn: u8) -> () {
let mut f = BufWriter::new(File::create("liczby.txt").expect("Unable to create file"));
let _var_name = write!(f, "{0}\n", sl);
let _var_name = write!(f, "{0}\n", nnn);
}

//#############################################################################################
async fn post_gcd(form: web::Form) -> HttpResponse {
if form.sl == 0 || form.nnn == 0 {
return HttpResponse::BadRequest()
.content_type("text/html")
.body("Podane liczby musza byc wieksze od zera :).");
}

let response =
    format!("Test zamkow zostanie przeprowadzony dla ID: {}. Dla kazdego zamka zostanie wyslana nastepujaca ilosc komend otwarcia zamka: \
             {}.\n 
             Wynik przeprowadzonych testow zostanie zapisany do pliku: time.txt \n",
            form.sl, form.nnn);
            let z = 1;
HttpResponse::Ok()
    .content_type("text/html")
    .body(response)

}

//#############################################################################################
#[tokio::main]
async fn tester() -> Result<(), Box> {
let sl :u8 = 3;
let nnn :u8 = 1;
let tty_path = "/dev/ttyUSB0";
let slave = Slave(sl);
let builder = tokio_serial::new(tty_path, 115200);
let open = SerialStream::open(&builder).unwrap();
let port = open;
let mut ctx = rtu::attach_slave(port, slave);
let _rsp = ctx.read_holding_registers(999, 1).await?;

let mut f = BufWriter::new(File::create("time.txt").expect("Unable to create file"));

//pętla test otwarcia zamków
let var_name = for _n in 1..nnn+1{

let _rsp = ctx.write_single_register(1004, 1).await?; // otwarcie zamka nr 1
let z1mt: u128 = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis();
println!("Czas wysłania komendy otwarcia zamek1: {z1mt}");
let i1 = z1mt;
//zapis do pliku
write!(f, "czas zamek1: ");
let _var_name = write!(f, "{0}\n", i1);
// delay 1000ms
let millis = time::Duration::from_millis(1000);
let now = time::Instant::now();
thread::sleep(millis);
assert!(now.elapsed() >= millis);

let _rsp = ctx.write_single_register(1004, 2).await?; // otwarcie zamka nr 2
let z2mt: u128 = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis();
println!("Czas wysłania komendy otwarcia zamek2: {z2mt}");
let i2 = z2mt;
//zapis do pliku
write!(f, "czas zamek2: ");
let var_name = write!(f, "{0}\n",i2);
// delay 1000ms
let millis = time::Duration::from_millis(1000);
let now = time::Instant::now();
thread::sleep(millis);
assert!(now.elapsed() >= millis);

let _rsp = ctx.write_single_register(1004, 4).await?; // otwarcie zamka nr 3
let z3mt: u128 = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis();
println!("Czas wysłania komendy otwarcia zamek3: {z3mt}");
let i3 = z3mt;
//zapis do pliku
write!(f, "czas zamek3: ");
let var_name = write!(f, "{0}\n",i3);
// delay 1000ms
let millis = time::Duration::from_millis(1000);
let now = time::Instant::now();
thread::sleep(millis);
assert!(now.elapsed() >= millis);

let _rsp = ctx.write_single_register(1004, 8).await?; // otwarcie zamka nr 4
let z4mt: u128 = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis();
println!("Czas wysłania komendy otwarcia zamek4: {z4mt}");
let i4 = z4mt;
//zapis do pliku
write!(f, "czas zamek4: ");
let _var_name = write!(f, "{0}\n", i4);
// delay 1000ms
let millis = time::Duration::from_millis(1000);
let now = time::Instant::now();
thread::sleep(millis);
assert!(now.elapsed() >= millis);

let _rsp = ctx.write_single_register(1004, 16).await?; // otwarcie zamka nr 5
let z5mt: u128 = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis();
println!("Czas wysłania komendy otwarcia zamek5: {z5mt}");
let i5 = z5mt;
//zapis do pliku
write!(f, "czas zamek5: ");
let var_name = write!(f, "{0}\n",i5);
// delay 1000ms
let millis = time::Duration::from_millis(1000);
let now = time::Instant::now();
thread::sleep(millis);
assert!(now.elapsed() >= millis);

let _rsp = ctx.write_single_register(1004, 32).await?; // otwarcie zamka nr 6
let z6mt: u128 = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis();
println!("Czas wysłania komendy otwarcia zamek6: {z6mt}");
let i6 = z6mt;
//zapis do pliku
write!(f, "czas zamek6: ");
let _var_name = write!(f, "{0}\n", i6);
// delay 1000ms
let millis = time::Duration::from_millis(1000);
let now = time::Instant::now();
thread::sleep(millis);
assert!(now.elapsed() >= millis);

let _rsp = ctx.write_single_register(1004, 64).await?; // otwarcie zamka nr 7
let z7mt: u128 = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis();
println!("Czas wysłania komendy otwarcia zamek7: {z7mt}");
let i7 = z7mt;
//zapis do pliku
write!(f, "czas zamek7: ");
let var_name = write!(f, "{0}\n",i7);
// delay 1000ms
let millis = time::Duration::from_millis(1000);
let now = time::Instant::now();
thread::sleep(millis);
assert!(now.elapsed() >= millis);

let _rsp = ctx.write_single_register(1004, 128).await?; // otwarcie zamka nr 8
let z8mt: u128 = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis();
println!("Czas wysłania komendy otwarcia zamek8: {z8mt}");
let i8 = z8mt;
//zapis do pliku
write!(f, "czas zamek8: ");
write!(f, "{0}\n", i8);
// delay 1000ms
let millis = time::Duration::from_millis(1000);
let now = time::Instant::now();
thread::sleep(millis);
assert!(now.elapsed() >= millis);

let _rsp = ctx.write_single_register(1004, 256).await?; // otwarcie zamka nr 9
let z9mt: u128 = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis();
println!("Czas wysłania komendy otwarcia zamek9: {z9mt}");
let i9 = z9mt;
//zapis do pliku
write!(f, "czas zamek9: ");
let var_name = write!(f, "{0}\n",i9);
// delay 1000ms
let millis = time::Duration::from_millis(1000);
let now = time::Instant::now();
thread::sleep(millis);
assert!(now.elapsed() >= millis);

let _rsp = ctx.write_single_register(1004, 512).await?; // otwarcie zamka nr 10
let z10mt: u128 = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis();
println!("Czas wysłania komendy otwarcia zamek10: {z10mt}");
let i10 = z10mt;
//zapis do pliku
write!(f, "czas zamek10: ");
let var_name = write!(f, "{0}\n",i10);
// delay 1000ms
let millis = time::Duration::from_millis(1000);
let now = time::Instant::now();
thread::sleep(millis);
assert!(now.elapsed() >= millis);

let _rsp = ctx.write_single_register(1004, 1024).await?; // otwarcie zamka nr 11
let z11mt: u128 = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis();
println!("Czas wysłania komendy otwarcia zamek11: {z11mt}");
let i11 = z11mt;
//zapis do pliku
write!(f, "czas zamek11: ");
let var_name = write!(f, "{0}\n",i11);
// delay 1000ms
let millis = time::Duration::from_millis(1000);
let now = time::Instant::now();
thread::sleep(millis);
assert!(now.elapsed() >= millis);

let _rsp = ctx.write_single_register(1004, 2048).await?; // otwarcie zamka nr 12
let z12mt: u128 = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis();
println!("Czas wysłania komendy otwarcia zamek12: {z12mt}");
let i12 = z12mt;
//zapis do pliku
write!(f, "czas zamek12: ");
let var_name = write!(f, "{0}\n",i12);
// delay 1000ms
let millis = time::Duration::from_millis(1000);
let now = time::Instant::now();
thread::sleep(millis);
assert!(now.elapsed() >= millis);

};
let var_name = var_name;
let _var_name = var_name;

let var_name = Ok(());
var_name

}

2

Hi, and welcome to the forum. Whenever you add a code snippet to a post, you should format it appropriately: Forum Code Formatting and Syntax Highlighting; that being said, this only applies when the amount of code can be reasonably parsed by a human. In other words, if the amount of code is too large, then it's better to either provide a link to a Playground (https://play.rust-lang.org/?version=stable&mode=debug&edition=2021) or to a public repository.

3 Likes
3

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.