Esempio n. 1
0
void LED_CLOSE_BLOCKED_SEQUENCE(void)
{
    static short LED_CURRENT_STATE;
    LED_CURRENT_STATE = 0;
    while(LED_CURRENT_STATE >= 0)
    {
        CLEAR_AND_START_TIMER3();
        if(xSemaphoreTake(TIMER3_RDY, portMAX_DELAY))
        {
            switch(LED_CURRENT_STATE)
            {
            case 0: {
                TURN_ON_LED(2);
                LED_CURRENT_STATE++;
                break;
            }
            case 1: {
                TURN_ON_LED(1);
                LED_CURRENT_STATE++;
                break;
            }
            case 2: {
                TURN_OFF_LED(1);
                LED_CURRENT_STATE++;
                break;
            }
            case 3: {
                TURN_ON_LED(1);
                LED_CURRENT_STATE++;
                break;
            }
            case 4: {
                TURN_OFF_LED(1);
                LED_CURRENT_STATE++;
                break;
            }
            case 5: {
                TURN_OFF_LED(2);
                LED_CURRENT_STATE++;
                break;
            }
            default:
            {
                T3CONbits.ON = 0;
                IFS0bits.T3IF = 0;
                LED_CURRENT_STATE = -1;
                TMR3 = 0;
                break;
            }
            }
        }
    }
    vTaskDelete(NULL);
}
Esempio n. 2
0
void NextIteration(void)
{
    switch(LED_CURRENT_VALUE)
    {
    case 0: {
        TURN_OFF_LED(1);
        LED_CURRENT_VALUE++;
        break;
    }
    case 1: {
        TURN_OFF_LED(0);
        TURN_OFF_LED(2);
        LED_CURRENT_VALUE++;
        break;
    }
    case 2:
    {}
    case 3:
    {}
    case 4:
    {}
    case 5:
    {}
    case 6:
    {}
    case 7:
    {
        LED_CURRENT_VALUE++;
        break;
    }
    case 8: {
        TURN_ON_LED(0);
        TURN_ON_LED(2);
        LED_CURRENT_VALUE++;
        break;
    }
    case 9: {
        TURN_ON_LED(1);
        LED_CURRENT_VALUE++;
        break;
    }
    default:
    {
        T3CONbits.ON = 0;
        LED_CURRENT_VALUE = 0;
        TMR3 = 0;
        break;
    }

    }
}
Esempio n. 3
0
void LED_OPEN_SEQUENCE(void)
{
    static short LED_CURRENT_STATE;
    LED_CURRENT_STATE = 0;
    while(LED_CURRENT_STATE >= 0)
    {
        CLEAR_AND_START_TIMER3();
        if(xSemaphoreTake(TIMER3_RDY, portMAX_DELAY))
        {
            switch(LED_CURRENT_STATE)
            {
            case 0:
            {}
            case 1:
            {}
            case 2: {
                TURN_OFF_LED(LED_CURRENT_STATE);
                LED_CURRENT_STATE++;
                break;
            }
            default:
            {
                LED_CURRENT_STATE = -1;
                break;
            }
            }
        }
    }
    vTaskDelete(NULL);
}
Esempio n. 4
0
INT LED_Blink(PMINI_ADAPTER Adapter, UINT GPIO_Num, UCHAR uiLedIndex, ULONG timeout, INT num_of_time, LedEventInfo_t currdriverstate)
{
	int Status = STATUS_SUCCESS;
	BOOLEAN bInfinite = FALSE;

	/*Check if num_of_time is -ve. If yes, blink led in infinite loop*/
	if(num_of_time < 0)
	{
		bInfinite = TRUE;
		num_of_time = 1;
	}
	while(num_of_time)
	{

		if(currdriverstate == Adapter->DriverState)
			TURN_ON_LED(GPIO_Num, uiLedIndex);

		/*Wait for timeout after setting on the LED*/
		Status = wait_event_interruptible_timeout(Adapter->LEDInfo.notify_led_event, 
					currdriverstate != Adapter->DriverState || kthread_should_stop(),
					msecs_to_jiffies(timeout));

		if(kthread_should_stop())
		{
			BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, LED_DUMP_INFO, DBG_LVL_ALL, "Led thread got signal to exit..hence exiting");
			Adapter->LEDInfo.led_thread_running= BCM_LED_THREAD_DISABLED;
			TURN_OFF_LED(GPIO_Num, uiLedIndex);
			Status=EVENT_SIGNALED;
			break;
		}
		if(Status)
		{
			TURN_OFF_LED(GPIO_Num, uiLedIndex);
			Status=EVENT_SIGNALED;
			break;
		}
		
		TURN_OFF_LED(GPIO_Num, uiLedIndex);
		Status = wait_event_interruptible_timeout(Adapter->LEDInfo.notify_led_event,
					currdriverstate!= Adapter->DriverState || kthread_should_stop(),
					msecs_to_jiffies(timeout));
		if(bInfinite == FALSE)
			num_of_time--;
	}
	return Status;
}
Esempio n. 5
0
/*******************************************************************
| led_drive - takes three parameters and performs 1 of
| four commands on an led sensor:
|           1.Read LED current state
|           2&3.SET LED ON or OFF
|           4.TOGGLE the LED state
| Parameters:
|   lednum: a value between 0 and 2 PORTD<2-0>
|   cmd: a value between 0 and 2 indicating which command
|   LED_ON: Default is off (0) for LED_ON value, will be used with
|       SET command (1).
| Return: return_value indicates if the command request was
|       successful and if it wasn't, why not.
*******************************************************************/
short led_drive(int lednum, int cmd, int LED_ON)
{
    short return_value;
    return_value = -1;
    // switch on the current command
    switch(cmd)
    {
    case 0: // READ the value for return
    {
        return_value =  READ_LED_STATE(lednum);
        break;
    }
    case 1: // set the led on or off
    {
        if(LED_ON)
        {
            // SET LED_ON
            TURN_ON_LED(lednum);
        }
        else
        {
            // SET LED_OFF
            TURN_OFF_LED(lednum);
        }
        return_value = 2; // return success
        break;
    }
    case 2: // TOGGLE the bits
    {
        // Toggle LED_ON/LED_OFF
        TOGGLE_LED(lednum);
        return_value = 2; // return success
        break;
    }
    // return invalid cmd
    default : {
        return_value = INVALID_LED_COMMAND;
        break;
    }
    }
    return return_value; // EXIT drive_led with return status
}
Esempio n. 6
0
INT LED_Proportional_Blink(PMINI_ADAPTER Adapter, UCHAR GPIO_Num_tx, 
		UCHAR uiTxLedIndex, UCHAR GPIO_Num_rx, UCHAR uiRxLedIndex, LedEventInfo_t currdriverstate)
{
	/* Initial values of TX and RX packets*/
	ULONG64 Initial_num_of_packts_tx = 0, Initial_num_of_packts_rx = 0; 
	/*values of TX and RX packets after 1 sec*/
	ULONG64 Final_num_of_packts_tx = 0, Final_num_of_packts_rx = 0; 
	/*Rate of transfer of Tx and Rx in 1 sec*/
	ULONG64 rate_of_transfer_tx = 0, rate_of_transfer_rx = 0; 
	int Status = STATUS_SUCCESS;
	INT num_of_time = 0, num_of_time_tx = 0, num_of_time_rx = 0;
	UINT remDelay = 0;
	BOOLEAN bBlinkBothLED = TRUE;
	//UINT GPIO_num = DISABLE_GPIO_NUM;
	ulong timeout = 0;
	
	/*Read initial value of packets sent/received */
	Initial_num_of_packts_tx = atomic_read(&Adapter->TxTotalPacketCount);
	Initial_num_of_packts_rx = atomic_read(&Adapter->GoodRxPktCount);
	/*Scale the rate of transfer to no of blinks.*/
	num_of_time_tx= ScaleRateofTransfer((ULONG)rate_of_transfer_tx);
	num_of_time_rx= ScaleRateofTransfer((ULONG)rate_of_transfer_rx);

	while((Adapter->device_removed == FALSE))
	{
		#if 0
		if(0 == num_of_time_tx && 0 == num_of_time_rx)
		{
			timeout = 1000;
			Status = wait_event_interruptible_timeout(Adapter->LEDInfo.notify_led_event,
				currdriverstate!= Adapter->DriverState || kthread_should_stop(), 
				msecs_to_jiffies (timeout));
			if(kthread_should_stop())
			{
				BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, LED_DUMP_INFO, DBG_LVL_ALL, "Led thread got signal to exit..hence exiting");
				Adapter->LEDInfo.led_thread_running= BCM_LED_THREAD_DISABLED;
				return EVENT_SIGNALED;
			}
			if(Status)
				return EVENT_SIGNALED;
			
		}
		#endif
		
		timeout = 50;
		#if 0
		/*Turn on LED if Tx is high bandwidth*/
		if(num_of_time_tx > MAX_NUM_OF_BLINKS)
		{
			TURN_ON_LED(1<<GPIO_Num_tx, uiTxLedIndex);
			num_of_time_tx = 0;
			bBlinkBothLED = FALSE;
			num_of_time = num_of_time_rx;
		}
			/*Turn on LED if Rx is high bandwidth*/
		if(num_of_time_rx > MAX_NUM_OF_BLINKS)
		{
			TURN_ON_LED(1<<GPIO_Num_rx, uiRxLedIndex);
			num_of_time_rx = 0;
			bBlinkBothLED = FALSE;
			num_of_time = num_of_time_tx;
		}
		#endif
		/*Blink Tx and Rx LED when both Tx and Rx is in normal bandwidth*/
		if(bBlinkBothLED)
		{
			/*Assign minimum number of blinks of either Tx or Rx.*/
			if(num_of_time_tx > num_of_time_rx)
				num_of_time = num_of_time_rx;
			else
				num_of_time = num_of_time_tx;
			if(num_of_time > 0)
			{
				/*Blink both Tx and Rx LEDs*/
				if(LED_Blink(Adapter, 1<<GPIO_Num_tx, uiTxLedIndex, timeout, num_of_time,currdriverstate) 
							== EVENT_SIGNALED)
				{
					return EVENT_SIGNALED;
				}
				if(LED_Blink(Adapter, 1<<GPIO_Num_rx, uiRxLedIndex, timeout, num_of_time,currdriverstate) 
							== EVENT_SIGNALED)
				{
					return EVENT_SIGNALED;
				}

			}

			if(num_of_time == num_of_time_tx)
			{
				/*Blink pending rate of Rx*/
				if(LED_Blink(Adapter, (1 << GPIO_Num_rx), uiRxLedIndex, timeout, 
						num_of_time_rx-num_of_time,currdriverstate) == EVENT_SIGNALED)
				{
					return EVENT_SIGNALED;
				}
				num_of_time = num_of_time_rx;
			}
			else
			{
				/*Blink pending rate of Tx*/
				if(LED_Blink(Adapter, 1<<GPIO_Num_tx, uiTxLedIndex, timeout, 
					num_of_time_tx-num_of_time,currdriverstate) == EVENT_SIGNALED)
				{
					return EVENT_SIGNALED;
				}
				num_of_time = num_of_time_tx;
			}
		}
		else
		{
			if(num_of_time == num_of_time_tx)
			{
				/*Blink pending rate of Rx*/
				if(LED_Blink(Adapter, 1<<GPIO_Num_tx, uiTxLedIndex, timeout, num_of_time,currdriverstate) 
							== EVENT_SIGNALED)
				{
					return EVENT_SIGNALED;
				}
			}
			else
			{
				/*Blink pending rate of Tx*/
				if(LED_Blink(Adapter, 1<<GPIO_Num_rx, uiRxLedIndex, timeout, 
						num_of_time,currdriverstate) == EVENT_SIGNALED)
				{
					return EVENT_SIGNALED;
				}
			}
		}
		/* If Tx/Rx rate is less than maximum blinks per second, 
			 * wait till delay completes to 1 second
			 */
		remDelay = MAX_NUM_OF_BLINKS - num_of_time;
		if(remDelay > 0)
		{
			timeout= 100 * remDelay;
			Status = wait_event_interruptible_timeout(Adapter->LEDInfo.notify_led_event,
						currdriverstate!= Adapter->DriverState ||kthread_should_stop() , 
						msecs_to_jiffies (timeout));

			if(kthread_should_stop())
			{
				BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, LED_DUMP_INFO, DBG_LVL_ALL, "Led thread got signal to exit..hence exiting");
				Adapter->LEDInfo.led_thread_running= BCM_LED_THREAD_DISABLED;
				return EVENT_SIGNALED;
			}
			if(Status)
				return EVENT_SIGNALED;
		}
		
		/*Turn off both Tx and Rx LEDs before next second*/
		TURN_OFF_LED(1<<GPIO_Num_tx, uiTxLedIndex);
		TURN_OFF_LED(1<<GPIO_Num_rx, uiTxLedIndex);
		
		/* 
 		 * Read the Tx & Rx packets transmission after 1 second and 
 		 * calculate rate of transfer
 		 */
		Final_num_of_packts_tx = atomic_read(&Adapter->TxTotalPacketCount);
		rate_of_transfer_tx = Final_num_of_packts_tx - Initial_num_of_packts_tx;
		Final_num_of_packts_rx = atomic_read(&Adapter->GoodRxPktCount);
		rate_of_transfer_rx = Final_num_of_packts_rx - Initial_num_of_packts_rx;

		/*Read initial value of packets sent/received */
		Initial_num_of_packts_tx = Final_num_of_packts_tx;
		Initial_num_of_packts_rx = Final_num_of_packts_rx ;

		/*Scale the rate of transfer to no of blinks.*/
		num_of_time_tx= ScaleRateofTransfer((ULONG)rate_of_transfer_tx);
		num_of_time_rx= ScaleRateofTransfer((ULONG)rate_of_transfer_rx);
		
	}
	return Status;
}