#include "Arduino.h"

long pulseIn(int pin, int value) {
    long start = micros();
    while (digitalRead(pin) != value) {}
    long end = micros();
    return (end - start);
}

long pulseIn(int pin, int value, long timeOut) {
    long start = micros();
    long t = start + timeOut;

    while (digitalRead(pin) != value) {
        if (micros() > t) {
            return 0;
        }
    }

    long end = micros();
    return end - start;
}

int abs(int x)
{
    int val = x;
    if (x < 0) {
        val *= -1;
    }

    return val;
}

long abs(long x)
{
    long val = x;
    if (x < 0L) {
        val *= -1;
    }

    return val;
}

double abs(double x)
{
    double val = x;
    if (x < 0.0) {
        val *= -1;
    }

    return val;
}

long map(long x, long in_min, long in_max, long out_min, long out_max) {
    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

long constrain(long x, long a, long b) {

    long min = (a < b) ? a : b;
    long max = (b > a) ? b : a;

    if (x < min) return min;

    if (x > max) return max;

    return x;
}

double constrain(double x, double a, double b) {

    double min = (a < b) ? a : b;
    double max = (b > a) ? b : a;

    if (x < min) return min;

    if (x > max) return max;

    return x;
}

double max(double x, double y) {

    return (y > x) ? y : x;

}

long max(long x, long y) {

    return (y > x) ? y : x;

}

double min(double x, double y) {

    return (y < x) ? y : x;

}

long min(long x, long y) {

    return (y < x) ? y : x;

}

double sq(double x) {
    return x * x;
}

double sq(long x) {
    return x * x;
}


// High/Low Byte Functions

unsigned char lowByte(long w) {
    return (unsigned char)((w) & 0xff);
}

unsigned char highByte(long w) {
    return (unsigned char)((w) >> 8);
}

// Bit Set Functions

void bitSet(long* value, int bit) {
    (*value) |= 1UL << bit;
}

void bitSet(int* value, int bit) {
    (*value) |= 1UL << bit;
}

void bitSet(short* value, int bit) {
    (*value) |= 1UL << bit;
}

void bitSet(char* value, int bit) {
    (*value) |= 1UL << bit;
}

// Bit Clear Functions

long bitClear(long value, int bit) {
    return value &= ~(1UL << (bit));
}

int bitClear(int value, int bit) {
    return value &= ~(1UL << (bit));
}

short bitClear(short value, int bit) {
    return value &= ~(1UL << (bit));
}

char bitClear(char value, int bit) {
    return value &= ~(1UL << (bit));
}

// Bit Toggle

void bitToggle(long* value, int bit) {
    (value) ^= (1UL << (bit));
}

void bitToggle(int* value, int bit) {
    (value) ^= (1UL << (bit));
}

void bitToggle(short* value, int bit) {
    (value) ^= (1UL << (bit));
}

void bitToggle(char* value, int bit) {
    (value) ^= (1UL << (bit));
}

// Bit Write Function

void bitWrite(long* value, int bit, int bitvalue) {
    if (bitvalue == 0)
        (*value) &= ~(1UL << (bit));

    if (bitvalue == 1)
        (*value) |= 1UL << bit;
}

void bitWrite(int* value, int bit, int bitvalue) {
    if (bitvalue == 0)
        (*value) &= ~(1UL << (bit));

    if (bitvalue == 1)
        (*value) |= 1UL << bit;
}

void bitWrite(short* value, int bit, int bitvalue) {
    if (bitvalue == 0)
        (*value) &= ~(1UL << (bit));

    if (bitvalue == 1)
        (*value) |= 1UL << bit;
}

void bitWrite(char* value, int bit, int bitvalue) {
    if (bitvalue == 0)
        (*value) &= ~(1UL << (bit));

    if (bitvalue == 1)
        (*value) |= 1UL << bit;
}

// Bit Function

long bit(long b) {
    return 1UL << b;
}

// Bit Read Function

long bitRead(long value, int bit) {
    return ((value) >> (bit)) & 0x01;
}

int bitRead(int value, int bit) {
    return ((value) >> (bit)) & 0x01;
}

short bitRead(short value, int bit) {
    return ((value) >> (bit)) & 0x01;
}

char bitRead(char value, int bit) {
    return ((value) >> (bit)) & 0x01;
}

// Interrupts

void interrupts() {
    INTERRUPTS_DISABLED = false;
}

void noInterrupts() {
    INTERRUPTS_DISABLED = true;
}

// Shift

void shiftOut(int dataPin, int clockPin, int bitOrder, unsigned char val)
{

    for (int i = 0; i < 8; i++) {
        if (bitOrder == LSBFIRST)
            digitalWrite(dataPin, !!(val & (1 << i)));
        else
            digitalWrite(dataPin, !!(val & (1 << (7 - i))));

        __tick(1);

        digitalWrite(clockPin, HIGH);

        __tick(1);

        digitalWrite(clockPin, LOW);

        __tick(1);
    }
}

unsigned char shiftIn(int dataPin, int clockPin, int bitOrder)
{
    unsigned char value = 0;

    for (int i = 0; i < 8; i++) {

        digitalWrite(clockPin, HIGH);

        __tick(1);

        if (bitOrder == LSBFIRST)
            value |= digitalRead(dataPin) << i;
        else
            value |= digitalRead(dataPin) << (7 - i);

        __tick(1);

        digitalWrite(clockPin, LOW);

        __tick(1);

    }

    return value;
}