コード例 #1
0
ファイル: 7seg.c プロジェクト: muszkab/Stopper-hazi
void DisplayDigit( uint8_t digit, uint8_t value, uint8_t dp  )  //digit: melyik kijelzõre írjuk az adatot, értéke:0...5)
{                                                              //value:0,1,...,F kijelzendõ szám; dp:0->nincs tizedespont 1->van
	uint16_t portval;

	uint16_t select=digit<<13;           //shiftelés  7sel0,..,7sel2: PB13,..PB15; a 16 bites port felsõ 3 bitjét állítjuk, ezért select értéke 13-mal shiftelve van fölfele select: abcxxxxxxxxxxxxx a,b,c az értékes bit
	uint16_t data=SegmentTable[value];   //kiválasztjuk a tömbbõl a kiküldendõ adatot, a kijelzendõ szám(value) alapján
		     data<<=8;                           //shiftelés 0xab00 DB0..DB7->PE8..Pe15: E port felsõ 8 bitje, ezért shiftejük 8-cal az értéket

	 GPIO_ResetBits(GPIOB,GPIO_Pin_8);       //7seg_clk lefutó él (D flipflophoz)

	 portval=GPIO_ReadOutputData(GPIOB);     //kiolvassuk a B port jelenlegi értékét (select itt kerül a port lábaira
	 portval&=0x1FFF;                        //port többi bitjét ne piszkáljuk, ezért a felsõ 3 bitet(13,14,15) kinulázzuk, a többi értékénél marad
	 portval|=select;                        //select értékét átmentjük a port felsõ 3 bitjébe (select alsó 13 bitje 0)
	 GPIO_Write(GPIOB,portval);              //kiküldjük az adatot a B portra (7sel0,7sel1,7sel2 értéket kap, amik demuxon keresztül kiválasztanak egy db kijelzõt, amit meghajtunk)

	 portval=GPIO_ReadOutputData(GPIOE);    //hasonlóan az E portnál is
	 portval&=0x00FF;                       //alsó 8 bitet változatlanul kell visszaírni
	 portval|=data;                        //data értéke bekerül a port felsõ 8 bitjébe
	 GPIO_Write(GPIOE,portval);            //adatkiírás


	 if(dp) GPIO_SetBits(GPIOE,GPIO_Pin_15);   //ha kell tizedespont, állítjuk a megfelelõ lábat
	 else   GPIO_ResetBits(GPIOE,GPIO_Pin_15);

	 GPIO_SetBits(GPIOB,GPIO_Pin_8);              //7seg_clk felfutó él-> D-flipflop kimenetén megjelenik az adat
	 GPIO_ResetBits(GPIOE,GPIO_Pin_7);           //#7sen: engedélyezzük a demux-t és D-flipflop-ot (low active)

}
コード例 #2
0
ファイル: bsp.c プロジェクト: jazzywhit/EmbeddedSystems
void  BSP_LED_Toggle (CPU_INT08U led)
{
    CPU_INT32U  pins;


    switch (led) {
        case 0:
             pins =  GPIO_ReadOutputData(GPIOD);
             pins ^= BSP_GPIOD_LEDS;
             GPIO_SetBits(  GPIOD,   pins  & BSP_GPIOD_LEDS);
             GPIO_ResetBits(GPIOD, (~pins) & BSP_GPIOD_LEDS);
             break;

        case 1:
        case 2:
        case 3:
            pins = GPIO_ReadOutputData(GPIOD);
            if ((pins & (1 << (led + BSP_LED_START_BIT))) == 0) {
                 GPIO_SetBits(  GPIOD, (1 << (led + BSP_LED_START_BIT)));
             } else {
                 GPIO_ResetBits(GPIOD, (1 << (led + BSP_LED_START_BIT)));
             }
            break;

        default:
             break;
    }
}
コード例 #3
0
void  CLed::Toggle (u8 led)
{
    uint16_t  pins;

    switch (led) {
			case 0:
					 pins =  GPIO_ReadOutputData(BSP_LED_GPIO);
					 pins ^= BSP_LEDS;
					 GPIO_SetBits(  BSP_LED_GPIO,   pins  & BSP_LEDS);
					 GPIO_ResetBits(BSP_LED_GPIO, (~pins) & BSP_LEDS);
					 break;

			case 1:
			case 2:
			case 3:
			case 4:
					pins = GPIO_ReadOutputData(BSP_LED_GPIO);
					if ((pins & (1 << (led + BSP_LED_START_BIT))) == 0) {
							 GPIO_SetBits(  BSP_LED_GPIO, (1 << (led + BSP_LED_START_BIT)));
					 } else {
							 GPIO_ResetBits(BSP_LED_GPIO, (1 << (led + BSP_LED_START_BIT)));
					 }
					break;

			default:
					 break;
    }
}
コード例 #4
0
ファイル: MD127.c プロジェクト: pigeon0411/eb00
void iris_auto_motor_run(u8 mode)
{
    static u8 i=0;

	u16 temp = 0;

	
	switch(mode)
	{
	case 1:
    	temp = GPIO_ReadOutputData(IRIS_AUTO_PORT);
        temp &= 0xFFF0;
    	temp |= ((u16)iris_auto_table[i]);

		GPIO_Write(IRIS_AUTO_PORT, temp);

		i++;
		if(i>=4)
			i = 0;

        zoom_run_state_pre = zoom_run_state;
        zoom_run_state = 1;
		break;
	case 2:

    	temp = GPIO_ReadOutputData(IRIS_AUTO_PORT);
        temp &= 0xFFF0;
    	temp |= ((u16)iris_auto_table[i]);

		GPIO_Write(IRIS_AUTO_PORT, temp);
		//i--;
		 if(i == 0)
			i = 4-1;
		else
			i--;

        zoom_run_state_pre = zoom_run_state;
        zoom_run_state = 1;
		
		break;
	case 0:
	
        md127_keepmode();
        zoom_run_state_pre = zoom_run_state;
        zoom_run_state = 0;
      
		break;
	default:
		return;
	}

    md127_keepmode();
}
コード例 #5
0
ファイル: main.c プロジェクト: mrosochacka/mikrokontroler
/**
**===========================================================================
**
**  Abstract: main program
**
**===========================================================================
*/
int main(void)
{
  int i = 0;
  unsigned int ledState=0x1000;
  unsigned int portState;
  /**
  *  IMPORTANT NOTE!
  *  The symbol VECT_TAB_SRAM needs to be defined when building the project
  *  if code has been located to RAM and interrupts are used.
  *  Otherwise the interrupt table located in flash will be used.
  *  See also the <system_*.c> file and how the SystemInit() function updates
  *  SCB->VTOR register.
  *  E.g.  SCB->VTOR = 0x20000000;
  */

  GPIO_Config();

  GPIO_ResetBits(GPIOD, GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15);
  /* Infinite loop */
  while (1)
  {
	if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0)) {
		portState=GPIO_ReadOutputData(GPIOD);
		portState&=0x0FFF;
		GPIO_Write(GPIOD, portState | ledState);
		ledState=ledState<<1;
		if (ledState>0x8000)
			ledState=0x1000;
		for(i=0; i<200000; i++) __NOP();
	}
  }
}
コード例 #6
0
/**
 * Initializes the analog input multiplexer, configuring the processor's peripherals and setting
 * the multiplexer to its default state.
 *
 * @param none
 * @retval none
 */
void InputMultiplexerInit(void) {
	GPIO_InitTypeDef GPIO_InitStructure;

	/* Enable the GPIO Clock */
	RCC_AHB1PeriphClockCmd(OCAL_CONTROL_GPIO_CLK, ENABLE);

	/* Configure the DEMUX GPIO pins */
	GPIO_InitStructure.GPIO_Pin = OCAL_CONTROL_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; /* At most the multiplexer can handle a few hundred Hz */
	GPIO_Init(OCAL_CONTROL_GPIO_PORT, &GPIO_InitStructure);
	GPIO_WriteBit(OCAL_CONTROL_GPIO_PORT, OCAL_CONTROL_PIN, OCAL_SELECT); /* TODO: This is temporary until the REV D boards arrive. Should be EXT_ANALOG_SELECT */

	/* Enable the DEMUX GPIO Clock */
	RCC_AHB1PeriphClockCmd(EXT_ANALOG_IN_GPIO_CLK, ENABLE);

	/* Configure the DEMUX GPIO pins */
	GPIO_InitStructure.GPIO_Pin = EXT_ANALOG_IN_MUX_PINS;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; /* At most the multiplexer can handle a few hundred Hz */
	GPIO_Init(EXT_ANALOG_IN_MUX_PORT, &GPIO_InitStructure);
	GPIO_Write(EXT_ANALOG_IN_MUX_PORT, (EXTERN_0 | (GPIO_ReadOutputData(EXT_ANALOG_IN_MUX_PORT ) & EXT_ANALOG_IN_BITMASK )));
}
コード例 #7
0
//***********点使能第几路红外发射管
void  Light(u8 port_num)
{
    u8  kk,led_light=0;
    if(port_num&BIT0) led_light|=BIT7;
    if(port_num&BIT1) led_light|=BIT6;
    if(port_num&BIT2) led_light|=BIT5;
    kk =GPIO_ReadOutputData(GPIOC)&0x1f;
    GPIO_Write(GPIOC,  kk|led_light);
}
コード例 #8
0
unsigned char CheckMotorStatus(void)
{
	unsigned char MotorRunning = 0;
	//读取列与行状态,未检测第10列(正反转)
	if(! ( ((GPIO_ReadOutputData(GPIOA)&0x8A10)<0x8A10) | ((GPIO_ReadOutputData(GPIOB)&0xEC00)<0xEC00)\
		| ((GPIO_ReadOutputData(GPIOC)&0x1680)<0x1680) | ((GPIO_ReadOutputData(GPIOD)&0xA200)<0xA200)\
		| ((GPIO_ReadOutputData(GPIOE)&0x780)<0x780) | ((GPIO_ReadOutputData(GPIOA)&0x1501)<0x1501)\
		| ((GPIO_ReadOutputData(GPIOC)&0xE940)<0xE940) | ((GPIO_ReadOutputData(GPIOD)&0x5510)<0x5510)\
		| ((GPIO_ReadOutputData(GPIOE)&0x007C)<0x007C) ))
	{
		MotorRunning = 0;
	}
	else MotorRunning = 1;
	return MotorRunning;
}
コード例 #9
0
ファイル: MD127.c プロジェクト: pigeon0411/eb00
void md127_keepmode(void)//保持上一输入状态函数
{
    u16 temp;

    temp = GPIO_ReadOutputData(IRIS_AUTO_PORT);
    temp &= 0xFFF0;
	temp |= ((u16)0X0F);

	GPIO_Write(IRIS_AUTO_PORT, temp);

}
コード例 #10
0
ファイル: dda_lcd.c プロジェクト: olegyurchenko/dda-control
/*----------------------------------------------------------------------------*/
static void DATA(uint8_t d)
{
  uint32_t port;
  port = GPIO_ReadOutputData(GPIOA);
  port &= ~(LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7);
  port |= (d & 1) ? LCD_D4 : 0;
  port |= (d & 2) ? LCD_D5 : 0;
  port |= (d & 4) ? LCD_D6 : 0;
  port |= (d & 8) ? LCD_D7 : 0;
  GPIO_Write(GPIOA, port);
}
コード例 #11
0
ファイル: GPIO_LCD1602.c プロジェクト: pedrominatel/embedded
/***************************************************************************//**
 * @brief  Write 4-bits to LCD controller
 ******************************************************************************/
void Lcd_Write_4bits(uc8 byte)
{
    uint16_t u16Temp=0;
    GPIO_WriteBit(GPIOA, RW, Bit_RESET);
    GPIO_WriteBit(GPIOA, EN, Bit_SET);
    u16Temp = GPIO_ReadOutputData(GPIOB)&0xFFF0;
    u16Temp |=  SWAP_DATA[byte&0x0F];
    GPIO_Write(GPIOB, u16Temp);
    Delay(10000);
    GPIO_WriteBit(GPIOA, EN, Bit_RESET);
    Delay(10000);
}
コード例 #12
0
ファイル: bsp.c プロジェクト: CaryHWSZ/Linux
void  BSP_LED_Toggle (CPU_INT08U led)
{
    CPU_INT32U  pins;


    pins = GPIO_ReadOutputData(GPIOC);

    switch (led) {
        case 0:
             BSP_LED_Toggle(1);
             BSP_LED_Toggle(2);
             BSP_LED_Toggle(3);
             BSP_LED_Toggle(4);
             break;

        case 1:
             if ((pins & BSP_GPIOF_LED1) == 0) {
                 GPIO_SetBits(  GPIOF, BSP_GPIOF_LED1);
             } else {
                 GPIO_ResetBits(GPIOF, BSP_GPIOF_LED1);
             }
            break;

        case 2:
             if ((pins & BSP_GPIOF_LED2) == 0) {
                 GPIO_SetBits(  GPIOF, BSP_GPIOF_LED2);
             } else {
                 GPIO_ResetBits(GPIOF, BSP_GPIOF_LED2);
             }
            break;

        case 3:
             if ((pins & BSP_GPIOF_LED3) == 0) {
                 GPIO_SetBits(  GPIOF, BSP_GPIOF_LED3);
             } else {
                 GPIO_ResetBits(GPIOF, BSP_GPIOF_LED3);
             }
            break;

        case 4:
             if ((pins & BSP_GPIOF_LED4) == 0) {
                 GPIO_SetBits(  GPIOF, BSP_GPIOF_LED4);
             } else {
                 GPIO_ResetBits(GPIOF, BSP_GPIOF_LED4);
             }
            break;

        default:
             break;
    }
}
コード例 #13
0
ファイル: MD127.c プロジェクト: pigeon0411/eb00
void md127_forward(void)//正向前进函数
{
    u16 temp;
    temp = GPIO_ReadOutputData(IRIS_AUTO_PORT);
    temp &= 0xFFF0;
	temp |= ((u16)iris_auto_table[test_127]);

	GPIO_Write(IRIS_AUTO_PORT, temp);

    test_127++;
    if(test_127>3)
    test_127=0;
 
}
コード例 #14
0
ファイル: MD127.c プロジェクト: pigeon0411/eb00
void md127_reverse(void)//反向函数
{
u16 temp;

    temp = GPIO_ReadOutputData(IRIS_AUTO_PORT);
    temp &= 0xFFF0;
	temp |= ((u16)iris_auto_table[test_127]);

	GPIO_Write(IRIS_AUTO_PORT, temp);

 test_127++;
 if(test_127>7)
 test_127=0;
 }
コード例 #15
0
/**
 * Selects the specified external input. This will cause the board to temporarily enter the ADC_EXTERNAL_MUXING
 * state (which will also sample the boards temperature sensor). This function is non-blocking but any analog
 * sampling will be held up by the state machine until the muxing process is completed.
 *
 * @param input ExternalMuxedInput_t The external input to select.
 * @retval none
 */
static void SelectExternalInput(ExternalMuxedInput_t input) {
	/* Verify that the internal input parameter is set */
	if (input == NULL_CHANNEL ) {
#ifdef INPUT_MULTIPLEXER_DEBUG
		printf("[Analog Input Multiplexer] Attempted to select an input as external when it is not configured to be.\n\r");
#endif
		return;
	}
	/* Make the switch */
	SelectInternalInput(EXTERNAL_ANALOG_IN);
	GPIO_Write(EXT_ANALOG_IN_MUX_PORT, (input | (GPIO_ReadOutputData(EXT_ANALOG_IN_MUX_PORT ) & EXT_ANALOG_IN_BITMASK )));
	/* Wait for the external multiplexing relays to conduct */
	MuxCompleteTime = GetLocalTime() + EXTERNAL_MUX_DELAY;
	/* Change ADC state machine to ADC_MUXING state */
	ADC_External_Muxing();
}
コード例 #16
0
void bsp_led_bottom_toggle(BSP_LED_BOTTOM_Def led)
{
	s32 pins;
	if( led >= ledBottomMax )
		return;

	pins = GPIO_ReadOutputData(led_bottom_group[ led ].gpio_reg);
	if ((pins & led_bottom_group[led].pin) == 0)
	{
		GPIO_SetBits(led_bottom_group[led].gpio_reg, led_bottom_group[led].pin);
	}
	else
	{
		GPIO_ResetBits(led_bottom_group[led].gpio_reg, led_bottom_group[led].pin);
	}	
}
コード例 #17
0
void bsp_led_core_toggle(BSP_LED_CORE_Def led)
{
	s32 pins;
	if( led >= ledCoreMax )
		return;

	pins = GPIO_ReadOutputData(led_core_group[ led ].gpio_reg);
	if ((pins & led_core_group[led].pin) == 0)
	{
		GPIO_SetBits(led_core_group[led].gpio_reg, led_core_group[led].pin);
	}
	else
	{
		GPIO_ResetBits(led_core_group[led].gpio_reg, led_core_group[led].pin);
	}	
}
コード例 #18
0
ファイル: tasks.c プロジェクト: davidhajas/uCOS-II
/* The Demo Task */
void Task_Demo(void* param)
{
	uint16_t ledVal = 0x1000;
	uint16_t portVal;
	while(1)
	{
		ledVal <<= 1;
		if ( ledVal == 0)
			ledVal = 0x1000;
		portVal = GPIO_ReadOutputData(GPIOD);
		portVal &= 0x0fff;
		portVal |= ledVal;
		GPIO_Write(GPIOD,portVal);
		OSTimeDly(OS_TICKS_PER_SEC/4);
	}

}
コード例 #19
0
ファイル: Dio.c プロジェクト: miaozhendaoren/PWC-Demonstrator
void Dio_WriteChannel(Dio_ChannelType channelId, Dio_LevelType level)
{
    VALIDATE( DioGlobal.InitRun, DIO_WRITECHANNEL_ID, DIO_E_UNINIT );
    /** @req SWS_Dio_00074 */
    VALIDATE( IS_VALID_CHANNEL(channelId), DIO_WRITECHANNEL_ID, DIO_E_PARAM_INVALID_CHANNEL_ID);

	Dio_PortLevelType portVal = GPIO_ReadOutputData(GPIO_ports[DIO_GET_PORT_FROM_CHANNEL_ID(channelId)]);
	Dio_PortLevelType bit = DIO_GET_BIT_FROM_CHANNEL_ID(channelId);

	if(level == STD_HIGH){
		portVal |= bit;
	}else{
		portVal &= ~bit;
	}

	Dio_WritePort(DIO_GET_PORT_FROM_CHANNEL_ID(channelId), portVal);

	return;
}
コード例 #20
0
ファイル: Dio.c プロジェクト: miaozhendaoren/PWC-Demonstrator
void Dio_WriteChannelGroup(const Dio_ChannelGroupType *channelGroupIdPtr,
    Dio_PortLevelType level)
{
    VALIDATE( DioGlobal.InitRun, DIO_WRITECHANNELGROUP_ID, DIO_E_UNINIT );
    /** @req SWS_Dio_00114 */
    VALIDATE( IS_VALID_CHANNELGROUP(channelGroupIdPtr), DIO_WRITECHANNELGROUP_ID, DIO_E_PARAM_INVALID_GROUP_ID );

	// Shift up and apply mask so that no unwanted bits are affected
	level = (level << channelGroupIdPtr->offset) & channelGroupIdPtr->mask;

	// Read port and clear out masked bits
	Dio_PortLevelType portVal = GPIO_ReadOutputData(GPIO_ports[channelGroupIdPtr->port]) & (~channelGroupIdPtr->mask);

	// Or in the upshifted masked level
	portVal |= level;

	Dio_WritePort(channelGroupIdPtr->port, portVal);

	return;
}
コード例 #21
0
ファイル: lcd.c プロジェクト: wesleyklhk/pill-dispenser
void lcd_write(uint8_t data, uint8_t rs) {
    __IO uint8_t outputdata;
    if(rs) { //write data
        lcd_rs_high();
    } else { //write instruction
        lcd_rs_low();
    }
    lcd_rw_low(); //set to write

    //set data pins to output
    GPIO_InitStructure.GPIO_Pin = DATA_PORT_Pin_0 | DATA_PORT_Pin_1 |
                                  DATA_PORT_Pin_2 | DATA_PORT_Pin_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_Init(LCD_PORT, &GPIO_InitStructure);

    /**
     * Preserve the RS,RW,E bits in order to write out:
     * our data goe son the 4 most significant bits with
     * the high nibble output first.
     */

    outputdata = (uint8_t)GPIO_ReadOutputData(LCD_PORT);
    outputdata &= 0x05; //we're only interested in the lower bits (RS,RW,E)

    //output high nibble first
    GPIO_Write(LCD_PORT, outputdata | (data & 0xF0));
    //push data
    lcd_e_toggle();

    GPIO_Write(LCD_PORT, outputdata | ((data << 4) & 0xF0));
    //push data
    lcd_e_toggle();

    GPIO_Write(LCD_PORT, outputdata | 0xF0); //set pins high as inactive state
}
コード例 #22
0
ファイル: platform.c プロジェクト: BackupTheBerlios/elua-svn
pio_type platform_pio_op( unsigned port, pio_type pinmask, int op )
{
  pio_type retval = 1;
  GPIO_InitTypeDef GPIO_InitStructure;
  GPIO_TypeDef * base = pio_port[ port ];

  switch( op )
  {
    case PLATFORM_IO_PORT_SET_VALUE:
      GPIO_Write(base, pinmask);
      break;

    case PLATFORM_IO_PIN_SET:
      GPIO_SetBits(base, pinmask);
      break;

    case PLATFORM_IO_PIN_CLEAR:
      GPIO_ResetBits(base, pinmask);
      break;

    case PLATFORM_IO_PORT_DIR_INPUT:
      pinmask = GPIO_Pin_All;
    case PLATFORM_IO_PIN_DIR_INPUT:
      GPIO_InitStructure.GPIO_Pin  = pinmask;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

      GPIO_Init(base, &GPIO_InitStructure);
      break;

    case PLATFORM_IO_PORT_DIR_OUTPUT:
      pinmask = GPIO_Pin_All;
    case PLATFORM_IO_PIN_DIR_OUTPUT:
      GPIO_InitStructure.GPIO_Pin   = pinmask;
      GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

      GPIO_Init(base, &GPIO_InitStructure);
      break;

    case PLATFORM_IO_PORT_GET_VALUE:
      retval = pinmask == PLATFORM_IO_READ_IN_MASK ? GPIO_ReadInputData(base) : GPIO_ReadOutputData(base);
      break;

    case PLATFORM_IO_PIN_GET:
      retval = GPIO_ReadInputDataBit(base, pinmask);
      break;

    case PLATFORM_IO_PIN_PULLUP:
      GPIO_InitStructure.GPIO_Pin   = pinmask;
      GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IPU;

      GPIO_Init(base, &GPIO_InitStructure);
      break;

    case PLATFORM_IO_PIN_PULLDOWN:
      GPIO_InitStructure.GPIO_Pin   = pinmask;
      GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IPD;

      GPIO_Init(base, &GPIO_InitStructure);
      break;

    case PLATFORM_IO_PIN_NOPULL:
      GPIO_InitStructure.GPIO_Pin   = pinmask;
      GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IN_FLOATING;

      GPIO_Init(base, &GPIO_InitStructure);
      break;

    default:
      retval = 0;
      break;
  }
  return retval;
}
コード例 #23
0
void MotorColStop(int Col)
{
	
	unsigned char i;
	switch (Col) 
	{
		case 1:
				GPIO_SetBits(GPIOC, GPIO_Pin_12);//Col 1st
				GPIO_SetBits(GPIOA, GPIO_Pin_4);
			break;
		case 2:
				GPIO_SetBits(GPIOC, GPIO_Pin_10);//Col 2nd
				GPIO_SetBits(GPIOE, GPIO_Pin_7);
			break;
		case 3:
				GPIO_SetBits(GPIOA, GPIO_Pin_15);//Col 3rd
				GPIO_SetBits(GPIOE, GPIO_Pin_8);
			break;
		case 4:
				GPIO_SetBits(GPIOA, GPIO_Pin_11);//Col 4th
				GPIO_SetBits(GPIOE, GPIO_Pin_9);
			break;
		case 5:
				GPIO_SetBits(GPIOA, GPIO_Pin_9);//Col 5th
				GPIO_SetBits(GPIOE, GPIO_Pin_10);
			break;
		case 6:
				GPIO_SetBits(GPIOC, GPIO_Pin_9);//Col 6th
				GPIO_SetBits(GPIOB, GPIO_Pin_10);
			break;
		case 7:
				GPIO_SetBits(GPIOC, GPIO_Pin_7);//Col 7th
				GPIO_SetBits(GPIOB, GPIO_Pin_11);
			break;
		case 8:
				GPIO_SetBits(GPIOD, GPIO_Pin_15);//Col 8th
				GPIO_SetBits(GPIOB, GPIO_Pin_13);
			break;
		case 9:
				GPIO_SetBits(GPIOD, GPIO_Pin_13);//Col 9th
				GPIO_SetBits(GPIOB, GPIO_Pin_15);
			break;
		case 10:
				GPIO_SetBits(GPIOD, GPIO_Pin_11);//Col 10th
				GPIO_SetBits(GPIOB, GPIO_Pin_12);
			break;
		case 11:
				GPIO_SetBits(GPIOD, GPIO_Pin_9);//Col 11th
				GPIO_SetBits(GPIOB, GPIO_Pin_14);
		break;
		default:
			break;
	}
	//必须所有的列关闭,行才能关闭,if的条件中!0 = 1, 则所有的为0,相或才能为0;
	//若要每个为0,则必须大于等于0x8A10,如果要等于8A10,则必须所有的都为高电平
		if(! (((GPIO_ReadOutputData(GPIOA)&0x8A10)<0x8A10) | ((GPIO_ReadOutputData(GPIOB)&0xEC00)<0xEC00)\
		| ((GPIO_ReadOutputData(GPIOC)&0x1680)<0x1680) | ((GPIO_ReadOutputData(GPIOD)&0xA200)<0xA200)\
		| ((GPIO_ReadOutputData(GPIOE)&0x780)<0x780) ))//未检测10列的正反转
		{
			for(i = 1; i <=9; i++)
			{
				MotorRowStop(i);
			}
		}
}
コード例 #24
0
ファイル: led.cpp プロジェクト: jachu51/sumo
void ledToggle(uint16_t mask){
	uint16_t state = GPIO_ReadOutputData(GPIOB);
	state ^= (0xffff & mask);
	GPIO_Write(GPIOB, state);
}
コード例 #25
0
ファイル: main.c プロジェクト: ADTL/ARMWork
int main(void) {
	uint16_t bits;
	uint32_t intval = 40;
	uint32_t tnow;
	char tmp[92];
	RCC_ClocksTypeDef RCC_Clocks;
	uint16_t i;
	
	TIM2_timer_start();

	usart_begin(&USerial3, USART3, PC11, PC10, 19200);

	usart_print(&USerial3, 
			"Happy are those who know they are spiritually poor; \n"
			"The kingdom of heaven belongs to them!\n");
	usart_flush(&USerial3);
	
	RCC_GetClocksFreq(&RCC_Clocks);

	sprintf(tmp, "SYSCLK = %ul\n", RCC_Clocks.SYSCLK_Frequency);
	usart_print(&USerial3, tmp);
	sprintf(tmp, "PCLK1 = %ul\n", RCC_Clocks.PCLK1_Frequency);
	usart_flush(&USerial3);

	GPIOMode(PinPort(PD12),
			(PinBit(PD12) | PinBit(PD13) | PinBit(PD14) | PinBit(PD15)), OUTPUT,
			FASTSPEED, PUSHPULL, NOPULL);
			/*
	spi_begin(SPI2, PB13, PB14, PB15, PB12);
	digitalWrite(PB12, HIGH);
*/
	I2C1_Init();
/*
	i2c_begin(&Wire1, PB9, PB8, 100000);
	lcd.init(&Wire1);
	lcd.begin();
	lcd.setContrast(46);
	lcd.print("Yappee!");       // Classic Hello World!
*/
	bits = GPIO_ReadOutputData(GPIOD );
	GPIOWrite(GPIOD, PinBit(PD13) | (bits & 0x0fff));
	delay_ms(intval);
	tnow = millis() / 1000;
	while (tnow == millis() / 1000)
		;
	tnow = millis() / 1000;

	while (1) {
		bits = GPIO_ReadOutputData(GPIOD );

		GPIOWrite(GPIOD, PinBit(PD13) | (bits & 0x0fff));
		delay_ms(intval);
		GPIOWrite(GPIOD, PinBit(PD14) | (bits & 0x0fff));
		delay_ms(intval);
		GPIOWrite(GPIOD, PinBit(PD15) | (bits & 0x0fff));
		delay_ms(intval);
		GPIOWrite(GPIOD, PinBit(PD12) | (bits & 0x0fff));
		delay_ms(intval);
		//
		bits &= 0x0fff;
		switch ((tnow % 60) / 15) {
		case 3:
			bits |= PinBit(PD12);
		case 2:
			bits |= PinBit(PD15);
		case 1:
			bits |= PinBit(PD14);
		case 0:
		default:
			bits |= PinBit(PD13);
			break;
		}
		GPIOWrite(GPIOD, bits);

		while (tnow == millis() / 1000);
		tnow = millis() / 1000;

		//Serial3.print(tmp);
		sprintf(tmp, "%04ld\n", millis());
		usart_print(&USerial3, tmp);

		/*
		digitalWrite(PB12, LOW);
		spi_transfer(SPI2, (uint8_t *) tmp, 8);
		digitalWrite(PB12, HIGH);
*/
		i = 0;
		if (usart_available(&USerial3) > 0) {
			while (usart_available(&USerial3) > 0 && i < 92) {
				tmp[i++] = (char) usart_read(&USerial3);
			}
			tmp[i] = 0;
			usart_print(&USerial3, "> ");
			usart_print(&USerial3, tmp);
			usart_print(&USerial3, "\n");
		}

	}
	return 0;
}