aprshttp 0.1.0

One-way APRS position reporting using APRS-IS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::time::Duration;

use aprs_encode::{
    ddm::{CardinalDirection, DdmLatitude, DdmLongitude, DegreeMinutes},
    stack_str::PackArrayString,
};
use arrayvec::ArrayString;
use callpass::Callpass;
use clap::{crate_authors, crate_description, crate_name, crate_version, App, Arg};

#[tokio::main]
async fn main() {
    let matches = App::new(crate_name!())
        .author(crate_authors!())
        .about(crate_description!())
        .version(crate_version!())
        .arg(
            Arg::with_name("callsign")
                .takes_value(true)
                .help("Your callsign")
                .required(true),
        )
        .arg(
            Arg::with_name("latitude")
                .long("latitude")
                .takes_value(true)
                .help("Latitude")
                .required(true),
        )
        .arg(
            Arg::with_name("longitude")
                .long("longitude")
                .takes_value(true)
                .help("Longitude")
                .required(true),
        )
        .arg(
            Arg::with_name("message")
                .long("message")
                .short("m")
                .takes_value(true)
                .help("Message to broadcast")
                .required(false),
        )
        .arg(
            Arg::with_name("symbol")
                .long("symbol")
                .short("s")
                .takes_value(true)
                .help("APRS symbol")
                .default_value("-")
                .required(false),
        )
        .get_matches();

    // Get data
    let callsign = matches.value_of("callsign").unwrap().to_uppercase();
    let callpass: Callpass = callsign.clone().into();
    let symbol = matches.value_of("symbol").unwrap();
    let message = matches.value_of("message");
    let latitude: f32 = matches.value_of("latitude").unwrap().parse().unwrap();
    let longitude: f32 = matches.value_of("longitude").unwrap().parse().unwrap();

    // Calculate position in DDM
    let mut ddm_longitude = ArrayString::<128>::new();
    DdmLongitude {
        ddm: DegreeMinutes::from(longitude.abs()),
        direction: if longitude >= 0.0 {
            CardinalDirection::East
        } else {
            CardinalDirection::West
        },
    }
    .pack_into(&mut ddm_longitude)
    .unwrap();
    let mut ddm_latitude = ArrayString::<128>::new();
    DdmLatitude {
        ddm: DegreeMinutes::from(latitude.abs()),
        direction: if latitude >= 0.0 {
            CardinalDirection::North
        } else {
            CardinalDirection::South
        },
    }
    .pack_into(&mut ddm_latitude)
    .unwrap();

    // Encode the packet
    let encoded_data = format!(
        "{}>{}:!{}/{}{} {}",
        callsign,
        "APRS",
        ddm_latitude,
        ddm_longitude,
        symbol,
        message.unwrap_or("")
    );

    // Print the packet
    println!("-> {}", encoded_data);

    // Set up the HTTP client
    let client = reqwest::Client::new();
    let response = client
        .post("http://rotate.aprs.net:8080/")
        .header("Accept-Type", "text/plain")
        .header("Content-Type", "application/octet-stream")
        .body(format!(
            "user {} pass {} vers aprshttp {}\n{}",
            callsign,
            callpass,
            crate_version!(),
            encoded_data
        ))
        .timeout(Duration::from_secs(3))
        .send()
        .await;

    if let Ok(response) = response {
        println!("<- {}", response.status());
    } else {
        let err = response.unwrap_err();
        if err.is_timeout() {
            println!("<- TIMED OUT");
        } else {
            println!("<- ERR: {:?}", err);
        }
    }
}