ctdo
/
crashtest-r0ket
16
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'master' of github.com:r0ket/r0ket

This commit is contained in:
schneider 2011-08-02 14:00:15 +02:00
parent d1cbe5de60 665a0e0c32
commit be9356308c
75 changed files with 1948 additions and 1375 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
firmware/Makefile
View File

@ -42,6 +42,7 @@ LDLIBS += -Llcd -llcd
LDLIBS += -Lcore -lcore LDLIBS += -Lcore -lcore
LDLIBS += -Lusb -lusb LDLIBS += -Lusb -lusb
LDLIBS += -lbasic LDLIBS += -lbasic
LDLIBS += -lfunk
OCFLAGS = --strip-unneeded OCFLAGS = --strip-unneeded
SUBDIRS?= $(foreach lib,$(LIBS),$(dir $(lib))) SUBDIRS?= $(foreach lib,$(LIBS),$(dir $(lib)))

2
firmware/Makefile.inc
View File

@ -23,6 +23,8 @@ CC = $(CROSS_COMPILE)gcc
LD = $(CROSS_COMPILE)ld LD = $(CROSS_COMPILE)ld
REALLD = $(CROSS_COMPILE)ld REALLD = $(CROSS_COMPILE)ld
SIZE = $(CROSS_COMPILE)size SIZE = $(CROSS_COMPILE)size
AR = $(CROSS_COMPILE)ar
RANLIB = $(CROSS_COMPILE)ranlib
OBJCOPY = $(CROSS_COMPILE)objcopy OBJCOPY = $(CROSS_COMPILE)objcopy
OBJDUMP = $(CROSS_COMPILE)objdump OBJDUMP = $(CROSS_COMPILE)objdump
OUTFILE = firmware OUTFILE = firmware

1
firmware/Makefile.util
View File

@ -6,6 +6,7 @@ all: $(LIBFILE)
$(LIBFILE): $(OBJS) $(LIBFILE): $(OBJS)
$(AR) rcs $@ $(OBJS) $(AR) rcs $@ $(OBJS)
$(RANLIB) $(RANLIBFLAGS) $@
%.o : %.c %.o : %.c
$(CC) $(CFLAGS) -o $@ $< $(CC) $(CFLAGS) -o $@ $<

15
firmware/applications/Makefile
View File

@ -8,6 +8,10 @@ ifeq "$(APP)" "initial"
NODEFAULT = y NODEFAULT = y
endif endif
ifeq "$(APP)" "tester"
DEBUG = -d
endif
ifndef NODEFAULT ifndef NODEFAULT
OBJS += default.o OBJS += default.o
endif endif
@ -33,6 +37,7 @@ endif
WRAP=wrapper WRAP=wrapper
LIBNAME=app LIBNAME=app
########################################################################## ##########################################################################
# GNU GCC compiler flags # GNU GCC compiler flags
########################################################################## ##########################################################################
@ -66,21 +71,21 @@ $(LOBJ):
OBJS += $(LOBJ) OBJS += $(LOBJ)
endif endif
ifeq "$(APP)" "tester" ifeq "$(wildcard $(APP))" "$(APP)"
ifndef TYPE ifndef TYPE
TYPE=$(APP) TYPE=$(APP)
endif endif
TSRCS = $(wildcard $(TYPE)/*.c) TSRCS = $(foreach type,$(TYPE),$(wildcard $(type)/*.c))
TOBJS = $(foreach mod,$(TSRCS),$(subst .c,.o,$(mod))) TOBJS = $(foreach mod,$(TSRCS),$(subst .c,.o,$(mod)))
TWRAP=tester.gen TWRAP=$(APP).gen
.PHONY: $(TWRAP) .PHONY: $(TWRAP)
$(APP).o: $(TWRAP) $(APP).o: $(TWRAP)
$(TWRAP): $(TWRAP):
./mktester $(TSRCS) > $@ ./mkfirmware.pl $(DEBUG) $(APP) $(TSRCS) > $@
OBJS += $(TOBJS) OBJS += $(TOBJS)
endif endif
@ -93,7 +98,7 @@ $(LIBFILE): $(OBJS) $(WRAPOBJ)
$(CC) $(CFLAGS) -o $@ $< $(CC) $(CFLAGS) -o $@ $<
clean: clean:
rm -f $(OBJS) $(WRAPOBJ) $(WRAPSRC) $(LIBFILE) *.o */*.o rm -f $(OBJS) $(WRAPOBJ) $(WRAPSRC) $(LIBFILE) *.o */*.o *.gen
%.c: %.c:
@echo @echo

3
firmware/applications/adc.c
View File

@ -15,9 +15,6 @@ void main_adc(void) {
uint32_t brightness = 0; uint32_t brightness = 0;
uint8_t c = 0; uint8_t c = 0;
font_direction = FONT_DIR_LTR; // LeftToRight is the default
font = &Font_7x8;
DoString(0, 0, "adc"); DoString(0, 0, "adc");
backlightInit(); backlightInit();

62
firmware/applications/default.c
View File

@ -1,10 +1,12 @@
#include <sysinit.h> #include <sysinit.h>
#include "basic/basic.h" #include "basic/basic.h"
#include "basic/config.h"
#include "lcd/lcd.h" #include "lcd/lcd.h"
#include "lcd/fonts/smallfonts.h" #include "lcd/fonts/smallfonts.h"
#include "lcd/print.h" #include "lcd/print.h"
#include "filesystem/ff.h" #include "filesystem/ff.h"
#include "usb/usbmsc.h"
#include "basic/random.h" #include "basic/random.h"
/**************************************************************************/ /**************************************************************************/
@ -12,51 +14,66 @@
void main_default(void) { void main_default(void) {
systickInit(SYSTICKSPEED); systickInit(SYSTICKSPEED);
if(getInputRaw()==BTN_ENTER){ switch(getInputRaw()){
ISPandReset(); case BTN_ENTER:
ISPandReset();
break;
case BTN_DOWN:
usbMSCInit();
while(1)
delayms_power(100);
break;
}; };
readConfig(); readConfig();
applyConfig();
randomInit(); randomInit();
return; return;
}; };
void queue_setinvert(void){
lcdSetInvert(1);
};
void queue_unsetinvert(void){
lcdSetInvert(0);
};
#define EVERY(x,y) if((ctr+y)%(x/SYSTICKSPEED)==0)
// every 10 ms // every 10 ms
void tick_default(void) { void tick_default(void) {
static int ctr; static int ctr;
ctr++; ctr++;
incTimer(); incTimer();
if(ctr>1000/SYSTICKSPEED){
EVERY(1000,0){
if(!adcMutex){ if(!adcMutex){
VoltageCheck(); VoltageCheck();
LightCheck(); LightCheck();
ctr=0;
}else{ }else{
ctr--; ctr--;
}; };
}; };
if(ctr>100/SYSTICKSPEED){ static char night=0;
if(isNight()){ EVERY(100,2){
backlightSetBrightness(GLOBAL(lcdbacklight)); if(night!=isNight()){
if(GLOBAL(nightinvert)) night=isNight();
lcdSetInvert(0); if(night){
} else { backlightSetBrightness(GLOBAL(lcdbacklight));
backlightSetBrightness(0); push_queue(queue_unsetinvert);
if(GLOBAL(nightinvert)) }else{
lcdSetInvert(1); backlightSetBrightness(0);
} push_queue(queue_setinvert);
} };
};
};
if(ctr%(50/SYSTICKSPEED)==0){
if(GetVoltage()<3600 EVERY(50,0){
#ifdef SAFE if(GetVoltage()<3600){
|| GetVoltage() > 10000 // pin not connected
#endif
){
IOCON_PIO1_11 = 0x0; IOCON_PIO1_11 = 0x0;
gpioSetDir(RB_LED3, gpioDirection_Output); gpioSetDir(RB_LED3, gpioDirection_Output);
if( (ctr/(50/SYSTICKSPEED))%10 == 1 ) if( (ctr/(50/SYSTICKSPEED))%10 == 1 )
@ -65,6 +82,5 @@ void tick_default(void) {
gpioSetValue (RB_LED3, 0); gpioSetValue (RB_LED3, 0);
}; };
}; };
return; return;
}; };

26
firmware/applications/exe.c
View File

@ -52,24 +52,16 @@ void adc_check(void) {
/**************************************************************************/ /**************************************************************************/
const struct MENU_DEF menu_ISP = {"Invoke ISP", &gotoISP}; static const struct MENU mainmenu = {"Mainmenu", {
const struct MENU_DEF menu_mirror = {"Mirror", &lcd_mirror}; {"MSC", &msc_menu},
const struct MENU_DEF menu_volt = {"Akku", &adc_check}; {"Exec", &execute_menu},
const struct MENU_DEF menu_nop = {"---", NULL}; {"---", NULL},
const struct MENU_DEF menu_msc = {"MSC", &msc_menu}; {"Mirror", &lcd_mirror},
const struct MENU_DEF menu_exe = {"Exec", &execute_menu}; {"Akku", &adc_check},
{"Invoke ISP", &gotoISP},
{NULL,NULL}
}};
static menuentry menu[] = {
&menu_msc,
&menu_exe,
&menu_nop,
&menu_mirror,
&menu_volt,
&menu_ISP,
NULL,
};
static const struct MENU mainmenu = {"Mainmenu", menu};
void main_exe(void) { void main_exe(void) {

181
firmware/applications/executor.c
View File

@ -1,181 +0,0 @@
#include <sysinit.h>
#include "basic/basic.h"
#include "lcd/render.h"
#include "lcd/allfonts.h"
void backlightInit(void);
extern void * __sram_top;
void execute (const void *function, uint16_t length){
void (*dst)(void);
dst=(void (*)(void)) (__sram_top);
DoString(0,8,"Enter RAM!");
DoIntX(0,16,(uint32_t)function);
DoIntX(0,24,(uint32_t)dst);
lcdDisplay();
for(int i=0;i<length;i++){
((char*)dst)[i]=((char*)function)[i];
};
dst=(void (*)(void)) ((uint32_t)(dst) | 1); // Enable Thumb mode!
dst();
};
#include "filesystem/ff.h"
void put_rc_y (FRESULT rc, int y) {
const TCHAR *p =
_T("OK\0DISK_ERR\0INT_ERR\0NOT_READY\0NO_FILE\0NO_PATH\0INVALID_NAME\0")
_T("DENIED\0EXIST\0INVALID_OBJECT\0WRITE_PROTECTED\0INVALID_DRIVE\0")
_T("NOT_ENABLED\0NO_FILE_SYSTEM\0MKFS_ABORTED\0TIMEOUT\0LOCKED\0")
_T("NOT_ENOUGH_CORE\0TOO_MANY_OPEN_FILES\0");
FRESULT i;
for (i = 0; i != rc && *p; i++) {
while(*p++) ;
}
DoString(0,y,p);
}
void put_rc (FRESULT rc){
put_rc_y(rc,0);
};
void execute_file (const char * fname){
FRESULT res;
FIL file;
UINT readbytes;
void (*dst)(void);
dst=(void (*)(void)) 0x10001800;
res=f_open(&file, fname, FA_OPEN_EXISTING|FA_READ);
put_rc(res);
if(res){
return;
};
res = f_read(&file, (char *)dst, RAMCODE, &readbytes);
put_rc_y(res,8);
if(res){
return;
};
int dx;
dx=DoString(0,16,"read: ");
DoInt(dx,16,readbytes);
lcdDisplay();
dst=(void (*)(void)) ((uint32_t)(dst) | 1); // Enable Thumb mode!
dst();
getInput();
};
/**************************************************************************/
void main_executor(void) {
lcdSetPixel(0,0,0); //the spaceinvader module needs this
backlightInit();
//disable the JTAG on PIO3_3
IOCON_PIO3_3 = 0x10;
int yctr=8;
int dx=0;
yctr=18;
uint8_t trigger;
trigger=20;
uint32_t ctr=0;
char key;
while (1) {
ctr++;
lcdDisplay();
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();
ISPandReset();
};
// DF xecute
if(key==BTN_RIGHT){
DoString(0,0,"Enter RAM!");
lcdDisplay();
while(getInput()!=BTN_NONE);
FATFS FatFs; /* File system object for logical drive */
put_rc(f_mount(0, &FatFs));
execute_file("0:test.c0d");
lcdDisplay();
while(!getInput());
};
if(key==BTN_UP){
#if CFG_USBMSC
usbMSCInit();
#endif
};
// 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;
}
void tick_executor(void){
static int foo=0;
static int toggle=0;
if(foo++>50){
toggle=1-toggle;
foo=0;
gpioSetValue (RB_LED0, toggle);
};
return;
};

35
firmware/applications/final.c Normal file
View File

@ -0,0 +1,35 @@
#include <sysinit.h>
#include "basic/basic.h"
#include "lcd/print.h"
#include <string.h>
/**************************************************************************/
#include "final.gen"
void init_nick();
void fancyNickname();
void main_final(void) {
//checkFirstBoot();
init_final();
while(1){
#ifndef FINAL
if(getInputRaw()==BTN_LEFT)
ISPandReset();
#endif
if(getInput()){
handleMenu(&mainmenu);
getInputWaitRelease();
init_nick();
};
fancyNickname();
delayms_queue(100);
};
};
void tick_final(void);

127
firmware/applications/final/config.c Normal file
View File

@ -0,0 +1,127 @@
#include <sysinit.h>
#include "basic/basic.h"
#include "basic/config.h"
#include "lcd/print.h"
#include "lcd/render.h"
#include "lcd/display.h"
#include "filesystem/ff.h"
#include <string.h>
/**************************************************************************/
void readcfg(void) {
readConfig();
};
void savecfg(void){
saveConfig();
};
void applycfg(void){
applyConfig();
};
//# MENU config
void changer(void){
uint8_t numentries = 0;
signed char menuselection = 0;
uint8_t visible_lines = 0;
uint8_t current_offset = 0;
for (int i=0;the_config[i].name!=NULL;i++){
numentries++;
};
visible_lines = ((RESY/getFontHeight())-1)/2;
while (1) {
// Display current menu page
lcdClear();
lcdPrint("Config");
lcdSetCrsrX(60);
lcdPrint("[");
lcdPrint(IntToStr(current_offset/visible_lines,1,0));
lcdPrint("/");
lcdPrint(IntToStr(numentries/visible_lines,1,0));
lcdPrint("]");
lcdNl();
lcdNl();
for (uint8_t i = current_offset; i < (visible_lines + current_offset) && i < numentries; i++) {
if(i==0){
lcdPrintln("Save changes:");
if (i == menuselection)
lcdPrint("*");
lcdSetCrsrX(14);
if (i == menuselection)
lcdPrintln("YES");
else
lcdPrintln("no");
}else{
lcdPrintln(the_config[i].name);
if (i == menuselection)
lcdPrint("*");
lcdSetCrsrX(14);
lcdPrint("<");
lcdPrint(IntToStr(the_config[i].value,3,F_LONG));
lcdPrintln(">");
};
}
lcdRefresh();
switch (getInputWait()) {
case BTN_UP:
menuselection--;
if (menuselection < current_offset) {
if (menuselection < 0) {
menuselection = numentries-1;
current_offset = ((numentries-1)/visible_lines) * visible_lines;
} else {
current_offset -= visible_lines;
}
}
break;
case BTN_DOWN:
menuselection++;
if (menuselection > (current_offset + visible_lines-1) || menuselection >= numentries) {
if (menuselection >= numentries) {
menuselection = 0;
current_offset = 0;
} else {
current_offset += visible_lines;
}
}
break;
case BTN_LEFT:
if(the_config[menuselection].value >
the_config[menuselection].min)
the_config[menuselection].value--;
if(the_config[menuselection].value > the_config[menuselection].max)
the_config[menuselection].value=
the_config[menuselection].max;
applyConfig();
break;
case BTN_RIGHT:
if(the_config[menuselection].value <
the_config[menuselection].max)
the_config[menuselection].value++;
if(the_config[menuselection].value < the_config[menuselection].min)
the_config[menuselection].value=
the_config[menuselection].min;
applyConfig();
break;
case BTN_ENTER:
if(menuselection==0)
saveConfig();
return;
}
getInputWaitRelease();
}
/* NOTREACHED */
}

21
firmware/applications/final/exe.c Normal file
View File

@ -0,0 +1,21 @@
#include <sysinit.h>
#include <string.h>
#include "basic/basic.h"
#include "lcd/lcd.h"
#include "lcd/allfonts.h"
#include "lcd/print.h"
#include "usb/usbmsc.h"
#include "filesystem/ff.h"
#include "filesystem/select.h"
#include "filesystem/execute.h"
/**************************************************************************/
//# MENU execute
void execute_menu(void){
while(getInput()!=BTN_NONE);
executeSelect("C0D");
lcdRefresh();
};

174
firmware/applications/final/flame.c Normal file
View File

@ -0,0 +1,174 @@
/*
flame m0dul - https://github.com/kiu/flame
*/
#include "basic/basic.h"
#include "core/i2c/i2c.h"
#include "basic/config.h"
#define FLAME_I2C_WRITE 0xC4
#define FLAME_I2C_READ 0xC5
#define FLAME_I2C_CR_INPUT 0x00
#define FLAME_I2C_CR_PSC0 0x01
#define FLAME_I2C_CR_PWM0 0x02
#define FLAME_I2C_CR_PSC1 0x03
#define FLAME_I2C_CR_PWM1 0x04
#define FLAME_I2C_CR_LS0 0x05
#define FLAME_I2C_LS0_OFF 0x00
#define FLAME_I2C_LS0_ON 0x01
#define FLAME_I2C_LS0_PWM0 0x02
#define FLAME_I2C_LS0_PWM1 0x03
#define FLAME_I2C_LS0_LED0 0x00
#define FLAME_I2C_LS0_LED1 0x02
#define FLAME_I2C_LS0_LED2 0x04
#define FLAME_I2C_LS0_LED3 0x06
#define FLAME_OFF 0x00
#define FLAME_UP 0x01
#define FLAME_UP_WAIT 0x02
#define FLAME_DOWN 0x03
#define FLAME_DOWN_WAIT 0x04
/**************************************************************************/
#define flameBrightnessMax GLOBAL(flamemax)
#define flameBrightnessMin GLOBAL(flamemin)
#define flameSpeedUp GLOBAL(flamespeed)
#define flameSpeedDown GLOBAL(flamespeed)
#define flameWaitUp GLOBAL(flamemaxw)
#define flameWaitDown GLOBAL(flameminw)
uint8_t flameEnabled = 0;
uint8_t flameMode = FLAME_OFF;
uint8_t flameI2Cpwm = 0;
uint8_t flameTicks = 0;
uint32_t flameSetI2C(uint8_t cr, uint8_t value) {
I2CMasterBuffer[0] = FLAME_I2C_WRITE;
I2CMasterBuffer[1] = cr;
I2CMasterBuffer[2] = value;
I2CWriteLength = 3;
I2CReadLength = 0;
return i2cEngine();
}
void setFlamePWM() {
flameSetI2C(FLAME_I2C_CR_PWM0, flameI2Cpwm); // set pwm
}
void tick_flame(void) { // every 10ms
static char night=0;
if(!flameEnabled)
return;
if(night!=isNight()){
night=isNight();
if(!night){
flameMode = FLAME_OFF;
flameI2Cpwm = 0;
push_queue(&setFlamePWM);
};
};
flameTicks++;
if (flameI2Cpwm > flameBrightnessMax) {
flameI2Cpwm = flameBrightnessMax;
}
if (flameI2Cpwm < flameBrightnessMin) {
flameI2Cpwm = flameBrightnessMin;
}
if (flameMode == FLAME_OFF) {
if (isNight() && flameEnabled) {
flameTicks = 0;
flameMode = FLAME_UP;
}
}
if (flameMode == FLAME_UP) {
if (flameI2Cpwm + flameSpeedUp > flameI2Cpwm ) {
flameI2Cpwm += flameSpeedUp;
} else {
flameI2Cpwm = 0xFF;
}
push_queue(&setFlamePWM);
if (flameI2Cpwm == flameBrightnessMax) {
flameMode = FLAME_UP_WAIT;
flameTicks = 0;
}
}
if (flameMode == FLAME_UP_WAIT) {
if (flameTicks >= flameWaitUp) {
flameMode = FLAME_DOWN;
}
}
if (flameMode == FLAME_DOWN) {
if (flameI2Cpwm - flameSpeedDown < flameI2Cpwm ) {
flameI2Cpwm -= flameSpeedDown;
} else {
flameI2Cpwm = 0x00;
}
push_queue(&setFlamePWM);
if (flameI2Cpwm == flameBrightnessMin) {
flameMode = FLAME_DOWN_WAIT;
flameTicks = 0;
}
}
if (flameMode == FLAME_DOWN_WAIT) {
if (flameTicks >= flameWaitDown) {
flameMode = FLAME_OFF;
}
}
}
//# MENU flame
void flameInit(void) {
i2cInit(I2CMASTER); // Init I2C
flameEnabled = (flameSetI2C(FLAME_I2C_CR_LS0, FLAME_I2C_LS0_OFF << FLAME_I2C_LS0_LED0) == I2CSTATE_ACK); // probe i2c
if (flameEnabled) {
flameSetI2C(FLAME_I2C_CR_LS0, FLAME_I2C_LS0_OFF << FLAME_I2C_LS0_LED0); // set led0 off
flameSetI2C(FLAME_I2C_CR_LS0, FLAME_I2C_LS0_OFF << FLAME_I2C_LS0_LED1); // set led1 off
flameSetI2C(FLAME_I2C_CR_LS0, FLAME_I2C_LS0_OFF << FLAME_I2C_LS0_LED2); // set led2 off
flameSetI2C(FLAME_I2C_CR_LS0, FLAME_I2C_LS0_OFF << FLAME_I2C_LS0_LED3); // set led3 off
flameSetI2C(FLAME_I2C_CR_PSC0, 0x00); // set prescaler
flameSetI2C(FLAME_I2C_CR_PWM0, 0x00); // set pwm
flameSetI2C(FLAME_I2C_CR_LS0, FLAME_I2C_LS0_PWM0 << FLAME_I2C_LS0_LED0); // set led0 to pwm
}
}
#include "lcd/print.h"
//# MENU debug ChkFlame
void ChkFlame(void) {
do{
lcdClear();
lcdPrint("Enabled:");
lcdPrintln(IntToStr(flameEnabled,1,0));
lcdPrint("State:");
lcdPrintln(IntToStr(flameMode,1,0));
lcdPrint("PWMtarg:");
lcdPrintln(IntToStr(flameI2Cpwm,3,0));
lcdPrint("FTicks:");
lcdPrintln(IntToStr(flameTicks,3,0));
lcdRefresh();
delayms_queue(10);
} while ((getInputRaw())==BTN_NONE);
}

277
firmware/applications/final/mesh.c Normal file
View File

@ -0,0 +1,277 @@
#include <sysinit.h>
#include <string.h>
#include <time.h>
#include "basic/basic.h"
#include "basic/byteorder.h"
#include "lcd/lcd.h"
#include "lcd/print.h"
#include "funk/nrf24l01p.h"
#include "funk/mesh.h"
#include <string.h>
/**************************************************************************/
void init_mesh(void){
nrf_init();
initMesh();
};
void m_tset(void){
_timet=1311961112;
};
//# MENU debug MeshInfo
void m_time(void){
struct tm* tm;
char c[2]={0,0};
getInputWaitRelease();
delayms(100);
do{
lcdClear();
tm= mygmtime(getSeconds());
lcdPrint(IntToStr(tm->tm_hour,2,F_LONG));
lcdPrint(":");
lcdPrint(IntToStr(tm->tm_min,2,F_LONG|F_ZEROS));
lcdPrint(":");
lcdPrint(IntToStr(tm->tm_sec,2,F_LONG|F_ZEROS));
lcdNl();
lcdPrint(IntToStr(tm->tm_mday,2,F_LONG));
lcdPrint(".");
lcdPrint(IntToStr(tm->tm_mon+1,2,0));
lcdPrint(".");
lcdPrint(IntToStr(tm->tm_year+YEAR0,4,F_LONG|F_ZEROS));
lcdNl();
lcdNl();
lcdPrint("<");
for(int i=0;i<MESHBUFSIZE;i++){
if(!meshbuffer[i].flags&MF_USED){
c[0]='_';
}else{
c[0]=meshbuffer[i].pkt[0];
};
lcdPrint(c);
};
lcdPrintln(">");
lcdPrint("Gen:");
lcdPrintInt(meshgen);
lcdNl();
lcdRefresh();
delayms_queue(50);
}while ((getInputRaw())==BTN_NONE);
};
inline void blink(char a, char b){
gpioSetValue (a,b, 1-gpioGetValue(a,b));
};
int choose(char * texts, int8_t menuselection){
uint8_t numentries = 0;
uint8_t visible_lines = 0;
uint8_t current_offset = 0;
char*p=texts;
do{
lcdPrintln(p);
while(*p)p++;
numentries++;p++;
}while(*p);
numentries--;
visible_lines = (RESY/getFontHeight())-1; // subtract title line
while (1) {
// Display current menu page
lcdClear();
lcdPrintln(texts);
p=texts;
while(*p++);
for(int i=0;i<current_offset;i++)
while(*p++);
for (uint8_t i = current_offset; i < (visible_lines + current_offset) && i < numentries; i++) {
if (i == menuselection)
lcdPrint("*");
lcdSetCrsrX(14);
lcdPrintln(p);
while(*p++);
}
lcdRefresh();
switch (getInputWait()) {
case BTN_UP:
menuselection--;
if (menuselection < current_offset) {
if (menuselection < 0) {
menuselection = numentries-1;
current_offset = ((numentries-1)/visible_lines) * visible_lines;
} else {
current_offset -= visible_lines;
}
}
break;
case BTN_DOWN:
menuselection++;
if (menuselection > (current_offset + visible_lines-1) || menuselection >= numentries) {
if (menuselection >= numentries) {
menuselection = 0;
current_offset = 0;
} else {
current_offset += visible_lines;
}
}
break;
case BTN_LEFT:
return -1;
case BTN_RIGHT:
case BTN_ENTER:
return menuselection;
}
getInputWaitRelease();
}
/* NOTREACHED */
}
/***********************************************************************/
char *meshmsgs(void){
static char msgtypes[MESHBUFSIZE+1];
memset(msgtypes,'_',MESHBUFSIZE);
msgtypes[MESHBUFSIZE]=0;
uint8_t lo=0;
uint8_t hi;
for(int o=0;o<MESHBUFSIZE;o++){
hi=0xff;
for(int i=0;i<MESHBUFSIZE;i++){
if(meshbuffer[i].flags&MF_USED){
if(MO_TYPE(meshbuffer[i].pkt)>lo)
if(MO_TYPE(meshbuffer[i].pkt)<hi)
hi=MO_TYPE(meshbuffer[i].pkt);
};
};
if(hi==0xff){
msgtypes[o]=0;
break;
};
msgtypes[o]=hi;
lo=hi;
};
return msgtypes;
};
extern MPKT meshbuffer[MESHBUFSIZE];
//# MENU mesh Messages
void m_choose(){
char list[99];
int i=0;
while(1){
char *p=list;
strcpy(p,"Note");
while(*p++);
char *mm=meshmsgs();
char *tmm=mm;
while(*mm){
switch(*mm){
case('A'):
strcpy(p,"Message");
break;
case('E'):
strcpy(p,"Kourou");
break;
case('F'):
strcpy(p,"Baikonur");
break;
case('T'):
strcpy(p,"Time");
break;
case('i'):
strcpy(p,"Invaders");
break;
default:
p[0]=*mm;
p[1]=0;
};
while(*p++);
mm++;
};
p[0]=0;
i=choose(list,i);
if(i<0)
return;
lcdClear();
int j=0;
for(int z=0;z<MESHBUFSIZE;z++)
if(meshbuffer[z].flags&MF_USED)
if(MO_TYPE(meshbuffer[z].pkt)==tmm[i])
j=z;
switch(tmm[i]){
case('A'):
lcdPrintln("Message");
break;
case('E'):
lcdPrintln("Kourou");
break;
case('F'):
lcdPrintln("Baikonur");
break;
case('T'):
lcdPrintln("Time");
break;
case('i'):
lcdPrintln("Invaders");
break;
};
if(tmm[i]>='a' && tmm[i]<='z'){
lcdPrintln(IntToStr(MO_TIME(meshbuffer[j].pkt),10,0));
}else{
struct tm *tm= mygmtime(MO_TIME(meshbuffer[j].pkt));
lcdPrint(IntToStr(tm->tm_hour,2,F_LONG));
lcdPrint(":");
lcdPrint(IntToStr(tm->tm_min,2,F_LONG|F_ZEROS));
lcdPrint(":");
lcdPrint(IntToStr(tm->tm_sec,2,F_LONG|F_ZEROS));
lcdNl();
};
char *foo=(char *)MO_BODY(meshbuffer[j].pkt);
while(strlen(foo)>13){
int q;
for(q=0;q<13;q++){
if(foo[q]==' ')
break;
};
foo[q]=0;
lcdPrintln(foo);
foo[q]=' ';
foo+=q+1;
};
lcdPrintln(foo);
lcdRefresh();
getInputWaitRelease();
};
};
void tick_mesh(void){
mesh_systick();
};

64
firmware/applications/final/nickname.c Normal file
View File

@ -0,0 +1,64 @@
#include <sysinit.h>
#include <string.h>
#include <time.h>
#include "basic/basic.h"
#include "basic/byteorder.h"
#include "basic/config.h"
#include "lcd/lcd.h"
#include "lcd/print.h"
#include "filesystem/ff.h"
#include "filesystem/select.h"
#include <string.h>
/**************************************************************************/
void fancyNickname(void) {
int dx=0;
int dy=0;
static uint32_t ctr=0;
ctr++;
lcdClear();
setExtFont(GLOBAL(nickfont));
DoString(dx,dy,GLOBAL(nickname));
lcdRefresh();
return;
}
/**************************************************************************/
void init_nick(void){
readFile("nick.cfg",GLOBAL(nickname),MAXNICK);
// readFile("font.cfg",GLOBAL(nickfont),FILENAMELEN);
};
//# MENU nick editNick
void doNick(void){
input("Nickname:", GLOBAL(nickname), 32, 127, MAXNICK-1);
writeFile("nick.cfg",GLOBAL(nickname),strlen(GLOBAL(nickname)));
getInputWait();
};
//# MENU nick changeFont
void doFont(void){
getInputWaitRelease();
if( selectFile(GLOBAL(nickfont),"F0N") != 0){
lcdPrintln("No file selected.");
return;
};
lcdClear();
lcdPrintln(GLOBAL(nickfont));
setExtFont(GLOBAL(nickfont));
lcdPrintln("PUabc€");
setIntFont(&Font_7x8);
lcdPrintln("done.");
lcdDisplay();
while(!getInputRaw())delayms(10);
};

139
firmware/applications/final/util.c Normal file
View File

@ -0,0 +1,139 @@
#include <sysinit.h>
#include <string.h>
#include "basic/basic.h"
#include "basic/config.h"
#include "lcd/render.h"
#include "lcd/print.h"
#include "usb/usbmsc.h"
#include "core/iap/iap.h"
/**************************************************************************/
//# MENU debug ChkLight
void ChkLight(void) {
int dx=0;
int dy=8;
dx=DoString(0,dy,"Light:");
DoString(0,dy+16,"Night:");
while ((getInputRaw())==BTN_NONE){
DoInt(dx,dy,GetLight());
DoInt(dx,dy+16,isNight());
DoInt(dx,dy+8,GLOBAL(daytrig));
lcdDisplay();
delayms_queue(100);
};
dx=DoString(0,dy+24,"Done.");
}
//# MENU debug ChkBattery
void ChkBattery(void) {
do{
lcdClear();
lcdPrintln("Voltage:");
lcdPrintln(IntToStr(GetVoltage(),5,0));
lcdNl();
lcdPrintln("Chrg_stat:");
if(gpioGetValue(RB_PWR_CHRG)){
lcdPrintln("1");
}else{
lcdPrintln("0");
};
lcdRefresh();
// delayms_queue(100);
} while ((getInputRaw())==BTN_NONE);
}
//# MENU debug Uptime
void uptime(void) {
int t;
int h;
char flag;
while ((getInputRaw())==BTN_NONE){
lcdClear();
lcdPrintln("Uptime:");
t=getTimer()/(1000/SYSTICKSPEED);
h=t/60/60;
flag=F_ZEROS;
if(h>0){
lcdPrint(IntToStr(h,2,flag));
lcdPrint("h");
flag|=F_LONG;
};
h=t/60%60;
if(h>0){
lcdPrint(IntToStr(h,2,flag));
lcdPrint("m");
flag|=F_LONG;
};
h=t%60;
if(h>0){
lcdPrint(IntToStr(h,2,flag));
lcdPrint("s");
};
lcdNl();
lcdNl();
lcdPrintln("Ticks:");
lcdPrint(IntToStr(_timectr,10,0));
lcdRefresh();
delayms_queue(200);
};
lcdPrintln("done.");
}
//# MENU debug Uuid
void uuid(void) {
IAP_return_t iap_return;
iap_return = iapReadSerialNumber();
lcdClear();
lcdPrintln("UUID:");
lcdPrintIntHex(iap_return.Result[0]); lcdNl();
lcdPrintIntHex(iap_return.Result[1]); lcdNl();
lcdPrintIntHex(iap_return.Result[2]); lcdNl();
lcdPrintIntHex(iap_return.Result[3]); lcdNl();
lcdNl();
lcdPrintln("Beacon ID:");
lcdPrintln(IntToStrX(GetUUID32(),4));
lcdRefresh();
}
//# MENU debug Qstatus
void Qstatus(void) {
int dx=0;
int dy=8;
lcdClear();
dx=DoString(0,dy+16,"Qdepth:");
while ((getInputRaw())!=BTN_ENTER){
DoInt(dx,dy+16,(the_queue.qend-the_queue.qstart+MAXQENTRIES)%MAXQENTRIES);
lcdDisplay();
if(getInputRaw()!=BTN_NONE)
work_queue();
else
delayms(10);
};
dy+=16;
dx=DoString(0,dy,"Done.");
};
void blink_led0(void){
gpioSetValue (RB_LED0, 1-gpioGetValue(RB_LED0));
};
void tick_alive(void){
static int foo=0;
if(GLOBAL(alivechk)==0)
return;
if(foo++>500/SYSTICKSPEED){
foo=0;
if(GLOBAL(alivechk)==2)
push_queue(blink_led0);
else
blink_led0();
};
return;
};

40
firmware/applications/flame.c
View File

@ -37,10 +37,20 @@ void ReinvokeISP(void);
/**************************************************************************/ /**************************************************************************/
//TODO SEC move to config
uint8_t flameBrightnessMax = 0xff;
uint8_t flameBrightnessMin = 0x00;
uint8_t flameSpeedUp = 0x01;
uint8_t flameSpeedDown = 0x01;
uint8_t flameWaitUp = 0xff;
uint8_t flameWaitDown = 0x8f;
//TODO SEC move to config
uint8_t flameEnabled = 0; uint8_t flameEnabled = 0;
uint8_t flameMode = FLAME_OFF; uint8_t flameMode = FLAME_OFF;
uint8_t flameI2Cpwm = 0; uint8_t flameI2Cpwm = 0;
uint16_t flameTicks = 0; uint8_t flameTicks = 0;
uint32_t flameSetI2C(uint8_t cr, uint8_t value) { uint32_t flameSetI2C(uint8_t cr, uint8_t value) {
I2CMasterBuffer[0] = FLAME_I2C_WRITE; I2CMasterBuffer[0] = FLAME_I2C_WRITE;
@ -55,9 +65,17 @@ void setFlamePWM() {
flameSetI2C(FLAME_I2C_CR_PWM0, flameI2Cpwm); // set pwm flameSetI2C(FLAME_I2C_CR_PWM0, flameI2Cpwm); // set pwm
} }
void tick_flame(void) { // every 10ms void tick_flame(void) { // every 10ms
flameTicks++; flameTicks++;
if (flameI2Cpwm > flameBrightnessMax) {
flameI2Cpwm = flameBrightnessMax;
}
if (flameI2Cpwm < flameBrightnessMin) {
flameI2Cpwm = flameBrightnessMin;
}
if (flameMode == FLAME_OFF) { if (flameMode == FLAME_OFF) {
if (isNight() && flameEnabled) { if (isNight() && flameEnabled) {
flameTicks = 0; flameTicks = 0;
@ -66,31 +84,39 @@ void tick_flame(void) { // every 10ms
} }
if (flameMode == FLAME_UP) { if (flameMode == FLAME_UP) {
flameI2Cpwm++; if (flameI2Cpwm + flameSpeedUp > flameI2Cpwm ) {
flameI2Cpwm += flameSpeedUp;
} else {
flameI2Cpwm = 0xFF;
}
push_queue(&setFlamePWM); push_queue(&setFlamePWM);
if (flameI2Cpwm == 0xFF) { if (flameI2Cpwm == flameBrightnessMax) {
flameMode = FLAME_UP_WAIT; flameMode = FLAME_UP_WAIT;
flameTicks = 0; flameTicks = 0;
} }
} }
if (flameMode == FLAME_UP_WAIT) { if (flameMode == FLAME_UP_WAIT) {
if (flameTicks > 0xFF) { if (flameTicks >= flameWaitUp) {
flameMode = FLAME_DOWN; flameMode = FLAME_DOWN;
} }
} }
if (flameMode == FLAME_DOWN) { if (flameMode == FLAME_DOWN) {
flameI2Cpwm--; if (flameI2Cpwm - flameSpeedDown < flameI2Cpwm ) {
flameI2Cpwm -= flameSpeedDown;
} else {
flameI2Cpwm = 0x00;
}
push_queue(&setFlamePWM); push_queue(&setFlamePWM);
if (flameI2Cpwm == 0x00) { if (flameI2Cpwm == flameBrightnessMin) {
flameMode = FLAME_DOWN_WAIT; flameMode = FLAME_DOWN_WAIT;
flameTicks = 0; flameTicks = 0;
} }
} }
if (flameMode == FLAME_DOWN_WAIT) { if (flameMode == FLAME_DOWN_WAIT) {
if (flameTicks > 0x8F) { if (flameTicks >= flameWaitDown) {
flameMode = FLAME_OFF; flameMode = FLAME_OFF;
} }
} }

51
firmware/applications/font.c
View File

@ -27,18 +27,6 @@ void f_init(void){
UINT readbytes; UINT readbytes;
int res; int res;
nrf_init();
struct NRF_CFG config = {
.channel= 81,
.txmac= "REMOT",
.nrmacs=1,
.mac0= "REMOT",
.maclen ="\x10",
};
nrf_config_set(&config);
res=f_open(&file[0], "nick.cfg", FA_OPEN_EXISTING|FA_READ); res=f_open(&file[0], "nick.cfg", FA_OPEN_EXISTING|FA_READ);
lcdPrint("open:"); lcdPrint("open:");
lcdPrintln(f_get_rc_string(res)); lcdPrintln(f_get_rc_string(res));
@ -79,7 +67,6 @@ void f_init(void){
char fontname[15]; char fontname[15];
void f_nick(void){ void f_nick(void){
static char ctr=0;
char key; char key;
static signed char x=10; static signed char x=10;
static signed char y=10; static signed char y=10;
@ -97,6 +84,7 @@ void f_nick(void){
lcdPrint("x"); lcdPrint("x");
lcdPrintInt(y); lcdPrintInt(y);
lcdDisplay(); lcdDisplay();
delayms(40); delayms(40);
@ -117,7 +105,6 @@ void f_nick(void){
lcdClear(); lcdClear();
lcdPrintln("Done."); lcdPrintln("Done.");
lcdDisplay(); lcdDisplay();
ctr++;
break; break;
}; };
}; };
@ -180,31 +167,19 @@ void msc_menu(void){
/**************************************************************************/ /**************************************************************************/
const struct MENU_DEF menu_ISP = {"Invoke ISP", &gotoISP};
const struct MENU_DEF menu_init = {"F Init", &f_init};
const struct MENU_DEF menu_nick = {"F Nick", &f_nick};
const struct MENU_DEF menu_font = {"F sel", &f_font};
const struct MENU_DEF menu_mirror = {"Mirror", &lcd_mirror};
const struct MENU_DEF menu_invert = {"Invert", &lcd_invert};
const struct MENU_DEF menu_volt = {"Akku", &adc_check};
const struct MENU_DEF menu_msc = {"MSC", &msc_menu};
const struct MENU_DEF menu_nop = {"---", NULL};
static menuentry menu[] = { static const struct MENU mainmenu = {"Mainmenu", {
&menu_init, {"Invoke ISP", &gotoISP},
&menu_nick, {"F Init", &f_init},
&menu_font, {"F Nick", &f_nick},
&menu_nop, {"F sel", &f_font},
&menu_mirror, {"Mirror", &lcd_mirror},
&menu_invert, {"Invert", &lcd_invert},
&menu_volt, {"Akku", &adc_check},
&menu_msc, {"MSC", &msc_menu},
&menu_nop, {"---", NULL},
&menu_ISP, {NULL,NULL}
NULL, }};
};
static const struct MENU mainmenu = {"Mainmenu", menu};
void main_font(void) { void main_font(void) {

49
firmware/applications/fs.c
View File

@ -25,42 +25,25 @@ void fs_mount(void);
/**************************************************************************/ /**************************************************************************/
const struct MENU_DEF menu_incBL = {"Backlight++", &incBacklight}; static const struct MENU mainmenu = {"Mainmenu", {
const struct MENU_DEF menu_decBL = {"Backlight--", &decBacklight}; {"FS Mount", &fs_mount},
const struct MENU_DEF menu_ISP = {"Invoke ISP", &gotoISP}; {"FS Status", &fs_status},
const struct MENU_DEF menu_status = {"FS Status", &fs_status}; {"FS List", &fs_list},
const struct MENU_DEF menu_mount = {"FS Mount", &fs_mount}; {"FS Create", &fs_create},
const struct MENU_DEF menu_list = {"FS List", &fs_list}; {"FS read", &fs_read},
const struct MENU_DEF menu_create = {"FS Create", &fs_create}; {"FS format", &fs_format},
const struct MENU_DEF menu_format = {"FS format", &fs_format}; {"---", NULL},
const struct MENU_DEF menu_read = {"FS read", &fs_read};
#if CFG_USBMSC #if CFG_USBMSC
const struct MENU_DEF menu_usb = {"USB mount", &usbMSCInit}; {"USB mount", &usbMSCInit},
const struct MENU_DEF menu_usboff = {"USB unmount", &usbMSCOff}; {"USB unmount", &usbMSCOff},
{"---", NULL},
#endif #endif
const struct MENU_DEF menu_nop = {"---", NULL}; {"Invoke ISP", &gotoISP},
{"Backlight++", &incBacklight},
{"Backlight--", &decBacklight},
{NULL,NULL}
}};
static menuentry menu[] = {
&menu_mount,
&menu_status,
&menu_list,
&menu_create,
&menu_read,
&menu_nop,
&menu_format,
&menu_nop,
#if CFG_USBMSC
&menu_usb,
&menu_usboff,
#endif
&menu_nop,
&menu_ISP,
&menu_incBL,
&menu_decBL,
NULL,
};
static const struct MENU mainmenu = {"Mainmenu", menu};
void main_fs(void) { void main_fs(void) {

251
firmware/applications/funk.c
View File

@ -1,251 +0,0 @@
#include <sysinit.h>
#include "basic/basic.h"
#include "lcd/lcd.h"
#include "lcd/print.h"
#include "funk/nrf24l01p.h"
#include <string.h>
#include "funk/rftransfer.h"
#include "funk/openbeacon.h"
/**************************************************************************/
#define BEACON_CHANNEL 81
#define BEACON_MAC "\x1\x2\x3\x2\1"
uint32_t const testkey[4] = {
0xB4595344,0xD3E119B6,0xA814D0EC,0xEFF5A24E
};
int enctoggle=0;
void f_init(void){
nrf_init();
struct NRF_CFG config = {
.channel= BEACON_CHANNEL,
.txmac= BEACON_MAC,
.nrmacs=1,
.mac0= BEACON_MAC,
.maclen ="\x10",
};
nrf_config_set(&config);
lcdPrintln("Done.");
};
void f_status(void){
int dx=0;
int dy=8;
uint8_t buf[4];
buf[0]=C_R_REGISTER | R_CONFIG;
buf[1]=0;
buf[2]=0;
buf[3]=0;
dx=DoString(0,dy,"S:");
dx=DoCharX(dx,dy,buf[0]);
dx=DoCharX(dx,dy,buf[1]);
dx=DoCharX(dx,dy,buf[2]);
dx=DoCharX(dx,dy,buf[3]);
dy+=8;
nrf_cmd_rw_long(buf,2);
dx=DoString(0,dy,"R:");
dx=DoCharX(dx,dy,buf[0]);
dx=DoCharX(dx,dy,buf[1]);
dx=DoCharX(dx,dy,buf[2]);
dx=DoCharX(dx,dy,buf[3]);
dy+=8;
int status=nrf_cmd_status(C_NOP);
dx=DoString(0,dy,"St:"); DoCharX(dx,dy,status);dy+=8;
};
void f_recv(void){
__attribute__ ((aligned (4))) uint8_t buf[32];
int len;
len=nrf_rcv_pkt_time_encr(1000,sizeof(buf),buf,enctoggle?testkey:NULL);
if(len==0){
lcdPrintln("No pkt (Timeout)");
};
lcdPrint("Size:");lcdPrintInt(len);lcdNl();
lcdPrint("1:");lcdPrintIntHex( *(int*)(buf+ 0) ); lcdNl();
lcdPrint("2:");lcdPrintIntHex( *(int*)(buf+ 4) ); lcdNl();
lcdPrint("3:");lcdPrintIntHex( *(int*)(buf+ 8) ); lcdNl();
lcdPrint("4:");lcdPrintIntHex( *(int*)(buf+12) ); lcdNl();
len=crc16(buf,14);
lcdPrint("crc:");lcdPrintShortHex(len); lcdNl();
};
void f_cfg(void){
struct NRF_CFG config;
nrfconfig cfg=&config;
nrf_config_get(cfg);
lcdPrint("ch:");lcdPrintInt( cfg->channel ); lcdNl();
lcdPrint("nr:");lcdPrintInt( cfg->nrmacs ); lcdNl();
lcdPrint("0:");
lcdPrintCharHex(cfg->mac0[0]);
lcdPrintCharHex(cfg->mac0[1]);
lcdPrintCharHex(cfg->mac0[2]);
lcdPrintCharHex(cfg->mac0[3]);
lcdPrintCharHex(cfg->mac0[4]);
lcdNl();
lcdPrint("1:");
lcdPrintCharHex(cfg->mac1[0]);
lcdPrintCharHex(cfg->mac1[1]);
lcdPrintCharHex(cfg->mac1[2]);
lcdPrintCharHex(cfg->mac1[3]);
lcdPrintCharHex(cfg->mac1[4]);
lcdNl();
lcdPrint("2345:");
lcdPrintCharHex(cfg->mac2345[0]);
lcdPrintCharHex(cfg->mac2345[1]);
lcdPrintCharHex(cfg->mac2345[2]);
lcdPrintCharHex(cfg->mac2345[3]);
lcdNl();
lcdPrint("tx:");
lcdPrintCharHex(cfg->txmac[0]);
lcdPrintCharHex(cfg->txmac[1]);
lcdPrintCharHex(cfg->txmac[2]);
lcdPrintCharHex(cfg->txmac[3]);
lcdPrintCharHex(cfg->txmac[4]);
lcdNl();
lcdPrint("len:");
lcdPrintCharHex(cfg->maclen[0]);
lcdPrintCharHex(cfg->maclen[1]);
lcdPrintCharHex(cfg->maclen[2]);
lcdPrintCharHex(cfg->maclen[3]);
lcdPrintCharHex(cfg->maclen[4]);
lcdNl();
};
void f_cfg_set(void){
struct NRF_CFG config = {
.channel= 13,
.txmac= "R0KET",
.nrmacs=1,
.mac0= "R0KET",
.maclen ="\x10",
};
nrf_config_set(&config);
};
void f_enctog(void){
enctoggle=1-enctoggle;
if(enctoggle)
lcdPrintln("Encrypt ON!");
else
lcdPrintln("encrypt off!");
};
void f_send(void){
uint8_t status;
status = openbeaconSend();
lcdPrint("Status:");
lcdPrintCharHex(status);
lcdNl();
};
void gotoISP(void) {
DoString(0,0,"Enter ISP!");
lcdDisplay();
ISPandReset();
}
void lcd_mirror(void) {
lcdToggleFlag(LCD_MIRRORX);
};
void adc_check(void) {
int dx=0;
int dy=8;
// Print Voltage
dx=DoString(0,dy,"Voltage:");
while ((getInputRaw())==BTN_NONE){
DoInt(dx,dy,GetVoltage());
lcdDisplay();
};
dy+=8;
dx=DoString(0,dy,"Done.");
};
void f_sendBlock(void)
{
uint8_t data[] = "hallo welt, das hier ist ein langer string, der"
"per funk verschickt werden soll.";
rftransfer_send(strlen((char *)data), data);
}
/**************************************************************************/
const struct MENU_DEF menu_ISP = {"Invoke ISP", &gotoISP};
const struct MENU_DEF menu_init = {"F Init", &f_init};
const struct MENU_DEF menu_status = {"F Status", &f_status};
const struct MENU_DEF menu_rcv = {"F Recv", &f_recv};
const struct MENU_DEF menu_snd = {"F Send", &f_send};
const struct MENU_DEF menu_cfg = {"F CfgGet", &f_cfg};
const struct MENU_DEF menu_cfg2 = {"F CfgSet", &f_cfg_set};
const struct MENU_DEF menu_enc = {"Toggle Encr", &f_enctog};
const struct MENU_DEF menu_sndblock={"F Send block", &f_sendBlock};
const struct MENU_DEF menu_mirror = {"Mirror", &lcd_mirror};
const struct MENU_DEF menu_volt = {"Akku", &adc_check};
const struct MENU_DEF menu_nop = {"---", NULL};
static menuentry menu[] = {
&menu_init,
&menu_status,
&menu_rcv,
&menu_snd,
&menu_enc,
&menu_cfg2,
&menu_cfg,
&menu_nop,
&menu_mirror,
&menu_volt,
&menu_ISP,
NULL,
};
static const struct MENU mainmenu = {"Mainmenu", menu};
void main_funk(void) {
backlightInit();
font=&Font_7x8;
openbeaconSetup();
while (1) {
lcdFill(0); // clear display buffer
lcdDisplay();
handleMenu(&mainmenu);
gotoISP();
}
};
void tick_funk(void){
static int foo=0;
static int toggle=0;
if(foo++>50){
toggle=1-toggle;
foo=0;
gpioSetValue (RB_LED0, toggle);
};
return;
};

4
firmware/applications/life.c
View File

@ -159,6 +159,7 @@ void nextledcycle() {
uchar stepmode=0; uchar stepmode=0;
uchar randdensity=0; uchar randdensity=0;
//uint8_t bl=0;
void main_life(void) { void main_life(void) {
backlightInit(); backlightInit();
@ -198,9 +199,12 @@ void main_life(void) {
stepmode=1; stepmode=1;
break; break;
} }
// bl=(bl+1)%101;
// backlightSetBrightness(bl);
draw_area(); // xor life pattern over display content draw_area(); // xor life pattern over display content
lcdDisplay(); lcdDisplay();
draw_area(); // xor life pattern again to restore original display content draw_area(); // xor life pattern again to restore original display content
lcdShift(1,-2,1);
delayms(10); delayms(10);
calc_area(); calc_area();
} }

29
firmware/applications/loadable.c
View File

@ -45,26 +45,17 @@ void msc_menu(void){
extern void (*ram)(void); extern void (*ram)(void);
const struct MENU_DEF menu_ISP = {"Invoke ISP", &gotoISP}; static const struct MENU mainmenu = {"Mainmenu", {
const struct MENU_DEF menu_again = {"Run Loadable", &ram}; {"Run Loadable", &ram},
const struct MENU_DEF menu_nop = {"---", NULL}; {"Invoke ISP", &gotoISP},
const struct MENU_DEF menu_msc = {"MSC", &msc_menu}; {"---", NULL},
const struct MENU_DEF menu_volt = {"Akku", &adc_check}; {"MSC", &msc_menu},
const struct MENU_DEF menu_mirror = {"Mirror", &lcd_mirror}; {"Akku", &adc_check},
const struct MENU_DEF menu_invert = {"Invert", &lcd_invert}; {"Mirror", &lcd_mirror},
{"Invert", &lcd_invert},
{NULL,NULL}
}};
static menuentry menu[] = {
&menu_again,
&menu_ISP,
&menu_nop,
&menu_msc,
&menu_mirror,
&menu_invert,
&menu_volt,
NULL,
};
static const struct MENU mainmenu = {"Mainmenu", menu};
/**************************************************************************/ /**************************************************************************/

43
firmware/applications/menutest.c
View File

@ -21,42 +21,25 @@ void gotoISP(void);
/**************************************************************************/ /**************************************************************************/
static const struct MENU mainmenu = {"Mainmenu", {
{"Backlight++", &incBacklight},
{"Backlight--", &decBacklight},
{"Invoke ISP", &gotoISP},
{"p1e4", NULL},
{"p1e5", NULL},
{"p1e6", NULL},
{"p1e7", NULL},
{"p2e1", NULL},
{"p2e2", NULL},
{"p2e3", NULL},
{NULL, NULL},
}};
const struct MENU_DEF menu_incBL = {"Backlight++", &incBacklight};
const struct MENU_DEF menu_decBL = {"Backlight--", &decBacklight};
const struct MENU_DEF menu_ISP = {"Invoke ISP", &gotoISP};
const struct MENU_DEF menu_Ep = {"p1e4", NULL};
const struct MENU_DEF menu_Eq = {"p1e5", NULL};
const struct MENU_DEF menu_Er = {"p1e6", NULL};
const struct MENU_DEF menu_Es = {"p1e7", NULL};
const struct MENU_DEF menu_Et = {"p2e1", NULL};
const struct MENU_DEF menu_Eu = {"p2e2", NULL};
const struct MENU_DEF menu_Ev = {"p2e3", NULL};
static menuentry menu[] = {
&menu_incBL,
&menu_decBL,
&menu_ISP,
&menu_Ep,
&menu_Eq,
&menu_Er,
&menu_Es,
&menu_Et,
&menu_Eu,
&menu_Ev,
&menu_Ev,
&menu_ISP,
NULL,
};
static const struct MENU mainmenu = {"Mainmenu", menu};
void main_menutest(void) { void main_menutest(void) {
backlightInit(); backlightInit();
font_direction = FONT_DIR_LTR; // LeftToRight is the default
while (1) { while (1) {
lcdDisplay(); lcdDisplay();
delayms(10); delayms(10);

1
firmware/applications/mesh/config.c
View File

@ -1,6 +1,7 @@
#include <sysinit.h> #include <sysinit.h>
#include "basic/basic.h" #include "basic/basic.h"
#include "basic/config.h"
#include "lcd/print.h" #include "lcd/print.h"
#include "lcd/display.h" #include "lcd/display.h"

15
firmware/applications/mesh/util.c
View File

@ -1,6 +1,7 @@
#include <sysinit.h> #include <sysinit.h>
#include "basic/basic.h" #include "basic/basic.h"
#include "basic/config.h"
#include "lcd/lcd.h" #include "lcd/lcd.h"
#include "lcd/print.h" #include "lcd/print.h"
@ -29,6 +30,18 @@ void show_ticks(void) {
}; };
void chrg_stat(void) {
int stat;
while ((getInputRaw())==BTN_NONE){
lcdClear();
lcdPrintln("Chrg_stat:");
stat=gpioGetValue(RB_PWR_CHRG);
lcdPrint(IntToStr(stat,3,0));
lcdNl();
lcdRefresh();
};
lcdPrintln("Done.");
};
void adc_light(void) { void adc_light(void) {
int dx=0; int dx=0;
int dy=8; int dy=8;
@ -37,7 +50,7 @@ void adc_light(void) {
while ((getInputRaw())==BTN_NONE){ while ((getInputRaw())==BTN_NONE){
DoInt(dx,dy,GetLight()); DoInt(dx,dy,GetLight());
DoInt(dx,dy+16,isNight()); DoInt(dx,dy+16,isNight());
DoInt(dx,dy+8,GLOBAL(nighttrigger)); DoInt(dx,dy+8,GLOBAL(daytrig));
lcdDisplay(); lcdDisplay();
}; };
dy+=8; dy+=8;

123
firmware/applications/mkfirmware.pl Executable file
View File

@ -0,0 +1,123 @@
#!/usr/bin/perl
#
# vim:set ts=4 sw=4:
use strict;
my $debug=0;
if($ARGV[0] eq "-d"){
$debug=1;
shift;
};
my $app=shift;
my @files=@ARGV;
my %menu;
my (@ticks,@inits);
$\="\n";
print "// Function definitions:";
my $menudef;
for my $file (@files){
open(F,"<",$file) || die "Can't open $file: $!";
while(<F>){
chomp;
s/\r$//; # Dos line-end
if(m!^\s*//#\s+(.*?)\s*$!){ # Menu definition
$menudef=$1;
next;
};
next if(/^\s*$/);
next if(m!^\s*//!);
if(m!^\s*void\s+([^(]+)\(!){ # A suitable function
my $func=$1;
if($func=~/tick_/){
push @ticks,$func;
print "void $func(void);";
};
if($func=~/init_/){
push @inits,$func;
print "void $func(void);";
};
if($debug){
my $f="debug";
$file =~ m!([^/.]+)\.! && do {$f=$1};
$menudef="MENU $f $func";
};
if(defined $menudef){
my @words=split(/\s+/,$menudef);
if($words[0] ne "MENU"){
warn "Not a menu definition?";
};
if($#words==1){
$menu{$words[1]}=$func;
}elsif($#words==2){
$menu{$words[1]}{$words[2]}=$func;
}else{
warn "Couldn't handle $menudef";
};
print "void $func(void);";
};
$menudef=undef;
};
};
};
print "";
print "// Submenus:";
#use Data::Dumper; print Dumper \%menu;
for (sort keys %menu){
if(ref $menu{$_} eq "HASH"){
printf "static const struct MENU submenu_${_}={";
print qq! "$_", {!;
for my $entry(sort keys %{$menu{$_}}){
print qq!\t{ "$entry", &$menu{$_}{$entry}},!;
};
print qq!\t{NULL,NULL}!;
print "}};";
};
};
print "";
for (sort keys %menu){
if(ref $menu{$_} eq "HASH"){
print qq!void run_submenu_$_(void) {!;
print qq!\thandleMenu(&submenu_$_);!;
print qq!};!;
};
};
print "";
print "// Main menu:";
printf "static const struct MENU mainmenu={";
print qq! "Menu:", {!;
for (sort keys %menu){
if(ref $menu{$_} eq "HASH"){
print qq!\t{ "$_", &run_submenu_$_},!;
}else{
print qq!\t{ "$_", &$menu{$_}},!;
};
};
print qq!\t\t{NULL,NULL}!;
print "}};";
print "";
print "// Tick & init functions:";
print qq!void tick_$app(void) {!;
for (sort @ticks){
print qq!\t$_();!;
};
print qq!};!;
print qq!void init_$app(void) {!;
for (sort @inits){
print qq!\t$_();!;
};
print qq!};!;

70
firmware/applications/mktester
View File

@ -1,70 +0,0 @@
#!/bin/sh
for f in $* ; do
grep -h '^void ' $f|sed 's/^void //;s/(.*//'|while read a ; do
echo "void $a(void);"
done
done
for f in $* ; do
grep -h '^void ' $f|sed 's/^void //;s/(.*//'|while read a ; do
echo "const struct MENU_DEF menu_$a = {\"$a\", &$a};"
done
done
echo "const struct MENU_DEF menu_nop = {\"---\", NULL};"
echo
for f in $* ; do
t=${f#*/}
t=${t%.c}
echo "static menuentry mentry_$t[] = {"
grep -h '^void ' $f|sed 's/^void //;s/(.*//'|while read a ; do
echo "&menu_$a,"
done
echo "NULL"
echo "};"
done
for f in $* ; do
t=${f#*/}
t=${t%.c}
echo "static const struct MENU m_$t = {\"$t\", mentry_$t};"
done
for f in $* ; do
t=${f#*/}
t=${t%.c}
echo "void run_$t(void) {"
echo "handleMenu(&m_$t);"
echo "};"
done
for f in $* ; do
t=${f#*/}
t=${t%.c}
echo "const struct MENU_DEF menu_$t = {\"$t\", &run_$t};"
done
echo "static menuentry mentry[] = {"
for f in $* ; do
t=${f#*/}
t=${t%.c}
echo "&menu_$t,"
done
echo "NULL"
echo "};"
echo "inline void generated_tick(void){"
for f in $* ; do
grep -h '^void tick_' $f|sed 's/^void //;s/(.*//'|while read a ; do
echo "$a();"
done
done
echo "return;"
echo "};"

197
firmware/applications/remote.c
View File

@ -1,197 +0,0 @@
#include <sysinit.h>
#include "basic/basic.h"
#include "lcd/lcd.h"
#include "lcd/print.h"
#include "funk/nrf24l01p.h"
#include "usb/usbmsc.h"
#include <string.h>
/**************************************************************************/
uint32_t const testkey[4] = {
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
};
void f_init(void){
nrf_init();
struct NRF_CFG config = {
.channel= 81,
.txmac= "REMOT",
.nrmacs=1,
.mac0= "REMOT",
.maclen ="\x10",
};
nrf_config_set(&config);
lcdPrintln("Done.");
};
void f_recv(void){
__attribute__ ((aligned (4))) uint8_t buf[32];
int len;
while(1){
len=nrf_rcv_pkt_time_encr(1000,sizeof(buf),buf,testkey);
if(len==0){
lcdPrintln("No pkt (Timeout)");
return;
};
lcdClear();
lcdPrint("Size:");lcdPrintInt(len);lcdNl();
lcdPrintCharHex(buf[0]);
lcdPrint(" ");
lcdPrintCharHex(buf[1]);
lcdPrint(" ");
lcdPrintCharHex(buf[2]);
lcdPrint(" ");
lcdPrintCharHex(buf[3]);
lcdNl();
lcdPrint("ct:");lcdPrintIntHex( *(int*)(buf+ 4) ); lcdNl();
lcdPrint("id:");lcdPrintIntHex( *(int*)(buf+ 8) ); lcdNl();
lcdPrint("xx:");lcdPrintIntHex( *(int*)(buf+12) ); lcdNl();
lcdDisplay();
};
};
void f_send(void){
int ctr=1;
__attribute__ ((aligned (4))) uint8_t buf[32];
int len;
int status;
while(1){
buf[0]=0x10; // Length: 16 bytes
buf[1]='C'; // Proto
buf[2]=getInputRaw();
buf[3]=0x00; // Unused
ctr++;
*(int*)(buf+4)=ctr;
/*
buf[4]=0x00; // ctr
buf[5]=0x00; // ctr
buf[6]=0x00; // ctr
buf[7]=ctr++; // ctr
*/
buf[8]=0x0; // Object id
buf[9]=0x0;
buf[10]=0x05;
buf[11]=0xec;
buf[12]=0xff; // salt (0xffff always?)
buf[13]=0xff;
status=nrf_snd_pkt_crc_encr(16,buf,testkey);
lcdClear();
lcdPrint("Key:"); lcdPrintInt(buf[2]); lcdNl();
lcdPrint("F-St:"); lcdPrintInt(status);
if(buf[2]==BTN_ENTER)
break;
lcdDisplay();
len=nrf_rcv_pkt_time_encr(10,sizeof(buf),buf,testkey);
if(len>0){
lcdPrint("Got!");
};
};
};
void gotoISP(void) {
DoString(0,0,"Enter ISP!");
lcdDisplay();
ISPandReset();
}
void lcd_mirror(void) {
lcdToggleFlag(LCD_MIRRORX);
};
void adc_check(void) {
int dx=0;
int dy=8;
// Print Voltage
dx=DoString(0,dy,"Voltage:");
while ((getInputRaw())==BTN_NONE){
DoInt(dx,dy,GetVoltage());
lcdDisplay();
};
dy+=8;
dx=DoString(0,dy,"Done.");
};
void msc_menu(void){
DoString(0,8,"MSC Enabled.");
lcdDisplay();
usbMSCInit();
while(!getInputRaw())delayms(10);
DoString(0,16,"MSC Disabled.");
usbMSCOff();
};
/**************************************************************************/
const struct MENU_DEF menu_ISP = {"Invoke ISP", &gotoISP};
const struct MENU_DEF menu_init = {"F Init", &f_init};
const struct MENU_DEF menu_rcv = {"F Recv", &f_recv};
const struct MENU_DEF menu_snd = {"F Send", &f_send};
//const struct MENU_DEF menu_cfg = {"F Cfg", &f_cfg};
const struct MENU_DEF menu_mirror = {"Mirror", &lcd_mirror};
const struct MENU_DEF menu_volt = {"Akku", &adc_check};
const struct MENU_DEF menu_msc = {"MSC", &msc_menu};
const struct MENU_DEF menu_nop = {"---", NULL};
static menuentry menu[] = {
&menu_init,
&menu_rcv,
&menu_snd,
// &menu_cfg,
&menu_nop,
&menu_mirror,
&menu_volt,
&menu_msc,
&menu_nop,
&menu_ISP,
NULL,
};
static const struct MENU mainmenu = {"Mainmenu", menu};
void main_remote(void) {
font=&Font_7x8;
while (1) {
lcdFill(0); // clear display buffer
lcdDisplay();
handleMenu(&mainmenu);
gotoISP();
}
};
void tick_remote(void){
static int foo=0;
static int toggle=0;
if(foo++>80){
toggle=1-toggle;
foo=0;
gpioSetValue (RB_LED0, toggle);
};
return;
};

229
firmware/applications/spaceinvaders.c
View File

@ -1,229 +0,0 @@
#include <sysinit.h>
#include "basic/basic.h"
#include "lcd/render.h"
#include "lcd/display.h"
#include "lcd/allfonts.h"
void ReinvokeISP(void);
void EnableWatchdog(uint32_t ms);
void delayms(uint32_t ms);
/**************************************************************************/
#define POS_PLAYER_Y 60
#define ENEMY_ROWS 3
#define ENEMY_COLUMNS 6
#define DISABLED 255
struct gamestate {
char player;
char shot_x, shot_y;
char alive;
char move, direction, lastcol;
bool killed;
char enemy_x[ENEMY_ROWS][ENEMY_COLUMNS];
char enemy_row_y[ENEMY_ROWS];
} game = {RESX/2-4, DISABLED, 0,ENEMY_ROWS*ENEMY_COLUMNS, 0, -1, ENEMY_COLUMNS-1, false};
char key;
void checkISP(void) {
if(gpioGetValue(RB_BTN2)==0){
gpioSetValue (RB_LED1, CFG_LED_ON);
delayms(200);
gpioSetValue (RB_LED1, CFG_LED_OFF);
while(gpioGetValue(RB_BTN0)==0);
EnableWatchdog(1000*5);
ReinvokeISP();
}
}
void init_enemy() {
for (int row = 0; row<ENEMY_ROWS; row++) {
game.enemy_row_y[row] = 10 + (40/ENEMY_ROWS)*row;
for (int col = 0; col<ENEMY_COLUMNS; col++) {
game.enemy_x[row][col] = 5+(86/ENEMY_COLUMNS)*col;
}
}
}
void move_shot() {
//No shot, do nothing
if(game.shot_x == DISABLED) {
return;
}
//moving out of top, end shot
if (game.shot_y <= 0) {
game.shot_x = DISABLED;
return;
}
//check for collision with enemy, kill enemy if
for (int row=0; row<ENEMY_ROWS; row++) {
if (game.enemy_row_y[row]+6 >= game.shot_y && game.enemy_row_y[row]+6 < game.shot_y+7) {
for(int col = 0; col<ENEMY_COLUMNS; col++) {
if(game.shot_x >= game.enemy_x[row][col] && game.shot_x < game.enemy_x[row][col]+8) {
game.enemy_x[row][col]=DISABLED;
game.shot_x = DISABLED;
game.alive--;
return;
}
}
}
}
game.shot_y -= 3;
}
void move_player() {
if(gpioGetValue(RB_BTN0)==0 && game.player > 0 ){
game.player-=1;
}
if(gpioGetValue(RB_BTN1)==0 && game.player < RESX-8){
game.player+=1;
}
if(gpioGetValue(RB_BTN4)==0 && game.shot_x == 255){
game.shot_x = game.player+4;
game.shot_y = POS_PLAYER_Y;
}
}
void move_enemy() {
if(game.move > 0){
game.move--;
return;
}
for (int col = 0; col < ENEMY_COLUMNS; col++) {
for (int row = 0; row < ENEMY_ROWS; row++) {
char pos = game.enemy_x[row][(game.direction==1)?(ENEMY_COLUMNS-(col+1)):col];
if (pos != DISABLED) {
//Check collision with player
if(game.enemy_row_y[row]+8 >= POS_PLAYER_Y && pos+8 >= game.player && pos < game.player+8){
game.killed = true;
}
if((pos <=0 && game.direction != 1) ||
(pos >=RESX-8-1 && game.direction == 1)){
game.direction = (game.direction==1)?-1:1;
for (char r = 0; r<ENEMY_ROWS; r++) {
game.enemy_row_y[r]+=4;
}
return;
}
game.enemy_x[row][(game.direction==1)?(ENEMY_COLUMNS-(col+1)):col] += game.direction;
}
}
}
game.move = game.alive-1;
}
void move_enemy2() {
if(game.move == 0) {
bool next = false;
for (int col = game.lastcol; col < ENEMY_COLUMNS || col <= 0; col+=game.direction) {
for (int row = 0; row < ENEMY_ROWS; row++) {
char pos = game.enemy_x[row][col];
//There is an enemy on this row
if (pos != DISABLED) {
if((pos <=0 && game.direction== -1) ||
(pos >=RESX-8 && game.direction == 1)){
game.direction *= -1;
//TODOmove down
return;
}
game.enemy_x[row][col] += game.direction;
next = true;
}
}
if (next){
game.lastcol += game.direction;
return;
}
}
game.move = game.alive;
return;
}
game.move--;
}
void draw_player() {
//draw_sprite(50, 20);
draw_sprite(game.player, POS_PLAYER_Y);
}
void draw_enemy() {
for (int row = 0; row<ENEMY_ROWS; row++) {
for (int col = 0; col<ENEMY_COLUMNS; col++) {
if (game.enemy_x[row][col] != DISABLED) {
draw_sprite(game.enemy_x[row][col],game.enemy_row_y[row]);
}
}
}
}
void draw_shot() {
if (game.shot_x != 255) {
for (int length=0; length<=5; length++) {
lcdSetPixel(game.shot_x, game.shot_y+length, true);
}
}
}
void draw_status() {
for (int p = 0; p<game.alive; p++){
lcdSetPixel(p+1,1,true);
}
}
void draw_sprite(char x, char y) {
font = &Font_Invaders;
DoString(x,y-1,"C");
/* for (int dx=0; dx<8; dx++){
for(int dy=0; dy<8; dy++){
lcdSetPixel(x+dx,y+dy, true);
}
} */
}
void check_end() {
if (game.killed) {
game.player = RESX/2+4;
for(int row; row<ENEMY_ROWS; row++) {
game.enemy_row_y[row] = 10 + (40/ENEMY_ROWS)*row;
}
game.killed = false;
}
if (game.alive == 0) {
}
}
void main_spaceinvaders(void) {
gpioSetValue (RB_LED1, CFG_LED_OFF);
backlightInit();
init_enemy();
while (1) {
checkISP();
lcdFill(0);
check_end();
move_shot();
move_player();
move_enemy();
draw_player();
draw_enemy();
draw_shot();
draw_status();
lcdDisplay();
delayms(10);
}
return;
}

8
firmware/applications/tester.c
View File

@ -10,15 +10,9 @@
#include "tester.gen" #include "tester.gen"
static const struct MENU mainmenu = {"Mainmenu", mentry};
void main_tester(void) { void main_tester(void) {
handleMenu(&mainmenu); handleMenu(&mainmenu);
gotoISP(); gotoISP();
}; };
void tick_tester(void){ void tick_tester(void);
generated_tick();
};

41
firmware/applications/tester/font.c
View File

@ -127,3 +127,44 @@ void f_font(void){
while(!getInputRaw())delayms(10); while(!getInputRaw())delayms(10);
}; };
void f_speedtest(void){
lcdClear();
lcdPrintln("Speedtest");
lcdNl();
lcdNl();
lcdPrintln("running...");
int start=getTimer();
int ctr=0;
while(ctr++<1000){
lcdRefresh();
};
start=getTimer()-start;
lcdPrint("Ticks:");
lcdPrintln(IntToStr(start,6,0));
lcdPrint("Tickspd:");
lcdPrintln(IntToStr(SYSTICKSPEED,3,0));
lcdRefresh();
getInputWait();
getInputWaitRelease();
};
void f_speedtest2(void){
lcdClear();
lcdPrintln("Speedtest");
lcdNl();
lcdNl();
lcdPrintln("running...");
int start=getTimer();
int ctr=0;
int tm;
while(!getInputRaw()){
ctr++;
tm=((getTimer()-start)*SYSTICKSPEED)*1000/ctr;
DoInt(0,32,tm);
lcdRefresh();
};
getInputWaitRelease();
};

15
firmware/applications/tester/util.c
View File

@ -1,6 +1,7 @@
#include <sysinit.h> #include <sysinit.h>
#include "basic/basic.h" #include "basic/basic.h"
#include "basic/config.h"
#include "lcd/lcd.h" #include "lcd/lcd.h"
#include "lcd/print.h" #include "lcd/print.h"
@ -29,6 +30,18 @@ void show_ticks(void) {
}; };
void chrg_stat(void) {
int stat;
while ((getInputRaw())==BTN_NONE){
lcdClear();
lcdPrintln("Chrg_stat:");
stat=gpioGetValue(RB_PWR_CHRG);
lcdPrint(IntToStr(stat,3,0));
lcdNl();
lcdRefresh();
};
lcdPrintln("Done.");
};
void adc_light(void) { void adc_light(void) {
int dx=0; int dx=0;
int dy=8; int dy=8;
@ -37,7 +50,7 @@ void adc_light(void) {
while ((getInputRaw())==BTN_NONE){ while ((getInputRaw())==BTN_NONE){
DoInt(dx,dy,GetLight()); DoInt(dx,dy,GetLight());
DoInt(dx,dy+16,isNight()); DoInt(dx,dy+16,isNight());
DoInt(dx,dy+8,GLOBAL(nighttrigger)); DoInt(dx,dy+8,GLOBAL(daytrig));
lcdDisplay(); lcdDisplay();
}; };
dy+=8; dy+=8;

3
firmware/basic/basic.c
View File

@ -34,6 +34,9 @@ void rbInit() {
gpioSetDir(RB_BTN4, gpioDirection_Input); gpioSetDir(RB_BTN4, gpioDirection_Input);
gpioSetPullup (&RB_BTN4_IO, gpioPullupMode_PullUp); gpioSetPullup (&RB_BTN4_IO, gpioPullupMode_PullUp);
// prepate chrg_stat
gpioSetDir(RB_PWR_CHRG, gpioDirection_Input);
gpioSetPullup (&RB_PWR_CHRG_IO, gpioPullupMode_PullUp);
// prepare LEDs // prepare LEDs
IOCON_JTAG_TDI_PIO0_11 &= ~IOCON_JTAG_TDI_PIO0_11_FUNC_MASK; IOCON_JTAG_TDI_PIO0_11 &= ~IOCON_JTAG_TDI_PIO0_11_FUNC_MASK;

39
firmware/basic/basic.h
View File

@ -81,6 +81,7 @@
#define RB_PWR_GOOD 1,8 #define RB_PWR_GOOD 1,8
#define RB_PWR_CHRG 2,3 #define RB_PWR_CHRG 2,3
#define RB_PWR_CHRG_IO IOCON_PIO2_3
#define RB_PWR_LCDBL 0,0 #define RB_PWR_LCDBL 0,0
#define RB_PWR_LCDBL_IO IOCON_nRESET_PIO0_0 #define RB_PWR_LCDBL_IO IOCON_nRESET_PIO0_0
@ -171,11 +172,9 @@ struct MENU_DEF {
void (*callback)(void); void (*callback)(void);
}; };
typedef const struct MENU_DEF * menuentry;
struct MENU { struct MENU {
char *title; char *title;
menuentry *entries; struct MENU_DEF entries[];
}; };
@ -185,36 +184,6 @@ void handleMenu(const struct MENU *the_menu);
#include "basic/idle.h" #include "basic/idle.h"
// config.c
int readConfig(void);
int saveConfig(void);
void applyConfig(void);
struct CDESC {
char *name;
char value;
char min;
char max;
};
extern struct CDESC the_config[];
#define GLOBALversion (the_config[0].value)
#define GLOBALprivacy (the_config[1].value)
#define GLOBALnighttrigger (the_config[2].value)
#define GLOBALnightinvert (the_config[3].value)
#define GLOBALlcdbacklight (the_config[4].value)
#define GLOBALlcdmirror (the_config[5].value)
#define GLOBALlcdinvert (the_config[6].value)
#define GLOBALlcdcontrast (the_config[7].value)
#define GLOBAL(x) GLOBAL ## x
#define SYSTICKSPEED 10
// itoa.c // itoa.c
#define F_ZEROS (1<<0) #define F_ZEROS (1<<0)
#define F_LONG (1<<1) #define F_LONG (1<<1)
@ -227,4 +196,8 @@ const char* IntToStr(int num, unsigned int mxlen, char flag);
#include "basic/simpletime.h" #include "basic/simpletime.h"
// global
#define SYSTICKSPEED 10
#endif #endif

26
firmware/basic/config.c
View File

@ -1,32 +1,46 @@
#include <sysinit.h> #include <sysinit.h>
#include "basic/basic.h" #include "basic/basic.h"
#include "lcd/display.h"
#include "lcd/print.h" #include "lcd/print.h"
#include "filesystem/ff.h" #include "filesystem/ff.h"
#include "basic/random.h" #include "basic/random.h"
#include "basic/config.h"
#define CFGVER 23 #define CFGVER 1
struct CDESC the_config[]= { struct CDESC the_config[]= {
{"version", CFGVER, CFGVER, CFGVER}, {"version", CFGVER, CFGVER, CFGVER},
// dflt min max
{"privacy", 3, 0, 2 }, {"privacy", 3, 0, 2 },
{"nighttrigger", 310/2, 0, 255}, {"daytrig", 310/2, 0, 255},
{"nightinvert", 1, 0, 1 }, {"daytrighyst", 10, 0, 50 },
{"dayinvert", 1, 0, 1 },
{"lcdbacklight", 50, 0, 100}, {"lcdbacklight", 50, 0, 100},
{"lcdmirror", 0, 0, 1 }, {"lcdmirror", 0, 0, 1 },
{"lcdinvert", 0, 0, 1 }, {"lcdinvert", 0, 0, 1 },
{"lcdcontrast", 3, 0, 31 }, {"lcdcontrast", 14, 0, 31 },
{"alivechk", 0, 0, 2 },
{"flamemax", 255, 0, 255},
{"flamemin", 0, 0, 255},
{"flamespeed", 1, 1, 100},
{"flamemaxw", 255, 1, 255},
{"flameminw", 0x8f, 1, 255},
{ NULL, 0, 0, 0 }, { NULL, 0, 0, 0 },
}; };
char nickname[MAXNICK]="anonymous";
char nickfont[FILENAMELEN];
#define CONFFILE "r0ket.cfg" #define CONFFILE "r0ket.cfg"
#define CONF_ITER for(int i=0;the_config[i].name!=NULL;i++) #define CONF_ITER for(int i=0;the_config[i].name!=NULL;i++)
/**************************************************************************/ /**************************************************************************/
void applyConfig(){ void applyConfig(){
lcdSetContrast(GLOBAL(lcdcontrast)); if(GLOBAL(lcdcontrast)>0)
return 0; lcdSetContrast(GLOBAL(lcdcontrast));
return;
}; };
int saveConfig(void){ int saveConfig(void){

41
firmware/basic/config.h Normal file
View File

@ -0,0 +1,41 @@
#ifndef __BASICCONFIG_H_
#define __BASICCONFIG_H_
int readConfig(void);
int saveConfig(void);
void applyConfig(void);
struct CDESC {
char *name;
char value;
char min;
char max;
};
#define MAXNICK 20
extern struct CDESC the_config[];
extern char nickname[MAXNICK];
extern char nickfont[];
#define GLOBALversion (the_config[ 0].value)
#define GLOBALprivacy (the_config[ 1].value)
#define GLOBALdaytrig (the_config[ 2].value)
#define GLOBALdaytrighyst (the_config[ 3].value)
#define GLOBALdayinvert (the_config[ 4].value)
#define GLOBALlcdbacklight (the_config[ 5].value)
#define GLOBALlcdmirror (the_config[ 6].value)
#define GLOBALlcdinvert (the_config[ 7].value)
#define GLOBALlcdcontrast (the_config[ 8].value)
#define GLOBALalivechk (the_config[ 9].value)
#define GLOBALflamemax (the_config[10].value)
#define GLOBALflamemin (the_config[11].value)
#define GLOBALflamespeed (the_config[12].value)
#define GLOBALflamemaxw (the_config[13].value)
#define GLOBALflameminw (the_config[14].value)
#define GLOBALnickname (nickname)
#define GLOBALnickfont (nickfont)
#define GLOBAL(x) GLOBAL ## x
#endif

33
firmware/basic/menu.c
View File

@ -2,8 +2,6 @@
#include "basic/basic.h" #include "basic/basic.h"
#include "lcd/fonts.h"
#include "lcd/render.h"
#include "lcd/print.h" #include "lcd/print.h"
/**************************************************************************/ /**************************************************************************/
@ -17,31 +15,28 @@ void handleMenu(const struct MENU *the_menu) {
if (the_menu == NULL) return; if (the_menu == NULL) return;
// font = &Font_7x8; // Font needs to be set externally? setSystemFont();
for (numentries = 0; the_menu->entries[numentries] != NULL; numentries++); for (numentries = 0; the_menu->entries[numentries].text != NULL ; numentries++);
visible_lines = (RESY/font->u8Height)-1; // subtract title line visible_lines = lcdGetVisibleLines()-1; // subtract title line
#ifdef SAFETY #ifdef SAFETY
if (visible_lines < 2) return; if (visible_lines < 2) return;
#endif #endif
while (!back) { while (!back) {
uint8_t line = 0;
// Display current menu page // Display current menu page
lcdFill(0); lcdClear();
DoString(0, line, the_menu->title); lcdPrintln(the_menu->title);
line += font->u8Height;
for (uint8_t i = current_offset; i < (visible_lines + current_offset) && i < numentries; i++) { for (uint8_t i = current_offset; i < (visible_lines + current_offset) && i < numentries; i++) {
DoString(14, line, the_menu->entries[i]->text);
if (i == menuselection) { if (i == menuselection) {
DoString(0, line, "* "); lcdPrint("*");
} }
line += font->u8Height; lcdSetCrsrX(14);
lcdPrintln(the_menu->entries[i].text);
} }
lcdDisplay(); lcdRefresh();
switch (getInputWait()) { switch (getInputWait()) {
case BTN_UP: case BTN_UP:
@ -69,17 +64,17 @@ void handleMenu(const struct MENU *the_menu) {
case BTN_LEFT: case BTN_LEFT:
return; return;
case BTN_RIGHT: case BTN_RIGHT:
if (the_menu->entries[menuselection]->callback!=NULL) if (the_menu->entries[menuselection].callback!=NULL)
the_menu->entries[menuselection]->callback(); the_menu->entries[menuselection].callback();
break; break;
case BTN_ENTER: case BTN_ENTER:
lcdClear(); lcdClear();
lcdPrintln("Called..."); lcdPrintln("Called...");
lcdRefresh(); lcdRefresh();
getInputWaitRelease(); getInputWaitRelease();
if (the_menu->entries[menuselection]->callback!=NULL) if (the_menu->entries[menuselection].callback!=NULL)
the_menu->entries[menuselection]->callback(); the_menu->entries[menuselection].callback();
lcdDisplay(); lcdRefresh();
getInputWait(); getInputWait();
break; break;

23
firmware/basic/night.c
View File

@ -1,45 +1,40 @@
#include <sysinit.h> #include <sysinit.h>
#include "basic/basic.h" #include "basic/basic.h"
#include "basic/config.h"
#define RANGE (10) #define SAMPCT (4)
#define HYST (4) uint32_t light=150*SAMPCT;
uint32_t light=300*HYST;
char _isnight=1; char _isnight=1;
#define threshold GLOBAL(nighttrigger) #define threshold GLOBAL(daytrig)
#define RANGE GLOBAL(daytrighyst)
void LightCheck(void){ void LightCheck(void){
int iocon; int iocon;
char iodir; char iodir;
int value;
iocon=IOCON_PIO1_11; iocon=IOCON_PIO1_11;
// iodir=gpioGetDir(RB_LED3); // iodir=gpioGetDir(RB_LED3);
iodir= (GPIO_GPIO1DIR & (1 << (RB_LED3) ))?1:0; iodir= (GPIO_GPIO1DIR & (1 << (RB_LED3) ))?1:0;
gpioSetDir(RB_LED3, gpioDirection_Input); gpioSetDir(RB_LED3, gpioDirection_Input);
IOCON_PIO1_11 = IOCON_PIO1_11_FUNC_AD7|IOCON_PIO1_11_ADMODE_ANALOG; IOCON_PIO1_11 = IOCON_PIO1_11_FUNC_AD7|IOCON_PIO1_11_ADMODE_ANALOG;
light-=light/HYST; light-=light/SAMPCT;
light += (adcRead(7)/2); light += (adcRead(7)/2);
gpioSetDir(RB_LED3, iodir); gpioSetDir(RB_LED3, iodir);
IOCON_PIO1_11=iocon; IOCON_PIO1_11=iocon;
if(threshold==0){ // uninitialized? if(_isnight && light/SAMPCT>(threshold+RANGE))
threshold=320;
};
if(_isnight && light/HYST>(threshold+RANGE))
_isnight=0; _isnight=0;
if(!_isnight && light/HYST<threshold) if(!_isnight && light/SAMPCT<threshold)
_isnight=1; _isnight=1;
}; };
uint32_t GetLight(void){ uint32_t GetLight(void){
return light/HYST; return light/SAMPCT;
}; };
char isNight(void){ char isNight(void){

1
firmware/basic/random.c
View File

@ -1,6 +1,7 @@
#include <stdint.h> #include <stdint.h>
#include "random.h" #include "random.h"
#include "xxtea.h" #include "xxtea.h"
#include "core/adc/adc.h"
#define STATE_SIZE 8 #define STATE_SIZE 8
uint32_t state[STATE_SIZE]; uint32_t state[STATE_SIZE];

1
firmware/basic/voltage.c
View File

@ -11,6 +11,7 @@ void VoltageCheck(void){
results /= 1024; results /= 1024;
if( results < 3500 ){ if( results < 3500 ){
nrf_off();
gpioSetValue (RB_PWR_GOOD, 0); gpioSetValue (RB_PWR_GOOD, 0);
gpioSetValue (RB_LCD_BL, 0); gpioSetValue (RB_LCD_BL, 0);
SCB_SCR |= SCB_SCR_SLEEPDEEP; SCB_SCR |= SCB_SCR_SLEEPDEEP;

12
firmware/filesystem/at45db041d.c
View File

@ -236,9 +236,13 @@ DRESULT dataflash_ioctl(BYTE ctrl, void *buff) {
} }
#endif /* _USE_IOCTL != 0 */ #endif /* _USE_IOCTL != 0 */
DWORD get_fattime () { DWORD get_fattime () {
// ToDo! struct tm* tm=mygmtime(getSeconds());
return 0; DWORD t= (((tm->tm_year+YEAR0-1980)<<9)|
((tm->tm_mon+1)<<5)|
(tm->tm_mday))<<16 |
((tm->tm_hour<<11)|
(tm->tm_min<<5)|
(tm->tm_sec>>1));
return t;
} }

3
firmware/filesystem/ff.h
View File

@ -329,8 +329,11 @@ int ff_del_syncobj (_SYNC_t); /* Delete a sync object */
#endif #endif
/* Utility functions */ /* Utility functions */
#define FILENAMELEN 13 // 8+1+3+1
const char* f_get_rc_string (FRESULT rc); const char* f_get_rc_string (FRESULT rc);
void fsInit(); void fsInit();
int readFile(char * filename, char * data, int len);
int writeFile(char * filename, char * data, int len);
#ifdef __cplusplus #ifdef __cplusplus
} }

83
firmware/filesystem/select.c
View File

@ -13,29 +13,30 @@ int getFiles(char files[][FLEN], uint8_t count, uint16_t skip, char *ext)
DIR dir; /* Directory object */ DIR dir; /* Directory object */
FILINFO Finfo; FILINFO Finfo;
FRESULT res; FRESULT res;
int ctr;
int pos = 0; int pos = 0;
int extlen = strlen(ext);
res = f_opendir(&dir, "0:"); res = f_opendir(&dir, "0:");
if(res){ if(res){
//lcdPrint("OpenDir:"); lcdPrintln(f_get_rc_string(res)); lcdRefresh(); //lcdPrint("OpenDir:"); lcdPrintln(f_get_rc_string(res)); lcdRefresh();
return 0; return 0;
}; };
ctr=0; while(f_readdir(&dir, &Finfo) == FR_OK && Finfo.fname[0]){
while(1){
res = f_readdir(&dir, &Finfo);
if ((res != FR_OK) || !Finfo.fname[0])
break;
int len=strlen(Finfo.fname); int len=strlen(Finfo.fname);
int extlen = strlen(ext);
if(len<extlen)
continue;
if( strcmp(Finfo.fname+len-extlen, ext) != 0) if( strcmp(Finfo.fname+len-extlen, ext) != 0)
continue; continue;
if (Finfo.fattrib & AM_DIR) if (Finfo.fattrib & AM_DIR)
continue; continue;
if( ctr++ < skip ) if( skip>0 ){
skip--;
continue; continue;
};
strcpy(files[pos++],Finfo.fname); strcpy(files[pos++],Finfo.fname);
if( pos == count ) if( pos == count )
break; break;
@ -43,6 +44,7 @@ int getFiles(char files[][FLEN], uint8_t count, uint16_t skip, char *ext)
return pos; return pos;
} }
#define PERPAGE 7
int selectFile(char *filename, char *extension) int selectFile(char *filename, char *extension)
{ {
int skip = 0; int skip = 0;
@ -50,12 +52,23 @@ int selectFile(char *filename, char *extension)
int selected = 0; int selected = 0;
font=&Font_7x8; font=&Font_7x8;
while(1){ while(1){
char files[7][FLEN]; char files[PERPAGE][FLEN];
int count = getFiles(files, 7, skip, extension); int count = getFiles(files, PERPAGE, skip, extension);
if(!count){
lcdPrintln("No Files?");
lcdRefresh();
getInputWait();
getInputWaitRelease();
return -1;
};
if(count<PERPAGE && selected==count){
skip--;
continue;
};
redraw: redraw:
if( count ) lcdClear();
lcdClear();
lcdPrintln("Select file:"); lcdPrintln("Select file:");
for(int i=0; i<count; i++){ for(int i=0; i<count; i++){
if( selected == i ) if( selected == i )
@ -67,27 +80,31 @@ int selectFile(char *filename, char *extension)
lcdRefresh(); lcdRefresh();
key=getInputWait(); key=getInputWait();
getInputWaitRelease(); getInputWaitRelease();
if( key==BTN_DOWN ){ switch(key){
if( selected < count-1 ){ case BTN_DOWN:
selected++; if( selected < count-1 ){
goto redraw; selected++;
}else{ goto redraw;
skip++; }else{
} skip++;
}else if( key==BTN_UP ){
if( selected > 0 ){
selected--;
goto redraw;
}else{
if( skip > 0 ){
skip--;
} }
} break;
}else if( key==BTN_LEFT ){ case BTN_UP:
return 1; if( selected > 0 ){
}else if( key==BTN_RIGHT ){ selected--;
strcpy(filename, files[selected]); goto redraw;
return 0; }else{
if( skip > 0 ){
skip--;
}
}
break;
case BTN_LEFT:
return -1;
case BTN_ENTER:
case BTN_RIGHT:
strcpy(filename, files[selected]);
return 0;
} }
} }
} }

47
firmware/filesystem/util.c
View File

@ -1,3 +1,4 @@
#include <sysdefs.h>
#include <ff.h> #include <ff.h>
FATFS FatFs; /* File system object for logical drive */ FATFS FatFs; /* File system object for logical drive */
@ -22,3 +23,49 @@ const char* f_get_rc_string (FRESULT rc) {
void fsInit(){ void fsInit(){
f_mount(0, &FatFs); f_mount(0, &FatFs);
}; };
void fsReInit(){
f_mount(0, NULL);
f_mount(0, &FatFs);
};
int readFile(char * filename, char * data, int len){
FIL file;
UINT readbytes;
int res;
res=f_open(&file, filename, FA_OPEN_EXISTING|FA_READ);
if(res){
return -1;
};
res = f_read(&file, data, len-1, &readbytes);
if(res){
return -1;
};
f_close(&file);
data[readbytes]=0;
return readbytes;
};
int writeFile(char * filename, char * data, int len){
FIL file;
UINT writebytes;
int res;
res=f_open(&file, filename, FA_OPEN_ALWAYS|FA_WRITE);
if(res){
return -1;
};
res = f_write(&file, data, len, &writebytes);
if(res){
return -1;
};
f_close(&file);
return writebytes;
};

2
firmware/funk/filetransfer.c
View File

@ -108,7 +108,7 @@ int filetransfer_receive(uint8_t *mac, uint32_t const k[4])
} }
lcdRefresh(); lcdRefresh();
if( fres < 0 ) if( fres < 0 )
return; return 1;
//nrf_set_rx_mac(0, 32, 5, macbuf); //nrf_set_rx_mac(0, 32, 5, macbuf);
xxtea_decode_words((uint32_t *)buf, wordcount, k); xxtea_decode_words((uint32_t *)buf, wordcount, k);

79
firmware/funk/mesh.c
View File

@ -25,8 +25,26 @@ void initMesh(void){
meshbuffer[0].flags=MF_USED; meshbuffer[0].flags=MF_USED;
}; };
inline void blink(char a, char b){ MPKT * meshGetMessage(uint8_t type){
gpioSetValue (a,b, 1-gpioGetValue(a,b)); int free=-1;
for(int i=0;i<MESHBUFSIZE;i++){
if ( ((meshbuffer[i].flags&MF_USED)==0) && free<0 )
free=i;
if ( (meshbuffer[i].flags&MF_USED) &&
(MO_TYPE(meshbuffer[i].pkt) == type)){
free=i;
break;
};
};
if(free==-1){ // Buffer full. Ah well. Kill a random packet
free=1; // XXX: GetRandom()?
meshbuffer[free].flags=MF_FREE;
};
if(meshbuffer[free].flags==MF_FREE){
memset(&meshbuffer[free],0,sizeof(MPKT));
MO_TYPE_set(meshbuffer[free].pkt,type);
};
return &meshbuffer[free];
}; };
void mesh_cleanup(void){ void mesh_cleanup(void){
@ -35,10 +53,15 @@ void mesh_cleanup(void){
if(meshbuffer[i].flags&MF_USED){ if(meshbuffer[i].flags&MF_USED){
if (MO_GEN(meshbuffer[i].pkt)<meshgen) if (MO_GEN(meshbuffer[i].pkt)<meshgen)
meshbuffer[i].flags=MF_FREE; meshbuffer[i].flags=MF_FREE;
if (MO_TIME(meshbuffer[i].pkt)<now) if (MO_TYPE(meshbuffer[i].pkt)>='a' &&
meshbuffer[i].flags=MF_FREE; MO_TYPE(meshbuffer[i].pkt)<='z'){
if (MO_TIME(meshbuffer[i].pkt)-now>SECS_DAY) ;
meshbuffer[i].flags=MF_FREE; }else{
if (MO_TIME(meshbuffer[i].pkt)<now)
meshbuffer[i].flags=MF_FREE;
if (MO_TIME(meshbuffer[i].pkt)-now>SECS_DAY)
meshbuffer[i].flags=MF_FREE;
};
}; };
}; };
}; };
@ -76,44 +99,29 @@ void mesh_recvloop(void){
}; };
if(MO_TYPE(buf)=='T'){ if(MO_TYPE(buf)=='T'){
time_t toff=MO_TIME(buf)-((getTimer()-(200/SYSTICKSPEED))/(1000/SYSTICKSPEED)); time_t toff=MO_TIME(buf)-((getTimer()+(300/SYSTICKSPEED))/(1000/SYSTICKSPEED));
if (toff>_timet) // Do not live in the past. if (toff>_timet) // Do not live in the past.
_timet = toff; _timet = toff;
continue; continue;
}; };
// Safety: Truncate ascii packets by 0-ing the CRC // Safety: Truncate ascii packets by 0-ing the CRC
if (MO_TYPE(buf) >='A' && MO_TYPE(buf) <='Z'){ buf[MESHPKTSIZE-2]=0;
buf[MESHPKTSIZE-2]=0;
};
// Store packet in a free slot // Store packet in a same/free slot
int free=-1; MPKT* mpkt=meshGetMessage(MO_TYPE(buf));
for(int i=0;i<MESHBUFSIZE;i++){
if ( ((meshbuffer[i].flags&MF_USED)==0) && free<0 )
free=i;
if ( (meshbuffer[i].flags&MF_USED) &&
(MO_TYPE(meshbuffer[i].pkt) == MO_TYPE(buf))){
if ( MO_TIME(buf) >
MO_TIME(meshbuffer[i].pkt)){
free=i;
break;
}else{
free=-2;
break;
};
};
};
if(free==-1){ // Buffer full. Ah well. Kill a random packet // Skip locked packet
free=1; // XXX: GetRandom()? if(mpkt->flags&MF_LOCK)
};
if(free<0)
continue; continue;
memcpy(meshbuffer[free].pkt,buf,MESHPKTSIZE); // only accept newer/better packets
meshbuffer[free].flags=MF_USED; if(mpkt->flags==MF_USED)
if(MO_TIME(buf)<MO_TIME(mpkt->pkt))
continue;
memcpy(mpkt->pkt,buf,MESHPKTSIZE);
mpkt->flags=MF_USED;
}while(getTimer()<recvend || pktctr>MESHBUFSIZE); }while(getTimer()<recvend || pktctr>MESHBUFSIZE);
@ -137,6 +145,8 @@ void mesh_sendloop(void){
for (int i=0;i<MESHBUFSIZE;i++){ for (int i=0;i<MESHBUFSIZE;i++){
if(!meshbuffer[i].flags&MF_USED) if(!meshbuffer[i].flags&MF_USED)
continue; continue;
if(meshbuffer[i].flags&MF_LOCK)
continue;
ctr++; ctr++;
memcpy(buf,meshbuffer[i].pkt,MESHPKTSIZE); memcpy(buf,meshbuffer[i].pkt,MESHPKTSIZE);
status=nrf_snd_pkt_crc_encr(MESHPKTSIZE,buf,meshkey); status=nrf_snd_pkt_crc_encr(MESHPKTSIZE,buf,meshkey);
@ -162,4 +172,3 @@ void mesh_systick(void){
sendctr+=getRandom()%(sendctr*2); sendctr+=getRandom()%(sendctr*2);
}; };
}; };

2
firmware/funk/mesh.h
View File

@ -26,6 +26,7 @@ typedef struct {
#define MF_FREE (0) #define MF_FREE (0)
#define MF_USED (1<<0) #define MF_USED (1<<0)
#define MF_LOCK (1<<1)
extern char meshgen; // Generation extern char meshgen; // Generation
extern MPKT meshbuffer[MESHBUFSIZE]; extern MPKT meshbuffer[MESHBUFSIZE];
@ -35,5 +36,6 @@ void mesh_cleanup(void);
void mesh_recvloop(void); void mesh_recvloop(void);
void mesh_sendloop(void); void mesh_sendloop(void);
void mesh_systick(void); void mesh_systick(void);
MPKT * meshGetMessage(uint8_t type);
#endif #endif

7
firmware/funk/nrf24l01p.c
View File

@ -395,3 +395,10 @@ void nrf_init() {
nrf_write_reg(R_RF_SETUP,DEFAULT_SPEED|R_RF_SETUP_RF_PWR_3); nrf_write_reg(R_RF_SETUP,DEFAULT_SPEED|R_RF_SETUP_RF_PWR_3);
}; };
void nrf_off() {
nrf_write_reg(R_CONFIG,
R_CONFIG_MASK_RX_DR|
R_CONFIG_MASK_TX_DS|
R_CONFIG_MASK_MAX_RT
); // Most important: no R_CONFIG_PWR_UP
};

1
firmware/funk/nrf24l01p.h
View File

@ -138,6 +138,7 @@ int nrf_rcv_pkt_time_encr(int maxtime, int maxsize, uint8_t * pkt, uint32_t cons
char nrf_snd_pkt_crc_encr(int size, uint8_t * pkt, uint32_t const k[4]); char nrf_snd_pkt_crc_encr(int size, uint8_t * pkt, uint32_t const k[4]);
void nrf_init() ; void nrf_init() ;
void nrf_off() ;
void nrf_cmd(uint8_t cmd); void nrf_cmd(uint8_t cmd);
uint8_t nrf_cmd_status(uint8_t cmd); uint8_t nrf_cmd_status(uint8_t cmd);

1
firmware/funk/rftransfer.c
View File

@ -1,6 +1,7 @@
#include "rftransfer.h" #include "rftransfer.h"
#include "nrf24l01p.h" #include "nrf24l01p.h"
#include <basic/basic.h> #include <basic/basic.h>
#include <basic/random.h>
#include <core/systick/systick.h> #include <core/systick/systick.h>
#include <lcd/print.h> #include <lcd/print.h>

1
firmware/lcd/display.c
View File

@ -6,6 +6,7 @@
#include "core/ssp/ssp.h" #include "core/ssp/ssp.h"
#include "gpio/gpio.h" #include "gpio/gpio.h"
#include "basic/basic.h" #include "basic/basic.h"
#include "basic/config.h"
#include "usb/usbmsc.h" #include "usb/usbmsc.h"
/**************************************************************************/ /**************************************************************************/

1
firmware/lcd/display.h
View File

@ -31,4 +31,5 @@ void lcdSafeSetPixel(char x, char y, bool f);
bool lcdGetPixel(char x, char y); bool lcdGetPixel(char x, char y);
void lcdShift(int x, int y, bool wrap); void lcdShift(int x, int y, bool wrap);
void lcdSetContrast(int c); void lcdSetContrast(int c);
void lcdSetInvert();
#endif #endif

23
firmware/lcd/fonts/invaders.c
View File

@ -38,19 +38,18 @@ const uint8_t InvadersBitmaps[] = {
0x9c, /* * *** */ 0x9c, /* * *** */
/* Char 67 is 9px wide @ 23 */ /* Char 67 is 8px wide @ 23 */
0x58, /* * ** */ 0x58, /* * ** */
0xbc, /* * **** */ 0xbc, /* * **** */
0x16, /* * ** */ 0x16, /* * ** */
0x3f, /* ****** */ 0x3f, /* ****** */
0x3f, /* ****** */ 0x3f, /* ****** */
0x36, /* ** ** */ 0x16, /* * ** */
0x1c, /* *** */ 0xbc, /* * **** */
0xb8, /* * *** */ 0x58, /* * ** */
0x40, /* * */
/* Char 80 is 7px wide @ 32 */ /* Char 80 is 7px wide @ 31 */
0xc0, /* ** */ 0xc0, /* ** */
0xec, /* *** ** */ 0xec, /* *** ** */
0x7e, /* ****** */ 0x7e, /* ****** */
@ -60,7 +59,7 @@ const uint8_t InvadersBitmaps[] = {
0xc0, /* ** */ 0xc0, /* ** */
/* Char 85 is 16px wide @ 39 */ /* Char 85 is 16px wide @ 38 */
0x20, /* * */ 0x20, /* * */
0x30, /* ** */ 0x30, /* ** */
0x78, /* **** */ 0x78, /* **** */
@ -79,7 +78,7 @@ const uint8_t InvadersBitmaps[] = {
0x20, /* * */ 0x20, /* * */
/* Char 97 is 11px wide @ 55 */ /* Char 97 is 11px wide @ 54 */
0x9e, /* * **** */ 0x9e, /* * **** */
0x38, /* *** */ 0x38, /* *** */
0x7d, /* ***** * */ 0x7d, /* ***** * */
@ -93,7 +92,7 @@ const uint8_t InvadersBitmaps[] = {
0x9e, /* * **** */ 0x9e, /* * **** */
/* Char 98 is 12px wide @ 66 */ /* Char 98 is 12px wide @ 65 */
0x1c, /* *** */ 0x1c, /* *** */
0x5e, /* * **** */ 0x5e, /* * **** */
0xfe, /* ******* */ 0xfe, /* ******* */
@ -108,7 +107,7 @@ const uint8_t InvadersBitmaps[] = {
0x1c, /* *** */ 0x1c, /* *** */
/* Char 99 is 8px wide @ 78 */ /* Char 99 is 8px wide @ 77 */
0x98, /* * ** */ 0x98, /* * ** */
0x5c, /* * *** */ 0x5c, /* * *** */
0xb6, /* * ** ** */ 0xb6, /* * ** ** */
@ -125,7 +124,7 @@ const uint8_t InvadersBitmaps[] = {
const FONT_CHAR_INFO InvadersLengths[] = { const FONT_CHAR_INFO InvadersLengths[] = {
{11}, /* A */ {11}, /* A */
{12}, /* B */ {12}, /* B */
{ 9}, /* C */ { 8}, /* C */
{ 7}, /* P */ { 7}, /* P */
{16}, /* U */ {16}, /* U */
{11}, /* a */ {11}, /* a */
@ -150,5 +149,5 @@ const struct FONT_DEF Font_Invaders = {
* Name: Invaders * Name: Invaders
* Height: 8 px (1 bytes) * Height: 8 px (1 bytes)
* Maximum width: 16 px * Maximum width: 16 px
* Storage size: 94 bytes (uncompressed) * Storage size: 93 bytes (uncompressed)
*/ */

11
firmware/lcd/print.c
View File

@ -2,6 +2,7 @@
#include <render.h> #include <render.h>
#include <fonts.h> #include <fonts.h>
#include <print.h> #include <print.h>
#include <fonts/smallfonts.h>
int x=0; int x=0;
int y=0; int y=0;
@ -69,3 +70,13 @@ void lcdSetCrsr(int dx,int dy){
void lcdSetCrsrX(int dx){ void lcdSetCrsrX(int dx){
x=dx; x=dx;
}; };
void setSystemFont(void){
setIntFont(&Font_7x8);
};
int lcdGetVisibleLines(void){
return (RESY/getFontHeight()); // subtract title line
};

3
firmware/lcd/print.h
View File

@ -10,4 +10,5 @@ void lcdRefresh();
void lcdMoveCrsr(signed int dx,signed int dy); void lcdMoveCrsr(signed int dx,signed int dy);
void lcdSetCrsr(int dx,int dy); void lcdSetCrsr(int dx,int dy);
void lcdSetCrsrX(int dx); void lcdSetCrsrX(int dx);
void setSystemFont(void);
int lcdGetVisibleLines(void);

6
firmware/lcd/render.c
View File

@ -18,10 +18,10 @@ FIL file; /* current font file */
/* Exported Functions */ /* Exported Functions */
void setIntFont(const struct FONT_DEF * font){ void setIntFont(const struct FONT_DEF * newfont){
memcpy(&efont.def,font,sizeof(struct FONT_DEF)); memcpy(&efont.def,newfont,sizeof(struct FONT_DEF));
efont.type=FONT_INTERNAL; efont.type=FONT_INTERNAL;
font=NULL; font=&efont.def;
}; };
void setExtFont(const char *fname){ void setExtFont(const char *fname){

428
firmware/loadable/spaceinvaders.c
View File

@ -4,8 +4,7 @@
#include "lcd/render.h" #include "lcd/render.h"
#include "lcd/display.h" #include "lcd/display.h"
#include "lcd/fonts/invaders.c" #include "lcd/allfonts.h"
//#include "lcd/allfonts.h"
void ReinvokeISP(void); void ReinvokeISP(void);
void EnableWatchdog(uint32_t ms); void EnableWatchdog(uint32_t ms);
@ -13,51 +12,170 @@ void delayms(uint32_t ms);
/**************************************************************************/ /**************************************************************************/
#define POS_PLAYER_Y 60 #define POS_PLAYER_Y 60
#define POS_UFO_Y 0
#define ENEMY_ROWS 3 #define ENEMY_ROWS 3
#define ENEMY_COLUMNS 6 #define ENEMY_COLUMNS 6
#define DISABLED 255 #define DISABLED 255
#define UFO_PROB 1000
#define TYPE_PLAYER 1 #define TYPE_PLAYER 1
#define TYPE_ALIEN 2 #define TYPE_ENEMY_A 2
#define TYPE_ENEMY_B 3
#define TYPE_ENEMY_C 4
#define TYPE_UFO 5
#define BUNKERS 3
#define BUNKER_WIDTH 10
static const BUNKER_X[] = {15, RESX/2-BUNKER_WIDTH/2,RESX-BUNKER_WIDTH-15};
static const ENEMY_WIDTHS[] = {10,11,8};
struct gamestate { struct gamestate {
char player; char player;
char ufo;
char shot_x, shot_y; char shot_x, shot_y;
char shots_x[ENEMY_COLUMNS];
char shots_y[ENEMY_COLUMNS];
char alive; char alive;
char move, direction, lastcol; char move, direction, lastcol;
bool killed; bool killed;
bool step;
uint32_t score;
char level;
int8_t rokets;
char enemy_x[ENEMY_ROWS][ENEMY_COLUMNS]; char enemy_x[ENEMY_ROWS][ENEMY_COLUMNS];
char enemy_row_y[ENEMY_ROWS]; char enemy_row_y[ENEMY_ROWS];
uint8_t bunker[BUNKERS][BUNKER_WIDTH];
} game = {RESX/2-4, DISABLED, 0,ENEMY_ROWS*ENEMY_COLUMNS, 0, -1, ENEMY_COLUMNS-1, false}; } game;
char key; char key;
void ram(void) {
gpioSetValue (RB_LED1, CFG_LED_OFF);
init_enemy();
while (1) {
if(gpioGetValue(RB_BTN2)==0){
delayms(200);
while(gpioGetValue(RB_BTN0)==0);
return;
}
lcdFill(0); void init_game();
check_end(); void check_end();
move_shot(); void move_ufo();
move_player(); void move_shots();
move_enemy(); void move_player();
draw_player(); void move_enemay();
draw_enemy(); void draw_score();
draw_shot(); void draw_bunker();
draw_status(); void draw_player();
lcdDisplay(); void draw_enemy();
delayms(10); void draw_shots();
} void draw_ufo();
void screen_intro();
void screen_gameover();
void screen_level();
bool check_bunker(char xpos, char ypos, int8_t shift);
void ram(void) {
//gpioSetValue (RB_LED1, CFG_LED_OFF);
//backlightInit();
while(1) {
screen_intro();
game.rokets = 3;
game.level = 1;
init_game();
screen_level();
while (game.rokets>=0) {
////checkISP();
lcdFill(0);
check_end();
move_ufo();
move_shot();
move_shots();
move_player();
move_enemy();
draw_score();
draw_ufo();
draw_bunker();
draw_player();
draw_enemy();
draw_shots();
// draw_status();
lcdDisplay();
delayms(12);
}
screen_gameover();
}
return; return;
} }
void screen_intro() {
char key=0;
while(key==0) {
lcdFill(0);
font = &Font_Invaders;
DoString(28,25,"ABC");
font = &Font_7x8;
DoString (28,40,"SPACE");
DoString (18,50,"INVADERS");
//DoString (20,RESY-24, "Highscore");
DoString (0, 0, "12345");
DoString (0, 9, "iggy");
lcdDisplay();
delayms_queue(50);
key=getInput();
}
}
void screen_gameover() {
char key =0;
while(key==0) {
lcdFill(0);
font = &Font_7x8;
DoString (12,32, "GAME OVER");
DoInt (0,0, game.score);
DoString (0,9,"HIGHSCORE!");
lcdDisplay();
delayms_queue(50);
key=getInput();
}
}
void screen_level() {
lcdFill(0);
draw_score();
font = &Font_7x8;
int dx = DoString(20,32, "Level ");
DoInt(dx,32,game.level);
lcdDisplay();
delayms(500);
}
void init_game(void) {
game.player = RESX/2-4;
game.shot_x = DISABLED;
game.shot_y = 0;
game.alive = ENEMY_ROWS*ENEMY_COLUMNS;
game.move = 0;
game.direction = -1;
game.lastcol = ENEMY_COLUMNS-1;
game.killed = 0;
game.step = false;
game.ufo = DISABLED;
init_enemy();
for (char col=0; col<ENEMY_COLUMNS; col++){
game.shots_x[col] = DISABLED;
}
for (int b=0; b<BUNKERS; b++){
//for (int slice=0; slice<BUNKER_WIDTH; slice++){
// game.bunker[b][slice] = 255<<2;
//}
game.bunker[b][0] = 0b00111100;
game.bunker[b][1] = 0b01111100;
game.bunker[b][2] = 0b11111100;
game.bunker[b][3] = 0b11100000;
game.bunker[b][4] = 0b11100000;
game.bunker[b][5] = 0b11100000;
game.bunker[b][6] = 0b11100000;
game.bunker[b][7] = 0b11111100;
game.bunker[b][8] = 0b01111100;
game.bunker[b][9] = 0b00111100;
}
}
void init_enemy() { void init_enemy() {
for (int row = 0; row<ENEMY_ROWS; row++) { for (int row = 0; row<ENEMY_ROWS; row++) {
game.enemy_row_y[row] = 10 + (40/ENEMY_ROWS)*row; game.enemy_row_y[row] = 10 + (40/ENEMY_ROWS)*row;
@ -67,6 +185,25 @@ void init_enemy() {
} }
} }
bool check_bunker(char xpos, char ypos, int8_t shift){
for (int b=0; b<BUNKERS; b++) {
if (xpos>BUNKER_X[BUNKERS-1-b] &&
xpos<BUNKER_X[BUNKERS-1-b]+BUNKER_WIDTH &&
ypos<RESY-8 &&
ypos>RESY-16) {
int offset = BUNKER_WIDTH - (xpos-BUNKER_X[BUNKERS-1-b]);
if (game.bunker[b][offset]!=0) {
if (shift>0)
game.bunker[b][offset]&=game.bunker[b][offset]<<shift;
else
game.bunker[b][offset]&=game.bunker[b][offset]>>-shift;
return true;
}
}
}
return false;
}
void move_shot() { void move_shot() {
//No shot, do nothing //No shot, do nothing
if(game.shot_x == DISABLED) { if(game.shot_x == DISABLED) {
@ -79,21 +216,114 @@ void move_shot() {
return; return;
} }
//check for collision with bunker
// for (int b=0; b<BUNKERS; b++) {
// if (game.shot_x>BUNKER_X[BUNKERS-1-b] &&
// game.shot_x<BUNKER_X[BUNKERS-1-b]+BUNKER_WIDTH &&
// game.shot_y<RESY-8 &&
// game.shot_y>RESY-16) {
// int offset = BUNKER_WIDTH - (game.shot_x-BUNKER_X[BUNKERS-1-b]);
// if (game.bunker[b][offset]!=0) {
// game.bunker[b][offset]&=game.bunker[b][offset]<<1;
// game.shot_x=DISABLED;
// }
// }
// }
if (check_bunker(game.shot_x,game.shot_y-5,1 ))
game.shot_x=DISABLED;
//check for collision with enemy, kill enemy if //check for collision with enemy, kill enemy if
for (int row=0; row<ENEMY_ROWS; row++) { for (int row=0; row<ENEMY_ROWS; row++) {
if (game.enemy_row_y[row]+6 >= game.shot_y && game.enemy_row_y[row]+6 < game.shot_y+7) { if (game.enemy_row_y[row]+6 >= game.shot_y && game.enemy_row_y[row]+6 < game.shot_y+7) {
for(int col = 0; col<ENEMY_COLUMNS; col++) { for(int col = 0; col<ENEMY_COLUMNS; col++) {
if(game.shot_x >= game.enemy_x[row][col] && game.shot_x < game.enemy_x[row][col]+8) { if(game.shot_x >= game.enemy_x[row][col] && game.shot_x < game.enemy_x[row][col]+ENEMY_WIDTHS[row]) {
game.enemy_x[row][col]=DISABLED; game.enemy_x[row][col]=DISABLED;
game.shot_x = DISABLED; game.shot_x = DISABLED;
game.alive--; game.alive--;
game.score++;
return; return;
} }
} }
} }
} }
//check for collision with ufo
game.shot_y -= 3; if (game.ufo != DISABLED &&
game.shot_x>game.ufo &&
game.shot_x<game.ufo + 16 &&
game.shot_y<8) {
game.ufo = DISABLED;
game.score += 5;
}
game.shot_y -= 2;
}
void move_shots() {
for (char col = 0; col<ENEMY_COLUMNS; col++){
//No shot, maybe generate
if (game.shots_x[col] == DISABLED) {
for (char row = 0; row<ENEMY_ROWS; row++) {
if (game.enemy_x[row][col] != DISABLED) {
if(getRandom()%(game.alive*5)==0) {
game.shots_x[col] = game.enemy_x[row][col]+5;
game.shots_y[col] = game.enemy_row_y[row]+0;
}
}
}
continue;
}
//moving out of bottm, end shot
if (game.shots_y[col] >= RESY) {
game.shots_x[col] = DISABLED;
return;
}
//check for collision with bunker
if (check_bunker(game.shots_x[col],game.shots_y[col],-1))
game.shots_x[col]=DISABLED;
// for (int b=0; b<BUNKERS; b++) {
// if (game.shots_x[col]>BUNKER_X[BUNKERS-1-b] &&
// game.shots_x[col]<BUNKER_X[BUNKERS-1-b]+BUNKER_WIDTH &&
// game.shots_y[col]<RESY-8 &&
// game.shots_y[col]>RESY-16) {
// int offset = BUNKER_WIDTH - (game.shots_x[col]-BUNKER_X[BUNKERS-1-b])-1;
// if (game.bunker[b][offset]!=0) {
// game.bunker[b][offset]&=game.bunker[b][offset]>>1;
// game.shots_x[col]=DISABLED;
// }
// }
// }
//check for collision with player
if (game.shots_y[col] >= RESY-13 &&
game.shots_x[col] > game.player+1 &&
game.shots_x[col] < game.player+6) {
game.killed = true;
}
//move shots down
game.shots_y[col] += 1;
}
}
void move_ufo() {
if (game.ufo == DISABLED) {
if ((getRandom()%UFO_PROB)==0) {
game.ufo = 0;
}
return;
}
if (game.ufo >= RESX){
game.ufo = DISABLED;
return;
}
game.ufo++;
} }
void move_player() { void move_player() {
@ -117,20 +347,40 @@ void move_enemy() {
return; return;
} }
game.step = !game.step;
for (int col = 0; col < ENEMY_COLUMNS; col++) { for (int col = 0; col < ENEMY_COLUMNS; col++) {
for (int row = 0; row < ENEMY_ROWS; row++) { for (int row = 0; row < ENEMY_ROWS; row++) {
char pos = game.enemy_x[row][(game.direction==1)?(ENEMY_COLUMNS-(col+1)):col]; char pos = game.enemy_x[row][(game.direction==1)?(ENEMY_COLUMNS-(col+1)):col];
if (pos != DISABLED) { if (pos != DISABLED) {
//Check collision with player //Check collision with player
if(game.enemy_row_y[row]+8 >= POS_PLAYER_Y && pos+8 >= game.player && pos < game.player+8){ if((game.enemy_row_y[row]+8 >= POS_PLAYER_Y && pos+8 >= game.player && pos < game.player+8) ||
game.killed = true; game.enemy_row_y[row]+8 >= POS_PLAYER_Y+8) {
for(int row=0; row<ENEMY_ROWS; row++) {
game.enemy_row_y[row] = 10 + (40/ENEMY_ROWS)*row;
}
game.killed = true;
} }
check_bunker(pos,game.enemy_row_y[row]+8,-2);
//check for collision with bunker, dirty
// for (int b=0; b<BUNKERS; b++) {
// if (pos>=BUNKER_X[BUNKERS-1-b] &&
// pos<=BUNKER_X[BUNKERS-1-b]+BUNKER_WIDTH &&
// game.enemy_row_y[row]+8<RESY-8 &&
// game.enemy_row_y[row]+8>RESY-16) {
// int offset = BUNKER_WIDTH - (pos-BUNKER_X[BUNKERS-1-b]);
// if (game.bunker[b][offset]!=0) {
// game.bunker[b][offset]&=game.bunker[b][offset]>>2;
// }
// }
// }
//Are we at the beginning or end? Direction change
if((pos <=0 && game.direction != 1) || if((pos <=0 && game.direction != 1) ||
(pos >=RESX-8-1 && game.direction == 1)){ (pos >=RESX-11-1 && game.direction == 1)){
game.direction = (game.direction==1)?-1:1; game.direction = (game.direction==1)?-1:1;
for (char r = 0; r<ENEMY_ROWS; r++) { for (char r = 0; r<ENEMY_ROWS; r++) {
game.enemy_row_y[r]+=4; game.enemy_row_y[r]+=2;
} }
return; return;
} }
@ -142,55 +392,47 @@ void move_enemy() {
game.move = game.alive-1; game.move = game.alive-1;
} }
void move_enemy2() {
if(game.move == 0) {
bool next = false;
for (int col = game.lastcol; col < ENEMY_COLUMNS || col <= 0; col+=game.direction) {
for (int row = 0; row < ENEMY_ROWS; row++) {
char pos = game.enemy_x[row][col];
//There is an enemy on this row
if (pos != DISABLED) {
if((pos <=0 && game.direction== -1) ||
(pos >=RESX-8 && game.direction == 1)){
game.direction *= -1;
//TODOmove down
return;
}
game.enemy_x[row][col] += game.direction;
next = true;
}
}
if (next){
game.lastcol += game.direction;
return;
}
}
game.move = game.alive;
return;
}
game.move--;
}
void draw_player() { void draw_player() {
//draw_sprite(50, 20); //draw_sprite(50, 20);
draw_sprite(TYPE_PLAYER,game.player, POS_PLAYER_Y); draw_sprite(TYPE_PLAYER, game.player, POS_PLAYER_Y);
}
void draw_ufo() {
if (game.ufo!=DISABLED)
draw_sprite(TYPE_UFO, game.ufo, POS_UFO_Y);
} }
void draw_enemy() { void draw_enemy() {
for (int row = 0; row<ENEMY_ROWS; row++) { for (int row = 0; row<ENEMY_ROWS; row++) {
for (int col = 0; col<ENEMY_COLUMNS; col++) { for (int col = 0; col<ENEMY_COLUMNS; col++) {
if (game.enemy_x[row][col] != DISABLED) { if (game.enemy_x[row][col] != DISABLED) {
draw_sprite(TYPE_ALIEN,game.enemy_x[row][col],game.enemy_row_y[row]); draw_sprite(TYPE_ENEMY_A+row,game.enemy_x[row][col],game.enemy_row_y[row]);
} }
} }
} }
} }
void draw_shot() { void draw_bunker() {
for (int b=0; b<BUNKERS; b++) {
memcpy(lcdBuffer+(RESX*1+BUNKER_X[b]),game.bunker+b,BUNKER_WIDTH);
}
}
void draw_shots() {
if (game.shot_x != 255) { if (game.shot_x != 255) {
for (int length=0; length<=5; length++) { for (int length=0; length<=5; length++) {
lcdSetPixel(game.shot_x, game.shot_y+length, true); lcdSetPixel(game.shot_x, game.shot_y+length, true);
} }
} }
for (char col = 0; col < ENEMY_COLUMNS; col++) {
if (game.shots_x[col] != DISABLED) {
for (int length=0; length<=5; length++) {
lcdSetPixel(game.shots_x[col], game.shots_y[col]+length,true);
}
}
}
} }
void draw_status() { void draw_status() {
@ -198,27 +440,53 @@ void draw_status() {
lcdSetPixel(p+1,1,true); lcdSetPixel(p+1,1,true);
} }
} }
void draw_sprite(char type, char x, char y) { void draw_sprite(char type, char x, char y) {
font = &Font_Invaders; font = &Font_Invaders;
if(type==TYPE_PLAYER){ switch(type) {
DoChar(x,y-1,'P'); case TYPE_PLAYER:
}else{ DoChar(x,y-1,'P');
DoChar(x,y-1,'C'); break;
}; case TYPE_ENEMY_A:
DoChar(x,y-1,game.step?'a':'A');
break;
case TYPE_ENEMY_B:
DoChar(x,y-1,game.step?'b':'B');
break;
case TYPE_ENEMY_C:
DoChar(x,y-1,game.step?'c':'C');
break;
case TYPE_UFO:
DoChar(x,y-1,'U');
break;
}
} }
void draw_score() {
font = &Font_7x8;
DoInt(0,0,game.score);
DoInt(RESX-8,0,game.rokets);
font = &Font_Invaders;
DoChar(RESX-16, 0, 'P');
}
void check_end() { void check_end() {
if (game.killed) { if (game.killed) {
game.rokets--;
delayms(500);
game.player = RESX/2+4; game.player = RESX/2+4;
for(int row; row<ENEMY_ROWS; row++) {
game.enemy_row_y[row] = 10 + (40/ENEMY_ROWS)*row; for(int col=0; col<ENEMY_COLUMNS; col++) {
} game.shots_x[col] = DISABLED;
}
game.killed = false; game.killed = false;
} }
if (game.alive == 0) { if (game.alive == 0) {
delayms(500);
game.level++;
init_game();
screen_level();
} }
} }

1
firmware/main.c
View File

@ -5,6 +5,7 @@
#include "basic/basic.h" #include "basic/basic.h"
#include "lcd/render.h" #include "lcd/render.h"
#include "filesystem/ff.h"
/**************************************************************************/ /**************************************************************************/

76
simulat0r/bin/test-all.sh Executable file
View File

@ -0,0 +1,76 @@
#!/bin/sh
#
# test-all.sh
# Build all applications as firmware and simulat0r
# Results are saved as /tmp/firmware-appname.bin-buildtag or /tmp/qsimulat0r-...
# Call prefixed with BUILD="-myowntag" to replace default timestamp based build tag
# Setting BUILD empty suppresses the build tag
# Use TARGET=firmware or TARGET=simulat0r to limit compilation
# When building both targets and the firmware build failed the simulat0r build is skipped
#
if test ! -v BUILD; then
BUILD=-`date --iso-8601=seconds`
echo Setting BUILD to $BUILD
fi
if test ! -v TARGET; then
BUILDFIRMWARE=1
BUILDSIM=1
else
case $TARGET in
both |all ) BUILDFIRMWARE=1; BUILDSIM=1;;
firmware | firm ) BUILDFIRMWARE=1; BUILDSIM=0;;
simulat0r | simulator | sim ) BUILDFIRMWARE=0; BUILDSIM=1;;
*) echo "Cannot build unknow target \"$TARGET\""; exit 1;;
esac
fi
echo -n "Building "
if test $BUILDFIRMWARE -eq 1; then
echo -n "firmware "
fi
if test $BUILDSIM -eq 1; then
echo -n "simulat0r "
fi
echo
function doTest()
{
APP=$1
FIRMWARESUCCESS=1
if test $BUILDFIRMWARE -eq 1; then
if make -C firmware APP=$APP 2>/dev/null >/dev/null
then
TMPFILE=/tmp/firmware-$APP.bin$BUILD
echo OK $APP as $TMPFILE
cp firmware/firmware.bin $TMPFILE
else
echo FIRMWARE BUILD FAILED $APP
FIRMWARESUCCESS=0
fi
fi
if test $FIRMWARESUCCESS -eq 1 -a $BUILDSIM -eq 1; then
if make -C simulat0r APP=$APP 2>/dev/null >/dev/null
then
TMPFILE=/tmp/qsimulat0r-$APP$BUILD
echo OK $APP as $TMPFILE
cp simulat0r/gui/build/qsimulat0r $TMPFILE
else
echo SIMULAT0R BUILD FAILED $APP
fi
fi
}
echo "Testing all applications..."
for i in `find firmware/applications/ -iname \*.c | sort`
do
if grep -q main_ $i
then
APP=`basename $i | sed "s/\..*//"`
doTest $APP
fi
done

8
simulat0r/firmware/Makefile.inc
View File

@ -23,6 +23,8 @@ CC = $(CROSS_COMPILE)gcc
LD = $(CROSS_COMPILE)ld LD = $(CROSS_COMPILE)ld
REALLD = $(CROSS_COMPILE)ld REALLD = $(CROSS_COMPILE)ld
SIZE = $(CROSS_COMPILE)size SIZE = $(CROSS_COMPILE)size
AR = $(CROSS_COMPILE)ar
RANLIB = $(CROSS_COMPILE)ranlib
OBJCOPY = $(CROSS_COMPILE)objcopy OBJCOPY = $(CROSS_COMPILE)objcopy
OBJDUMP = $(CROSS_COMPILE)objdump OBJDUMP = $(CROSS_COMPILE)objdump
OUTFILE = firmware OUTFILE = firmware
@ -44,6 +46,12 @@ endif
CFLAGS = -std=c99 -c -g -O0 $(INCLUDE_PATHS) -Wall -funsigned-char -ffunction-sections -fdata-sections -fmessage-length=0 -DRAMCODE=$(RAMCODE) -fno-builtin -DSIMULATOR -I$(ROOT_PATH)/../simcore -include libc-unc0llide.h $(CONFIG_GCC_SHOWCOLUMN) CFLAGS = -std=c99 -c -g -O0 $(INCLUDE_PATHS) -Wall -funsigned-char -ffunction-sections -fdata-sections -fmessage-length=0 -DRAMCODE=$(RAMCODE) -fno-builtin -DSIMULATOR -I$(ROOT_PATH)/../simcore -include libc-unc0llide.h $(CONFIG_GCC_SHOWCOLUMN)
#LDFLAGS = -nostartfiles #LDFLAGS = -nostartfiles
ifeq ($(shell uname), Darwin)
# Mac OS X provides a stdio.h with unwanted defines
CFLAGS += -D_FORTIFY_SOURCE=0
# ld64 has problems with common symbols <rdar://problem/9870713>, apply a workaround
RANLIBFLAGS = -c
endif
CONFIG_MAKE_PRINTDIRECTORY = --no-print-directory CONFIG_MAKE_PRINTDIRECTORY = --no-print-directory
CONFIG_GCC_SHOWCOLUMN = CONFIG_GCC_SHOWCOLUMN =

2
simulat0r/firmware/applications/inputtest.c Normal file
View File

@ -0,0 +1,2 @@
/* AUTOGENERATED SOURCE FILE */
#include "../../../firmware/applications/inputtest.c"

2
simulat0r/firmware/applications/mesh/config.c Normal file
View File

@ -0,0 +1,2 @@
/* AUTOGENERATED SOURCE FILE */
#include "../../../../firmware/applications/mesh/config.c"

2
simulat0r/firmware/applications/mesh/mesh.c Normal file
View File

@ -0,0 +1,2 @@
/* AUTOGENERATED SOURCE FILE */
#include "../../../../firmware/applications/mesh/mesh.c"

2
simulat0r/firmware/applications/mesh/util.c Normal file
View File

@ -0,0 +1,2 @@
/* AUTOGENERATED SOURCE FILE */
#include "../../../../firmware/applications/mesh/util.c"

2
simulat0r/firmware/applications/mesh/uuid.c Normal file
View File

@ -0,0 +1,2 @@
/* AUTOGENERATED SOURCE FILE */
#include "../../../../firmware/applications/mesh/uuid.c"

2
simulat0r/firmware/basic/config.h Normal file
View File

@ -0,0 +1,2 @@
/* AUTOGENERATED SOURCE FILE */
#include "../../../firmware/basic/config.h"

2
simulat0r/firmware/basic/simpletime.c Normal file
View File

@ -0,0 +1,2 @@
/* AUTOGENERATED SOURCE FILE */
#include "../../../firmware/basic/simpletime.c"

2
simulat0r/firmware/basic/simpletime.h Normal file
View File

@ -0,0 +1,2 @@
/* AUTOGENERATED SOURCE FILE */
#include "../../../firmware/basic/simpletime.h"

2
simulat0r/firmware/basic/stringin.c Normal file
View File

@ -0,0 +1,2 @@
/* AUTOGENERATED SOURCE FILE */
#include "../../../firmware/basic/stringin.c"

2
simulat0r/firmware/funk/mesh.c Normal file
View File

@ -0,0 +1,2 @@
/* AUTOGENERATED SOURCE FILE */
#include "../../../firmware/funk/mesh.c"

2
simulat0r/firmware/funk/mesh.h Normal file
View File

@ -0,0 +1,2 @@
/* AUTOGENERATED SOURCE FILE */
#include "../../../firmware/funk/mesh.h"

11
simulat0r/gui/qsimulat0r.cc
View File

@ -19,6 +19,7 @@ using namespace std;
extern "C" { extern "C" {
#include "basic/basic.h" #include "basic/basic.h"
#include "basic/config.h"
#include "lcd/backlight.h" #include "lcd/backlight.h"
#define lcdGetPixel __hideaway_lcdGetPixel #define lcdGetPixel __hideaway_lcdGetPixel
@ -92,15 +93,15 @@ public:
pixmap.setPixel(1,1,(QColor(backlight,backlight,backlight).rgb())); pixmap.setPixel(1,1,(QColor(backlight,backlight,backlight).rgb()));
pixmap.fill(pixmap.pixel(1,1)); pixmap.fill(pixmap.pixel(1,1));
const int pixelOn=GLOBAL(lcdinvert)?colorInvertedPixelOn:colorPixelOn;
const int pixelOff=GLOBAL(lcdinvert)?colorInvertedPixelOff:colorPixelOff;
// draw lcd array // draw lcd array
for (int x = 0; x < dimx; ++x) { for (int x = 0; x < dimx; ++x) {
for(int y=0; y<dimy; ++y) { for(int y=0; y<dimy; ++y) {
int color; int color;
if(globalconfig.lcdstate & LCD_INVERTED) { color=lcdGetPixel((GLOBAL(lcdmirror) /* LCD_MIRRORX */ )?(RESX-x-1):x,( 0 /* LCD_MIRRORY */)?(RESY-y-1):y)?pixelOn:pixelOff;
color=lcdGetPixel((globalconfig.lcdstate & LCD_MIRRORX)?(RESX-x-1):x,(globalconfig.lcdstate & LCD_MIRRORY)?(RESY-y-1):y)?colorInvertedPixelOn:colorInvertedPixelOff;
} else {
color=lcdGetPixel((globalconfig.lcdstate & LCD_MIRRORX)?(RESX-x-1):x,(globalconfig.lcdstate & LCD_MIRRORY)?(RESY-y-1):y)?colorPixelOn:colorPixelOff;
}
for(int minix=0; minix<pixw; ++minix) { for(int minix=0; minix<pixw; ++minix) {
for(int miniy=0; miniy<pixh; ++miniy) { for(int miniy=0; miniy<pixh; ++miniy) {
pixmap.setPixel(x*rasterx+minix,ledsize+ledsep+y*rastery+miniy,color); pixmap.setPixel(x*rasterx+minix,ledsize+ledsep+y*rastery+miniy,color);

8
simulat0r/tui/Makefile
View File

@ -9,11 +9,8 @@ CFLAGS += -I../simcore
OBJS+= ../firmware/basic/*.o OBJS+= ../firmware/basic/*.o
OBJS+= ../firmware/core/*.o OBJS+= ../firmware/core/*.o
OBJS+= ../firmware/core/*/*.o OBJS+= ../firmware/core/*/*.o
LDFLAGS+= -L../firmware/applications
LIBS+= ../firmware/applications/libapp.a LIBS+= ../firmware/applications/libapp.a
LDFLAGS+= -L../firmware/lcd
LIBS+= ../firmware/lcd/liblcd.a LIBS+= ../firmware/lcd/liblcd.a
LDFLAGS+= -L../firmware/usb
LIBS+= ../firmware/usb/libusb.a LIBS+= ../firmware/usb/libusb.a
#LIBS += -lm #LIBS += -lm
@ -27,10 +24,13 @@ LIBS += ../firmware/basic/libbasic.a
OBJS+=../simcore/simcore.o ../simcore/misc.o ../simcore/timecounter.o OBJS+=../simcore/simcore.o ../simcore/misc.o ../simcore/timecounter.o
OBJS += simulat0r.o
.PHONY : all .PHONY : all
all : simulat0r all : simulat0r
simulat0r : simulat0r.o $(OBJS) $(LIBS) simulat0r : $(OBJS) $(LIBS)
$(LD) $(OBJS) $(LIBS) -lc -o $@
clean: clean:
$(RM) simulat0r.o $(RM) simulat0r.o

10
simulat0r/tui/simulat0r.c
View File

@ -1,18 +1,18 @@
#include "simulator.h" #include "simulator.h"
#include "../firmware/basic/basic.h" #include "../firmware/basic/basic.h"
#include "../firmware/basic/config.h"
#include "../firmware/lcd/display.h" #include "../firmware/lcd/display.h"
#include <unistd.h> #include <unistd.h>
void simlcdDisplayUpdate() { void simlcdDisplayUpdate() {
write(1,"\033[H",3); write(1,"\033[H",3);
const char* symbolOff=GLOBAL(lcdinvert)?"_":"@";
const char* symbolOn=GLOBAL(lcdinvert)?"#":".";
for(int y=0; y<RESY; ++y) { for(int y=0; y<RESY; ++y) {
for(int x=0; x<RESX; ++x) { for(int x=0; x<RESX; ++x) {
if(globalconfig.lcdstate & LCD_INVERTED) { write(1,(lcdGetPixel((GLOBAL(lcdmirror) /* LCD_MIRRORX */ )?(RESX-x-1):x,(0 /* & LCD_MIRRORY */)?(RESY-y-1):y)?symbolOn:symbolOff),1);
write(1,(lcdGetPixel((globalconfig.lcdstate & LCD_MIRRORX)?(RESX-x-1):x,(globalconfig.lcdstate & LCD_MIRRORY)?(RESY-y-1):y)?"#":"_"),1);
} else {
write(1,(lcdGetPixel((globalconfig.lcdstate & LCD_MIRRORX)?(RESX-x-1):x,(globalconfig.lcdstate & LCD_MIRRORY)?(RESY-y-1):y)?".":"@"),1);
}
} }
write(1,("\n"),1); write(1,("\n"),1);
} }

16
tools/font/bdf/invaders.xbdf
View File

@ -41,14 +41,14 @@ ENDCHAR
STARTCHAR alien3-1 STARTCHAR alien3-1
ENCODING 67 ENCODING 67
XBITMAP XBITMAP
...xx.... ...xx...
..xxxx... ..xxxx..
.xxxxxx.. .xxxxxx.
xx.xx.xx. xx.xx.xx
xxxxxxxx. xxxxxxxx
.x.xxx.x. .x.xx.x.
x.......x x......x
.x.....x. .x....x.
ENDCHAR ENDCHAR
STARTCHAR alien1-2 STARTCHAR alien1-2

BIN
tools/font/binary/invaders.f0n
View File

Binary file not shown.