/usr/include/vdr/diseqc.h is in vdr-dev 2.2.0-5build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 | /*
* diseqc.h: DiSEqC handling
*
* See the main source file 'vdr.c' for copyright information and
* how to reach the author.
*
* $Id: diseqc.h 3.1 2013/06/12 11:52:17 kls Exp $
*/
#ifndef __DISEQC_H
#define __DISEQC_H
#include "config.h"
#include "positioner.h"
#include "thread.h"
class cDiseqcPositioner : public cPositioner {
private:
void SendDiseqc(uint8_t *Codes, int NumCodes);
public:
cDiseqcPositioner(void);
virtual void Drive(ePositionerDirection Direction);
virtual void Step(ePositionerDirection Direction, uint Steps = 1);
virtual void Halt(void);
virtual void SetLimit(ePositionerDirection Direction);
virtual void DisableLimits(void);
virtual void EnableLimits(void);
virtual void StorePosition(uint Number);
virtual void RecalcPositions(uint Number);
virtual void GotoPosition(uint Number, int Longitude);
virtual void GotoAngle(int Longitude);
};
class cScr : public cListObject {
private:
int devices;
int channel;
uint userBand;
int pin;
bool used;
public:
cScr(void);
bool Parse(const char *s);
int Devices(void) const { return devices; }
int Channel(void) const { return channel; }
uint UserBand(void) const { return userBand; }
int Pin(void) const { return pin; }
bool Used(void) const { return used; }
void SetUsed(bool Used) { used = Used; }
};
class cScrs : public cConfig<cScr> {
private:
cMutex mutex;
public:
bool Load(const char *FileName, bool AllowComments = false, bool MustExist = false);
cScr *GetUnused(int Device);
};
extern cScrs Scrs;
class cDiseqc : public cListObject {
public:
enum eDiseqcActions {
daNone,
daToneOff,
daToneOn,
daVoltage13,
daVoltage18,
daMiniA,
daMiniB,
daPositionN,
daPositionA,
daScr,
daCodes,
daWait,
};
enum { MaxDiseqcCodes = 6 };
private:
int devices;
int source;
int slof;
char polarization;
int lof;
mutable int position;
mutable int scrBank;
char *commands;
bool parsing;
uint SetScrFrequency(uint SatFrequency, const cScr *Scr, uint8_t *Codes) const;
int SetScrPin(const cScr *Scr, uint8_t *Codes) const;
const char *Wait(const char *s) const;
const char *GetPosition(const char *s) const;
const char *GetScrBank(const char *s) const;
const char *GetCodes(const char *s, uchar *Codes = NULL, uint8_t *MaxCodes = NULL) const;
public:
cDiseqc(void);
~cDiseqc();
bool Parse(const char *s);
eDiseqcActions Execute(const char **CurrentAction, uchar *Codes, uint8_t *MaxCodes, const cScr *Scr, uint *Frequency) const;
///< Parses the DiSEqC commands and returns the appropriate action code
///< with every call. CurrentAction must be the address of a character pointer,
///< which is initialized to NULL. This pointer is used internally while parsing
///< the commands and shall not be modified once Execute() has been called with
///< it. Call Execute() repeatedly (always providing the same CurrentAction pointer)
///< until it returns daNone. After a successful execution of all commands
///< *CurrentAction points to the value 0x00.
///< If the current action consists of sending code bytes to the device, those
///< bytes will be copied into Codes. MaxCodes must be initialized to the maximum
///< number of bytes Codes can handle, and will be set to the actual number of
///< bytes copied to Codes upon return.
///< If this DiSEqC entry requires SCR, the given Scr will be used. This must
///< be a pointer returned from a previous call to cDiseqcs::Get().
///< Frequency must be the frequency the tuner will be tuned to, and will be
///< set to the proper SCR frequency upon return (if SCR is used).
int Devices(void) const { return devices; }
///< Returns an integer where each bit represents one of the system's devices.
///< If a bit is set, this DiSEqC sequence applies to the corresponding device.
int Source(void) const { return source; }
///< Returns the satellite source this DiSEqC sequence applies to.
int Slof(void) const { return slof; }
///< Returns the switch frequency of the LNB this DiSEqC sequence applies to.
char Polarization(void) const { return polarization; }
///< Returns the signal polarization this DiSEqC sequence applies to.
int Lof(void) const { return lof; }
///< Returns the local oscillator frequency of the LNB this DiSEqC sequence applies to.
int Position(void) const { return position; }
///< Indicates which positioning mode to use in order to move the dish to a given
///< satellite position. -1 means "no positioning" (i.e. fixed dish); 0 means the
///< positioner can be moved to any arbitrary satellite position (within its
///< limits); and a positive number means "move the dish to the position stored
///< under the given number".
bool IsScr(void) const { return scrBank >= 0; }
///< Returns true if this DiSEqC sequence uses Satellite Channel Routing.
const char *Commands(void) const { return commands; }
///< Returns a pointer to the actual commands of this DiSEqC sequence.
};
class cDiseqcs : public cConfig<cDiseqc> {
public:
bool Load(const char *FileName, bool AllowComments = false, bool MustExist = false);
const cDiseqc *Get(int Device, int Source, int Frequency, char Polarization, const cScr **Scr) const;
///< Selects a DiSEqC entry suitable for the given Device and tuning parameters.
///< If this DiSEqC entry requires SCR and the given *Scr is NULL
///< a free one will be selected from the Scrs and a pointer to that will
///< be returned in Scr. The caller shall memorize that pointer and reuse it in
///< subsequent calls.
///< Scr may be NULL for checking whether there is any DiSEqC entry for the
///< given transponder.
};
extern cDiseqcs Diseqcs;
#endif //__DISEQC_H
|