Arduino Game Boy (4 / 4 paso)

Paso 4: Programar tu Arduino Gameboy

#include < LiquidCrystal.h >
LiquidCrystal pantalla
inicializar la biblioteca con los números de los pines de interfaz
LiquidCrystal lcd (12, 11, 5, 4, 3, 2);

Potenciómetro de volante
const int POTPIN = 1;
const int MAXPOT = 800; no hay necesidad de girar la rueda hasta 1023 :)

Altavoz piezoeléctrico
const int SPEAKERPIN = 9;

const int RANDSEEDPIN = 0; un pin analógico que no está conectado a nada

const int MAXSTEPDURATION = 300; Comience lentamente, cada paso es más corto 1 millisec.
const int MINSTEPDURATION = 150; Esto es tan rápido como se pone

const int NGLYPHS = 6;
los glifos se definirá a partir de 1 (no 0),
para permitir lcd.print() de cadenas terminadas en null
glifos de Byte [NGLYPHS] [8] = {}
1: coche para arriba
{B00000,
B01110,
B11111,
B01010,
B00000,
B00000,
B00000,
B00000}
2: coche
, {B00000,
B00000,
B00000,
B00000,
B01110,
B11111,
B01010,
B00000}
3: camión hasta
, {B00000,
B11110,
B11111,
B01010,
B00000,
B00000,
B00000,
B00000}
4: camión abajo
, {B00000,
B00000,
B00000,
B00000,
B11110,
B11111,
B01010,
B00000}
5: accidente hasta
, {B10101,
B01110,
B01110,
B10101,
B00000,
B00000,
B00000,
B00000}
6: desplome abajo
, {B00000,
B00000,
B00000,
B10101,
B01110,
B01110,
B10101,
B00000}
};

const int NCARPOSITIONS = 4;

Cada posición se asigna a una columna de 2 glifos
Utilizado para hacer sentido cuando había una 5ª posición
en coche o accidente fue dibujado como 2 pictogramas
(no puede hacer eso desde 0 termina cuerdas),
por lo que ahora es un poco tonta, pero no rompió :)
const char blanco = 32;
char car2glyphs [NCARPOSITIONS] [2] = {}
{1, ESPACIO EN BLANCO}, {2, BLANCO}, {EN BLANCO, 1}, {EN BLANCO, 2}
};
char truck2glyphs [NCARPOSITIONS] [2] = {}
{3, ESPACIO EN BLANCO}, {4, ESPACIO EN BLANCO}, {EN BLANCO, 3}, {EN BLANCO, 4}
};
char crash2glyphs [NCARPOSITIONS] [2] = {}
{5, ESPACIO EN BLANCO}, {6, ESPACIO EN BLANCO}, {EN BLANCO, 5}, {EN BLANCO, 6}
};

const int ROADLEN = 15; Ancho de la pantalla LCD (sin contar nuestro coche)
camino int [ROADLEN]; posiciones de otros coches
char line_buff [2 + ROADLEN]; cadena de AUX para drawRoad()
int road_index;
int car_pos;
Posición Off the grid significa columna vacía, tan MAXROADPOS
determina la probabilidad de que un coche en una columna
por ejemplo, 3 * NCARPOSITIONS da p = 1/3
const int MAXROADPOS = 3 * NCARPOSITIONS;
int step_duration;

accidente de int; True si se estrelló
unsigned int crashtime; Millis() cuando se estrelló
const int CRASHSOUNDDURATION = 250;

const char * INTRO1 = "Adelante, camiones";
const char * INTRO2 = "Conduzca con cuidado";
const int INTRODELAY = 2000;

void setup()
{
accidente = crashtime = road_index = 0;
step_duration = MAXSTEPDURATION;
line_buff [1 + ROADLEN] = '\0'; null terminarlo
randomSeed(analogRead(RANDSEEDPIN));
para (int i = 0; i < NGLYPHS; i ++) {}
lcd.createChar(i+1,glyphs[i]);
}
para (int i = 0; i < ROADLEN; i ++) {}
camino [i] =-1;
}
pinMode(SPEAKERPIN,OUTPUT);
analogWrite(SPEAKERPIN,0); en el lado seguro
LCD.Begin(16,2);
getSteeringWheel();
drawRoad();
lcd.setCursor(1,0);
LCD.Print(INTRO1);
lcd.setCursor(1,1);
LCD.Print(INTRO2);
Delay(INTRODELAY);
}

void loop() {}
sin firmar largo ahora = millis ()-INTRODELAY;
Si (! crash) {}
getSteeringWheel();
accidente = (car_pos==road[road_index]);
}
Si {} (desplome)
Si (! crashtime) {}
crashtime = ahora;
drawRoad();
Juego sobre el texto
(mantener intacta la 2 primeras columnas de "crash")
lcd.setCursor(2,0);
LCD.Print ("Crashed después");
lcd.setCursor(2,1);
LCD.Print(Now/1000);
LCD.Print ("segundos.");
}
Si ((now-crashtime) < CRASHSOUNDDURATION) {}
analogWrite(SPEAKERPIN,random(255)); ruido blanco
}
Else {}
analogWrite(SPEAKERPIN,0); crush post dramático silencio :)
}
Delay(10); Esperar un poco entre escrituras
}
Else {}

int prev_pos = camino [(road_index-1) % ROADLEN];
int this_pos = random(MAXROADPOS);
mientras que (abs(this_pos-prev_pos) < 2) {/ / no jam el camino
this_pos = random(MAXROADPOS);
}
camino [road_index] = this_pos;
road_index = (road_index + 1) % ROADLEN;
drawRoad();
Delay(step_duration);
Si (step_duration > MINSTEPDURATION) {}
step_duration--; ir más rápido
}
}
}
void getSteeringWheel() {}
car_pos = map(analogRead(POTPIN),0,1024,0,NCARPOSITIONS);
}

void drawRoad() {}
para (int i = 0; i < 2; i ++) {}
Si {} (desplome)
line_buff [0] = crash2glyphs [car_pos] [i];
}
Else {}
line_buff [0] = car2glyphs [car_pos] [i];
}
para (int j = 0; j < ROADLEN; j ++) {}
int pos = camino [(j+road_index) % ROADLEN];
¿line_buff [j + 1] = pos > = 0 & & pos < NCARPOSITIONS? truck2glyphs [pos] [i]: espacio en blanco;
}
lcd.setCursor(0,i);
LCD.Print(line_buff);
}
}