HOLD repeat times

rfayer1 wrote: »

Thanks. This is the 'Time' parameter of the 'Hold' action. Is there a way to make it so that the time the code in the 'Hold' section is repeatedly sent is different from the time that the button must be held for the repeated command to be executed?

button_event[dvTP, 100]
{
  push:
  {
    
  }
  hold[20]
  {
    hold = 1
  }
  release:
  {
    hold = 0
  }
}

button_event[dvTP, 100]
{
  hold[5, repeat]
  {
    if (hold)
      callFunctionEveryHalfSecond()
  }
}

DHawthorne wrote: »

Not directly. If you really need that, launch a repeating timeline on the hold, and kill it on the release.

Will that work? Is holdtime guaranteed to be a perfect multiple of the repeat?

ACTIVE(button.holdtime % 300 == 0)://do something every 3/10th of a second
		    {
		    //DO SOMETHING
		    }

I prefer this way since HOLDs don't play nicely with arrays (can't fully rely on a GET_LAST in a HOLD.)

{
     PUSH:
	  {
	  STACK_VAR INTEGER nTEBtn ;
	  STACK_VAR INTEGER nTETPIndx ;
	  STACK_VAR INTEGER nTEBtnBIC ;
	  
	  nTEBtnBIC = BUTTON.INPUT.CHANNEL ;
	  nTEBtn = GET_LAST(nETableBtnArry) ;
	  nTETPIndx = GET_LAST(dvEventTableTPArry) ;
	  fnTableEventDeBug("'PUSH: TP-',itoa(nTETPIndx),', tp/array, GET_LAST btn-',itoa(nTEBtn),', BIC btn-',itoa(nTEBtnBIC),'.   >-line-<',ITOA(__LINE__),'>'") ;
	  if(!nTEHolding)
	       {
	       nTECurHoldBtn = nTEBtnBIC ;
	       nTECurHoldTPIndx = nTETPIndx ;
	       }
	  }
     HOLD [10,REPEAT]:
	  {
	  nTEHolding = 1 ;
	  fnTableEventDeBug("'HOLD: TP-',itoa(nTECurHoldTPIndx),', tp/array, HOLD btn-',itoa(nTECurHoldBtn),'.   >-line-<',ITOA(__LINE__),'>'") ;
	  }
     RELEASE:
	  {
	  STACK_VAR INTEGER nTEBtn ;
	  STACK_VAR INTEGER nTETPIndx ;
	  STACK_VAR INTEGER nTEBtnBIC ;
	  
	  nTEBtnBIC = BUTTON.INPUT.CHANNEL ;
	  nTEBtn = GET_LAST(nETableBtnArry) ;
	  nTETPIndx = GET_LAST(dvEventTableTPArry) ;
	  fnTableEventDeBug("'RELEASE: TP-',itoa(nTETPIndx),', tp/array, GET_LAST btn-',itoa(nTEBtn),', BIC btn-',itoa(nTEBtnBIC),'.   >-line-<',ITOA(__LINE__),'>'") ;
	  if(nTEHolding && nTETPIndx == nTECurHoldTPIndx && nTEBtnBIC == nTECurHoldBtn)
	       {
	       nTEHolding = 0 ;
	       fnTableEventDeBug("'RELEASE: TP-',itoa(nTETPIndx),', Released Hold!   >-line-<',ITOA(__LINE__),'>'") ;
	       }
	  }
     }

vining wrote: »

a_riot42 wrote:

No, in the example I posted the repeat time was 2 (2/10th) so in this case the ACTIVE statement for 300ms could never be true:

ACTIVE(button.holdtime % 300 == 0)://do something every 3/10th of a second
		    {
		    //DO SOMETHING
		    }

Although the holdtime is in milliseconds the code would only repeat every 200 milliseconds so only multiples of 200 milliseconds could ever be evaluated as true.

vining wrote: »

What do you mean? I know of no reliability problems using GET_LAST during a triggered event. I don't really consider HOLD a triggered event since its really just the result of a push that hasn't been released. So if you use GET_LAST on the trigger events (PUSH, RELEASE) I see no problems.

jjames wrote: »

I just think there's too much hassle with the HOLD event.

B_Clements wrote: »

This is a difficult concept to grasp until you get burnt.

vining wrote: »

It's been suggested that a TIMELINE should be used but that has the same potential for erroneous results as does using the HOLD event since they both depend on the method you use to obtain the value for the button you wish to HOLD and or REPEAT.

BUTTON_EVENT[dv_TP,TRANSPORT_BTNS]
{
	HOLD[2,REPEAT]:
	{
		LOCAL_VAR INTEGER nPANEL
		LOCAL_VAR INTEGER nBTN
		nBTN = BUTTON.INPUT.CHANNEL
		nPANEL = GET_LAST(dv_TP)
		
		IF(nBTN = 4 OR nBTN = 5)
		{
			SWITCH(nCUR_SRC[nPANEL])
			{
				// MANAGE IR DEVICES
				CASE SRC_DVD:		// DVD COMMANDS
					SEND_STRING PANEL[nPANEL].DVD_PLAYER,"DVD_COMMANDS[nBTN],CR"
					
				CASE SRC_CDC:		// CD PLAYER
					SEND_STRING dvCDC_HRT,"CD_COMMANDS[nBTN],CR"
			}
		}
	}
}

BUTTON_EVENT[dv_TP[02],4]
BUTTON_EVENT[dv_TP[02],5]
{
	HOLD[2,REPEAT]:
	{
		STACK_VAR INTEGER nBTN
		nBTN = BUTTON.INPUT.CHANNEL
		
		// ONLY FOR FAST FORWARD AND REWIND OF DVD & CD PLAYER
		IF(nBTN = 4 OR nBTN = 5)
		{
			SWITCH(nCUR_SRC[2][nCUR_SEL[2]])
			{
				// MANAGE IR DEVICES
				CASE SRC_DVD:		// DVD COMMANDS
					SEND_STRING PANEL[2].DVD_PLAYER,"DVD_COMMANDS[nBTN],CR"
					
				CASE SRC_CDC:		// CD PLAYER
					SEND_STRING dvCDC_HRT,"CD_COMMANDS[nBTN],CR"
			}
		}
	}
}

BUTTON_EVENT[dvTPArry,nBtnArry]     
     
     {
     PUSH:
	  {
	  STACK_VAR INTEGER nGLBtn ;
	  STACK_VAR INTEGER nTPIndx ;
	  	  
	  nGLBtn = GET_LAST(nBtnArry) ;
	  nTPIndx = GET_LAST(dvTPArry) ;
	  
	  if(nGLBtn == VOL_UP || nGLBtn == VOL_DN)
	       {//pre-qualify if you want so you only set buttons which need a hold.
	        //This makes the hold event run quicker by not running the Switch for buttons other than vol up or down should they be held.
	       nTPHoldArry[nTPIndx] = nGLBtn ;
	       }
	  }
     HOLD [2,REPEAT]:
	  {
	  STACK_VAR INTEGER i ;
	  
	  for(i = 1 ; i <= NUM_TPs ; i ++)
	       {
	       if(nTPHoldArry[i])
		    {
		    SWITCH(nTPHoldArry[i])
			 {
			 CASE VOL_UP:
			      {
			      //do something cuz dvTPArry[i] is holding the vol up button.
			      }
			 CASE VOL_DN:
			      {
			      //do something cuz dvTPArry[i] is holding the vol dn button.
			      }
			 }
		    }
	       }
	  }
     RELEASE:
	  {
	  STACK_VAR INTEGER nGLBtn ;
	  STACK_VAR INTEGER nTPIndx ;
	  	  
	  nGLBtn = GET_LAST(nBtnArry) ;
	  nTPIndx = GET_LAST(dvTPArry) ;
	  //pre-qualify if you want so you only release buttons which which may have been used in a hold. 
	  //nothing gained here by pre-qualifying so just set to 0.
	  nTPHoldArry[nTPIndx] = 0 ;
	  }
     }

PROGRAM_NAME='Timeline Example, Rev 0-0 by BC'

DEFINE_DEVICE
// Touch panels - add as many as required
dvTP1	=	10001:01:0 // Master Bedroom 1
dvTP2	=	10002:01:0 // Master Bedroom 2
dvTP3	=	10003:01:0 // Kitchen 1
dvTP4	=	10004:01:0 // Kitchen 2
dvTP5	=	10005:01:0 // Family Room


DEFINE_CONSTANT
INTEGER nMinVolumeLevel = 0  // Minimum volume range
INTEGER nMaxVolumeLevel = 40 // Maximum volume range

INTEGER nTotalVolumeZones = 3 // Adjust to the number of volume zones in the system

// Timeline values
LONG nVolumeRampDelay[]	= {500}	 //  1/2 second
LONG nVolumeRampRepeat[]	= {100}	 //  1/10 second

// Volume Buttons
INTEGER nVolumeButtons[] =
{
	24, // 1 - Volume Up
	25, // 2 - Volume Down
	26  // 3 - Volume Mute Toggle
}

// Volume zone map - maps volume zone to touch panel
// Mapping allows multiple touch panels to control the same volume zone.
INTEGER nVolumeZoneMap[] =
{
	1, // Master Bedroom 1
	1, // Master Bedroom 2
	2, // Kitchen 1
	2, // Kitchen 2
	3  // Family Room
}

DEFINE_TYPE
STRUCTURE VolStruct
{
	INTEGER nVolRampState	// Tracks volume ramping state
	INTEGER nVolMute		// Tracks volume mute state
	INTEGER nVolLevel		// Tracks volume level
	INTEGER nVolChange		// Tracks which panel is controlling volume zone
}

DEFINE_VARIABLE
INTEGER nLoop
VOLATILE VolStruct Volume[nTotalVolumeZones]

// Array of all Touch Panels
DEV dv_TP[] =
{
	dvTP1,	// Master Bedroom 1
	dvTP2,	// Master Bedroom 2
	dvTP3,	// Kitchen 1
	dvTP4,	// Kitchen 2
	dvTP5	// Family Room
}

DEFINE_CALL 'ADJUST VOLUME' (INTEGER nZone, INTEGER nState)
{
	SWITCH(nState)
	{
		CASE 1: // Ramp Up
		{
			IF (Volume[nZone].nVolLevel < nMaxVolumeLevel)
			{
				Volume[nZone].nVolLevel++
				// VOLUME LEVEL - VOLUME DEVICE CODE HERE
			}
		}
		CASE 2: // Ramp Down
		{
			IF (Volume[nZone].nVolLevel > nMinVolumeLevel)
			{
				Volume[nZone].nVolLevel--
				// VOLUME LEVEL - VOLUME DEVICE CODE HERE
			}
		}
		CASE 3: // Toggle Mute
		{
			IF (Volume[nZone].nVolMute) // Mute
			{
				// VOLUME MUTE - VOLUME DEVICE CODE HERE
			}
			ELSE	// Unmute
			{
				// VOLUME UNMUTE - VOLUME DEVICE CODE HERE
			}
		}
	}
}

DEFINE_CALL 'VOLUME FEEDBACK' (INTEGER nPanel)
{
	STACK_VAR INTEGER nVolumeZone
	
	// Determine which volume zone status based on which touch panel
	nVolumeZone = nVolumeZoneMap[nPanel]
	
	[dv_TP[nPanel],nVolumeButtons[1]] = (Volume[nVolumeZone].nVolRampState=1) 	// Volume Up Button
	[dv_TP[nPanel],nVolumeButtons[2]] = (Volume[nVolumeZone].nVolRampState=2) 	// Volume Down Button
	[dv_TP[nPanel],nVolumeButtons[3]] = (Volume[nVolumeZone].nVolMute)		// Volume Mute Button
	
	// Assumes touch panel bargragh matches volume level range.
	SEND_LEVEL dv_TP[nPanel],1,Volume[nVolumeZone].nVolLevel							// Volume Bargraph
}

DEFINE_EVENT	// Button Events - Volume Control

// This set of Timelines will delay the start of the volume ramping and then
// 	will repeat volume ramping until a volume button is released.
// Add as many timeslines as there are volume zones.
TIMELINE_EVENT[1]
TIMELINE_EVENT[2]
TIMELINE_EVENT[3]
{
	// Restart same timelime with repeat time instead of delay time
	TIMELINE_CREATE(TIMELINE.ID,nVolumeRampRepeat,1,TIMELINE_RELATIVE,TIMELINE_REPEAT)

	// Call volume control subroutine
	CALL 'ADJUST VOLUME' (TIMELINE.ID,Volume[TIMELINE.ID].nVolRampState)
}


BUTTON_EVENT[dv_TP,nVolumeButtons]  // VOLUME CONTROL
{
   PUSH:
   {
      STACK_VAR INTEGER nVolumeZone
		
	// Determine which volume zone to control based on which touch panel is pressed
	nVolumeZone = nVolumeZoneMap[GET_LAST(dv_TP)]
		
	// Make sure another panel is not adjusting volume in the same zone
	IF (!Volume[nVolumeZone].nVolChange)
	{
		// Set flag for tracking which panel is controlling the volume zone
		Volume[nVolumeZone].nVolChange = GET_LAST(dv_TP)
			
		// Set volume ramp flag indexed to the button array - 1 Up, 2 Down, 3 Mute
		Volume[nVolumeZone].nVolRampState = GET_LAST(nVolumeButtons)
			
		// Not the mute button
		IF (BUTTON.INPUT.CHANNEL <> nVolumeButtons[3])
		{
			IF (Volume[nVolumeZone].nVolMute)	// If volume is muted - unmute
			{
				Volume[nVolumeZone].nVolMute = 0 // Reset mute flag
					
				// Call volume control subroutine
				CALL 'ADJUST VOLUME' (nVolumeZone,Volume[nVolumeZone].nVolRampState)
			}
			ELSE  		// Not muted - Adjust volume one unit
			{
				// Call volume control subroutine
				CALL 'ADJUST VOLUME' (nVolumeZone,Volume[nVolumeZone].nVolRampState)
			}
				
			// Start delay before continuing to ramp -
			// The delay allows a single button tap to increment/decrement one volume unit
			//		before ramping continues.
			TIMELINE_CREATE(nVolumeZone,nVolumeRampDelay,1,TIMELINE_RELATIVE,TIMELINE_ONCE)
		}
		// Mute button
		ELSE
		{
			Volume[nVolumeZone].nVolMute = !Volume[nVolumeZone].nVolMute	// Toggle mute flag
				
			// Call volume control subroutine
			CALL 'ADJUST VOLUME' (nVolumeZone,Volume[nVolumeZone].nVolRampState)
		}
	}
   }
   RELEASE:
   {
      STACK_VAR INTEGER nVolumeZone
		
	// Determine which volume zone to control based on which touch panel is released
	nVolumeZone = nVolumeZoneMap[GET_LAST(dv_TP)]
		
	// Make sure the releasing panel is the same panel that pushed
	IF (Volume[nVolumeZone].nVolChange == GET_LAST(dv_TP))
	{
		Volume[nVolumeZone].nVolChange = 0		// Reset panel tracking flag
		Volume[nVolumeZone].nVolRampState = 0	// Reset volume ramp flag
		IF (TIMELINE_ACTIVE(nVolumeZone))	// Cancel repeating timeline for ramping volume
			TIMELINE_KILL(nVolumeZone)
	}
   }
}

DEFINE_PROGRAM
// Feedback for Volume Buttons and Bargraph on All Touch Panels
nLoop++
IF (nLoop>LENGTH_ARRAY(dv_TP))
	nLoop = 1

CALL 'VOLUME FEEDBACK' (nLoop)