Place::Place(std::vector<std::string> filenames, std::vector<std::string> machineTextures, std::vector<std::string> pinTextures) :
TexturizableObject(filenames)
{
machine1 = BowlingMachine(machineTextures);
machine2 = BowlingMachine(machineTextures);
pinSet = PinSet(pinTextures);
pinSet1 = PinSet(pinTextures);
pinSet2 = PinSet(pinTextures);
}
void ConfigMotor()
{
// Setup SCL, SDA pins as I/O function
PinTypeDigital(SCL_PORT, SCL_PIN);
PinTypeDigital(SDA_PORT, SDA_PIN);
PinTypeDigital(CS_PORT, CS_PIN);
// Setup SCL, SDA pins as output
PinTypeOutput(SCL_PORT, SCL_PIN);
PinTypeOutput(SDA_PORT, SDA_PIN);
PinTypeOutput(CS_PORT, CS_PIN);
// Reset SCL, SDA pin to Low
PinSet(SCL_PORT, SCL_PIN);
PinSet(SDA_PORT, SDA_PIN);
PinSet(CS_PORT, CS_PIN);
}
void Send_byte_SW(char d)
{
unsigned char bit;
PinReset(CS_PORT, CS_PIN);
for(bit = 0x80; bit; bit >>= 1) {
PinReset(SCL_PORT, SCL_PIN);
if(d & bit) PinSet(SDA_PORT, SDA_PIN);
else PinReset(SDA_PORT, SDA_PIN);
__delay_cycles(10);
PinSet(SCL_PORT, SCL_PIN);
__delay_cycles(5);
}
PinSet(CS_PORT, CS_PIN);
}
void App_t::LedBlink(uint32_t Duration_ms) {
PinSet(LED_GPIO, LED_PIN);
chSysLock()
if(chVTIsArmedI(&TmrLed)) chVTResetI(&TmrLed);
chVTSetI(&TmrLed, MS2ST(Duration_ms), LedTmrCallback, nullptr);
chSysUnlock();
}
void Infrared_t::RxInit() {
chEvtInit(&IEvtSrcIrRx);
// GPIO
PinSetupOut(IR_RX_PWR_GPIO, IR_RX_PWR_PIN, omPushPull); // }
PinSet(IR_RX_PWR_GPIO, IR_RX_PWR_PIN); // } Power
PinSetupIn(IR_RX_IN_GPIO, IR_RX_IN_PIN, pudNone); // Input
// ==== Timer ====
RxTimer.Init();
RxTimer.Enable();
RxTimer.SetTopValue(0xFFFF); // Maximum
RxTimer.SetupPrescaler(1000000); // Input Freq: 1 MHz => one tick = 1 uS
//RxTimer.Disable();
// ==== Input queue ====
chMBInit(&imailbox, IRxBuf, IR_RXBUF_SZ);
// ==== Receiving thread ====
chThdCreateStatic(waIRRxThread, sizeof(waIRRxThread), NORMALPRIO, IRRxThread, NULL);
// ==== IRQ ==== PC5
rccEnableAPB2(RCC_APB2ENR_SYSCFGEN, FALSE); // Enable sys cfg controller
SYSCFG->EXTICR[1] &= 0xFFFFFF0F; // EXTI5 is connected to PortC
SYSCFG->EXTICR[1] |= 0x00000020; // EXTI5 is connected to PortC
// Configure EXTI line
EXTI->IMR |= IR_IRQ_MASK; // Interrupt mode enabled
EXTI->EMR &= ~IR_IRQ_MASK; // Event mode disabled
RxIrqWaitFalling();
EXTI->PR = IR_IRQ_MASK; // Clean irq flag
nvicEnableVector(EXTI9_5_IRQn, CORTEX_PRIORITY_MASK(IRQ_PRIO_HIGH));
}
void PillReset() {
PillDeinit();
PinSetupOut(PERIPH_PWR_GPIO, PERIPH_PWR_PIN, omPushPull); // Power
PinSet(PERIPH_PWR_GPIO, PERIPH_PWR_PIN);
chThdSleepMilliseconds(1); // Allow power to rise
i2c.Resume();
}
void Init() {
JtagDisable();
Uart.Init(USART2, 256000);
#ifndef TESTING
// Charging and powering
PinSetupIn(EXT_PWR_GPIO, EXT_PWR_PIN, pudPullDown);
PinSetupIn(CHARGING_GPIO, CHARGING_PIN, pudPullUp);
LedsInit();
VibroInit();
if(!Iwdg.ResetOccured()) {
Uart.Printf("Glove1_f100 AHB=%u; APB1=%u; APB2=%u\r", Clk.AHBFreqHz, Clk.APB1FreqHz, Clk.APB2FreqHz);
Vibro.On(100);
chThdSleepMilliseconds(99);
ShowChargeLevel();
chThdSleepMilliseconds(900);
SwitchOffEverything();
}
else Uart.Printf("W\r");
AccInit();
// Application init
App.Init();
#else
Uart.Printf("Glove tester\r");
PinSetupOut(GPIOA, 15, omPushPull);
PinSet(GPIOA, 15);
chThdSleepMilliseconds(450);
Acc[0].SetPortAndPins(GPIOA, 1, 3, 4);
#endif
}
//! [initialize_i2c]
void configure_EEPROM(void)
{
pinMode(WP, OUTPUT);
PinSet(WP);
/* Initialize config structure and software module. */
//! [init_conf]
struct i2c_master_config config_i2c_master;
i2c_master_get_config_defaults(&config_i2c_master);
//! [init_conf]
/* Change buffer timeout to something longer. */
//! [conf_change]
config_i2c_master.buffer_timeout = 10000;
config_i2c_master.generator_source=GCLK_GENERATOR_0;
config_i2c_master.pinmux_pad0=PINMUX_PA12C_SERCOM2_PAD0;
config_i2c_master.pinmux_pad1=PINMUX_PA13C_SERCOM2_PAD1;
//! [conf_change]
/* Initialize and enable device with config. */
//! [init_module]
i2c_master_init(&i2c_master_instance, SERCOM2, &config_i2c_master);
/*BAUD=GCLK0freq(48Mhz)*Thigh
/i.e SCLfreq=GCLK/(2*Baud)*/
REG_SERCOM2_I2CM_BAUD=200; //force baud rate after above setting gives around 100Khz
//! [enable_module]
i2c_master_enable(&i2c_master_instance);
//! [enable_module]
}
void App_t::OnUartCmd(CmdUart_t *PUart) {
LedBlink(54);
UartCmd_t *PCmd = &PUart->Cmd;
__attribute__((unused)) int32_t dw32 = 0; // May be unused in some configurations
Uart.Printf("\r%S\r", PCmd->Name);
// Handle command
if(PCmd->NameIs("#Ping")) PUart->Ack(OK);
else if(PCmd->NameIs("#SetLines")) {
int32_t L[4];
// Receive desired state
if(PCmd->GetNextToken() != OK) { PUart->Ack(CMD_ERROR); return; }
if(PCmd->TryConvertTokenToNumber(&L[0]) != OK) { PUart->Ack(CMD_ERROR); return; }
if(PCmd->GetNextToken() != OK) { PUart->Ack(CMD_ERROR); return; }
if(PCmd->TryConvertTokenToNumber(&L[1]) != OK) { PUart->Ack(CMD_ERROR); return; }
if(PCmd->GetNextToken() != OK) { PUart->Ack(CMD_ERROR); return; }
if(PCmd->TryConvertTokenToNumber(&L[2]) != OK) { PUart->Ack(CMD_ERROR); return; }
if(PCmd->GetNextToken() != OK) { PUart->Ack(CMD_ERROR); return; }
if(PCmd->TryConvertTokenToNumber(&L[3]) != OK) { PUart->Ack(CMD_ERROR); return; }
// Setup state
if(L[0] == 0) PinClear(PATH_GPIO, PATH21_PIN);
else PinSet(PATH_GPIO, PATH21_PIN);
if(L[1] == 0) PinClear(PATH_GPIO, PATH31_PIN);
else PinSet(PATH_GPIO, PATH31_PIN);
if(L[2] == 0) PinClear(PATH_GPIO, PATH22_PIN);
else PinSet(PATH_GPIO, PATH22_PIN);
if(L[3] == 0) PinClear(PATH_GPIO, PATH32_PIN);
else PinSet(PATH_GPIO, PATH32_PIN);
PUart->Ack(OK);
}
else if(PCmd->NameIs("#GetLines")) {
char c[4];
// Collect data
c[0] = PinIsSet(PATH_GPIO, PATH21_PIN)? '1' : '0';
c[1] = PinIsSet(PATH_GPIO, PATH31_PIN)? '1' : '0';
c[2] = PinIsSet(PATH_GPIO, PATH22_PIN)? '1' : '0';
c[3] = PinIsSet(PATH_GPIO, PATH32_PIN)? '1' : '0';
// Send reply
PUart->Printf("#Lines %c %c %c %c\r\n", c[0], c[1], c[2], c[3]);
}
else if(*PCmd->Name == '#') PUart->Ack(CMD_UNKNOWN); // reply only #-started stuff
}
void Initialize_Hardware(){
Config_MatrixKeypad();
Config_LCD();
configure_EEPROM();
ConfigureSpi(SERCOMX0, 2000000);
pinMode(F350Ready, INPUT); //make input with pull up
pinMode(BuzzerPin, WEAKOUT);
pinMode(PA09, OUTPUT);
PinSet(PA09);
//pinMux(PB23, GCLKmux);
}
void PillInit() {
PillDeinit();
PinSetupOut(PERIPH_PWR_GPIO, PERIPH_PWR_PIN, omPushPull); // Power
PinSet(PERIPH_PWR_GPIO, PERIPH_PWR_PIN);
chThdSleepMilliseconds(1); // Allow power to rise
i2c.Init(PILL_I2C, PILL_I2C_GPIO, PILL_SCL_PIN, PILL_SDA_PIN, PILL_I2C_BITRATE_HZ, PILL_DMATX, PILL_DMARX);
// Firmware
chEvtInit(&IEvtPillChange);
// Pills
for(uint8_t i=0; i<PILL_CNT; i++) Pill[i].Init(i);
// Thread
chThdCreateStatic(waPillThread, sizeof(waPillThread), NORMALPRIO, PillThread, NULL);
}
int main(void) {
Init();
Uart.Printf("klNFC\r");
PinSetupOut(GPIOC, 8, poPushPull, pudNone);
//PinSetupOut(GPIOC, 9, poPushPull, pudNone);
PinSet(GPIOC, 8);
uint32_t Tmr;
while(1) {
if(Delay.Elapsed(&Tmr, 198)) {
PinToggle(GPIOC, 8);
Uart.Printf("ege\r");
//USART_SendData(USART1, 'e');
}
//Delay.ms(999);
//PinToggle(GPIOC, 8);
}
}
int main(void) {
// ==== Init Vcore & clock system ====
SetupVCore(vcore1V8);
Clk.UpdateFreqValues();
// ==== Init OS ====
halInit();
chSysInit();
// ==== Init Hard & Soft ====
PinSetupOut(GPIOC, 9, omPushPull);
PinSet(GPIOC, 9);
while(1) {
// PinSet(GPIOC, 8);
// chThdSleepMilliseconds(207);
// PinClear(GPIOC, 8);
// chThdSleepMilliseconds(360);
} // while
}
void AccInit() {
// Init pwr
PinSetupOut(GPIOA, 15, omPushPull);
PinSet(GPIOA, 15);
chThdSleepMilliseconds(450);
// Set ports & pins
Acc[0].SetPortAndPins(GPIOA, 1, 3, 4);
Acc[1].SetPortAndPins(GPIOA, 5, 6, 7);
Acc[2].SetPortAndPins(GPIOC, 0, 1, 2);
Acc[3].SetPortAndPins(GPIOC, 3, 4, 5);
Acc[4].SetPortAndPins(GPIOC, 6, 7, 8);
Acc[5].SetPortAndPins(GPIOC, 10, 11, 12);
Acc[6].SetPortAndPins(GPIOB, 13, 14, 15);
// Init
for(uint8_t i=0; i<ACC_CNT; i++) {
Acc[i].Init();
if(!Acc[i].IsOperational) Uart.Printf("Acc %u is not operational\r", i);
}
}
void cc1101_t::Receive(void) {
//while(IState != CC_STB_IDLE) EnterIdle();
//Aim = caRx;
PinSet(GPIOB, 0);
EnterRX(); // After that, some time will be wasted to recalibrate
// while(!GDO2IsHi());
while(!GDO0IsHi()); // Wait until sync word is sent
while(GDO0IsHi()); // Wait until transmission completed
//PinClear(GPIOB, 0);
FlushRxFIFO();
//Uart.Printf("1\r");
// uint8_t b;
//// bool result=false;
//// b = ReadRegister(CC_RXBYTES);
//// Uart.Printf("Sz: %X ", b);
// // Get pkt status
// b = ReadRegister(CC_PKTSTATUS);
//// Uart.Printf("St: %X ", b);
// if(b & 0x80) { // CRC OK
//// if(b) { // FIFO not empty
// CsLo(); // Start transmission
// //BusyWait(); // Wait for chip to become ready
// ReadWriteByte(CC_FIFO|CC_READ_FLAG|CC_BURST_FLAG); // Address with read & burst flags
// for (uint8_t i=0; i<12+2; i++) { // Read bytes
// b = ReadWriteByte(0);
// //*PArr++ = b;
// // Uart.Printf(" %X", b);
// }
// CsHi(); // End transmission
//// result = true;
// }
// Uart.Printf("\r");
//FlushRxFIFO();
//Uart.Printf("2\r");
}
void EEP_Reset()
{
i2c_master_disable(&i2c_master_instance);
pinMux(SCL, Disablemux);
pinMux(SDA, Disablemux);
pinMode(SDA,INPUT);
for (uint8_t i=0;i<9; i++)
{
PinSet(SCL);
delay_us(10);
if(PinRead(SDA))
{
break;
}
PinClr(SCL);
}
pinMux(SCL, CSERCOMmux);
pinMode(SDA,OUTPUT);
pinMux(SDA, CSERCOMmux);
i2c_master_enable(&i2c_master_instance);
I2C_STATUS|=(1<<4);
}
void eAdc_t::Init() {
PThread = chThdSelf();
PinSetupOut(ADC_GPIO, ADC_CNV, omPushPull, pudNone);
PinSetupOut(ADC_GPIO, ADC_SDI, omPushPull, pudNone);
PinSetupAlterFunc(ADC_GPIO, ADC_SCLK, omPushPull, pudNone, AF5);
PinSetupAlterFunc(ADC_GPIO, ADC_SDO, omPushPull, pudNone, AF5);
PinSet(ADC_GPIO, ADC_SDI); //select CS MODE
ADC_CNV_LOW(); // Idle mode
// ==== DMA ====
dmaStreamAllocate (EADC_DMA, IRQ_PRIO_MEDIUM, SIrqDmaHandler, NULL);
dmaStreamSetPeripheral(EADC_DMA, &ADC_SPI->DR);
dmaStreamSetMode (EADC_DMA, EADC_DMA_MODE);
dmaStreamSetMemory0(EADC_DMA, &Adc.Rslt);
dmaStreamSetTransactionSize(EADC_DMA, 1);
dmaStreamEnable(EADC_DMA);
// ==== SPI ==== MSB first, master, ClkLowIdle, FirstEdge, Baudrate=...
// Select baudrate (2.4MHz max): APB=120MHz => div = 64
ISpi.Setup(ADC_SPI, boMSB, cpolIdleLow, cphaFirstEdge, sbFdiv64, sbc16Bit);
ISpi.SetModeRxOnly();
ISpi.EnableRxDma();
ISpi.Enable();
// ==== Sampling timer ====
SamplingTmr.Init(TIM2);
SamplingTmr.SetUpdateFrequency(FSAMPL_ADC);
SamplingTmr.EnableIrq(TIM2_IRQn, IRQ_PRIO_MEDIUM);
SamplingTmr.EnableIrqOnUpdate();
SamplingTmr.Enable();
CskTmr.Init(TIM5);
CskTmr.SetUpdateFrequency(FSAMPL_CNV); // request 2 usec
CskTmr.EnableIrq(TIM5_IRQn, IRQ_PRIO_MEDIUM);
CskTmr.EnableIrqOnUpdate();
CskTmr.Disable();
}
int main (void)
{
system_init();
Initialize_Hardware();
#ifndef BypassLCD
CalibrationModeChk();
Disp_IntroLcdMsgs(); //Display company name, model name
// DoAutoZero();
LCD_Clrscr();
#endif
LCD_Setcursor(3,20);
LCD_DataWrite(ARROW);
LCD_Setcursor(1,1);
ExtADCHi=ExtADCLo+ExtADCMid+ExtADCHi;
while(1){
Spi_Get3BytesfromExtADC(Ch_Orifice_DP);
}
// volatile float asd= Compute_PT100Temp(9900);
//LCD_FullDisp( LCD_BLANK_LINE_MACRO,
//" Erase stored data? ",
//" Yes / No ",
//LCD_BLANK_LINE_MACRO);
//LCD_Frame2();
// volatile uint32_t as= CombineDigitstoNumber1(arr, 3);
volatile uint8_t selected=0;
// selected =LCD_MenuHandle(MenuSize(CalibrationMenu),CalibrationMenu);
// LCD_FullDisp(MSG[0],MSG[1],MSG[2],MSG[3]);
// LCD_FullDisp(CalibrationMenu[0],CalibrationMenu[1],CalibrationMenu[2],CalibrationMenu[3]);
// LCD_MenuDisplay(CalibrationMenu, 4);
LCD_Setcursor(1,2);
LCD_CursorOn();
LCD_DispAscii(selected);
// LCD_DispVariable(12345,2,10,0,1);
Ambient_PT100.STDvalue=10021;
volatile uint32_t ans=GetNumDataFromUser(32768,2,3,1,10);
LCD_DispVariable(ans, 2, 3, 3, 10);
volatile uint8_t a,b,c,d;
a=EE_MISCAddr(c);
b=EE_CALAddr(EE_OrifPart_Z);
c=EE_CALAddr(EE_AuxTemp_STDUP);
d=EE_CALAddr(EE_Abs_ADCLOW);
a=a+b+c+d;
while (1)
{
PinSet(BuzzerPin);
delay_sec(2);
PinClr(BuzzerPin);
delay_sec(2);
}
// Insert application code here, after the board has been initialized.
}
