Mark Drobnak
12 months ago
committed by
GitHub
9 changed files with 907 additions and 19 deletions
@ -0,0 +1,269 @@
@@ -0,0 +1,269 @@
|
||||
//! ir:USER Circle Pad Pro example.
|
||||
//!
|
||||
//! A demo of using the ir:USER service to connect to the Circle Pad Pro.
|
||||
|
||||
use ctru::prelude::*; |
||||
use ctru::services::gfx::{Flush, Swap}; |
||||
use ctru::services::ir_user::{CirclePadProInputResponse, ConnectionStatus, IrDeviceId, IrUser}; |
||||
use ctru::services::svc::HandleExt; |
||||
use ctru_sys::Handle; |
||||
use std::time::Duration; |
||||
|
||||
// Configuration for this demo of the Circle Pad Pro (not general purpose ir:USER values).
|
||||
const PACKET_INFO_SIZE: usize = 8; |
||||
const MAX_PACKET_SIZE: usize = 32; |
||||
const PACKET_COUNT: usize = 1; |
||||
const PACKET_BUFFER_SIZE: usize = PACKET_COUNT * (PACKET_INFO_SIZE + MAX_PACKET_SIZE); |
||||
const CPP_CONNECTION_POLLING_PERIOD_MS: u8 = 0x08; |
||||
const CPP_POLLING_PERIOD_MS: u8 = 0x32; |
||||
|
||||
// This export tells libctru to not initialize ir:rst when initializing HID.
|
||||
// This is necessary on the New 3DS because ir:rst is mutually exclusive with ir:USER.
|
||||
#[no_mangle] |
||||
unsafe extern "C" fn hidShouldUseIrrst() -> bool { |
||||
false |
||||
} |
||||
|
||||
fn main() { |
||||
let apt = Apt::new().unwrap(); |
||||
let gfx = Gfx::new().unwrap(); |
||||
let top_console = Console::new(gfx.top_screen.borrow_mut()); |
||||
let bottom_console = Console::new(gfx.bottom_screen.borrow_mut()); |
||||
let mut demo = CirclePadProDemo::new(top_console, bottom_console); |
||||
demo.print_status_info(); |
||||
|
||||
// Initialize HID after ir:USER because libctru also initializes ir:rst,
|
||||
// which is mutually exclusive with ir:USER. Initializing HID before ir:USER
|
||||
// on New 3DS causes ir:USER to not work.
|
||||
let mut hid = Hid::new().unwrap(); |
||||
|
||||
println!("Press A to connect to the CPP, or Start to exit"); |
||||
|
||||
let mut is_connected = false; |
||||
while apt.main_loop() { |
||||
hid.scan_input(); |
||||
|
||||
// Check if we need to exit
|
||||
if hid.keys_held().contains(KeyPad::START) { |
||||
break; |
||||
} |
||||
|
||||
// Check if we've received a packet from the circle pad pro
|
||||
let packet_received = demo |
||||
.receive_packet_event |
||||
.wait_for_event(Duration::ZERO) |
||||
.is_ok(); |
||||
if packet_received { |
||||
demo.handle_packets(); |
||||
} |
||||
|
||||
// Check if we should start the connection
|
||||
if hid.keys_down().contains(KeyPad::A) && !is_connected { |
||||
println!("Attempting to connect to the CPP"); |
||||
|
||||
match demo.connect_to_cpp(&mut hid) { |
||||
ConnectionResult::Connected => is_connected = true, |
||||
ConnectionResult::Canceled => break, |
||||
} |
||||
} |
||||
|
||||
gfx.wait_for_vblank(); |
||||
} |
||||
} |
||||
|
||||
struct CirclePadProDemo<'screen> { |
||||
top_console: Console<'screen>, |
||||
bottom_console: Console<'screen>, |
||||
ir_user: IrUser, |
||||
connection_status_event: Handle, |
||||
receive_packet_event: Handle, |
||||
} |
||||
|
||||
enum ConnectionResult { |
||||
Connected, |
||||
Canceled, |
||||
} |
||||
|
||||
impl<'screen> CirclePadProDemo<'screen> { |
||||
fn new(mut top_console: Console<'screen>, bottom_console: Console<'screen>) -> Self { |
||||
// Set up double buffering on top screen
|
||||
top_console.set_double_buffering(true); |
||||
top_console.swap_buffers(); |
||||
|
||||
// Write messages to bottom screen (not double buffered)
|
||||
bottom_console.select(); |
||||
println!("Welcome to the ir:USER / Circle Pad Pro Demo"); |
||||
|
||||
println!("Starting up ir:USER service"); |
||||
let ir_user = IrUser::init( |
||||
PACKET_BUFFER_SIZE, |
||||
PACKET_COUNT, |
||||
PACKET_BUFFER_SIZE, |
||||
PACKET_COUNT, |
||||
) |
||||
.expect("Couldn't initialize ir:USER service"); |
||||
println!("ir:USER service initialized"); |
||||
|
||||
// Get event handles
|
||||
let connection_status_event = ir_user |
||||
.get_connection_status_event() |
||||
.expect("Couldn't get ir:USER connection status event"); |
||||
let receive_packet_event = ir_user |
||||
.get_recv_event() |
||||
.expect("Couldn't get ir:USER recv event"); |
||||
|
||||
Self { |
||||
top_console, |
||||
bottom_console, |
||||
ir_user, |
||||
connection_status_event, |
||||
receive_packet_event, |
||||
} |
||||
} |
||||
|
||||
fn print_status_info(&mut self) { |
||||
self.top_console.select(); |
||||
self.top_console.clear(); |
||||
println!("{:#x?}", self.ir_user.get_status_info()); |
||||
self.top_console.flush_buffers(); |
||||
self.top_console.swap_buffers(); |
||||
self.bottom_console.select(); |
||||
} |
||||
|
||||
fn connect_to_cpp(&mut self, hid: &mut Hid) -> ConnectionResult { |
||||
// Connection loop
|
||||
loop { |
||||
hid.scan_input(); |
||||
if hid.keys_held().contains(KeyPad::START) { |
||||
return ConnectionResult::Canceled; |
||||
} |
||||
|
||||
// Start the connection process
|
||||
self.ir_user |
||||
.require_connection(IrDeviceId::CirclePadPro) |
||||
.expect("Couldn't initialize circle pad pro connection"); |
||||
|
||||
// Wait for the connection to establish
|
||||
if let Err(e) = self |
||||
.connection_status_event |
||||
.wait_for_event(Duration::from_millis(100)) |
||||
{ |
||||
if !e.is_timeout() { |
||||
panic!("Couldn't initialize circle pad pro connection: {e}"); |
||||
} |
||||
} |
||||
|
||||
self.print_status_info(); |
||||
if self.ir_user.get_status_info().connection_status == ConnectionStatus::Connected { |
||||
println!("Connected!"); |
||||
break; |
||||
} |
||||
|
||||
// If not connected (ex. timeout), disconnect so we can retry
|
||||
self.ir_user |
||||
.disconnect() |
||||
.expect("Failed to disconnect circle pad pro connection"); |
||||
|
||||
// Wait for the disconnect to go through
|
||||
if let Err(e) = self |
||||
.connection_status_event |
||||
.wait_for_event(Duration::from_millis(100)) |
||||
{ |
||||
if !e.is_timeout() { |
||||
panic!("Couldn't initialize circle pad pro connection: {e}"); |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Sending first packet retry loop
|
||||
loop { |
||||
hid.scan_input(); |
||||
if hid.keys_held().contains(KeyPad::START) { |
||||
return ConnectionResult::Canceled; |
||||
} |
||||
|
||||
// Send a request for input to the CPP
|
||||
if let Err(e) = self |
||||
.ir_user |
||||
.request_input_polling(CPP_CONNECTION_POLLING_PERIOD_MS) |
||||
{ |
||||
println!("Error: {e:?}"); |
||||
} |
||||
self.print_status_info(); |
||||
|
||||
// Wait for the response
|
||||
let recv_event_result = self |
||||
.receive_packet_event |
||||
.wait_for_event(Duration::from_millis(100)); |
||||
self.print_status_info(); |
||||
|
||||
if recv_event_result.is_ok() { |
||||
println!("Got first packet from CPP"); |
||||
self.handle_packets(); |
||||
break; |
||||
} |
||||
|
||||
// We didn't get a response in time, so loop and retry
|
||||
} |
||||
|
||||
ConnectionResult::Connected |
||||
} |
||||
|
||||
fn handle_packets(&mut self) { |
||||
let packets = self |
||||
.ir_user |
||||
.get_packets() |
||||
.expect("Packets should be well formed"); |
||||
let packet_count = packets.len(); |
||||
let Some(last_packet) = packets.last() else { |
||||
return; |
||||
}; |
||||
let status_info = self.ir_user.get_status_info(); |
||||
let cpp_response = CirclePadProInputResponse::try_from(last_packet) |
||||
.expect("Failed to parse CPP response from IR packet"); |
||||
|
||||
// Write data to top screen
|
||||
self.top_console.select(); |
||||
self.top_console.clear(); |
||||
println!("{:x?}", status_info); |
||||
|
||||
self.ir_user.process_shared_memory(|ir_mem| { |
||||
println!("\nReceiveBufferInfo:"); |
||||
print_buffer_as_hex(&ir_mem[0x10..0x20]); |
||||
|
||||
println!("\nReceiveBuffer:"); |
||||
print_buffer_as_hex(&ir_mem[0x20..0x20 + PACKET_BUFFER_SIZE]); |
||||
println!(); |
||||
}); |
||||
|
||||
println!("\nPacket count: {packet_count}"); |
||||
println!("{last_packet:02x?}"); |
||||
println!("\n{cpp_response:#02x?}"); |
||||
|
||||
// Flush output and switch back to bottom screen
|
||||
self.top_console.flush_buffers(); |
||||
self.top_console.swap_buffers(); |
||||
self.bottom_console.select(); |
||||
|
||||
// Done handling the packets, release them
|
||||
self.ir_user |
||||
.release_received_data(packet_count as u32) |
||||
.expect("Failed to release ir:USER packet"); |
||||
|
||||
// Remind the CPP that we're still listening
|
||||
if let Err(e) = self.ir_user.request_input_polling(CPP_POLLING_PERIOD_MS) { |
||||
println!("Error: {e:?}"); |
||||
} |
||||
} |
||||
} |
||||
|
||||
fn print_buffer_as_hex(buffer: &[u8]) { |
||||
let mut counter = 0; |
||||
for byte in buffer { |
||||
print!("{byte:02x} "); |
||||
counter += 1; |
||||
if counter % 16 == 0 { |
||||
println!(); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,15 @@
@@ -0,0 +1,15 @@
|
||||
//! This is a private module to prevent users from implementing certain traits.
|
||||
//! This is done by requiring a `Sealed` trait implementation, which can only be
|
||||
//! done in this crate.
|
||||
|
||||
use crate::console::Console; |
||||
use crate::services::gfx::{BottomScreen, TopScreen, TopScreen3D, TopScreenLeft, TopScreenRight}; |
||||
|
||||
pub trait Sealed {} |
||||
|
||||
impl Sealed for TopScreen {} |
||||
impl Sealed for TopScreen3D<'_> {} |
||||
impl Sealed for TopScreenLeft {} |
||||
impl Sealed for TopScreenRight {} |
||||
impl Sealed for BottomScreen {} |
||||
impl Sealed for Console<'_> {} |
||||
@ -0,0 +1,496 @@
@@ -0,0 +1,496 @@
|
||||
//! IR (Infrared) User Service.
|
||||
//!
|
||||
//! The ir:USER service allows you to communicate with IR devices such as the Circle Pad Pro.
|
||||
//!
|
||||
//! The Circle Pad Pro (CPP) is an accessory for the 3DS which adds a second Circle Pad and extra shoulder buttons.
|
||||
//! On New 3DS systems, the ir:USER service uses the built-in C-stick and new shoulder buttons to emulate the Circle Pad
|
||||
//! Pro. Many released games which support the second stick and extra shoulder buttons use this service to communicate
|
||||
//! so they can support both Old 3DS + CPP and New 3DS.
|
||||
#![doc(alias = "input")] |
||||
#![doc(alias = "controller")] |
||||
#![doc(alias = "gamepad")] |
||||
|
||||
use crate::error::ResultCode; |
||||
use crate::services::svc::{make_ipc_header, HandleExt}; |
||||
use crate::services::ServiceReference; |
||||
use crate::Error; |
||||
use ctru_sys::{Handle, MEMPERM_READ, MEMPERM_READWRITE}; |
||||
use std::alloc::Layout; |
||||
use std::ffi::CString; |
||||
use std::ptr::slice_from_raw_parts; |
||||
use std::sync::Mutex; |
||||
|
||||
static IR_USER_ACTIVE: Mutex<()> = Mutex::new(()); |
||||
static IR_USER_STATE: Mutex<Option<IrUserState>> = Mutex::new(None); |
||||
|
||||
/// The "ir:USER" service. This service is used to talk to IR devices such as
|
||||
/// the Circle Pad Pro.
|
||||
pub struct IrUser { |
||||
_service_reference: ServiceReference, |
||||
} |
||||
|
||||
// We need to hold on to some extra service state, hence this struct.
|
||||
struct IrUserState { |
||||
service_handle: Handle, |
||||
shared_memory_handle: Handle, |
||||
shared_memory: &'static [u8], |
||||
shared_memory_layout: Layout, |
||||
recv_buffer_size: usize, |
||||
recv_packet_count: usize, |
||||
} |
||||
|
||||
// ir:USER syscall command headers
|
||||
const REQUIRE_CONNECTION_COMMAND_HEADER: u32 = make_ipc_header(6, 1, 0); |
||||
const DISCONNECT_COMMAND_HEADER: u32 = make_ipc_header(9, 0, 0); |
||||
const GET_RECEIVE_EVENT_COMMAND_HEADER: u32 = make_ipc_header(10, 0, 0); |
||||
const GET_CONNECTION_STATUS_EVENT_COMMAND_HEADER: u32 = make_ipc_header(12, 0, 0); |
||||
const SEND_IR_NOP_COMMAND_HEADER: u32 = make_ipc_header(13, 1, 2); |
||||
const INITIALIZE_IRNOP_SHARED_COMMAND_HEADER: u32 = make_ipc_header(24, 6, 2); |
||||
const RELEASE_RECEIVED_DATA_COMMAND_HEADER: u32 = make_ipc_header(25, 1, 0); |
||||
|
||||
// Misc constants
|
||||
const SHARED_MEM_INFO_SECTIONS_SIZE: usize = 0x30; |
||||
const SHARED_MEM_RECV_BUFFER_OFFSET: usize = 0x20; |
||||
const PAGE_SIZE: usize = 0x1000; |
||||
const IR_BITRATE: u32 = 4; |
||||
const PACKET_INFO_SIZE: usize = 8; |
||||
const CIRCLE_PAD_PRO_INPUT_RESPONSE_PACKET_ID: u8 = 0x10; |
||||
|
||||
impl IrUser { |
||||
/// Initialize the ir:USER service. The provided buffer sizes and packet
|
||||
/// counts are used to calculate the size of shared memory used by the
|
||||
/// service.
|
||||
pub fn init( |
||||
recv_buffer_size: usize, |
||||
recv_packet_count: usize, |
||||
send_buffer_size: usize, |
||||
send_packet_count: usize, |
||||
) -> crate::Result<Self> { |
||||
let service_reference = ServiceReference::new( |
||||
&IR_USER_ACTIVE, |
||||
|| unsafe { |
||||
// Get the ir:USER service handle
|
||||
let mut service_handle = Handle::default(); |
||||
let service_name = CString::new("ir:USER").unwrap(); |
||||
ResultCode(ctru_sys::srvGetServiceHandle( |
||||
&mut service_handle, |
||||
service_name.as_ptr(), |
||||
))?; |
||||
|
||||
// Calculate the shared memory size.
|
||||
// Shared memory length must be a multiple of the page size.
|
||||
let minimum_shared_memory_len = |
||||
SHARED_MEM_INFO_SECTIONS_SIZE + recv_buffer_size + send_buffer_size; |
||||
let shared_memory_len = round_up(minimum_shared_memory_len, PAGE_SIZE); |
||||
|
||||
// Allocate the shared memory
|
||||
let shared_memory_layout = |
||||
Layout::from_size_align(shared_memory_len, PAGE_SIZE).unwrap(); |
||||
let shared_memory_ptr = std::alloc::alloc_zeroed(shared_memory_layout); |
||||
let shared_memory = &*slice_from_raw_parts(shared_memory_ptr, shared_memory_len); |
||||
|
||||
// Mark the memory as shared
|
||||
let mut shared_memory_handle = Handle::default(); |
||||
ResultCode(ctru_sys::svcCreateMemoryBlock( |
||||
&mut shared_memory_handle, |
||||
shared_memory_ptr as u32, |
||||
shared_memory_len as u32, |
||||
MEMPERM_READ, |
||||
MEMPERM_READWRITE, |
||||
))?; |
||||
|
||||
// Initialize the ir:USER service with the shared memory
|
||||
let request = vec![ |
||||
INITIALIZE_IRNOP_SHARED_COMMAND_HEADER, |
||||
shared_memory_len as u32, |
||||
recv_buffer_size as u32, |
||||
recv_packet_count as u32, |
||||
send_buffer_size as u32, |
||||
send_packet_count as u32, |
||||
IR_BITRATE, |
||||
0, |
||||
shared_memory_handle, |
||||
]; |
||||
service_handle.send_service_request(request, 2)?; |
||||
|
||||
// Set up our service state
|
||||
let user_state = IrUserState { |
||||
service_handle, |
||||
shared_memory_handle, |
||||
shared_memory, |
||||
shared_memory_layout, |
||||
recv_buffer_size, |
||||
recv_packet_count, |
||||
}; |
||||
let mut ir_user_state = IR_USER_STATE |
||||
.lock() |
||||
.map_err(|e| Error::Other(format!("Failed to write to IR_USER_STATE: {e}")))?; |
||||
*ir_user_state = Some(user_state); |
||||
|
||||
Ok(()) |
||||
}, |
||||
|| { |
||||
// Remove our service state from the global location
|
||||
let mut shared_mem_guard = IR_USER_STATE |
||||
.lock() |
||||
.expect("Failed to write to IR_USER_STATE"); |
||||
let Some(shared_mem) = shared_mem_guard.take() else { |
||||
// If we don't have any state, then we don't need to clean up.
|
||||
return; |
||||
}; |
||||
|
||||
(move || unsafe { |
||||
// Close service and memory handles
|
||||
ResultCode(ctru_sys::svcCloseHandle(shared_mem.service_handle))?; |
||||
ResultCode(ctru_sys::svcCloseHandle(shared_mem.shared_memory_handle))?; |
||||
|
||||
// Free shared memory
|
||||
std::alloc::dealloc( |
||||
shared_mem.shared_memory.as_ptr() as *mut u8, |
||||
shared_mem.shared_memory_layout, |
||||
); |
||||
|
||||
Ok(()) |
||||
})() |
||||
.unwrap(); |
||||
}, |
||||
)?; |
||||
|
||||
Ok(IrUser { |
||||
_service_reference: service_reference, |
||||
}) |
||||
} |
||||
|
||||
/// Try to connect to the device with the provided ID.
|
||||
pub fn require_connection(&mut self, device_id: IrDeviceId) -> crate::Result<()> { |
||||
unsafe { |
||||
self.send_service_request( |
||||
vec![REQUIRE_CONNECTION_COMMAND_HEADER, device_id.get_id()], |
||||
2, |
||||
)?; |
||||
} |
||||
Ok(()) |
||||
} |
||||
|
||||
/// Close the current IR connection.
|
||||
pub fn disconnect(&mut self) -> crate::Result<()> { |
||||
unsafe { |
||||
self.send_service_request(vec![DISCONNECT_COMMAND_HEADER], 2)?; |
||||
} |
||||
Ok(()) |
||||
} |
||||
|
||||
/// Get an event handle that activates on connection status changes.
|
||||
pub fn get_connection_status_event(&self) -> crate::Result<Handle> { |
||||
let response = unsafe { |
||||
self.send_service_request(vec![GET_CONNECTION_STATUS_EVENT_COMMAND_HEADER], 4) |
||||
}?; |
||||
let status_event = response[3] as Handle; |
||||
|
||||
Ok(status_event) |
||||
} |
||||
|
||||
/// Get an event handle that activates when a packet is received.
|
||||
pub fn get_recv_event(&self) -> crate::Result<Handle> { |
||||
let response = |
||||
unsafe { self.send_service_request(vec![GET_RECEIVE_EVENT_COMMAND_HEADER], 4) }?; |
||||
let recv_event = response[3] as Handle; |
||||
|
||||
Ok(recv_event) |
||||
} |
||||
|
||||
/// Circle Pad Pro specific request.
|
||||
///
|
||||
/// This will send a packet to the CPP requesting it to send back packets
|
||||
/// with the current device input values.
|
||||
pub fn request_input_polling(&mut self, period_ms: u8) -> crate::Result<()> { |
||||
let ir_request: [u8; 3] = [1, period_ms, (period_ms + 2) << 2]; |
||||
unsafe { |
||||
self.send_service_request( |
||||
vec![ |
||||
SEND_IR_NOP_COMMAND_HEADER, |
||||
ir_request.len() as u32, |
||||
2 + (ir_request.len() << 14) as u32, |
||||
ir_request.as_ptr() as u32, |
||||
], |
||||
2, |
||||
)?; |
||||
} |
||||
|
||||
Ok(()) |
||||
} |
||||
|
||||
/// Mark the last `packet_count` packets as processed, so their memory in
|
||||
/// the receive buffer can be reused.
|
||||
pub fn release_received_data(&mut self, packet_count: u32) -> crate::Result<()> { |
||||
unsafe { |
||||
self.send_service_request(vec![RELEASE_RECEIVED_DATA_COMMAND_HEADER, packet_count], 2)?; |
||||
} |
||||
Ok(()) |
||||
} |
||||
|
||||
/// This will let you directly read the ir:USER shared memory via a callback.
|
||||
pub fn process_shared_memory(&self, process_fn: impl FnOnce(&[u8])) { |
||||
let shared_mem_guard = IR_USER_STATE.lock().unwrap(); |
||||
let shared_mem = shared_mem_guard.as_ref().unwrap(); |
||||
|
||||
process_fn(shared_mem.shared_memory); |
||||
} |
||||
|
||||
/// Read and parse the ir:USER service status data from shared memory.
|
||||
pub fn get_status_info(&self) -> IrUserStatusInfo { |
||||
let shared_mem_guard = IR_USER_STATE.lock().unwrap(); |
||||
let shared_mem = shared_mem_guard.as_ref().unwrap().shared_memory; |
||||
|
||||
IrUserStatusInfo { |
||||
recv_err_result: i32::from_ne_bytes(shared_mem[0..4].try_into().unwrap()), |
||||
send_err_result: i32::from_ne_bytes(shared_mem[4..8].try_into().unwrap()), |
||||
connection_status: match shared_mem[8] { |
||||
0 => ConnectionStatus::Disconnected, |
||||
1 => ConnectionStatus::Connecting, |
||||
2 => ConnectionStatus::Connected, |
||||
n => ConnectionStatus::Unknown(n), |
||||
}, |
||||
trying_to_connect_status: shared_mem[9], |
||||
connection_role: shared_mem[10], |
||||
machine_id: shared_mem[11], |
||||
unknown_field_1: shared_mem[12], |
||||
network_id: shared_mem[13], |
||||
unknown_field_2: shared_mem[14], |
||||
unknown_field_3: shared_mem[15], |
||||
} |
||||
} |
||||
|
||||
/// Read and parse the current packets received from the IR device.
|
||||
pub fn get_packets(&self) -> Result<Vec<IrUserPacket>, String> { |
||||
let shared_mem_guard = IR_USER_STATE.lock().unwrap(); |
||||
let user_state = shared_mem_guard.as_ref().unwrap(); |
||||
let shared_mem = user_state.shared_memory; |
||||
|
||||
// Find where the packets are, and how many
|
||||
let start_index = u32::from_ne_bytes(shared_mem[0x10..0x14].try_into().unwrap()); |
||||
let valid_packet_count = u32::from_ne_bytes(shared_mem[0x18..0x1c].try_into().unwrap()); |
||||
|
||||
// Parse the packets
|
||||
(0..valid_packet_count as usize) |
||||
.map(|i| { |
||||
// Get the packet info
|
||||
let packet_index = (i + start_index as usize) % user_state.recv_packet_count; |
||||
let packet_info_offset = |
||||
SHARED_MEM_RECV_BUFFER_OFFSET + (packet_index * PACKET_INFO_SIZE); |
||||
let packet_info = |
||||
&shared_mem[packet_info_offset..packet_info_offset + PACKET_INFO_SIZE]; |
||||
|
||||
let offset_to_data_buffer = |
||||
u32::from_ne_bytes(packet_info[0..4].try_into().unwrap()) as usize; |
||||
let data_length = |
||||
u32::from_ne_bytes(packet_info[4..8].try_into().unwrap()) as usize; |
||||
|
||||
// Find the packet data. The packet data may wrap around the buffer end, so
|
||||
// `packet_data` is a function from packet byte offset to value.
|
||||
let packet_info_section_size = user_state.recv_packet_count * PACKET_INFO_SIZE; |
||||
let header_size = SHARED_MEM_RECV_BUFFER_OFFSET + packet_info_section_size; |
||||
let data_buffer_size = user_state.recv_buffer_size - packet_info_section_size; |
||||
let packet_data = |idx| -> u8 { |
||||
let data_buffer_offset = offset_to_data_buffer + idx; |
||||
shared_mem[header_size + data_buffer_offset % data_buffer_size] |
||||
}; |
||||
|
||||
// Find out how long the payload is (payload length is variable-length encoded)
|
||||
let (payload_length, payload_offset) = if packet_data(2) & 0x40 != 0 { |
||||
// Big payload
|
||||
( |
||||
((packet_data(2) as usize & 0x3F) << 8) + packet_data(3) as usize, |
||||
4, |
||||
) |
||||
} else { |
||||
// Small payload
|
||||
((packet_data(2) & 0x3F) as usize, 3) |
||||
}; |
||||
|
||||
// Check our payload length math against what the packet info contains
|
||||
if data_length != payload_offset + payload_length + 1 { |
||||
return Err(format!( |
||||
"Invalid payload length (expected {}, got {})", |
||||
data_length, |
||||
payload_offset + payload_length + 1 |
||||
)); |
||||
} |
||||
|
||||
// IR packets start with a magic number, so double check it
|
||||
let magic_number = packet_data(0); |
||||
if magic_number != 0xA5 { |
||||
return Err(format!( |
||||
"Invalid magic number in packet: {magic_number:#x}, expected 0xA5" |
||||
)); |
||||
} |
||||
|
||||
Ok(IrUserPacket { |
||||
magic_number: packet_data(0), |
||||
destination_network_id: packet_data(1), |
||||
payload_length, |
||||
payload: (payload_offset..payload_offset + payload_length) |
||||
.map(packet_data) |
||||
.collect(), |
||||
checksum: packet_data(payload_offset + payload_length), |
||||
}) |
||||
}) |
||||
.collect() |
||||
} |
||||
|
||||
/// Internal helper for calling ir:USER service methods.
|
||||
unsafe fn send_service_request( |
||||
&self, |
||||
request: Vec<u32>, |
||||
expected_response_len: usize, |
||||
) -> crate::Result<Vec<u32>> { |
||||
let mut shared_mem_guard = IR_USER_STATE.lock().unwrap(); |
||||
let shared_mem = shared_mem_guard.as_mut().unwrap(); |
||||
|
||||
shared_mem |
||||
.service_handle |
||||
.send_service_request(request, expected_response_len) |
||||
} |
||||
} |
||||
|
||||
// Internal helper for rounding up a value to a multiple of another value.
|
||||
fn round_up(value: usize, multiple: usize) -> usize { |
||||
if value % multiple != 0 { |
||||
(value / multiple) * multiple + multiple |
||||
} else { |
||||
(value / multiple) * multiple |
||||
} |
||||
} |
||||
|
||||
/// An enum which represents the different IR devices the 3DS can connect to via
|
||||
/// the ir:USER service.
|
||||
pub enum IrDeviceId { |
||||
/// Circle Pad Pro
|
||||
CirclePadPro, |
||||
/// Other devices
|
||||
// Pretty sure no other IDs are recognized, but just in case
|
||||
Custom(u32), |
||||
} |
||||
|
||||
impl IrDeviceId { |
||||
/// Get the ID of the device.
|
||||
pub fn get_id(&self) -> u32 { |
||||
match *self { |
||||
IrDeviceId::CirclePadPro => 1, |
||||
IrDeviceId::Custom(id) => id, |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// This struct holds a parsed copy of the ir:USER service status (from shared memory).
|
||||
#[derive(Debug)] |
||||
pub struct IrUserStatusInfo { |
||||
/// The result of the last receive operation.
|
||||
pub recv_err_result: ctru_sys::Result, |
||||
/// The result of the last send operation.
|
||||
pub send_err_result: ctru_sys::Result, |
||||
/// The current connection status.
|
||||
pub connection_status: ConnectionStatus, |
||||
/// The status of the connection attempt.
|
||||
pub trying_to_connect_status: u8, |
||||
/// The role of the device in the connection (value meaning is unknown).
|
||||
pub connection_role: u8, |
||||
/// The machine ID of the device.
|
||||
pub machine_id: u8, |
||||
/// Unknown field.
|
||||
pub unknown_field_1: u8, |
||||
/// The network ID of the connection.
|
||||
pub network_id: u8, |
||||
/// Unknown field.
|
||||
pub unknown_field_2: u8, |
||||
/// Unknown field.
|
||||
pub unknown_field_3: u8, |
||||
} |
||||
|
||||
/// Connection status values for [`IrUserStatusInfo`].
|
||||
#[repr(u8)] |
||||
#[derive(Debug, PartialEq, Eq)] |
||||
pub enum ConnectionStatus { |
||||
/// Device is not connected
|
||||
Disconnected = 0, |
||||
/// Waiting for device to connect
|
||||
Connecting = 1, |
||||
/// Device is connected
|
||||
Connected = 2, |
||||
/// Unknown connection status
|
||||
Unknown(u8), |
||||
} |
||||
|
||||
/// A packet of data sent/received to/from the IR device.
|
||||
#[derive(Debug)] |
||||
pub struct IrUserPacket { |
||||
/// The magic number of the packet. Should always be 0xA5.
|
||||
pub magic_number: u8, |
||||
/// The destination network ID.
|
||||
pub destination_network_id: u8, |
||||
/// The length of the payload.
|
||||
pub payload_length: usize, |
||||
/// The payload data.
|
||||
pub payload: Vec<u8>, |
||||
/// The checksum of the packet.
|
||||
pub checksum: u8, |
||||
} |
||||
|
||||
/// Circle Pad Pro response packet holding the current device input signals and status.
|
||||
#[derive(Debug, Default)] |
||||
pub struct CirclePadProInputResponse { |
||||
/// The X value of the C-stick.
|
||||
pub c_stick_x: u16, |
||||
/// The Y value of the C-stick.
|
||||
pub c_stick_y: u16, |
||||
/// The battery level of the Circle Pad Pro.
|
||||
pub battery_level: u8, |
||||
/// Whether the ZL button is pressed.
|
||||
pub zl_pressed: bool, |
||||
/// Whether the ZR button is pressed.
|
||||
pub zr_pressed: bool, |
||||
/// Whether the R button is pressed.
|
||||
pub r_pressed: bool, |
||||
/// Unknown field.
|
||||
pub unknown_field: u8, |
||||
} |
||||
|
||||
impl TryFrom<&IrUserPacket> for CirclePadProInputResponse { |
||||
type Error = String; |
||||
|
||||
fn try_from(packet: &IrUserPacket) -> Result<Self, Self::Error> { |
||||
if packet.payload.len() != 6 { |
||||
return Err(format!( |
||||
"Invalid payload length (expected 6 bytes, got {})", |
||||
packet.payload.len() |
||||
)); |
||||
} |
||||
|
||||
let response_id = packet.payload[0]; |
||||
if response_id != CIRCLE_PAD_PRO_INPUT_RESPONSE_PACKET_ID { |
||||
return Err(format!( |
||||
"Invalid response ID (expected {CIRCLE_PAD_PRO_INPUT_RESPONSE_PACKET_ID}, got {:#x}", |
||||
packet.payload[0] |
||||
)); |
||||
} |
||||
|
||||
let c_stick_x = packet.payload[1] as u16 + (((packet.payload[2] & 0x0F) as u16) << 8); |
||||
let c_stick_y = |
||||
(((packet.payload[2] & 0xF0) as u16) >> 4) + ((packet.payload[3] as u16) << 4); |
||||
let battery_level = packet.payload[4] & 0x1F; |
||||
let zl_pressed = packet.payload[4] & 0x20 == 0; |
||||
let zr_pressed = packet.payload[4] & 0x40 == 0; |
||||
let r_pressed = packet.payload[4] & 0x80 == 0; |
||||
let unknown_field = packet.payload[5]; |
||||
|
||||
Ok(CirclePadProInputResponse { |
||||
c_stick_x, |
||||
c_stick_y, |
||||
battery_level, |
||||
zl_pressed, |
||||
zr_pressed, |
||||
r_pressed, |
||||
unknown_field, |
||||
}) |
||||
} |
||||
} |
||||
@ -0,0 +1,76 @@
@@ -0,0 +1,76 @@
|
||||
//! Syscall APIs
|
||||
//!
|
||||
//! Not all APIs are wrapped in this module, since a lot are fundamentally unsafe.
|
||||
//! Most APIs should be used directly from `ctru-sys`.
|
||||
|
||||
use crate::error::ResultCode; |
||||
use ctru_sys::Handle; |
||||
use std::time::Duration; |
||||
|
||||
/// Extension trait for [Handle]
|
||||
pub trait HandleExt { |
||||
/// Wait for an event to fire. If the timeout is reached, an error is returned. You can use
|
||||
/// [`Error::is_timeout`] to check if the error is due to a timeout.
|
||||
fn wait_for_event(self, timeout: Duration) -> crate::Result<()>; |
||||
|
||||
/// Send a service request to the handle.
|
||||
/// The request vector must contain the command header and any parameters.
|
||||
/// The request vector is overwritten with the response and returned.
|
||||
/// The error in the response is checked and returned as a `Result::Err` if the operation failed.
|
||||
///
|
||||
/// # Safety
|
||||
/// This function is unsafe because it directly accesses the thread command buffer.
|
||||
/// If the request vector or the expected response length is incorrect, or the handle is not a service that accepts
|
||||
/// requests, the function may cause undefined behavior.
|
||||
unsafe fn send_service_request( |
||||
self, |
||||
request: Vec<u32>, |
||||
expected_response_len: usize, |
||||
) -> crate::Result<Vec<u32>>; |
||||
} |
||||
|
||||
impl HandleExt for Handle { |
||||
fn wait_for_event(self, timeout: Duration) -> crate::Result<()> { |
||||
let timeout = i64::try_from(timeout.as_nanos()).map_err(|e| { |
||||
crate::Error::Other(format!( |
||||
"Failed to convert timeout to 64-bit nanoseconds: {}", |
||||
e |
||||
)) |
||||
})?; |
||||
unsafe { |
||||
ResultCode(ctru_sys::svcWaitSynchronization(self, timeout))?; |
||||
} |
||||
Ok(()) |
||||
} |
||||
|
||||
unsafe fn send_service_request( |
||||
self, |
||||
mut request: Vec<u32>, |
||||
expected_response_len: usize, |
||||
) -> crate::Result<Vec<u32>> { |
||||
// Copy over the request
|
||||
let cmd_buffer_ptr = unsafe { ctru_sys::getThreadCommandBuffer() }; |
||||
std::ptr::copy_nonoverlapping(request.as_ptr(), cmd_buffer_ptr, request.len()); |
||||
|
||||
// Send the request
|
||||
ResultCode(ctru_sys::svcSendSyncRequest(self))?; |
||||
|
||||
// Handle the result returned by the service
|
||||
let result = unsafe { std::ptr::read(cmd_buffer_ptr.add(1)) }; |
||||
ResultCode(result as ctru_sys::Result)?; |
||||
|
||||
// Copy back the response
|
||||
request.clear(); |
||||
request.resize(expected_response_len, 0); |
||||
std::ptr::copy_nonoverlapping(cmd_buffer_ptr, request.as_mut_ptr(), expected_response_len); |
||||
|
||||
Ok(request) |
||||
} |
||||
} |
||||
|
||||
/// Creates a command header to be used for IPC. This is a const fn version of [`ctru_sys::IPC_MakeHeader`].
|
||||
pub const fn make_ipc_header(command_id: u16, normal_params: u8, translate_params: u8) -> u32 { |
||||
((command_id as u32) << 16) |
||||
| (((normal_params as u32) & 0x3F) << 6) |
||||
| ((translate_params as u32) & 0x3F) |
||||
} |
||||
Loading…
Reference in new issue