parallel_write.cxx

Go to the documentation of this file.

/*
         Copyright 2008-2009 Pierre SMARS (smars@yuntech.edu.tw)
         This program is free software: you can redistribute it and/or modify
         it under the terms of the GNU General Public License as published by
         the Free Software Foundation, either version 2 of the License, or
         (at your option) any later version.
 
         This program is distributed in the hope that it will be useful,
         but WITHOUT ANY WARRANTY; without even the implied warranty of
         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
         GNU General Public License for more details.
 
         You should have received a copy of the GNU General Public License
         along with this program.  If not, see <http://www.gnu.org/licenses/>.
         */
#include <dev/ppbus/ppi.h>
#include <dev/ppbus/ppbconf.h>
#include <fcntl.h>
#include <iostream>
#include <string>
#include <sstream>
#include <unistd.h>
#include "SimpleOpt.h"
 
enum { OPT_HELP, OPT_INIT, OPT_FREQ };
 
CSimpleOpt::SOption g_rgOptions[] = {
        { OPT_HELP,_T("-?"),     SO_NONE    },
        { OPT_HELP,_T("-h"),     SO_NONE    },
        { OPT_HELP,_T("--help"), SO_NONE    },
        { OPT_INIT,_T("-i"), SO_NONE    },
        { OPT_INIT,_T("--init"), SO_NONE    },
        { OPT_FREQ,_T("-f"), SO_REQ_SEP    },
        { OPT_FREQ,_T("--frequency"), SO_REQ_SEP    },
        SO_END_OF_OPTIONS
};
 
//---------------------------------------------------------------------------
int error(int val)
{
        std::cerr << "parallel_write:" << std::endl;
        std::cerr << "   set the data on the parallel port" << std::endl;
        std::cerr << "syntax: parallel_write [-i|--init] [-f val|--frequency val] [-?|-h|--help] [bits|seq] " << std::endl;
        std::cerr << "   bits: data bits of the parallel port" << std::endl;
        std::cerr << "       examples: parallel_write 1101" << std::endl;
        std::cerr << "                  sets data1, data3 and data4 to '1'" << std::endl;
        std::cerr << "                 parallel_write 5 0 10" << std::endl;
        std::cerr << "                  sets data1 (5 times) and data3 (3 times) high then low" << std::endl;
        std::cerr << "                  keeps other bits unchanged" << std::endl;
        std::cerr << "   --init: put the INIT bit 'low' then 'high'" << std::endl;
        std::cerr << "   --frequency val: sets the frequency of the most frequent bit change" << std::endl;
        std::cerr << "                    default (and max value): 500Hz" << std::endl;
        std::cerr << "author: P.Smars, 2008-9" << std::endl;
        std::cerr << "version: 2009-05-12" << std::endl;
        return val;
}
//---------------------------------------------------------------------------
int fd;
int val;
//---------------------------------------------------------------------------
void send_init()
{
        ioctl(fd, PPIGCTRL, &val);
        val &= ~nINIT;
        ioctl(fd, PPISCTRL, &val);
        val |= nINIT;
        ioctl(fd, PPISCTRL, &val);
}
//---------------------------------------------------------------------------
void send_strobe()
{
        int stat;
        ioctl(fd, PPIGCTRL, &stat);
        stat |= STROBE;
        ioctl(fd, PPISCTRL, &stat);
        stat &= ~STROBE;
        ioctl(fd, PPISCTRL, &stat);
}
//---------------------------------------------------------------------------
int main( int argc, char *argv[] )
{
        CSimpleOpt args(argc, argv, g_rgOptions);
        bool do_init = false;
        int wtime = 1000;
        while (args.Next())
        {
                if (args.LastError() == SO_SUCCESS)
                {
                        if (args.OptionId() == OPT_HELP)
                                return error(0);
                        else if (args.OptionId() == OPT_INIT)
                                do_init = true;
                        else if (args.OptionId() == OPT_FREQ)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                double freq;
                                in >> freq;
                                if ((freq >= 0.00001)&&(freq <= 5000))
                                        wtime = (1/freq)*1000000/2;
                        }
 
                        else
                                return error(-1);
                } else {
                        std::cerr << "Invalid argument: " << args.OptionText() << std::endl;
                        return error(args.LastError());
                }
        }
        if ((args.FileCount() < 1)&&(!do_init)) return error(-2);
        fd = open ("/dev/ppi0", O_RDWR);
        if (do_init)
                send_init();
        if (args.FileCount() == 1)
        {
                val = 0;
                int ex = 1;
                std::string binary = args.File(0);
                for (int i=binary.size()-1; i>-1; i--)
                {
                        char digit = binary[i];
                        if (digit == '1')
                                val += ex;
                        else if (digit != '0')
                                return error(-3);
                        ex *= 2;
                        if (ex==512)
                                return error(-4);
                }
                ioctl (fd, PPISDATA, &val);
                ioctl(fd, PPIGCTRL, &val);
                val |= STROBE;
                ioctl(fd, PPISCTRL, &val);
                val &= ~STROBE;
                ioctl(fd, PPISCTRL, &val);
        }
        else if (args.FileCount() > 8)
                return error(-3);
        else if (args.FileCount() > 1)
        {
                int val0 = 0;
                unsigned int num[] = {0,0,0,0,0,0,0,0};
                int num0[] = {-1,-1,-1,-1,-1,-1,-1,-1};
                int nmax = 0;
                for (int i=0; i<args.FileCount(); i++)
                {
                        std::string ns = args.File(i);
                        std::istringstream in(ns.c_str());
                        in >> num[i];
                        if (num[i]>nmax)
                                nmax = num[i];
                }
                ioctl (fd, PPIGDATA, &val0);
                for (int i=1; i<=nmax; i++)
                {
                        val = 0;
                        int ex = 1;
                        for (int j=0; j<8; j++)
                        {
                                int bit;
                                if (num[j] != 0)
                                {
                                        int t = (int)(i*num[j]/(double)(nmax)+.5);
                                        if ((t>0)&&(t != num0[j]))
                                        {
                                                num0[j] = t;
                                                val += ex;
                                        }
                                }
                                ex *= 2;
                        }
                        val0 |= val;
                        ioctl (fd, PPISDATA, &val0);
                        send_strobe();
                        usleep(wtime);
                        val0 &= ~val;
                        ioctl (fd, PPISDATA, &val0);
                        send_strobe();
                        usleep(wtime);
                }
        }
        close(fd);
}