예제 #1
0
파일: campbell.c 프로젝트: kLabUM/IoT
uint8 campbell_cond_start(){
    /* Start of all components */
    ADC_DelSig_1_Start();
    
    ADC_DelSig_1_SelectConfiguration(1u, 1u);
   
    Comp_1_Start();
    Comp_2_Start();
    Comp_3_Start();
    //Comp_4_Start();
    
    AMux_1_Start();   
    //AMuxSeq_1_Next();  // Connect Mux to first 
    
    Sample_Hold_1_Start();
    Sample_Hold_2_Start();
    Sample_Hold_3_Start();
    //Sample_Hold_4_Start();
    
    PWM_1_Start();
    PWM_2_Start();
    
    Cond_Vout_Write(0u);
    
    return 1u;
}
예제 #2
0
파일: main.c 프로젝트: iwabuchiken/WS_E2
int main()
{
    //CyGlobalIntEnable; /* Enable global interrupts. */
    PWM_1_Start();


    /* Place your initialization/startup code here (e.g. MyInst_Start()) */

    for(;;)
    {
        /* Place your application code here. */
/*        if( IN_1_Read() == 1 ) {
           
            OUT_OnOff(1, 200);
            OUT_2_Write( 0 );
            
        } else if( IN_2_Read() == 1 ) {
            
            OUT_OnOff(2, 200);
            OUT_1_Write( 0 );
            
        } else {
            
            OUT_1_Write( 0 );
            OUT_2_Write( 0 );
            
        }
*/
    }//for(;;)
    
}//main()
예제 #3
0
파일: main.c 프로젝트: f16falcona46/PSoC
void play_song(int* notebuf, int* accidentalsbuf, int* octavebuf, int length) {
	PWM_1_Start();
	PWM_2_Start();
	PWM_3_Start();
	PWM_4_Start();
	for (int i = 0; i < length; i+=4) {
		PWM_1_WriteCompare((note_lengths[note_lookup[notebuf[i]]+accidentalsbuf[i]]/2)>>octavebuf[i]);
		PWM_1_WritePeriod(note_lengths[note_lookup[notebuf[i]]+accidentalsbuf[i]]>>octavebuf[i]);
		PWM_1_WriteCounter(0);
		PWM_2_WriteCompare((note_lengths[note_lookup[notebuf[i+1]]+accidentalsbuf[i]]/2)>>octavebuf[i+1]);
		PWM_2_WritePeriod(note_lengths[note_lookup[notebuf[i+1]]+accidentalsbuf[i]]>>octavebuf[i+1]);
		PWM_2_WriteCounter(0);
		PWM_3_WriteCompare((note_lengths[note_lookup[notebuf[i+2]]+accidentalsbuf[i]]/2)>>octavebuf[i+2]);
		PWM_3_WritePeriod(note_lengths[note_lookup[notebuf[i+2]]+accidentalsbuf[i]]>>octavebuf[i+2]);
		PWM_3_WriteCounter(0);
		PWM_4_WriteCompare((note_lengths[note_lookup[notebuf[i+3]]+accidentalsbuf[i]]/2)>>octavebuf[i+3]);
		PWM_4_WritePeriod(note_lengths[note_lookup[notebuf[i+3]]+accidentalsbuf[i]]>>octavebuf[i+3]);
		PWM_4_WriteCounter(0);
		if (Keypad_1_Status_Reg_Read() & 0x10) break;
		CyDelay(TEMPO_MS);
	}
	PWM_1_Stop();
	PWM_2_Stop();
	PWM_3_Stop();
	PWM_4_Stop();
}
예제 #4
0
void PID_init()
{
    parameter_.Kp = Kp_def;
    parameter_.Ki = Ki_def;
    parameter_.Kd = Kd_def;
    parameter_.MAX = MAX_def;
    parameter_.MIN = MIN_def;
    
    PWM_1_Start();
    PWM_1_WriteCompare((unsigned char)parameter_.MIN);
    
}
예제 #5
0
int main()
{
    CyGlobalIntEnable; /* Enable global interrupts. */

    /* Place your initialization/startup code here (e.g. MyInst_Start()) */
    PWM_1_Start();
    for(;;)
    {
        /* Place your application code here. */
        CyDelay(2);
    }
}
예제 #6
0
int main()
{
	Timer_1_Start(); // Configure and enable ms timer
    PWM_1_Start(); // Configure and enable PWM module
	
	
	blue_isr_StartEx(BLUE_ISR); // Point to BLUE_ISR to turn on the blue LED
	red_isr_StartEx(RED_ISR); // Point to RED_ISR to turn on the red LED
	tc_isr_StartEx(TC_ISR); // Point to TC_ISR to turn off both LEDs
	ms_isr_StartEx(MS_ISR); // Point to MS_ISR to update the compare values

    CyGlobalIntEnable; // Enable global interrupts
	
    for(;;)
    {
        PWM_1_WriteCompare1(comp_val1); // Write new compare value to PWM output 1
		PWM_1_WriteCompare2(comp_val2); // Write new compare value to PWM output 2
    }
}
예제 #7
0
파일: main.c 프로젝트: shadowpho/Chalk-Bot
void main()
{
    uint8 ButtonPressFlag = 0;
	int32 temp=0;
	uint32 lowest=24,i;
	uint32 increment=2;
	uint32 battery_volts;
	volatile uint32 counter=0;
    
	CYGlobalIntDisable;
	/* Intitalize hardware */
  	LEDControlReg_Write(0xff);         /* Turn off the LEDs on PORT2(pin 0-3) and PORT4 pin(0-3) */
    PSU_Enable_Write(3);
//	AMux_1_Start();                 /* Enable THe analog mux input to the ADC */
//    AcclADC_Start();                /* Start ADC */
//    VDAC8_1_Start();                /* Start and configure the VDAC used to measure the Thermistor */
//    VDAC8_1_SetRange(VDAC8_1_RANGE_1V);
//    VDAC8_1_SetValue(200 );

	PWM_0_Start();
	PWM_1_Start();
	PWM_2_Start();
	PWM_3_Start();
	
	PWM_4_Start();
	PWM_5_Start();
	PWM_6_Start();
	PWM_7_Start();
	
//	VBATT_ADC_Start();
	//VBATT_ADC_StartConvert();
//	VBATT_ADC_Stop(); //debugging

//	UART_1_Start();
	I2C_1_Start();
	I2C_1_EnableInt();
	
	Button_ClearInterrupt();
	ALERT2_ClearPending();
	ALERT1_ClearPending();
	
	ALERT1_StartEx(ALERT1_ISR);	

	Button_Pressed_StartEx(Button_Press_ISR);
	ALERT2_StartEx(ALERT2_ISR);

	
	CYGlobalIntEnable;              /* Enable global interrupt */
    
	I2C_1_MasterClearStatus();
		while(set_ina226(CH1)!=CYRET_SUCCESS);
		while(set_tmp100(CH1)!=CYRET_SUCCESS);


	while(1)
	{
		if(0)
		//if(Status_Reg_1_Read()&1)
		{
			read_tmp100(CH1);
			read_ina226(CH1);
		}
		LEDControlReg_Write(((uint8)~(PSU_Enable_Read())));
		for(i=0;i<65000;i++);
		LEDControlReg_Write(((uint8)~(PSU_Enable_Read())) & ~(1<<7));
		for(i=0;i<65000;i++);
//		CyPmSaveClocks();
//		CyPmSleep(PM_SLEEP_TIME_NONE, PM_SLEEP_SRC_PICU);
//        CyPmRestoreClocks();
        
//		battery_volts = VBATT_ADC_GetResult32();
	
		if(reset==1)
		{
	
		for(i=0;i<65000;i++); //delay for half a second.
		PSU_Enable_Write(3); //Both PSU ON
		I2C_1_Start();
		I2C_1_EnableInt();
		while(set_ina226(CH1)!=CYRET_SUCCESS);
		while(set_tmp100(CH1)!=CYRET_SUCCESS);
		reset=0;
		}
		
	}
	
	
	


    while(1)
    {
        /* Calculate the current board temperature */
        temp = Thermistor_TemperatureCompute() / 10; //we get 24.1 as 241. We drop fractionals.
		uint32 barrels_above= (temp-lowest)/increment;
		if(temp<=lowest) barrels_above=0; //negative temperatures are too low!
		if(barrels_above>8) barrels_above=8;
		LEDControlReg_Write(1<<barrels_above);
		
    }
}
예제 #8
0
파일: main.c 프로젝트: yukisega/yukisegaRep
int main()
{
    CyGlobalIntEnable; /* Enable global interrupts. */
    //PWM_1_Start();
    PWM_1_Start();
    USBUART_Start(0,USBUART_5V_OPERATION);
    while(!USBUART_bGetConfiguration()){}
    USBUART_CDC_Init();
    
    int count = 0;
    uint8 buff[64];
    buff[0] = 0;
    
    int up_b = 0;
    int left_b = 0;
    int down_b = 0;
    int right_b = 0;
    int PWM_count = 0;
    int judge_count = 0;
    
    while(1)//main loop
    {   
        if(0 != USBUART_GetConfiguration())
        {
            
            if(0 != USBUART_DataIsReady())
            {
                count = USBUART_GetAll(buff);
                if( count != 0){
                    
                    while(0 == USBUART_CDCIsReady()){}
                    
                    PWM_1_Start();
                    PWM_2_Start();
                    PWM_3_Start();
                    PWM_4_Start();
              
                    USBUART_PutData(buff,count);
                    CyDelay(500);
                    USBUART_PutCRLF(); 
                    
                    switch(buff[0]){
                        case 48:
                            up_b = 1;
                            break;
                        case 49:
                            up_b = 0;
                            break;
                        case 50:
                            left_b = 1;
                            break;
                        case 51:
                            left_b = 0;
                            break;
                        case 52:
                            right_b = 1;
                            break;
                        case 53:
                            right_b = 0;
                            break;
                        case 54:
                            down_b = 1;
                            break;
                        case 55:
                            down_b = 0;
                            break;
                        
                        default:
                        break;
                        
                    }   
            judge_count = up_b + left_b + down_b +right_b;
               
                    
                    if(judge_count == 0){
                        PWM_count = 0;
                    }
            if(judge_count == 1){//押されているボタンの数が1つの場合
                if(PWM_count <=100){
                    PWM_count++;
                    int i = 0;
                    for(i=0;i<=100;i++){}
                }else{}
                    
                    if(up_b == 1){//上ボタン
                    
                    PWM_1_WriteCompare(PWM_count);
                    PWM_1_direction_Write(1);
                    PWM_2_WriteCompare(PWM_count);
                    PWM_2_direction_Write(1);
                    PWM_3_WriteCompare(PWM_count);
                    PWM_3_direction_Write(1);
                    PWM_4_WriteCompare(PWM_count);
                    PWM_4_direction_Write(1);
                    }
                    if(left_b == 1)

                    PWM_1_WriteCompare(PWM_count);
                    PWM_1_direction_Write(0);
                    PWM_2_WriteCompare(PWM_count);
                    PWM_2_direction_Write(1);
                    PWM_3_WriteCompare(PWM_count);
                    PWM_3_direction_Write(1);
                    PWM_4_WriteCompare(PWM_count);
                    PWM_4_direction_Write(0);

                    }
                    if(right_b == 1)

                    PWM_1_WriteCompare(PWM_count);
                    PWM_1_direction_Write(1);
                    PWM_2_WriteCompare(PWM_count);
                    PWM_2_direction_Write(0);
                    PWM_3_WriteCompare(PWM_count);
                    PWM_3_direction_Write(0);
                    PWM_4_WriteCompare(PWM_count);
                    PWM_4_direction_Write(1);

                    }
                    if(down_b == 1)
                    PWM_1_WriteCompare(PWM_count);
                    PWM_1_direction_Write(0);
                    PWM_2_WriteCompare(PWM_count);
                    PWM_2_direction_Write(0);
                    PWM_3_WriteCompare(PWM_count);
                    PWM_3_direction_Write(0);
                    PWM_4_WriteCompare(PWM_count);
                    PWM_4_direction_Write(0);

                    }
        }else if(judge_count == 2){//2個の場合
            if(PWM_count <=100){
                    PWM_count++;
                    int i = 0;
                    for(i=0;i<=100;i++){}
                }else{}
                
                if(up_b == 1&& left_b == 1){
                    PWM_1_WriteCompare(0);
                    PWM_1_direction_Write(0);
                    PWM_2_WriteCompare(PWM_count);
                    PWM_2_direction_Write(1);
                    PWM_3_WriteCompare(PWM_count);
                    PWM_3_direction_Write(1);
                    PWM_4_WriteCompare(0);
                    PWM_4_direction_Write(0);
                }else if(up_b == 1&& right_b == 1){
                    PWM_1_WriteCompare(PWM_count);
                    PWM_1_direction_Write(1);
                    PWM_2_WriteCompare(0);
                    PWM_2_direction_Write(0);
                    PWM_3_WriteCompare(0);
                    PWM_3_direction_Write(0);
                    PWM_4_WriteCompare(PWM_count);
                    PWM_4_direction_Write(1);
                }else if(down_b == 1&& right_b==1){
                    PWM_1_WriteCompare(0);
                    PWM_1_direction_Write(0);
                    PWM_2_WriteCompare(PWM_count);
                    PWM_2_direction_Write(0);
                    PWM_3_WriteCompare(PWM_count);
                    PWM_3_direction_Write(0);
                    PWM_4_WriteCompare(0);
                    PWM_4_direction_Write(0);
                }else if(down_b == 1&& left_b == 1){
                    PWM_1_WriteCompare(PWM_count);
                    PWM_1_direction_Write(0);
                    PWM_2_WriteCompare(0);
                    PWM_2_direction_Write(0);
                    PWM_3_WriteCompare(0);
                    PWM_3_direction_Write(0);
                    PWM_4_WriteCompare(PWM_count);
                    PWM_4_direction_Write(0);
                }
        }else{}
            
                    //if(USBUART_IsLineChanged() == USBUART_LINE_CODING_CHANGED || USBUART_IsLineChanged() == USBUART_LINE_CONTROL_CHANGED)
                    //{
                    USBUART_PutCRLF(); 
                        //CyDelay(100);
                    //}
                    if(64 == count){
                        while(0 == USBUART_CDCIsReady()){}
                        //sent zero packet
                        USBUART_PutData(NULL,0);
                    }
                    //LED_Write(0);
                 
            }
           
}
예제 #9
0
파일: main.c 프로젝트: wuweijia1994/PSOC
void main()
{
	CYGlobalIntEnable; /* Enable global interrupts */
	
	ADC_DelSig_1_Start();/* Configure and power up ADC */
	LCD_Char_1_Start(); /* Initialize and clear the LCD */
	
	/* Move the cursor to Row 0 Column 0 */
	LCD_Char_1_Position(ROW_0,COLUMN_0); 
	/* Print Label for the pot voltage raw count */
	LCD_Char_1_PrintString("TEMP NOW:    C");
	
	LCD_Char_1_Position(ROW_1,COLUMN_0);
	LCD_Char_1_PrintString("TEMP SET:    C");
	
	ADC_DelSig_1_StartConvert(); /* Force ADC to initiate a conversion */
	
	/* Start capsense and initialize baselines and enable scan */
	CapSense_Start();
	CapSense_InitializeAllBaselines();
	CapSense_ScanEnabledWidgets();

    /* CyGlobalIntEnable; */ /* Uncomment this line to enable global interrupts. */
	//Start the pwm;
	PWM_1_Start();
    for(;;)
    {
		/* If scanning is completed update the baseline count and check if sensor is active */
		while(CapSense_IsBusy());
		
		/* Update baseline for all the sensors */
		CapSense_UpdateEnabledBaselines();
		CapSense_ScanEnabledWidgets();
		
		/* Test if button widget is active */
		stateB_1 = CapSense_CheckIsWidgetActive(CapSense_BUTTON0__BTN);
		stateB_2 = CapSense_CheckIsWidgetActive(CapSense_BUTTON1__BTN);
	
        /* Wait for end of conversion */
		ADC_DelSig_1_IsEndConversion(ADC_DelSig_1_WAIT_FOR_RESULT);
		/* Get converted result */
		voltageRawCount = ADC_DelSig_1_GetResult16();
		//Change voltageRawCount to Temperature;
		temp = voltageRawCount / 3.870 * 0.1017 + 0.5;
		cold = (9999 - (temp > temp_set ? temp - temp_set : 0) * 50);
		if(cold < 1000)
			cold = 1000;
		if(cold > 9999)
			cold = 9999;
		//Change the pwm;
		PWM_1_WriteCompare(cold);
		/* Set range limit */
		if (temp > 0x7FFF)
		{
			temp = 0;
		}
		else
		{
		/* Continue on */
		}
		if(show < 10)
		{
			show++;
		}
		else
		{
			show = 0;
			UpdateDisplay(temp, 0); /* Print result on LCD */
			UpdateButtonState(stateB_1, stateB_2);
		}
    }
}