Mirrors/esp32-doom
2
0
Fork 0
mirror of https://github.com/espressif/esp32-doom.git synced 2026-03-22 08:26:51 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add missing files

Browse Source
This commit is contained in:
Jeroen Domburg
2017-04-12 14:18:51 +08:00
parent 40c817f3ab
commit 1332af830f
8 changed files with 495 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
components/prboom-esp32-compat/component.mk Normal file
View File

@@ -0,0 +1,13 @@
#
# Component Makefile
#
# This Makefile should, at the very least, just include $(SDK_PATH)/make/component.mk. By default,
# this will take the sources in the src/ directory, compile them and link them into
# lib(subdirectory_name).a in the build directory. This behaviour is entirely configurable,
# please read the SDK documents if you need to do this.
#
include $(IDF_PATH)/make/component_common.mk

9
components/prboom-esp32-compat/include/psxcontroller.h Normal file
View File

@@ -0,0 +1,9 @@
#ifndef PSXCONTROLLER_H
#define PSXCONTROLLER_H
//#define PSXJ_
int psxReadInput();
void psxcontrollerInit();
#endif

3
components/prboom-esp32-compat/include/spi_lcd.h Normal file
View File

@@ -0,0 +1,3 @@
void spi_lcd_wait_finish();
void spi_lcd_send(uint16_t *scr);
void spi_lcd_init();

128
components/prboom-esp32-compat/psxcontroller.c Normal file
View File

@@ -0,0 +1,128 @@
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "freertos/queue.h"
#include "driver/gpio.h"
#include "soc/gpio_struct.h"
#include "psxcontroller.h"
#define PSX_CLK 0
#define PSX_DAT 26
#define PSX_ATT 4
#define PSX_CMD 2
#define DELAY() asm("nop; nop; nop; nop;nop; nop; nop; nop;nop; nop; nop; nop;nop; nop; nop; nop;")
/* Sends and receives a byte from/to the PSX controller using SPI */
static int psxSendRecv(int send) {
int x;
int ret=0;
volatile int delay;
#if 0
while(1) {
GPIO.out_w1ts=(1<<PSX_CMD);
GPIO.out_w1ts=(1<<PSX_CLK);
GPIO.out_w1tc=(1<<PSX_CMD);
GPIO.out_w1tc=(1<<PSX_CLK);
}
#endif
GPIO.out_w1tc=(1<<PSX_ATT);
for (delay=0; delay<100; delay++);
for (x=0; x<8; x++) {
if (send&1) {
GPIO.out_w1ts=(1<<PSX_CMD);
} else {
GPIO.out_w1tc=(1<<PSX_CMD);
}
DELAY();
for (delay=0; delay<100; delay++);
GPIO.out_w1tc=(1<<PSX_CLK);
for (delay=0; delay<100; delay++);
GPIO.out_w1ts=(1<<PSX_CLK);
ret>>=1;
send>>=1;
if (GPIO.in&(1<<PSX_DAT)) ret|=128;
}
return ret;
}
static void psxDone() {
DELAY();
GPIO_REG_WRITE(GPIO_OUT_W1TS_REG, (1<<PSX_ATT));
}
int psxReadInput() {
int b1, b2;
psxSendRecv(0x01); //wake up
psxSendRecv(0x42); //get data
psxSendRecv(0xff); //should return 0x5a
b1=psxSendRecv(0xff); //buttons byte 1
b2=psxSendRecv(0xff); //buttons byte 2
psxDone();
return (b2<<8)|b1;
}
void psxcontrollerInit() {
volatile int delay;
int t;
gpio_config_t gpioconf[2]={
{
.pin_bit_mask=(1<<PSX_CLK)|(1<<PSX_CMD)|(1<<PSX_ATT),
.mode=GPIO_MODE_OUTPUT,
.pull_up_en=GPIO_PULLUP_DISABLE,
.pull_down_en=GPIO_PULLDOWN_DISABLE,
.intr_type=GPIO_PIN_INTR_DISABLE
},{
.pin_bit_mask=(1<<PSX_DAT),
.mode=GPIO_MODE_INPUT,
.pull_up_en=GPIO_PULLUP_ENABLE,
.pull_down_en=GPIO_PULLDOWN_DISABLE,
.intr_type=GPIO_PIN_INTR_DISABLE
}
};
gpio_config(&gpioconf[0]);
gpio_config(&gpioconf[1]);
PIN_PULLUP_EN(PERIPHS_IO_MUX_GPIO27_U);
//Send a few dummy bytes to clean the pipes.
psxSendRecv(0);
psxDone();
for (delay=0; delay<500; delay++) DELAY();
psxSendRecv(0);
psxDone();
for (delay=0; delay<500; delay++) DELAY();
//Try and detect the type of controller, so we can give the user some diagnostics.
psxSendRecv(0x01);
t=psxSendRecv(0x00);
psxDone();
if (t==0 || t==0xff) {
printf("No PSX/PS2 controller detected (0x%X). You will not be able to control the game.\n", t);
} else {
printf("PSX controller type 0x%X\n", t);
}
}

307
components/prboom-esp32-compat/spi_lcd.c Normal file
View File

@@ -0,0 +1,307 @@
/* SPI Master example
This example code is in the Public Domain (or CC0 licensed, at your option.)
Unless required by applicable law or agreed to in writing, this
software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "driver/spi_master.h"
#include "soc/gpio_struct.h"
#include "driver/gpio.h"
#include "esp_heap_alloc_caps.h"
#define PIN_NUM_MISO 25
#define PIN_NUM_MOSI 27
//#define PIN_NUM_MOSI 23
#define PIN_NUM_CLK 19
#define PIN_NUM_CS 22
#define PIN_NUM_DC 21
#define PIN_NUM_RST 18
#define PIN_NUM_BCKL 5
/*
The ILI9341 needs a bunch of command/argument values to be initialized. They are stored in this struct.
*/
typedef struct {
uint8_t cmd;
uint8_t data[16];
uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
} ili_init_cmd_t;
static const ili_init_cmd_t ili_init_cmds[]={
{0xCF, {0x00, 0x83, 0X30}, 3},
{0xED, {0x64, 0x03, 0X12, 0X81}, 4},
{0xE8, {0x85, 0x01, 0x79}, 3},
{0xCB, {0x39, 0x2C, 0x00, 0x34, 0x02}, 5},
{0xF7, {0x20}, 1},
{0xEA, {0x00, 0x00}, 2},
{0xC0, {0x26}, 1},
{0xC1, {0x11}, 1},
{0xC5, {0x35, 0x3E}, 2},
{0xC7, {0xBE}, 1},
{0x36, {0x28}, 1},
{0x3A, {0x55}, 1},
{0xB1, {0x00, 0x1B}, 2},
{0xF2, {0x08}, 1},
{0x26, {0x01}, 1},
{0xE0, {0x1F, 0x1A, 0x18, 0x0A, 0x0F, 0x06, 0x45, 0X87, 0x32, 0x0A, 0x07, 0x02, 0x07, 0x05, 0x00}, 15},
{0XE1, {0x00, 0x25, 0x27, 0x05, 0x10, 0x09, 0x3A, 0x78, 0x4D, 0x05, 0x18, 0x0D, 0x38, 0x3A, 0x1F}, 15},
{0x2A, {0x00, 0x00, 0x00, 0xEF}, 4},
{0x2B, {0x00, 0x00, 0x01, 0x3f}, 4},
{0x2C, {0}, 0},
{0xB7, {0x07}, 1},
{0xB6, {0x0A, 0x82, 0x27, 0x00}, 4},
{0x11, {0}, 0x80},
{0x29, {0}, 0x80},
{0, {0}, 0xff},
};
static spi_device_handle_t spi;
//Send a command to the ILI9341. Uses spi_device_transmit, which waits until the transfer is complete.
void ili_cmd(spi_device_handle_t spi, const uint8_t cmd)
{
esp_err_t ret;
spi_transaction_t t;
memset(&t, 0, sizeof(t)); //Zero out the transaction
t.length=8; //Command is 8 bits
t.tx_buffer=&cmd; //The data is the cmd itself
t.user=(void*)0; //D/C needs to be set to 0
ret=spi_device_transmit(spi, &t); //Transmit!
assert(ret==ESP_OK); //Should have had no issues.
}
//Send data to the ILI9341. Uses spi_device_transmit, which waits until the transfer is complete.
void ili_data(spi_device_handle_t spi, const uint8_t *data, int len)
{
esp_err_t ret;
spi_transaction_t t;
if (len==0) return; //no need to send anything
memset(&t, 0, sizeof(t)); //Zero out the transaction
t.length=len*8; //Len is in bytes, transaction length is in bits.
t.tx_buffer=data; //Data
t.user=(void*)1; //D/C needs to be set to 1
ret=spi_device_transmit(spi, &t); //Transmit!
assert(ret==ESP_OK); //Should have had no issues.
}
//This function is called (in irq context!) just before a transmission starts. It will
//set the D/C line to the value indicated in the user field.
void ili_spi_pre_transfer_callback(spi_transaction_t *t)
{
int dc=(int)t->user;
gpio_set_level(PIN_NUM_DC, dc);
}
//Initialize the display
void ili_init(spi_device_handle_t spi)
{
int cmd=0;
//Initialize non-SPI GPIOs
gpio_set_direction(PIN_NUM_DC, GPIO_MODE_OUTPUT);
gpio_set_direction(PIN_NUM_RST, GPIO_MODE_OUTPUT);
gpio_set_direction(PIN_NUM_BCKL, GPIO_MODE_OUTPUT);
//Reset the display
gpio_set_level(PIN_NUM_RST, 0);
vTaskDelay(100 / portTICK_RATE_MS);
gpio_set_level(PIN_NUM_RST, 1);
vTaskDelay(100 / portTICK_RATE_MS);
//Send all the commands
while (ili_init_cmds[cmd].databytes!=0xff) {
ili_cmd(spi, ili_init_cmds[cmd].cmd);
ili_data(spi, ili_init_cmds[cmd].data, ili_init_cmds[cmd].databytes&0x1F);
if (ili_init_cmds[cmd].databytes&0x80) {
vTaskDelay(100 / portTICK_RATE_MS);
}
cmd++;
}
///Enable backlight
gpio_set_level(PIN_NUM_BCKL, 0);
}
static void send_header_start(spi_device_handle_t spi, int xpos, int ypos, int w, int h)
{
esp_err_t ret;
int x;
//Transaction descriptors. Declared static so they're not allocated on the stack; we need this memory even when this
//function is finished because the SPI driver needs access to it even while we're already calculating the next line.
static spi_transaction_t trans[5];
//In theory, it's better to initialize trans and data only once and hang on to the initialized
//variables. We allocate them on the stack, so we need to re-init them each call.
for (x=0; x<5; x++) {
memset(&trans[x], 0, sizeof(spi_transaction_t));
if ((x&1)==0) {
//Even transfers are commands
trans[x].length=8;
trans[x].user=(void*)0;
} else {
//Odd transfers are data
trans[x].length=8*4;
trans[x].user=(void*)1;
}
trans[x].flags=SPI_TRANS_USE_TXDATA;
}
trans[0].tx_data[0]=0x2A; //Column Address Set
trans[1].tx_data[0]=xpos>>8; //Start Col High
trans[1].tx_data[1]=xpos; //Start Col Low
trans[1].tx_data[2]=(xpos+w-1)>>8; //End Col High
trans[1].tx_data[3]=(xpos+w-1)&0xff; //End Col Low
trans[2].tx_data[0]=0x2B; //Page address set
trans[3].tx_data[0]=ypos>>8; //Start page high
trans[3].tx_data[1]=ypos&0xff; //start page low
trans[3].tx_data[2]=(ypos+h-1)>>8; //end page high
trans[3].tx_data[3]=(ypos+h-1)&0xff; //end page low
trans[4].tx_data[0]=0x2C; //memory write
//Queue all transactions.
for (x=0; x<5; x++) {
ret=spi_device_queue_trans(spi, &trans[x], portMAX_DELAY);
assert(ret==ESP_OK);
}
//When we are here, the SPI driver is busy (in the background) getting the transactions sent. That happens
//mostly using DMA, so the CPU doesn't have much to do here. We're not going to wait for the transaction to
//finish because we may as well spend the time calculating the next line. When that is done, we can call
//send_line_finish, which will wait for the transfers to be done and check their status.
}
void send_header_cleanup(spi_device_handle_t spi)
{
spi_transaction_t *rtrans;
esp_err_t ret;
//Wait for all 5 transactions to be done and get back the results.
for (int x=0; x<5; x++) {
ret=spi_device_get_trans_result(spi, &rtrans, portMAX_DELAY);
assert(ret==ESP_OK);
//We could inspect rtrans now if we received any info back. The LCD is treated as write-only, though.
}
}
volatile static uint16_t *currFbPtr=NULL;
SemaphoreHandle_t dispSem = NULL;
SemaphoreHandle_t dispDoneSem = NULL;
#define NO_SIM_TRANS 5
#define MEM_PER_TRANS 1024
extern int16_t lcdpal[256];
void IRAM_ATTR displayTask(void *arg) {
int x, i;
int idx=0;
int inProgress=0;
static uint16_t *dmamem[NO_SIM_TRANS];
spi_transaction_t trans[NO_SIM_TRANS];
spi_transaction_t *rtrans;
esp_err_t ret;
spi_bus_config_t buscfg={
.miso_io_num=PIN_NUM_MISO,
.mosi_io_num=PIN_NUM_MOSI,
.sclk_io_num=PIN_NUM_CLK,
.quadwp_io_num=-1,
.quadhd_io_num=-1
};
spi_device_interface_config_t devcfg={
.clock_speed_hz=40000000, //Clock out at 40 MHz. Yes, that's heavily overclocked.
.mode=0, //SPI mode 0
.spics_io_num=PIN_NUM_CS, //CS pin
.queue_size=10, //We want to be able to queue 7 transactions at a time
.pre_cb=ili_spi_pre_transfer_callback, //Specify pre-transfer callback to handle D/C line
};
printf("*** Display task starting.\n");
//Initialize the SPI bus
ret=spi_bus_initialize(HSPI_HOST, &buscfg, 1);
assert(ret==ESP_OK);
//Attach the LCD to the SPI bus
ret=spi_bus_add_device(HSPI_HOST, &devcfg, &spi);
assert(ret==ESP_OK);
//Initialize the LCD
ili_init(spi);
for (x=0; x<NO_SIM_TRANS; x++) {
dmamem[x]=pvPortMallocCaps(MEM_PER_TRANS*2, MALLOC_CAP_DMA);
assert(dmamem[x]);
memset(&trans[x], 0, sizeof(spi_transaction_t));
trans[x].length=MEM_PER_TRANS*4;
trans[x].user=(void*)1;
trans[x].tx_buffer=&dmamem[x];
}
xSemaphoreGive(dispDoneSem);
while(1) {
xSemaphoreTake(dispSem, portMAX_DELAY);
// printf("Display task: frame.\n");
uint8_t *myData=(uint8_t*)currFbPtr;
send_header_start(spi, 0, 0, 320, 240);
send_header_cleanup(spi);
for (x=0; x<320*240; x+=MEM_PER_TRANS) {
for (i=0; i<MEM_PER_TRANS; i++) {
dmamem[idx][i]=lcdpal[myData[i]];
}
trans[idx].length=MEM_PER_TRANS*16;
trans[idx].user=(void*)1;
trans[idx].tx_buffer=dmamem[idx];
ret=spi_device_queue_trans(spi, &trans[idx], portMAX_DELAY);
assert(ret==ESP_OK);
myData+=MEM_PER_TRANS;
idx++;
if (idx>=NO_SIM_TRANS) idx=0;
if (inProgress==NO_SIM_TRANS-1) {
ret=spi_device_get_trans_result(spi, &rtrans, portMAX_DELAY);
assert(ret==ESP_OK);
} else {
inProgress++;
}
}
xSemaphoreGive(dispDoneSem);
while(inProgress) {
ret=spi_device_get_trans_result(spi, &rtrans, portMAX_DELAY);
assert(ret==ESP_OK);
inProgress--;
}
}
}
#include <xtensa/config/core.h>
#include <xtensa/corebits.h>
#include <xtensa/config/system.h>
#include <xtensa/simcall.h>
void spi_lcd_wait_finish() {
xSemaphoreTake(dispDoneSem, portMAX_DELAY);
}
void spi_lcd_send(uint16_t *scr) {
currFbPtr=scr;
xSemaphoreGive(dispSem);
}
void spi_lcd_init(){
printf("spi_lcd_init()\n");
dispSem=xSemaphoreCreateBinary();
dispDoneSem=xSemaphoreCreateBinary();
xTaskCreatePinnedToCore(&displayTask, "display", 3000, NULL, 6, NULL, 0);
}

11
components/prboom-wad-tables/component.mk Normal file
View File

@@ -0,0 +1,11 @@
#
# Component Makefile
#
# This Makefile should, at the very least, just include $(SDK_PATH)/make/component.mk. By default,
# this will take the sources in the src/ directory, compile them and link them into
# lib(subdirectory_name).a in the build directory. This behaviour is entirely configurable,
# please read the SDK documents if you need to do this.
#
include $(IDF_PATH)/make/component_common.mk

14
components/prboom/component.mk Normal file
View File

@@ -0,0 +1,14 @@
#
# Component Makefile
#
# This Makefile should, at the very least, just include $(SDK_PATH)/make/component.mk. By default,
# this will take the sources in the src/ directory, compile them and link them into
# lib(subdirectory_name).a in the build directory. This behaviour is entirely configurable,
# please read the SDK documents if you need to do this.
#
include $(IDF_PATH)/make/component_common.mk
CFLAGS += -Wno-error=char-subscripts -Wno-error=unused-value -Wno-error=parentheses -Wno-error=int-to-pointer-cast -Wno-pointer-sign \
-Wno-error=unused-but-set-parameter -Wno-error=maybe-uninitialized

10
main/component.mk Normal file
View File

@@ -0,0 +1,10 @@
#
# Main Makefile. This is basically the same as a component makefile.
#
# This Makefile should, at the very least, just include $(SDK_PATH)/make/component.mk. By default,
# this will take the sources in the src/ directory, compile them and link them into
# lib(subdirectory_name).a in the build directory. This behaviour is entirely configurable,
# please read the SDK documents if you need to do this.
#
include $(IDF_PATH)/make/component_common.mk