Skip to main content

wait() example

0 likes • Nov 19, 2022 • 0 views
C
Loading...

More C Posts

Arduino Sound Demo

0 likes • Jan 4, 2022 • 1 view
C
//Leif Messinger
const int BUZZER_PIN = 8;
const int BUTTON_PIN = 2;
const int BUTTON_PINMODE = INPUT_PULLUP;
#define DEBOUNCE_DELAY 50
class Button{
private:
short buttonPin;
bool buttonState;
bool lastButtonState;
int lastDebounceTime;
public:
Button(short buttonPin): buttonState(HIGH), lastButtonState(LOW), lastDebounceTime(millis()){
this->buttonPin = buttonPin;
}
bool checkForPress(const bool desiredState){ //Returns true if button pressed
bool reading = (bool)digitalRead(buttonPin);
// check to see if you just pressed the button
// (i.e. the input went from LOW to HIGH), and you've waited long enough
// since the last press to ignore any noise:
// If the switch changed, due to noise or pressing:
if (reading != lastButtonState) {
// reset the debouncing timer
lastDebounceTime = millis();
}else if ((millis() - lastDebounceTime) > DEBOUNCE_DELAY) {
// whatever the reading is at, it's been there for longer than the debounce
// delay, so take it as the actual current state:
// if the button state has changed:
if (reading != buttonState) {
buttonState = reading;
// only toggle the LED if the new button state is HIGH
if (buttonState == desiredState) {
return true;
}
}
}
// save the reading. Next time through the loop, it'll be the lastButtonState:
lastButtonState = reading;
return false;
}
void waitForPress(const bool desiredState){
while(!checkForPress(desiredState));
}
};
class Note{
public:
short frequency; //Short max is ~ 30k, so way higher than you can hear
short lag; //Also 30k ms is 30 seconds
float sustainPercentage;
};
const short normalBeatLength = 500;
const short wholeNote = 4*normalBeatLength;
const short halfNote = 2*normalBeatLength;
const short dottedQuarterNote = normalBeatLength + (normalBeatLength / 2);
const short quarterNote = normalBeatLength;
const short dottedEighthNote = ((3 * normalBeatLength) / 4);
const short eighthNote = normalBeatLength/ 2;
const short sixteenthNote = normalBeatLength / 4;
const float normalSustainLength = .25;
void beep(const Note& note){ //It might go terribly wrong if you try to beep two tones at the same time.
tone(BUZZER_PIN, note.frequency);
delay(note.lag * note.sustainPercentage);
noTone(BUZZER_PIN);
delay(note.lag * (1.0 - note.sustainPercentage));
}
Note song[] = {
{(int)523.25, halfNote, normalSustainLength},
{(int)392, eighthNote, normalSustainLength},
{(int)523.25, quarterNote, normalSustainLength},
{(int)392, dottedEighthNote, normalSustainLength},
{(int)440.00, sixteenthNote, normalSustainLength},
{(int)493.88, quarterNote, normalSustainLength},
{(int)329.63, eighthNote, normalSustainLength},
{(int)329.63, eighthNote, normalSustainLength},
{(int)440.00, quarterNote, normalSustainLength},
{(int)392, dottedEighthNote, normalSustainLength},
{(int)349.23, sixteenthNote, normalSustainLength},
{(int)392, quarterNote, normalSustainLength},
{(int)261.63, dottedEighthNote, normalSustainLength},
{(int)261.63, sixteenthNote, normalSustainLength},
{(int)293.66, quarterNote, normalSustainLength},
{(int)293.66, dottedEighthNote, normalSustainLength},
{(int)329.63, sixteenthNote, normalSustainLength},
{(int)349.23, quarterNote, normalSustainLength},
{(int)349.23, dottedEighthNote, normalSustainLength},
{(int)392.00, sixteenthNote, normalSustainLength},
{(int)440.00, quarterNote, normalSustainLength},
{(int)493.88, eighthNote, normalSustainLength},
{(int)523.25, eighthNote, normalSustainLength},
{(int)587.33, dottedQuarterNote, normalSustainLength},
{(int)392, eighthNote, normalSustainLength},
{(int)659.25, quarterNote, normalSustainLength},
{(int)587.33, dottedEighthNote, normalSustainLength},
{(int)523.25, sixteenthNote, normalSustainLength},
{(int)587.33, quarterNote, normalSustainLength},
{(int)493.88, eighthNote, normalSustainLength},
{(int)392, eighthNote, normalSustainLength},
{(int)523.25, quarterNote, normalSustainLength},
{(int)493.88, dottedEighthNote, normalSustainLength},
{(int)440.00, sixteenthNote, normalSustainLength},
{(int)493.88, quarterNote, normalSustainLength},
{(int)329.63, eighthNote, normalSustainLength},
{(int)329.63, eighthNote, normalSustainLength},
{(int)440.00, quarterNote, normalSustainLength},
{(int)392, dottedEighthNote, normalSustainLength},
{(int)349.23, sixteenthNote, normalSustainLength},
{(int)392, quarterNote, normalSustainLength},
{(int)261.63, dottedEighthNote, normalSustainLength},
{(int)261.63, sixteenthNote, normalSustainLength},
{(int)523.25, quarterNote, normalSustainLength},
{(int)493.88, dottedEighthNote, normalSustainLength},
{(int)440.00, sixteenthNote, normalSustainLength},
{(int)392.00, halfNote, normalSustainLength * .5},
};
size_t songLength = (sizeof(song) / sizeof(Note));
void playSong(){
for(size_t pos = 0; pos < songLength; ++pos){
const Note& bruh = song[pos];
beep(bruh);
}
}
void setup() {
const int BUZZER_PIN = 8;
pinMode(BUZZER_PIN, OUTPUT);
pinMode(BUTTON_PIN, BUTTON_PINMODE);
playSong();
}
Button button(BUTTON_PIN);
void loop() {
button.waitForPress(LOW);
// read the state of the switch into a local variable:
playSong();
}

signal() example

0 likes • Nov 19, 2022 • 0 views
C
#include <stdio.h>
#include <assert.h>
#include <signal.h>
void myHandler(int iSig) {
printf("In myHandler with argument %d\n", iSig);
}
int main() {
void( * pfRet)(int) = signal(SIGINT, myHandler);
assert(pfRet != SIG_ERR);
printf("Entering an infinite loop\n");
while (1) {
printf(".");
}
return 0; // use CTRL+\ to exit
}

replaceString

0 likes • Nov 14, 2021 • 0 views
C
//===============replaceString.c===============
#include "replaceString.h"
//Normally I'd make a replaceStringMalloc to return a malloced string or a replaceStringMut to change the original string, but I'm not satisfied with those function names so it's best just to do to = (char*)malloc(replaceStringLength(from, replace, replacement)); replaceString(to, from, replace, replacement);
//If this was c++, I'd have no problem just overloading replaceString
//Returns the length of the resulting string (minus the null char)
size_t replaceStringLength(const char* from, const char* replace, const char* replacement){
size_t fromLength = strlen(from);
size_t replaceLength = strlen(replace);
size_t replacementLength = strlen(replacement);
size_t fromEndIt = 0;
size_t toLength = 0;
while(fromEndIt < fromLength){
int replaceIt = 0;
while(replaceIt < replaceLength && (fromEndIt+replaceIt) < fromLength && from[fromEndIt + replaceIt] == replace[replaceIt]){
++replaceIt;
}
if(replaceIt == replaceLength){
//Update from buffer iterator positions
toLength += (fromEndIt + replacementLength);
from += (fromEndIt + replaceLength);
fromEndIt = 0;
continue;
}
++fromEndIt;
}
toLength += fromEndIt;
return toLength;
}
//Baller replaceString by Leif Messinger
//Needs null terminated from, replace, and replacement strings as well as a large block of memory to store the result.
void replaceString(char* to, const char* from, const char* replace, const char* replacement){
size_t fromLength = strlen(from);
size_t replaceLength = strlen(replace);
size_t replacementLength = strlen(replacement);
size_t fromEndIt = 0;
while(fromEndIt < fromLength){
int replaceIt = 0;
while(replaceIt < replaceLength && (fromEndIt+replaceIt) < fromLength && from[fromEndIt + replaceIt] == replace[replaceIt]){
++replaceIt;
}
if(replaceIt == replaceLength){
//Copy the string before the matched bit
memcpyToAndShiftPointers(to, from, fromEndIt);
//Copy the replacement too
memcpyToAndShiftPointer(to, replacement, replacementLength);
//Update from buffer iterator positions
from += replaceLength;
fromEndIt = 0;
continue; //I don't want this thing to get incremented again
}
++fromEndIt;
}
//Copy the rest of the unmatched string
memcpyToAndShiftPointer(to, from, fromEndIt);
to[0] = '\0'; //Should work
}
//===============replaceString.h===============
#ifndef REPLACE_STRING_H
#define REPLACE_STRING_H
#include <string.h>
#define memcpyToAndShiftPointer(to,from,n); memcpy((to),(from),(n)); (to) += (n);
#define memcpyToAndShiftPointers(to,from,n); memcpy((to),(from),(n)); (to) += (n); (from) += n;
//Normally I'd make a replaceStringMalloc to return a malloced string or a replaceStringMut to change the original string, but I'm not satisfied with those function names so it's best just to do to = (char*)malloc(replaceStringLength(from, replace, replacement)); replaceString(to, from, replace, replacement);
//If this was c++, I'd have no problem just overloading replaceString
//Returns the length of the resulting string (minus the null char)
size_t replaceStringLength(const char* from, const char* replace, const char* replacement);
//Baller replaceString by Leif Messinger
//Needs null terminated from, replace, and replacement strings as well as a large block of memory to store the result.
void replaceString(char* to, const char* from, const char* replace, const char* replacement);
#endif
//===============replaceStringMain.c===============
#include <stdio.h>
#include <stdlib.h>
#include "replaceString.h"
#define BUFFER_SIZE (1<<21) //About a mebibyte
//There could be matches between buffers, so make sure the buffer size you set it to is good enough for your application. Basically as big as your input.
//Replaces strings from sdtin, then outputs it to stdout
//./a.out [[replace], [replacement]]...
int main(int argc, char** argv){
char* buffer1 = (char*) malloc(BUFFER_SIZE);
char* buffer2 = (char*) malloc(BUFFER_SIZE);
if(buffer1 == NULL || buffer2 == NULL){
perror("You need a couple MBs of ram my boy");
return 1;
}
while(!feof(stdin)){
fread(buffer1, BUFFER_SIZE, 1, stdin);
char* activeBuffer = buffer1;
char* inactiveBuffer = buffer2;
char* tmp;
for(size_t i = 1; (i + 1) < argc; i += 2){
//puts(activeBuffer);
replaceString(inactiveBuffer, activeBuffer, argv[i], argv[i+1]);
//Swap buffers
tmp = activeBuffer;
activeBuffer = inactiveBuffer;
inactiveBuffer = tmp;
}
fputs(activeBuffer, stdout);
}
free(buffer1);
free(buffer2);
return 0;
}

execlp() example

0 likes • Nov 19, 2022 • 0 views
C
#include <stdio.h>
#include <unistd.h>
int main() {
char * cmd[] = {
"who",
"ls",
"date"
};
int i;
printf("0=who 1=ls 2=date : ");
scanf("%d", & i);
execlp(cmd[i], cmd[i], (char * ) 0);
printf("execlp failed\n");
return 0;
}

socketUDPServer.c

0 likes • Aug 5, 2023 • 3 views
C
// Server side implementation of UDP client-server model
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#define PORT 8008
#define RECIEVE_BUFFER_SIZE 1024
const char* responseMessage = "Hello from server";
// Driver code
int main() {
//Create a UDP socket
//int socket(int domain, int type, int protocol);
//Domain is the place where the data goes. AF_BLUETOOTH, AF_INET6, AF_UNIX is local communication between different programs
//Type is the type of connection, so connection based (TCP), connectionless (UDP) or somewhere in between or beyond
//Protocol is an enum or flags that give some more options specific to that type. For SOCK_STREAM, you can force it to use SCTP instead of TCP. For SOCK_RAW, it can give you control over the ip frame, and even the ethernet frame.
//So this function makes a file descriptor to an IPV4 UDP 'connection' with no options.
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
// Creating socket file descriptor
if ( sockfd < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
struct sockaddr_in serverAddress;
memset(&serverAddress, 0, sizeof(serverAddress));
// Filling server information
serverAddress.sin_family = AF_INET; // IPv4
serverAddress.sin_addr.s_addr = INADDR_ANY;
serverAddress.sin_port = htons(PORT);
// Bind the socket with the server address
if(bind(sockfd, (const struct sockaddr*)&serverAddress, sizeof(serverAddress))){ //Bind returns 0 if succeeded, or -1 if failed. -1 is still true.
perror("bind failed");
exit(EXIT_FAILURE);
}
struct sockaddr_in clientAddress; unsigned int clientAddressSize = sizeof(clientAddress);
memset(&clientAddress, 0, clientAddressSize);
char buffer[RECIEVE_BUFFER_SIZE];
int bytesRecieved = recvfrom(sockfd, (char*)buffer, RECIEVE_BUFFER_SIZE, MSG_WAITALL, (struct sockaddr*) &clientAddress, &clientAddressSize); //sets clientAddress to the client's address and the new size
buffer[bytesRecieved] = '\0';
printf("Client : %s\n", buffer);
sendto(sockfd, (const char*)responseMessage, strlen(responseMessage), MSG_CONFIRM, (const struct sockaddr*) &clientAddress, clientAddressSize);
printf("Hello message sent.\n");
return 0;
}

pipe() example

0 likes • Nov 19, 2022 • 0 views
C
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#define READ 0 /* The index of the read end of the pipe */
#define WRITE 1 /* The index of the write end of the pipe */
char * phrase = "This goes in the pipe";
int main() {
int fd[2], bytesRead;
char message[100]; /* Parent process' message buffer */
pipe(fd); /* Create unnamed pipe */
if (fork() == 0) /* Child, writer */ {
close(fd[READ]); /* Close unused end */
write(fd[WRITE], phrase, strlen(phrase) + 1); /* Include NULL */
close(fd[WRITE]); /* Close used end */
} else /* Parent, reader */ {
close(fd[WRITE]); /* Close unused end */
bytesRead = read(fd[READ], message, 100);
printf("Parent just read %i bytes: %s\n", bytesRead, message);
close(fd[READ]); /* Close used end */
}
}