/** * @file lv_math.c * */ /********************* * INCLUDES *********************/ #include "lv_math.h" /********************* * DEFINES *********************/ /********************** * TYPEDEFS **********************/ /********************** * STATIC PROTOTYPES **********************/ /********************** * STATIC VARIABLES **********************/ static const int16_t sin0_90_table[] = { 0, 572, 1144, 1715, 2286, 2856, 3425, 3993, 4560, 5126, 5690, 6252, 6813, 7371, 7927, 8481, 9032, 9580, 10126, 10668, 11207, 11743, 12275, 12803, 13328, 13848, 14364, 14876, 15383, 15886, 16383, 16876, 17364, 17846, 18323, 18794, 19260, 19720, 20173, 20621, 21062, 21497, 21925, 22347, 22762, 23170, 23571, 23964, 24351, 24730, 25101, 25465, 25821, 26169, 26509, 26841, 27165, 27481, 27788, 28087, 28377, 28659, 28932, 29196, 29451, 29697, 29934, 30162, 30381, 30591, 30791, 30982, 31163, 31335, 31498, 31650, 31794, 31927, 32051, 32165, 32269, 32364, 32448, 32523, 32587, 32642, 32687, 32722, 32747, 32762, 32767 }; /********************** * MACROS **********************/ /********************** * GLOBAL FUNCTIONS **********************/ /** * Return with sinus of an angle * @param angle * @return sinus of 'angle'. sin(-90) = -32767, sin(90) = 32767 */ LV_ATTRIBUTE_FAST_MEM int16_t lv_trigo_sin(int16_t angle) { int16_t ret = 0; angle = angle % 360; if(angle < 0) angle = 360 + angle; if(angle < 90) { ret = sin0_90_table[angle]; } else if(angle >= 90 && angle < 180) { angle = 180 - angle; ret = sin0_90_table[angle]; } else if(angle >= 180 && angle < 270) { angle = angle - 180; ret = -sin0_90_table[angle]; } else { /*angle >=270*/ angle = 360 - angle; ret = -sin0_90_table[angle]; } return ret; } /** * Calculate a value of a Cubic Bezier function. * @param t time in range of [0..LV_BEZIER_VAL_MAX] * @param u0 start values in range of [0..LV_BEZIER_VAL_MAX] * @param u1 control value 1 values in range of [0..LV_BEZIER_VAL_MAX] * @param u2 control value 2 in range of [0..LV_BEZIER_VAL_MAX] * @param u3 end values in range of [0..LV_BEZIER_VAL_MAX] * @return the value calculated from the given parameters in range of [0..LV_BEZIER_VAL_MAX] */ uint32_t lv_bezier3(uint32_t t, uint32_t u0, uint32_t u1, uint32_t u2, uint32_t u3) { uint32_t t_rem = 1024 - t; uint32_t t_rem2 = (t_rem * t_rem) >> 10; uint32_t t_rem3 = (t_rem2 * t_rem) >> 10; uint32_t t2 = (t * t) >> 10; uint32_t t3 = (t2 * t) >> 10; uint32_t v1 = (t_rem3 * u0) >> 10; uint32_t v2 = (3 * t_rem2 * t * u1) >> 20; uint32_t v3 = (3 * t_rem * t2 * u2) >> 20; uint32_t v4 = (t3 * u3) >> 10; return v1 + v2 + v3 + v4; } /** * Get the square root of a number * @param x integer which square root should be calculated * @param q store the result here. q->i: integer part, q->f: fractional part in 1/256 unit * @param mask optional to skip some iterations if the magnitude of the root is known. * Set to 0x8000 by default. * If root < 16: mask = 0x80 * If root < 256: mask = 0x800 * Else: mask = 0x8000 */ LV_ATTRIBUTE_FAST_MEM void lv_sqrt(uint32_t x, lv_sqrt_res_t * q, uint32_t mask) { x = x << 8; /*To get 4 bit precision. (sqrt(256) = 16 = 4 bit)*/ uint32_t root = 0; uint32_t trial; // http://ww1.microchip.com/...en/AppNotes/91040a.pdf do { trial = root + mask; if(trial * trial <= x) root = trial; mask = mask >> 1; } while(mask); q->i = root >> 4; q->f = (root & 0xf) << 4; } /** * Calculate the atan2 of a vector. * @param x * @param y * @return the angle in degree calculated from the given parameters in range of [0..360] */ uint16_t lv_atan2(int x, int y) { // Fast XY vector to integer degree algorithm - Jan 2011 www.RomanBlack.com // Converts any XY values including 0 to a degree value that should be // within +/- 1 degree of the accurate value without needing // large slow trig functions like ArcTan() or ArcCos(). // NOTE! at least one of the X or Y values must be non-zero! // This is the full version, for all 4 quadrants and will generate // the angle in integer degrees from 0-360. // Any values of X and Y are usable including negative values provided // they are between -1456 and 1456 so the 16bit multiply does not overflow. unsigned char negflag; unsigned char tempdegree; unsigned char comp; unsigned int degree; // this will hold the result unsigned int ux; unsigned int uy; // Save the sign flags then remove signs and get XY as unsigned ints negflag = 0; if(x < 0) { negflag += 0x01; // x flag bit x = (0 - x); // is now + } ux = x; // copy to unsigned var before multiply if(y < 0) { negflag += 0x02; // y flag bit y = (0 - y); // is now + } uy = y; // copy to unsigned var before multiply // 1. Calc the scaled "degrees" if(ux > uy) { degree = (uy * 45) / ux; // degree result will be 0-45 range negflag += 0x10; // octant flag bit } else { degree = (ux * 45) / uy; // degree result will be 0-45 range } // 2. Compensate for the 4 degree error curve comp = 0; tempdegree = degree; // use an unsigned char for speed! if(tempdegree > 22) { // if top half of range if(tempdegree <= 44) comp++; if(tempdegree <= 41) comp++; if(tempdegree <= 37) comp++; if(tempdegree <= 32) comp++; // max is 4 degrees compensated } else { // else is lower half of range if(tempdegree >= 2) comp++; if(tempdegree >= 6) comp++; if(tempdegree >= 10) comp++; if(tempdegree >= 15) comp++; // max is 4 degrees compensated } degree += comp; // degree is now accurate to +/- 1 degree! // Invert degree if it was X>Y octant, makes 0-45 into 90-45 if(negflag & 0x10) degree = (90 - degree); // 3. Degree is now 0-90 range for this quadrant, // need to invert it for whichever quadrant it was in if(negflag & 0x02) { // if -Y if(negflag & 0x01) // if -Y -X degree = (180 + degree); else // else is -Y +X degree = (180 - degree); } else { // else is +Y if(negflag & 0x01) // if +Y -X degree = (360 - degree); } return degree; } /** * Calculate the integer exponents. * @param base * @param power * @return base raised to the power exponent */ int64_t lv_pow(int64_t base, int8_t exp) { int64_t result = 1; while(exp) { if(exp & 1) result *= base; exp >>= 1; base *= base; } return result; } /** * Get the mapped of a number given an input and output range * @param x integer which mapped value should be calculated * @param min_in min input range * @param max_in max input range * @param min_out max output range * @param max_out max output range * @return the mapped number */ int32_t lv_map(int32_t x, int32_t min_in, int32_t max_in, int32_t min_out, int32_t max_out) { if(max_in >= min_in && x >= max_in) return max_out; if(max_in >= min_in && x <= min_in) return min_out; if(max_in <= min_in && x <= max_in) return max_out; if(max_in <= min_in && x >= min_in) return min_out; /** * The equation should be: * ((x - min_in) * delta_out) / delta in) + min_out * To avoid rounding error reorder the operations: * (x - min_in) * (delta_out / delta_min) + min_out */ int32_t delta_in = max_in - min_in; int32_t delta_out = max_out - min_out; return ((x - min_in) * delta_out) / delta_in + min_out; } uint32_t lv_rand(uint32_t min, uint32_t max) { static uint32_t a = 0x1234ABCD; /*Seed*/ /*Algorithm "xor" from p. 4 of Marsaglia, "Xorshift RNGs"*/ uint32_t x = a; x ^= x << 13; x ^= x >> 17; x ^= x << 5; a = x; return (a % (max - min + 1)) + min; } /********************** * STATIC FUNCTIONS **********************/