scrapyard-core 0.1.0

Core crate for scrapyard containing MCU, Peripherals, ...
Documentation 
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

use std::ffi::{CStr, CString};
use std::path::Path;
use std::os::raw::c_char;
use std;

use module::peripheral::Peripheral;
use package::Package;
use pins::Pins;
use mcu::{MCUConf, MCU};

#[repr(C)]
pub enum PackageType {
    LQFP,
    TSSOP,
    WLCSP,
    UFQFPN,
    TFBGA,
    VFQFPN,
    EWLCSP,
    UFBGA,
    LFBGA,
    NONE,
}

pub mod cc {

    use super::*;

    #[no_mangle]
    pub extern "C" fn mcu_conf_new(path: *const c_char) -> *mut MCUConf {
        let path = unsafe {
            assert!(!path.is_null());
            CStr::from_ptr(path)
        };

        match path.to_str() {
            Ok(path) => match MCU::new(Path::new(path)) {
                Ok(mcu) => Box::into_raw(Box::new(mcu.finish())),
                Err(_) => std::ptr::null_mut(),
            },
            Err(_) => std::ptr::null_mut(),
        }
    }

    #[no_mangle]
    pub extern "C" fn mcu_conf_free(ptr: *mut MCUConf) {
        if !ptr.is_null() {
            unsafe {
                Box::from_raw(ptr);
            }
        }
    }

    #[no_mangle]
    pub extern "C" fn mcu_conf_get_name(ptr: *mut MCUConf) -> *mut c_char {
        let mcu_conf = unsafe {
            assert!(!ptr.is_null());
            &mut *ptr
        };

        let c_str_name = CString::new(mcu_conf.get_name()).unwrap();
        c_str_name.into_raw()
    }

    #[no_mangle]
    pub extern "C" fn mcu_conf_free_name(name: *mut c_char) {
        unsafe {
            if name.is_null() {
                return;
            }
            CString::from_raw(name)
        };
    }

    #[no_mangle]
    pub extern "C" fn mcu_conf_get_pins(ptr: *mut MCUConf) -> *mut Pins {
        let mcu_conf = unsafe {
            assert!(!ptr.is_null());
            &mut *ptr
        };

        mcu_conf.get_pins()
    }

    #[no_mangle]
    pub extern "C" fn mcu_conf_get_package(ptr: *mut MCUConf) -> *mut Package {
        let mcu_conf = unsafe {
            assert!(!ptr.is_null());
            &mut *ptr
        };

        mcu_conf.get_package()
    }

    #[no_mangle]
    pub extern "C" fn package_is_grid(ptr: *mut Package) -> bool {
        let package = unsafe {
            assert!(!ptr.is_null());
            &mut *ptr
        };

        package.is_grid()
    }

    #[no_mangle]
    pub extern "C" fn package_type(ptr: *mut Package) -> PackageType {
        let package = unsafe {
            assert!(!ptr.is_null());
            &mut *ptr
        };

        match *package {
            Package::LQFP(..) => PackageType::LQFP,
            Package::TSSOP(..) => PackageType::TSSOP,
            Package::WLCSP(..) => PackageType::WLCSP,
            Package::UFQFPN(..) => PackageType::UFQFPN,
            Package::TFBGA(..) => PackageType::TFBGA,
            Package::VFQFPN(..) => PackageType::VFQFPN,
            Package::EWLCSP(..) => PackageType::EWLCSP,
            Package::UFBGA(..) => PackageType::UFBGA,
            Package::LFBGA(..) => PackageType::LFBGA,
            Package::Unknown(..) => PackageType::NONE,
        }
    }

    #[no_mangle]
    pub extern "C" fn mcu_conf_get_peripheral(
        ptr: *mut MCUConf,
        name: *const c_char,
    ) -> *mut Peripheral {
        let mcu_conf = unsafe {
            assert!(!ptr.is_null());
            &mut *ptr
        };

        let name = unsafe {
            assert!(!name.is_null());
            CStr::from_ptr(name)
        };

        match mcu_conf
            .get_peripherals()
            .iter_mut()
            .find(|p| p.name == name.to_str().unwrap())
        {
            Some(peripheral) => peripheral,
            None => std::ptr::null_mut(),
        }
    }
}