#c-lang

Fixed it! It took a while to figure out exactly how lightmapper.h works and pass over my geometry in a way it expects it. Now the whole mapping process can be done using just the editor without needing to convert shit around between Trenchbroom and Blender.

Alright guys, so for several weeks I have been studying rust, playing with it,trying to make meaningful programs using the keypoints of the language. what do I mean by that

zero-cost abstractions

move semantics

guaranteed memory safety

threads without data races

trait-based generics

pattern matching

type inference

minimal runtime

efficient C bindings

The highlights of the language are more wordy than I like(I enjoy understanding text without frying my brain to read at a college level). so ill break some of this down. Zero-cost abstration: This is the idea in Rust, that you can implement and use interfaces without lowering performance(basically). Move semantics: This is probably my second favorite thing about rust, This is the act of moving variables between functions and different scopes, by transferring ownership or borrowing , and when the variable exits scope, it will be disposed of in memory. ( you can google ownership and borrowing , i dont want this post to drag on). Guaranteed memory safety: RUST WILL NOT LET YOU RUN A PROGRAM THAT IS NOT MEMORY SAFE. the language and compiler forces you to write safe code. this is the sole reason for rusts existence. The last few keypoints are something that can be explained quickly through google searches, and in my point are not that important ( except traits, but those are basically interfaces, and threading is important but not for the scope of this post). Now to the good stuff. Is Rust Worth it. If you are coming from a c/c++ background( or have taken some classes on it) then you know about pointers, references, and how fun they can be [sarcasm]. Rust makes using pointers simple, and easy, and the compiler will not let you use a pointer incorrectly or unsafely(unless specified, but dont do that if you dont have to). By using the "move semantics" you pass everything a function needs /safely/.That is the big deal about Rust, being able to do everything safely, and not having to worry about seg-faults or other random errors. Now, other than the safety nets, the language does offer zero-cost abstraction, so you can do interfacing and other abstractions safely, and without slowing performance. That is it. That is all the language has offered to me in the past months. It can do everything C can do. It can do it SAFER though. But, if you program in C or C++ you know there are safe ways to do things, so if you actively try to be safe, you will be safe. Rust is for the people that arent actively trying or do not know what is unsafe about their code. Rust is a C safety-net, with some nice things added to the language, like UTF-8 encoding by default, disposing of unneeded variables and memory for you (THIS IS A BIG HELP DO NOT GET ME WRONG), and faster interfacing. But does that make Rust worth it? Yes and no. Yes because you can make sure you are safe, and you can make sure your programs are efficient. Rust can also be compiled to a shared object ( dynamic library) and be used by C with extern functions ( THAT ARE SAFE), and the language is fast, just as fast as C from what I have come to understand(i could be wrong). No because C can do everything Rust can as long as you are safe about your code, and check and try it over and over again with testing. C also has rich libraries developed for things that rust doesnt( YET, libraries are constantly being developed and ported to rust). For instand http is really hard with Rust right now. OpenGL is kind of hard ( though the game engines i have tried are nice with rust.) And finally, it is a little confusing as to how to interop rust with other languages at times, it took me 2 weeks before I was able to use it with C( it was because I am stupid and did not know you can just gcc main.c and rust.so).So as long as you are safe with C, you are just as good as if you were to use rust.

/* PID Library Copyright @2013 vidieukhien.net forum */ #ifndef _PID_H_ #define _PID_H_ #include <stdint.h> #define PID_DIRECT 0 #define PID_REVERSE 1 typedef struct { double kp; double ki; double kd; double *input; double *output; double *setPoint; double outMin; double outMax; double lastInput; double lastProcessValue; double sampleTime; } PID; void PID_Init(PID *pid, double *input, double *output, double *setPoint, double kp, double ki, double kd, double sampleTimeMs, uint8_t direction); void PID_SetOutputLimits(PID *pid, double min, double max); void PID_Compute(PID *pid); void PID_SetTunings(PID *pid, double kp, double ki, double kd, uint8_t direction); #endif

file pid.c

/* PID Library Copyright @2013 vidieukhien.net forum */ #include "pid.h" void PID_SetOutputLimits(PID *pid, double min, double max) { pid->outMin = min; pid->outMax = max; if(pid->lastProcessValue < min) pid->lastProcessValue = min; if(pid->lastProcessValue > max) pid->lastProcessValue = max; if(*pid->output < min) *pid->output = min; if(*pid->output > max) *pid->output = max; } void PID_SetTunings(PID *pid, double kp, double ki, double kd, uint8_t direction) { float sampleTimeInSec = pid->sampleTime/1000.0; pid->kp = kp; pid->ki = ki * sampleTimeInSec; pid->kd = kd / sampleTimeInSec; if(direction == PID_REVERSE) { pid->kp = -pid->kp; pid->ki = -pid->ki; pid->kd = -pid->kd; } } void PID_Init(PID *pid, double *input, double *output, double *setPoint, double kp, double ki, double kd, double sampleTimeMs, uint8_t direction) { pid->input = input; pid->output = output; pid->setPoint = setPoint; pid->lastInput = *input; pid->lastProcessValue = *output; pid->sampleTime = sampleTimeMs; PID_SetTunings(pid, kp, ki, kd, direction); PID_SetOutputLimits(pid, 100, 1000); } void PID_Compute(PID *pid) { double input, error, dinput, output; input = *pid->input; error = *pid->setPoint - input; pid->lastProcessValue += (pid->ki * error); if(pid->lastProcessValue > pid->outMax) pid->lastProcessValue = pid->outMax; if(pid->lastProcessValue < pid->outMin) pid->lastProcessValue = pid->outMin; dinput = input - pid->lastInput; output = pid->kp * error + pid->lastProcessValue - pid->kd * dinput; if(output > pid->outMax) output = pid->outMax; if(output < pid->outMin) output = pid->outMin; *pid->output = output; pid->lastInput = input; }

Ví dụ sử dụng:

/*app examle */ #include "pid.h" PID pid; double vInput, vSetpoint, pwmOutput; double kp = 3, ki = 7, kd = 0.1, sampleTime = 100; /* initilize pid in initilization function */ void APP_Init() { vInput = SENSOR_Read(); vSetpoint = 30; /*Set voltage at 30V*/ PID_Init(&pid, &vInput, &pwmOutput, &vSetpoint, kp, ki, kd, sampleTime, PID_REVERSE); } /*Call every sample time (in milisecond)*/ void TaskEvery100ms() { //Read sensor to vInput vInput = SENSOR_Read(); //Calculate PID PID_Compute(&pid); //Set PWM duty PWM_SetDuty(pwmOutput); } void APP_SetVref(double volt) { vSetpoint = volt; }

Demo: