int main() {
//config_timer( timer_id, go, roi, init_val, sat_val )
//Config WD timer to 3000 cycles
config_timer( 0, 1, 0, 0, 3000 );
while(1);
}
int main() {
//Clear All Pending Interrupts
*((volatile uint32_t *) 0xE000E280) = 0x03FF;
//Enable Interrupts
*((volatile uint32_t *) 0xE000E100) = 0x03FF;
//Enumeration
enumerate(RAD_ADDR);
asm ("wfi;");
enumerate(SNS_ADDR);
asm ("wfi;");
//config_timer( timer_id, go, roi, init_val, sat_val )
//Config WD timer to 3000 cycles
config_timer( 1, 1, 0, 1000, 3000 );
config_timer( 2, 1, 0, 4000, 6000 );
config_timer( 3, 1, 1, 0, 3000 );
while(1);
}
int main(void) {
Config_Puertos();
Interrupciones();
SysTick_Config(ticks);
Config_Eintx(eint2, puerto_eint2);
Config_Uart();
Config_ADC();
config_timer(timer1, match1, prescaler1);
while(1) {
if ((botonPanic==1) | (tempSen > tempTemp)) Cooler_ON();
else if (tempSen < (tempTemp-2)) Cooler_OFF();
}
return 0;
}
//***************************************************************************************
// MAIN function starts here
//***************************************************************************************
int main() {
//Clear All Pending Interrupts
*((volatile uint32_t *) 0xE000E280) = 0xF;
//Enable Interrupts
*((volatile uint32_t *) 0xE000E100) = 0xF;
// Config watchdog timer to about 30 sec: 3,000,000 with default PRCv9
//config_timer( timer_id, go, roi, init_val, sat_val )
config_timer( 0, 1, 0, 0, 3000000 );
operation_init();
delay(MBUS_DELAY);
// Should not reach here
operation_sleep_notimer();
while(1);
}
int main() {
uint32_t first_exec;
//Config watchdog timer to about 10 sec: 1,000,000 with default PRCv9
//config_timer( timer_id, go, roi, init_val, sat_val )
// FIXME: Watchdog timer disabled
config_timer( 0, 0, 0, 0, 1000000 );
delay(MBUS_DELAY);
//Check if it is the first execution
if (enumerated != 0x12345678){
first_exec = 1;
//Mark execution
enumerated = 0x12345678;
}else{
first_exec = 0;
}
// Interrupts
//Clear All Pending Interrupts
*((volatile uint32_t *) 0xE000E280) = 0xF;
//Enable Interrupts
*((volatile uint32_t *) 0xE000E100) = 0xF;
if (first_exec == 1){
// Enumeration
enumerate(MD_ADDR);
delay(MBUS_DELAY);
enumerate(RAD_ADDR);
delay(MBUS_DELAY);
// Set PMU Strength & division threshold
// Change PMU_CTRL Register
// PRCv9 Default: 0x8F770049
// Fastest sleep osc: 0x8F770079
// Fastest sleep & active osc: 0x4F773879
//*((volatile uint32_t *) 0xA200000C) = 0x8F770079; // Works well with 1.2/0.6V override
//*((volatile uint32_t *) 0xA200000C) = 0x4F771879; // works well with 1.2V override; if 1.2V is not overriden, system still works, but MD donesn't ACK --> MBUS voltage issue again!
*((volatile uint32_t *) 0xA200000C) = 0x4F772879; // works without any override!
delay(DELAY_1);
// Set MBUS Clock faster
// Change GOC_CTRL Register
// PRCv9 Default: 0x00202903
// 0x00202303 = Fastest MBUS clk
// 0x00201303 = Fastest MBUS clk, faster CPU
// 0x00200303 = Fastest MBUS clk, fastest CPU
//*((volatile uint32_t *) 0xA2000008) = 0x00202303;
*((volatile uint32_t *) 0xA2000008) = 0x00202603;
delay(DELAY_1);
} // if first_exec
// Initialize
initialize_md_reg();
// Release power gates, isolation, and reset for frame controller
if (first_exec){
poweron_frame_controller();
}else{
poweron_frame_controller_short();
}
// Release power gates, isolation, and reset for imager array
poweron_array_adc();
delay(WAKEUP_DELAY_FINAL);
capture_image_start();
while(1);
// Capture a single image
while (1){
capture_image_single();
}
poweroff_array_adc();
set_wakeup_timer(2, 0x1, 0x0);
operation_sleep();
while(1);
}
//***************************************************************************************
// MAIN function starts here
//***************************************************************************************
int main() {
//Clear All Pending Interrupts
*((volatile uint32_t *) 0xE000E280) = 0xF;
//Enable Interrupts
*((volatile uint32_t *) 0xE000E100) = 0xF;
//Config watchdog timer to about 10 sec: 1,000,000 with default PRCv9
//config_timer( timer_id, go, roi, init_val, sat_val )
config_timer( 0, 0, 0, 0, 1000000 ); // Check with Gyouho
// Initialization sequence
if (enumerated != 0xDEADBEEF){
// Set up PMU/GOC register in PRC layer (every time)
// Enumeration & RAD/SNS layer register configuration
operation_init();
}
delay(10000);
read_mbus_register(MRR_ADDR, 0x0, 0xE0);
delay(MBUS_DELAY*10);
delay(10000);
read_mbus_register(MRR_ADDR, 0xE, 0xE1);
delay(MBUS_DELAY*10);
//delay(10000);
//Digital monitoring
//0-DCP_S 2-TX 3-RX C-REC_RST
mrrv2_r12.MRR_EN_DIG_MONITOR = 0x0; // Enable monitor
write_mbus_register(MRR_ADDR,0x12,mrrv2_r12.as_int);
delay(MBUS_DELAY*10);
mrrv2_r13.MRR_DIG_MONITOR_SEL1 = 0x0;
mrrv2_r13.MRR_DIG_MONITOR_SEL2 = 0x1;
mrrv2_r13.MRR_DIG_MONITOR_SEL3 = 0x2;
write_mbus_register(MRR_ADDR,0x13,mrrv2_r13.as_int);
delay(MBUS_DELAY*10);
//TX Set-up
mrrv2_r00.MRR_TRX_CAP_ANTP_TUNE = 0x3FFF; //ANT CAP 14b unary
write_mbus_register(MRR_ADDR,0x00,mrrv2_r00.as_int);
delay(MBUS_DELAY*10);
mrrv2_r01.MRR_TRX_CAP_ANTN_TUNE = 0x3FFF ; //ANT CAP 14b unary
write_mbus_register(MRR_ADDR,0x01,mrrv2_r01.as_int);
delay(MBUS_DELAY*10);
mrrv2_r02.MRR_TX_BIAS_TUNE = 0x1FFF; //Set TX BIAS TUNE 13b
write_mbus_register(MRR_ADDR,0x02,mrrv2_r02.as_int);
delay(MBUS_DELAY*10);
//RX Set-up
mrrv2_r03.MRR_RX_BIAS_TUNE = 0x0000;// 0x1FFF; // turn on Q_enhancement
mrrv2_r03.MRR_RX_SAMPLE_CAP = 0x1; // RX_SAMPLE_CAP
write_mbus_register(MRR_ADDR,3,mrrv2_r03.as_int);
delay(MBUS_DELAY*10);
/*
mrrv2_r11.MRR_RAD_FSM_RX_POWERON_LEN = 0x3; //Set RX Power on length
mrrv2_r11.MRR_RAD_FSM_RX_SAMPLE_LEN = 0x0; //Set RX Sample length
mrrv2_r11.MRR_RAD_FSM_GUARD_LEN = 0x0FFF; //Set TX_RX Guard length
write_mbus_register(MRR_ADDR,0x11,mrrv2_r11.as_int);
delay(MBUS_DELAY*10);
*/
mrrv2_r12.MRR_RAD_FSM_RX_HDR_BITS = 0x08; //Set RX header
mrrv2_r12.MRR_RAD_FSM_RX_HDR_TH = 0x00; //Set RX header threshold
mrrv2_r12.MRR_RAD_FSM_RX_DATA_BITS = 0xAA; //Set RX data
write_mbus_register(MRR_ADDR,0x12,mrrv2_r12.as_int);
delay(MBUS_DELAY*10);
//DCP set-up
mrrv2_r03.MRR_DCP_S_OW = 0;
write_mbus_register(MRR_ADDR,0x03,mrrv2_r03.as_int);
//Timer set-up
//mrrv2_r05.MRR_EN_CLK_MONITOR = 1; //
write_mbus_register(MRR_ADDR,0x05,mrrv2_r05.as_int);
delay(MBUS_DELAY*10);
//RAD_FSM set-up
mrrv2_r0E.MRR_RAD_FSM_TX_H_LEN = 31; //31-31b header (max)
mrrv2_r0E.MRR_RAD_FSM_TX_D_LEN = 24; //0-skip tx data
write_mbus_register(MRR_ADDR,0x0E,mrrv2_r0E.as_int);
delay(MBUS_DELAY*10);
//mrrv2_r0F.MRR_RAD_FSM_TX_PW_LEN = 0; //4us PW
//mrrv2_r10.MRR_RAD_FSM_TX_C_LEN = 32; // (PW_LEN+1):C_LEN=1:32
//mrrv2_r0F.MRR_RAD_FSM_TX_PS_LEN = 0; // PW=PS
//mrrv2_r0F.MRR_RAD_FSM_TX_PW_LEN = 1; //8us PW
//mrrv2_r10.MRR_RAD_FSM_TX_C_LEN = 64; // (PW_LEN+1):C_LEN=1:32
//mrrv2_r0F.MRR_RAD_FSM_TX_PS_LEN = 1; // PW=PS
//mrrv2_r0F.MRR_RAD_FSM_TX_PW_LEN = 124; //500us PW
//mrrv2_r10.MRR_RAD_FSM_TX_C_LEN = 4000; // (PW_LEN+1):C_LEN=1:32
//mrrv2_r0F.MRR_RAD_FSM_TX_PS_LEN = 124; // PW=PS
mrrv2_r0F.MRR_RAD_FSM_TX_PW_LEN = 249; //1ms PW
mrrv2_r10.MRR_RAD_FSM_TX_C_LEN = 8000; // (PW_LEN+1):C_LEN=1:32
mrrv2_r0F.MRR_RAD_FSM_TX_PS_LEN = 249; // PW=PS
mrrv2_r0F.MRR_RAD_FSM_TX_PR_LEN = 0; //
write_mbus_register(MRR_ADDR,0x0F,mrrv2_r0F.as_int);
delay(MBUS_DELAY*10);
mrrv2_r02.MRR_TX_PULSE_FINE = 0;
mrrv2_r02.MRR_TX_PULSE_FINE_TUNE = 15;
write_mbus_register(MRR_ADDR,0x02,mrrv2_r02.as_int);
delay(MBUS_DELAY*10);
mrrv2_r10.MRR_RAD_FSM_SEED = 1; //default
mrrv2_r10.MRR_RAD_FSM_TX_MODE = 3; //code rate 0:4 1:3 2:2 3:1(baseline) 4:1/2 5:1/3 6:1/4
write_mbus_register(MRR_ADDR,0x10,mrrv2_r10.as_int);
delay(MBUS_DELAY*10);
mrrv2_r11.MRR_RAD_FSM_TX_POWERON_LEN = 7; //3bits
write_mbus_register(MRR_ADDR,0x11,mrrv2_r11.as_int);
delay(MBUS_DELAY*10);
mrrv2_r06.MRR_RAD_FSM_TX_DATA_0 = 0x5555; // alternating 10
mrrv2_r07.MRR_RAD_FSM_TX_DATA_1 = 0x5555; // alternating 10
write_mbus_register(MRR_ADDR,0x06,mrrv2_r06.as_int);
delay(MBUS_DELAY*10);
//<<<<<<< HEAD
mrrv2_r07.MRR_RAD_FSM_TX_DATA_1 = 0x5555; // alternating 10
//=======
//>>>>>>> c68953f854b6cdea9e96b6411ddf33448e1c7693
write_mbus_register(MRR_ADDR,0x07,mrrv2_r07.as_int);
delay(MBUS_DELAY*10);
//CL set-up
mrrv2_r00.MRR_CL_EN = 1; //Enable CL
mrrv2_r00.MRR_CL_CTRL = 0x01; //Set CL 1-finite 16-20uA
write_mbus_register(MRR_ADDR,0x00,mrrv2_r00.as_int);
delay(MBUS_DELAY*10);
//Timer & State Machine run
mrrv2_r04.MRR_SCRO_EN_TIMER = 1; //power on TIMER
write_mbus_register(MRR_ADDR,0x04,mrrv2_r04.as_int);
delay(MBUS_DELAY*100); //LDO stab 1s
mrrv2_r04.MRR_SCRO_RSTN_TIMER = 1; //UNRST TIMER
write_mbus_register(MRR_ADDR,0x04,mrrv2_r04.as_int);
delay(MBUS_DELAY*100); //freq stab 5s
mrrv2_r04.MRR_SCRO_EN_CLK = 1; //Enable clk
write_mbus_register(MRR_ADDR,0x04,mrrv2_r04.as_int);
delay(MBUS_DELAY*100); //freq stab 5s
mrrv2_r0E.MRR_RAD_FSM_SLEEP = 0; // Power on BB
write_mbus_register(MRR_ADDR,0x0E,mrrv2_r0E.as_int);
delay(MBUS_DELAY*100);
while(1){
mrrv2_r0E.MRR_RAD_FSM_RSTN = 1; //UNRST BB
write_mbus_register(MRR_ADDR,0x0E,mrrv2_r0E.as_int);
delay(MBUS_DELAY*10);
mrrv2_r03.MRR_TRX_ISOLATEN = 1; //set ISOLATEN 1, let state machine control
write_mbus_register(MRR_ADDR,0x03,mrrv2_r03.as_int);
delay(MBUS_DELAY*10);
mrrv2_r0E.MRR_RAD_FSM_EN = 1; //Start BB
write_mbus_register(MRR_ADDR,0x0E,mrrv2_r0E.as_int);
delay(MBUS_DELAY*10);
//radio operate
//<<<<<<< HEAD
delay(MBUS_DELAY*400); //800ms pulses
//=======
// delay(MBUS_DELAY*300); //1ms pulses,1.5s packet, 1.2s idle time
//>>>>>>> c68953f854b6cdea9e96b6411ddf33448e1c7693
mrrv2_r03.MRR_TRX_ISOLATEN = 0; //set ISOLATEN 0
write_mbus_register(MRR_ADDR,0x03,mrrv2_r03.as_int);
delay(MBUS_DELAY*10);
mrrv2_r0E.MRR_RAD_FSM_EN = 0; //Stop BB
write_mbus_register(MRR_ADDR,0x0E,mrrv2_r0E.as_int);
delay(MBUS_DELAY*10);
mrrv2_r0E.MRR_RAD_FSM_RSTN = 0; //RST BB
write_mbus_register(MRR_ADDR,0x0E,mrrv2_r0E.as_int);
delay(MBUS_DELAY*10);
};
// Should not reach here
operation_sleep();
while(1);
}
void handler_ext_int_9(void){
*((volatile uint32_t *) 0xE000E280) = 0x200;
config_timer( 3, 0, 0, 0, 3000 );
write_mbus_register(SNS_ADDR,3,0xA);
}
void handler_ext_int_8(void){
*((volatile uint32_t *) 0xE000E280) = 0x100;
config_timer( 2, 0, 0, 0, 6000 );
write_mbus_register(SNS_ADDR,2,0xA);
}
//***************************************************************************************
// MAIN function starts here
//***************************************************************************************
int main() {
//Clear All Pending Interrupts
*((volatile uint32_t *) 0xE000E280) = 0xF;
//Enable Interrupts
*((volatile uint32_t *) 0xE000E100) = 0xF;
//Config watchdog timer to about 10 sec: 1,000,000 with default PRCv9
//config_timer( timer_id, go, roi, init_val, sat_val )
config_timer( 0, 1, 0, 0, 1000000 );
// Initialization sequence
if (enumerated != 0xDEADBEEF){
// Set up PMU/GOC register in PRC layer (every time)
// Enumeration & RAD/SNS layer register configuration
operation_init();
}
// Check if wakeup is due to GOC interrupt
// 0x68 is reserved for GOC-triggered wakeup (Named IRQ10VEC)
// 8 MSB bits of the wakeup data are used for function ID
uint32_t wakeup_data = *((volatile uint32_t *) IRQ10VEC);
uint8_t wakeup_data_header = wakeup_data>>24;
uint8_t wakeup_data_field_0 = wakeup_data & 0xFF;
uint8_t wakeup_data_field_1 = wakeup_data>>8 & 0xFF;
uint8_t wakeup_data_field_2 = wakeup_data>>16 & 0xFF;
if(wakeup_data_header == 1){
// Debug mode: Transmit something via radio and go to sleep w/o timer
// wakeup_data[7:0] is the # of transmissions
// wakeup_data[15:8] is the user-specified period
// wakeup_data[23:16] is the MSB of # of transmissions
WAKEUP_PERIOD_CONT_INIT = wakeup_data_field_1;
delay(MBUS_DELAY);
if (exec_count_irq < (wakeup_data_field_0 + (wakeup_data_field_2<<8))){
exec_count_irq++;
if (exec_count_irq == 1){
// Prepare radio TX
radio_power_on();
// Go to sleep for SCRO stabilitzation
set_wakeup_timer(WAKEUP_PERIOD_RADIO_INIT, 0x1, 0x0);
operation_sleep_noirqreset();
}else{
// radio
send_radio_data_ppm(0,0xFAF000+exec_count_irq);
// set timer
set_wakeup_timer (WAKEUP_PERIOD_CONT_INIT, 0x1, 0x0);
// go to sleep and wake up with same condition
operation_sleep_noirqreset();
}
}else{
exec_count_irq = 0;
// radio
send_radio_data_ppm(1,0xFAF000);
// Go to sleep without timer
operation_sleep_notimer();
}
}else if(wakeup_data_header == 2){
// Slow down PMU sleep osc and run CDC code with desired wakeup period
// wakeup_data[15:0] is the user-specified period
// wakeup_data[19:16] is the initial user-specified period
// wakeup_data[20] enables radio tx for each measurement
// wakeup_data[23:21] specifies how many cdc executes; 0: unlimited, n: 50*2^n
WAKEUP_PERIOD_CONT = wakeup_data_field_0 + (wakeup_data_field_1<<8);
WAKEUP_PERIOD_CONT_INIT = wakeup_data_field_2 & 0xF;
radio_tx_option = wakeup_data_field_2 & 0x10;
set_cdc_exec_count = wakeup_data_field_2 >> 5;
cdc_run_single = 0;
//set_pmu_sleep_clk_low();
delay(MBUS_DELAY);
if (!cdc_running){
// Go to sleep for initial settling of pressure // FIXME
set_wakeup_timer (5, 0x1, 0x0); // 150: around 5 min
cdc_running = 1;
operation_sleep_noirqreset();
}
exec_count = 0;
meas_count = 0;
cdc_storage_count = 0;
radio_tx_count = 0;
// Reset IRQ10VEC
*((volatile uint32_t *) IRQ10VEC) = 0;
// Run CDC Program
cdc_reset_timeout_count = 0;
operation_cdc_run();
}else if(wakeup_data_header == 3){
void handler_ext_int_7(void){
*((volatile uint32_t *) 0xE000E280) = 0x80;
config_timer( 1, 0, 0, 4000, 6000 );
write_mbus_register(SNS_ADDR,1,0xA);
}
static int __init bcm_tty_init(void)
{
int ret;
int mcu_req = 0;
int mcu_resp = 0;
//int host_req = 0;
/* Check GPIO# */
/*===================================================
We need folowing OF node in dts
bcm477x-gpio {
ssp-mcu-req = <some_gpio_number>
ssp-mcu-resp = <some_gpio_number>
ssp-host-req = <some_gpio_number>
}
===================================================== */
struct device_node *np = of_find_node_by_name(NULL, "gps_power");
if (!np) {
pr_err("[SSPBBD]gpstty driver fail to find OF node huawei,gps_power\n");
goto err_exit;
}
mcu_req = of_get_named_gpio(np,"huawei,mcu_req",0);
mcu_resp = of_get_named_gpio(np,"huawei,mcu_req_rsp",0);
//host_req = of_get_named_gpio(np,"huawei,gps_hostwake",0);
#ifdef BCM_TTY_DEBUG_INFO
pr_info("[SSPBBD]gpstty driver huawei,mcu_req=%d, huawei,mcu_req_rsp=%d\n", mcu_req, mcu_resp);
#endif
if (mcu_req<0 || mcu_resp<0) {
pr_err("[SSPBBD]: GPIO value not correct\n");
goto err_exit;
}
/* Config GPIO */
gpio_request(mcu_req, "MCU REQ");
gpio_direction_output(mcu_req, 0);
gpio_request(mcu_resp, "MCU RESP");
gpio_direction_input(mcu_resp);
/* Alloc */
priv = (struct bcm_tty_priv*) kmalloc(sizeof(*priv), GFP_KERNEL);
if (!priv) {
pr_err("%s Failed to allocate \"gpstty\"\n", __func__);
goto err_exit;
}
memset(priv, 0, sizeof(*priv));
/* Init - gpios */
//priv->host_req = host_req;
priv->mcu_req = mcu_req;
priv->mcu_resp = mcu_resp;
/* Register misc device */
priv->misc.minor = MISC_DYNAMIC_MINOR;
priv->misc.name = "gpstty";
priv->misc.fops = &bcm_tty_fops;
/* Initialize alarm bases */
#ifdef USE_TIMER
config_timer(priv);
#endif
ret = misc_register(&priv->misc);
if (ret) {
pr_err("%s Failed to register gpstty. err=%d\n", __func__,ret);
goto free_mem;
}
return 0;
free_mem:
if (priv)
kfree(priv);
err_exit:
return -ENODEV;
}
int main (int argc, char *argv[])
{
char msg[32] = "\n\rHallo Welt!\n\r";
char msg_key1[32] = " Pushbutton 1 ";
char msg_key2[32] = " Pushbutton 2 ";
char msg_key3[32] = " Pushbutton 3 ";
char msg_pos1[32] = "\r";
char msg_tmp[32] = "";
UART_Cfg cfg;
// Initialize peripheral components ...
// UART
cfg.fclk = 50000000;
cfg.baud = UART_CFG_BAUD_115200;
cfg.frame.msg_len = UART_CFG_MSG_LEN_8;
cfg.frame.parity = UART_CFG_PARITY_EVEN;
cfg.frame.stop_bits = UART_CFG_STOP_BITS_1;
UART_init (cfg);
// 7-Segment
dis7seg_initHandle(&display_handle, DISP7SEG_BADDR, 8);
dis7seg_displayHexUInt32(&display_handle, 0, 0x00000042);
uint32_t keys, keys_old, led_port;
uint8_t i;
keys_old = 0;
led_port = 0;
UART_write(0, msg, strlen(msg));
//register interrupt to line 2
REGISTER_INTERRUPT(isr, 2);
// unmask interrupt line 2
UMASKI(2);
// globally enable interrupts
SEI();
// timer 80000 ticks = 1ms, 80 ticks = 1s
config_timer(50000000, 0);
timer_initHandle(&timer_handle, TIMER_BADDR);
start_timer();
while(1) {
// pushbuttons
keys = getButtonStatus();
if(keys != keys_old) {
if(keys & (1<<BUTTON3)) {
UART_write(0, msg_key3, strlen(msg_key3));
}
if(keys & (1<<BUTTON2)) {
UART_write(0, msg_key2, strlen(msg_key2));
}
if(keys & (1<<BUTTON1)) {
UART_write(0, msg_key1, strlen(msg_key1));
}
}
keys_old = keys;
// switches & leds
led_port = 0;
for(i=0; i<18; i++)
{
if (getSwitchStatus(i) == SW_ON) {
led_port |= (SW_ON<<i);
//(void) sprintf(msg_tmp, "KEY %i ON", i);
//UART_write(0, msg_tmp, strlen(msg_tmp));
}
}
UART_write(0, msg_pos1, strlen(msg_pos1));
// leds
//setLeds(led_port);
}
return 0;
}
