1 /*
2 * Copyright (c) 2022 Unionman Technology Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <string.h>
17 #include <stdlib.h>
18 #include <stdio.h>
19 #include <unistd.h>
20 #include "securec.h"
21 #include "hilog/log.h"
22 #include "um_pwm.h"
23
init_pmw(int pwmChannel)24 int init_pmw(int pwmChannel)
25 {
26 char pwm_file_name[128] = {0};
27 (void)memset_s(pwm_file_name, sizeof(pwm_file_name), 0, sizeof(pwm_file_name));
28
29 if (PWM1 == pwmChannel) {
30 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/export", PWM1_PEX);
31 } else if (PWM2 == pwmChannel) {
32 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/export", PWM2_PEX);
33 } else {
34 HILOG_ERROR(LOG_CORE, "PWM WRONOG CHANEEL\n");
35 return PWM_WRONOG_CHANNEL;
36 }
37
38 if (access(pwm_file_name, F_OK) != 0) {
39 HILOG_ERROR(LOG_CORE, "PWM EXPORT FILE NOT EXIST\n");
40 return PWM_FILE_NOT_EXIST;
41 }
42
43 FILE *fp = NULL;
44 fp = fopen(pwm_file_name, "w");
45 if (!fp) {
46 HILOG_ERROR(LOG_CORE, "Failed to open export file!");
47 return PWM_FILE_NOT_EXIST;
48 }
49 (void)fprintf(fp, "%d", 0);
50 (void)fclose(fp);
51 fp = NULL;
52 return 0;
53 }
54
set_pwm_period(int pwmChannel,int period)55 int set_pwm_period(int pwmChannel, int period)
56 {
57 char pwm_file_name[128] = {0};
58 (void)memset_s(pwm_file_name, sizeof(pwm_file_name), 0, sizeof(pwm_file_name));
59
60 if (PWM1 == pwmChannel) {
61 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/period", PWM1_PEX);
62 } else if (PWM2 == pwmChannel) {
63 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/period", PWM2_PEX);
64 } else {
65 HILOG_ERROR(LOG_CORE, "PWM WRONOG CHANEEL\n");
66 return PWM_WRONOG_CHANNEL;
67 }
68
69 if (access(pwm_file_name, F_OK) != 0) {
70 HILOG_ERROR(LOG_CORE, "PWM PERIOD FILE NOT EXIST\n");
71 return PWM_FILE_NOT_EXIST;
72 }
73
74 FILE *fp = NULL;
75 fp = fopen(pwm_file_name, "r+");
76 if (!fp) {
77 HILOG_ERROR(LOG_CORE, "Failed to open period file!");
78 return PWM_FILE_NOT_EXIST;
79 }
80 if (period) {
81 fprintf(fp, "%d", period);
82 }
83 (void)fclose(fp);
84 fp = NULL;
85
86 return 0;
87 }
88
set_pwm_dutyCycle(int pwmChannel,int dutyCycle)89 int set_pwm_dutyCycle(int pwmChannel, int dutyCycle)
90 {
91 char pwm_file_name[128] = {0};
92 (void)memset_s(pwm_file_name, sizeof(pwm_file_name), 0, sizeof(pwm_file_name));
93
94 if (PWM1 == pwmChannel) {
95 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/duty_cycle", PWM1_PEX);
96 } else if (PWM2 == pwmChannel) {
97 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/duty_cycle", PWM2_PEX);
98 } else {
99 HILOG_ERROR(LOG_CORE, "PWM WRONOG CHANEEL\n");
100 return PWM_WRONOG_CHANNEL;
101 }
102
103 if (access(pwm_file_name, F_OK) != 0) {
104 HILOG_ERROR(LOG_CORE, "PWM DUTY_CYCLE FILE NOT EXIST\n");
105 return PWM_FILE_NOT_EXIST;
106 }
107
108 FILE *fp = NULL;
109 fp = fopen(pwm_file_name, "r+");
110 if (!fp) {
111 HILOG_ERROR(LOG_CORE, "Failed to open duty_cycle file!");
112 return PWM_FILE_NOT_EXIST;
113 }
114 if (dutyCycle) {
115 fprintf(fp, "%d", dutyCycle);
116 }
117 (void)fclose(fp);
118 fp = NULL;
119
120 return 0;
121 }
122
set_pwm_polarity(int pwmChannel,int polarity)123 int set_pwm_polarity(int pwmChannel, int polarity)
124 {
125 char pwm_file_name[128] = {0};
126 (void)memset_s(pwm_file_name, sizeof(pwm_file_name), 0, sizeof(pwm_file_name));
127
128 if (PWM1 == pwmChannel) {
129 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/polarity", PWM1_PEX);
130 } else if (PWM2 == pwmChannel) {
131 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/polarity", PWM2_PEX);
132 } else {
133 HILOG_ERROR(LOG_CORE, "PWM WRONOG CHANEEL\n");
134 return PWM_WRONOG_CHANNEL;
135 }
136
137 if (access(pwm_file_name, F_OK) != 0) {
138 HILOG_ERROR(LOG_CORE, "PWM POKARITY FILE NOT EXIST\n");
139 return PWM_FILE_NOT_EXIST;
140 }
141
142 FILE *fp = NULL;
143 fp = fopen(pwm_file_name, "rw+");
144 if (!fp) {
145 HILOG_ERROR(LOG_CORE, "Failed to open polarity file!");
146 return PWM_FILE_NOT_EXIST;
147 }
148 if (polarity == PWM_POLARITY_NORMAL) {
149 fprintf(fp, "%s", "normal");
150 } else if (polarity == PWM_POLARITY_INVERSED) {
151 fprintf(fp, "%s", "inversed");
152 }
153 (void)fclose(fp);
154 fp = NULL;
155
156 return 0;
157 }
158
set_pwm_enable(int pwmChannel,int isEnable)159 int set_pwm_enable(int pwmChannel, int isEnable)
160 {
161 char buffer[256] = {0};
162 char pwm_file_name[128] = {0};
163 (void)memset_s(pwm_file_name, sizeof(pwm_file_name), 0, sizeof(pwm_file_name));
164
165 if (PWM1 == pwmChannel) {
166 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/enable", PWM1_PEX);
167 } else if (PWM2 == pwmChannel) {
168 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/enable", PWM2_PEX);
169 } else {
170 HILOG_ERROR(LOG_CORE, "PWM WRONOG CHANEEL\n");
171 return PWM_WRONOG_CHANNEL;
172 }
173
174 if (access(pwm_file_name, F_OK) != 0) {
175 HILOG_ERROR(LOG_CORE, "PWM ENABLE FILE NOT EXIST\n");
176 return PWM_FILE_NOT_EXIST;
177 }
178
179 (void)snprintf_s(buffer, sizeof(buffer), sizeof(buffer), "echo %d > %s", isEnable, pwm_file_name);
180 system(buffer);
181
182 return 0;
183 }
184
get_pwm_period(int pwmChannel)185 int get_pwm_period(int pwmChannel)
186 {
187 int ret = 0;
188 char pwm_file_name[128] = {0};
189 (void)memset_s(pwm_file_name, sizeof(pwm_file_name), 0, sizeof(pwm_file_name));
190
191 if (PWM1 == pwmChannel) {
192 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/period", PWM1_PEX);
193 } else if (PWM2 == pwmChannel) {
194 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/period", PWM2_PEX);
195 } else {
196 HILOG_ERROR(LOG_CORE, "PWM WRONOG CHANEEL\n");
197 return PWM_WRONOG_CHANNEL;
198 }
199
200 if (access(pwm_file_name, F_OK) != 0) {
201 HILOG_ERROR(LOG_CORE, "PWM PERIOD FILE NOT EXIST\n");
202 return PWM_FILE_NOT_EXIST;
203 }
204
205 FILE *fp = NULL;
206 char buffer[32] = {0};
207 (void)memset_s(buffer, sizeof(buffer), 0, sizeof(buffer));
208 fp = fopen(pwm_file_name, "r");
209 if (!fp) {
210 HILOG_ERROR(LOG_CORE, "Failed to open period file!");
211 return PWM_FILE_NOT_EXIST;
212 }
213 (void)fread(buffer, sizeof(buffer), 1, fp);
214 (void)fclose(fp);
215 fp = NULL;
216
217 ret = atoi(buffer);
218 return ret;
219 }
220
get_pwm_dutyCycle(int pwmChannel)221 int get_pwm_dutyCycle(int pwmChannel)
222 {
223 int ret = 0;
224 char pwm_file_name[128] = {0};
225 (void)memset_s(pwm_file_name, sizeof(pwm_file_name), 0, sizeof(pwm_file_name));
226 if (PWM1 == pwmChannel) {
227 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/duty_cycle", PWM1_PEX);
228 } else if (PWM2 == pwmChannel) {
229 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/duty_cycle", PWM2_PEX);
230 } else {
231 HILOG_ERROR(LOG_CORE, "PWM WRONOG CHANEEL\n");
232 return PWM_WRONOG_CHANNEL;
233 }
234
235 if (access(pwm_file_name, F_OK) != 0) {
236 HILOG_ERROR(LOG_CORE, "PWM DUTY_CYCLE FILE NOT EXIST\n");
237 return PWM_FILE_NOT_EXIST;
238 }
239
240 FILE *fp = NULL;
241 char buffer[32] = {0};
242 (void)memset_s(buffer, sizeof(buffer), 0, sizeof(buffer));
243 fp = fopen(pwm_file_name, "r");
244 if (!fp) {
245 HILOG_ERROR(LOG_CORE, "Failed to open duty_cycle file!");
246 return PWM_FILE_NOT_EXIST;
247 }
248 (void)fread(buffer, sizeof(buffer), 1, fp);
249 (void)fclose(fp);
250 fp = NULL;
251
252 ret = atoi(buffer);
253 return ret;
254 }
255
get_pwm_polarity(int pwmChannel)256 int get_pwm_polarity(int pwmChannel)
257 {
258 int ret = 0;
259 char pwm_file_name[128] = {0};
260 (void)memset_s(pwm_file_name, sizeof(pwm_file_name), 0, sizeof(pwm_file_name));
261
262 if (PWM1 == pwmChannel) {
263 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/polarity", PWM1_PEX);
264 } else if (PWM2 == pwmChannel) {
265 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/polarity", PWM2_PEX);
266 } else {
267 HILOG_ERROR(LOG_CORE, "PWM WRONOG CHANEEL\n");
268 return PWM_WRONOG_CHANNEL;
269 }
270
271 if (access(pwm_file_name, F_OK) != 0) {
272 HILOG_ERROR(LOG_CORE, "PWM POLARITY FILE NOT EXIST\n");
273 return PWM_FILE_NOT_EXIST;
274 }
275
276 FILE *fp = NULL;
277 char buffer[32] = {0};
278 (void)memset_s(buffer, sizeof(buffer), 0, sizeof(buffer));
279 fp = fopen(pwm_file_name, "r");
280 if (!fp) {
281 HILOG_ERROR(LOG_CORE, "Failed to open polarity file!");
282 return PWM_FILE_NOT_EXIST;
283 }
284 (void)fread(buffer, sizeof(buffer), 1, fp);
285 (void)fclose(fp);
286 fp = NULL;
287
288 if (strstr(buffer, "normal") != NULL) {
289 ret = PWM_POLARITY_NORMAL;
290 } else if (strstr(buffer, "inversed") != NULL) {
291 ret = PWM_POLARITY_INVERSED;
292 } else {
293 HILOG_ERROR(LOG_CORE, "PWM ERROR \n");
294 ret = PWM_ERR;
295 }
296
297 return ret;
298 }
299
is_pwm_enabled(int pwmChannel)300 int is_pwm_enabled(int pwmChannel)
301 {
302 int ret = 0;
303 char pwm_file_name[128] = {0};
304 (void)memset_s(pwm_file_name, sizeof(pwm_file_name), 0, sizeof(pwm_file_name));
305
306 if (PWM1 == pwmChannel) {
307 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/enable", PWM1_PEX);
308 } else if (PWM2 == pwmChannel) {
309 (void)sprintf_s(pwm_file_name, sizeof(pwm_file_name), "%s/pwm0/enable", PWM2_PEX);
310 } else {
311 HILOG_ERROR(LOG_CORE, "PWM WRONOG CHANEEL\n");
312 return PWM_WRONOG_CHANNEL;
313 }
314
315 if (access(pwm_file_name, F_OK) != 0) {
316 HILOG_ERROR(LOG_CORE, "PWM ENABLE FILE NOT EXIST\n");
317 return PWM_FILE_NOT_EXIST;
318 }
319
320 FILE *fp = NULL;
321 char buffer[32] = {0};
322 (void)memset_s(buffer, sizeof(buffer), 0, sizeof(buffer));
323 fp = fopen(pwm_file_name, "r");
324 if (!fp) {
325 HILOG_ERROR(LOG_CORE, "Failed to open enable file!");
326 return PWM_FILE_NOT_EXIST;
327 }
328 (void)fread(buffer, sizeof(buffer), 1, fp);
329 (void)fclose(fp);
330 fp = NULL;
331
332 ret = atoi(buffer);
333 return ret;
334 }