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

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

use projectsettings::ProjectSettings;

pub mod cc {

    use super::*;

    #[no_mangle]
    pub extern "C" fn project_settings_new() -> *mut ProjectSettings {
        Box::into_raw(Box::new(ProjectSettings::new()))
    }

    #[no_mangle]
    pub extern "C" fn project_settings_free(ptr: *mut ProjectSettings) {
        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(),
        }
    }*/
}