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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
#[derive(Copy, Clone)]
pub enum TransferState {
FirstContact,
WaitAck,
SendHeader,
SendExeSize,
CleaningRAM,
SendExeData,
Finished
}
use serial;
pub fn first_contact(port : &mut serial::SystemPort) -> TransferState {
const INITIAL_TRANSMISSION: u8 = 99u8;
use std::io::Write;
match (*port).write(&vec![INITIAL_TRANSMISSION]) {
Err(_) => TransferState::FirstContact,
Ok(b) => {
if b == 1 {
TransferState::WaitAck
}
else
{
TransferState::FirstContact
}
}
}
}
fn wait_ack(port : &mut serial::SystemPort, buffer : &mut [u8]) -> Result<usize, std::io::Error> {
// For some reason, this trait has to be imported,
// but shouldn't serial::SerialPort be already doing this?
use std::io::Read;
use serial::SerialPort;
const TIMEOUT_SECONDS : u64 = 2;
(*port).set_timeout(std::time::Duration::from_secs(TIMEOUT_SECONDS)).expect("Could not adjust timeout");
(*port).read(buffer)
}
pub fn wait_ack_default(port : &mut serial::SystemPort, prev_state: TransferState) -> TransferState {
let mut buffer : [u8; 1] = [0];
match wait_ack(port, &mut buffer) {
Ok(1) => {
if *(buffer.get(0).unwrap()) == 'b' as u8 {
match prev_state {
TransferState::FirstContact => TransferState::SendHeader,
TransferState::SendHeader => TransferState::SendExeSize,
TransferState::SendExeSize => TransferState::CleaningRAM,
TransferState::CleaningRAM => TransferState::SendExeData,
TransferState::SendExeData => TransferState::SendExeData,
_ => TransferState::Finished
}
}
else
{
prev_state
}
},
_ => {
match prev_state {
TransferState::SendExeSize => TransferState::CleaningRAM,
_ => prev_state
}
}
}
}
const PACKET_SIZE : usize = 8 as usize;
pub fn send_header(port : &mut serial::SystemPort, exe_data: &Vec<u8>) -> TransferState {
const HEADER_SIZE : usize = 32 as usize;
for packet in (0..HEADER_SIZE).step_by(PACKET_SIZE) {
match exe_data.get(packet..(packet + PACKET_SIZE)) {
None => return TransferState::Finished,
Some(chunk) => {
use std::{thread, time};
thread::sleep(time::Duration::from_millis(100));
use std::io::Write;
(*port).write(&chunk).expect("Could not write EXE header into the device");
}
}
}
TransferState::WaitAck
}
const EXE_DATA_OFFSET : usize = 2048 as usize;
pub fn send_exe_size(port: &mut serial::SystemPort, exe_data: &Vec<u8>) -> TransferState {
if exe_data.len() > EXE_DATA_OFFSET {
let exe_size = exe_data.len() - EXE_DATA_OFFSET;
use std::io::Write;
let exe_size_vec : [u8; 4] = [(exe_size & 0xFF) as u8,
((exe_size & 0xFF00) >> 8) as u8,
((exe_size & 0xFF0000) >> 16) as u8,
((exe_size & 0xFF000000) >> 24) as u8];
(*port).write(&exe_size_vec).expect("Could not write EXE size into the device");
TransferState::WaitAck
}
else
{
println!("PSX-EXE is too small");
TransferState::Finished
}
}
pub fn send_exe_data(port: &mut serial::SystemPort, sent_bytes: &mut usize, exe_data: &Vec<u8>) -> TransferState {
let exe_size = exe_data.len();
let total_sent_bytes = *sent_bytes + EXE_DATA_OFFSET;
if total_sent_bytes < exe_size {
match exe_data.get(total_sent_bytes..(total_sent_bytes + PACKET_SIZE)) {
None => return TransferState::Finished,
Some(chunk) => {
use std::io::Write;
(*port).write(&chunk).expect("Could not write EXE header into the device");
*sent_bytes += PACKET_SIZE;
}
}
TransferState::WaitAck
}
else
{
TransferState::Finished
}
}
pub fn get_exe_data(folder: &String) -> Option<Vec<u8>> {
match get_exe_name(folder) {
None => None,
Some(exe_name) => {
let exe_path = format!("{}/{}", folder, exe_name);
use std::fs;
match fs::read(&exe_path) {
Err(e) => {
println!("{}. File path: {}", e, exe_path);
None
},
Ok(data) => {
Some(data)
}
}
}
}
}
fn get_exe_name(folder : &String) -> Option<String> {
use std::fs;
use regex::Regex;
let path = format!("{}/{}", folder, "SYSTEM.CNF");
let data_buffer = fs::read_to_string(&path).unwrap();
lazy_static! {
static ref RX: Regex = Regex::new(r"BOOT\s*=\s*cdrom:\\([aA-zZ0-9]{1,8}\.[aA-zZ0-9]{1,3}).+").expect("Could not compile regex");
}
match RX.captures(&data_buffer) {
None => {
println!("Could not find executable name on {}", &path);
None
},
Some(s) => {
match s.get(1) {
None => {
println!("Internal error");
None
},
Some(s_) => Some(String::from(s_.as_str()))
}
}
}
}
|
