This version of the program allows a variable number of parameters:
#define _DEFAULT_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <fcntl.h>
#include <time.h>
#include <stdarg.h>
FILE *doCommand(char *cmd)
{
FILE *fp = popen(cmd, "r");
if (fp == NULL)
{
printf("Failed to run command %s \n\r", cmd);
exit(1);
}
return fp;
}
void checkPWM()
{
FILE *fd = doCommand("sudo dtparam -l");
char output[1024];
int txfound = 0;
char indicator[] = "pwm-2chan";
char command[] = "sudo dtoverlay pwm-2chan";
while (fgets(output, sizeof(output), fd) != NULL)
{
printf("%s\n\r", output);
fflush(stdout);
if (strstr(output, indicator) != NULL)
{
txfound = 1;
}
}
if (txfound == 0)
{
pclose(fd);
fd = doCommand(command);
}
pclose(fd);
}
enum pwm
{
OpenChan,
SetFreq,
SetDuty,
EnableChan,
DisableChan,
CloseChan,
InvertChan
};
int pwmAction(enum pwm action, int chan, ...)
{
static int fdf[2];
static int fdd[2];
int fd;
int param;
char buf[150];
char schan[2];
va_list params;
int status;
int L;
if (chan != 0 && chan != 1)
return -1;
snprintf(schan, 2, "%d", chan);
switch (action)
{
case OpenChan:
checkPWM();
fd = open("/sys/class/pwm/pwmchip0/export", O_WRONLY);
if (fd < 0)
printf("failed to open PWM Chip");
write(fd, schan, 1);
close(fd);
sleep(3);
snprintf(buf, 150, "%s%s%s", "/sys/class/pwm/pwmchip0/pwm",schan, "/period");
fdf[chan] = open(buf, O_WRONLY);
if (fdf < 0)
printf("failed to open period");
snprintf(buf, 150, "%s%s%s", "/sys/class/pwm/pwmchip0/pwm",schan, "/duty_cycle");
fdd[chan] = open(buf, O_WRONLY);
if (fdd < 0)
printf("failed to open duty");
break;
case SetFreq:
va_start(params, chan);
param = va_arg(params, int);
L = snprintf(buf, 150, "%d", param);
write(fdf[chan], buf, L);
break;
case SetDuty:
va_start(params, chan);
param = va_arg(params, int);
L = snprintf(buf, 150, "%d", param);
write(fdd[chan], buf, L);
break;
return 0;
case EnableChan:
snprintf(buf, 150, "%s%s%s", "/sys/class/pwm/pwmchip0/pwm", schan, "/enable");
fd = open(buf, O_WRONLY);
if (fd < 0)
printf("failed to open enable");
write(fd, "1", 1);
close(fd);
break;
case DisableChan:
snprintf(buf, 150, "%s%s%s", "/sys/class/pwm/pwmchip0/pwm",schan, "/enable");
fd = open(buf, O_WRONLY);
write(fd, "0", 1);
close(fd);
break;
case CloseChan:
close(fdf[chan]);
close(fdd[chan]);
fd = open("/sys/class/pwm/pwmchip0/unexport", O_WRONLY);
write(fd, schan, 1);
close(fd);
break;
case InvertChan:
va_start(params, chan);
param = va_arg(params, int);
snprintf(buf, 150, "%s%s%s", "/sys/class/pwm/pwmchip0/pwm",schan, "/polarity");
fd = open(buf, O_WRONLY);
if (param == 0)
{
L = snprintf(buf, 150, "%s", "normal");
write(fd, buf, L);
}
if (param == 1)
{
L = snprintf(buf, 150, "%s", "inversed");
write(fd, buf, L);
}
close(fd);
break;
}
return 0;
}
int main(int argc, char **argv)
{
pwmAction(OpenChan, 0);
struct timespec delay = {0, 6667 * 2};
int t = 20 * 1000000;
pwmAction(SetFreq, 0, t);
int d1 = t * 2.5 / 100;
int d2 = t * 12 / 100;
pwmAction(InvertChan,0,1);
pwmAction(EnableChan, 0);
for (;;)
{
pwmAction(SetDuty, 0, d1);
sleep(1);
pwmAction(SetDuty, 0, d2);
sleep(1);
}
}
Summary
Italics indicates not covered in this extract
PWM, Pulse Width Modulation, has a fixed repetition rate but a variable duty cycle, i.e. the amount of time the signal is high or low changes.
PWM can be generated by software simply by changing the state of a GPIO line correctly, but it can also be generated in hardware, so relieving the processor of some work.
Hardware PWM can generate high speed pulses, but how quickly you can change the duty cycle is still software-limited.
All versions of the Pi have two hardware PWM channels which can be used and configured using Linux drivers.
The PWM drivers do not provide control over the PWM clock frequency which determines how accurately you can set the duty cycle.
A typical use of PWM is to control a servo and this only requires a PWM frequency of 50Hz. The position of the servo depends on the duty cycle.
You can easily invert the sense of the PWM signal, which is useful when the device is being driven by a single transistor.
As well as being a way of signaling, PWM can also be used to vary the amount of power or voltage transferred. The higher the duty cycle, the more power/voltage.
In the same way, by varying the duty cycle, you can dim an LED. As the brightness of an LED is not linear with applied voltage, you have to modify the output using a cubic law to get linear changes in brightness.
Are you ready for Thanksgiving, when overeating remorse and a surfeit of being thankful causes the unsettling thought that there are only four weeks till the Xmas break? So here is a mix of weird [ ... ]
Lightbend, the company that developed Akka, has announced Akka 3, and has changed its name to Akka. The company produces cloud-native microservices frameworks, and Akka is used for building distribute [ ... ]
