void Chip_ADS1248_SelfOffsetCal(uint8_t chip)
{
Chip_SSP_DATA_SETUP_T xf_setup;
xf_setup.length = BUFFER_SIZE;
xf_setup.rx_cnt = 0;
xf_setup.tx_cnt = 0;
xf_setup.rx_data = rx_buf;
xf_setup.tx_data = tx_buf;
Chip_ADS1248_BufferInit();
tx_buf[0] = SELFOCAL;
if(chip == CHIP_U1)
{
Chip_GPIO_SetPinOutLow(LPC_GPIO, ADS_nSSEL0); //Chip select Low(0)
Chip_SSP_RWFrames_Blocking(ADS_SSP, &xf_setup);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_nSSEL0); //Chip select High(1)
}
else
{
Chip_GPIO_SetPinOutLow(LPC_GPIO, ADS_nSSEL1); //Chip select Low(0)
Chip_SSP_RWFrames_Blocking(ADS_SSP, &xf_setup);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_nSSEL1); //Chip select High(1)
}
return;
}
uint8_t Chip_ADS1248_ReadRegister(uint8_t chip, uint8_t address)
{
Chip_SSP_DATA_SETUP_T xf_setup;
xf_setup.length = BUFFER_SIZE;
xf_setup.rx_cnt = 0;
xf_setup.tx_cnt = 0;
xf_setup.rx_data = rx_buf;
xf_setup.tx_data = tx_buf;
Chip_ADS1248_BufferInit();
tx_buf[0] = (RREG | address); //Register address 0010 rrrr, 'r' being register address
tx_buf[1] = 0; //Num_of_bytes - 1
if(chip == CHIP_U1)
{
Chip_GPIO_SetPinOutLow(LPC_GPIO, ADS_nSSEL0); //Chip select Low(0)
Chip_SSP_RWFrames_Blocking(ADS_SSP, &xf_setup);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_nSSEL0); //Chip select High(1)
}
else
{
Chip_GPIO_SetPinOutLow(LPC_GPIO, ADS_nSSEL1); //Chip select Low(0)
Chip_SSP_RWFrames_Blocking(ADS_SSP, &xf_setup);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_nSSEL1); //Chip select High(1)
}
return rx_buf[2]; //during transmission 2 rcv. bytes are junk, third is the reg. value
}
void Chip_ADS1248_WriteRegister(uint8_t chip, uint8_t address, uint8_t value)
{
Chip_SSP_DATA_SETUP_T xf_setup;
xf_setup.length = BUFFER_SIZE;
xf_setup.rx_cnt = 0;
xf_setup.tx_cnt = 0;
xf_setup.rx_data = rx_buf;
xf_setup.tx_data = tx_buf;
Chip_ADS1248_BufferInit();
tx_buf[0] = (WREG | address); //Register address 0010 rrrr, 'r' being register address
tx_buf[1] = 0; //Num_of_bytes - 1
tx_buf[2] = value; //Register value
if(chip == CHIP_U1)
{
Chip_GPIO_SetPinOutLow(LPC_GPIO, ADS_nSSEL0); //Chip select Low(0)
Chip_SSP_RWFrames_Blocking(ADS_SSP, &xf_setup);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_nSSEL0); //Chip select High(1)
}
else
{
Chip_GPIO_SetPinOutLow(LPC_GPIO, ADS_nSSEL1); //Chip select Low(0)
Chip_SSP_RWFrames_Blocking(ADS_SSP, &xf_setup);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_nSSEL1); //Chip select High(1)
}
return;
}
/*Función para encender uno o más leds dentro del led RGB.*/
void RGBon (edu_CIAA_ledRGB *rgb){
if (rgb->red != 0){
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, LED_RGB_R_GPIO_NUMBER, LED_RGB_R_GPIO_PIN);
}
if (rgb->green != 0){
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, LED_RGB_G_GPIO_NUMBER, LED_RGB_G_GPIO_PIN);
}
if (rgb->blue != 0){
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, LED_RGB_B_GPIO_NUMBER, LED_RGB_B_GPIO_PIN);
}
}
/*Función para encender alguno de los leds 1, 2 y 3. Qué led se enciende
* depende del parámetro "led", que recibe la función.*/
void LEDon(uint8_t led) {
switch(led){
case LED_ROJO: // Led 1
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, LED_1_GPIO_NUMBER, LED_1_GPIO_PIN);
break;
case LED_AMARILLO: // Led 2
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, LED_2_GPIO_NUMBER, LED_2_GPIO_PIN);
break;
case LED_VERDE: // Led 3
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, LED_3_GPIO_NUMBER, LED_3_GPIO_PIN);
break;
}
}
void Board_GPIOs_writeValue(int32_t gpioNumber,uint8_t value)
{
if(value)
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, gpiosInfo[gpioNumber].gpio, gpiosInfo[gpioNumber].gpioBit);
else
Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, gpiosInfo[gpioNumber].gpio, gpiosInfo[gpioNumber].gpioBit);
}
/*Enciende leds como parametro puerto y pin*/
void PrenderLed(int PIN){
int puerto;
int pin=PIN;
/**/
switch(pin){
case 14 :
puerto=0;
break;
case 11 :
case 12 :
puerto=1;
break;
case 0 :
case 1 :
case 2 :
puerto=5;
break; /* optional */
/* you can have any number of case statements */
default : /* Optional */
break;
}
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,puerto,pin);
}
uint32_t PWMSetWidth(uint8_t channel, uint8_t output, uint32_t width) {
if (output >= MAX_OUTPUTS || channel > CHANNEL_C_TIMER_INDEX) {
return 1;
}
if (eDVSMode != EDVS_MODE_INTERNAL && channel == 0) {
return 1; // channel 0 taken for master/slave mode
}
LPC_TIMER_T * timer = halTimers[channel].timer;
halTimers[channel].witdh[output] = width;
halTimers[channel].enabled[output] = ENABLE;
/**
* Since we have to use the Core M0 to overcome hardware limitations
* when the width is 0 or bigger than the period of the wave,
* the output is set as GPIO and driven accordingly.
*/
if (width == 0) { //Set GPIO Low
Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, halTimers[channel].portGpio[output],
halTimers[channel].pinGpio[output]);
Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, halTimers[channel].portGpio[output], halTimers[channel].pinGpio[output]);
Chip_SCU_PinMuxSet(halTimers[channel].port[output], halTimers[channel].pin[output],
halTimers[channel].gpioMode[output]);
} else if (width >= timer->MR[2]) { //Set GPIO High
Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, halTimers[channel].portGpio[output],
halTimers[channel].pinGpio[output]);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, halTimers[channel].portGpio[output], halTimers[channel].pinGpio[output]);
Chip_SCU_PinMuxSet(halTimers[channel].port[output], halTimers[channel].pin[output],
halTimers[channel].gpioMode[output]);
} else {
Chip_TIMER_SetMatch(timer, halTimers[channel].timerChannel[output], width);
Chip_SCU_PinMuxSet(halTimers[channel].port[output], halTimers[channel].pin[output],
halTimers[channel].timerMode[output]);
}
return 0;
}
void PrenderLed(void) // Led Amarillo
//uint8_t LED;
//switch LED
//case
{
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,0,14);
}
void writeToSPI(int length) {
spi.length = length;
spi.rx_cnt = 0;
spi.tx_cnt = 0;
Chip_GPIO_SetPinOutLow(LPC_GPIO, CSN_PORT, CSN_PIN);
Chip_SSP_RWFrames_Blocking(LPC_SSP1, &spi);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, CSN_PORT, CSN_PIN);
}
/**
* Methods
*/
void nRF24L01PInit(unsigned char transmitMode) {
Chip_GPIO_SetPinOutHigh(LPC_GPIO, CSN_PORT, CSN_PIN);
Chip_GPIO_SetPinDIROutput(LPC_GPIO, CSN_PORT, CSN_PIN);
Chip_GPIO_SetPinOutLow(LPC_GPIO, NORDIC_CE_PORT, NORDIC_CE_PIN);
Chip_GPIO_SetPinDIROutput(LPC_GPIO, NORDIC_CE_PORT, NORDIC_CE_PIN);
Chip_GPIO_SetPinDIRInput(LPC_GPIO, NORDIC_IRQ_PORT, NORDIC_IRQ_PIN);
nRF24L01P.mode = NRF24L01P_MODE_UNKNOWN;
nRF24L01P.transmissionTimeout = -1;
nRF24L01P.payloadsinTXFIFO = 0;
RFdisable();
Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_SSP1);
Chip_SSP_Set_Mode(LPC_SSP1, SSP_MODE_MASTER);
Chip_SSP_SetFormat(LPC_SSP1, SSP_BITS_8, SSP_FRAMEFORMAT_SPI, SSP_CLOCK_CPHA0_CPOL0); // 8-bit, ClockPhase = 0, ClockPolarity = 0
Chip_SSP_SetBitRate(LPC_SSP1, NRF24L01P_SPI_MAX_DATA_RATE / 2); // 2Mbit, 1/5th the maximum transfer rate for the SPI bus
Chip_SSP_Enable(LPC_SSP1);
RingBuffer_Init(&nordicTxBuffer, nordictxBufferArray, 1, TX_BUFFER_SIZE);
memset(&spi, 0, sizeof(spi));
spi.tx_data = spiBufferTx;
spi.rx_data = spiBufferRx;
timerDelayUs(NRF24L01P_TIMING_Tundef2pd_us); // Wait for Power-on reset
RFsetRegister(NRF24L01P_REG_CONFIG, 0); // Power Down
RFsetRegister(NRF24L01P_REG_STATUS, NRF24L01P_STATUS_MAX_RT | NRF24L01P_STATUS_TX_DS | NRF24L01P_STATUS_RX_DR); // Clear any pending interrupts
RFsetRegister(NRF24L01P_REG_FEATURE, NRF24L01P_EN_DYN_ACK | NRF24L01P_EN_ACK_PAY | NRF24L01P_EN_DPL); //Enabled no ack packages
RFsetRegister(NRF24L01P_REG_DYNPD, NRF24L01P_DPL_P0);
RFsetRegister(NRF24L01P_REG_RF_SETUP, 0); // Clear this register
//
// Setup default configuration
//
RFdisableAllRxPipes();
RFsetFrequency(DEFAULTNRF24L01P_RF_FREQUENCY);
RFsetAirDataRate(DEFAULTNRF24L01P_DATARATE);
RFsetRfOutputPower(DEFAULTNRF24L01P_TX_PWR);
RFsetCrcWidth(DEFAULTNRF24L01P_CRC);
RFsetTxAddress(DEFAULTNRF24L01P_ADDRESS, DEFAULTNRF24L01P_ADDRESS_WIDTH);
RFsetRxAddress(DEFAULTNRF24L01P_ADDRESS, DEFAULTNRF24L01P_ADDRESS_WIDTH, NRF24L01P_PIPE_P0);
RFenableAutoRetransmit(250, 3);
RFdisableAutoAcknowledge();
RFenableAutoAcknowledge(NRF24L01P_PIPE_P0);
RFsetTransferSize(DEFAULTNRF24L01P_TRANSFER_SIZE, NRF24L01P_PIPE_P0);
nRF24L01P.mode = NRF24L01P_MODE_POWER_DOWN;
if (transmitMode) {
RFsetTransmitMode();
} else {
RFsetReceiveMode();
}
RFenable();
}
void PrenderLEDS(void){
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 1, 12); //VERDE
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 0, 14); //ROJO
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 1, 11); //AMARILLO
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 0); //R,G,B
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 1);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 2);
}
int main(void) {
uint32_t prompt = 0, rdCnt = 0;
volatile bool start_trigger = false;
#if defined (M0_SLAVE_PAUSE_AT_MAIN)
// Pause execution until debugger attaches and modifies variable
while (pause_at_main == 0) {
}
#endif
init_g_vInitHardware();
// usb_g_vInit();
// init the interface
SGPIO_spiInit();
// ipc_g_vInit();
// set direction of u4
Chip_SCU_PinMux(2, 10, SCU_MODE_PULLUP, SCU_MODE_FUNC0);
Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, 14);
Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, 0, 14);
//SysTick_Config(120000000/1000);
// CS_Pin
Chip_SCU_PinMux(0, 1, SCU_MODE_PULLUP, SCU_MODE_FUNC0);
Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, 1);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 0, 1);
// radar_g_vDefaultInit();
while (1) {
// if (start_trigger) {
// radar_mg_vPLLRampUp();
// radar_mg_vPLLActivateModulation();
// for (uint32_t i = 0; i < 40000000; i++)
// ;
// radar_mg_vPLLDeactivateModulation();
// radar_mg_vPLLRampDown();
// radar_mg_vPLLActivateModulation();
// for (uint32_t i = 0; i < 40000000; i++)
// ;
// radar_mg_vPLLDeactivateModulation();
//
// }
}
while(1);
}
static void pinConfig(void)
{
// PE.15 FUNC4 => GPIO7[15] output for CS
Chip_SCU_PinMuxSet(0xE, 15, SCU_MODE_PULLDOWN | FUNC4);
Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 7, 15);
// P8.1 FUNC0 => GPIO4[1] input for TP_IRQ
Chip_SCU_PinMuxSet(0x8, 1, SCU_MODE_INACT | SCU_MODE_INBUFF_EN | FUNC0);
Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 4, 1);
// CS is controlled via PE.15 (GPIO7[16]) and not SSP0_SSEL.
// Pin PF.1 should be configured as GPIO and set high.
Chip_SCU_PinMuxSet(0xf, 1, SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_HIGHSPEEDSLEW_EN | FUNC4);
Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 7, 16);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 7, 16);
}
void InitSPI ()
{
Chip_IOCON_PinMux(LPC_IOCON,TOUCH_E,IOCON_MODE_PULLUP,IOCON_FUNC0);
Chip_GPIO_SetPinDIROutput(LPC_GPIO,TOUCH_E);
Chip_IOCON_DisableOD(LPC_IOCON,TOUCH_E);
Chip_GPIO_SetPinOutHigh(LPC_GPIO,TOUCH_E);
Chip_IOCON_PinMux(LPC_IOCON,TOUCH_CLK,IOCON_MODE_INACT,IOCON_FUNC2);
Chip_IOCON_PinMux(LPC_IOCON,TOUCH_MOSI,IOCON_MODE_INACT,IOCON_FUNC2);
Chip_IOCON_PinMux(LPC_IOCON,TOUCH_MISO,IOCON_MODE_INACT,IOCON_FUNC2);
Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_SSP0);
Chip_SSP_Set_Mode(LPC_SSP0,SSP_MASTER_MODE);
Chip_SSP_SetFormat(LPC_SSP0,SSP_BITS_8,SSP_FRAMEFORMAT_SPI,SSP_CLOCK_CPHA0_CPOL0);
Chip_SSP_SetBitRate(LPC_SSP0,1000000 );
Chip_SSP_Enable(LPC_SSP0);
}
void Board_KEYBOARD_tick_ms(void)
{
if(keyboardInfo.enable==1)
{
switch(keyboardInfo.state)
{
case KEYBOARD_SCAN_STATE_START:
{
keyboardInfo.currentCol=0;
keyboardInfo.state=KEYBOARD_SCAN_STATE_COL_LOW;
break;
}
case KEYBOARD_SCAN_STATE_COL_LOW:
{
if(keyboardInfo.currentCol>=keyboardInfo.columns)
{
keyboardInfo.state=KEYBOARD_SCAN_STATE_START;
}
else
{
// set col low
Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, keyboardColsPinInfo[keyboardInfo.currentCol].gpio, keyboardColsPinInfo[keyboardInfo.currentCol].gpioBit);
keyboardInfo.state=KEYBOARD_SCAN_STATE_READ_ROWS;
}
break;
}
case KEYBOARD_SCAN_STATE_READ_ROWS:
{
// read rows
int row;
for(row=0; row<keyboardInfo.rows;row++)
{
int rowVal = Chip_GPIO_GetPinState(LPC_GPIO_PORT, keyboardRowsPinInfo[row].gpio, keyboardRowsPinInfo[row].gpioBit);
keyboardInfo.stateMatrix[row][keyboardInfo.currentCol] = rowVal;
}
// set col high
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, keyboardColsPinInfo[keyboardInfo.currentCol].gpio, keyboardColsPinInfo[keyboardInfo.currentCol].gpioBit);
keyboardInfo.currentCol++;
keyboardInfo.state=KEYBOARD_SCAN_STATE_COL_LOW;
break;
}
}
}
}
/* Initialize Pin Muxing for LCD */
void Board_LCD_Init(void)
{
uint32_t val;
Board_SSP_Init(LCD_SSP);
val = LCD_SSP->CR0 & 0xFFFF;
Chip_SCU_PinMuxSet(LCD_CDM_PORT, LCD_CMD_PIN, LCD_CMD_CFG);
Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, LCD_CMD_GPIO_PORT, LCD_CMD_GPIO_PIN);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, LCD_CMD_GPIO_PORT, LCD_CMD_GPIO_PIN);
/* Enable the SSP interface */
Chip_SSP_Init(LCD_SSP);
Chip_SSP_Set_Mode(LCD_SSP, SSP_MODE_MASTER);
Chip_SSP_SetFormat(LCD_SSP, SSP_BITS_8, SSP_FRAMEFORMAT_SPI, SSP_CLOCK_CPHA1_CPOL1);
Chip_SSP_SetBitRate(LCD_SSP, LCD_BIT_RATE);
Chip_SSP_Enable(LCD_SSP);
lcd_cfg_val = LCD_SSP->CR0 & 0xFFFF;
LCD_SSP->CR0 = val;
}
int __attribute__ ((noinline)) main(void)
{
/* set systick and start systick interrupt */
SysTick_Config(SYS_CORE_CLOCK/1000UL*(unsigned long)SYS_TICK_PERIOD_IN_MS);
/* turn on GPIO */
Chip_GPIO_Init(LPC_GPIO_PORT);
/* disable SWCLK and SWDIO, after reset, boot code may activate this */
Chip_SWM_DisableFixedPin(2);
Chip_SWM_DisableFixedPin(3);
/* turn on IOCON */
Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_IOCON);
/* turn on switch matrix */
Chip_SWM_Init();
/* activate analog comperator */
Chip_ACMP_Init(LPC_CMP);
/* let LED on pin 4 of the DIP8 blink */
Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, 2);
for(;;)
{
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 0, 2);
delay_micro_seconds(500000UL);
Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, 0, 2);
delay_micro_seconds(500000UL);
}
/* enter sleep mode: Reduce from 1.4mA to 0.8mA with 12MHz */
while (1)
{
SCB->SCR |= (1UL << SCB_SCR_SLEEPONEXIT_Pos); /* enter sleep mode after interrupt */
Chip_PMU_SleepState(LPC_PMU); /* enter sleep mode now */
}
}
void Board_KEYBOARD_Init(uint8_t rows, uint8_t columns)
{
keyboardInfo.enable=0;
if(rows>KEYBOARD_MAX_ROWS)
rows=KEYBOARD_MAX_ROWS;
if(columns>KEYBOARD_MAX_COLUMNS)
columns=KEYBOARD_MAX_COLUMNS;
keyboardInfo.rows=rows;
keyboardInfo.columns=columns;
// configure Rows (Input)
for(i=0 ; i<rows; i++)
{
Chip_SCU_PinMuxSet(keyboardRowsPinInfo[i].port, keyboardRowsPinInfo[i].portBit, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | keyboardRowsPinInfo[i].func));
Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, keyboardRowsPinInfo[i].gpio, keyboardRowsPinInfo[i].gpioBit);
}
// configure Columns (output)
for(i=0 ; i<columns; i++)
{
Chip_SCU_PinMuxSet(keyboardColsPinInfo[i].port, keyboardColsPinInfo[i].portBit, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | keyboardColsPinInfo[i].func));
Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, keyboardColsPinInfo[i].gpio, keyboardColsPinInfo[i].gpioBit);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, keyboardColsPinInfo[i].gpio, keyboardColsPinInfo[i].gpioBit);
}
keyboardInfo.state=KEYBOARD_SCAN_STATE_START;
for(r=0; r<KEYBOARD_MAX_ROWS; r++)
{
for(c=0; c<KEYBOARD_MAX_COLUMNS; c++)
keyboardInfo.stateMatrix[r][c]=1;
}
keyboardInfo.enable=1;
}
void encender_led (int led_n)
{
if (led_n==1)
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 0, 14 );
if (led_n==2)
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 1, 11 );
if (led_n==3)
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 1, 12 );
if (led_n==LED_ROJO )
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, LED_RGB_PORT, LED_RGB_ROJO );
if (led_n==LED_VERDE )
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, LED_RGB_PORT, LED_RGB_VERDE );
if (led_n==LED_AZUL )
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, LED_RGB_PORT, LED_RGB_AZUL );
}
void Chip_ADS1248_Init()
{
Chip_SSP_DeInit(ADS_SSP); //Clear previous setup
Chip_GPIO_Init(LPC_GPIO); //Init GPIO
Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_IOCON);
Chip_IOCON_PinMuxSet(LPC_IOCON, ADS_SCLK, IOCON_FUNC2); //SCLK
Chip_IOCON_PinMuxSet(LPC_IOCON, ADS_MOSI, IOCON_FUNC2); //MOSI
Chip_IOCON_PinMuxSet(LPC_IOCON, ADS_MISO, IOCON_FUNC2); //MISO
Chip_IOCON_PinMuxSet(LPC_IOCON, ADS_nSSEL1, IOCON_FUNC0 | IOCON_MODE_PULLUP);
Chip_IOCON_PinMuxSet(LPC_IOCON, ADS_START1, IOCON_FUNC0 | IOCON_MODE_PULLUP);
Chip_IOCON_PinMuxSet(LPC_IOCON, ADS_nRESET1,IOCON_FUNC0 | IOCON_MODE_PULLUP);
Chip_IOCON_PinMuxSet(LPC_IOCON, ADS_nSSEL0, IOCON_FUNC0 | IOCON_MODE_PULLUP);
Chip_IOCON_PinMuxSet(LPC_IOCON, ADS_START0, IOCON_FUNC0 | IOCON_MODE_PULLUP);
Chip_IOCON_PinMuxSet(LPC_IOCON, ADS_nRESET0,IOCON_FUNC0 | IOCON_MODE_PULLUP);
Chip_IOCON_PinMuxSet(LPC_IOCON, ADS_nDRDY0, IOCON_FUNC0 | IOCON_MODE_PULLUP);
Chip_IOCON_PinMuxSet(LPC_IOCON, ADS_nDRDY1, IOCON_FUNC0 | IOCON_MODE_PULLUP);
Chip_GPIO_SetPinDIROutput(LPC_GPIO, ADS_nSSEL1);
Chip_GPIO_SetPinDIROutput(LPC_GPIO, ADS_START1);
Chip_GPIO_SetPinDIROutput(LPC_GPIO, ADS_nRESET1);
Chip_GPIO_SetPinDIROutput(LPC_GPIO, ADS_nSSEL0);
Chip_GPIO_SetPinDIROutput(LPC_GPIO, ADS_START0);
Chip_GPIO_SetPinDIROutput(LPC_GPIO, ADS_nRESET0);
Chip_GPIO_SetPinDIRInput(LPC_GPIO, ADS_nDRDY0);
Chip_GPIO_SetPinDIRInput(LPC_GPIO, ADS_nDRDY1);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_nSSEL1);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_nRESET1);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_START1);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_nSSEL0);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_nRESET0);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_START0);
Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_PINT);
Chip_SYSCTL_SetPinInterrupt(0, ADS_nDRDY0);
Chip_PININT_SetPinModeEdge(LPC_PININT, PININTCH(0));
Chip_PININT_EnableIntLow(LPC_PININT, PININTCH(0));
Chip_SYSCTL_EnablePINTWakeup(0);
Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_PINT);
Chip_SYSCTL_SetPinInterrupt(1, ADS_nDRDY1);
Chip_PININT_SetPinModeEdge(LPC_PININT, PININTCH(1));
Chip_PININT_EnableIntLow(LPC_PININT, PININTCH(1));
Chip_SYSCTL_EnablePINTWakeup(1);
Chip_SSP_Init(ADS_SSP);
ssp_format.frameFormat = SSP_FRAMEFORMAT_SPI; //SPI Frame
ssp_format.bits = SSP_BITS_8; //8bits
ssp_format.clockMode = SSP_CLOCK_CPHA1_CPOL0; //CPHA=1, CPOL=0
Chip_SSP_SetFormat(ADS_SSP, ssp_format.bits, ssp_format.frameFormat, ssp_format.clockMode);
Chip_SSP_Set_Mode(ADS_SSP, SSP_MODE_MASTER);
Chip_SSP_SetClockRate(ADS_SSP, 1, 16);
Chip_Clock_SetSSP1ClockDiv(1);
Chip_SSP_Enable(ADS_SSP);
ADS1248_PeriphInit(CHIP_U1);
ADS1248_PeriphInit(CHIP_U3);
}
int PrenderLED(int LED, int COLOR){
switch (LED) {
case VERDE:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 1, 12);
break;
case AMARILLO:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 0, 14);
break;
case ROJO:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 1, 11);
break;
case RGB:
switch(COLOR){
case RGBROJO:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 0);
break;
case RGBVERDE:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 1);
break;
case RGBAZUL:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 2);
break;
case RGBBLANCO:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 0);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 1);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 2);
break;
case RGBMAGENTA:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 0);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 2);
break;
case RGBAMARILLO:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 0);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 1);
break;
case RGBCIAN:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 1);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 2);
break;
default: return 0;
}
break;
default: return 0;
break;
}
return 1;
}
void led_on(void){
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5 , 1);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5 , 2);
}
void RFenable(void) {
Chip_GPIO_SetPinOutHigh(LPC_GPIO, NORDIC_CE_PORT, NORDIC_CE_PIN);
timerDelayUs( NRF24L01P_TIMING_Tpece2csn_us);
}
int32_t Chip_ADS1248_GetTemperature(uint8_t chip, uint8_t rtd)
{
uint32_t temperatura_raw = 0;
int32_t temperatura = 0;
Chip_SSP_DATA_SETUP_T xf_setup;
if(chip == CHIP_U1)
{
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_START0);
temperatura_raw = Chip_ADS1248_ReadRegister(CHIP_U1, MUX0);
if(rtd == RTD_1)
{
Chip_ADS1248_WriteRegister(chip, MUX0, 0x01);
Chip_ADS1248_WriteRegister(chip, IDAC1, 0x8F);
}
else
{
Chip_ADS1248_WriteRegister(chip, MUX0, 0x13);
Chip_ADS1248_WriteRegister(chip, IDAC1, 0x9F);
}
temperatura_raw = Chip_ADS1248_ReadRegister(CHIP_U1, MUX0);
temperatura_raw = Chip_ADS1248_ReadRegister(CHIP_U1, IDAC1);
Chip_ADS1248_BufferInit();
xf_setup.length = BUFFER_SIZE;
xf_setup.rx_cnt = 0;
xf_setup.tx_cnt = 0;
xf_setup.rx_data = rx_buf;
xf_setup.tx_data = tx_buf;
tx_buf[0] = RDATA;
Chip_GPIO_SetPinOutLow(LPC_GPIO, ADS_START0);
NVIC_EnableIRQ(PIN_INT0_IRQn);
osSignalWait(0x0004, osWaitForever);
NVIC_DisableIRQ(PIN_INT0_IRQn);
Chip_GPIO_SetPinOutLow(LPC_GPIO, ADS_nSSEL0); //Chip select Low(0)
Chip_SSP_RWFrames_Blocking(ADS_SSP, &xf_setup);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_nSSEL0); //Chip select High(1)
}
else
{
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_START1);
if(rtd == RTD_3)
{
Chip_ADS1248_WriteRegister(chip, MUX0, 0x01);
Chip_ADS1248_WriteRegister(chip, IDAC1, 0x8F);
}
else
{
Chip_ADS1248_WriteRegister(chip, MUX0, 0x13);
Chip_ADS1248_WriteRegister(chip, IDAC1, 0x9F);
}
Chip_ADS1248_BufferInit();
xf_setup.length = BUFFER_SIZE;
xf_setup.rx_cnt = 0;
xf_setup.tx_cnt = 0;
xf_setup.rx_data = rx_buf;
xf_setup.tx_data = tx_buf;
tx_buf[0] = RDATA;
Chip_GPIO_SetPinOutLow(LPC_GPIO, ADS_START1);
NVIC_EnableIRQ(PIN_INT1_IRQn);
osSignalWait(0x0005, osWaitForever);
NVIC_DisableIRQ(PIN_INT1_IRQn);
Chip_GPIO_SetPinOutLow(LPC_GPIO, ADS_nSSEL1); //Chip select Low(0)
Chip_SSP_RWFrames_Blocking(ADS_SSP, &xf_setup);
Chip_GPIO_SetPinOutHigh(LPC_GPIO, ADS_nSSEL1);
}
temperatura_raw = ((rx_buf[1] << 16) & 0x00ff0000) |
((rx_buf[2] << 8) & 0x0000ff00) |
(rx_buf[3] & 0xff);
temperatura = GetTemperature(temperatura_raw);
return temperatura;
}
int LED::set_led(void)
{
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,0,this->pvt_pin_number);
return 0;
}
void prenderled(uint8_t cualprendo) // defino la funcion para prender leds
{
switch (cualprendo)
{
case 1:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,5,0); // seteo el led rgb rojo
break;
case 2:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,5,1); // seteo el led rgb verde
break;
case 3:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,5,2); // seteo el led rgb azul
break;
case 4:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,0,14); // seteo el led 1
break;
case 5:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,1,11); // seteo el led 2
break;
case 6:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,1,12); // seteo el led 3
break;
default:
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,5,0); // seteo el led rgb rojo
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,5,1); // seteo el led rgb verde
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,5,2); // seteo el led rgb azul
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,0,14); // seteo el led 1
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,1,11); // seteo el led 2
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT,1,12); // seteo el led 3
break;
}
}
static inline void _set_off(lamp_t lamp)
{
Chip_GPIO_SetPinOutHigh(LPC_GPIO, lamp->port, lamp->pin);
}
int main(void)
{
uint32_t estado[4] ={0,0,0,0},suspender[4]={0,0,0,0}, StartMotores[4] = {0,0,0,0};
initHardware();
Chip_GPIO_WriteDirBit(LPC_GPIO, 2, 10, 1); //led isp
Chip_GPIO_SetPinOutHigh(LPC_GPIO, 2,10);
while(1)
{
if(available())
{
read( &data_led[0], 4 );
data=data_led[0];
data=(data<<8)|data_led[1];
data=(data<<8)|data_led[2];
data=(data<<8)|data_led[3];
}
if(data == 0xAABBCCDD)
{
Chip_GPIO_SetPinOutLow(LPC_GPIO, 2,10); //led isp
StartMotores[2] = 1;
StartMotores[3] = 1;
}
if(data == 0xEEFF0123)
{
Chip_GPIO_SetPinOutHigh(LPC_GPIO, 2,10); //led isp
estado[2] = 0;
estado[3] = 0;
Stop_and_Default(0); //Condiciones iniciales
Stop_and_Default(1); //Condiciones iniciales
Stop_and_Default(2); //Condiciones iniciales
Stop_and_Default(3); //Condiciones iniciales
}
if (StartMotores[2] && estado[2] == 0)
{
StartMotores[2] = 0;
estado[2] = 1;
msTick[2] = 0;
}
/* if (StartMotores[3] && estado[3] == 0)
{
StartMotores[3] = 0;
estado[3] = 1;
msTick[3] = 0;
}
*/
if(estado[2] == 1)
{
if(msTick[2])
{
msTick[2]=0;
suspender[2]=Start_Up_Brushless(2);
if(suspender[2])
{
suspender[2] = 0;
estado[2] = 2;
}
}
}
if(estado[2] == 2)
{
if(Conmutar[2])
{
Conmutar[2] = 0;
NextPWM(2);
}
}
/* if(estado[3] == 1)
{
if(msTick[3])
{
msTick[3]=0;
suspender[3]=Start_Up_Brushless(3);
if(suspender[3])
{
suspender[3] = 0;
estado[3] = 2;
}
}
}
if(estado[3] == 2)
{
if(Conmutar[3])
{
Conmutar[3] = 0;
NextPWM(3);
}
}*/
}
return 0;
}
void PrendeLed(uint8_t led) {
if (led==1) {
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 0, 14);
}
if (led==2) {
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 1, 11);
}
if (led==3) {
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 1, 12);
}
if (led==4) {
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 0);
}
if (led==5) {
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 1);
}
if (led==6) {
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 2);
}
if (led==0) {
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 0, 14);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 1, 11);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 1, 12);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 0);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 1);
Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 5, 2);
}
}
