Example #1
0
void eeLoadModel(uint8_t id)
{
  if(id<MAX_MODELS)
  {
        theFile.openRd(FILE_MODEL(id));
        memset(&g_model, 0, sizeof(ModelData));
        uint16_t sz = theFile.readRlc((uint8_t*)&g_model, sizeof(g_model));

        if(sz<256) // if not loaded a fair amount
        {
            modelDefaultWrite(id);
        }
				validateName( g_model.name, sizeof(g_model.name) ) ;

//        for(uint8_t i=0; i<sizeof(g_model.name);i++) // makes sure name is valid
//        {
//            uint8_t idx = char2idx(g_model.name[i]);
//            g_model.name[i] = idx2char(idx);
//        }
		if ( g_model.numBlades == 0 )
		{
			g_model.numBlades = g_model.xnumBlades + 2 ;				
		}


#ifdef FRSKY
  FrskyAlarmSendState |= 0x40 ;		// Get RSSI Alarms
        FRSKY_setModelAlarms();
#endif
#ifdef FIX_MODE

// check for updating mix sources
		if ( g_model.modelVersion < 2 )
		{
    	for(uint8_t i=0;i<MAX_MIXERS;i++)
			{
        MixData *md = mixaddress( i ) ;
        if (md->srcRaw)
				{
        	if (md->srcRaw <= 4)		// Stick
					{
						md->srcRaw = modeFixValue( md->srcRaw-1 ) ;
					}
				}
			}


			for (uint8_t i = 0 ; i < NUM_CSW ; i += 1 )
			{
    		CSwData *cs = &g_model.customSw[i];
    		uint8_t cstate = CS_STATE(cs->func);
				uint8_t t = 0 ;
    		if(cstate == CS_VOFS)
				{
					t = 1 ;
				}
				else if(cstate == CS_VCOMP)
				{
					t = 1 ;
      		if (cs->v2)
					{
    		    if (cs->v2 <= 4)		// Stick
						{
    	    		cs->v2 = modeFixValue( cs->v2-1 ) ;
						}
					}
				}
				if ( t )
				{
      		if (cs->v1)
					{
    		    if (cs->v1 <= 4)		// Stick
						{
    	    		cs->v1 = modeFixValue( cs->v1-1 ) ;
						}
					}
				}
			}

#if defined(CPUM128) || defined(CPUM2561)
			for (uint8_t i = NUM_CSW ; i < NUM_CSW+EXTRA_CSW ; i += 1 )
			{
	    	CxSwData *cs = &g_model.xcustomSw[i-NUM_CSW];
    		uint8_t cstate = CS_STATE(cs->func);
				uint8_t t = 0 ;
    		if(cstate == CS_VOFS)
				{
					t = 1 ;
				}
				else if(cstate == CS_VCOMP)
				{
					t = 1 ;
      		if (cs->v2)
					{
    		    if (cs->v2 <= 4)		// Stick
						{
    	    		cs->v2 = modeFixValue( cs->v2-1 ) ;
						}
					}
				}
				if ( t )
				{
      		if (cs->v1)
					{
    		    if (cs->v1 <= 4)		// Stick
						{
    	    		cs->v1 = modeFixValue( cs->v1-1 ) ;
						}
					}
				}
			}
#endif	// CPUs
	    memmove( &Xmem.texpoData, &g_model.expoData, sizeof(Xmem.texpoData) ) ;
			for (uint8_t i = 0 ; i < 4 ; i += 1 )
			{
				uint8_t dest = modeFixValue( i ) - 1 ;
	    	memmove( &g_model.expoData[dest], &Xmem.texpoData[i], sizeof(Xmem.texpoData[0]) ) ;
			}

// sort expo/dr here

			alert(PSTR("CHECK MIX/DR SOURCES"));
			g_model.modelVersion = 2 ;
      eeDirty( EE_MODEL ) ;
			eeWaitComplete() ;
		}
#endif	// FIX_MODE

#ifdef VERSION3
		if ( g_model.modelVersion < 3 )
		{
			for (uint8_t i = 0 ; i < NUM_CSW ; i += 1 )
			{
    		CSwData *cs = &g_model.customSw[i];
				if ( cs->func == CS_LATCH )
				{
					cs->func = CS_GREATER ;
				}
				if ( cs->func == CS_FLIP )
				{
					cs->func = CS_LESS ;
				}
			}

#if defined(CPUM128) || defined(CPUM2561)
			for (uint8_t i = NUM_CSW ; i < NUM_CSW+EXTRA_CSW ; i += 1 )
			{
	    	CxSwData *cs = &g_model.xcustomSw[i-NUM_CSW];
				if ( cs->func == CS_LATCH )
				{
					cs->func = CS_GREATER ;
				}
				if ( cs->func == CS_FLIP )
				{
					cs->func = CS_LESS ;
				}
			}
#endif	// CPUs
			g_model.modelVersion = 3 ;
      eeDirty( EE_MODEL ) ;
			eeWaitComplete() ;
		}
#endif
#ifdef VERSION4
		if ( g_model.modelVersion < 4 )
		{
			g_model.switchWarningStates = g_eeGeneral.switchWarningStates ;
			alert(PSTR("CHECK MODEL TIMERS"));
			g_model.modelVersion = 4 ;
      eeDirty( EE_MODEL ) ;
			eeWaitComplete() ;
		}
#endif	// VERSION4
  }

	TimerMode *ptConfig = TimerConfig ;
	FORCE_INDIRECT(ptConfig) ;

	ptConfig->tmrModeA = g_model.tmrMode ;
	ptConfig->tmrModeB = g_model.tmrModeB ;
	ptConfig->tmrVal = g_model.tmrVal ;
	ptConfig->tmrDir = g_model.tmrDir ;
	ptConfig += 1 ;
	ptConfig->tmrModeA = g_model.tmr2Mode ;
	ptConfig->tmrModeB = g_model.tmr2ModeB ;
	ptConfig->tmrVal = g_model.tmr2Val ;
	ptConfig->tmrDir = g_model.tmr2Dir ;

  resetTimer1() ;
  resetTimer2() ;

	asm("") ;
}
void applyTemplate(uint8_t idx)
#endif
{
    MixData *md = &g_model.mixData[0];

    //CC(STK)   -> vSTK
    //ICC(vSTK) -> STK
#define ICC(x) icc[(x)-1]
    uint8_t icc[4] = {0};
    for(uint8_t i=1; i<=4; i++) //generate inverse array
        for(uint8_t j=1; j<=4; j++) if(CC(i)==j) icc[j-1]=i;


#ifndef NO_TEMPLATES
    uint8_t j = 0;

    //Simple 4-Ch
    if(idx==j++)
    {
#endif
        clearMixes();
        md=setDest(ICC(STK_RUD));
        md->srcRaw=CM(STK_RUD);
        md=setDest(ICC(STK_ELE));
        md->srcRaw=CM(STK_ELE);
        md=setDest(ICC(STK_THR));
        md->srcRaw=CM(STK_THR);
        md=setDest(ICC(STK_AIL));
        md->srcRaw=CM(STK_AIL);

#ifndef NO_TEMPLATES
    }

    //T-Cut
    if(idx==j++)
    {
        md=setDest(ICC(STK_THR));
        md->srcRaw=MIX_MAX;
        md->weight=-100;
        md->swtch=DSW_THR;
        md->mltpx=MLTPX_REP;
    }

    //sticky t-cut
    if(idx==j++)
    {
        md=setDest(ICC(STK_THR));
        md->srcRaw=MIX_MAX;
        md->weight=-100;
        md->swtch=DSW_SWC;
        md->mltpx=MLTPX_REP;
        md=setDest(14);
        md->srcRaw=CH(14);
        md=setDest(14);
        md->srcRaw=MIX_MAX;
        md->weight=-100;
        md->swtch=DSW_SWB;
        md->mltpx=MLTPX_REP;
        md=setDest(14);
        md->srcRaw=MIX_MAX;
        md->swtch=DSW_THR;
        md->mltpx=MLTPX_REP;

        setSwitch(0xB,CS_VNEG, CM(STK_THR), -99);
        setSwitch(0xC,CS_VPOS, CH(14), 0);
    }

    //V-Tail
    if(idx==j++)
    {
        clearMixes();
        md=setDest(ICC(STK_RUD));
        md->srcRaw=CM(STK_RUD);
        md=setDest(ICC(STK_RUD));
        md->srcRaw=CM(STK_ELE);
        md->weight=-100;
        md=setDest(ICC(STK_ELE));
        md->srcRaw=CM(STK_RUD);
        md=setDest(ICC(STK_ELE));
        md->srcRaw=CM(STK_ELE);
    }

    //Elevon\\Delta
    if(idx==j++)
    {
        clearMixes();
        md=setDest(ICC(STK_ELE));
        md->srcRaw=CM(STK_ELE);
        md=setDest(ICC(STK_ELE));
        md->srcRaw=CM(STK_AIL);
        md=setDest(ICC(STK_AIL));
        md->srcRaw=CM(STK_ELE);
        md=setDest(ICC(STK_AIL));
        md->srcRaw=CM(STK_AIL);
        md->weight=-100;
    }


    //Heli Setup
    if(idx==j++)
    {
        clearMixes();  //This time we want a clean slate
        clearCurves();

        //Set up Mixes
        //3 cyclic channels
        md=setDest(1);
        md->srcRaw=MIX_CYC1;
        md=setDest(2);
        md->srcRaw=MIX_CYC2;
        md=setDest(3);
        md->srcRaw=MIX_CYC3;

        //rudder
        md=setDest(4);
        md->srcRaw=CM(STK_RUD);

        //Throttle
        md=setDest(5);
        md->srcRaw=CM(STK_THR);
        md->swtch= DSW_ID0;
        md->curve=CV(1);
        md->carryTrim=TRIM_OFF;
        md=setDest(5);
        md->srcRaw=CM(STK_THR);
        md->swtch= DSW_ID1;
        md->curve=CV(2);
        md->carryTrim=TRIM_OFF;
        md=setDest(5);
        md->srcRaw=CM(STK_THR);
        md->swtch= DSW_ID2;
        md->curve=CV(3);
        md->carryTrim=TRIM_OFF;
        md=setDest(5);
        md->srcRaw=MIX_MAX;
        md->weight=-100;
        md->swtch= DSW_THR;
        md->mltpx=MLTPX_REP;

        //gyro gain
        md=setDest(6);
        md->srcRaw=MIX_FULL;
        md->weight=30;
        md->swtch=-DSW_GEA;

        //collective
        md=setDest(11);
        md->srcRaw=CM(STK_THR);
        md->weight=70;
        md->swtch= DSW_ID0;
        md->curve=CV(4);
        md->carryTrim=TRIM_OFF;
        md=setDest(11);
        md->srcRaw=CM(STK_THR);
        md->weight=70;
        md->swtch= DSW_ID1;
        md->curve=CV(5);
        md->carryTrim=TRIM_OFF;
        md=setDest(11);
        md->srcRaw=CM(STK_THR);
        md->weight=70;
        md->swtch= DSW_ID2;
        md->curve=CV(6);
        md->carryTrim=TRIM_OFF;

        g_model.swashType = SWASH_TYPE_120;
        g_model.swashCollectiveSource = CH(11);

        //Set up Curves
        setCurve(CURVE5(1),heli_ar1);
        setCurve(CURVE5(2),heli_ar2);
        setCurve(CURVE5(3),heli_ar3);
        setCurve(CURVE5(4),heli_ar4);
        setCurve(CURVE5(5),heli_ar5);
        setCurve(CURVE5(6),heli_ar5);
    }

    //Gyro Gain
    if(idx==j++)
    {
        md=setDest(6);
        md->srcRaw=STK_P2;
        md->weight= 50;
        md->swtch=-DSW_GEA;
        md->sOffset=100;
        md=setDest(6);
        md->srcRaw=STK_P2;
        md->weight=-50;
        md->swtch= DSW_GEA;
        md->sOffset=100;
    }

    //Servo Test
    if(idx==j++)
    {
        md=setDest(15);
        md->srcRaw=CH(16);
        md->speedUp = 8;
        md->speedDown = 8;
        md=setDest(16);
        md->srcRaw=MIX_FULL;
        md->weight= 110;
        md->swtch=DSW_SW1;
        md=setDest(16);
        md->srcRaw=MIX_MAX;
        md->weight=-110;
        md->swtch=DSW_SW2;
        md->mltpx=MLTPX_REP;
        md=setDest(16);
        md->srcRaw=MIX_MAX;
        md->weight= 110;
        md->swtch=DSW_SW3;
        md->mltpx=MLTPX_REP;

        setSwitch(1,CS_LESS,CH(15),CH(16));
        setSwitch(2,CS_VPOS,CH(15),   105);
        setSwitch(3,CS_VNEG,CH(15),  -105);
    }



    STORE_MODELVARS;
    eeWaitComplete() ;

#endif

}