struct Max31855Data readMax31855Data()
{
	union {
		uint32_t dword;
		struct Max31855Data data;
	} u;
	GPIO_PinClear(p_cs);

	for (int i = 0; i < 32; i++)
	{
		u.dword <<= 1;

		GPIO_PinSet(p_clk); /* Set CLK to sample value */

		WAIT_Waitus(1);

		if ( GPIO_Read(GPIOB) & (1l << (p_miso - 32)) )
			u.dword |= 1; /* Read value from MISO */

		GPIO_PinClear(p_clk); /* Set CLK to shift value */
	}

	GPIO_PinSet(p_cs);

	return u.data;
}
Esempio n. 2
0
File: main.c Progetto: yguo89/RTOS
static void sensorUnplug4( void )
{
	#if ENABLE_UART_PRINTF
	UARTprintf ( "Sensor 4 Unplug Task\n" );
	#endif
			   
	// Wait a few milliseconds to debounce the port interrupt
	Delay_MS( SENSOR_UNPLUG_DELAY );	  

	// If the sensor has been re-connected, abort the unplug routine.													 
	if( 1 == GPIO_Read( SensorPort4.int_port, SensorPort4.int_pin ) )	
	{
		GPIO_EnableInterrupts( SensorPort4.int_port, SensorPort4.int_pin );
	}
	else				
	{
		// Remove this sensor from the sensor task scheduler
		ActiveSensor[3] = -1;
		NumActiveSensors--;
		SensorSampRate[3] = 0;
		SampRateChanged = 1;

#if ENABLE_TRANSCEIVER
		// Remove sensor id 
		Transceiver_UnregisterSensor ( SensorPort4.port_number );
#endif

		// Change the interrupt to detect when a sensor is plugged into this port	  
		GPIO_SetInterruptTask( SensorPort4.int_port, SensorPort4.int_pin, GPIO_RISING_EDGE,
						   2, sensorDetect4 );
   	}

	// Kill this task
	vTaskDelete( NULL );
}
Esempio n. 3
0
File: main.c Progetto: yguo89/RTOS
// *************** InitializeSensorPorts **************
// Initilizes all sensor ports. Enables the INT pin and initializes the rx and tx
// fifos for each port.
static void InitializeSensorPorts( void )
{	
	unsigned long i;

	// Populate the array of sensor task function pointers					
	SensorTask[0] = (int (*)(PORT_T *))&SensorTask1;	   			
	SensorTask[1] = (int (*)(PORT_T *))&SensorTask2;			
	SensorTask[2] = (int (*)(PORT_T *))&SensorTask3;			
	SensorTask[3] = (int (*)(PORT_T *))&SensorTask4;			

	for( i = 0; i < NUM_SENSOR_PORTS; i++ )
	{
		// Enable the INT interrupt for each sensor port
		GPIO_Init( SensorPort[i]->int_port, SensorPort[i]->int_pin, GPIO_DIR_MODE_IN, 
		           GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD );   
		GPIO_SetInterruptTask( SensorPort[i]->int_port, SensorPort[i]->int_pin,
							   GPIO_RISING_EDGE, 2, SensorDetect[i] );	

		// Initialize and set high the ROM_CS pin high for each sensor port
		GPIO_Init( SensorPort[i]->rom_cs_port, SensorPort[i]->rom_cs_pin, GPIO_DIR_MODE_OUT, 
		           GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD );    
		GPIO_Set( SensorPort[i]->rom_cs_port, SensorPort[i]->rom_cs_pin ); 
		 
		// Intialize the RX and TX queues (FIFOs) for each port
		SensorPort[i]->rx_fifo = (void *)xQueueCreate( SENSOR_RX_QUEUE_SIZE,
													   sizeof( SENSOR_MSG_T ) );
		SensorPort[i]->tx_fifo = (void *)xQueueCreate( SENSOR_TX_QUEUE_SIZE, 
													   sizeof( SENSOR_MSG_T ) );			  
	}

	// If any sensors are already plugged in, trigger the detection routine.
	// No rising edge interrupt can happen because the pin is high before the
	// interrupt is enabled. 										 
	if( 0 != GPIO_Read( SensorPort1.int_port, SensorPort1.int_pin ) )
		sensorDetect1();											 
	if( 0 != GPIO_Read( SensorPort2.int_port, SensorPort2.int_pin ) )
		sensorDetect2();									 
	if( 0 != GPIO_Read( SensorPort3.int_port, SensorPort3.int_pin ) )
		sensorDetect3();									 
	if( 0 != GPIO_Read( SensorPort4.int_port, SensorPort4.int_pin ) )
		sensorDetect4();
}
Esempio n. 4
0
pio_type platform_pio_op( unsigned port, pio_type pinmask, int op )
{
  GPIO_TypeDef* base = ( GPIO_TypeDef* )port_data[ port ];
  GPIO_InitTypeDef data;
  pio_type retval = 1;
  
  GPIO_StructInit( &data );
  switch( op )
  {
    case PLATFORM_IO_PORT_SET_VALUE:    
      GPIO_Write( base, ( u8 )pinmask );
      break;
      
    case PLATFORM_IO_PIN_SET:
      GPIO_WriteBit( base, ( u8 )pinmask, Bit_SET );
      break;
      
    case PLATFORM_IO_PIN_CLEAR:
      GPIO_WriteBit( base, ( u8 )pinmask, Bit_RESET );
      break;
      
    case PLATFORM_IO_PORT_DIR_OUTPUT:
      pinmask = 0xFF;     
    case PLATFORM_IO_PIN_DIR_OUTPUT:
      data.GPIO_Direction = GPIO_PinOutput;
      data.GPIO_Type = GPIO_Type_PushPull ;
      data.GPIO_Alternate=GPIO_OutputAlt1;
      data.GPIO_Pin = ( u8 )pinmask;
      GPIO_Init(base, &data);
      break;
      
    case PLATFORM_IO_PORT_DIR_INPUT:
      pinmask = 0xFF;     
    case PLATFORM_IO_PIN_DIR_INPUT:
      data.GPIO_Pin = ( u8 )pinmask;
      GPIO_Init(base, &data);
      break;    
            
    case PLATFORM_IO_PORT_GET_VALUE:
      retval = GPIO_Read( base );
      break;
      
    case PLATFORM_IO_PIN_GET:
      retval = GPIO_ReadBit( base, ( u8 )pinmask );
      break;
      
    default:
      retval = 0;
      break;
  }
  return retval;
}
Esempio n. 5
0
File: main.c Progetto: yguo89/RTOS
static void sensorInit4( void )
{
	unsigned short  eeprom_addr = 0x1800;
	unsigned short  driver_size = 0x700;
	unsigned char  *node_addr   = NULL;

	#if ENABLE_UART_PRINTF
	UARTprintf( "Sensor 4 Init\n" );
	#endif		 

	// Wait a few milliseconds to debounce the port interrupt	
	Delay_MS(SENSOR_INIT_DELAY);

	// If a sensor is no longer plugged in, abort the initialization.														 
	if( 0 == GPIO_Read( SensorPort4.int_port, SensorPort4.int_pin ) )	
	{
		GPIO_EnableInterrupts( SensorPort4.int_port, SensorPort4.int_pin );
	}
	else				
	{
		// Read in the sensor driver from this sensor's EEPROM 
		node_addr = (unsigned char *)SensorDriver4Ptr;			  
    	EEPROM_Open( SensorPort4.rom_cs_port, SensorPort4.rom_cs_pin );
    	EEPROM_ReadBurst( eeprom_addr, node_addr, driver_size );	  		  
    	EEPROM_Close( SensorPort4.rom_cs_port, SensorPort4.rom_cs_pin );

		// Call the sensor_init routine
		SensorInit4( (PORT_T *)&SensorPort4 );
	
		// Call the sensor_config routine
		SensorConfig4( (PORT_T *)&SensorPort4 );

#if ENABLE_TRANSCEIVER
		// Send sensor id to transceiver
		Transceiver_RegisterSensor ( SensorPort4.port_number, SensorPort4.sensor_id );
#endif
		
		taskENTER_CRITICAL();
		SensorSampRate[3] = 1;
		SampRateChanged   = 1;
		ActiveSensor[3]   = 1;
		NumActiveSensors++;	
		taskEXIT_CRITICAL();
										  
		GPIO_SetInterruptTask( SensorPort4.int_port, SensorPort4.int_pin, GPIO_FALLING_EDGE,
							   2, sensorDetectUnplug4 );	
	}

	// Kill this task
	vTaskDelete( NULL );	 
}
Esempio n. 6
0
int main(void)
{
	SIM_COPC = 0x00;		//Deshabilito el watchdog
	CLK_init();	//Activo relojes de PORTA y PORTB, Core Clock = 47.972.352 Hz, Bus Clock = 23.986.176 Hz, desactivo WDOG

	GPIO_Init(PORT_A, 11, IO_MUX | PULL_UP | PULL_EN);	//Selecciono MUX de IO para PTA11
	GPIO_Init(PORT_A, 9, IO_MUX | PULL_UP | PULL_EN);	//Selecciono MUX de IO para PTA9
	GPIO_Init(PORT_A, 10, IO_MUX);	//Selecciono MUX de IO para PTA10
	GPIO_Init(PORT_A, 8, IO_MUX);	//Selecciono MUX de IO para PTA8
	GPIO_IO(PORT_A, 11, INPUT);		//Configuro PTA11 como entrada
	GPIO_IO(PORT_A, 9, INPUT);		//Configuro PTA9 como entrada
	GPIO_IO(PORT_A, 10, OUTPUT);	//Configuro PTA10 como salida
	GPIO_IO(PORT_A, 8, OUTPUT);		//Configuro PTA8 como salida
    for (;;) {

    	estado = GPIO_Read(PORT_A, 11);
    	if (!estado)
			{
				GPIO_Set(PORT_A, 10);
			}
    	else if (estado)
			{
				GPIO_Clear(PORT_A, 10);
			}
    	estado1 = GPIO_Read(PORT_A, 9);
    	if (!estado1)
			{
				GPIO_Set(PORT_A, 8);
			}
    	else if (estado1)
			{
				GPIO_Clear(PORT_A, 8);
			}

    }
    /* Never leave main */
    return 0;
}
Esempio n. 7
0
readByte(char *byte, int lastbyte)
{
	int idx;
	*byte = 0x0;
	for(idx=7 ; idx >= 0 ; --idx)
	{
		GPIO_Set(SDA);
		wait();
		GPIO_Set(SCL);
		wait();
		
		char cs = (GPIO_Read()&SDA)>>SDA_OFFSET;
		char myByte = ((GPIO_Read()&SDA)>>SDA_OFFSET)<<idx;
		*byte |= ((GPIO_Read()&SDA)>>SDA_OFFSET)<<idx;
		
		GPIO_Clr(SCL);
	}
	if(lastbyte == 1)
		GPIO_Set(SDA);//NACK
	else
		GPIO_Clr(SDA);//ACK
		
	giveClk();
}
Esempio n. 8
0
unsigned int writeByte(char *byte)
{
	int idx, count;
	count = 0;
	do{
		for(idx=7 ; idx >=  0 ; idx--)
		{
			int c = ((*byte)>>idx)&0x1;
			if(c==1)
				GPIO_Set(SDA);
			else
				GPIO_Clr(SDA);
			
			giveClk();
		}
		giveClk();
		++count;
	}while((count <= MAX_SEND) &&(GPIO_Read()&SDA == 0)); //Verifica se ainda é NACK, enquanto for tenta enviar os dados
	//if(GPIO_Read()&SDA != 0) return 1;  //Faz read ao ACK que vem do dispositivo para garantir que recebeu bem os dados
	if(count > MAX_SEND) return -1;
	return 1;
}
Esempio n. 9
0
void Linesensor_Update(void){
	++_counter;
	switch(_counter){
		case 1	:	
					GPIO_Set(_OutputPins[0],1);
					GPIO_Set(_OutputPins[2],1);
					GPIO_Set(_OutputPins[6],1);
					GPIO_Set(_OutputPins[11],1);
					break;
		case 2	:	
					GPIO_Set(_OutputPins[0],0);
					GPIO_Set(_OutputPins[2],0);
					GPIO_Set(_OutputPins[6],0);
					GPIO_Set(_OutputPins[11],0);
					break;
		case 3	:	
					_Readings[0] = GPIO_Read(_InputPins[0]);
					_Readings[2] = GPIO_Read(_InputPins[2]);
					_Readings[6] = GPIO_Read(_InputPins[6]);
					_Readings[11] = GPIO_Read(_InputPins[11]);
					GPIO_Set(_OutputPins[3],1);
					GPIO_Set(_OutputPins[5],1);
					GPIO_Set(_OutputPins[8],1);
					GPIO_Set(_OutputPins[10],1);
					break;
		case 4	:	
					GPIO_Set(_OutputPins[3],0);
					GPIO_Set(_OutputPins[5],0);
					GPIO_Set(_OutputPins[8],0);
					GPIO_Set(_OutputPins[10],0);
					break;
		case 5	:	
					_Readings[3] = GPIO_Read(_InputPins[3]);
					_Readings[5] = GPIO_Read(_InputPins[5]);
					_Readings[8] = GPIO_Read(_InputPins[8]);
					_Readings[10] = GPIO_Read(_InputPins[10]);
					GPIO_Set(_OutputPins[1],1);
					GPIO_Set(_OutputPins[4],1);
					GPIO_Set(_OutputPins[7],1);
					GPIO_Set(_OutputPins[9],1);
					break;
		case 6	:	
					GPIO_Set(_OutputPins[1],0);
					GPIO_Set(_OutputPins[4],0);
					GPIO_Set(_OutputPins[7],0);
					GPIO_Set(_OutputPins[9],0);
					break;
		case 7	:	
					_Readings[1] = GPIO_Read(_InputPins[1]);
					_Readings[4] = GPIO_Read(_InputPins[4]);
					_Readings[7] = GPIO_Read(_InputPins[7]);
					_Readings[9] = GPIO_Read(_InputPins[9]);
					break;
		case 10	:	
					_counter = 0;
					break;
	}
	return;
}
Esempio n. 10
0
File: Sensor.c Progetto: yguo89/RTOS
// *************** Sensor_ReadGPIO *************** 
int Sensor_ReadGPIO( PORT_T *port, SENSOR_GPIO_T pin )
{
	return GPIO_Read( port->gpio_port[pin], port->gpio_pin[pin] );
}									  
Esempio n. 11
0
/* Devolve 0 se o LED está apagado e um valor diferente de zero no caso
contrário. */
int LED_GetState(){
	return ledOutPut & GPIO_Read();
}