pruio.h

Go to the documentation of this file.

 
#ifdef __cplusplus
 extern "C" {
#endif /* __cplusplus */
 
// common declarations
#include "pruio.hp"
 
#define PRUIO_VERSION "0.6.6"
 
//#include "../pruio/pruio.bi" (transformed)
typedef signed char int8;      
typedef short int16;           
typedef int int32;             
typedef unsigned char uint8;   
typedef unsigned short uint16; 
typedef unsigned int uint32;   
typedef float float_t;         
 
typedef struct pruIo pruIo;
 
//#include "pruio_adc.h"
#define PRUIO_DEF_AVRAGE 4
#define PRUIO_DEF_ODELAY 183
#define PRUIO_DEF_SDELAY 0
#define PRUIO_DEF_SAMPLS 1
#define PRUIO_DEF_STPMSK 510 // &b111111110
#define PRUIO_DEF_TIMERV 0
#define PRUIO_DEF_LSLMOD 4
#define PRUIO_DEF_CLKDIV 0
 
struct adcSteps{
  uint32
    Confg,
    Delay;
};
 
typedef struct adcSet{
  uint32
    DeAd,  
    ClAd,  
    ClVa;  
 
  uint32
    REVISION,      
    SYSCONFIG,     
    IRQSTATUS_RAW, 
    IRQSTATUS,     
    IRQENABLE_SET, 
    IRQENABLE_CLR, 
    IRQWAKEUP,     
    DMAENABLE_SET, 
    DMAENABLE_CLR, 
    CTRL,          
    ADCSTAT,       
    ADCRANGE,      
    ADC_CLKDIV,    
    ADC_MISC,      
    STEPENABLE,    
    IDLECONFIG;    
 
  struct adcSteps St_p[16 + 1];
 
  uint32
    FIFO0COUNT,    
    FIFO0THRESHOLD,
    DMA0REQ,       
    FIFO1COUNT,    
    FIFO1THRESHOLD,
    DMA1REQ;       
} adcSet;
 
typedef struct adcUdt{
  pruIo* Top; 
  adcSet
    *Init,    
    *Conf;    
  uint32
    Samples,  
    TimerVal, 
    InitParA; 
  uint16
    LslMode,  
    ChAz;     
  uint16
    *Value;   
} adcUdt;
 
//#include "pruio_gpio.h"
typedef struct gpioSet{
  uint32
    DeAd,            
    ClAd,            
    ClVa;            
 
  uint32
    REVISION,        
    SYSCONFIG,       
    EOI,             
    IRQSTATUS_RAW_0, 
    IRQSTATUS_RAW_1, 
    IRQSTATUS_0,     
    IRQSTATUS_1,     
    IRQSTATUS_SET_0, 
    IRQSTATUS_SET_1, 
    IRQSTATUS_CLR_0, 
    IRQSTATUS_CLR_1, 
    IRQWAKEN_0,      
    IRQWAKEN_1,      
    SYSSTATUS,       
    CTRL,            
    OE,              
    DATAIN,          
    DATAOUT,         
    LEVELDETECT0,    
    LEVELDETECT1,    
    RISINGDETECT,    
    FALLINGDETECT,   
    DEBOUNCENABLE,   
    DEBOUNCINGTIME,  
    CLEARDATAOUT,    
    SETDATAOUT;      
} gpioSet;
 
typedef struct gpioArr{
  uint32
    DeAd;    
  uint32
    DATAIN,  
    DATAOUT, 
    Mix;     
} gpioArr;
 
 
typedef struct gpioUdt{
  pruIo* Top;
  gpioSet
    *Init[PRUIO_AZ_GPIO + 1], 
    *Conf[PRUIO_AZ_GPIO + 1]; 
  gpioArr
    *Raw[PRUIO_AZ_GPIO + 1];  
  uint32
    InitParA, 
    Mask;     
  uint8
    Mode, 
    Indx, 
    Fe1,  
    Fe2;  
} gpioUdt;
 
 
 
 
//#include "pruio_timer.bi"
typedef struct timerSet{
  uint32
    DeAd, 
    ClAd, 
    ClVa; 
 
  uint32
    TIDR         
  , TIOCPCFG     
  , IRQEOI       
  , IRQSTATUSRAW 
  , IRQSTATUS    
  , IRQENABLESET 
  , IRQENABLECLR 
  , IRQWAKEEN    
  , TCLR   
  , TCRR   
  , TLDR   
  , TTGR   
  , TWPS   
  , TMAR   
  , TCAR1  
  , TSICR  
  , TCAR2; 
} timerSet;
 
 
typedef struct timerArr{
  uint32
    DeAd; 
 
  uint32
    CMax   
  , TCAR1  
  , TCAR2; 
} timerArr;
 
 
typedef struct timerUdt{
  pruIo* Top;                 
  timerSet
    *Init[PRUIO_AZ_GPIO + 1], 
    *Conf[PRUIO_AZ_GPIO + 1]; 
  timerArr
    *Raw[PRUIO_AZ_GPIO + 1];  
  uint32
    InitParA  
  , PwmMode   
  , TimMode   
  , TimHigh   
  , Tim_Low   
  , CapMode;  
  char*
    E0  
  , E1  
  , E2; 
} timerUdt;
 
 
//#include "pruio_pwm.bi"
typedef struct pwmssSet{
  uint32
    DeAd,       
    ClAd,       
    ClVa;       
 
  uint32
    IDVER,      
    SYSCONFIG,  
    CLKCONFIG,  
    CLKSTATUS;  
 
  uint32
    TSCTR,      
    CTRPHS,     
    CAP1,       
    CAP2,       
    CAP3,       
    CAP4;       
  uint16
    ECCTL1,     
    ECCTL2,     
    ECEINT,     
    ECFLG,      
    ECCLR,      
    ECFRC;      
  uint32
    CAP_REV;    
 
  uint32
    QPOSCNT,    
    QPOSINIT,   
    QPOSMAX,    
    QPOSCMP,    
    QPOSILAT,   
    QPOSSLAT,   
    QPOSLAT,    
    QUTMR,      
    QUPRD;      
  uint16
    QWDTMR,     
    QWDPRD,     
    QDECCTL,    
    QEPCTL,     
    QCAPCTL,    
    QPOSCTL,    
    QEINT,      
    QFLG,       
    QCLR,       
    QFRC,       
    QEPSTS,     
    QCTMR,      
    QCPRD,      
    QCTMRLAT,   
    QCPRDLAT,   
    empty;      
  uint32
    QEP_REV;    
 
  uint16
    TBCTL,      
    TBSTS,      
    TBPHSHR,    
    TBPHS,      
    TBCNT,      
    TBPRD,      
 
    CMPCTL,     
    CMPAHR,     
    CMPA,       
    CMPB,       
 
    AQCTLA,     
    AQCTLB,     
    AQSFRC,     
    AQCSFRC,    
 
    DBCTL,     
    DBRED,     
    DBFED,     
 
    TZSEL,     
    TZCTL,     
    TZEINT,    
    TZFLG,     
    TZCLR,     
    TZFRC,     
 
    ETSEL,     
    ETPS,      
    ETFLG,     
    ETCLR,     
    ETFRC,     
 
    PCCTL,     
 
    HRCTL;     
} pwmssSet;
 
 
typedef struct pwmssArr{
  uint32
    DeAd; 
  uint32
    CMax  
  , C1    
  , C2    
  , QPos  
  , NPos  
  , OPos  
  , PLat; 
} pwmssArr;
 
 
typedef struct pwmssUdt{
  pruIo* Top;  
  pwmssSet
    *Init[PRUIO_AZ_PWMSS + 1], 
    *Conf[PRUIO_AZ_PWMSS + 1]; 
  pwmssArr
    *Raw[PRUIO_AZ_PWMSS + 1];  
  uint32 InitParA;             
  const uint16
    PwmMod                     
  , CapMod;                    
} pwmssUdt;
 
 
typedef struct pwmMod{
  pruIo* Top;  
  uint16
    ForceUpDown               
  , Cntrl[PRUIO_AZ_PWMSS + 1] 
  , AqCtl[1 + 1][PRUIO_AZ_PWMSS + 1][2 + 1]; 
  char
    *E0  
  , *E1  
  , *E2  
  , *E3  
  , *E4; 
} pwmMod;
 
typedef struct capMod capMod;
 
typedef struct qepMod{
  pruIo* Top;  
  float_t
    FVh[PRUIO_AZ_PWMSS + 1]  
  , FVl[PRUIO_AZ_PWMSS + 1]; 
  uint32
    Prd[PRUIO_AZ_PWMSS + 1]; 
  char
    *E0  
  , *E1  
  , *E2; 
} qepMod;
 
 
// PRUSS driver interrupt settings
#include "pruio_intc.h"
 
enum BBTypes{
  BBB2x46 = 0, 
  PBB2x36 = 1, 
  BB_Blue = 2  
};
 
enum pinMuxing{
  PRUIO_PULL_DOWN = 0,      
  PRUIO_NO_PULL   = 1 << 3, 
  PRUIO_PULL_UP   = 1 << 4, 
  PRUIO_RX_ACTIV  = 1 << 5, 
  PRUIO_GPIO_OUT0 = 7 + PRUIO_NO_PULL,                    
  PRUIO_GPIO_OUT1 = 7 + PRUIO_NO_PULL + 128,              
  PRUIO_GPIO_IN   = 7 + PRUIO_NO_PULL + PRUIO_RX_ACTIV,   
  PRUIO_GPIO_IN_0 = 7 + PRUIO_PULL_DOWN + PRUIO_RX_ACTIV, 
  PRUIO_GPIO_IN_1 = 7 + PRUIO_PULL_UP + PRUIO_RX_ACTIV,   
  PRUIO_PIN_RESET = 0xFF
};
 
enum adcStepmask{
  AIN0 = 1 << 1   
, AIN1 = 1 << 2   
, AIN2 = 1 << 3   
, AIN3 = 1 << 4   
, AIN4 = 1 << 5   
, AIN5 = 1 << 6   
, AIN6 = 1 << 7   
, AIN7 = 1 << 8   
};
 
enum activateDevice{
  PRUIO_ACT_PRU1  =   1      
, PRUIO_ACT_ADC   = 1 << 1   
, PRUIO_ACT_GPIO0 = 1 << 2   
, PRUIO_ACT_GPIO1 = 1 << 3   
, PRUIO_ACT_GPIO2 = 1 << 4   
, PRUIO_ACT_GPIO3 = 1 << 5   
, PRUIO_ACT_PWM0  = 1 << 6   
, PRUIO_ACT_PWM1  = 1 << 7   
, PRUIO_ACT_PWM2  = 1 << 8   
, PRUIO_ACT_TIM4  = 1 << 9   
, PRUIO_ACT_TIM5  = 1 << 10  
, PRUIO_ACT_TIM6  = 1 << 11  
, PRUIO_ACT_TIM7  = 1 << 12  
, PRUIO_DEF_ACTIVE = 0x1FFF  
, PRUIO_ACT_FREMUX = 0xFFF8   
};
 
 
typedef struct ballSet{
  uint32
    DeAd;  
  uint8 Value[PRUIO_AZ_BALL + 1];
} ballSet;
 
typedef struct pruIo{
  char* Errr;      
 
  adcUdt* Adc;     
  gpioUdt* Gpio;   
  pwmssUdt* PwmSS; 
  timerUdt* TimSS; 
  pwmMod* Pwm;     
  capMod* Cap;     
  qepMod* Qep;     
  timerUdt* Tim;   
 
  uint32* DRam;    
  ballSet
    *Init,         
    *Conf;         
  void
    *ERam,         
    *DInit,        
    *DConf,        
    *MOffs;        
  uint8
    *BallInit,     
    *BallConf;     
  uint32
    EAddr,         
    ESize,         
    DSize,         
    PruNo,         
    PruIRam,       
    PruDRam,       
    PruIntNo;      
  int16
    ParOffs,       
    DevAct;        
  uint32
    BbType, 
    MuxFnr; 
  char
    *MuxAcc,     
    (*setPin)(pruIo*, uint8, uint8); 
  uint8 BallGpio[PRUIO_AZ_BALL + 1];
  struct __pruss_intc_initdata* IntcInit;
  uint32 WaitCycles;
} pruIo;
 
pruIo* pruio_new(uint16 Act, uint8 Av, uint32 OpD, uint8 SaD);
 
void pruio_destroy(pruIo* Io);
 
char* pruio_config(pruIo* Io, uint32 Samp, uint32 Mask, uint32 Tmr, uint16 Mds);
 
char* pruio_Pin(pruIo* Io, uint8 Ball);
 
char* pruio_mm_start(pruIo* Io, uint32 Trg1, uint32 Trg2, uint32 Trg3, uint32 Trg4);
 
char* pruio_rb_start(pruIo* Io);
 
 
char* pruio_gpio_config(pruIo* Io, uint8 Ball, uint8 Modus);
 
char* pruio_gpio_setValue(pruIo* Io, uint8 Ball, uint8 Modus);
 
char* pruio_gpio_flush(pruIo* Io, uint8 Indx);
 
uint32 pruio_gpio_Value(pruIo* Io, uint8 Ball);
 
 
char* pruio_adc_setStep(pruIo* Io, uint8 Stp, uint8 ChN, uint8 Av, uint8 SaD, uint32 OpD);
 
uint32 pruio_adc_mm_trg_pin(pruIo* Io, uint8 Ball, uint8 GpioV, uint16 Skip);
 
 
uint32 pruio_adc_mm_trg_ain(pruIo* Io, uint8 Stp, int32 AdcV, uint8 Rela, uint16 Skip);
 
uint32 pruio_adc_mm_trg_pre(pruIo* Io, uint8 Stp, int32 AdcV, uint16 Samp, uint8 Rela);
 
 
char* pruio_qep_config(pruIo* Io, uint8 Ball, uint32 PMax, float_t VHz, float_t Scale, uint8 Mo);
 
char* pruio_qep_Value(pruIo* Io, uint8 Ball, uint32* Posi, float_t* Velo);
 
 
char* pruio_cap_config(pruIo* Io, uint8 Ball, float_t FLow);
 
char* pruio_cap_Value(pruIo* Io, uint8 Ball, float_t* Hz, float_t* Du);
 
 
char* pruio_pwm_Value(pruIo* Io, uint8 Ball, float_t* Hz, float_t* Du);
 
char* pruio_pwm_setValue(pruIo* Io, uint8 Ball, float_t Hz, float_t Du);
 
char* pruio_tim_Value(pruIo* Io, uint8 Ball, float_t* Dur1, float_t* Dur2);
 
char* pruio_tim_setValue(pruIo* Io, uint8 Ball, float_t Dur1, float_t Dur2, uint16 Mode);
 
#ifdef __cplusplus
 }
#endif /* __cplusplus */