owl_patch 0.8.0

Rust SDK for Rebel Technology Owl2/3 devices
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#include "SmoothValue.h"
#include "basicmaths.h"

template<>
SmoothFloat::SmoothValue()
  : value(0.0), lambda(0.9) {}

template<>
SmoothFloat::SmoothValue(float l)
  : value(0.0), lambda(l) {}

template<>
SmoothFloat::SmoothValue(float l, float initialValue)
  : value(initialValue), lambda(l) {}

template<>
SmoothInt::SmoothValue(int divider)
  : value(0), lambda(divider) {
// lambda = 1 - 1/divider
// divider 4:0.75, 5:0.8, 6:0.833, 7:0.857, 8:0.875, 9:0.888, 10:0.9 et c
}

template<>
SmoothInt::SmoothValue(int divider, int initialValue) 
  : value(initialValue), lambda(divider) {}

template<>
void SmoothFloat::update(float newValue){
  value = value*lambda + newValue*(1.0f - lambda);
}

template<>
void SmoothInt::update(int newValue){
  value = (value*lambda + newValue)/(lambda+1);
}

template<>
void SmoothStiffFloat::update(float newValue){
  if(abs(value-newValue) >= delta)
    value = value*lambda + newValue*(1.0f - lambda);
}

template<>
void SmoothStiffInt::update(int newValue){
  if(abs(value-newValue) >= delta)
    value = (value*lambda + newValue)/(lambda+1);
}

template<>
float SmoothValue<float>::normal(float lambda, int blocksize){
  return lambda*128.0f/blocksize;
}

template<>
int SmoothValue<int>::normal(float lambda, int blocksize){
  return (1.0f/(1.0-lambda))*128.0f/blocksize;
}

template<>
float StiffValue<float>::normal(float delta){
  return delta;
}

template<>
int StiffValue<int>::normal(float delta){
  return delta;
}

template class SmoothValue<int>;
template class SmoothValue<float>;
template class SmoothStiffValue<int>;
template class SmoothStiffValue<float>;