Пример #1
0
void Transfer::setInternalSpeedLimits(int down,int up)
{
	if((m_nDownLimit < down && m_nDownLimit) || !down)
		down = m_nDownLimit;
	if((m_nUpLimit < up && m_nUpLimit) || !up)
		up = m_nUpLimit;
	
	if(down != m_nDownLimitInt || up != m_nUpLimitInt)
	{
		m_nDownLimitInt = down;
		m_nUpLimitInt = up;
	
		setSpeedLimits(down,up);
	}
}
Пример #2
0
int main( void )
{
    mInit();
    mUSBInit();
    mBusInit();

    // Set up usb interface
    bQueue in_q;
    bQueue out_q;
    usbIface usb( &in_q, &out_q );
    
//    picker_setup();
    stepper_setup();
//    set_timer5 (60000,30000,1200);
    
    setMode( STEP_8TH);
    setSpeedLimits( 65, 500 );
    set_speed(m_speed_min);
    setAccelerationLimit(100); //5000 is good
    
    uint8_t cmd; 
    uint16_t pos = 0;
    while(1)
    {
        usb.readBytes();

        // Handle bytes 
        if (!in_q.isempty() ) {
          mBlueTOGGLE;
          in_q.dequeue(&cmd);
          if ( cmd == 'l' ) {
            pos += 10;
          } else if ( cmd == 'h' ) {
            pos -= 10;
          }
        }
        update(pos);
    }
    return(0);
}
Пример #3
0
// Public Methods //////////////////////////////////////////////////////////////
uint8_t Finger::attach(uint8_t dir0, uint8_t dir1, uint8_t sense, bool inv)
{
    if (fingerIndex < MAX_FINGERS)
    {
        // configure pins
        pinMode(dir0, OUTPUT);                           // set direction1 pin to output
        pinMode(dir1, OUTPUT);                           // set direction2 pin to output
        pinMode(sense, INPUT);                           // set sense pin to input
        // attach all finger pins
        _fingers[fingerIndex].Pin.dir[0] = dir0;
        _fingers[fingerIndex].Pin.dir[1] = dir1;
        _fingers[fingerIndex].Pin.sns = sense;
        // enable the motor and disable finger inversion
        _fingers[fingerIndex].invert = inv;
        _fingers[fingerIndex].motorEn = true;
        // set limits and initial values
        setPosLimits(MIN_FINGER_POS,MAX_FINGER_POS);
        setSpeedLimits(MIN_FINGER_SPEED,MAX_FINGER_SPEED);
        writeSpeed(MAX_FINGER_SPEED);
        writePos(MIN_FINGER_POS);
        _fingers[fingerIndex].CurrDir = OPEN;					// set dir to OPEN after initial writePos to configure finger dir


        // if using the Atmega2560, set the PWM freq to > 20kHz to prevent humming
        setPWMFreq(dir0, 0x01);		// set PWM frequency to max freq
        setPWMFreq(dir1, 0x01);		// set PWM frequency to max freq

        // initialise the timer
        if(_timerSetupFlag == false)
        {
            _passMotorPtr(&fingerPosCtrl);
            _timerSetup();
            _timerSetupFlag = true;
        }
        _fingers[fingerIndex].Pin.isActive = true;		// this must be set after the check
    }

    return fingerIndex;
}
Пример #4
0
int main( void )
{
    mInit();
    mUSBInit();
    //mBusInit();
    
    bQueue in_q;
    bQueue out_q;
    bQueueInit( &in_q );
    bQueueInit( &out_q );
    usbIface usb;
    usbIfaceInit( &usb, &in_q, &out_q );
    
    // Set up midi parser
    midiParser parser;
    midiParserInit( &parser, &in_q );
    midiMsg msg;
    
    picker_setup();
    stepper_setup();
    set_timer5 (60000,30000,1200);
   
    setMode( STEP_HALF );
    setSpeedLimits( 65, 200 );
    set_speed(m_speed_min);
    setAccelerationLimit(200);
    
    int test=0;
    
    //    uint16_t pos[]={0,-180,0,-360,0,-540,0,-720,-900,0};
    //    uint16_t dur[]={1000,1000,1000,1000};
    
    uint16_t pos=0;
    /*
    //set_speed(m_speed_min);
    int i=0;
    update(0);
    //    TIM_Cmd(TIM5, DISABLE);
    accStop();
    setPosition(0);
    */
    int Sflag=0;
    
    
    //strum_delay(1);
    while(1)
    {
        //        test = update(pos);
        //        if(test==1){
        //            if(Sflag==1){
        //                strum();
        //                Sflag=0;
        //            }
        //        }
        update(pos);    
        
        usbIfaceReadBytes(&usb);
        if(midiParserHasMsg(&parser,&msg)){
            mGreenTOGGLE;
            usbIfacePrintf(&usb, "status  %02x\n",msg.status);
            usbIfacePrintf(&usb, "channel %02x\n",msg.channel);
            usbIfacePrintf(&usb, "data[0] %02x\n",msg.data[0]);
            usbIfacePrintf(&usb, "data[1] %02x\n\n",msg.data[1]);
            if(msg.channel == INSTRUMENT_CHANNEL || msg.channel == BOTH_CHANNEL) {
              if(msg.status==NOTE_ON){
                  strum();
                  Sflag=1;
                  switch(msg.data[0]){
                      case 40:
                        pos = E2;
                        break;
                      case 41:
                        pos = F2;
                        break;
                      case 42:
                        pos = FS2;
                        break;
                      case 43:
                        pos = G2;
                        break;
                      case 44:
                        pos = GS2;
                        break;
                      case 45:
                        pos = A2;
                        break;
                      case 46:
                        pos = AS2;
                        break;
                      case 47:
                        pos = B2;
                        break;
                      case 48:
                        pos = C3;
                        break;
                      case 49:
                        pos = CS3;
                        break;
                      case 50:
                        pos = D3;
                        break;
                      case 51:
                        pos = DS3;
                        break;
                      case 52:
                        pos = E3;
                        break;
                      case 53:
                        pos = F3;
                        break;
                      case 54:
                        pos = FS3;
                        break;
                      case 55:
                        pos = G3;
                        break;
                      case 56:
                        pos = GS3;
                        break;
                      case 57:
                        pos = A3;
                        break;
                      case 58:
                        pos = AS3;
                        break;
                      case 59:
                        pos = B3;
                        break;
                      case 60:
                        pos = C4;
                        break;
                      default:
                        break;

                    /*
                    case 57:
                        pos=A3;
                        break;
                    case 59:
                        pos=B3;
                        break;
                    case 60:
                        pos=C4;
                        break;
                    case 62:
                        pos=D4;
                        break;
                    case 64:
                        pos=E4;
                        break;
                        pos=F4;
                        break;
                    case 67:
                        pos=G4;
                        break;
                    case 69:
                        pos=A4;
                        break;
                    case 71:
                        pos=B4;
                        break;
                    case 72:
                        pos=C5;
                        break;
                    default:
                        break;
                    */
                  }
               }
            }
        }
        usbIfaceWriteBytes(&usb);
    }
}
Пример #5
0
void Transfer::setUserSpeedLimits(int down,int up)
{
	m_nDownLimitInt = m_nDownLimit = down;
	m_nUpLimitInt = m_nUpLimit = up;
	setSpeedLimits(down,up);
}