static void move_player(long frame_count) {
// move x
if(gpioGetValue(RB_BTN0) == 0) {
game.player_x_vel--;
}
else if(gpioGetValue(RB_BTN1) == 0) {
game.player_x_vel++;
}
else {
game.player_x_vel = 0;
}
if(game.player_x_vel > MAX_VEL_X) {
game.player_x_vel = MAX_VEL_X;
}
else if(game.player_x_vel < -1*MAX_VEL_X) {
game.player_x_vel = -1*MAX_VEL_X;
}
game.player_x += game.player_x_vel + RESX;
game.player_x %= RESX;
// move y (jump)
// half the speed
if(frame_count%2 == 0) {
int old_y = game.player_y;
if(game.player_ground) {
game.player_y_vel = JUMP_FORCE;
game.player_ground = false;
}
game.player_y_vel += GRAVITY;
game.player_y_vel = game.player_y_vel > MAX_VEL_Y ? MAX_VEL_Y : game.player_y_vel;
int new_y = old_y + game.player_y_vel;
// collision detection
int player_x_center = game.player_x + PLAYER_SPRITE_WIDTH/2;
for(int i = 0; i < NUM_PLATFORMS; i++) {
if(game.player_y_vel > 0
&& old_y < game.platforms_y[i]
&& new_y >= game.platforms_y[i]
&& game.platforms_x1[i] <= player_x_center+2
&& game.platforms_x2[i] >= player_x_center-2) {
game.player_y = game.platforms_y[i]-1;
game.player_y_vel = 0;
game.player_ground = true;
break;
}
}
game.player_y = new_y;
if(game.player_y > RESY + PLAYER_SPRITE_HEIGHT) {
game.running = false;
}
}
}
int
main(void)
{
// Configure cpu and mandatory peripherals
systemInit();
uint32_t currentSecond, lastSecond;
currentSecond = lastSecond = 0;
// uartInit(115200);
prt();
while (1)
{
// Toggle LED once per second
currentSecond = systickGetSecondsActive();
if (currentSecond != lastSecond)
{
lastSecond = currentSecond;
gpioSetValue(CFG_LED_PORT, CFG_LED_PIN, !(gpioGetValue(CFG_LED_PORT, CFG_LED_PIN)));
uartSendByte('*');
}
// Poll for CLI input if CFG_INTERFACE is enabled in projectconfig.h
#ifdef CFG_INTERFACE
cmdPoll();
#endif
}
return 0;
}
int main(void)
{
// Configure cpu and mandatory peripherals
systemInit();
uint32_t currentSecond, lastSecond;
currentSecond = lastSecond = 0;
while (1)
{
// Toggle LED once per second ... rollover = 136 years :)
currentSecond = systickGetSecondsActive();
if (currentSecond != lastSecond)
{
lastSecond = currentSecond;
if (gpioGetValue(CFG_LED_PORT, CFG_LED_PIN) == CFG_LED_OFF)
{
gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_ON);
}
else
{
gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_OFF);
}
}
// Poll for CLI input if CFG_INTERFACE is enabled in projectconfig.h
#ifdef CFG_INTERFACE
cmdPoll();
#endif
}
return 0;
}
/** reaction.c
* First l0dable for my r0ket
* Improvement is welcome
*
* AUTHOR: hubba
*/
void ram(void)
{
char x = gpioGetValue(RB_LED1);
int rand_wait = 0;
int react_time=0;
int start_time = 0;
int end_time = 0;
gpioSetValue (RB_LED1,0); //upperleft LED off
lcdClear();
lcdPrintln("Hello");
lcdPrintln(GLOBAL(nickname));
lcdPrintln("ReACTION");
lcdRefresh();
delayms(500);
while(1)
{
react_time = 0;
lcdPrintln("Press ENTER if ");
lcdPrintln("LED is on!");
lcdRefresh();
rand_wait = getRandom();
rand_wait = rand_wait%50;
rand_wait = 40 + rand_wait*4; // Minimum pause time is 400ms
for(int i =0; i<=rand_wait; i++) //directly calling delayms(rand_wait) didn't work
{
delayms(10);
}
gpioSetValue (RB_LED1, 1); //upperleft LED ON
getInputWaitRelease();
start_time = getTimer()*(SYSTICKSPEED);
while (getInputWait() != BTN_ENTER); //wait for user input
{
}
end_time = getTimer()*(SYSTICKSPEED);
react_time = end_time - start_time; //measure used time
lcdClear();
lcdPrint("Needed ");
lcdPrintInt(react_time);
lcdPrintln(" ms");
lcdPrintln("DOWN: Exit");
lcdPrintln("0ther: New game");
lcdRefresh();
gpioSetValue (RB_LED1,0); //upperleft LED off
getInputWaitRelease();
if(getInputWait() == BTN_DOWN) //Check for Exit/new game
{
gpioSetValue (RB_LED1, x); //upperleft LED as before l0dable executed
return;
}
}
/* NEVER LAND HERE */
lcdPrintln("Flow-Error");
lcdRefresh();
return;
};
void ram(void){
char x = gpioGetValue(RB_LED1);
for (int x=0;x<20;x++){
gpioSetValue (RB_LED1, x%2);
delayms(50);
};
gpioSetValue (RB_LED1, x);
}
static void
sts(void)
{
int j, i;
char s[64];
j = 0;
s[j++] = 's';
s[j++] = '0' + gpioGetValue(1, 1);
s[j++] = ' ';
for (i = 7; i >- 0; i--)
s[j++] = '0' + gpioGetValue(2, i);
s[j++] = ' ';
s[j++] = 'a';
s[j++] = '0' + gpioGetValue(3, 0);
s[j++] = ' ';
s[j++] = 'i';
s[j++] = '0' + gpioGetValue(3, 2);
s[j++] = ' ';
s[j++] = 's';
s[j++] = '0' + gpioGetValue(3, 3);
s[j++] = ' ';
s[j++] = ' ';
s[j++] = 's';
s[j++] = '0' + gpioGetValue(0, 8);
s[j++] = ' ';
s[j++] = 'p';
s[j++] = '0' + gpioGetValue(0, 9);
s[j++] = ' ';
s[j++] = 'b';
s[j++] = '0' + gpioGetValue(0, 10);
s[j++] = ' ';
s[j++] = 'a';
s[j++] = '0' + gpioGetValue(0, 11);
s[j++] = ' ';
s[j++] = 'e';
s[j++] = '0' + gpioGetValue(3, 1);
s[j++] = '\0';
puts(s);
puts("\r\n");
}
void cmd_sysinfo(uint8_t argc, char **argv)
{
IAP_return_t iap_return;
printf("%-25s : %d.%d MHz %s", "System Clock", CFG_CPU_CCLK / 1000000, CFG_CPU_CCLK % 1000000, CFG_PRINTF_NEWLINE);
printf("%-25s : v%d.%d.%d %s", "Firmware", CFG_FIRMWARE_VERSION_MAJOR, CFG_FIRMWARE_VERSION_MINOR, CFG_FIRMWARE_VERSION_REVISION, CFG_PRINTF_NEWLINE);
// 128-bit MCU Serial Number
iap_return = iapReadSerialNumber();
if(iap_return.ReturnCode == 0)
{
printf("%-25s : %08X %08X %08X %08X %s", "Serial Number", iap_return.Result[0],iap_return.Result[1],iap_return.Result[2],iap_return.Result[3], CFG_PRINTF_NEWLINE);
}
// CLI and buffer Settings
#ifdef CFG_INTERFACE
printf("%-25s : %d bytes %s", "Max CLI Command", CFG_INTERFACE_MAXMSGSIZE, CFG_PRINTF_NEWLINE);
#endif
#ifdef CFG_PRINTF_UART
uart_pcb_t *pcb = uartGetPCB();
printf("%-25s : %d %s", "UART Baud Rate", pcb->baudrate, CFG_PRINTF_NEWLINE);
#endif
// TFT LCD Settings (if CFG_TFTLCD enabled)
#ifdef CFG_TFTLCD
printf("%-25s : %d %s", "LCD Width", (int)lcdGetWidth(), CFG_PRINTF_NEWLINE);
printf("%-25s : %d %s", "LCD Height", (int)lcdGetHeight(), CFG_PRINTF_NEWLINE);
#endif
// Wireless Settings (if CFG_CHIBI enabled)
#ifdef CFG_CHIBI
chb_pcb_t *pcb = chb_get_pcb();
printf("%-25s : %s %s", "Wireless", "AT86RF212", CFG_PRINTF_NEWLINE);
printf("%-25s : 0x%04X %s", "802.15.4 PAN ID", CFG_CHIBI_PANID, CFG_PRINTF_NEWLINE);
printf("%-25s : 0x%04X %s", "802.15.4 Node Address", pcb->src_addr, CFG_PRINTF_NEWLINE);
printf("%-25s : %d %s", "802.15.4 Channel", CFG_CHIBI_CHANNEL, CFG_PRINTF_NEWLINE);
#endif
// System Uptime (based on systick timer)
printf("%-25s : %u s %s", "System Uptime", (unsigned int)systickGetSecondsActive(), CFG_PRINTF_NEWLINE);
// System Temperature (if LM75B Present)
#ifdef CFG_LM75B
int32_t temp = 0;
lm75bGetTemperature(&temp);
temp *= 125;
printf("%-25s : %d.%d C %s", "Temperature", temp / 1000, temp % 1000, CFG_PRINTF_NEWLINE);
#endif
#ifdef CFG_SDCARD
printf("%-25s : %s %s", "SD Card Present", gpioGetValue(CFG_SDCARD_CDPORT, CFG_SDCARD_CDPIN) ? "True" : "False", CFG_PRINTF_NEWLINE);
#endif
}
static void conrtols(void){
if (gpioGetValue(RB_BTN0)==0) {
if (game.ship_x > 0){
game.ship_x -= 1;
}
} else if (gpioGetValue(RB_BTN1)==0) {
if (game.ship_x < RESX-SHIP_WIDTH){
game.ship_x += 1;
}
} else if (gpioGetValue(RB_BTN2)==0) {
if (game.ship_y < RESY-SHIP_HEIGHT){
game.ship_y += 1;
}
} else if (gpioGetValue(RB_BTN3)==0) {
if (game.ship_y > 0){
game.ship_y -= 1;
}
} else if (gpioGetValue(RB_BTN4)==0) {
shoot();
}
}
uint8_t lcdRead(uint8_t data)
{
uint32_t op211cache=IOCON_PIO2_11;
uint32_t op09cache=IOCON_PIO0_9;
uint32_t dircache=GPIO_GPIO2DIR;
IOCON_PIO2_11=IOCON_PIO2_11_FUNC_GPIO|IOCON_PIO2_11_MODE_PULLUP;
IOCON_PIO0_9=IOCON_PIO0_9_FUNC_GPIO|IOCON_PIO0_9_MODE_PULLUP;
gpioSetDir(SCK, 1);
uint8_t i;
gpioSetDir(SDA, 1);
gpioSetValue(SCK, 0);
gpioSetValue(CS, 0);
delayms(1);
gpioSetValue(SDA, 0);
gpioSetValue(SCK, 1);
delayms(1);
for(i=0; i<8; i++){
gpioSetValue(SCK, 0);
delayms(1);
if( data & 0x80 )
gpioSetValue(SDA, 1);
else
gpioSetValue(SDA, 0);
data <<= 1;
gpioSetValue(SCK, 1);
delayms(1);
}
uint8_t ret = 0;
gpioSetDir(SDA, 0);
for(i=0; i<8; i++){
gpioSetValue(SCK, 0);
delayms(1);
ret <<= 1;
ret |= gpioGetValue(SDA);
gpioSetValue(SCK, 1);
delayms(1);
}
gpioSetValue(SCK, 0);
gpioSetValue(CS, 1);
gpioSetDir(SDA, 1);
IOCON_PIO2_11=op211cache;
IOCON_PIO0_9=op09cache;
GPIO_GPIO2DIR=dircache;
delayms(1);
return ret;
}
int main(void)
{
#ifndef CFG_PWM
#ERROR "CFG_PWM must be enabled in projectconfig.h for this example."
#endif
// Configure cpu and mandatory peripherals
// PWM is initialised in systemInit and defaults to using P1.9
systemInit();
// Set duty cycle to 50% for square wave output
pwmSetDutyCycle(50);
// Frequency can be set anywhere from 2khz and 10khz (4khz is loudest)
// Note: Since this is a 16-bit timer, make sure the delay is not
// greater than 0xFFFF (65535), though anything 2khz and higher
// is within an acceptable range
// The piezo buzzer used for this example is the PS1240, available at
// http://www.adafruit.com/index.php?main_page=product_info&cPath=35&products_id=160
pwmSetFrequencyInTicks(CFG_CPU_CCLK / 2000);
uint32_t currentSecond, lastSecond;
currentSecond = lastSecond = 0;
while (1)
{
// Beep the piezo buzzer very briefly once per second, toggling the LED at the same time
currentSecond = systickGetSecondsActive();
// Make sure that at least one second has passed
if (currentSecond != lastSecond)
{
// Update the second tracker
lastSecond = currentSecond;
// Set the LED state and buzzer loudness depending on the current LED state
if (gpioGetValue(CFG_LED_PORT, CFG_LED_PIN) == CFG_LED_OFF)
{
pwmSetFrequencyInTicks(CFG_CPU_CCLK / 4000); // 4khz (louder)
pwmStartFixed(200); // 2x as long as @ 2khz since it's 2x faster
gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_ON); // Turn the LED on
}
else
{
pwmSetFrequencyInTicks(CFG_CPU_CCLK / 2000); // 2khz (softer)
pwmStartFixed(100);
gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_OFF); // Turn the LED off
}
}
}
return 0;
}
void VoltageCheck(void){
chrg=gpioGetValue(RB_PWR_CHRG);
results = adcRead(1);
results *= 10560;
results /= 1024;
if( results < 3500 ){
nrf_off();
gpioSetValue (RB_PWR_GOOD, 0);
gpioSetValue (RB_LCD_BL, 0);
SCB_SCR |= SCB_SCR_SLEEPDEEP;
PMU_PMUCTRL = PMU_PMUCTRL_DPDEN_DEEPPOWERDOWN;
__asm volatile ("WFI");
};
int main(void)
{
// Configure cpu and mandatory peripherals
systemInit();
while (1)
{
// Wait one second
systickDelay(1000);
// Toggle the LED
if (gpioGetValue(CFG_LED_PORT, CFG_LED_PIN) == CFG_LED_OFF)
{
gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_ON);
}
else
{
gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_OFF);
}
}
return 0;
}
int main(void)
{
// Configure cpu and mandatory peripherals
systemInit();
uint32_t currentSecond, lastSecond;
currentSecond = lastSecond = 0;
// Toggle LED once per second and constantly check CLI input
while (1)
{
// Get the number of seconds the CPU has been active
// If the value has changed we've advanced at least 1 second
currentSecond = systickGetSecondsActive();
if (currentSecond != lastSecond)
{
lastSecond = currentSecond;
// Toggle the LED
if (gpioGetValue(CFG_LED_PORT, CFG_LED_PIN) == CFG_LED_OFF)
{
gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_ON);
}
else
{
gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_OFF);
}
}
// Poll for CLI input if CFG_INTERFACE is enabled in projectconfig.h
#ifdef CFG_INTERFACE
cmdPoll();
#endif
}
return 0;
}
U8 chb_set_state(U8 state)
{
U8 curr_state, delay;
// if we're sleeping then don't allow transition
if (gpioGetValue(CHB_SLPTRPORT, CHB_SLPTRPIN))
{
return RADIO_WRONG_STATE;
}
// if we're in a transition state, wait for the state to become stable
curr_state = chb_get_state();
if ((curr_state == BUSY_TX_ARET) || (curr_state == BUSY_RX_AACK) || (curr_state == BUSY_RX) || (curr_state == BUSY_TX))
{
while (chb_get_state() == curr_state);
}
// At this point it is clear that the requested new_state is:
// TRX_OFF, RX_ON, PLL_ON, RX_AACK_ON or TX_ARET_ON.
// we need to handle some special cases before we transition to the new state
switch (state)
{
case TRX_OFF:
/* Go to TRX_OFF from any state. */
CHB_SLPTR_DISABLE();
chb_reg_read_mod_write(TRX_STATE, CMD_FORCE_TRX_OFF, 0x1f);
chb_delay_us(TIME_ALL_STATES_TRX_OFF);
break;
case TX_ARET_ON:
if (curr_state == RX_AACK_ON)
{
/* First do intermediate state transition to PLL_ON, then to TX_ARET_ON. */
chb_reg_read_mod_write(TRX_STATE, CMD_PLL_ON, 0x1f);
chb_delay_us(TIME_RX_ON_PLL_ON);
}
break;
case RX_AACK_ON:
if (curr_state == TX_ARET_ON)
{
/* First do intermediate state transition to RX_ON, then to RX_AACK_ON. */
chb_reg_read_mod_write(TRX_STATE, CMD_PLL_ON, 0x1f);
chb_delay_us(TIME_RX_ON_PLL_ON);
}
break;
}
/* Now we're okay to transition to any new state. */
chb_reg_read_mod_write(TRX_STATE, state, 0x1f);
/* When the PLL is active most states can be reached in 1us. However, from */
/* TRX_OFF the PLL needs time to activate. */
delay = (curr_state == TRX_OFF) ? TIME_TRX_OFF_PLL_ON : TIME_RX_ON_PLL_ON;
chb_delay_us(delay);
if (chb_get_state() == state)
{
return RADIO_SUCCESS;
}
return RADIO_TIMED_OUT;
}
int main(void)
{
#if !defined CFG_TFTLCD
#error "CFG_TFTLCD must be enabled in projectconfig.h for this test"
#endif
#if defined CFG_INTERFACE
#error "CFG_INTERFACE must be disabled in projectconfig.h for this test (to save space)"
#endif
// Configure cpu and mandatory peripherals
systemInit();
/* Set P2.0 to GPIO input (just in case) */
gpioSetDir(2, 0, 0);
/* Set P1.4/AD5 to analog input (only AD0..3 are configured by adcInit) */
IOCON_PIO1_4 &= ~(IOCON_PIO1_4_ADMODE_MASK |
IOCON_PIO1_4_FUNC_MASK |
IOCON_PIO1_4_MODE_MASK);
IOCON_PIO1_4 |= (IOCON_PIO1_4_FUNC_AD5 &
IOCON_PIO1_4_ADMODE_ANALOG);
// Rotate the screen and render the area around the data grid
lcdSetOrientation(LCD_ORIENTATION_LANDSCAPE);
renderLCDFrame();
tsTouchData_t touch;
// Start reading
while (1)
{
// Wait up to 5ms for a touch event
tsTouchError_t error = tsWaitForEvent(&touch, 5);
if (!error)
{
if (touch.x > 25 && touch.x < 100 && touch.y > 210)
{
// Analog switch selected
adcEnabled = adcEnabled ? false : true;
}
if (touch.x > 125 && touch.x < 200 && touch.y > 210)
{
// Digital switch selected
digEnabled = digEnabled ? false : true;
}
// Refresh the frame
renderLCDFrame();
}
// Read pins
if (adcEnabled)
addToBuffer(adcBuffer, adcRead(5) / 4); // 10-bit value converted to 8-bits
if (digEnabled)
addToBuffer(digBuffer, gpioGetValue(2, 0) ? 0xFF : 0x00);
// Update the LCD is required
renderLCDGrid();
// Note, this will actually mean the timing is ~100mS + the amount of
// time it took to get the readings and update the LCD
// A timer interrupt could be used to get much more accurate results,
// filling the buffer inside the IRQ and rendering the screen updates
// every x milliseconds
systickDelay(100);
}
return 0;
}
void cmd_sysinfo(uint8_t argc, char **argv)
{
IAP_return_t iap_return;
/* Note: Certain values are only reported if CFG_INTERFACE_LONGSYSINFO
is set to 1 in projectconfig.h. These extra values are more useful
for debugging than real-world use, so there's no point wasiting
flash space storing the code for them */
printf("%-25s : %d.%d.%d %s", "Firmware", CFG_FIRMWARE_VERSION_MAJOR, CFG_FIRMWARE_VERSION_MINOR, CFG_FIRMWARE_VERSION_REVISION, CFG_PRINTF_NEWLINE);
printf("%-25s : %d.%d MHz %s", "System Clock", CFG_CPU_CCLK / 1000000, CFG_CPU_CCLK % 1000000, CFG_PRINTF_NEWLINE);
// System Uptime (based on systick timer)
printf("%-25s : %u s %s", "System Uptime", (unsigned int)systickGetSecondsActive(), CFG_PRINTF_NEWLINE);
// 128-bit MCU Serial Number
iap_return = iapReadSerialNumber();
if(iap_return.ReturnCode == 0)
{
printf("%-25s : %08X %08X %08X %08X %s", "Serial Number", iap_return.Result[0],iap_return.Result[1],iap_return.Result[2],iap_return.Result[3], CFG_PRINTF_NEWLINE);
}
#if CFG_INTERFACE_LONGSYSINFO
#ifdef CFG_USBCDC
printf("%-25s : %d ms %s", "USB Init Timeout", CFG_USBCDC_INITTIMEOUT, CFG_PRINTF_NEWLINE);
#endif
#endif
// CLI and buffer Settings
#if CFG_INTERFACE_LONGSYSINFO
printf("%-25s : %d bytes %s", "CLI Max Command Size", CFG_INTERFACE_MAXMSGSIZE, CFG_PRINTF_NEWLINE);
printf("%-25s : %s %s", "CLI IRQ Enabled", CFG_INTERFACE_ENABLEIRQ ? "True" : "False", CFG_PRINTF_NEWLINE);
#if CFG_INTERFACE_ENABLEIRQ
printf("%-25s : %d.%d %s", "CLI IRQ Location", CFG_INTERFACE_IRQPORT, CFG_INTERFACE_IRQPIN, CFG_PRINTF_NEWLINE);
#endif
#endif
#if CFG_INTERFACE_LONGSYSINFO
#ifdef CFG_I2CEEPROM
printf("%-25s : %d bytes %s", "EEPROM Size", CFG_I2CEEPROM_SIZE, CFG_PRINTF_NEWLINE);
#endif
#endif
#ifdef CFG_SDCARD
printf("%-25s : %s %s", "SD Card Present", gpioGetValue(CFG_SDCARD_CDPORT, CFG_SDCARD_CDPIN) ? "True" : "False", CFG_PRINTF_NEWLINE);
#if CFG_INTERFACE_LONGSYSINFO
printf("%-25s : %s %s", "FAT File System", CFG_SDCARD_READONLY ? "Read Only" : "Read/Write", CFG_PRINTF_NEWLINE);
#endif
#endif
#ifdef CFG_PRINTF_UART
uart_pcb_t *pcb = uartGetPCB();
printf("%-25s : %u %s", "UART Baud Rate", (unsigned int)(pcb->baudrate), CFG_PRINTF_NEWLINE);
#endif
// TFT LCD Settings (if CFG_TFTLCD enabled)
#ifdef CFG_TFTLCD
printf("%-25s : %d %s", "LCD Width", (int)lcdGetWidth(), CFG_PRINTF_NEWLINE);
printf("%-25s : %d %s", "LCD Height", (int)lcdGetHeight(), CFG_PRINTF_NEWLINE);
#if CFG_INTERFACE_LONGSYSINFO
printf("%-25s : %04X %s", "LCD Controller ID", (unsigned short)lcdGetControllerID(), CFG_PRINTF_NEWLINE);
printf("%-25s : %s %s", "LCD Small Fonts", CFG_TFTLCD_INCLUDESMALLFONTS == 1 ? "True" : "False", CFG_PRINTF_NEWLINE);
printf("%-25s : %s %s", "LCD AA Fonts", CFG_TFTLCD_USEAAFONTS == 1 ? "True" : "False", CFG_PRINTF_NEWLINE);
lcdProperties_t lcdprops = lcdGetProperties();
printf("%-25s : %s %s", "Touch Screen", lcdprops.touchscreen ? "True" : "False", CFG_PRINTF_NEWLINE);
if (lcdprops.touchscreen)
{
printf("%-25s : %s %s", "Touch Screen Calibrated", eepromReadU8(CFG_EEPROM_TOUCHSCREEN_CALIBRATED) == 1 ? "True" : "False", CFG_PRINTF_NEWLINE);
printf("%-25s : %d %s", "Touch Screen Threshold", CFG_TFTLCD_TS_DEFAULTTHRESHOLD, CFG_PRINTF_NEWLINE);
}
#endif
#endif
// Wireless Settings (if CFG_CHIBI enabled)
#ifdef CFG_CHIBI
chb_pcb_t *pcb = chb_get_pcb();
printf("%-25s : %s %s", "Wireless", "AT86RF212", CFG_PRINTF_NEWLINE);
printf("%-25s : 0x%04X %s", "802.15.4 PAN ID", CFG_CHIBI_PANID, CFG_PRINTF_NEWLINE);
printf("%-25s : 0x%04X %s", "802.15.4 Node Address", pcb->src_addr, CFG_PRINTF_NEWLINE);
printf("%-25s : %d %s", "802.15.4 Channel", CFG_CHIBI_CHANNEL, CFG_PRINTF_NEWLINE);
#endif
// System Temperature (if LM75B Present)
#ifdef CFG_LM75B
int32_t temp = 0;
lm75bGetTemperature(&temp);
temp *= 125;
printf("%-25s : %d.%d C %s", "Temperature", temp / 1000, temp % 1000, CFG_PRINTF_NEWLINE);
#endif
// ADC Averaging
#if CFG_INTERFACE_LONGSYSINFO
printf("%-25s : %s %s", "ADC Averaging", ADC_AVERAGING_ENABLE ? "True" : "False", CFG_PRINTF_NEWLINE);
#if ADC_AVERAGING_ENABLE
printf("%-25s : %d %s", "ADC Averaging Samples", ADC_AVERAGING_SAMPLES, CFG_PRINTF_NEWLINE);
#endif
#endif
// Debug LED
#if CFG_INTERFACE_LONGSYSINFO
printf("%-25s : %d.%d %s", "LED Location", CFG_LED_PORT, CFG_LED_PIN, CFG_PRINTF_NEWLINE);
#endif
}
void cmd_sysinfo(uint8_t argc, char **argv)
{
printf("%-25s : %d.%d MHz %s", "System Clock", CFG_CPU_CCLK / 1000000, CFG_CPU_CCLK % 1000000, CFG_PRINTF_NEWLINE);
printf("%-25s : %d.%d.%d %s", "Firmware", CFG_FIRMWARE_VERSION_MAJOR, CFG_FIRMWARE_VERSION_MINOR, CFG_FIRMWARE_VERSION_REVISION, CFG_PRINTF_NEWLINE);
// 128-bit MCU Serial Number
IAP_return_t iap_return;
iap_return = iapReadSerialNumber();
if(iap_return.ReturnCode == 0)
{
printf("%-25s : %08X %08X %08X %08X %s", "Serial Number", iap_return.Result[0],iap_return.Result[1],iap_return.Result[2],iap_return.Result[3], CFG_PRINTF_NEWLINE);
}
// Check the battery voltage
#ifdef CFG_BAT
uint32_t c;
gpioSetDir(CFG_BAT_ENPORT, CFG_BAT_ENPIN, gpioDirection_Output );
gpioSetValue(CFG_BAT_ENPORT, CFG_BAT_ENPIN, 1 ); // Enable the voltage divider
systickDelay(5);
c = adcRead(CFG_BAT_ADC); // Pre-read ADC to warm it up
systickDelay(10);
c = adcRead(CFG_BAT_ADC);
c = (c * CFG_VREG_VCC_MAIN) / 1000; // Value in millivolts relative to supply voltage
c = (c * CFG_BAT_MULTIPLIER) / 1000; // Battery voltage in millivolts (depends on resistor values)
gpioSetValue(CFG_BAT_ENPORT, CFG_BAT_ENPIN, 0 ); // Turn the voltage divider back off to save power
printf("%-25s : %u.%u V %s", "Supply Voltage", (unsigned int)(c / 1000), (unsigned int)(c % 1000), CFG_PRINTF_NEWLINE);
#endif
// Wireless Settings (if CFG_CHIBI enabled)
#ifdef CFG_CHIBI
chb_pcb_t *pcb = chb_get_pcb();
printf("%-25s : %s %s", "RF Transceiver", "AT86RF212", CFG_PRINTF_NEWLINE);
#if CFG_CHIBI_PROMISCUOUS == 1
printf("%-25s : %s %s", "RF Receive Mode", "Promiscuous", CFG_PRINTF_NEWLINE);
#else
printf("%-25s : %s %s", "RF Receive Mode", "Normal", CFG_PRINTF_NEWLINE);
#endif
printf("%-25s : 0x%04X (%d) %s", "802.15.4 PAN ID", CFG_CHIBI_PANID, CFG_CHIBI_PANID, CFG_PRINTF_NEWLINE);
printf("%-25s : 0x%04X (%d) %s", "802.15.4 Node Address", pcb->src_addr, pcb->src_addr, CFG_PRINTF_NEWLINE);
printf("%-25s : %d %s", "802.15.4 Channel", CFG_CHIBI_CHANNEL, CFG_PRINTF_NEWLINE);
#endif
// CLI and buffer Settings
#ifdef CFG_INTERFACE
printf("%-25s : %d bytes %s", "Max CLI Command", CFG_INTERFACE_MAXMSGSIZE, CFG_PRINTF_NEWLINE);
#endif
// System Uptime (based on systick timer)
printf("%-25s : %u s %s", "System Uptime", (unsigned int)systickGetSecondsActive(), CFG_PRINTF_NEWLINE);
// System Temperature (if LM75B Present)
#ifdef CFG_LM75B
int32_t temp = 0;
lm75bGetTemperature(&temp);
temp *= 125;
printf("%-25s : %d.%d C %s", "Temperature", (int)(temp / 1000), (int)(temp % 1000), CFG_PRINTF_NEWLINE);
#endif
#ifdef CFG_SDCARD
printf("%-25s : %s %s", "SD Card Present", gpioGetValue(CFG_SDCARD_CDPORT, CFG_SDCARD_CDPIN) ? "True" : "False", CFG_PRINTF_NEWLINE);
#endif
}
void main_sec(void) {
backlightInit();
//disable the JTAG on PIO3_3
IOCON_PIO3_3 = 0x10;
int yctr=8;
int dx=0;
font_direction = FONT_DIR_LTR; // LeftToRight is the default
yctr=18;
uint8_t trigger;
trigger=20;
uint32_t ctr=0;
char key;
while (1) {
ctr++;
lcdDisplay(0);
delayms(10);
key= getInput();
if(key==BTN_UP){
trigger +=1;
}else if (key ==BTN_DOWN){
trigger -=1;
};
font=&Font_7x8;
dx=DoString(0,0,"Trig:");
dx=DoInt(dx,0,trigger);
DoString(dx,0," ");
// Easy flashing
if(key==BTN_LEFT){
DoString(0,8,"Enter ISP!");
lcdDisplay(0);
ISPandReset(5);
};
// Display nickname
font = &Font_Ubuntu36pt;
dx=DoString(0,0,"Sec");
// Blink LED
if(ctr++>trigger){
ctr=0;
if (gpioGetValue(RB_LED2) == CFG_LED_OFF){
gpioSetValue (RB_LED2, CFG_LED_ON);
} else {
gpioSetValue (RB_LED2, CFG_LED_OFF);
};
};
// Print Voltage
font = &Font_7x8;
dx=DoString(0,yctr+28,"Voltage:");
DoInt(dx,yctr+28,GetVoltage());
}
return;
}
static uint8_t mainloop() {
uint32_t volatile oldCount = BusIntCtr;
uint32_t loopCount=BusIntCtr;
perMin = 0; // counts in last 60 s
uint32_t minuteTime = _timectr;
startTime = minuteTime;
uint8_t button;
//usbHIDInit();
while (1) {
LED_OFF;
if (loopCount != BusIntCtr) {
loopCount=BusIntCtr;
LED_ON;
IOCON_PIO1_11 = IOCON_PIO1_11_FUNC_GPIO;
gpioSetDir(RB_LED3,gpioDirection_Output ) ;
gpioSetValue(RB_LED3, 1);
if (!GLOBAL(positionleds) ) {
gpioSetValue(RB_LED2,1);
gpioSetValue(RB_LED0,1);
}
} else {
if (gpioGetValue(RB_PWR_CHRG) || !GLOBALchargeled) {
gpioSetDir(RB_LED3,gpioDirection_Input ); // only when not charging..
}
if (!GLOBAL(positionleds) ) {
gpioSetValue(RB_LED0,0);
gpioSetValue(RB_LED2,0);
}
}
lcdClear();
//lcdPrintln(" Geiger");
//lcdPrintln(" Counter");
memcpy(&lcdBuffer[RESX*RESY_B-sizeof(Header_Invers)],Header_Invers,sizeof(Header_Invers));
lcdPrintln("");
lcdPrintln("");
// ####
for (int i = 0; i < (14 * (_timectr - minuteTime)) / (60 * 100); i++) {
lcdPrint("#");
}
lcdPrintln("");
lcdPrint(" ");
lcdPrintInt(BusIntCtr);
lcdPrint(" in ");
lcdPrintInt((_timectr - startTime) / 100);
lcdPrintln("s");
lcdPrint(" ");
lcdPrintInt(perMin);
lcdPrintln(" cpm");
{
uint32_t equivalent = nanoSievertPerH(perMin)+5; // letzte stelle runden
lcdPrint(" ");
lcdPrintInt(equivalent / 1000);
lcdPrint(".");
lcdPrintInt((equivalent % 1000) / 100);
lcdPrintInt((equivalent % 100) / 10);
//lcdPrintInt((equivalent % 10));
lcdPrintln(" uSv/h");
}
//getGeigerMeshVal();
lcdPrintln("");
if (gpioGetValue(RB_PWR_CHRG)){
uint32_t voltage=GetVoltage();
if (voltage >= GOOD_VOLTAGE) {
lcdPrintln("Bat: [++++] ");
} else if (voltage >= HALF_VOLTAGE) {
lcdPrintln("Bat: [ooo ] ");
} else if (voltage >= MIN_SAFE_VOLTAGE) {
lcdPrintln("Bat: [== ] ");
} else if (voltage >= CRIT_VOLTAGE) {
lcdPrintln("Bat: [- ] L");
} else {
lcdPrintln("Battery: CRIT!");
}
} else {
lcdPrintln("Bat: Charging");
}
// remember: We have a 10ms Timer counter
if ((minuteTime + 60 * 100) <= _timectr) {
// dumb algo: Just use last 60 seconds count
perMin = BusIntCtr - oldCount;
minuteTime = _timectr;
oldCount = BusIntCtr;
//transmitGeigerMeshVal(perMin,minuteTime / (100));
}
lcdRefresh();
delayms_queue_plus(42, 0);
button = getInputRaw();
if (button != BTN_NONE) {
break;
}
}
//usbHidDisconnect();
return button;
}
void blink_led0(void){
gpioSetValue (RB_LED0, 1-gpioGetValue(RB_LED0));
};
inline uint32_t readLineState() {
return gpioGetValue(portNum, bitPos );
}
static void
prt(void)
{
int i, j;
printf("\r\nHello World\r\n");
gpioSetDir(1, 1, gpioDirection_Input);
for (i = 0; i < 8; i++)
gpioSetDir(2, i, gpioDirection_Input);
gpioSetDir(0, 8, gpioDirection_Output);
gpioSetDir(0, 9, gpioDirection_Output);
gpioSetDir(0, 10, gpioDirection_Output);
IOCON_JTAG_TCK_PIO0_10 = 0
| IOCON_JTAG_TDI_PIO0_11_FUNC_GPIO
| IOCON_JTAG_TDI_PIO0_11_ADMODE_DIGITAL;
IOCON_JTAG_TDI_PIO0_11 = 0
| IOCON_JTAG_TDI_PIO0_11_FUNC_GPIO
| IOCON_JTAG_TDI_PIO0_11_ADMODE_DIGITAL;
gpioSetDir(0, 11, gpioDirection_Output);
gpioSetDir(3, 0, gpioDirection_Input);
gpioSetDir(3, 1, gpioDirection_Output);
gpioSetDir(3, 2, gpioDirection_Input);
gpioSetDir(3, 3, gpioDirection_Input);
gpioSetInterrupt(1, // Port
1, // Pin
gpioInterruptSense_Edge, // Edge/Level Sensitive
gpioInterruptEdge_Single, // Single/Double Edge
gpioInterruptEvent_ActiveLow); // Rising/Falling
gpioIntEnable(1, 1);
gpioSetValue(0,11,1);
gpioSetValue(0,10,0);
gpioSetValue(0,9,0);
while (1) {
j = CDC_getchar();
switch (j) {
case 's': gpioSetValue(0,8,0); sts(); break;
case 'S': gpioSetValue(0,8,1); sts(); break;
case 'p': gpioSetValue(0,9,0); sts(); break;
case 'P': gpioSetValue(0,9,1); sts(); break;
case 'b': gpioSetValue(0,10,0); sts(); break;
case 'B': gpioSetValue(0,10,1); sts(); break;
case 'a': gpioSetValue(0,11,0); sts(); break;
case 'A': gpioSetValue(0,11,1); sts(); break;
case 'e': gpioSetValue(3,1,0); sts(); break;
case 'E': gpioSetValue(3,1,1); sts(); break;
case 'x':
while (1)
CDC_putchar('x');
break;
case '?':
sts();
break;
}
if (gpioGetValue(0, 10)) {
CDC_putchar(got_prn);
for (j = 0; j < 2; j++)
gpioSetValue(0,11,0);
gpioSetValue(0,11,1);
gpioSetValue(0,10,0);
}
}
}