stm32f4xx_hal/fsmc_lcd/
display_interface_impl.rs

1use super::{Lcd, SubBank};
2
3macro_rules! impl_display_interface {
4    ($display_interface:ident) => {
5        impl<S> $display_interface::WriteOnlyDataCommand for Lcd<S, u16>
6        where
7            S: SubBank,
8        {
9            fn send_commands(
10                &mut self,
11                cmd: $display_interface::DataFormat<'_>,
12            ) -> Result<(), $display_interface::DisplayError> {
13                use $display_interface::DataFormat;
14                match cmd {
15                    DataFormat::U8(slice) => {
16                        for value in slice {
17                            self.write_command(u16::from(*value));
18                        }
19                    }
20                    DataFormat::U16(slice) => {
21                        for value in slice {
22                            self.write_command(*value);
23                        }
24                    }
25                    DataFormat::U16BE(slice) | DataFormat::U16LE(slice) => {
26                        // As long as the data bus is 16 bits wide, the byte order doesn't matter.
27                        for value in slice {
28                            self.write_command(*value);
29                        }
30                    }
31                    DataFormat::U8Iter(iter) => {
32                        for value in iter {
33                            self.write_command(u16::from(value));
34                        }
35                    }
36                    DataFormat::U16BEIter(iter) | DataFormat::U16LEIter(iter) => {
37                        // As long as the data bus is 16 bits wide, the byte order doesn't matter.
38                        for value in iter {
39                            self.write_command(value);
40                        }
41                    }
42                    _ => return Err($display_interface::DisplayError::DataFormatNotImplemented),
43                }
44                Ok(())
45            }
46
47            fn send_data(
48                &mut self,
49                buf: $display_interface::DataFormat<'_>,
50            ) -> Result<(), $display_interface::DisplayError> {
51                use $display_interface::DataFormat;
52                match buf {
53                    DataFormat::U8(slice) => {
54                        for value in slice {
55                            self.write_data(u16::from(*value));
56                        }
57                    }
58                    DataFormat::U16(slice) => {
59                        for value in slice {
60                            self.write_data(*value);
61                        }
62                    }
63                    DataFormat::U16BE(slice) | DataFormat::U16LE(slice) => {
64                        // As long as the data bus is 16 bits wide, the byte order doesn't matter.
65                        for value in slice {
66                            self.write_data(*value);
67                        }
68                    }
69                    DataFormat::U8Iter(iter) => {
70                        for value in iter {
71                            self.write_data(u16::from(value));
72                        }
73                    }
74                    DataFormat::U16BEIter(iter) | DataFormat::U16LEIter(iter) => {
75                        // As long as the data bus is 16 bits wide, the byte order doesn't matter.
76                        for value in iter {
77                            self.write_data(value);
78                        }
79                    }
80                    _ => return Err($display_interface::DisplayError::DataFormatNotImplemented),
81                }
82                Ok(())
83            }
84        }
85    };
86}
87
88macro_rules! impl_display_interface_u8 {
89    ($display_interface:ident) => {
90        impl<S> $display_interface::WriteOnlyDataCommand for Lcd<S, u8>
91        where
92            S: SubBank,
93        {
94            fn send_commands(
95                &mut self,
96                cmd: $display_interface::DataFormat<'_>,
97            ) -> Result<(), $display_interface::DisplayError> {
98                use $display_interface::DataFormat;
99                match cmd {
100                    DataFormat::U8(slice) => {
101                        for value in slice {
102                            self.write_command(*value);
103                        }
104                    }
105                    DataFormat::U16(slice) => {
106                        for value in slice {
107                            let bytes = value.to_ne_bytes();
108                            self.write_command(bytes[0]);
109                            self.write_command(bytes[1]);
110                        }
111                    }
112                    DataFormat::U16BE(slice) => {
113                        for value in slice {
114                            let bytes = value.to_be_bytes();
115                            self.write_command(bytes[0]);
116                            self.write_command(bytes[1]);
117                        }
118                    }
119                    DataFormat::U16LE(slice) => {
120                        for value in slice {
121                            let bytes = value.to_le_bytes();
122                            self.write_command(bytes[0]);
123                            self.write_command(bytes[1]);
124                        }
125                    }
126                    DataFormat::U8Iter(iter) => {
127                        for value in iter {
128                            self.write_command(value);
129                        }
130                    }
131                    DataFormat::U16BEIter(iter) => {
132                        for value in iter {
133                            let bytes = value.to_be_bytes();
134                            self.write_command(bytes[0]);
135                            self.write_command(bytes[1]);
136                        }
137                    }
138                    DataFormat::U16LEIter(iter) => {
139                        for value in iter {
140                            let bytes = value.to_le_bytes();
141                            self.write_command(bytes[0]);
142                            self.write_command(bytes[1]);
143                        }
144                    }
145                    _ => return Err($display_interface::DisplayError::DataFormatNotImplemented),
146                }
147                Ok(())
148            }
149
150            fn send_data(
151                &mut self,
152                buf: $display_interface::DataFormat<'_>,
153            ) -> Result<(), $display_interface::DisplayError> {
154                use $display_interface::DataFormat;
155                match buf {
156                    DataFormat::U8(slice) => {
157                        for value in slice {
158                            self.write_data(*value);
159                        }
160                    }
161                    DataFormat::U8Iter(iter) => {
162                        for value in iter {
163                            self.write_data(value);
164                        }
165                    }
166                    DataFormat::U16(slice) => {
167                        for value in slice {
168                            let bytes = value.to_ne_bytes();
169                            self.write_data(bytes[0]);
170                            self.write_data(bytes[1]);
171                        }
172                    }
173                    DataFormat::U16BE(slice) => {
174                        for value in slice {
175                            let bytes = value.to_be_bytes();
176                            self.write_data(bytes[0]);
177                            self.write_data(bytes[1]);
178                        }
179                    }
180                    DataFormat::U16LE(slice) => {
181                        for value in slice {
182                            let bytes = value.to_le_bytes();
183                            self.write_data(bytes[0]);
184                            self.write_data(bytes[1]);
185                        }
186                    }
187                    DataFormat::U16BEIter(iter) => {
188                        for value in iter {
189                            let bytes = value.to_be_bytes();
190                            self.write_data(bytes[0]);
191                            self.write_data(bytes[1]);
192                        }
193                    }
194                    DataFormat::U16LEIter(iter) => {
195                        for value in iter {
196                            let bytes = value.to_le_bytes();
197                            self.write_data(bytes[0]);
198                            self.write_data(bytes[1]);
199                        }
200                    }
201                    _ => return Err($display_interface::DisplayError::DataFormatNotImplemented),
202                }
203                Ok(())
204            }
205        }
206    };
207}
208
209impl_display_interface!(display_interface);
210impl_display_interface!(display_interface_04);
211impl_display_interface_u8!(display_interface);
212impl_display_interface_u8!(display_interface_04);
stm32f4xx_hal/fsmc_lcd/display_interface_impl.rs

stm32f4xx_hal/fsmc_lcd/
display_interface_impl.rs
