BusIn.cc

00001 
00002 namespace CPPToPigpio{
00003         
00004     //default value of NC is set in the header, need to check each pin input to make sure connected
00005     BusIn::BusIn (PinName p0, PinName p1, PinName p2, PinName p3, PinName p4, PinName p5, PinName p6, PinName p7, PinName p8, PinName p9, PinName p10, PinName p11, PinName p12, PinName p13, PinName p14, PinName p15)
00006     {
00007         CPPToPigpio::_handlePigpioInitialisationIfNeeded();
00008         std::vector<PinName> pinNamesInBus;
00009         pinNamesInBus.emplace_back(p0);
00010         if(p1 != NC)
00011             pinNamesInBus.emplace_back(p1);
00012         if(p2 != NC)
00013             pinNamesInBus.emplace_back(p2);
00014         if(p3 != NC)
00015             pinNamesInBus.emplace_back(p3);
00016         if(p4 != NC)
00017             pinNamesInBus.emplace_back(p4);
00018         if(p5 != NC)
00019             pinNamesInBus.emplace_back(p5);
00020         if(p6 != NC)
00021             pinNamesInBus.emplace_back(p6);
00022         if(p7 != NC)
00023             pinNamesInBus.emplace_back(p7);
00024         if(p8 != NC)
00025             pinNamesInBus.emplace_back(p8);
00026         if(p9 != NC)
00027             pinNamesInBus.emplace_back(p9);
00028         if(p10 != NC)
00029             pinNamesInBus.emplace_back(p10);
00030         if(p11 != NC)
00031             pinNamesInBus.emplace_back(p11);
00032         if(p12 != NC)
00033             pinNamesInBus.emplace_back(p12);
00034         if(p13 != NC)
00035             pinNamesInBus.emplace_back(p13);
00036         if(p14 != NC)
00037             pinNamesInBus.emplace_back(p14);
00038         if(p15 != NC)
00039             pinNamesInBus.emplace_back(p15);
00040             
00041         for(size_t i=0;i<pinNamesInBus.size();++i)
00042         {
00043            _digitalIns.emplace_back(new DigitalIn(pinNamesInBus[i]));
00044         }
00045 
00046     }
00047     //Default val of -1 for each pin set in header
00048     BusIn::BusIn (int p0, int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8, int p9, int p10, int p11, int p12, int p13, int p14, int p15)
00049     {
00050         CPPToPigpio::_handlePigpioInitialisationIfNeeded();
00051         std::vector<int> pinNamesInBus;
00052         pinNamesInBus.emplace_back(p0);
00053         if(p1 != -1)
00054             pinNamesInBus.emplace_back(p1);
00055         if(p2 != -1)
00056             pinNamesInBus.emplace_back(p2);
00057         if(p3 != -1)
00058             pinNamesInBus.emplace_back(p3);
00059         if(p4 != -1)
00060             pinNamesInBus.emplace_back(p4);
00061         if(p5 != -1)
00062             pinNamesInBus.emplace_back(p5);
00063         if(p6 != -1)
00064             pinNamesInBus.emplace_back(p6);
00065         if(p7 != -1)
00066             pinNamesInBus.emplace_back(p7);
00067         if(p8 != -1)
00068             pinNamesInBus.emplace_back(p8);
00069         if(p9 != -1)
00070             pinNamesInBus.emplace_back(p9);
00071         if(p10 != -1)
00072             pinNamesInBus.emplace_back(p10);
00073         if(p11 != -1)
00074             pinNamesInBus.emplace_back(p11);
00075         if(p12 != -1)
00076             pinNamesInBus.emplace_back(p12);
00077         if(p13 != -1)
00078             pinNamesInBus.emplace_back(p13);
00079         if(p14 != -1)
00080             pinNamesInBus.emplace_back(p14);
00081         if(p15 != -1)
00082             pinNamesInBus.emplace_back(p15);
00083             
00084         for(size_t i=0;i<pinNamesInBus.size();++i)
00085         {
00086            _digitalIns.emplace_back(new DigitalIn(pinNamesInBus[i]));
00087         }
00088 
00089 
00090     }
00091    
00092     //Different from MBED API, has a leading busSize argument
00093     BusIn::BusIn(int busSize, PinName pinNames[16])
00094     {
00095         CPPToPigpio::_handlePigpioInitialisationIfNeeded();
00096         //ex. input {p15 p16} pushes back 15, then back 16 to get {15 16} stored in _digitalIns
00097         for(int i=0;i<busSize;++i)
00098         {
00099             _digitalIns.emplace_back(new DigitalIn(pinNames[i]));
00100         }
00101     }
00102 
00103     //Different from MBED API, has a leading busSize argument
00104     BusIn::BusIn(int busSize, int pinNames[16])
00105     {
00106         CPPToPigpio::_handlePigpioInitialisationIfNeeded();
00107         for(int i=0;i<busSize;++i)
00108         {
00109             _digitalIns.emplace_back(new DigitalIn(pinNames[i]));
00110         }
00111 
00112     }
00113 
00114     //_digitalIns[0] is the MSB. Might be bad to use read() if we wanted bus of >31 bits, but restricted size to 16 for now and int is the value from MBED API.
00115     int BusIn::read()
00116     {
00117         int outVal = 0;
00118         int numBitsToShift = _digitalIns.size()-1; //Need to shift 0th bit by .size()-1 bits, etc 
00119         for(size_t i=0;i<_digitalIns.size();++i)
00120         {
00121             outVal = outVal | ( _digitalIns[i]->read() << numBitsToShift);
00122             --numBitsToShift;
00123         }
00124         
00125         return outVal;
00126     }
00127 
00128     void BusIn::mode(PinMode pMode)
00129     {
00130         for(size_t i=0;i<_digitalIns.size();++i)
00131         {
00132             
00133             switch(pMode){
00134                 case PullUp:
00135                     gpioSetPullUpDown(_digitalIns[i]->_pinNumber, PI_PUD_UP);
00136                     break;
00137                 case PullDown:
00138                     gpioSetPullUpDown(_digitalIns[i]->_pinNumber, PI_PUD_DOWN); 
00139                     break;
00140                 case PullNone:
00141                     gpioSetPullUpDown(_digitalIns[i]->_pinNumber, PI_PUD_OFF); 
00142                     break;
00143             }
00144         }
00145 
00146     }
00147 
00148     BusIn::operator int()
00149     {
00150         return BusIn::read();
00151     }
00152 
00153     DigitalIn & BusIn::operator[](int index)
00154     {
00155         return *(_digitalIns[index]);
00156     }
00157 
00158     //If only digital pin is p0, would return ...000001. Is that right? Feels weird to have a 0-->0001
00159     //i.e. output is 0-indexed representation of which pins are on
00160     long long BusIn::mask()
00161     {
00162         long long output = 0;
00163         for(size_t i=0; i<_digitalIns.size(); ++i)
00164         {
00165             //Convert pin# to value, then add to mask by shifting a 1 into that position
00166            output = output | (static_cast<long long>(1) << static_cast<int>(_digitalIns[i]->_pinNumber));
00167         }
00168         return output;
00169     }
00170 
00171 
00172     BusIn::~BusIn()
00173     {
00174         CPPToPigpio::_handlePigpioTermination(); 
00175         while(!_digitalIns.empty())
00176         {
00177             delete _digitalIns.back();
00178             _digitalIns.pop_back();
00179         }
00180     }
00181 }
00182 
00183