Struct CoordinateFormat

pub struct CoordinateFormat {
    pub integer: u8,
    pub decimal: u8,
}

Expand description

The coordinate format specifies the number of integer and decimal places in a coordinate number. For example, the 24 format specifies 2 integer and 4 decimal places. The number of decimal places must be 4, 5 or 6. The number of integer places must be not more than 6. Thus the longest representable coordinate number is nnnnnn.nnnnnn.

Fields§

§integer: u8§decimal: u8

Implementations§

impl CoordinateFormat

pub fn new(integer: u8, decimal: u8) -> Self

Examples found in repository ?

examples/two-boxes.rs (line 15)

14fn main() {
15    let cf = CoordinateFormat::new(2, 6);
16    let commands: Vec<Command> = vec![
17        FunctionCode::GCode(GCode::Comment(CommentContent::String(
18            "Ucamco ex. 1: Two square boxes".to_string(),
19        )))
20        .into(),
21        ExtendedCode::Unit(Unit::Millimeters).into(),
22        ExtendedCode::CoordinateFormat(cf).into(),
23        ExtendedCode::FileAttribute(FileAttribute::GenerationSoftware(GenerationSoftware::new(
24            "MakerPnP",
25            "gerber-types",
26            Some(VERSION),
27        )))
28        .into(),
29        ExtendedCode::FileAttribute(FileAttribute::Part(Part::Other("example".to_string()))).into(),
30        ExtendedCode::LoadPolarity(Polarity::Dark).into(),
31        ExtendedCode::ApertureDefinition(ApertureDefinition {
32            code: 10,
33            aperture: Aperture::Circle(Circle {
34                diameter: 0.01,
35                hole_diameter: None,
36            }),
37        })
38        .into(),
39        FunctionCode::DCode(DCode::SelectAperture(10)).into(),
40        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
41            0, 0, cf,
42        )))))
43        .into(),
44        FunctionCode::GCode(GCode::InterpolationMode(InterpolationMode::Linear)).into(),
45        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
46            Some(Coordinates::new(5, 0, cf)),
47            None,
48        )))
49        .into(),
50        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
51            Some(Coordinates::at_y(5, cf)),
52            None,
53        )))
54        .into(),
55        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
56            Some(Coordinates::at_x(0, cf)),
57            None,
58        )))
59        .into(),
60        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
61            Some(Coordinates::at_y(0, cf)),
62            None,
63        )))
64        .into(),
65        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::at_x(
66            6, cf,
67        )))))
68        .into(),
69        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
70            Some(Coordinates::at_x(11, cf)),
71            None,
72        )))
73        .into(),
74        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
75            Some(Coordinates::at_y(5, cf)),
76            None,
77        )))
78        .into(),
79        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
80            Some(Coordinates::at_x(6, cf)),
81            None,
82        )))
83        .into(),
84        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
85            Some(Coordinates::at_y(0, cf)),
86            None,
87        )))
88        .into(),
89        FunctionCode::MCode(MCode::EndOfFile).into(),
90    ];
91    let mut stdout = stdout();
92    commands.serialize(&mut stdout).unwrap();
93}

More examples

Hide additional examples

examples/polarities-apertures.rs (line 12)

11fn main() {
12    let cf = CoordinateFormat::new(2, 6);
13    let commands: Vec<Command> = vec![
14        FunctionCode::GCode(GCode::Comment(CommentContent::String(
15            "Ucamco ex. 2: Shapes".to_string(),
16        )))
17        .into(),
18        ExtendedCode::CoordinateFormat(cf).into(),
19        ExtendedCode::Unit(Unit::Inches).into(),
20        ExtendedCode::FileAttribute(FileAttribute::GenerationSoftware(GenerationSoftware::new(
21            "Rust Gerber",
22            "gerber-types",
23            Some(VERSION),
24        )))
25        .into(),
26        ExtendedCode::FileAttribute(FileAttribute::Part(Part::Other(
27            "Only an example".to_string(),
28        )))
29        .into(),
30        ExtendedCode::LoadPolarity(Polarity::Dark).into(),
31        FunctionCode::GCode(GCode::Comment(CommentContent::String(
32            "Define Apertures".to_string(),
33        )))
34        .into(),
35        ExtendedCode::ApertureMacro(ApertureMacro::new("TARGET125").add_content(MoirePrimitive {
36            center: (0.0.into(), 0.0.into()),
37            diameter: 0.125.into(),
38            ring_thickness: 0.01.into(),
39            gap: 0.01.into(),
40            max_rings: 3,
41            cross_hair_thickness: 0.003.into(),
42            cross_hair_length: 0.150.into(),
43            angle: 0.0.into(),
44        }))
45        .into(),
46        ExtendedCode::ApertureMacro(ApertureMacro::new("THERMAL80").add_content(
47            ThermalPrimitive {
48                center: (0.0.into(), 0.0.into()),
49                outer_diameter: 0.08.into(),
50                inner_diameter: 0.055.into(),
51                gap: 0.0125.into(),
52                angle: 45.0.into(),
53            },
54        ))
55        .into(),
56        ExtendedCode::ApertureDefinition(ApertureDefinition {
57            code: 10,
58            aperture: Aperture::Circle(Circle {
59                diameter: 0.01,
60                hole_diameter: None,
61            }),
62        })
63        .into(),
64        ExtendedCode::ApertureDefinition(ApertureDefinition {
65            code: 11,
66            aperture: Aperture::Circle(Circle {
67                diameter: 0.06,
68                hole_diameter: None,
69            }),
70        })
71        .into(),
72        ExtendedCode::ApertureDefinition(ApertureDefinition {
73            code: 12,
74            aperture: Aperture::Rectangle(Rectangular {
75                x: 0.06,
76                y: 0.06,
77                hole_diameter: None,
78            }),
79        })
80        .into(),
81        ExtendedCode::ApertureDefinition(ApertureDefinition {
82            code: 13,
83            aperture: Aperture::Rectangle(Rectangular {
84                x: 0.04,
85                y: 0.1,
86                hole_diameter: None,
87            }),
88        })
89        .into(),
90        ExtendedCode::ApertureDefinition(ApertureDefinition {
91            code: 14,
92            aperture: Aperture::Rectangle(Rectangular {
93                x: 0.1,
94                y: 0.04,
95                hole_diameter: None,
96            }),
97        })
98        .into(),
99        ExtendedCode::ApertureDefinition(ApertureDefinition {
100            code: 15,
101            aperture: Aperture::Obround(Rectangular {
102                x: 0.04,
103                y: 0.1,
104                hole_diameter: None,
105            }),
106        })
107        .into(),
108        ExtendedCode::ApertureDefinition(ApertureDefinition {
109            code: 16,
110            aperture: Aperture::Polygon(Polygon {
111                diameter: 0.1,
112                vertices: 3,
113                rotation: None,
114                hole_diameter: None,
115            }),
116        })
117        .into(),
118        ExtendedCode::ApertureDefinition(ApertureDefinition {
119            code: 18,
120            aperture: Aperture::Macro("TARGET125".to_string(), None),
121        })
122        .into(),
123        ExtendedCode::ApertureDefinition(ApertureDefinition {
124            code: 19,
125            aperture: Aperture::Macro("THERMAL80".to_string(), None),
126        })
127        .into(),
128        FunctionCode::GCode(GCode::Comment(CommentContent::String(
129            "Start image generation".to_string(),
130        )))
131        .into(),
132        FunctionCode::DCode(DCode::SelectAperture(10)).into(),
133        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
134            0,
135            CoordinateNumber::try_from(0.25).unwrap(),
136            cf,
137        )))))
138        .into(),
139        FunctionCode::GCode(GCode::InterpolationMode(InterpolationMode::Linear)).into(),
140        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
141            Some(Coordinates::new(0, 0, cf)),
142            None,
143        )))
144        .into(),
145        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
146            Some(Coordinates::new(
147                CoordinateNumber::try_from(0.25).unwrap(),
148                0,
149                cf,
150            )),
151            None,
152        )))
153        .into(),
154        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
155            1, 1, cf,
156        )))))
157        .into(),
158        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
159            Some(Coordinates::at_x(
160                CoordinateNumber::try_from(1.5).unwrap(),
161                cf,
162            )),
163            None,
164        )))
165        .into(),
166        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
167            Some(Coordinates::new(
168                2,
169                CoordinateNumber::try_from(1.5).unwrap(),
170                cf,
171            )),
172            None,
173        )))
174        .into(),
175        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::at_x(
176            CoordinateNumber::try_from(2.5).unwrap(),
177            cf,
178        )))))
179        .into(),
180        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
181            Some(Coordinates::at_y(1, cf)),
182            None,
183        )))
184        .into(),
185        FunctionCode::DCode(DCode::SelectAperture(11)).into(),
186        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
187            1, 1, cf,
188        )))))
189        .into(),
190        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
191            2, 1, cf,
192        )))))
193        .into(),
194        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
195            CoordinateNumber::try_from(2.5).unwrap(),
196            1,
197            cf,
198        )))))
199        .into(),
200        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
201            CoordinateNumber::try_from(2.5).unwrap(),
202            CoordinateNumber::try_from(1.5).unwrap(),
203            cf,
204        )))))
205        .into(),
206        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
207            2,
208            CoordinateNumber::try_from(1.5).unwrap(),
209            cf,
210        )))))
211        .into(),
212        FunctionCode::DCode(DCode::SelectAperture(12)).into(),
213        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
214            1,
215            CoordinateNumber::try_from(1.5).unwrap(),
216            cf,
217        )))))
218        .into(),
219        FunctionCode::DCode(DCode::SelectAperture(13)).into(),
220        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
221            3,
222            CoordinateNumber::try_from(1.5).unwrap(),
223            cf,
224        )))))
225        .into(),
226        FunctionCode::DCode(DCode::SelectAperture(14)).into(),
227        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
228            3,
229            CoordinateNumber::try_from(1.25).unwrap(),
230            cf,
231        )))))
232        .into(),
233        FunctionCode::DCode(DCode::SelectAperture(15)).into(),
234        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
235            3, 1, cf,
236        )))))
237        .into(),
238        FunctionCode::DCode(DCode::SelectAperture(10)).into(),
239        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
240            CoordinateNumber::try_from(3.75).unwrap(),
241            1,
242            cf,
243        )))))
244        .into(),
245        FunctionCode::GCode(GCode::QuadrantMode(QuadrantMode::Multi)).into(),
246        FunctionCode::GCode(GCode::InterpolationMode(
247            InterpolationMode::CounterclockwiseCircular,
248        ))
249        .into(),
250        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
251            Some(Coordinates::new(
252                CoordinateNumber::try_from(3.75).unwrap(),
253                1,
254                cf,
255            )),
256            Some(CoordinateOffset::new(
257                CoordinateNumber::try_from(0.25).unwrap(),
258                0,
259                cf,
260            )),
261        )))
262        .into(),
263        FunctionCode::DCode(DCode::SelectAperture(16)).into(),
264        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
265            CoordinateNumber::try_from(3.4).unwrap(),
266            1,
267            cf,
268        )))))
269        .into(),
270        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
271            CoordinateNumber::try_from(3.5).unwrap(),
272            CoordinateNumber::try_from(0.9).unwrap(),
273            cf,
274        )))))
275        .into(),
276        FunctionCode::DCode(DCode::SelectAperture(10)).into(),
277        FunctionCode::GCode(GCode::RegionMode(true)).into(),
278        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
279            CoordinateNumber::try_from(0.5).unwrap(),
280            2,
281            cf,
282        )))))
283        .into(),
284        FunctionCode::GCode(GCode::InterpolationMode(InterpolationMode::Linear)).into(),
285        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
286            Some(Coordinates::at_y(
287                CoordinateNumber::try_from(3.75).unwrap(),
288                cf,
289            )),
290            None,
291        )))
292        .into(),
293        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
294            Some(Coordinates::at_x(
295                CoordinateNumber::try_from(3.75).unwrap(),
296                cf,
297            )),
298            None,
299        )))
300        .into(),
301        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
302            Some(Coordinates::at_y(2, cf)),
303            None,
304        )))
305        .into(),
306        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
307            Some(Coordinates::at_x(
308                CoordinateNumber::try_from(0.5).unwrap(),
309                cf,
310            )),
311            None,
312        )))
313        .into(),
314        FunctionCode::GCode(GCode::RegionMode(false)).into(),
315        FunctionCode::DCode(DCode::SelectAperture(18)).into(),
316        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
317            0,
318            CoordinateNumber::try_from(3.875).unwrap(),
319            cf,
320        )))))
321        .into(),
322        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
323            CoordinateNumber::try_from(3.875).unwrap(),
324            CoordinateNumber::try_from(3.875).unwrap(),
325            cf,
326        )))))
327        .into(),
328        ExtendedCode::LoadPolarity(Polarity::Clear).into(),
329        FunctionCode::GCode(GCode::RegionMode(true)).into(),
330        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
331            1,
332            CoordinateNumber::try_from(2.5).unwrap(),
333            cf,
334        )))))
335        .into(),
336        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
337            Some(Coordinates::at_y(3, cf)),
338            None,
339        )))
340        .into(),
341        FunctionCode::GCode(GCode::QuadrantMode(QuadrantMode::Single)).into(),
342        FunctionCode::GCode(GCode::InterpolationMode(
343            InterpolationMode::ClockwiseCircular,
344        ))
345        .into(),
346        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
347            Some(Coordinates::new(
348                CoordinateNumber::try_from(1.25).unwrap(),
349                CoordinateNumber::try_from(3.25).unwrap(),
350                cf,
351            )),
352            Some(CoordinateOffset::new(
353                CoordinateNumber::try_from(0.25).unwrap(),
354                0,
355                cf,
356            )),
357        )))
358        .into(),
359        FunctionCode::GCode(GCode::InterpolationMode(InterpolationMode::Linear)).into(),
360        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
361            Some(Coordinates::at_x(3, cf)),
362            None,
363        )))
364        .into(),
365        FunctionCode::GCode(GCode::QuadrantMode(QuadrantMode::Multi)).into(),
366        FunctionCode::GCode(GCode::InterpolationMode(
367            InterpolationMode::ClockwiseCircular,
368        ))
369        .into(),
370        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
371            Some(Coordinates::new(
372                3,
373                CoordinateNumber::try_from(2.5).unwrap(),
374                cf,
375            )),
376            Some(CoordinateOffset::new(
377                0,
378                CoordinateNumber::try_from(0.375).unwrap(),
379                cf,
380            )),
381        )))
382        .into(),
383        FunctionCode::GCode(GCode::InterpolationMode(InterpolationMode::Linear)).into(),
384        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
385            Some(Coordinates::at_x(1, cf)),
386            None,
387        )))
388        .into(),
389        FunctionCode::GCode(GCode::RegionMode(false)).into(),
390        ExtendedCode::LoadPolarity(Polarity::Dark).into(),
391        FunctionCode::DCode(DCode::SelectAperture(10)).into(),
392        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
393            CoordinateNumber::try_from(1.5).unwrap(),
394            CoordinateNumber::try_from(2.875).unwrap(),
395            cf,
396        )))))
397        .into(),
398        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
399            Some(Coordinates::at_x(2, cf)),
400            None,
401        )))
402        .into(),
403        FunctionCode::DCode(DCode::SelectAperture(11)).into(),
404        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
405            CoordinateNumber::try_from(1.5).unwrap(),
406            CoordinateNumber::try_from(2.875).unwrap(),
407            cf,
408        )))))
409        .into(),
410        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::at_x(
411            2, cf,
412        )))))
413        .into(),
414        FunctionCode::DCode(DCode::SelectAperture(19)).into(),
415        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
416            CoordinateNumber::try_from(2.875).unwrap(),
417            CoordinateNumber::try_from(2.875).unwrap(),
418            cf,
419        )))))
420        .into(),
421        ExtendedCode::FileAttribute(FileAttribute::Md5(
422            "6ab9e892830469cdff7e3e346331d404".to_string(),
423        ))
424        .into(),
425        FunctionCode::MCode(MCode::EndOfFile).into(),
426    ];
427    let mut stdout = stdout();
428    commands.serialize(&mut stdout).unwrap();
429}

Trait Implementations§

impl Clone for CoordinateFormat

fn clone(&self) -> CoordinateFormat

Returns a duplicate of the value. Read more

1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl Debug for CoordinateFormat

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

impl From<CoordinateFormat> for Command

fn from(val: CoordinateFormat) -> Self

Converts to this type from the input type.

impl From<CoordinateFormat> for ExtendedCode

fn from(val: CoordinateFormat) -> Self

Converts to this type from the input type.

impl PartialEq for CoordinateFormat

fn eq(&self, other: &CoordinateFormat) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for CoordinateFormat

impl Eq for CoordinateFormat

impl StructuralPartialEq for CoordinateFormat

Auto Trait Implementations§

impl Freeze for CoordinateFormat

impl RefUnwindSafe for CoordinateFormat

impl Send for CoordinateFormat

impl Sync for CoordinateFormat

impl Unpin for CoordinateFormat

impl UnwindSafe for CoordinateFormat

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> CloneToUninit for T
where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.