PlayerBase.cpp

00001 #include "PlayerBase.h"
00002 
00003 #include "assert.h"
00004 #include "VectorFormat.h"
00005 
00006 //#include <iostream>
00007 
00008 olc::PlayerBase::PlayerBase() :
00009 mData(0),
00010 mSize(0),
00011 mPlayHead(0),
00012 mPenDown(false),
00013 mLaserPower(0xFFFF),
00014 mGalvoX(0),
00015 mGalvoY(0),
00016 mDelay(0),
00017 mStepSize(1)
00018 {
00019 }
00020 
00021 void olc::PlayerBase::setGalvo(uint16_t x, uint16_t y) {
00022 }
00023 
00024 void olc::PlayerBase::setLaserPower(uint16_t power) {
00025   //  std::cout << "laser power " << power << std::endl;
00026 }
00027 
00028 void olc::PlayerBase::wait(uint16_t ms) {  
00029 }
00030 
00031 void olc::PlayerBase::setData(uint8_t *aData, int aSize) {
00032   reset();
00033   assert(aSize > 0);
00034   assert(aData != 0);
00035   mSize = aSize;
00036   mData = aData;
00037 }
00038 
00039 void olc::PlayerBase::reset() {
00040   mPlayHead = 0;
00041   setLaserPower(0);
00042 }
00043 
00044 bool olc::PlayerBase::hasNext() {
00045   // std::cout << "bytes left " << bytesLeft() << std::endl;
00046   if ( bytesLeft() > 0 ) return true;
00047   return false;
00048 }
00049 
00050 bool olc::PlayerBase::playOne() {
00051   if ( bytesLeft() == 0  ) return true;
00052   
00053   // definition of variables neccesairy due to the switch statement. maybe
00054   // use the if else if construction.
00055   
00056   uint16_t x;
00057   uint16_t y;
00058   uint8_t header = get();
00059   
00060   // this cannot be a byte because we overflow with 255 packets.
00061   int size;
00062   uint16_t power;
00063   char messageString[256];
00064   char *mesgPtr;
00065   uint8_t messageLength;
00066   uint8_t messageLevel;
00067   uint16_t delay;
00068   uint8_t r,g,b;
00069   
00070   switch (header) {
00071     case olc::MOVE_TO:
00072       // if pen was down, make it go up.
00073       if (mPenDown) {
00074         penUp();
00075       }
00076       mGalvoX = decodeU16();
00077       mGalvoY = decodeU16();
00078       setGalvo(mGalvoX,mGalvoY);
00079       //std::cout << "move to [" << mGalvoX << "," << mGalvoY << "]" << std::endl;
00080       break;       
00081       
00082     case olc::LINE_TO:
00083       // if pen was up, make it go down.
00084       if (!mPenDown) {
00085         penDown();
00086         // setLaserPower(mLaserPower);
00087         // mPenDown = true;
00088       }
00089       x = decodeU16();
00090       y = decodeU16();
00091       rasterLine(mGalvoX, mGalvoY, x, y, mStepSize);
00092       mGalvoX = x;
00093       mGalvoY = y;
00094       // setGalvo(mGalvoX,mGalvoY);
00095       //std::cout << "line to [" << mGalvoX << "," << mGalvoY << "]" << std::endl;
00096       break;
00097     case olc::STEP_DELAY:
00098       mDelay = decodeU16();
00099       break;
00100     case olc::PEN_DOWN:
00101       penDown();
00102       break;
00103     case olc::PEN_UP:
00104       penUp();
00105       break;
00106     case olc::STEP_SIZE:
00107       // std::cout << "step size" << std::endl;      
00108       mStepSize = decodeU16();
00109       break;
00110     // sending a message. length is as strlen: number of characters
00111     // preceeding the terminating /0 character
00112     case olc:: REPORT_BUFFER_IN_SIZE:
00113       reportBufferInSize();
00114       break;
00115     case olc::WAIT:
00116       delay = decodeU16();
00117       wait(delay);
00118       break;
00119     case olc::MESSAGE:
00120       messageLevel  = get(); 
00121       messageLength = get();
00122       assert(messageLength < 255);
00123       // now skip x bytes
00124       mesgPtr = &(messageString[0]);
00125       while(1) { 
00126         *mesgPtr = get(); 
00127         if (*mesgPtr == '\0') break;
00128         mesgPtr++;
00129         // check for buffer overflow.
00130         if ( mesgPtr - &(messageString[0]) == 256 ) break;
00131       }
00132       message(messageLevel, messageLength, &(messageString[0])); 
00133       break;
00134       
00135     case olc::CALIBRATION_SCAN:
00136       calibrationScan();
00137       break;
00138     case olc::POINT:
00139       x = decodeU16();
00140       y = decodeU16();
00141       point(x,y);
00142       break;
00143     case olc::READ_COLOR:
00144       readColor();
00145       break;      
00146     case olc::AYT:
00147       areYouThere();
00148       break;      
00149     case olc::READY:
00150       ready();
00151       break;  
00152       
00153     case olc::LASER_POWER_RGB:
00154       r = get();
00155       g = get();
00156       b = get();
00157       setLaserPowerRgb(r,g,b);
00158       break;          
00159     case olc::LASER_POWER:
00160       //std::cout << "laser power" << std::endl;      
00161       mLaserPower = decodeU16();
00162       //setLaserPower(mLaserPower);
00163       break;
00164     case olc::BITMAPU8:
00165       //std::cout << "bitmapU8" << std::endl;
00166       penDown();
00167       size = (int)get();
00168       for( int i = 0; i < size; i++ ) {
00169         uint16_t delay = ((uint16_t) get() ) << 4;
00170         wait(delay);
00171         // setLaserPower( power );
00172         mGalvoX += mStepSize;
00173         setGalvo(mGalvoX, mGalvoY);
00174         //std::cout << "power " << (int)power << std::endl;
00175       }      
00176       break;
00177     default:
00178       //std::cout << "found unknown code " << (int)header << std::endl;
00179       return false;
00180   }
00181   // if (mPlayHead >= mSize) return false;
00182   return true;
00183 }
00184 
00185 // a simple bresenheim line integer algorithm
00186 void olc::PlayerBase::rasterLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, int step) 
00187 {
00188   
00189   int dy = y1 - y0;
00190   int dx = x1 - x0;
00191   int stepx, stepy;
00192   if (dy < 0) { dy = -dy;  stepy = -step; } else { stepy = step; }
00193   if (dx < 0) { dx = -dx;  stepx = -step; } else { stepx = step; }
00194   dy <<= 2;  // dy is now 2*dy
00195   dx <<= 2;  // dx is now 2*dx
00196   
00197   if ( (dx == 0) && (dy == 0) ) return;   // nothing to move.
00198   
00199   if (dx > dy) {
00200     int fraction = dy - (dx >> 1);   // same as 2*dy - dx
00201     if ( stepx > 0) {
00202       while (x0 < x1) {
00203         if (fraction >= 0) { y0 += stepy; fraction -= dx; }
00204         x0 += stepx; fraction += dy;
00205         setGalvo(x0, y0);
00206         wait(mDelay);
00207       }
00208     } else {
00209       while (x0 > x1) {
00210         if (fraction >= 0) { y0 += stepy; fraction -= dx; }
00211         x0 += stepx; fraction += dy;
00212         setGalvo(x0, y0);
00213         wait(mDelay);
00214       }
00215     }
00216   } else {
00217     int fraction = dx - (dy >> 1);
00218     if ( stepy >  0) {
00219       while (y0 < y1) {
00220         if (fraction >= 0) { x0 += stepx; fraction -= dy; }
00221         y0 += stepy;
00222         fraction += dx;
00223         setGalvo(x0, y0);
00224         wait(mDelay);
00225       }
00226     } else {
00227       while (y0 > y1) {
00228         if (fraction >= 0) { x0 += stepx; fraction -= dy; }
00229         y0 += stepy;
00230         fraction += dx;
00231         setGalvo(x0, y0);
00232         wait(mDelay);
00233       }
00234     }
00235   }
00236 }
00237