Ss_FastArduino.cpp

Go to the documentation of this file.

#include <Ss_FastArduino.h>

#if defined FASTARDUINO_ON

void f_FastdigitalWrite(uint8_t pin, uint8_t val)
{
    uint8_t bit = digitalPinToBitMask(pin);
    volatile uint8_t *out;
    out = portOutputRegister(digitalPinToPort(pin));
  if (val != LOW) *out |= (uint8_t)bit;
  else *out &= ~(uint8_t)bit;
}
//==============================================================================
int f_FastdigitalRead(uint8_t pin)
{
    uint8_t  bit = digitalPinToBitMask(pin);
    uint8_t  port = digitalPinToPort(pin);
    if (*portInputRegister(port) & bit) return HIGH;
    return LOW;
}

//==============================================================================
void f_FastshiftOut(const uint8_t dataPin, const uint8_t clockPin, const uint8_t val)
{
    register uint8_t i;
  register uint8_t tmp=128; //1<<7
  uint8_t send;
    for (i = 8; i ; i--)
  {
    send=((uint8_t)val &tmp);
    f_FastdigitalWrite(dataPin,send); //MSBFIRST
        f_FastdigitalWrite(clockPin, HIGH);
        f_FastdigitalWrite(clockPin, LOW);
        tmp=tmp>>1;
    }

}
//==============================================================================
/// @cond nodoxy
void f_FastDigitalPulse(uint8_t pin, uint8_t val)
{
    uint8_t bit = digitalPinToBitMask(pin);
    volatile uint8_t *out;
    out = portOutputRegister(digitalPinToPort(pin));
  if (val) {*out |= bit;*out &= ~bit;}
  else {*out &= ~bit;*out |= bit;}

}
/// @endcond
//==============================================================================
#else
// FASTARDUINO_ON NON DEFINITA =================================================
/// @cond nodoxy
void f1_FastDigitalPulse(uint8_t pin, uint8_t val)
{
 FastdigitalWrite(pin,val);
 FastdigitalWrite(pin,(!val));
}
/// @endcond
#endif

/** \brief Set digital pin to low, then to high
 * \param pin is the digital pin to send the pulse.
 */
//==============================================================================
void LPulse(uint8_t pin)
{
  FastdigitalWrite(pin,LOW);
  FastdigitalWrite(pin,HIGH);
}
//==============================================================================

/** \brief Set digital pin to high, then to low
 * \param pin is the digital pin to send the pulse.
 */
void HPulse(uint8_t pin)
{
  FastdigitalWrite(pin,HIGH);
  FastdigitalWrite(pin,LOW);
}
//==============================================================================

/** \brief This function return n bit from a buffer
 * \param buff is the buffer
 * \param Fbit is the bit you want to extract (for example bit 54 from a char buffer)
 * \return true or false
 */
bool GetBitN(uint8_t * buff,unsigned int Fbit)
{
    uint8_t byte,bit;
    byte=Fbit>>3; //Fbit/8;
    bit=Fbit-8*byte;
    if (((*(buff+byte))&(1<<bit))==(1<<bit)) return(true);
    else return(false);
    //return (((*(buff+byte))&(1<<bit))==(1<<bit)); non testata ma dovrebbe sostituire correttamete le due righe di sopra
}

//==============================================================================
//!Questa funzione setta l'n-esimo bit del buffer buff (0-n) (il singolo byte è riempito da destra a sinistra) con il valore val (0 o 1)

/** \brief This function sets n bit in a buffer
 * \param buff is the buffer
 * \param Fbit is the bit you want to set (for example set bit 54 to tue)
 * \param val true or false
 */
void SetBitN(uint8_t * buff,unsigned int Fbit,bool val)
{
    uint8_t byte,bit;
  byte=Fbit>>3; //(bit/8)
  bit=Fbit-8*byte;
  *(buff+byte) = (*(buff+byte) & ~(1<<bit)) | (val << bit);
}

//asm volatile("nop \n\t nop \n\t nop \n\t nop");
//asm volatile("jmp 0"); // restart

/** \brief Calculate free RAM 
 * This function Works only on AVR microcontrollers
 * \return bytes of free RAM
 */
int Mc_FreeRam()
{
  extern int __heap_start, *__brkval;
  int v;
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
  /* da provare per arduino 2
  #include <malloc.h>
#include <stdlib.h>
#include <stdio.h>

extern char _end;                                                                                                                                                                           d
extern "C" char *sbrk(int i);
char *ramstart=(char *)0x20070000;
char *ramend=(char *)0x20088000;

void setup() {
        char *heapend=sbrk(0);
    register char * stack_ptr asm ("sp");
    struct mallinfo mi=mallinfo();
    printf("\nDynamic ram used: %d\n",mi.uordblks);
    printf("Program static ram used %d\n",&_end - ramstart);
    printf("Stack ram used %d\n\n",ramend - stack_ptr);
    printf("My guess at free mem: %d\n",stack_ptr - heapend + mi.fordblks);
}

void loop() {
*/
}


//==============================================================================
/** \brief This fill a buffer using random values
 * \param arr is a float array pointer
 * \param campioni is the number of element you want to fill
 * \param media is the mean value of random values
 * \param spered is the maximum spread value from mean value
 */
void Mc_SetNoisyArray(float* arr,int campioni,float media,float spread)
{
randomSeed(millis()+analogRead(A0));
int ran,ran2;
ran=random(spread*2);
ran2=media-ran;
for(int i=0;i<campioni;i++)
{
int  ran = random(spread*2-ran2);
ran2=media-ran;
 *(arr+i)=media+ran-spread;
}
}


/*
void setPwmFrequency(int pin, int divisor) {
  byte mode;
  if(pin == 5 || pin == 6 || pin == 9 || pin == 10) {
    switch(divisor) {
      case 1: mode = 0x01; break;
      case 8: mode = 0x02; break;
      case 64: mode = 0x03; break;
      case 256: mode = 0x04; break;
      case 1024: mode = 0x05; break;
      default: return;
    }
    if(pin == 5 || pin == 6) {
      TCCR0B = TCCR0B & 0b11111000 | mode;
    } else {
      TCCR1B = TCCR1B & 0b11111000 | mode;
    }
  } else if(pin == 3 || pin == 11) {
    switch(divisor) {
      case 1: mode = 0x01; break;
      case 8: mode = 0x02; break;
      case 32: mode = 0x03; break;
      case 64: mode = 0x04; break;
      case 128: mode = 0x05; break;
      case 256: mode = 0x06; break;
      case 1024: mode = 0x7; break;
      default: return;
    }
    TCCR2B = TCCR2B & 0b11111000 | mode;
  }
}*/