//initialize motors
int motorInit(ioportid_t gpio, int p11, int p12, int p21, int p22, PWMDriver *pwm, int lpa, int lpb, int rpa, int rpb){
//vars
lp1 = lpa;
lp2 = lpb;
rp1 = rpa;
rp2 = rpb;
motor_pwm = pwm;
//configure
palSetPadMode(gpio, p11, PAL_MODE_ALTERNATE(2));
palSetPadMode(gpio, p12, PAL_MODE_ALTERNATE(2));
palSetPadMode(gpio, p21, PAL_MODE_ALTERNATE(2));
palSetPadMode(gpio, p22, PAL_MODE_ALTERNATE(2));
chBSemInit(&motor_left_sem, FALSE);
chBSemInit(&motor_right_sem, FALSE);
//disable motors
pwmStart(motor_pwm, &motor_pwmcfg);
pwmEnableChannel(motor_pwm, lp1, PWM_PERCENTAGE_TO_WIDTH(motor_pwm,0));
pwmEnableChannel(motor_pwm, lp2, PWM_PERCENTAGE_TO_WIDTH(motor_pwm,0));
pwmEnableChannel(motor_pwm, rp1, PWM_PERCENTAGE_TO_WIDTH(motor_pwm,0));
pwmEnableChannel(motor_pwm, rp2, PWM_PERCENTAGE_TO_WIDTH(motor_pwm,0));
return TRUE;
}
//fungsi utama
int main (void) {
//inisialisasi HAL (Hardware Abstraction Layer)
halInit();
//inisialisasi kernel
chSysInit();
Adc_Init();
process_running();
//inisialisasi CAN
CAN_Config();
// serial
sdStart(&SD2,NULL);
palSetPadMode(GPIOB,3, PAL_MODE_ALTERNATE(7)); //TX
palSetPadMode(GPIOB,4, PAL_MODE_ALTERNATE(7)); //RX
sdStart(&SD1,NULL);
palSetPadMode(GPIOA,9, PAL_MODE_ALTERNATE(7)); //TX
palSetPadMode(GPIOA,10, PAL_MODE_ALTERNATE(7)); //RX
sdStart(&SD3,NULL);
palSetPadMode(GPIOB,10, PAL_MODE_ALTERNATE(7)); //TX
palSetPadMode(GPIOE,15, PAL_MODE_ALTERNATE(7)); //RX
//inisialisasi USB
sduObjectInit(&SDU1);
sduStart(&SDU1, &serusbcfg);
//aktifasi USB
usbDisconnectBus(serusbcfg.usbp);
chThdSleepMilliseconds(200);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
//thread 1
chThdCreateStatic(waBacavolt, sizeof(waBacavolt), NORMALPRIO, Bacavolt, NULL);
chThdCreateStatic(waBacacurrent, sizeof(waBacacurrent), NORMALPRIO, Bacacurrent, NULL);
chThdCreateStatic(waThreadBMS, sizeof(waThreadBMS), NORMALPRIO, ThreadBMS, NULL);
//chThdCreateStatic(waThreadkirimjoule, sizeof(waThreadkirimjoule), NORMALPRIO, Threadkirimjoule, NULL);
//chThdCreateStatic(waThreadkirimjoule2, sizeof(waThreadkirimjoule2), NORMALPRIO, Threadkirimjoule2, NULL);
while(TRUE) {
kirim_data_usart1();
chprintf((BaseSequentialStream *)&SD1,"%d,%f,%d,%d,%f,%f,%d,%d,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%d,%d,%d,%d \n",avgtemp,packsoc,packDCL,packCCL,lowvoltcell,highvoltcell,hightemp,lowtemp,packcurrent,packvolt,amphours,supply12v, deltacellvolt,avgcellvolt,mppt1_v,mppt2_v,mppt3_v,mppt4_v,mppt5_v,mppt6_v,mppt7_v,mppt8_v,mppt9_v,mppt10_v,mppt11_v,mppt12_v,mppt13_v,mppt15_v,mppt16_v, mppt1_i, mppt2_i, mppt3_i, mppt4_i, mppt5_i, mppt6_i, mppt7_i,mppt8_i, mppt9_i, mppt10_i, mppt11_i, mppt12_i, mppt13_i, mppt14_i, mppt15_i,current1,current2,current3,voltage1,voltage2,voltage3,milidetik,detik,menit,jam);
//chprintf((BaseSequentialStream *)&SDU1,"%d,%f,%d,%d,%f,%f,%d,%d,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f \n",avgtemp,packsoc,packDCL,packCCL,lowvoltcell,highvoltcell,hightemp,lowtemp,packcurrent,packvolt,amphours,supply12v, deltacellvolt,avgcellvolt,mppt1_v,mppt2_v,mppt3_v,mppt4_v,mppt5_v,mppt6_v,mppt7_v,mppt8_v,mppt9_v,mppt10_v,mppt11_v,mppt12_v,mppt13_v,mppt15_v,mppt16_v, mppt1_i, mppt2_i, mppt3_i, mppt4_i, mppt5_i, mppt6_i, mppt7_i,mppt8_i, mppt9_i, mppt10_i, mppt11_i, mppt12_i, mppt13_i, mppt14_i, mppt15_i);
//chprintf((BaseSequentialStream *)&SDU1,"%x %x %x %x %x %x %x %x \n",RxMessage33.StdId, RxMessage44.StdId, RxMessage55.StdId, RxMessage66.StdId, RxMessage77.StdId, RxMessage88.StdId, RxMessage99.StdId, RxMessage11.StdId);
//chprintf((BaseSequentialStream *)&SD1,"tes \n");
chThdSleepMilliseconds(500);
}
return 0 ;
}
static void setPower( bool_t en )
{
if ( en )
palSetPad( PWR_PORT, PWR_PIN );
// initUsb();
else
{
palClearPad( PWR_PORT, PWR_PIN );
setLight( 0 );
adcCfg( 0 );
motoConfig( 0, 3 );
// finitUsb();
}
palSetPadMode( PWR_PORT, PWR_PIN, PAL_MODE_OUTPUT_PUSHPULL );
}
void i2cUtilsStart(I2CDriver * driver, const I2CConfig * config, const I2CPins * pins){
chDbgCheck(driver && config && pins, utils_i2cStart);
chDbgAssert(driver->state != I2C_UNINIT,
DBG_PREFIX "I2C hal driver must be enabled",
NULL);
palSetPadMode(pins->SDA.port, pins->SDA.pad, I2C_PINMODE);
palSetPadMode(pins->SCL.port, pins->SCL.pad, I2C_PINMODE);
if(driver->state == I2C_STOP){
i2cStart(driver, config);
}else{
//Verify I2C configs match.
chDbgAssert(driver->config->op_mode == config->op_mode,
DBG_PREFIX "requested opmode does not match previously configured",
NULL);
chDbgAssert(driver->config->clock_speed == config->clock_speed,
DBG_PREFIX "requested clock speed does not match previously configured",
NULL);
chDbgAssert(driver->config->duty_cycle == config->duty_cycle,
DBG_PREFIX "requested duty cycle does not match previously configured",
NULL);
}
}
void encoder_init_as5047p_spi(void) {
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
palSetPadMode(SPI_SW_MISO_GPIO, SPI_SW_MISO_PIN, PAL_MODE_INPUT);
palSetPadMode(SPI_SW_SCK_GPIO, SPI_SW_SCK_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);
palSetPadMode(SPI_SW_CS_GPIO, SPI_SW_CS_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);
// Set MOSI to 1
#if AS5047_USE_HW_SPI_PINS
palSetPadMode(SPI_SW_MOSI_GPIO, SPI_SW_MOSI_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);
palSetPad(SPI_SW_MOSI_GPIO, SPI_SW_MOSI_PIN);
#endif
// Enable timer clock
HW_ENC_TIM_CLK_EN();
// Time Base configuration
TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseStructure.TIM_Period = ((168000000 / 2 / AS5047_SAMPLE_RATE_HZ) - 1);
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
TIM_TimeBaseInit(HW_ENC_TIM, &TIM_TimeBaseStructure);
// Enable overflow interrupt
TIM_ITConfig(HW_ENC_TIM, TIM_IT_Update, ENABLE);
// Enable timer
TIM_Cmd(HW_ENC_TIM, ENABLE);
nvicEnableVector(HW_ENC_TIM_ISR_CH, 6);
mode = ENCODER_MODE_AS5047P_SPI;
index_found = true;
spi_error_rate = 0.0;
}
/*
* Application entry point.
*/
int main(void) {
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Activates the serial driver 1 using the driver default configuration.
* PA9(TX) and PA10(RX) are routed to USART1.
*/
sdStart(&SD1, NULL);
palSetPadMode(GPIOA, 9, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOA, 10, PAL_MODE_ALTERNATE(7));
/*
* Creates the example thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and check the button state, when the button is
* pressed the test procedure is launched.
*/
while (TRUE) {
if (palReadPad(GPIOA, GPIOA_BUTTON))
TestThread(&SD1);
chThdSleepMilliseconds(500);
}
}
static void initMMCSpiHw(void)
{
/* Setup CC3000 SPI pins Chip Select*/
palSetPad(MMC_CS_PORT, MMC_CS_PAD);
palSetPadMode(MMC_CS_PORT, MMC_CS_PAD,
PAL_MODE_OUTPUT_PUSHPULL |
PAL_STM32_OSPEED_LOWEST); /* 400 kHz */
/* General SPI pin setting */
palSetPadMode(MMC_SPI_PORT, MMC_SCK_PAD,
PAL_MODE_ALTERNATE(5) | /* SPI SCK */
PAL_STM32_OTYPE_PUSHPULL |
PAL_STM32_OSPEED_MID2); /* 10 MHz */
palSetPadMode(MMC_SPI_PORT, MMC_MISO_PAD,
PAL_MODE_ALTERNATE(5)); /* SPI MISO */
palSetPadMode(MMC_SPI_PORT, MMC_MOSI_PAD,
PAL_MODE_ALTERNATE(5) | /* SPI MOSI */
PAL_STM32_OTYPE_PUSHPULL |
PAL_STM32_OSPEED_MID2); /* 10 MHz */
mmcObjectInit(&MMCD1);
mmcStart(&MMCD1, &mmccfg);
}
static msg_t blinkLed(void *arg)
{
led_config_t *ledConfig = (led_config_t*) arg;
chRegSetThreadName("Blinker");
palSetPadMode(ledConfig->port, ledConfig->pin, PAL_MODE_OUTPUT_PUSHPULL);
while (TRUE) {
chThdSleepMilliseconds(ledConfig->sleep);
palTogglePad(ledConfig->port, ledConfig->pin);
}
return (msg_t) 0;
}
void servoInit(Servo *servo) {
/* create the channel configuration */
PWMChannelConfig chcfg = { PWM_OUTPUT_ACTIVE_HIGH, NULL };
pwmcfg.channels[servo->pwm_channel] = chcfg;
/* configure PAL */
#if defined(STM32F1XX)
palSetPadMode(servo->port, servo->pin, PAL_MODE_STM32_ALTERNATE_PUSHPULL);
#else
#error "PAL configuration for this device not implemented yet - Please modify servoInit()"
#endif
/* start the PWM unit */
pwmStart(servo->pwm_driver, &pwmcfg);
}
/*
* Application entry point.
*/
int main(void) {
unsigned i;
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* SPI2 I/O pins setup.
*/
palSetPadMode(GPIOB, 13, PAL_MODE_STM32_ALTERNATE_PUSHPULL); /* New SCK. */
palSetPadMode(GPIOB, 14, PAL_MODE_STM32_ALTERNATE_PUSHPULL); /* New MISO. */
palSetPadMode(GPIOB, 15, PAL_MODE_STM32_ALTERNATE_PUSHPULL); /* New MOSI. */
palSetPadMode(GPIOB, 12, PAL_MODE_OUTPUT_PUSHPULL); /* New CS. */
palSetPadMode(GPIOA, 9, PAL_MODE_STM32_ALTERNATE_PUSHPULL); /* USART1 TX. */
palSetPadMode(GPIOA, 10, PAL_MODE_INPUT);
sdStart(&SD1, NULL);
spiAcquireBus(&SPID2); /* Acquire ownership of the bus. */
spiStart(&SPID2, &ls_spicfg); /* Setup transfer parameters. */
// nrf_init();
nrf_configure_sb_tx();
nrf_dump_regs(&nrf_reg_def);
// chThdCreateStatic(blinker_wa, sizeof(blinker_wa),
// NORMALPRIO-1, blinker, NULL);
static nrf_payload p;
int s;
// set payload size according to the payload size configured for the RX channel
p.size = 1;
p.data[0] = 0;
while (TRUE) {
chprintf((BaseSequentialStream *) &SD1, "Sending payload: %x ", p.data[0]);
s = nrf_send_blocking(&p);
chprintf((BaseSequentialStream *) &SD1, " - done; bytes send: %u\n\r", s);
chThdSleepMilliseconds(100);
p.data[0]++;
}
return 0;
}
/*
* Initialise GPIO ports to handle:
* - the CS43L22's I2C channel,
* - the CS43L22's I2S channel.
*/
static void _i2s_init_gpio( void )
{
// Reset pin
palSetPadMode( I2S_ORESET_PORT , I2S_ORESET_PAD ,
PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_MID2 );
// SDL/SDA pins
_i2s_init_i2c_pad( I2C_OSCL_PORT , I2C_OSCL_PAD );
_i2s_init_i2c_pad( I2C_OSDA_PORT , I2C_OSDA_PAD );
// I2S WS/MCK/SCK/SD pins
_i2s_init_i2s_pad( I2S_OWS_PORT , I2S_OWS_PAD );
_i2s_init_i2s_pad( I2S_OMCK_PORT , I2S_OMCK_PAD );
_i2s_init_i2s_pad( I2S_OSCK_PORT , I2S_OSCK_PAD );
_i2s_init_i2s_pad( I2S_OSD_PORT , I2S_OSD_PAD );
}
/*
* Application entry point.
*/
int main(void) {
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Setting up analog input used by the demo (P0.02, SMBA).
*/
palSetPadMode(IOPORT1, 2, PAL_MODE_INPUT_ANALOG);
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Activates the ADC1 driver and the temperature sensor.
*/
adcStart(&ADCD1, NULL);
/*
* Linear conversion.
*/
adcConvert(&ADCD1, &adcgrpcfg1, samples1, ADC_GRP1_BUF_DEPTH);
chThdSleepMilliseconds(1000);
/*
* Starts an ADC continuous conversion.
*/
adcStartConversion(&ADCD1, &adcgrpcfg2, samples2, ADC_GRP2_BUF_DEPTH);
/*
* Normal main() thread activity, in this demo it does nothing.
*/
while (true) {
if (palReadPad(IOPORT1, KEY1) == 0)
adcStopConversion(&ADCD1);
chThdSleepMilliseconds(500);
}
}
/*
* Application entry point.
*/
int main(void) {
halInit();
chSysInit();
/*
* Serial port initialization.
*/
sdStart(&SD1, NULL);
chprintf((BaseSequentialStream *)&SD1, "Main (SD1 started)\r\n");
/*
*Semaphore Initialization
*/
chSemInit(&mySemaphore, 1);
/*
* Set mode of PINES
*/
palSetPadMode(GPIO0_PORT, GPIO0_PAD, PAL_MODE_INPUT); //Input T1
palSetPadMode(GPIO1_PORT, GPIO1_PAD, PAL_MODE_INPUT); //Input T2
palSetPadMode(GPIO4_PORT, GPIO4_PAD, PAL_MODE_INPUT); //Input T3
palSetPadMode(GPIO17_PORT, GPIO17_PAD, PAL_MODE_INPUT); //Input T4
palSetPadMode(GPIO18_PORT, GPIO18_PAD, PAL_MODE_OUTPUT); //Output T1
palSetPadMode(GPIO22_PORT, GPIO22_PAD, PAL_MODE_OUTPUT); //Output T2
palSetPadMode(GPIO23_PORT, GPIO23_PAD, PAL_MODE_OUTPUT); //Output T3
palSetPadMode(GPIO24_PORT, GPIO24_PAD, PAL_MODE_OUTPUT); //Output T4
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waTh1, sizeof(waTh1), NORMALPRIO, Th1, NULL);
chThdCreateStatic(waTh2, sizeof(waTh2), NORMALPRIO, Th2, NULL);
chThdCreateStatic(waTh3, sizeof(waTh3), NORMALPRIO, Th3, NULL);
chThdCreateStatic(waTh4, sizeof(waTh4), NORMALPRIO, Th4, NULL);
/*
* Events servicing loop.
*/
chThdWait(chThdSelf());
return 0;
}
static THD_FUNCTION(ThreadINA, arg)
{
(void)arg;
chRegSetThreadName("INA");
systime_t time = chVTGetSystemTimeX(); // T0
while (true) {
time += US2ST(READFREQ);
//palSetPad(GPIOG, GPIOG_LED4_RED);
//palTogglePad(GPIOG, GPIOG_LED4_RED);
busvoltage=ina219GetBusVoltage_V();
current_mA=ina219GetCurrent_mA();
shuntvoltage = ina219GetShuntVoltage_mV();
loadvoltage = busvoltage + (shuntvoltage / 1000);
milliwatthours += busvoltage*current_mA*READFREQ/1e6/3600; // 1 Wh = 3600 joules
milliamphours += current_mA*READFREQ/1e6/3600;
// Update peaks, min and avg during our serial refresh period:
if (current_mA > rpPeakCurrent)
rpPeakCurrent = current_mA;
if (current_mA < rpMinCurrent)
rpMinCurrent = current_mA;
if (loadvoltage > rpPeakLoadVolt)
rpPeakLoadVolt = loadvoltage;
if (loadvoltage < rpMinLoadVolt)
rpMinLoadVolt = loadvoltage;
rpAvgCurrent = (rpAvgCurrent*rpSamples + current_mA)/(rpSamples+1);
rpAvgLoadVolt = (rpAvgLoadVolt*rpSamples + loadvoltage)/(rpSamples+1);
rpSamples++;
// Update absolute peaks and mins
if (current_mA > peakCurrent) {
peakCurrent = current_mA;
voltageAtPeakCurrent = loadvoltage;
}
if (loadvoltage < minVoltage) {
minVoltage = loadvoltage;palSetPadMode(GPIOA, 5, PAL_MODE_OUTPUT_PUSHPULL); palClearPad(GPIOA, 5);
currentAtMinVoltage = current_mA;
}
//palClearPad(GPIOG, GPIOG_LED4_RED);
chThdSleepUntil(time);
}
}
void gps_reset() {
palSetPadMode(GPIO_GPS_PWR_PORT, GPIO_GPS_PWR_PIN, PAL_MODE_OUTPUT_PUSHPULL);
//! Set GPS power Off
palClearPad(GPIO_GPS_PWR_PORT, GPIO_GPS_PWR_PIN);
chThdSleepMilliseconds(500);
//! Set GPS power On
palClearPad(GPIO_GPS_PWR_PORT, GPIO_GPS_PWR_PIN);
sdStop(&GPS_SERIAL);
SD3_Config.sc_speed = 9600;
sdStart(&GPS_SERIAL, &SD3_Config);
// Wait until initialized
while (sdReadTimeout(&GPS_SERIAL, gps_data, GPS_CMD_BUF, 100) <= 0) {}
// Set serial config
GPS_CMD_SEND("PSRF100,1,38400,8,1,0");
chThdSleepMilliseconds(100);
sdStop(&GPS_SERIAL);
SD3_Config.sc_speed = 38400;
sdStart(&GPS_SERIAL, &SD3_Config);
// Disable unneeded
GPS_CMD_SEND("PSRF103,01,00,00,01");
chThdSleepMilliseconds(100);
GPS_CMD_SEND("PSRF103,02,00,00,01");
chThdSleepMilliseconds(100);
GPS_CMD_SEND("PSRF103,03,00,00,01");
chThdSleepMilliseconds(100);
GPS_CMD_SEND("PSRF103,05,00,00,01");
// Enable needed
// GGA
GPS_CMD_SEND("PSRF103,00,00,01,01");
chThdSleepMilliseconds(100);
// RMC
GPS_CMD_SEND("PSRF103,04,00,01,01");
chThdSleepMilliseconds(100);
sdAsynchronousRead(&GPS_SERIAL, gps_data, GPS_CMD_BUF);
}
/**
* @brief Configures and activates the SPI peripheral.
*
* @param[in] spip pointer to the @p SPIDriver object
*
* @notapi
*/
void spi_lld_start(SPIDriver *spip) {
uint8_t scbr =
spip->config->speed == 0 ? 0xFF :
SystemCoreClock < spip->config->speed ? 0x01 :
SystemCoreClock / spip->config->speed > 0xFF ? 0xFF :
SystemCoreClock / spip->config->speed;
if (spip->state == SPI_STOP) {
uint32_t irq_priority =
spip->config->irq_priority ? spip->config->irq_priority :
SAM3XA_SPI_DEFAULT_IRQ_PRIORITY;
chDbgCheck(CORTEX_IS_VALID_KERNEL_PRIORITY(irq_priority),
"SPI irq_priority");
pmc_enable_peripheral_clock(spip->peripheral_id);
nvicEnableVector(spip->irq_id, CORTEX_PRIORITY_MASK(irq_priority));
spip->spi->SPI_CR = SPI_CR_SPIDIS;
spip->spi->SPI_CR = SPI_CR_SWRST;
spip->spi->SPI_CR = SPI_CR_SWRST;
spip->spi->SPI_MR = SPI_MR_MSTR | SPI_MR_MODFDIS;
spip->spi->SPI_CSR[0] = SPI_CSR_BITS_8_BIT | SPI_CSR_CSAAT |
SPI_CSR_SCBR(scbr) | (
spip->config->spi_mode == 1 ? 0 :
spip->config->spi_mode == 2 ? SPI_CSR_CPOL | SPI_CSR_NCPHA :
spip->config->spi_mode == 3 ? SPI_CSR_CPOL :
SPI_CSR_NCPHA);
peripheral_pin_apply(&spip->config->spck_pin);
peripheral_pin_apply(&spip->config->miso_pin);
peripheral_pin_apply(&spip->config->mosi_pin);
palSetPad(spip->config->cs_pin.port, spip->config->cs_pin.pin);
palSetPadMode(spip->config->cs_pin.port, spip->config->cs_pin.pin, PAL_MODE_OUTPUT_OPENDRAIN);
spip->spi->SPI_CR = SPI_CR_SPIEN;
} else {
// MMC_SD will reconfigure us without stopping
spip->spi->SPI_CSR[0] = SPI_CSR_BITS_8_BIT | SPI_CSR_CSAAT |
SPI_CSR_SCBR(scbr) | (
spip->config->spi_mode == 1 ? 0 :
spip->config->spi_mode == 2 ? SPI_CSR_CPOL | SPI_CSR_NCPHA :
spip->config->spi_mode == 3 ? SPI_CSR_CPOL :
SPI_CSR_NCPHA);
}
}
/*
* LCD set I/Os
*/
void lcd_setio(){
palSetPadMode(GPIOE, EN, PAL_MODE_OUTPUT_PUSHPULL); //EN
palSetPadMode(GPIOB, RS, PAL_MODE_OUTPUT_PUSHPULL); //RS
palSetPadMode(GPIOE, DB4, PAL_MODE_OUTPUT_PUSHPULL); //DB4
palSetPadMode(GPIOE, DB5, PAL_MODE_OUTPUT_PUSHPULL); //DB5
palSetPadMode(GPIOE, DB6, PAL_MODE_OUTPUT_PUSHPULL); //DB6
palSetPadMode(GPIOE, DB7, PAL_MODE_OUTPUT_PUSHPULL); //DB7
palWritePort(GPIOE, 0);
}
/*
* Application entry point.
*/
int main(void) {
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
palSetPadMode(IOPORT3, BOARD_LED1, PAL_MODE_OUTPUT_PUSHPULL);
palClearPad(IOPORT3, BOARD_LED1);
/*
* Initializes a serial-over-USB CDC driver.
*/
sduObjectInit(&SDU1);
sduStart(&SDU1, &serusbcfg);
/*
* Activates the USB driver and then the USB bus pull-up on D+.
* Note, a delay is inserted in order to not have to disconnect the cable
* after a reset.
*/
usbDisconnectBus(serusbcfg.usbp);
chThdSleepMilliseconds(1000);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
/*
* Starts the LED blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
while (true) {
if (SDU1.config->usbp->state == USB_ACTIVE) {
chnWrite(&SDU1, (const uint8_t *)"Hello from Arduino Leonardo!\r\n", 30);
}
chThdSleepMilliseconds(2113);
}
}
/*
* Application entry point.
*/
int main(void) {
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Starting DAC1 driver, setting up the output pin as analog as suggested
* by the Reference Manual.
*/
palSetPadMode(GPIOA, 4, PAL_MODE_INPUT_ANALOG);
dacStart(&DACD1, &dac1cfg1);
/*
* Starting GPT6 driver, it is used for triggering the DAC.
*/
gptStart(&GPTD6, &gpt6cfg1);
/*
* Starting a continuous conversion.
*/
dacStartConversion(&DACD1, &dacgrpcfg1, dac_buffer, DAC_BUFFER_SIZE);
gptStartContinuous(&GPTD6, 2U);
/*
* Normal main() thread activity, if the button is pressed then the DAC
* transfer is stopped.
*/
while (true) {
if (palReadPad(GPIOA, GPIOA_BUTTON)) {
gptStopTimer(&GPTD6);
dacStopConversion(&DACD1);
}
chThdSleepMilliseconds(500);
}
return 0;
}
void BoardDriverStart(void)
{
canStart(&CAND1, &cancfg);
/*CAN1 RX and TX*/
palSetPadMode(GPIOB, 8, PAL_MODE_STM32_ALTERNATE_PUSHPULL);
palSetPadMode(GPIOB, 9, PAL_MODE_STM32_ALTERNATE_PUSHPULL);
sdStart(&SD2, &serialConfig);
palSetPadMode(GPIOA, 0, PAL_MODE_STM32_ALTERNATE_PUSHPULL);
palSetPadMode(GPIOA, 1, PAL_MODE_STM32_ALTERNATE_PUSHPULL);
palSetPadMode(GPIOA, 2, PAL_MODE_STM32_ALTERNATE_PUSHPULL);
palSetPadMode(GPIOA, 3, PAL_MODE_STM32_ALTERNATE_PUSHPULL);
}
void kirim_setup(void){
sdStart(&SD2,NULL);
palSetPadMode(GPIOB,3, PAL_MODE_ALTERNATE(7)); //TX
palSetPadMode(GPIOB,4, PAL_MODE_ALTERNATE(7)); //RX
sdStart(&SD1,NULL);
palSetPadMode(GPIOA,9, PAL_MODE_ALTERNATE(7)); //TX
palSetPadMode(GPIOA,10, PAL_MODE_ALTERNATE(7)); //RX
sdStart(&SD3,NULL);
palSetPadMode(GPIOB,10, PAL_MODE_ALTERNATE(7)); //TX
palSetPadMode(GPIOE,15, PAL_MODE_ALTERNATE(7)); //RX
};
void efiSetPadUnused(brain_pin_e brainPin)
{
/* input with pull up, is it safe? */
iomode_t mode = PAL_STM32_MODE_INPUT | PAL_STM32_PUPDR_PULLUP;
if (brain_pin_is_onchip(brainPin)) {
ioportid_t port = getHwPort("unused", brainPin);
ioportmask_t pin = getHwPin("unused", brainPin);
/* input with pull up, is it safe? */
palSetPadMode(port, pin, mode);
}
#if (BOARD_EXT_GPIOCHIPS > 0)
else {
gpiochips_setPadMode(brainPin, mode);
}
#endif
brain_pin_markUnused(brainPin);
}
void BoardDriverStart(void)
{
ws281xStart(&ws281x, &ws281x_cfg);
palSetPadMode(GPIOA, 1, PAL_MODE_STM32_ALTERNATE_PUSHPULL);
/*
* Initializes a serial-over-USB CDC driver.
*/
sduStart(&SDU1, &serusbcfg);
/*
* Activates the USB driver and then the USB bus pull-up on D+.
* Note, a delay is inserted in order to not have to disconnect the cable
* after a reset.
*/
usbDisconnectBus(serusbcfg.usbp);
chThdSleepMilliseconds(1000);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
}
USARTPlatform::USARTPlatform() {
// UART2
sdStart(&SD2, &UART2_CONFIG);
palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7)); // TX
palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7)); // RX
// UART4
sdStart(&SD4, &UART4_CONFIG);
palSetPadMode(GPIOA, 0, PAL_MODE_ALTERNATE(8)); // TX
palSetPadMode(GPIOA, 1, PAL_MODE_ALTERNATE(8)); // RX
// UART6
sdStart(&SD6, &UART6_CONFIG);
palSetPadMode(GPIOC, 6, PAL_MODE_ALTERNATE(8)); // TX
palSetPadMode(GPIOC, 7, PAL_MODE_ALTERNATE(8)); // RX
}
void init3310( void )
{
palSetPad( PORT_CS, PAD_CS ); // Set CS high
palSetPadMode( PORT_SCK, PAD_SCK, PAL_MODE_STM32_ALTERNATE_PUSHPULL ); // SCK
palSetPadMode( PORT_MOSI, PAD_MOSI, PAL_MODE_STM32_ALTERNATE_PUSHPULL ); // MISO
palSetPadMode( PORT_CS, PAD_CS, PAL_MODE_OUTPUT_PUSHPULL ); // CS
CS_HIGH();
DC_HIGH();
RST_HIGH();
palSetPadMode( PORT_DC, PAD_DC, PAL_MODE_OUTPUT_PUSHPULL );
palSetPadMode( PORT_CS, PAD_CS, PAL_MODE_OUTPUT_PUSHPULL );
palSetPadMode( PORT_RST, PAD_RST, PAL_MODE_OUTPUT_PUSHPULL );
delay3310( 100000 );
}
/**
* @brief Configures and activates the 1-wire driver.
*
* @param[in] owp pointer to the @p onewireDriver object
* @param[in] config pointer to the @p onewireConfig object
*
* @api
*/
void onewireStart(onewireDriver *owp, const onewireConfig *config) {
osalDbgCheck((NULL != owp) && (NULL != config));
osalDbgAssert(PWM_STOP == config->pwmd->state,
"PWM will be started by onewire driver internally");
osalDbgAssert(ONEWIRE_STOP == owp->reg.state, "Invalid state");
#if ONEWIRE_USE_STRONG_PULLUP
osalDbgCheck((NULL != config->pullup_assert) &&
(NULL != config->pullup_release));
#endif
owp->config = config;
owp->config->pwmcfg->frequency = ONEWIRE_PWM_FREQUENCY;
owp->config->pwmcfg->period = ONEWIRE_RESET_TOTAL_WIDTH;
#if !defined(STM32F1XX)
palSetPadMode(owp->config->port, owp->config->pad,
owp->config->pad_mode_active);
#endif
ow_bus_idle(owp);
owp->reg.state = ONEWIRE_READY;
}
DigitalPlatform::DigitalPlatform() {
palSetPadMode(GPIOA, 4, PAL_MODE_OUTPUT_PUSHPULL);
//palSetPadMode(GPIOA, 5, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(GPIOC, 4, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(GPIOC, 5, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(GPIOA, 12, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(GPIOA, 15, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(GPIOB, 2, PAL_MODE_OUTPUT_PUSHPULL);
palClearPad(GPIOA, 4);
//palClearPad(GPIOA, 5);
palClearPad(GPIOC, 4);
palClearPad(GPIOC, 5);
palClearPad(GPIOA, 12);
palClearPad(GPIOA, 15);
palClearPad(GPIOB, 2);
}
/* Main thread
*/
int main(void) {
/* ChibiOS/RT init */
halInit();
#if defined(F042)
SYSCFG->CFGR1 |= SYSCFG_CFGR1_PA11_PA12_RMP; /* remap pins to USB */
#endif /* F042 */
chSysInit();
palSetPad(LED_GPIO, LED_PIN);
chThdSleepMilliseconds(400);
palClearPad(LED_GPIO, LED_PIN);
/* Init USB */
init_usb_driver(&USB_DRIVER);
/* Start blinking */
chThdCreateStatic(waBlinkerThread, sizeof(waBlinkerThread), NORMALPRIO, blinkerThread, NULL);
/* Wait until the USB is active */
while(USB_DRIVER.state != USB_ACTIVE)
chThdSleepMilliseconds(1000);
chThdSleepMilliseconds(500);
/* Start the button thread */
palSetPadMode(BUTTON_GPIO, BUTTON_PIN, BUTTON_MODE);
chThdCreateStatic(waButtonThread, sizeof(waButtonThread), NORMALPRIO, buttonThread, NULL);
/* Main loop */
while(true) {
chThdSleepMilliseconds(200);
/* caps lock led status */
#if defined(LED2_GPIO)
palWritePad(LED2_GPIO, LED2_PIN, ((keyboard_leds() & 2) == 2));
#endif
}
}
void encoder_init_ad2s1205_spi(void) {
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
palSetPadMode(SPI_SW_MISO_GPIO, SPI_SW_MISO_PIN, PAL_MODE_INPUT);
palSetPadMode(SPI_SW_SCK_GPIO, SPI_SW_SCK_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);
palSetPadMode(SPI_SW_CS_GPIO, SPI_SW_CS_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);
// Set MOSI to 1
#if AS5047_USE_HW_SPI_PINS
palSetPadMode(SPI_SW_MOSI_GPIO, SPI_SW_MOSI_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);
palSetPad(SPI_SW_MOSI_GPIO, SPI_SW_MOSI_PIN);
#endif
// TODO: Choose pins on comm port when these are not defined
#if defined(AD2S1205_SAMPLE_GPIO) && defined(AD2S1205_RDVEL_GPIO)
palSetPadMode(AD2S1205_SAMPLE_GPIO, AD2S1205_SAMPLE_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);
palSetPadMode(AD2S1205_RDVEL_GPIO, AD2S1205_RDVEL_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_HIGHEST);
palSetPad(AD2S1205_SAMPLE_GPIO, AD2S1205_SAMPLE_PIN); // Prepare for a falling edge SAMPLE assertion
palSetPad(AD2S1205_RDVEL_GPIO, AD2S1205_RDVEL_PIN); // Will always read position
#endif
// Enable timer clock
HW_ENC_TIM_CLK_EN();
// Time Base configuration
TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseStructure.TIM_Period = ((168000000 / 2 / AD2S1205_SAMPLE_RATE_HZ) - 1);
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
TIM_TimeBaseInit(HW_ENC_TIM, &TIM_TimeBaseStructure);
// Enable overflow interrupt
TIM_ITConfig(HW_ENC_TIM, TIM_IT_Update, ENABLE);
// Enable timer
TIM_Cmd(HW_ENC_TIM, ENABLE);
nvicEnableVector(HW_ENC_TIM_ISR_CH, 6);
mode = RESOLVER_MODE_AD2S1205;
index_found = true;
}
/**
* This method would set an error condition if pin is already used
*/
void efiSetPadMode(const char *msg, brain_pin_e brainPin, iomode_t mode)
{
bool wasUsed = brain_pin_markUsed(brainPin, msg);
if (!wasUsed) {
/*check if on-chip pin or external */
if (brain_pin_is_onchip(brainPin)) {
/* on-cip */
ioportid_t port = getHwPort(msg, brainPin);
ioportmask_t pin = getHwPin(msg, brainPin);
/* paranoid */
if (port == GPIO_NULL)
return;
palSetPadMode(port, pin, mode);
}
#if (BOARD_EXT_GPIOCHIPS > 0)
else {
gpiochips_setPadMode(brainPin, mode);
}
#endif
}
}