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:
Stefan `Sec` Zehl 2011-08-11 09:25:03 +02:00
parent 0acd7a78e2 de266e50b4
commit 7cbc87b3a6
4 changed files with 773 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

290
firmware/l0dable/leiwand.c Normal file
View File

@ -0,0 +1,290 @@
#include <sysinit.h>
#include "basic/basic.h"
//#include "lcd/render.h"
//#include "lcd/display.h"
//#include "lcd/allfonts.h"
//#include "lcd/backlight.h"
//#include "lcd/print.h"
#include "usetable.h"
//void backlightInit(void);
void incBacklight(void);
void decBacklight(void);
void paintLogo(bool);
void leiwandDisplay(void);
/**************************************************************************/
#include "leiwand.h"
/**************************************************************************/
void ram(void) {
int key;
while (1) {
leiwandDisplay();
// Exit on enter+left
key=getInputRaw();
if(key== BTN_ENTER + BTN_LEFT)
return;
}
return;
}
void leiwandInit(void) {
paintLogo(false);
delayms(200);
DoString(0,0,"Boot...");
lcdDisplay();
delayms(1000);
}
void leiwandDisplay(void) {
int dx=0;
char key = 0;
//backlightInit();
int i;
int j;
char str[] = "LeiwandVille";
char msg[] = " Just cool! ";
#define msglen 12
int pos[msglen];
int dir[msglen];
int round = 0;
bool upPressed=false;
bool rightPressed=false;
bool downPressed=false;
int demoround = 0;
//lcdToggleFlag(LCD_INVERTED);
for(i = 0; i < msglen; i++) {
pos[i] = 1 + (i * 2);
dir[i] = 0;
}
while (1) {
lcdDisplay();
delayms(20);
key= getInputRaw();
// Easy flashing
if((key&(BTN_ENTER|BTN_LEFT))==(BTN_ENTER|BTN_LEFT)){
//DoString(0,8,"Enter ISP!");
//lcdDisplay();
//ISPandReset();
return;
}
/*
// INVERT
if(((key&(BTN_RIGHT))==(BTN_RIGHT))){
if(!rightPressed) {
lcdToggleFlag(LCD_INVERTED);
}
rightPressed = true;
} else {
rightPressed = false;
}
*/
// BRIGHTER
if(((key&(BTN_UP))==(BTN_UP))){
if(!upPressed) {
incBacklight();
}
upPressed = true;
} else {
upPressed = false;
}
// DARKER
if(((key&(BTN_DOWN))==(BTN_DOWN))){
if(!downPressed) {
decBacklight();
}
downPressed = true;
} else {
downPressed = false;
}
round++;
if(round > 200) {
round = 0;
if(demoround == 1) {
paintLogo(true);
} else {
paintLogo(false);
delayms(1000);
}
demoround++;
}
if(demoround == 4) {
demoround = 0;
}
for(i = 0; i < msglen; i++) {
if(dir[i] == 1) {
if(pos[i] >= 30) {
dir[i] = 0;
} else {
pos[i]++;
}
} else {
if(pos[i] == 0) {
dir[i] = 1;
} else {
pos[i]--;
}
}
}
lcdFill(0);
//font=&Font_7x8;
for(i = 0; i < msglen; i++) {
if(str[i] != 32) {
dx=DoChar(i*8, pos[i], str[i]);
}
}
if(round < 100) {
// Second line of message
for(i = 0; i < msglen; i++) {
if(msg[i] != 32) {
dx=DoChar(i*8, 15+pos[i], msg[i]);
}
}
} else {
// INVADERS
//font = &Font_Invaders;
for(i = 2; i < 10; i+= 2) {
dx=DoChar(i*8, 15+pos[i], 'x');
}
}
//font=&Font_7x8;
if(round < 50) {
dx=DoString(0, 60, " Visit us! ");
} else if(round < 100) {
dx=DoString(0, 60, " We are ");
} else if(round < 150) {
dx=DoString(0, 60, " next to the ");
} else {
dx=DoString(0, 60, " phone booth ");
if((round % 6) < 3) {
for(i = 0; i < 96; i++) {
for(j = 0; j < 8; j++) {
lcdSetPixel(i, j+60, !lcdGetPixel(i, j+60));
}
}
}
}
/*
if(key&BTN_ENTER){
lcdPrintInt(ctr++);
lcdPrintln(".");
while(getInputRaw())delayms(10);
};
if(key&BTN_RIGHT){
lcdShift(1,0,wrap);
}
if(key&BTN_LEFT){
lcdShift(-1,0,wrap);
}
if(key&BTN_UP){
lcdShift(0,1,wrap);
}
if(key&BTN_DOWN){
lcdShift(0,-1,wrap);
}
*/
//font = &Font_Ubuntu36pt;
}
return;
}
void tick_scroll(void){
return;
};
void incBacklight(void) {
/*
uint32_t brightness = backlightGetBrightness();
if (brightness < 100) {
backlightSetBrightness(brightness + 10);
}
*/
return;
}
void decBacklight(void) {
/*
uint32_t brightness = backlightGetBrightness();
if (brightness > 0) {
backlightSetBrightness(brightness - 10);
}
*/
return;
}
void paintLogo(bool animate) {
int i;
int j;
int t;
uint8_t pixel;
int bc = 8;
int next = 0;
int mask = 1;
lcdFill(0);
lcdDisplay();
for(i = 0; i < 68; i++) {
for(j = 0; j < 68; j++) {
if(bc == 8) {
mask = 1;
bc = 0;
pixel = lv_logo[next];
next++;
}
if((pixel & mask) > 0) {
lcdSetPixel(14+j, i, true);
} else {
lcdSetPixel(14+j, i, false);
}
bc++;
mask = mask << 1;
pixel >> 2;
}
//lcdDisplay();
}
lcdDisplay();
if(!animate) {
return;
}
/*
for(i = 0; i < 30; i++) {
delayms(20);
}
*/
for(t=0; t < 8; t++) {
for(i=0; i < 96; i++) {
for(j=0; j < 68; j++) {
lcdSetPixel(i, j, !lcdGetPixel(i,j));
}
lcdDisplay();
}
}
/*
for(i = 0; i < 50; i++) {
delayms(20);
}
*/
return;
}

70
firmware/l0dable/leiwand.h Normal file
View File

@ -0,0 +1,70 @@
uint8_t lv_logo[] = {
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,192,1,
0,0,0,0,0,0,128,63,0,
0,0,0,0,0,0,255,3,
0,0,0,0,0,0,255,95,0,
0,0,0,0,0,254,248,13,
0,0,0,0,0,254,3,159,0,
0,0,0,0,254,29,240,17,
0,0,0,0,252,131,1,31,1,
0,0,0,252,29,16,240,33,
0,0,0,252,131,1,1,31,2,
0,0,64,31,24,16,248,65,
0,0,0,224,129,129,193,31,4,
0,0,31,30,24,56,255,67,
0,0,252,231,129,129,255,61,4,
0,224,255,31,56,254,129,71,
0,0,255,255,129,255,3,120,4,
0,248,128,63,254,3,31,79,
0,192,247,224,255,3,248,243,4,
0,254,15,254,3,159,127,94,
0,224,255,240,3,248,251,199,5,
0,255,199,3,158,63,255,124,
0,240,63,4,248,251,247,143,7,
128,255,129,130,63,255,126,120,
0,248,0,0,248,247,207,129,3,
192,31,48,4,255,254,0,1,
0,252,255,231,240,207,3,0,0,
192,255,127,14,254,0,0,0,
0,254,255,113,193,3,0,0,0,
224,255,255,3,0,0,0,56,
0,0,255,63,2,0,0,240,7,
0,192,255,1,0,0,16,99,
0,0,224,7,2,0,8,49,4,
0,0,0,0,0,192,17,99,
0,0,0,0,0,24,60,49,6,
0,0,0,0,128,67,23,51,
0,0,0,0,96,60,228,241,1,
0,0,0,48,70,70,28,3,
0,0,0,8,39,100,132,1,0,
0,0,152,121,226,79,0,0,
0,0,136,153,54,198,0,0,6,
0,240,152,201,51,0,0,60,
0,0,131,241,28,1,0,192,0,
64,176,24,135,1,0,48,12,
0,4,143,113,0,0,4,195,7,
64,48,24,2,0,64,48,12,
0,4,131,1,0,100,4,195,0,
64,240,0,0,64,70,48,124,
0,60,3,0,48,102,4,203,0,
192,1,0,0,35,70,240,0,
0,0,0,0,96,99,60,0,0,
0,0,0,0,54,198,0,0,
0,0,0,0,192,97,0,0,0,
0,0,0,0,28,0,0,0,
0,0,0,0,128,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,
0x0};

194
firmware/l0dable/snake.c Normal file
View File

@ -0,0 +1,194 @@
#include <sysinit.h>
#include "basic/basic.h"
#include "basic/config.h"
#include "lcd/lcd.h"
#include "lcd/print.h"
#include "usetable.h"
struct elem
{
int x,y;
};
void reset(struct elem snake[],size_t *snake_size,int *dirc,
int*speed, int*points,int*point_s);
void o_rectangle (int x0, int y0, int width, int height);
struct elem rnd(void);
#define MAX_SNAKE_LEN (40)
#define SNAKE_DEM (3)
#define MIN_SPEED (25)
#define MAX_SPEED (3)
#define SIZE_X (RESX)
#define SIZE_Y (RESY)
void ram(void)
{
int inpt,dirc,c,grows = 0,dx,dy,points,point_s=1;
size_t n = 0, snake_size = 5, speed=MIN_SPEED;
struct elem snake[MAX_SNAKE_LEN], food;
char test[512]; /* scratch space */
o_init (test, sizeof(test));
reset(snake,&snake_size,&dirc,&speed,&points,&point_s);
food = rnd();
while (1)
{
head:
if(!(++c % speed))
{
inpt = getInputRaw();
dx=DoString(0,0,IntToStrX(points,2));
dx=(SIZE_X-dx)/2;
if(dx<0)
dx=0;
dy=(SIZE_Y-getFontHeight())/2;
lcdFill(255);
o_rectangle(1,0,SIZE_X-2,SIZE_Y-2);
o_set_gray (0);
o_fill ();
//o_identity (); /* reset tranforms */
o_set_gray (50);
setExtFont("UBUNTU29");
lcdSetPixel(1,1,1);
DoString(dx,dy,IntToStrX(points,2));
o_set_gray (255);
for(n=0;n<snake_size;++n)
{
o_rectangle
(snake[n].x*SNAKE_DEM,snake[n].y*SNAKE_DEM,SNAKE_DEM,SNAKE_DEM); /*
fill background with black */
o_fill (); /* fill with 50% {
reset(snake,&snake_size);
goto head;
}gray */
}
o_rectangle
(food.x*SNAKE_DEM,food.y*SNAKE_DEM,SNAKE_DEM,SNAKE_DEM); /* fill
background with black */
o_fill ();
lcdDisplay();
if (inpt == BTN_UP && dirc != 1)
{
dirc = 3;
}
else if (inpt == BTN_DOWN && dirc != 3)
{
dirc = 1;
}
else if (inpt == BTN_LEFT && dirc != 0)
{
dirc = 2;
}
else if (inpt == BTN_RIGHT && dirc !=2)
{
dirc = 0;
}
//
struct elem t = snake[snake_size-1];
if(dirc == 0)
++t.x;
else if(dirc == 1)
++t.y;
else if(dirc == 2)
--t.x;
else if(dirc == 3)
--t.y;
if(t.x < 0 || t.y < 0 || t.y > SIZE_Y/SNAKE_DEM-1 ||
t.x > SIZE_X/SNAKE_DEM)
{
reset(snake,&snake_size,&dirc,&speed,&points,&point_s);
goto head;
}
for(n=0;n<snake_size-1;++n)
{
if(snake[n].x == t.x && snake[n].y == t.y)
{
reset(snake,&snake_size,&dirc,&speed,&points,&point_s);
goto head;
}
else if(snake[n].x == food.x && snake[n].y == food.y)
{
grows = 1;
++snake_size;
++points;
if(speed > MAX_SPEED) --speed;
food = rnd();
}
}
if(!grows)
{
for(n=0;n<snake_size-1;++n)
{
snake[n] = snake[n+1];
}
}
else
grows = 0;
snake[snake_size-1] = t;
}
else
delayms(3);
}
}
struct elem rnd(void)
{
struct elem res;
res.x = getRandom() % (SIZE_X/SNAKE_DEM-1) +1;
res.y = getRandom() % (SIZE_Y/SNAKE_DEM-1) + 1;
return res;
}
void reset(struct elem snake[],size_t *snake_size,int *dirc,
int*speed, int*points,int* point_s)
{
size_t n = 0;
for(n=0;n<MAX_SNAKE_LEN;++n)
{ snake[n].x=5;snake[n].y=5; }
*snake_size = 5;
*dirc = 0;
*speed = MIN_SPEED;
*points=0;
*point_s=1;
}
void o_rectangle (int x0, int y0, int width, int height)
{
o_path_new ();
o_move_to (x0, y0);
o_line_to (x0 + width, y0);
o_line_to (x0 + width, y0+height+1);
o_line_to (x0, y0+height+1);
o_close ();
}

219
firmware/l0dable/tedliz.c Normal file
View File

@ -0,0 +1,219 @@
// tedliz
// ======
// a kick ass tetris clone
// code by twobit (c3d2 at pentagon ville)
////////////////////////////////////////////////////////////////////////////////
#include <sysinit.h>
#include <string.h>
#include "basic/basic.h"
#include "basic/config.h"
#include "basic/random.h"
#include "lcd/render.h"
#include "lcd/display.h"
#include "lcd/fonts.h"
#include "lcd/fonts/invaders.h"
#include "funk/mesh.h"
#include "usetable.h"
////////////////////////////////////////////////////////////////////////////////
enum {
GRID_WIDTH = 10,
GRID_HEIGHT = 20,
TICK_LENGTH = 30,
KEY_REPEAT_DELEAY = 5,
STARTING_SPEED = 12
};
// key repeat delay stuff
int key_rep[] = { 0, 0, 0, 0, 0 };
int ticks_per_drop = STARTING_SPEED;
int lines = 0;
int ticks = 0;
int rot;
int stone;
int next_rot;
int next_stone;
int x_pos;
int y_pos;
uint8_t grid[GRID_HEIGHT][GRID_WIDTH];
const uint8_t stones[7][16] = {
{ 0, 0, 0, 0, 0,15,15, 0, 0,15,15, 0, 0, 0, 0, 0 },
{ 0, 0,10, 0, 5, 5,15, 5, 0, 0,10, 0, 0, 0,10, 0 },
{ 0, 0, 5, 0, 0, 0,15,15, 0,10,10, 5, 0, 0, 0, 0 },
{ 0, 0, 0, 5, 0,10,15, 5, 0, 0,15,10, 0, 0, 0, 0 },
{ 0, 4, 5, 8, 0,10,15,10, 0, 2, 5, 1, 0, 0, 0, 0 },
{ 0, 8, 5, 1, 0,10,15,10, 0, 4, 5, 2, 0, 0, 0, 0 },
{ 0, 0,11, 0, 0,13,15, 7, 0, 0,14, 0, 0, 0, 0, 0 }
};
void draw_grid();
void new_stone();
int collision(int top_also);
void ram() {
int raw_key, key;
int i, j;
new_stone();
new_stone();
// epmty grid
for(i = 0; i < GRID_HEIGHT; i++)
for(j = 0; j < GRID_WIDTH; j++)
grid[i][j] = 0;
// prepare screen
lcdClear();
for(i = 0; i < 96; i++) {
lcdSetPixel(i, 2, 1);
lcdSetPixel(i, 65, 1);
}
for(i = 3; i < 65; i++) {
lcdSetPixel(2, i, 1);
lcdSetPixel(35, i, 1);
lcdSetPixel(93, i, 1);
}
for(;;) {
// handle input
raw_key = getInputRaw();
key = 0;
for(i = 0; i < 5; i++) {
if(raw_key & (1 << i)) {
if(!key_rep[i] || key_rep[i] == KEY_REPEAT_DELEAY) key |= 1 << i;
key_rep[i] += key_rep[i] < KEY_REPEAT_DELEAY;
}
else key_rep[i] = 0;
}
// rotate
if(key & BTN_UP) {
i = rot;
rot = (rot << 1) % 15;
if(collision(0)) rot = i;
}
// horizontal movement
i = x_pos;
x_pos += !!(key & BTN_RIGHT) - !!(key & BTN_LEFT);
if(i != x_pos && collision(0)) x_pos = i;
// vertical movement
ticks++;
if(key & BTN_DOWN || ticks >= ticks_per_drop) {
ticks = 0;
y_pos++;
if(collision(0)) {
y_pos--;
// check for game over
if(collision(1)) return;
// copy stone to grid
int x, y;
for(y = 0; y < 4; y++) {
for(x = 0; x < 4; x++) {
if(stones[stone][(x << 2) + y] & rot)
grid[y + y_pos][x + x_pos] = 1;
}
}
// check for complete lines
for(y = 0; y < GRID_HEIGHT; y++) {
for(x = 0; x < GRID_WIDTH; x++)
if(!grid[y][x]) break;
if(x == GRID_WIDTH) {
lines++;
ticks_per_drop = STARTING_SPEED - lines / 10;
if(ticks_per_drop < 1) ticks_per_drop = 1;
for(i = y; i > 0; i--)
for(x = 0; x < GRID_WIDTH; x++)
grid[i][x] = grid[i - 1][x];
}
}
// get a new stone
new_stone();
}
}
draw_grid();
lcdDisplay();
delayms(TICK_LENGTH);
}
return;
}
int collision(int top_also) {
int x, y;
for(y = 0; y < 4; y++) {
for(x = 0; x < 4; x++) {
if(stones[stone][(x << 2) + y] & rot && (
x + x_pos < 0 || x + x_pos >= GRID_WIDTH ||
(top_also && y + y_pos < 0) || y + y_pos >= GRID_HEIGHT ||
grid[y + y_pos][x + x_pos]))
return 1;
}
}
return 0;
}
void new_stone() {
x_pos = 3;
y_pos = -3;
rot = next_rot;
stone = next_stone;
next_rot = 1 << getRandom() % 4;
next_stone = getRandom() % 7;
}
void draw_block(int x, int y, int b) {
lcdSetPixel(0 + x, 0 + y, b);
lcdSetPixel(1 + x, 0 + y, b);
lcdSetPixel(2 + x, 0 + y, b);
lcdSetPixel(0 + x, 1 + y, b);
lcdSetPixel(1 + x, 1 + y, b);
lcdSetPixel(2 + x, 1 + y, b);
lcdSetPixel(0 + x, 2 + y, b);
lcdSetPixel(1 + x, 2 + y, b);
lcdSetPixel(2 + x, 2 + y, b);
}
void draw_grid() {
int b, y, x;
for(y = 0; y < GRID_HEIGHT; y++) {
for(x = 0; x < GRID_WIDTH; x++) {
b = grid[y][x] ||
(x >= x_pos && x < x_pos + 4 && y >= y_pos && y < y_pos + 4 &&
stones[stone][((x - x_pos) << 2) + (y - y_pos)] & rot);
draw_block(4 + x * 3, 4 + y * 3, b);
}
}
// look adhead
for(y = 0; y < 4; y++)
for(x = 0; x < 4; x++)
draw_block(40 + x * 3, 7 + y * 3, !!(stones[next_stone][(x << 2) + y] & next_rot));
}