├── LICENSE
├── README.md
├── arduino
    ├── .pio
    │   ├── build
    │   │   └── nada.txt
    │   └── libdeps
    │   │   └── lolin32
    │   │       └── nada.txt
    ├── .vscode
    │   └── nada.txt
    ├── data
    │   ├── nada.txt
    │   ├── persist
    │   │   └── nada.txt
    │   └── rom
    │   │   └── nada.txt
    ├── doc
    │   └── nada.txt
    ├── gameboy
    │   ├── ESP32Lib
    │   │   ├── ESP32Lib.h
    │   │   ├── GfxWrapper.h
    │   │   ├── Graphics
    │   │   │   ├── Animation.h
    │   │   │   ├── Engine3D.h
    │   │   │   ├── Entity.h
    │   │   │   ├── Font.h
    │   │   │   ├── Graphics.h
    │   │   │   ├── GraphicsL8CompositeSwapped.h
    │   │   │   ├── GraphicsPAL8Swapped.h
    │   │   │   ├── GraphicsPALColor.h
    │   │   │   ├── GraphicsR1G1B1A1.h
    │   │   │   ├── GraphicsR1G1B1A1X2S2Swapped.h
    │   │   │   ├── GraphicsR2G2B2A2.h
    │   │   │   ├── GraphicsR2G2B2S2Swapped.h
    │   │   │   ├── GraphicsR5G5B4A2.h
    │   │   │   ├── GraphicsR5G5B4S2Swapped.h
    │   │   │   ├── Image.h
    │   │   │   ├── ImageDrawer.h
    │   │   │   ├── Mesh.h
    │   │   │   ├── RGB2YUV.h
    │   │   │   ├── Sprites.h
    │   │   │   └── TriangleTree.h
    │   │   ├── I2S
    │   │   │   ├── DMABufferDescriptor.h
    │   │   │   └── I2S.h
    │   │   ├── Math
    │   │   │   └── Matrix.h
    │   │   ├── Ressources
    │   │   │   ├── CodePage437_8x14.h
    │   │   │   ├── CodePage437_8x16.h
    │   │   │   ├── CodePage437_8x19.h
    │   │   │   ├── CodePage437_8x8.h
    │   │   │   ├── CodePage437_9x16.h
    │   │   │   ├── Font6x8.h
    │   │   │   └── Font8x8.h
    │   │   ├── Tools
    │   │   │   └── Log.h
    │   │   └── VGA
    │   │   │   ├── Mode.h
    │   │   │   ├── PinConfig.h
    │   │   │   ├── VGA.h
    │   │   │   ├── VGA14Bit.h
    │   │   │   ├── VGA14BitI.h
    │   │   │   ├── VGA3Bit.h
    │   │   │   ├── VGA3BitI.h
    │   │   │   ├── VGA6Bit.h
    │   │   │   └── VGA6BitI.h
    │   ├── Emulator
    │   │   └── Keyboard
    │   │   │   └── PS2Kbd.h
    │   ├── I2S.cpp
    │   ├── LICENSE
    │   ├── MartianVGA.h
    │   ├── PS2Kbd.cpp
    │   ├── PS2Kbd.h
    │   ├── VGA.cpp
    │   ├── VGA14BitI.cpp
    │   ├── VGA3BitI.cpp
    │   ├── VGA6BitI.cpp
    │   ├── cpu.cpp
    │   ├── cpu.h
    │   ├── dataFlash
    │   │   ├── gbrom.h
    │   │   └── roms
    │   │   │   ├── romLastCrown.h
    │   │   │   └── romRetroid.h
    │   ├── def
    │   │   ├── Font.h
    │   │   ├── ascii.h
    │   │   ├── hardware.h
    │   │   ├── keys.h
    │   │   └── types.h
    │   ├── gameboy.ino
    │   ├── gbConfig.h
    │   ├── gb_globals.h
    │   ├── gb_sdl_font6x8.h
    │   ├── interrupt.cpp
    │   ├── interrupt.h
    │   ├── keys.h
    │   ├── lcd.cpp
    │   ├── lcd.h
    │   ├── mbc.cpp
    │   ├── mbc.h
    │   ├── mem.cpp
    │   ├── mem.h
    │   ├── osd.cpp
    │   ├── osd.h
    │   ├── rom.cpp
    │   ├── rom.h
    │   ├── sdl.cpp
    │   ├── sdl.h
    │   ├── timer.cpp
    │   └── timer.h
    ├── include
    │   └── nada.txt
    ├── lib
    │   └── FabGL
    │   │   ├── CODE_OF_CONDUCT.md
    │   │   ├── CONTRIBUTING.md
    │   │   ├── LICENSE
    │   │   ├── README.md
    │   │   ├── fabgl GPIOs assignment.txt
    │   │   ├── library.json
    │   │   ├── library.properties
    │   │   └── src
    │   │       ├── canvas.cpp
    │   │       ├── canvas.h
    │   │       ├── collisiondetector.cpp
    │   │       ├── collisiondetector.h
    │   │       ├── comdrivers
    │   │           ├── ps2controller.cpp
    │   │           ├── ps2controller.h
    │   │           ├── ps2device.cpp
    │   │           ├── ps2device.h
    │   │           ├── tsi2c.cpp
    │   │           └── tsi2c.h
    │   │       ├── devdrivers
    │   │           ├── DS3231.cpp
    │   │           ├── DS3231.h
    │   │           ├── keyboard.cpp
    │   │           ├── keyboard.h
    │   │           ├── mouse.cpp
    │   │           ├── mouse.h
    │   │           ├── soundgen.cpp
    │   │           ├── soundgen.h
    │   │           ├── swgenerator.cpp
    │   │           └── swgenerator.h
    │   │       ├── dispdrivers
    │   │           ├── SSD1306Controller.cpp
    │   │           ├── SSD1306Controller.h
    │   │           ├── TFTControllerGeneric.cpp
    │   │           ├── TFTControllerGeneric.h
    │   │           ├── TFTControllerSpecif.cpp
    │   │           ├── TFTControllerSpecif.h
    │   │           ├── vga16controller.cpp
    │   │           ├── vga16controller.h
    │   │           ├── vgacontroller.cpp
    │   │           ├── vgacontroller.h
    │   │           ├── vgatextcontroller.cpp
    │   │           └── vgatextcontroller.h
    │   │       ├── displaycontroller.cpp
    │   │       ├── displaycontroller.h
    │   │       ├── fabfonts.cpp
    │   │       ├── fabfonts.h
    │   │       ├── fabgl.h
    │   │       ├── fabglconf.h
    │   │       ├── fabui.cpp
    │   │       ├── fabui.h
    │   │       ├── fabutils.cpp
    │   │       ├── fabutils.h
    │   │       ├── fonts
    │   │           ├── font_10x20.h
    │   │           ├── font_4x6.h
    │   │           ├── font_5x7.h
    │   │           ├── font_5x8.h
    │   │           ├── font_6x10.h
    │   │           ├── font_6x12.h
    │   │           ├── font_6x13.h
    │   │           ├── font_6x8.h
    │   │           ├── font_6x9.h
    │   │           ├── font_7x13.h
    │   │           ├── font_7x14.h
    │   │           ├── font_8x13.h
    │   │           ├── font_8x14.h
    │   │           ├── font_8x8.h
    │   │           ├── font_8x9.h
    │   │           ├── font_9x15.h
    │   │           ├── font_9x18.h
    │   │           ├── font_std_12.h
    │   │           ├── font_std_14.h
    │   │           ├── font_std_15.h
    │   │           ├── font_std_16.h
    │   │           ├── font_std_17.h
    │   │           ├── font_std_18.h
    │   │           ├── font_std_22.h
    │   │           └── font_std_24.h
    │   │       ├── images
    │   │           ├── bitmaps.h
    │   │           └── cursors.h
    │   │       ├── network
    │   │           ├── ICMP.cpp
    │   │           └── ICMP.h
    │   │       ├── scene.cpp
    │   │       ├── scene.h
    │   │       ├── terminal.cpp
    │   │       ├── terminal.h
    │   │       ├── terminfo.cpp
    │   │       ├── terminfo.h
    │   │       ├── ulp_macro_ex.cpp
    │   │       └── ulp_macro_ex.h
    ├── platformio.ini
    ├── platformio.ini.linux
    ├── platformio.ini.osx
    └── tools
    │   ├── input
    │       └── roms
    │       │   └── onehour.gb
    │   ├── output
    │       └── dataFlash
    │       │   ├── gbrom.h
    │       │   └── roms
    │       │       └── romonehour.h
    │   ├── rom2h.cpp
    │   └── rom2h.exe
├── preview
    ├── preview.gif
    ├── previewArduinoIDElibrary.gif
    ├── previewArduinoIDEpreferences.gif
    ├── previewGameboyYoutube.gif
    ├── previewOSD.gif
    ├── previewPlatformIO.gif
    ├── previewPlatformIOinstall.gif
    └── ttgovga32v12.jpg
├── readmeEnglish.md
└── readmeSpanish.md


/LICENSE:
--------------------------------------------------------------------------------
 1 | DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
 2 |                     Version 2, December 2004
 3 | 
 4 |  Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
 5 | 
 6 |  Everyone is permitted to copy and distribute verbatim or modified
 7 |  copies of this license document, and changing it is allowed as long
 8 |  as the name is changed.
 9 | 
10 |             DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
11 |    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
12 | 
13 |   0. You just DO WHAT THE FUCK YOU WANT TO.
14 |   
15 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ESP32 Gameboy emulator
 2 | <center><img src='https://github.com/rpsubc8/esp32gameboy/blob/master/preview/previewGameboyYoutube.gif'></center>
 3 | <ul>
 4 |  <li><b>Discord: </b><a href='https://discord.gg/rtyAbT5mgQ'>https://discord.gg/rtyAbT5mgQ</a></li>
 5 |  <li><b>Youtube: </b><a href='https://www.youtube.com/watch?v=F00ctuDlUbs'>https://www.youtube.com/watch?v=F00ctuDlUbs</a></li>
 6 |  <li><b>Forum: </b><a href='https://retrowiki.es/viewforum.php?f=114'>https://retrowiki.es/viewforum.php?f=114</a></li>
 7 | </ul>
 8 | 
 9 | <br><br>
10 | <h1>Documentation (Help)</h1>
11 | <ul>
12 |  <li><a href='readmeEnglish.md'>English Doc</a></li>
13 |  <li><a href='readmeSpanish.md'>Spanish Doc</a></li>
14 | </ul>
15 | 


--------------------------------------------------------------------------------
/arduino/.pio/build/nada.txt:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/arduino/.pio/libdeps/lolin32/nada.txt:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/arduino/.vscode/nada.txt:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/arduino/data/nada.txt:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/arduino/data/persist/nada.txt:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/arduino/data/rom/nada.txt:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/arduino/doc/nada.txt:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/ESP32Lib.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <VGA/VGA14BitI.h>
 4 | #include <VGA/VGA14Bit.h>
 5 | #include <VGA/VGA6BitI.h>
 6 | #include <VGA/VGA6Bit.h>
 7 | #include <VGA/VGA3BitI.h>
 8 | #include <VGA/VGA3Bit.h>
 9 | #include <Composite/CompositeL8.h>
10 | #include <Composite/CompositePAL8.h>
11 | 
12 | #include <LED/SerialLED.h>
13 | #include <LED/ParallelLED.h>
14 | #include <LED/ParallelLEDGraphics.h>
15 | 
16 | #include <Graphics/Sprites.h>
17 | #include <Graphics/Mesh.h>
18 | #include <Graphics/Sprites.h>
19 | #include <Graphics/Animation.h>
20 | #include <Controller/GameControllers.h>
21 | #include <Audio/AudioOutput.h>
22 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/GfxWrapper.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | 	Author: bitluni 2019
 3 | 	License: 
 4 | 	Creative Commons Attribution ShareAlike 4.0
 5 | 	https://creativecommons.org/licenses/by-sa/4.0/
 6 | 	
 7 | 	For further details check out: 
 8 | 		https://youtube.com/bitlunislab
 9 | 		https://github.com/bitluni
10 | 		http://bitluni.net
11 | */
12 | #pragma once
13 | #include "Adafruit_GFX.h"
14 | 
15 | template<class Base>
16 | class GfxWrapper : public Adafruit_GFX
17 | {
18 |   public:
19 | 	Base &base;
20 | 	typedef typename Base::Color Color;
21 | 	GfxWrapper(Base &vga, const int xres, const int yres)
22 | 		:base(vga),
23 | 		Adafruit_GFX(xres, yres)
24 | 	{
25 | 	}
26 | 
27 | 	virtual void drawPixel(int16_t x, int16_t y, uint16_t color)
28 | 	{
29 | 		base.dot(x, y, base.RGBA((color >> 8) & 0b11111000, (color >> 3) & 0b11111100, (color << 3) & 0b11111000));
30 | 	}
31 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/Animation.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | 	Author: bitluni 2019
 3 | 	License: 
 4 | 	Creative Commons Attribution ShareAlike 4.0
 5 | 	https://creativecommons.org/licenses/by-sa/4.0/
 6 | 	
 7 | 	For further details check out: 
 8 | 		https://youtube.com/bitlunislab
 9 | 		https://github.com/bitluni
10 | 		http://bitluni.net
11 | */
12 | #pragma once
13 | #include "Entity.h"
14 | 
15 | class Animation : public Entity
16 | {
17 |   public:
18 | 	int start, end, frameDuration;
19 | 	int time;
20 | 	int drawMode;
21 | 
22 | 	Animation(Sprites &sprites, int x, int y, int start, int end, int frameDuration, int drawMode = 0)
23 | 	{
24 | 		this->x = x;
25 | 		this->y = y;
26 | 		this->sprites = &sprites;
27 | 		this->start = start;
28 | 		this->end = end;
29 | 		this->frameDuration = frameDuration;
30 | 		time = 0;
31 | 		this->drawMode = drawMode;
32 | 	}
33 | 
34 | 	virtual ~Animation()
35 | 	{
36 | 	}
37 | 	
38 | 	bool act(int dt)
39 | 	{
40 | 		time += dt;
41 | 		return time < (end - start + 1) * frameDuration;
42 | 	}
43 | /*
44 | 	void draw(Graphics &g)
45 | 	{
46 | 		int current = time / frameDuration + start;
47 | 		if (drawMode == 0)
48 | 			this->sprites->drawMix(g, current, this->x, this->y);
49 | 		else if (drawMode == 1)
50 | 			this->sprites->drawAdd(g, current, this->x, this->y);
51 | 	}
52 | */
53 | 	static void animationsAct(Animation **animations, int dt, int maxCount = 100)
54 | 	{
55 | 		for (int i = 0; i < maxCount; i++)
56 | 		{
57 | 			if (animations[i])
58 | 				if (!animations[i]->act(dt))
59 | 				{
60 | 					delete animations[i];
61 | 					animations[i] = 0;
62 | 				}
63 | 		}
64 | 	}
65 | /*
66 | 	void animationsDraw(Graphics &g, Animation **animations, int maxCount = 100)
67 | 	{
68 | 		for (int i = 0; i < maxCount; i++)
69 | 			if (animations[i])
70 | 				if (animations[i])
71 | 					animations[i]->draw(g);
72 | 	}
73 | */
74 | 	void animationsEmit(Animation **animations, Animation *e, int maxCount = 100)
75 | 	{
76 | 		for (int i = 0; i < maxCount; i++)
77 | 		{
78 | 			if (!animations[i])
79 | 			{
80 | 				animations[i] = e;
81 | 				return;
82 | 			}
83 | 		}
84 | 		delete e;
85 | 	}
86 | };
87 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/Engine3D.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | 	Author: bitluni 2019
 3 | 	License: 
 4 | 	Creative Commons Attribution ShareAlike 4.0
 5 | 	https://creativecommons.org/licenses/by-sa/4.0/
 6 | 	
 7 | 	For further details check out: 
 8 | 		https://youtube.com/bitlunislab
 9 | 		https://github.com/bitluni
10 | 		http://bitluni.net
11 | */
12 | #pragma once
13 | #include <stdlib.h>
14 | #include "TriangleTree.h"
15 | #include "../Tools/Log.h"
16 | template<class Graphics>
17 | class Engine3D
18 | {
19 | 	public:
20 | 	typedef typename Graphics::Color Color;
21 | 	TriangleTree *triangleBuffer;
22 | 	TriangleTree *triangleRoot;
23 | 	int trinagleBufferSize;
24 | 	int triangleCount;
25 | 
26 | 	Engine3D(const int initialTrinagleBufferSize = 1)
27 | 	{
28 | 		trinagleBufferSize = initialTrinagleBufferSize;
29 | 		triangleBuffer = (TriangleTree*)malloc(sizeof(TriangleTree) * trinagleBufferSize);
30 | 		if(!triangleBuffer)
31 | 			ERROR("Not enough memory for triangleBuffer");
32 | 		triangleRoot = 0;
33 | 		triangleCount = 0;
34 | 	}
35 | 
36 | 
37 | 	void enqueueTriangle(short *v0, short *v1, short *v2, Color color)
38 | 	{
39 | 		if (triangleCount >= trinagleBufferSize)
40 | 			return;
41 | 		TriangleTree &t = triangleBuffer[triangleCount++];
42 | 		t.set(v0, v1, v2, color);
43 | 		if (triangleRoot)
44 | 			triangleRoot->add(&triangleRoot, t);
45 | 		else
46 | 			triangleRoot = &t;
47 | 	}
48 | 	
49 | 	void drawTriangleTree(Graphics &g, TriangleTree *t)
50 | 	{
51 | 		if (t->left)
52 | 			drawTriangleTree(g, t->left);
53 | 		g.triangle(t->v[0], t->v[1], t->v[2], t->color);
54 | 		if (t->right)
55 | 			drawTriangleTree(g, t->right);
56 | 	}
57 | 
58 | 	virtual void begin()
59 | 	{
60 | 		triangleCount = 0;
61 | 		triangleRoot = 0;
62 | 	}
63 | 
64 | 	virtual void end(Graphics &g)
65 | 	{
66 | 		if (triangleRoot)
67 | 			drawTriangleTree(g, triangleRoot);
68 | 	}
69 | };
70 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/Entity.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | 	Author: bitluni 2019
 3 | 	License: 
 4 | 	Creative Commons Attribution ShareAlike 4.0
 5 | 	https://creativecommons.org/licenses/by-sa/4.0/
 6 | 	
 7 | 	For further details check out: 
 8 | 		https://youtube.com/bitlunislab
 9 | 		https://github.com/bitluni
10 | 		http://bitluni.net
11 | */
12 | #pragma once
13 | #include "Graphics.h"
14 | #include "Sprites.h"
15 | 
16 | class Entity
17 | {
18 |   public:
19 | 	int x, y;
20 | 	int vx, vy;
21 | 	int life;
22 | 	int faction;
23 | 	Sprites *sprites;
24 | 	virtual bool act(int dt);
25 | 	virtual void draw() = 0;
26 | };
27 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/Font.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | 	Author: bitluni 2019
 3 | 	License: 
 4 | 	Creative Commons Attribution ShareAlike 4.0
 5 | 	https://creativecommons.org/licenses/by-sa/4.0/
 6 | 	
 7 | 	For further details check out: 
 8 | 		https://youtube.com/bitlunislab
 9 | 		https://github.com/bitluni
10 | 		http://bitluni.net
11 | */
12 | #pragma once
13 | 
14 | class Font
15 | {
16 |   public:
17 | 	const int firstChar;
18 | 	const int charCount;
19 | 	const unsigned char *pixels;
20 | 	const int charWidth;
21 | 	const int charHeight;
22 | 	Font(int charWidth, int charHeight, const unsigned char *pixels, int firstChar = 32, int charCount = 96)
23 | 		:firstChar(firstChar),
24 | 		charCount(charCount),
25 | 		pixels(pixels),
26 | 		charWidth(charWidth),
27 | 		charHeight(charHeight)
28 | 	{
29 | 	}
30 | 
31 | 	bool valid(char ch) const
32 | 	{
33 | 		return ch >= firstChar && ch < firstChar + charCount;
34 | 	}
35 | };
36 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/GraphicsL8CompositeSwapped.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | 	Author: bitluni 2019
 3 | 	License: 
 4 | 	Creative Commons Attribution ShareAlike 4.0
 5 | 	https://creativecommons.org/licenses/by-sa/4.0/
 6 | 	
 7 | 	For further details check out: 
 8 | 		https://youtube.com/bitlunislab
 9 | 		https://github.com/bitluni
10 | 		http://bitluni.net
11 | */
12 | #pragma once
13 | #include "Graphics.h"
14 | 
15 | class GraphicsL8CompositeSwapped: public Graphics<unsigned char>
16 | {
17 | 	public:
18 | 	typedef unsigned char Color;
19 | 	static const Color BlackLevel = 76;
20 | 	
21 | 	GraphicsL8CompositeSwapped()
22 | 	{
23 | 		frontColor = 0xff;
24 | 	}
25 | 
26 | 	virtual int R(Color c) const
27 | 	{
28 | 		return ((int)(c - BlackLevel) * 255) / (255 - BlackLevel) ;
29 | 	}
30 | 	virtual int G(Color c) const
31 | 	{
32 | 		return ((int)(c - BlackLevel) * 255) / (255 - BlackLevel) ;
33 | 	}
34 | 	virtual int B(Color c) const
35 | 	{
36 | 		return ((int)(c - BlackLevel) * 255) / (255 - BlackLevel) ;
37 | 	}
38 | 	virtual int A(Color c) const
39 | 	{
40 | 		return 255;
41 | 	}
42 | 
43 | 	virtual Color RGBA(int r, int g, int b, int a = 255) const
44 | 	{
45 | 		return (r * 2126 + g * 7152 + b * 722) * (255 - BlackLevel) / 2550000 + BlackLevel;
46 | 	}
47 | 
48 | 	virtual void dotFast(int x, int y, Color color)
49 | 	{
50 | 		backBuffer[y][x^2] = color;
51 | 	}
52 | 
53 | 	virtual void dot(int x, int y, Color color)
54 | 	{
55 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
56 | 			backBuffer[y][x^2] = color;
57 | 	}
58 | 
59 | 	virtual void dotAdd(int x, int y, Color color)
60 | 	{
61 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
62 | 		{
63 | 			int c0 = backBuffer[y][x^2];
64 | 			int c1 = color;
65 | 			int cn = c0 + c1 - BlackLevel;
66 | 			if(cn > 255) cn = 255;
67 | 			backBuffer[y][x^2] = cn;
68 | 		}
69 | 	}
70 | 	
71 | 	virtual void dotMix(int x, int y, Color color)
72 | 	{
73 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
74 | 			backBuffer[y][x^2] = ((int)backBuffer[y][x^2] + color) / 2;
75 | 	}
76 | 	
77 | 	virtual Color get(int x, int y)
78 | 	{
79 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
80 | 			return backBuffer[y][x^2];
81 | 		return 0;
82 | 	}
83 | 
84 | 	virtual void clear(Color color = 0)
85 | 	{
86 | 		for (int y = 0; y < this->yres; y++)
87 | 			for (int x = 0; x < this->xres; x++)
88 | 				backBuffer[y][x^2] = BlackLevel;
89 | 	}
90 | 	
91 | 	virtual Color** allocateFrameBuffer()
92 | 	{
93 | 		return Graphics<Color>::allocateFrameBuffer(xres, yres, (Color)BlackLevel);
94 | 	}
95 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/GraphicsPAL8Swapped.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "Graphics.h"
 14 | 
 15 | class GraphicsPAL8Swapped: public Graphics<unsigned char>
 16 | {
 17 | 	public:
 18 | 	typedef unsigned char Color;
 19 | 	static const Color BlackLevel = 76;
 20 | 	short *SIN;
 21 | 	short *COS;
 22 | 	short YLUT[16];
 23 | 	short UVLUT[16];
 24 | 	float burstPerSample;
 25 | 	
 26 | 	GraphicsPAL8Swapped()
 27 | 	{
 28 | 		frontColor = 0xff;
 29 | 	}
 30 | 
 31 | 	void initLUTs(long pixelClock, long colorClock, int burstDelta, int hres)
 32 | 	{
 33 | 		burstPerSample = (2 * M_PI) / ((double)pixelClock / colorClock);
 34 | 		SIN = (short*)malloc(hres * sizeof(short));
 35 | 		COS = (short*)malloc(hres * sizeof(short));
 36 | 		int maxLevel = 255;
 37 | 		for(int i = 0; i < hres; i++)
 38 | 		{
 39 | 			int c = burstDelta + i;
 40 | 			SIN[i] = round(0.436798f * sin(c * burstPerSample) * 256);
 41 | 			COS[i] = round(0.614777f * cos(c * burstPerSample) * 256);     
 42 | 		}
 43 | 		for(int i = 0; i < 16; i++)
 44 | 		{
 45 | 			YLUT[i] = (int(BlackLevel) << 8) + round(i / 15.f * 256 * maxLevel);
 46 | 			UVLUT[i] = round((i - 8) / 7.f * maxLevel);
 47 | 		}
 48 | 	}
 49 | 
 50 | 	virtual int R(Color c) const
 51 | 	{
 52 | 		return ((int)(c - BlackLevel) * 255) / (255 - BlackLevel) ;
 53 | 	}
 54 | 	virtual int G(Color c) const
 55 | 	{
 56 | 		return ((int)(c - BlackLevel) * 255) / (255 - BlackLevel) ;
 57 | 	}
 58 | 	virtual int B(Color c) const
 59 | 	{
 60 | 		return ((int)(c - BlackLevel) * 255) / (255 - BlackLevel) ;
 61 | 	}
 62 | 	virtual int A(Color c) const
 63 | 	{
 64 | 		return 255;
 65 | 	}
 66 | 
 67 | 	virtual Color RGBA(int r, int g, int b, int a = 255) const
 68 | 	{
 69 | 		return (r * 2126 + g * 7152 + b * 722) * (255 - BlackLevel) / 2550000 + BlackLevel;
 70 | 	}
 71 | 
 72 | 	virtual void dotFast(int x, int y, Color color)
 73 | 	{
 74 | 		x <<= 1;
 75 | 		backBuffer[y][x^2] = color;
 76 | 		backBuffer[y][(x + 1)^2] = color;
 77 | 		//backBuffer[y][(x + 2)^2] = color;
 78 | 		//backBuffer[y][(x + 3)^2] = color;
 79 | 	}
 80 | 
 81 | 	virtual void dot(int x, int y, Color color)
 82 | 	{
 83 | 		x <<= 1;
 84 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 85 | 		{
 86 | 			backBuffer[y][x^2] = color;
 87 | 			backBuffer[y][(x + 1)^2] = color;
 88 | 			//backBuffer[y][(x + 2)^2] = color;
 89 | 			//backBuffer[y][(x + 3)^2] = color;
 90 | 		}
 91 | 	}
 92 | 
 93 | 	virtual void dotAdd(int x, int y, Color color)
 94 | 	{
 95 | 		dot(x, y, color);
 96 | /*		if ((unsigned int)x < xres && (unsigned int)y < yres)
 97 | 		{
 98 | 			int c0 = backBuffer[y][x^2];
 99 | 			int c1 = color;
100 | 			int cn = c0 + c1 - BlackLevel;
101 | 			if(cn > 255) cn = 255;
102 | 			backBuffer[y][x^2] = cn;
103 | 		}*/
104 | 	}
105 | 	
106 | 	virtual void dotMix(int x, int y, Color color)
107 | 	{
108 | 		dot(x, y, color);
109 | 		/*if ((unsigned int)x < xres && (unsigned int)y < yres)
110 | 			backBuffer[y][x^2] = ((int)backBuffer[y][x^2] + color) / 2;*/
111 | 	}
112 | 	
113 | 	virtual Color get(int x, int y)
114 | 	{
115 | 		/*if ((unsigned int)x < xres && (unsigned int)y < yres)
116 | 			return backBuffer[y][x^2];*/
117 | 		return 0;
118 | 	}
119 | 
120 | 	virtual void clear(Color color = 0)
121 | 	{
122 | 		for (int y = 0; y < this->yres; y++)
123 | 			for (int x = 0; x < this->xres; x++)
124 | 				backBuffer[y][x^2] = BlackLevel;
125 | 	}
126 | 	
127 | 	virtual Color** allocateFrameBuffer()
128 | 	{
129 | 		return Graphics<Color>::allocateFrameBuffer(xres, yres, (Color)BlackLevel);
130 | 	}
131 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/GraphicsPALColor.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "Graphics.h"
 14 | #include "RGB2YUV.h"
 15 | 
 16 | class GraphicsPALColor: public Graphics<unsigned short>
 17 | {
 18 | 	public:
 19 | 	typedef unsigned short Color;
 20 | 	static const Color BlackLevel = 72;
 21 | 	static const int maxLevel = 255 - BlackLevel;
 22 | 	short *SIN;
 23 | 	short *COS;
 24 | 	short YLUT[16];
 25 | 	short UVLUT[16];
 26 | 	float burstPerSample;
 27 | 	
 28 | 	GraphicsPALColor()
 29 | 	{
 30 | 		frontColor = RGBA(255, 255, 255);
 31 | 		backColor = RGBA(0, 0, 0);
 32 | 	}
 33 | 
 34 | 	void initLUTs(long pixelClock, long colorClock, int burstDelta, int hres)
 35 | 	{
 36 | 		burstPerSample = (2 * M_PI) / ((double)pixelClock / colorClock);
 37 | 		Serial.print("hres: ");
 38 | 		Serial.print(hres);
 39 | 		SIN = (short*)malloc(hres * sizeof(short));
 40 | 		COS = (short*)malloc(hres * sizeof(short));
 41 | 		int maxLevel = 54;
 42 | 		for(int i = 0; i < hres; i++)
 43 | 		{
 44 | 			int c = burstDelta + i;
 45 | 			SIN[i] = round(0.436798f * sin(c * burstPerSample) * 256);
 46 | 			COS[i] = round(0.614777f * cos(c * burstPerSample) * 256);     
 47 | 		}
 48 | 		for(int i = 0; i < 16; i++)
 49 | 		{
 50 | 			YLUT[i] = (int(BlackLevel) << 8) + round(i / 15.f * 256 * maxLevel);
 51 | 			UVLUT[i] = round((i - 8) / 7.f * maxLevel);
 52 | 		}
 53 | 	}
 54 | 
 55 | 	virtual int R(Color c) const
 56 | 	{
 57 | 		return 0;
 58 | 	}
 59 | 	virtual int G(Color c) const
 60 | 	{
 61 | 		return 0;
 62 | 	}
 63 | 	virtual int B(Color c) const
 64 | 	{
 65 | 		return 0;
 66 | 	}
 67 | 	virtual int A(Color c) const
 68 | 	{
 69 | 		return 255;
 70 | 	}
 71 | 
 72 | 	virtual Color RGBA(int r, int g, int b, int a = 255) const
 73 | 	{
 74 | 		return RGB2YUV[(r >> 4) | (g & 0xf0) | ((b & 0xf0) << 4)];
 75 | 	}
 76 | 
 77 | 	virtual void dotFast(int x, int y, Color color)
 78 | 	{
 79 | 		x <<= 1;
 80 | 		short y0 = YLUT[color & 15];
 81 | 		short u = UVLUT[(color >> 4) & 15];
 82 | 		short v = UVLUT[(color >> 12)];
 83 |         short u0 = (SIN[x] * u);
 84 |         short u1 = (SIN[x + 1] * u);
 85 |         short v0 = (COS[x] * v);
 86 |         short v1 = (COS[x + 1] * v);
 87 | 
 88 | 		if(y & 1)
 89 | 		{
 90 | 			((unsigned char*)backBuffer[y])[x^2] = (y0 + u0 + v0) >> 8;
 91 | 			((unsigned char*)backBuffer[y])[(x + 1)^2] = (y0 + u1 + v1) >> 8;
 92 | 		}
 93 | 		else
 94 | 		{
 95 | 			((unsigned char*)backBuffer[y])[x^2] = (y0 + u0 + v0) >> 8;
 96 | 			((unsigned char*)backBuffer[y])[(x + 1)^2] = (y0 + u1 + v1) >> 8;
 97 | 		}
 98 | 		
 99 | 		
100 | 		//backBuffer[y][x^2] = color;
101 | 		//backBuffer[y][(x + 1)^2] = color;
102 | 		//backBuffer[y][(x + 2)^2] = color;
103 | 		//backBuffer[y][(x + 3)^2] = color;
104 | 	}
105 | 
106 | 	virtual void dot(int x, int y, Color color)
107 | 	{
108 | 		if ((unsigned int)x < xres / 2 && (unsigned int)y < yres)
109 | 		{
110 | 			dotFast(x, y, color);
111 | 		}
112 | 	}
113 | 
114 | 	virtual void dotAdd(int x, int y, Color color)
115 | 	{
116 | 		dot(x, y, color);
117 | /*		if ((unsigned int)x < xres && (unsigned int)y < yres)
118 | 		{
119 | 			int c0 = backBuffer[y][x^2];
120 | 			int c1 = color;
121 | 			int cn = c0 + c1 - BlackLevel;
122 | 			if(cn > 255) cn = 255;
123 | 			backBuffer[y][x^2] = cn;
124 | 		}*/
125 | 	}
126 | 	
127 | 	virtual void dotMix(int x, int y, Color color)
128 | 	{
129 | 		dot(x, y, color);
130 | 		/*if ((unsigned int)x < xres && (unsigned int)y < yres)
131 | 			backBuffer[y][x^2] = ((int)backBuffer[y][x^2] + color) / 2;*/
132 | 	}
133 | 	
134 | 	virtual Color get(int x, int y)
135 | 	{
136 | 		/*if ((unsigned int)x < xres && (unsigned int)y < yres)
137 | 			return backBuffer[y][x^2];*/
138 | 		return 0;
139 | 	}
140 | 
141 | 	virtual void clear(Color color = 0)
142 | 	{
143 | 		for (int y = 0; y < this->yres; y++)
144 | 			for (int x = 0; x < this->xres; x++)
145 | 				((unsigned char*)backBuffer[y])[x^2] = BlackLevel;
146 | 	}
147 | 	
148 | 	virtual Color** allocateFrameBuffer()
149 | 	{
150 | 		return Graphics<Color>::allocateFrameBuffer(xres, yres, (Color)BlackLevel);
151 | 	}
152 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/GraphicsR1G1B1A1.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "Graphics.h"
 14 | 
 15 | class GraphicsR1G1B1A1: public Graphics<unsigned char>
 16 | {
 17 | 	public:
 18 | 	typedef unsigned char Color;
 19 | 	GraphicsR1G1B1A1()
 20 | 	{
 21 | 		frontColor = 0xf;
 22 | 	}
 23 | 
 24 | 	virtual int R(Color c) const
 25 | 	{
 26 | 		return (c & 1) * 255;
 27 | 	}
 28 | 	virtual int G(Color c) const
 29 | 	{
 30 | 		return (c & 2) ? 255 : 0;
 31 | 	}
 32 | 	virtual int B(Color c) const
 33 | 	{
 34 | 		return (c & 4) ? 255 : 0;
 35 | 	}
 36 | 	virtual int A(Color c) const
 37 | 	{
 38 | 		return (c & 8) ? 255 : 0;
 39 | 	}
 40 | 
 41 | 	virtual Color RGBA(int r, int g, int b, int a = 255) const
 42 | 	{
 43 | 		return ((r >> 7) & 1) | ((g >> 6) & 2) | ((b >> 5) & 4) | ((a >> 4) & 8);
 44 | 	}
 45 | 
 46 | 	virtual void dotFast(int x, int y, Color color)
 47 | 	{
 48 | 		if(x & 1)
 49 | 			backBuffer[y][x >> 1] =  (backBuffer[y][x >> 1] & 0xf) | (color << 4);
 50 | 		else
 51 | 			backBuffer[y][x >> 1] = (backBuffer[y][x >> 1] & 0xf0) | (color & 0xf);
 52 | 	}
 53 | 
 54 | 	virtual void dot(int x, int y, Color color)
 55 | 	{
 56 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 57 | 		{
 58 | 			if(x & 1)
 59 | 				backBuffer[y][x >> 1] = (backBuffer[y][x >> 1] & 0xf) | (color << 4);
 60 | 			else
 61 | 				backBuffer[y][x >> 1] = (backBuffer[y][x >> 1] & 0xf0) | (color & 0xf);
 62 | 		}
 63 | 	}
 64 | 
 65 | 	virtual void dotAdd(int x, int y, Color color)
 66 | 	{
 67 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 68 | 		{
 69 | 			if(x & 1)
 70 | 				backBuffer[y][x >> 1] = backBuffer[y][x >> 1] | (color << 4);
 71 | 			else
 72 | 				backBuffer[y][x >> 1] = backBuffer[y][x >> 1] | (color & 0xf);
 73 | 		}
 74 | 	}
 75 | 	
 76 | 	virtual void dotMix(int x, int y, Color color)
 77 | 	{
 78 | 		if ((unsigned int)x < xres && (unsigned int)y < yres && (color & 8) != 0)
 79 | 		{
 80 | 			if(x & 1)
 81 | 				backBuffer[y][x >> 1] = (backBuffer[y][x >> 1] & 0xf) | (color << 4);
 82 | 			else
 83 | 				backBuffer[y][x >> 1] =  (backBuffer[y][x >> 1] & 0xf0) | (color & 0xf);
 84 | 		}	
 85 | 	}
 86 | 	
 87 | 	virtual Color get(int x, int y)
 88 | 	{
 89 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 90 | 		{
 91 | 			if(x & 1)
 92 | 				return backBuffer[y][x >> 1] = backBuffer[y][x >> 1] >> 4;
 93 | 			else
 94 | 				return backBuffer[y][x >> 1] = backBuffer[y][x >> 1] & 0xf;
 95 | 		}
 96 | 		return 0;
 97 | 	}
 98 | 
 99 | 	virtual void clear(Color color = 0)
100 | 	{
101 | 		for (int y = 0; y < this->yres; y++)
102 | 			for (int x = 0; x < this->xres / 2; x++)
103 | 				this->backBuffer[y][x] = color | (color << 4);
104 | 	}
105 | 
106 | 	virtual Color** allocateFrameBuffer()
107 | 	{
108 | 		return Graphics<Color>::allocateFrameBuffer(xres / 2, yres, (Color)0);
109 | 	}
110 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/GraphicsR1G1B1A1X2S2Swapped.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | 	Author: bitluni 2019
 3 | 	License: 
 4 | 	Creative Commons Attribution ShareAlike 4.0
 5 | 	https://creativecommons.org/licenses/by-sa/4.0/
 6 | 	
 7 | 	For further details check out: 
 8 | 		https://youtube.com/bitlunislab
 9 | 		https://github.com/bitluni
10 | 		http://bitluni.net
11 | */
12 | #pragma once
13 | #include "Graphics.h"
14 | 
15 | class GraphicsR1G1B1A1X2S2Swapped: public Graphics<unsigned char>
16 | {
17 | 	public:
18 | 	typedef unsigned char Color;
19 | 	static const Color RGBAXMask = 0x3f;
20 | 	Color SBits;
21 | 	
22 | 	GraphicsR1G1B1A1X2S2Swapped()
23 | 	{
24 | 		SBits = 0xc0;
25 | 		frontColor = 0xf;
26 | 	}
27 | 
28 | 	virtual int R(Color c) const
29 | 	{
30 | 		return (c & 1) * 255;
31 | 	}
32 | 	virtual int G(Color c) const
33 | 	{
34 | 		return (c & 2) ? 255 : 0;
35 | 	}
36 | 	virtual int B(Color c) const
37 | 	{
38 | 		return (c & 4) ? 255 : 0;
39 | 	}
40 | 	virtual int A(Color c) const
41 | 	{
42 | 		return (c & 8) ? 255 : 0;
43 | 	}
44 | 
45 | 	virtual Color RGBA(int r, int g, int b, int a = 255) const
46 | 	{
47 | 		return ((r >> 7) & 1) | ((g >> 6) & 2) | ((b >> 5) & 4) | ((a >> 4) & 8);
48 | 	}
49 | 
50 | 	virtual void dotFast(int x, int y, Color color)
51 | 	{
52 | 		backBuffer[y][x^2] = (color & RGBAXMask) | SBits;
53 | 	}
54 | 
55 | 	virtual void dot(int x, int y, Color color)
56 | 	{
57 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
58 | 			backBuffer[y][x^2] = (color & RGBAXMask) | SBits;
59 | 	}
60 | 
61 | 	virtual void dotAdd(int x, int y, Color color)
62 | 	{
63 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
64 | 			backBuffer[y][x^2] = backBuffer[y][x^2] | (color & RGBAXMask);
65 | 	}
66 | 	
67 | 	virtual void dotMix(int x, int y, Color color)
68 | 	{
69 | 		if ((unsigned int)x < xres && (unsigned int)y < yres && (color & 8) != 0)
70 | 			backBuffer[y][x^2] = (color & RGBAXMask) | SBits;
71 | 	}
72 | 	
73 | 	virtual Color get(int x, int y)
74 | 	{
75 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
76 | 			return backBuffer[y][x^2] & RGBAXMask;
77 | 		return 0;
78 | 	}
79 | 
80 | 	virtual void clear(Color color = 0)
81 | 	{
82 | 		for (int y = 0; y < this->yres; y++)
83 | 			for (int x = 0; x < this->xres; x++)
84 | 				backBuffer[y][x^2] = (color & RGBAXMask) | SBits;
85 | 	}
86 | 
87 | 	virtual Color** allocateFrameBuffer()
88 | 	{
89 | 		return Graphics<Color>::allocateFrameBuffer(xres, yres, (Color)SBits);
90 | 	}
91 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/GraphicsR2G2B2A2.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "Graphics.h"
 14 | 
 15 | class GraphicsR2G2B2A2: public Graphics<unsigned char>
 16 | {
 17 | 	public:
 18 | 	typedef unsigned char Color;
 19 | 	static const Color RGBAXMask = 0x3f;
 20 | 	Color SBits;
 21 | 	
 22 | 	GraphicsR2G2B2A2()
 23 | 	{
 24 | 		SBits = 0xc0;
 25 | 		frontColor = 0xff;
 26 | 	}
 27 | 
 28 | 	virtual int R(Color c) const
 29 | 	{
 30 | 		return (((int)c & 3) * 255 + 1) / 3;
 31 | 	}
 32 | 	virtual int G(Color c) const
 33 | 	{
 34 | 		return (((int)(c >> 2) & 3) * 255 + 1) / 3;
 35 | 	}
 36 | 	virtual int B(Color c) const
 37 | 	{
 38 | 		return (((int)(c >> 4) & 3) * 255 + 1) / 3;
 39 | 	}
 40 | 	virtual int A(Color c) const
 41 | 	{
 42 | 		return (((int)(c >> 6) & 3) * 255 + 1) / 3;
 43 | 	}
 44 | 
 45 | 	virtual Color RGBA(int r, int g, int b, int a = 255) const
 46 | 	{
 47 | 		return ((r >> 6) & 0b11) | ((g >> 4) & 0b1100) | ((b >> 2) & 0b110000) | (a & 0b11000000);
 48 | 	}
 49 | 
 50 | 	virtual void dotFast(int x, int y, Color color)
 51 | 	{
 52 | 		backBuffer[y][x] = (color & RGBAXMask) | SBits;
 53 | 	}
 54 | 
 55 | 	virtual void dot(int x, int y, Color color)
 56 | 	{
 57 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 58 | 			backBuffer[y][x] = (color & RGBAXMask) | SBits;
 59 | 	}
 60 | 
 61 | 	virtual void dotAdd(int x, int y, Color color)
 62 | 	{
 63 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 64 | 		{
 65 | 			int c0 = backBuffer[y][x^2];
 66 | 			int c1 = color;
 67 | 			int r = (c0 & 0b11) + (c1 & 0b11);
 68 | 			if(r > 0b11) r = 0b11;
 69 | 			int g = (c0 & 0b1100) + (c1 & 0b1100);
 70 | 			if(g > 0b1100) g = 0b1100;
 71 | 			int b = (c0 & 0b110000) + (c1 & 0b110000);
 72 | 			if(b > 0b110000) b = 0b110000;
 73 | 			backBuffer[y][x] = r | (g & 0b1100) | (b & 0b110000) | SBits;
 74 | 		}
 75 | 	}
 76 | 	
 77 | 	virtual void dotMix(int x, int y, Color color)
 78 | 	{
 79 | 		if ((unsigned int)x < xres && (unsigned int)y < yres && (color >> 6) != 0)
 80 | 		{
 81 | 			unsigned int ai = (3 - ((int)color >> 6)) * (65536 / 3);
 82 | 			unsigned int a = 65536 - ai;
 83 | 			unsigned int co = backBuffer[y][x^2];
 84 | 			unsigned int ro = (co & 0b11) * ai;
 85 | 			unsigned int go = (co & 0b1100) * ai;
 86 | 			unsigned int bo = (co & 0b110000) * ai;
 87 | 			unsigned int r = (color & 0b11) * a + ro;
 88 | 			unsigned int g = ((color & 0b1100) * a + go) & 0b11000000000000000000;
 89 | 			unsigned int b = ((color & 0b110000) * a + bo) & 0b1100000000000000000000;
 90 | 			backBuffer[y][x] = ((r | g | b) >> 16) | SBits;
 91 | 		}	
 92 | 	}
 93 | 	
 94 | 	virtual Color get(int x, int y)
 95 | 	{
 96 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 97 | 			return backBuffer[y][x] & RGBAXMask;
 98 | 		return 0;
 99 | 	}
100 | 
101 | 	virtual void clear(Color color = 0)
102 | 	{
103 | 		for (int y = 0; y < this->yres; y++)
104 | 			for (int x = 0; x < this->xres; x++)
105 | 				backBuffer[y][x] = (color & RGBAXMask) | SBits;
106 | 	}
107 | 
108 | 	virtual void imageR2G2B2A2(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres)
109 | 	{
110 | 		for (int py = 0; py < srcYres; py++)
111 | 		{
112 | 			int i = srcX + (py + srcY) * image.xres;
113 | 			for (int px = 0; px < srcXres; px++)
114 | 				dot(px + x, py + y, ((unsigned char*)image.pixels)[i++]);
115 | 		}		
116 | 	}
117 | 
118 | 	virtual void imageAddR2G2B2A2(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres)
119 | 	{
120 | 		for (int py = 0; py < srcYres; py++)
121 | 		{
122 | 			int i = srcX + (py + srcY) * image.xres;
123 | 			for (int px = 0; px < srcXres; px++)
124 | 				dotAdd(px + x, py + y, ((unsigned char*)image.pixels)[i++]);
125 | 		}
126 | 	}
127 | 
128 | 	virtual void imageMixR2G2B2A2(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres)
129 | 	{
130 | 		for (int py = 0; py < srcYres; py++)
131 | 		{
132 | 			int i = srcX + (py + srcY) * image.xres;
133 | 			for (int px = 0; px < srcXres; px++)
134 | 				dotMix(px + x, py + y, ((unsigned char*)image.pixels)[i++]);
135 | 		}
136 | 	}	
137 | 
138 | 	virtual Color** allocateFrameBuffer()
139 | 	{
140 | 		return Graphics<Color>::allocateFrameBuffer(xres, yres, (Color)SBits);
141 | 	}
142 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/GraphicsR2G2B2S2Swapped.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "Graphics.h"
 14 | 
 15 | class GraphicsR2G2B2S2Swapped: public Graphics<unsigned char>
 16 | {
 17 | 	public:
 18 | 	typedef unsigned char Color;
 19 | 	static const Color RGBAXMask = 0x3f;
 20 | 	Color SBits;
 21 | 	
 22 | 	GraphicsR2G2B2S2Swapped()
 23 | 	{
 24 | 		SBits = 0xc0;
 25 | 		frontColor = 0xff;
 26 | 	}
 27 | 
 28 | 	virtual int R(Color c) const
 29 | 	{
 30 | 		return (((int)c & 3) * 255 + 1) / 3;
 31 | 	}
 32 | 	virtual int G(Color c) const
 33 | 	{
 34 | 		return (((int)(c >> 2) & 3) * 255 + 1) / 3;
 35 | 	}
 36 | 	virtual int B(Color c) const
 37 | 	{
 38 | 		return (((int)(c >> 4) & 3) * 255 + 1) / 3;
 39 | 	}
 40 | 	virtual int A(Color c) const
 41 | 	{
 42 | 		return (((int)(c >> 6) & 3) * 255 + 1) / 3;
 43 | 	}
 44 | 
 45 | 	virtual Color RGBA(int r, int g, int b, int a = 255) const
 46 | 	{
 47 | 		return ((r >> 6) & 0b11) | ((g >> 4) & 0b1100) | ((b >> 2) & 0b110000) | (a & 0b11000000);
 48 | 	}
 49 | 
 50 | 	virtual void dotFast(int x, int y, Color color)
 51 | 	{
 52 | 		backBuffer[y][x^2] = (color & RGBAXMask) | SBits;
 53 | 	}
 54 | 
 55 | 	virtual void dot(int x, int y, Color color)
 56 | 	{
 57 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 58 | 			backBuffer[y][x^2] = (color & RGBAXMask) | SBits;
 59 | 	}
 60 | 
 61 | 	virtual void dotAdd(int x, int y, Color color)
 62 | 	{
 63 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 64 | 		{
 65 | 			int c0 = backBuffer[y][x^2];
 66 | 			int c1 = color;
 67 | 			int r = (c0 & 0b11) + (c1 & 0b11);
 68 | 			if(r > 0b11) r = 0b11;
 69 | 			int g = (c0 & 0b1100) + (c1 & 0b1100);
 70 | 			if(g > 0b1100) g = 0b1100;
 71 | 			int b = (c0 & 0b110000) + (c1 & 0b110000);
 72 | 			if(b > 0b110000) b = 0b110000;
 73 | 			backBuffer[y][x^2] = r | (g & 0b1100) | (b & 0b110000) | SBits;
 74 | 		}
 75 | 	}
 76 | 	
 77 | 	virtual void dotMix(int x, int y, Color color)
 78 | 	{
 79 | 		if ((unsigned int)x < xres && (unsigned int)y < yres && (color >> 6) != 0)
 80 | 		{
 81 | 			unsigned int ai = (3 - ((int)color >> 6)) * (65536 / 3);
 82 | 			unsigned int a = 65536 - ai;
 83 | 			unsigned int co = backBuffer[y][x^2];
 84 | 			unsigned int ro = (co & 0b11) * ai;
 85 | 			unsigned int go = (co & 0b1100) * ai;
 86 | 			unsigned int bo = (co & 0b110000) * ai;
 87 | 			unsigned int r = (color & 0b11) * a + ro;
 88 | 			unsigned int g = ((color & 0b1100) * a + go) & 0b11000000000000000000;
 89 | 			unsigned int b = ((color & 0b110000) * a + bo) & 0b1100000000000000000000;
 90 | 			backBuffer[y][x^2] = ((r | g | b) >> 16) | SBits;
 91 | 		}	
 92 | 	}
 93 | 	
 94 | 	virtual Color get(int x, int y)
 95 | 	{
 96 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 97 | 			return backBuffer[y][x^2] & RGBAXMask;
 98 | 		return 0;
 99 | 	}
100 | 
101 | 	virtual void clear(Color color = 0)
102 | 	{
103 | 		for (int y = 0; y < this->yres; y++)
104 | 			for (int x = 0; x < this->xres; x++)
105 | 				backBuffer[y][x^2] = (color & RGBAXMask) | SBits;
106 | 	}
107 | 
108 | 	virtual void imageR2G2B2A2(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres)
109 | 	{
110 | 		for (int py = 0; py < srcYres; py++)
111 | 		{
112 | 			int i = srcX + (py + srcY) * image.xres;
113 | 			for (int px = 0; px < srcXres; px++)
114 | 				dot(px + x, py + y, ((unsigned char*)image.pixels)[i++]);
115 | 		}		
116 | 	}
117 | 
118 | 	virtual void imageAddR2G2B2A2(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres)
119 | 	{
120 | 		for (int py = 0; py < srcYres; py++)
121 | 		{
122 | 			int i = srcX + (py + srcY) * image.xres;
123 | 			for (int px = 0; px < srcXres; px++)
124 | 				dotAdd(px + x, py + y, ((unsigned char*)image.pixels)[i++]);
125 | 		}
126 | 	}
127 | 
128 | 	virtual void imageMixR2G2B2A2(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres)
129 | 	{
130 | 		for (int py = 0; py < srcYres; py++)
131 | 		{
132 | 			int i = srcX + (py + srcY) * image.xres;
133 | 			for (int px = 0; px < srcXres; px++)
134 | 				dotMix(px + x, py + y, ((unsigned char*)image.pixels)[i++]);
135 | 		}
136 | 	}	
137 | 	
138 | 	virtual Color** allocateFrameBuffer()
139 | 	{
140 | 		return Graphics<Color>::allocateFrameBuffer(xres, yres, (Color)SBits);
141 | 	}
142 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/GraphicsR5G5B4A2.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "Graphics.h"
 14 | 
 15 | class GraphicsR5G5B4A2: public Graphics<unsigned short>
 16 | {
 17 | 	public:
 18 | 	typedef unsigned short Color;
 19 | 	GraphicsR5G5B4A2()
 20 | 	{
 21 | 		frontColor = 0xffff;
 22 | 	}
 23 | 
 24 | 	virtual int R(Color c) const
 25 | 	{
 26 | 		return (((c << 1) & 0x3e) * 255 + 1) / 0x3e;
 27 | 	}
 28 | 	virtual int G(Color c) const
 29 | 	{
 30 | 		return (((c >> 4) & 0x3e) * 255 + 1) / 0x3e;
 31 | 	}
 32 | 	virtual int B(Color c) const
 33 | 	{
 34 | 		return (((c >> 9) & 0x1e) * 255 + 1) / 0x1e;
 35 | 	}
 36 | 	virtual int A(Color c) const
 37 | 	{
 38 | 		return (((c >> 13) & 6) * 255 + 1) / 6;
 39 | 	}
 40 | 
 41 | 	virtual Color RGBA(int r, int g, int b, int a = 255) const
 42 | 	{
 43 | 		return ((r >> 3) & 0b11111) | ((g << 2) & 0b1111100000) | ((b << 6) & 0b11110000000000) | ((a << 8) & 0xc000);
 44 | 	}
 45 | 
 46 | 	virtual void dotFast(int x, int y, Color color)
 47 | 	{
 48 | 		backBuffer[y][x] = color;
 49 | 	}
 50 | 
 51 | 	virtual void dot(int x, int y, Color color)
 52 | 	{
 53 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 54 | 			backBuffer[y][x] = color;
 55 | 	}
 56 | 
 57 | 	virtual void dotAdd(int x, int y, Color color)
 58 | 	{
 59 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 60 | 		{
 61 | 			int c0 = backBuffer[y][x];
 62 | 			int c1 = color;
 63 | 			int r = (c0 & 0b11111) + (c1 & 0b11111);
 64 | 			if(r > 0b11111) r = 0b11111;
 65 | 			int g = (c0 & 0b1111100000) + (c1 & 0b1111100000);
 66 | 			if(g > 0b1111100000) g = 0b1111100000;
 67 | 			int b = (c0 & 0b11110000000000) + (c1 & 0b11110000000000);
 68 | 			if(b > 0b11110000000000) b = 0b11110000000000;
 69 | 			backBuffer[y][x] = r | (g & 0b1111100000) | (b & 0b11110000000000);
 70 | 		}
 71 | 	}
 72 | 	
 73 | 	virtual void dotMix(int x, int y, Color color)
 74 | 	{
 75 | 		if ((unsigned int)x < xres && (unsigned int)y < yres && (color >> 14) != 0)
 76 | 		{
 77 | 			unsigned int ai = (3 - (color >> 14)) * (65536 / 3);
 78 | 			unsigned int a = 65536 - ai;
 79 | 			unsigned int co = backBuffer[y][x];
 80 | 			unsigned int ro = (co & 0b11111) * ai;
 81 | 			unsigned int go = (co & 0b1111100000) * ai;
 82 | 			unsigned int bo = (co & 0b11110000000000) * ai;
 83 | 			unsigned int r = (color & 0b11111) * a + ro;
 84 | 			unsigned int g = ((color & 0b1111100000) * a + go) & 0b11111000000000000000000000;
 85 | 			unsigned int b = ((color & 0b11110000000000) * a + bo) & 0b111100000000000000000000000000;
 86 | 			backBuffer[y][x] = (r | g | b) >> 16;
 87 | 		}	
 88 | 	}
 89 | 	
 90 | 	virtual Color get(int x, int y)
 91 | 	{
 92 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 93 | 			return backBuffer[y][x];
 94 | 		return 0;
 95 | 	}
 96 | 
 97 | 	virtual void clear(Color color = 0)
 98 | 	{
 99 | 		for (int y = 0; y < this->yres; y++)
100 | 			for (int x = 0; x < this->xres; x++)
101 | 				backBuffer[y][x] = color;
102 | 	}
103 | 
104 | 	virtual Color** allocateFrameBuffer()
105 | 	{
106 | 		return Graphics<Color>::allocateFrameBuffer(xres, yres, (Color)0);
107 | 	}
108 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/GraphicsR5G5B4S2Swapped.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "Graphics.h"
 14 | 
 15 | class GraphicsR5G5B4S2Swapped: public Graphics<unsigned short>
 16 | {
 17 | 	public:
 18 | 	typedef unsigned short Color;
 19 | 	static const Color RGBMask = 0x3fff;
 20 | 	Color SBits;
 21 | 
 22 | 	GraphicsR5G5B4S2Swapped()
 23 | 	{
 24 | 		SBits = 0xc000;
 25 | 		frontColor = 0xffff;
 26 | 	}
 27 | 
 28 | 	virtual int R(Color c) const
 29 | 	{
 30 | 		return (((c << 1) & 0x3e) * 255 + 1) / 0x3e;
 31 | 	}
 32 | 	virtual int G(Color c) const
 33 | 	{
 34 | 		return (((c >> 4) & 0x3e) * 255 + 1) / 0x3e;
 35 | 	}
 36 | 	virtual int B(Color c) const
 37 | 	{
 38 | 		return (((c >> 9) & 0x1e) * 255 + 1) / 0x1e;
 39 | 	}
 40 | 	virtual int A(Color c) const
 41 | 	{
 42 | 		return (((c >> 13) & 6) * 255 + 1) / 6;
 43 | 	}
 44 | 
 45 | 	virtual Color RGBA(int r, int g, int b, int a = 255) const
 46 | 	{
 47 | 		return ((r >> 3) & 0b11111) | ((g << 2) & 0b1111100000) | ((b << 6) & 0b11110000000000) | ((a << 8) & 0xc000);
 48 | 	}
 49 | 
 50 | 	virtual void dotFast(int x, int y, Color color)
 51 | 	{
 52 | 		backBuffer[y][x^1] = (color & RGBMask) | SBits;
 53 | 	}
 54 | 
 55 | 	virtual void dot(int x, int y, Color color)
 56 | 	{
 57 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 58 | 			backBuffer[y][x^1] = (color & RGBMask) | SBits;
 59 | 	}
 60 | 
 61 | 	virtual void dotAdd(int x, int y, Color color)
 62 | 	{
 63 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 64 | 		{
 65 | 			int c0 = backBuffer[y][x^1];
 66 | 			int c1 = color;
 67 | 			int r = (c0 & 0b11111) + (c1 & 0b11111);
 68 | 			if(r > 0b11111) r = 0b11111;
 69 | 			int g = (c0 & 0b1111100000) + (c1 & 0b1111100000);
 70 | 			if(g > 0b1111100000) g = 0b1111100000;
 71 | 			int b = (c0 & 0b11110000000000) + (c1 & 0b11110000000000);
 72 | 			if(b > 0b11110000000000) b = 0b11110000000000;
 73 | 			backBuffer[y][x^1] = r | (g & 0b1111100000) | (b & 0b11110000000000) | SBits;
 74 | 		}
 75 | 	}
 76 | 	
 77 | 	virtual void dotMix(int x, int y, Color color)
 78 | 	{
 79 | 		if ((unsigned int)x < xres && (unsigned int)y < yres && (color >> 14) != 0)
 80 | 		{
 81 | 			unsigned int ai = (3 - (color >> 14)) * (65536 / 3);
 82 | 			unsigned int a = 65536 - ai;
 83 | 			unsigned int co = backBuffer[y][x^1];
 84 | 			unsigned int ro = (co & 0b11111) * ai;
 85 | 			unsigned int go = (co & 0b1111100000) * ai;
 86 | 			unsigned int bo = (co & 0b11110000000000) * ai;
 87 | 			unsigned int r = (color & 0b11111) * a + ro;
 88 | 			unsigned int g = ((color & 0b1111100000) * a + go) & 0b11111000000000000000000000;
 89 | 			unsigned int b = ((color & 0b11110000000000) * a + bo) & 0b111100000000000000000000000000;
 90 | 			backBuffer[y][x^1] = ((r | g | b) >> 16) | SBits;
 91 | 		}	
 92 | 	}
 93 | 	
 94 | 	virtual Color get(int x, int y)
 95 | 	{
 96 | 		if ((unsigned int)x < xres && (unsigned int)y < yres)
 97 | 			return backBuffer[y][x^1] & RGBMask;
 98 | 		return 0;
 99 | 	}
100 | 
101 | 	virtual void clear(Color color = 0)
102 | 	{
103 | 		for (int y = 0; y < this->yres; y++)
104 | 			for (int x = 0; x < this->xres; x++)
105 | 				backBuffer[y][x^1] = (color & RGBMask) | SBits;
106 | 	}
107 | 
108 | 	virtual Color** allocateFrameBuffer()
109 | 	{
110 | 		return Graphics<Color>::allocateFrameBuffer(xres, yres, (Color)SBits);
111 | 	}
112 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/Image.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | 	Author: bitluni 2019
 3 | 	License: 
 4 | 	Creative Commons Attribution ShareAlike 4.0
 5 | 	https://creativecommons.org/licenses/by-sa/4.0/
 6 | 	
 7 | 	For further details check out: 
 8 | 		https://youtube.com/bitlunislab
 9 | 		https://github.com/bitluni
10 | 		http://bitluni.net
11 | */
12 | #pragma once
13 | 
14 | class Image
15 | {
16 |   public:
17 | 	enum PixelFormat
18 | 	{
19 | 		R8G8B8A8 = 1,
20 | 		R1G1B1A1 = 2,
21 | 		R2G2B2A2 = 3,
22 | 		R4G4B4A4 = 4,
23 | 		R5G5B5A1 = 5,
24 | 		R5G5B4A2 = 6
25 | 	};
26 | 
27 | 	int xres;
28 | 	int yres;
29 | 	PixelFormat pixelFormat;
30 | 	const void *pixels;
31 | 
32 | 	void init(int xres, int yres, const void *pixels, PixelFormat pixelFormat)
33 | 	{
34 | 		this->xres = xres;
35 | 		this->yres = yres;
36 | 		this->pixels = pixels;
37 | 		this->pixelFormat = pixelFormat;
38 | 	}
39 | 
40 | 	Image(){};
41 | 
42 | 	Image(int xres, int yres, const void *pixels, PixelFormat pixelFormat)
43 | 	{
44 | 		init(xres, yres, pixels, pixelFormat);
45 | 	}
46 | 
47 | 	/*
48 | 	Color get(int x, int y) const
49 | 	{
50 | 		return pixels[y * xres + x];
51 | 	}*/
52 | };
53 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/ImageDrawer.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "Image.h"
 14 | class ImageDrawer
 15 | {
 16 | 	public:
 17 | 	virtual void imageR8G8B8A8(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres) = 0;
 18 | 	virtual void imageAddR8G8B8A8(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres) = 0;
 19 | 	virtual void imageMixR8G8B8A8(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres) = 0;
 20 | 	virtual void imageR5G5B4A2(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres) = 0;
 21 | 	virtual void imageAddR5G5B4A2(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres) = 0;
 22 | 	virtual void imageMixR5G5B4A2(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres) = 0;
 23 | 	virtual void imageR2G2B2A2(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres) = 0;
 24 | 	virtual void imageAddR2G2B2A2(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres) = 0;
 25 | 	virtual void imageMixR2G2B2A2(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres) = 0;
 26 | 	virtual void imageR4G4B4A4(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres) = 0;
 27 | 	virtual void imageAddR4G4B4A4(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres) = 0;
 28 | 	virtual void imageMixR4G4B4A4(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres) = 0;
 29 | 
 30 | 	void image(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres)
 31 | 	{
 32 | 		switch(image.pixelFormat)
 33 | 		{
 34 | 			case Image::R8G8B8A8:
 35 | 				imageR8G8B8A8(image, x, y, srcX, srcY, srcXres, srcYres);
 36 | 			break;
 37 | 			case Image::R5G5B4A2:
 38 | 				imageR5G5B4A2(image, x, y, srcX, srcY, srcXres, srcYres);
 39 | 			break;
 40 | 			case Image::R2G2B2A2:
 41 | 				imageR2G2B2A2(image, x, y, srcX, srcY, srcXres, srcYres);
 42 | 			break;
 43 | 			case Image::R4G4B4A4:
 44 | 				imageR4G4B4A4(image, x, y, srcX, srcY, srcXres, srcYres);
 45 | 			break;
 46 | 			default:
 47 | 			break;
 48 | 		}
 49 | 	}
 50 | 
 51 | 	void imageAdd(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres)
 52 | 	{
 53 | 		switch(image.pixelFormat)
 54 | 		{
 55 | 			case Image::R8G8B8A8:
 56 | 				imageAddR8G8B8A8(image, x, y, srcX, srcY, srcXres, srcYres);
 57 | 			break;
 58 | 			case Image::R5G5B4A2:
 59 | 				imageAddR5G5B4A2(image, x, y, srcX, srcY, srcXres, srcYres);
 60 | 			break;
 61 | 			case Image::R2G2B2A2:
 62 | 				imageAddR2G2B2A2(image, x, y, srcX, srcY, srcXres, srcYres);
 63 | 			break;
 64 | 			case Image::R4G4B4A4:
 65 | 				imageAddR4G4B4A4(image, x, y, srcX, srcY, srcXres, srcYres);
 66 | 			break;
 67 | 			default:
 68 | 			break;
 69 | 		}
 70 | 	}
 71 | 
 72 | 	void imageMix(Image &image, int x, int y, int srcX, int srcY, int srcXres, int srcYres)
 73 | 	{
 74 | 		switch(image.pixelFormat)
 75 | 		{
 76 | 			case Image::R8G8B8A8:
 77 | 				imageMixR8G8B8A8(image, x, y, srcX, srcY, srcXres, srcYres);
 78 | 			break;
 79 | 			case Image::R5G5B4A2:
 80 | 				imageMixR5G5B4A2(image, x, y, srcX, srcY, srcXres, srcYres);
 81 | 			break;
 82 | 			case Image::R2G2B2A2:
 83 | 				imageMixR2G2B2A2(image, x, y, srcX, srcY, srcXres, srcYres);
 84 | 			break;
 85 | 			case Image::R4G4B4A4:
 86 | 				imageMixR4G4B4A4(image, x, y, srcX, srcY, srcXres, srcYres);
 87 | 			break;
 88 | 			default:
 89 | 			break;
 90 | 		}
 91 | 	}
 92 | 
 93 | 	void image(Image &image, int x, int y)
 94 | 	{
 95 | 		switch(image.pixelFormat)
 96 | 		{
 97 | 			case Image::R8G8B8A8:
 98 | 				imageR8G8B8A8(image, x, y, 0, 0, image.xres, image.yres);
 99 | 			break;
100 | 			case Image::R5G5B4A2:
101 | 				imageR5G5B4A2(image, x, y, 0, 0, image.xres, image.yres);
102 | 			break;
103 | 			case Image::R2G2B2A2:
104 | 				imageR2G2B2A2(image, x, y, 0, 0, image.xres, image.yres);
105 | 			break;
106 | 			case Image::R4G4B4A4:
107 | 				imageR4G4B4A4(image, x, y, 0, 0, image.xres, image.yres);
108 | 			break;
109 | 			default:
110 | 			break;
111 | 		}
112 | 	}
113 | 
114 | 	void imageAdd(Image &image, int x, int y)
115 | 	{
116 | 		switch(image.pixelFormat)
117 | 		{
118 | 			case Image::R8G8B8A8:
119 | 				imageAddR8G8B8A8(image, x, y, 0, 0, image.xres, image.yres);
120 | 			break;
121 | 			case Image::R5G5B4A2:
122 | 				imageAddR5G5B4A2(image, x, y, 0, 0, image.xres, image.yres);
123 | 			break;
124 | 			case Image::R2G2B2A2:
125 | 				imageAddR2G2B2A2(image, x, y, 0, 0, image.xres, image.yres);
126 | 			break;
127 | 			case Image::R4G4B4A4:
128 | 				imageAddR4G4B4A4(image, x, y, 0, 0, image.xres, image.yres);
129 | 			break;
130 | 			default:
131 | 			break;
132 | 		}
133 | 	}
134 | 
135 | 	void imageMix(Image &image, int x, int y)
136 | 	{
137 | 		switch(image.pixelFormat)
138 | 		{
139 | 			case Image::R8G8B8A8:
140 | 				imageMixR8G8B8A8(image, x, y, 0, 0, image.xres, image.yres);
141 | 			break;
142 | 			case Image::R5G5B4A2:
143 | 				imageMixR5G5B4A2(image, x, y, 0, 0, image.xres, image.yres);
144 | 			break;
145 | 			case Image::R2G2B2A2:
146 | 				imageMixR2G2B2A2(image, x, y, 0, 0, image.xres, image.yres);
147 | 			break;
148 | 			case Image::R4G4B4A4:
149 | 				imageMixR4G4B4A4(image, x, y, 0, 0, image.xres, image.yres);
150 | 			break;
151 | 			default:
152 | 			break;
153 | 		}
154 | 	}
155 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/Mesh.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "../Math/Matrix.h"
 14 | #include "Engine3D.h"
 15 | #include "../Tools/Log.h"
 16 | 
 17 | template <typename Graphics>
 18 | class Mesh
 19 | {
 20 |   public:
 21 | 	typedef typename Graphics::Color Color;
 22 | 	int vertexCount;
 23 | 	int edgeCount;
 24 | 	int triangleCount;
 25 | 	const float (*vertices)[3];
 26 | 	const unsigned short (*edges)[2];
 27 | 	const unsigned short (*triangles)[3];
 28 | 	const float (*triangleNormals)[3];
 29 | 	short (*tvertices)[3];
 30 | 	signed char (*tTriNormals)[3];
 31 | 
 32 | 	typedef Color (*triangleShader)(int trinangleNo, short *v0, short *v1, short *v2, const signed char *normal, Color color);
 33 | 
 34 | 	Mesh(int vertCount, const float verts[][3], int edgeCount_ = 0, const unsigned short edges_[][2] = 0, int triCount = 0, const unsigned short tris[][3] = 0, const float triNorms[][3] = 0)
 35 | 		: vertexCount(vertCount),
 36 | 		  edgeCount(edgeCount_),
 37 | 		  triangleCount(triCount),
 38 | 		  vertices(verts),
 39 | 		  edges(edges_),
 40 | 		  triangles(tris),
 41 | 		  triangleNormals(triNorms)
 42 | 	{
 43 | 		tvertices = (short(*)[3])malloc(sizeof(short) * 3 * vertexCount);
 44 | 		if(!tvertices)
 45 | 			ERROR("Not enough memory for vertices");
 46 | 		if (triangleNormals)
 47 | 		{
 48 | 			tTriNormals = (signed char(*)[3])malloc(sizeof(signed char) * 3 * triangleCount);
 49 | 			if(!tTriNormals)
 50 | 				ERROR("Not enough memory for triangle normals");
 51 | 		}
 52 | 	}
 53 | 
 54 | 	~Mesh()
 55 | 	{
 56 | 		delete (tvertices);
 57 | 	}
 58 | 
 59 | 	static Color basicTriangleShader(int trinangleNo, short *v0, short *v1, short *v2, const signed char *normal, Color color)
 60 | 	{
 61 | 		return color;
 62 | 	}
 63 | 
 64 | 	static Color basicTriangleShaderNormals(int trinangleNo, short *v0, short *v1, short *v2, const signed char *normal, Color color)
 65 | 	{
 66 | 		const float scaleN = 1.0f / 127.0f;
 67 | 		const float nx = normal[0] * scaleN;
 68 | 		const float ny = normal[1] * scaleN;
 69 | 		const float nz = normal[2] * scaleN;
 70 | 
 71 | 		const float L[3] = {0, 0, -1};
 72 | 
 73 | 		float NdotL = nx * L[0] + ny * L[1] + nz * L[2];
 74 | 		if(NdotL < 0) NdotL = 0; 
 75 | 		return  int(NdotL * (color & 0x1f)) | (int(NdotL * ((color >> 5) & 0x1f)) << 5) | (int(NdotL * ((color >> 10) & 0xf)) << 10);
 76 | 	}
 77 | 
 78 | 	void drawTriangles(Engine3D<Graphics> &e, Color color = -1, triangleShader ts = 0)
 79 | 	{
 80 | 		if(ts == 0)
 81 | 		{
 82 | 			if(tTriNormals)
 83 | 				ts = basicTriangleShaderNormals;
 84 | 			else
 85 | 				ts = basicTriangleShader;
 86 | 		}
 87 | 
 88 | 		for (int i = 0; i < triangleCount; i++)
 89 | 		{
 90 | 			short *v0 = tvertices[triangles[i][0]];
 91 | 			short *v1 = tvertices[triangles[i][1]];
 92 | 			short *v2 = tvertices[triangles[i][2]];
 93 | 			int dx1 = v1[0] - v0[0];
 94 | 			int dy1 = v1[1] - v0[1];
 95 | 			int dx2 = v2[0] - v0[0];
 96 | 			int dy2 = v2[1] - v0[1];
 97 | 			if (dx1 * dy2 - dx2 * dy1 < 0)
 98 | 			{
 99 | 				Color c = ts(i, v0, v1, v2, tTriNormals ? tTriNormals[i] : 0, color);
100 | 				e.enqueueTriangle(tvertices[triangles[i][0]], tvertices[triangles[i][1]], tvertices[triangles[i][2]], c);
101 | 			}
102 | 		}
103 | 	}
104 | 
105 | 	void drawEdges(Graphics &g, Color color)
106 | 	{
107 | 		for (int i = 0; i < edgeCount; i++)
108 | 		{
109 | 			g.line(tvertices[edges[i][0]][0], tvertices[edges[i][0]][1], tvertices[edges[i][1]][0], tvertices[edges[i][1]][1], color);
110 | 		}
111 | 	}
112 | 
113 | 	void drawVertices(Graphics &g, Color color)
114 | 	{
115 | 		for (int i = 0; i < vertexCount; i++)
116 | 			g.dot(tvertices[i][0], tvertices[i][1], color);
117 | 	}
118 | 
119 | 	void transform(Matrix m, Matrix normTrans = Matrix())
120 | 	{
121 | 		for (int i = 0; i < vertexCount; i++)
122 | 		{
123 | 			Vector v = m * Vector(vertices[i][0], vertices[i][1], vertices[i][2]);
124 | 			tvertices[i][0] = v[0] / v[3];
125 | 			tvertices[i][1] = v[1] / v[3];
126 | 			tvertices[i][2] = v[2];
127 | 		}
128 | 		if (triangleNormals)
129 | 			for (int i = 0; i < triangleCount; i++)
130 | 			{
131 | 				Vector v = normTrans * Vector(triangleNormals[i][0], triangleNormals[i][1], triangleNormals[i][2]);
132 | 				tTriNormals[i][0] = v[0] * 127;
133 | 				tTriNormals[i][1] = v[1] * 127;
134 | 				tTriNormals[i][2] = v[2] * 127;
135 | 			}
136 | 	}
137 | };
138 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/Sprites.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "ImageDrawer.h"
 14 | #include "Image.h"
 15 | 
 16 | class Sprite : public Image
 17 | {
 18 |   public:
 19 | 	typedef Image::PixelFormat PixelFormat;
 20 | 	unsigned char pointCount;
 21 | 	const signed short (*points)[2];
 22 | 
 23 | 	void init(int xres, int yres, const void *pixels, unsigned char pointCount, const signed short points[][2], PixelFormat pixelFormat)
 24 | 	{
 25 | 		static const signed short zeroPoint[][2] = {0, 0};
 26 | 		Image::init(xres, yres, pixels, pixelFormat);
 27 | 		if (pointCount)
 28 | 		{
 29 | 			this->pointCount = pointCount;
 30 | 			this->points = points;
 31 | 		}
 32 | 		else
 33 | 		{
 34 | 			this->pointCount = 1;
 35 | 			this->points = zeroPoint;
 36 | 		}
 37 | 	}
 38 | 	void draw(ImageDrawer &g, int x, int y)
 39 | 	{
 40 | 		g.image(*this, x - points[0][0], y - points[0][1]);
 41 | 	}
 42 | 
 43 | 	void drawMix(ImageDrawer &g, int x, int y)
 44 | 	{
 45 | 		g.imageMix(*this, x - points[0][0], y - points[0][1]);
 46 | 	}
 47 | 
 48 | 	void drawAdd(ImageDrawer &g, int x, int y)
 49 | 	{
 50 | 		g.imageAdd(*this, x - points[0][0], y - points[0][1]);
 51 | 	}
 52 | };
 53 | 
 54 | class Sprites
 55 | {
 56 |   public:
 57 | 	typedef Image::PixelFormat PixelFormat;
 58 | 	int count;
 59 | 	Sprite *sprites;
 60 | 
 61 | 	Sprites(int count, const void* pixels, const int offsets[], const unsigned short resolutions[][2], const signed short points[][2], const short pointOffsets[], PixelFormat pixelFormat)
 62 | 	{
 63 | 		this->count = count;
 64 | 		this->sprites = new Sprite[count];
 65 | 		for (int i = 0; i < count; i++)
 66 | 			this->sprites[i].init(resolutions[i][0], resolutions[i][1], (unsigned char*)pixels + offsets[i], pointOffsets[i + 1] - pointOffsets[i], &points[pointOffsets[i]], pixelFormat);
 67 | 	}
 68 | 
 69 | 	void draw(ImageDrawer &g, int sprite, int x, int y)
 70 | 	{
 71 | 		sprites[sprite].draw(g, x, y);
 72 | 	}
 73 | 
 74 | 	void drawMix(ImageDrawer &g, int sprite, int x, int y)
 75 | 	{
 76 | 		sprites[sprite].drawMix(g, x, y);
 77 | 	}
 78 | 
 79 | 	void drawAdd(ImageDrawer &g, int sprite, int x, int y)
 80 | 	{
 81 | 		sprites[sprite].drawAdd(g, x, y);
 82 | 	}
 83 | 
 84 | 	int xres(int sprite) const
 85 | 	{
 86 | 		return sprites[sprite].xres;
 87 | 	}
 88 | 
 89 | 	int yres(int sprite) const
 90 | 	{
 91 | 		return sprites[sprite].yres;
 92 | 	}
 93 | 
 94 | 	const short (*points(int sprite) const)[2]
 95 | 	{
 96 | 		return sprites[sprite].points;
 97 | 	}
 98 | 
 99 | 	const short *point(int sprite, int point) const
100 | 	{
101 | 		return sprites[sprite].points[point];
102 | 	}
103 | 
104 | 	/*unsigned short get(int sprite, int x, int y) const
105 | 	{
106 | 		return sprites[sprite].get(x, y);
107 | 	}*/
108 | };
109 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Graphics/TriangleTree.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | 
 14 | class TriangleTree
 15 | {
 16 |   public:
 17 | 	short *v[3];
 18 | 	int z;
 19 | 	TriangleTree *left, *right;
 20 | 	int depth;
 21 | 	long color;
 22 | 
 23 | 	void set(short *v0, short *v1, short *v2, long color)
 24 | 	{
 25 | 		v[0] = v0;
 26 | 		v[1] = v1;
 27 | 		v[2] = v2;
 28 | 		z = v[0][2] + v[1][2] + v[2][2];
 29 | 		this->color = color;
 30 | 		left = right = 0;
 31 | 		depth = 1;
 32 | 	}
 33 | 
 34 | 	int leftDepth() const
 35 | 	{
 36 | 		return left ? left->depth : 0;
 37 | 	}
 38 | 
 39 | 	int rightDepth() const
 40 | 	{
 41 | 		return right ? right->depth : 0;
 42 | 	}
 43 | 
 44 | 	void recalcDepth()
 45 | 	{
 46 | 		int l = leftDepth();
 47 | 		int r = rightDepth();
 48 | 		depth = l > r ? l : r;
 49 | 	}
 50 | 
 51 | 	int add(TriangleTree **origin, TriangleTree &t)
 52 | 	{
 53 | 		int d = 1;
 54 | 		if (t.z < z)
 55 | 		{
 56 | 			if (left)
 57 | 				d = left->add(&left, t);
 58 | 			else
 59 | 				left = &t;
 60 | 		}
 61 | 		else
 62 | 		{
 63 | 			if (right)
 64 | 				d = right->add(&right, t);
 65 | 			else
 66 | 				right = &t;
 67 | 		}
 68 | 		if (depth < d + 1)
 69 | 			depth = d + 1;
 70 | 		int l = leftDepth();
 71 | 		int r = rightDepth();
 72 | 		if (l > r + 1)
 73 | 		{
 74 | 			int ll = left->leftDepth();
 75 | 			int lr = left->rightDepth();
 76 | 			if (ll < lr)
 77 | 			{
 78 | 				TriangleTree *tl = left;
 79 | 				left = tl->right;
 80 | 				tl->right = left->left;
 81 | 				left->left = tl;
 82 | 				left->left->recalcDepth();
 83 | 				left->recalcDepth();
 84 | 				ll = left->leftDepth();
 85 | 				lr = left->rightDepth();
 86 | 				l = leftDepth();
 87 | 				recalcDepth();
 88 | 			}
 89 | 			{
 90 | 				*origin = left;
 91 | 				left = left->right;
 92 | 				(*origin)->right = this;
 93 | 				depth = lr > r ? lr + 1 : r + 1;
 94 | 				(*origin)->depth = ll > depth ? ll + 1 : depth + 1;
 95 | 				return (*origin)->depth + 1;
 96 | 			}
 97 | 		}
 98 | 		if (r > l + 1)
 99 | 		{
100 | 			int rl = right->leftDepth();
101 | 			int rr = right->rightDepth();
102 | 			if (rr < rl)
103 | 			{
104 | 				TriangleTree *tr = right;
105 | 				right = tr->left;
106 | 				tr->left = right->right;
107 | 				right->right = tr;
108 | 				right->right->recalcDepth();
109 | 				right->recalcDepth();
110 | 				rr = right->rightDepth();
111 | 				rl = right->leftDepth();
112 | 				r = rightDepth();
113 | 				recalcDepth();
114 | 			}
115 | 			{
116 | 				*origin = right;
117 | 				right = right->left;
118 | 				(*origin)->left = this;
119 | 				depth = rl > l ? rl + 1 : l + 1;
120 | 				(*origin)->depth = rr > depth ? rr + 1 : depth + 1;
121 | 				return (*origin)->depth + 1;
122 | 			}
123 | 		}
124 | 		return depth;
125 | 	}
126 | };
127 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/I2S/DMABufferDescriptor.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "../Tools/Log.h"
 14 | 
 15 | class DMABufferDescriptor : protected lldesc_t
 16 | {
 17 |   public:
 18 | 	static void *allocateBuffer(int bytes, bool clear = true, unsigned long clearValue = 0)
 19 | 	{
 20 | 		bytes = (bytes + 3) & 0xfffffffc;
 21 | 		void *b = heap_caps_malloc(bytes, MALLOC_CAP_DMA);
 22 | 		if (!b)
 23 | 			DEBUG_PRINTLN("Failed to alloc dma buffer");
 24 | 		if (clear)
 25 | 			for (int i = 0; i < bytes / 4; i++)
 26 | 				((unsigned long *)b)[i] = clearValue;
 27 | 		return b;
 28 | 	}
 29 | 
 30 | 	static void **allocateDMABufferArray(int count, int bytes, bool clear = true, unsigned long clearValue = 0)
 31 | 	{
 32 | 		void **arr = (void **)malloc(count * sizeof(void *));
 33 | 		if(!arr)
 34 | 			ERROR("Not enough DMA memory");
 35 | 		for (int i = 0; i < count; i++)
 36 | 		{
 37 | 			arr[i] = DMABufferDescriptor::allocateBuffer(bytes, true, clearValue);
 38 | 			if(!arr[i])
 39 | 				ERROR("Not enough DMA memory");
 40 | 		}
 41 | 		return arr;
 42 | 	}
 43 | 
 44 | 	void setBuffer(void *buffer, int bytes)
 45 | 	{
 46 | 		length = bytes;
 47 | 		size = length;
 48 | 		buf = (uint8_t *)buffer;
 49 | 	}
 50 | 
 51 | 	void *buffer() const
 52 | 	{
 53 | 		return (void *)buf;
 54 | 	}
 55 | 
 56 | 	void init()
 57 | 	{
 58 | 		length = 0;
 59 | 		size = 0;
 60 | 		owner = 1;
 61 | 		sosf = 0;
 62 | 		buf = (uint8_t *)0;
 63 | 		offset = 0;
 64 | 		empty = 0;
 65 | 		eof = 1;
 66 | 		qe.stqe_next = 0;
 67 | 	}
 68 | 
 69 | 	static DMABufferDescriptor *allocateDescriptors(int count)
 70 | 	{
 71 | 		DMABufferDescriptor *b = (DMABufferDescriptor *)heap_caps_malloc(sizeof(DMABufferDescriptor) * count, MALLOC_CAP_DMA);
 72 | 		if (!b)
 73 | 			DEBUG_PRINTLN("Failed to alloc DMABufferDescriptors");
 74 | 		for (int i = 0; i < count; i++)
 75 | 			b[i].init();
 76 | 		return b;
 77 | 	}
 78 | 
 79 | 	static DMABufferDescriptor *allocateDescriptor(int bytes, bool allocBuffer = true, bool clear = true, unsigned long clearValue = 0)
 80 | 	{
 81 | 		bytes = (bytes + 3) & 0xfffffffc;
 82 | 		DMABufferDescriptor *b = (DMABufferDescriptor *)heap_caps_malloc(sizeof(DMABufferDescriptor), MALLOC_CAP_DMA);
 83 | 		if (!b)
 84 | 			DEBUG_PRINTLN("Failed to alloc DMABufferDescriptor");
 85 | 		b->init();
 86 | 		if (allocateBuffer)
 87 | 			b->setBuffer(allocateBuffer(bytes, clear, clearValue), bytes);
 88 | 		return b;
 89 | 	}
 90 | 
 91 | 	void next(DMABufferDescriptor &next)
 92 | 	{
 93 | 		qe.stqe_next = &next;
 94 | 	}
 95 | 
 96 | 	int sampleCount() const
 97 | 	{
 98 | 		return length / 4;
 99 | 	}
100 | 
101 | 	void destroy()
102 | 	{
103 | 		if (buf)
104 | 		{
105 | 			free((void *)buf);
106 | 			buf = 0;
107 | 		}
108 | 		free(this);
109 | 	}
110 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/I2S/I2S.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | 	Author: bitluni 2019
 3 | 	License: 
 4 | 	Creative Commons Attribution ShareAlike 4.0
 5 | 	https://creativecommons.org/licenses/by-sa/4.0/
 6 | 	
 7 | 	For further details check out: 
 8 | 		https://youtube.com/bitlunislab
 9 | 		https://github.com/bitluni
10 | 		http://bitluni.net
11 | */
12 | #pragma once
13 | 
14 | #include "esp_heap_caps.h"
15 | #include "soc/soc.h"
16 | #include "soc/gpio_sig_map.h"
17 | #include "soc/i2s_reg.h"
18 | #include "soc/i2s_struct.h"
19 | #include "soc/io_mux_reg.h"
20 | #include "driver/gpio.h"
21 | #include "driver/periph_ctrl.h"
22 | #include "rom/lldesc.h"
23 | #include "DMABufferDescriptor.h"
24 | 
25 | class I2S
26 | {
27 |   public:
28 | 	int i2sIndex;
29 | 	intr_handle_t interruptHandle;
30 | 	int dmaBufferDescriptorCount;
31 | 	int dmaBufferDescriptorActive;
32 | 	DMABufferDescriptor *dmaBufferDescriptors;
33 | 	volatile bool stopSignal;
34 | 
35 | 	/// hardware index [0, 1]
36 | 	I2S(const int i2sIndex = 0);
37 | 	void reset();
38 | 
39 | 	void stop();
40 | 
41 | 	void i2sStop();
42 | 	void startTX();
43 | 	void startRX();
44 | 
45 | 	void resetDMA();
46 | 	void resetFIFO();
47 | 	bool initParallelOutputMode(const int *pinMap, long APLLFreq = 1000000, const int bitCount = 8, int wordSelect = -1, int baseClock = -1);
48 | 	bool initSerialOutputMode(int dataPin, const int bitCount = 8, int wordSelect = -1, int baseClock = -1);
49 | 	bool initParallelInputMode(const int *pinMap, long sampleRate = 1000000, const int bitCount = 8, int wordSelect = -1, int baseClock = -1);
50 | 	virtual DMABufferDescriptor *firstDescriptorAddress() const;
51 | 
52 | 	void allocateDMABuffers(int count, int bytes);
53 | 	void deleteDMABuffers();
54 | 	virtual void getClockSetting(long *sampleRate, int *n, int *a, int *b, int *div);
55 | 
56 | 	void (*interruptStaticChild)(void *arg) = 0;
57 | 
58 |   protected:
59 | 	virtual bool useInterrupt();
60 | 	void setAPLLClock(long sampleRate, int bitCount);
61 | 	void setClock(long sampleRate, int bitCount, bool useAPLL = true);
62 | 	
63 |   private:
64 | 	static void IRAM_ATTR interruptStatic(void *arg);
65 | };
66 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Math/Matrix.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include <math.h>
 14 | 
 15 | class Vector
 16 | {
 17 | public:
 18 | 	float v[4];
 19 | 
 20 | 	Vector(float x = 0, float y = 0, float z = 0, float w = 1)
 21 | 	{
 22 | 		v[0] = x;
 23 | 		v[1] = y;
 24 | 		v[2] = z;
 25 | 		v[3] = w;
 26 | 	}
 27 | 
 28 | 	Vector operator*(float s) const
 29 | 	{
 30 | 		return Vector(v[0] * s, v[1] * s, v[2] * s, 1);
 31 | 	}
 32 | 
 33 | 	Vector &operator*=(float s)
 34 | 	{
 35 | 		*this = *this * s;
 36 | 		return *this;
 37 | 	}
 38 | 
 39 | 	float operator[](int i) const
 40 | 	{
 41 | 		return v[i];
 42 | 	}
 43 | 
 44 | 	Vector operator+(const Vector &v2) const
 45 | 	{
 46 | 		return Vector(v[0] + v2.v[0], v[1] + v2.v[1], v[2] + v2.v[2], 1);
 47 | 	}
 48 | 
 49 | 	Vector operator-(const Vector &v2) const
 50 | 	{
 51 | 		return Vector(v[0] - v2.v[0], v[1] - v2.v[1], v[2] - v2.v[2], 1);
 52 | 	}
 53 | 
 54 | 	Vector operator-() const
 55 | 	{
 56 | 		return Vector(-v[0], -v[1], -v[2], 1);
 57 | 	}
 58 | 
 59 | 	void normalize()
 60 | 	{
 61 | 		float l2 = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
 62 | 		if (!l2)
 63 | 			return;
 64 | 		//float rl = 1 / sqrt(l2);
 65 | 		*this *= rsqrt(l2);//rl;
 66 | 	}
 67 | 
 68 | 	float length() const
 69 | 	{
 70 | 		float l2 = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
 71 | 		if (!l2) return 0.f;
 72 | 		return sqrt(l2);
 73 | 	}
 74 | 
 75 | 	float dot(const Vector &v2) const
 76 | 	{
 77 | 		return v[0] * v2.v[0] + v[1] * v2.v[1] + v[2] * v2.v[2];
 78 | 	}
 79 | 
 80 | 	static float rsqrt(float x)
 81 | 	{	
 82 | 		const float x2 = x * 0.5F;
 83 | 		const float threehalfs = 1.5F;
 84 | 
 85 | 		union {
 86 | 			float f;
 87 | 			uint32_t i;
 88 | 		} conv = {x};
 89 | 		conv.i  = 0x5f3759df - ( conv.i >> 1 );
 90 | 		conv.f  *= ( threehalfs - ( x2 * conv.f * conv.f ) );
 91 | 		conv.f  *= ( threehalfs - ( x2 * conv.f * conv.f ) );
 92 | 		return conv.f;
 93 | 	}
 94 | 	
 95 | 	static float sqrt(float x)
 96 | 	{	
 97 | 		return x * rsqrt(x);
 98 | 	}
 99 | };
100 | 
101 | class Matrix
102 | {
103 | public:
104 | 	float m[4][4];
105 | 
106 | 	Matrix()
107 | 		: Matrix(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
108 | 	{
109 | 	}
110 | 
111 | 	Matrix(float m00, float m01, float m02, float m03,
112 | 		   float m10, float m11, float m12, float m13,
113 | 		   float m20, float m21, float m22, float m23,
114 | 		   float m30, float m31, float m32, float m33)
115 | 	{
116 | 		m[0][0] = m00;
117 | 		m[0][1] = m01;
118 | 		m[0][2] = m02;
119 | 		m[0][3] = m03;
120 | 		m[1][0] = m10;
121 | 		m[1][1] = m11;
122 | 		m[1][2] = m12;
123 | 		m[1][3] = m13;
124 | 		m[2][0] = m20;
125 | 		m[2][1] = m21;
126 | 		m[2][2] = m22;
127 | 		m[2][3] = m23;
128 | 		m[3][0] = m30;
129 | 		m[3][1] = m31;
130 | 		m[3][2] = m32;
131 | 		m[3][3] = m33;
132 | 	}
133 | 
134 | 	static Matrix identity()
135 | 	{
136 | 		return Matrix(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
137 | 	}
138 | 
139 | 	static Matrix scaling(float s)
140 | 	{
141 | 		return Matrix(s, 0, 0, 0, 0, s, 0, 0, 0, 0, s, 0, 0, 0, 0, 1);
142 | 	}
143 | 
144 | 	static Matrix scaling(float u, float v, float w)
145 | 	{
146 | 		return Matrix(u, 0, 0, 0, 0, v, 0, 0, 0, 0, w, 0, 0, 0, 0, 1);
147 | 	}
148 | 
149 | 	static Matrix translation(float x, float y, float z)
150 | 	{
151 | 		return Matrix(1, 0, 0, x, 0, 1, 0, y, 0, 0, 1, z, 0, 0, 0, 1);
152 | 	}
153 | 
154 | 	static Matrix rotation(float a, float x, float y, float z)
155 | 	{
156 | 		float cosa = cos(a);
157 | 		float rcosa = 1 - cosa;
158 | 		float sina = sin(a);
159 | 		return Matrix(
160 | 			x * x * rcosa + cosa, x * y * rcosa - z * sina, x * z * rcosa + y * sina, 0,
161 | 			y * x * rcosa + z * sina, y * y * rcosa + cosa, y * z * rcosa - x * sina, 0,
162 | 			z * x * rcosa - y * sina, z * y * rcosa + x * sina, z * z * rcosa + cosa, 0,
163 | 			0, 0, 0, 1);
164 | 	}
165 | 
166 | 	static Matrix perspective(float fov, float near, float far)
167 | 	{
168 | 		float scale = tan(fov * 0.5 * M_PI / 180);
169 | 		return Matrix(
170 | 			scale, 0, 0, 0,
171 | 			0, scale, 0, 0,
172 | 			0, 0, -far * near / (far - near), 0,
173 | 			0, 0, -1, 0);
174 | 	}
175 | 
176 | 	Vector operator*(const Vector &v)
177 | 	{
178 | 		return Vector(
179 | 			v.v[0] * m[0][0] + v.v[1] * m[0][1] + v.v[2] * m[0][2] + m[0][3],
180 | 			v.v[0] * m[1][0] + v.v[1] * m[1][1] + v.v[2] * m[1][2] + m[1][3],
181 | 			v.v[0] * m[2][0] + v.v[1] * m[2][1] + v.v[2] * m[2][2] + m[2][3],
182 | 			v.v[0] * m[3][0] + v.v[1] * m[3][1] + v.v[2] * m[3][2] + m[3][3]);
183 | 	}
184 | 
185 | 	Matrix operator*(const Matrix &m2)
186 | 	{
187 | 		Matrix mr;
188 | 		for (int y = 0; y < 4; y++)
189 | 			for (int x = 0; x < 4; x++)
190 | 				mr.m[y][x] = m[y][0] * m2.m[0][x] + m[y][1] * m2.m[1][x] + m[y][2] * m2.m[2][x] + m[y][3] * m2.m[3][x];
191 | 		return mr;
192 | 	}
193 | 
194 | 	Matrix &operator*=(const Matrix &m2)
195 | 	{
196 | 		*this = *this * m2;
197 | 		return *this;
198 | 	}
199 | };
200 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/Tools/Log.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | 	Author: bitluni 2019
 3 | 	License: 
 4 | 	Creative Commons Attribution ShareAlike 4.0
 5 | 	https://creativecommons.org/licenses/by-sa/4.0/
 6 | 	
 7 | 	For further details check out: 
 8 | 		https://youtube.com/bitlunislab
 9 | 		https://github.com/bitluni
10 | 		http://bitluni.net
11 | */
12 | #pragma once
13 | #include "Arduino.h"
14 | 
15 | 
16 | #define DEBUG_PRINTLN(a) Serial.println(a)
17 | #define DEBUG_PRINT(a) Serial.print(a)
18 | #define DEBUG_PRINTLNF(a, f) Serial.println(a, f)
19 | #define DEBUG_PRINTF(a, f) Serial.print(a, f)
20 | /*
21 | #define DEBUG_PRINTLN(a) ;
22 | #define DEBUG_PRINT(a) ;
23 | #define DEBUG_PRINTLNF(a, f) ;
24 | #define DEBUG_PRINTF(a, f) ;
25 | */
26 | #define ERROR(a) {Serial.println((a)); delay(3000); throw 0;};
27 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/VGA/Mode.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | 
 14 | class Mode
 15 | {
 16 |   public:
 17 | 	int hFront;
 18 | 	int hSync;
 19 | 	int hBack;
 20 | 	int hRes;
 21 | 	int vFront;
 22 | 	int vSync;
 23 | 	int vBack;
 24 | 	int vRes;
 25 | 	int vDiv;
 26 | 	unsigned long pixelClock;
 27 | 	int hSyncPolarity;
 28 | 	int vSyncPolarity;
 29 | 	float aspect;
 30 | 	int activeLineCount;
 31 | 	Mode(
 32 | 		const int hFront = 0,
 33 | 		const int hSync = 0,
 34 | 		const int hBack = 0,
 35 | 		const int hRes = 0,
 36 | 		const int vFront = 0,
 37 | 		const int vSync = 0,
 38 | 		const int vBack = 0,
 39 | 		const int vRes = 0,
 40 | 		const int vDiv = 1,
 41 | 		const unsigned long pixelClock = 0,
 42 | 		const int hSyncPolarity = 1,
 43 | 		const int vSyncPolarity = 1,
 44 | 		const float aspect = 1.f)
 45 | 		: hFront(hFront),
 46 | 		  hSync(hSync),
 47 | 		  hBack(hBack),
 48 | 		  hRes(hRes),
 49 | 		  vFront(vFront),
 50 | 		  vSync(vSync),
 51 | 		  vBack(vBack),
 52 | 		  vRes(vRes),
 53 | 		  vDiv(vDiv),
 54 | 		  pixelClock(pixelClock),
 55 | 		  hSyncPolarity(hSyncPolarity),
 56 | 		  vSyncPolarity(vSyncPolarity),
 57 | 		  aspect(aspect),
 58 | 		  activeLineCount(vRes / vDiv)
 59 | 	{
 60 | 	}
 61 | 
 62 | 	int maxXRes() const
 63 | 	{
 64 | 		return (int(hRes * 19673499. / pixelClock) & 0xfffffffe);
 65 | 	}
 66 | 
 67 | 	int linesPerField() const
 68 | 	{
 69 | 		return vFront + vSync + vBack + vRes;
 70 | 	}
 71 | 
 72 | 	int pixelsPerLine() const
 73 | 	{
 74 | 		return hFront + hSync + hBack + hRes;
 75 | 	}
 76 | 
 77 | 	Mode custom(int xres, int yres, int fixedYDivider = 0) const
 78 | 	{
 79 | 		xres = (xres + 3) & 0xfffffffc;
 80 | 		float f = float(xres) / hRes;
 81 | 		int hs = int(hSync * f + 3) & 0xfffffffc;
 82 | 		int hb = int((hSync + hBack - hs / f) * f + 3) & 0xfffffffc;
 83 | 		int hr = xres;
 84 | 		int hf = int((pixelsPerLine() - (hs + hb + hr) / f) * f + 3) & 0xfffffffc;
 85 | 		
 86 | 		int vd = fixedYDivider ? fixedYDivider : (vRes / yres);
 87 | 		int vr = yres * vd;
 88 | 		int vf = vFront + vRes / 2 - vr / 2;
 89 | 		int vb = vBack + vRes / 2 - (vr - vr / 2);
 90 | 		long pc = long(pixelClock * f);
 91 | 		return Mode(hf, hs, hb, hr, vf, vSync, vb, vr, vd, pc, hSyncPolarity, vSyncPolarity);
 92 | 	}
 93 | 
 94 | 	template<class Output>
 95 | 	void print(Output &output) const
 96 | 	{
 97 | 		output.print("hFront: ");
 98 | 		output.println(hFront);
 99 | 		output.print("hSync: ");
100 |  		output.println(hSync);
101 | 		output.print("hBack: ");
102 | 		output.println(hBack);
103 | 		output.print("hRes: ");
104 | 		output.println(hRes);
105 | 		output.print("vFront: ");
106 | 		output.println(vFront);
107 | 		output.print("vSync: ");
108 | 		output.println(vSync);
109 | 		output.print("vBack: ");
110 | 		output.println(vBack);
111 | 		output.print("vRes: ");
112 | 		output.println(vRes);
113 | 		output.print("vDiv: ");
114 | 		output.println(vDiv);
115 | 		output.print("pixelClock: ");
116 | 		output.println(pixelClock);
117 | 		output.print("hSyncPolarity: ");
118 | 		output.println(hSyncPolarity);
119 | 		output.print("vSyncPolarity: ");
120 | 		output.println(vSyncPolarity);
121 | 	}
122 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/VGA/PinConfig.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | 
 14 | class PinConfig
 15 | {
 16 |   public:
 17 | 	int r0, r1, r2, r3, r4;
 18 | 	int g0, g1, g2, g3, g4;
 19 | 	int b0, b1, b2, b3;
 20 | 	int hSync, vSync, clock;
 21 | 	PinConfig(
 22 | 		const int r0 = -1,
 23 | 		const int r1 = -1,
 24 | 		const int r2 = -1,
 25 | 		const int r3 = -1,
 26 | 		const int r4 = -1,
 27 | 		const int g0 = -1,
 28 | 		const int g1 = -1,
 29 | 		const int g2 = -1,
 30 | 		const int g3 = -1,
 31 | 		const int g4 = -1,
 32 | 		const int b0 = -1,
 33 | 		const int b1 = -1,
 34 | 		const int b2 = -1,
 35 | 		const int b3 = -1,
 36 | 		const int hSync = -1,
 37 | 		const int vSync = -1,
 38 | 		const int clock = -1)
 39 | 		: r0(r0),
 40 | 		  r1(r1),
 41 | 		  r2(r2),
 42 | 		  r3(r3),
 43 | 		  r4(r4),
 44 | 		  g0(g0),
 45 | 		  g1(g1),
 46 | 		  g2(g2),
 47 | 		  g3(g3),
 48 | 		  g4(g4),
 49 | 		  b0(b0),
 50 | 		  b1(b1),
 51 | 		  b2(b2),
 52 | 		  b3(b3),
 53 | 		  hSync(hSync),
 54 | 		  vSync(vSync),
 55 | 		  clock(clock)
 56 | 	{
 57 | 	}
 58 | 
 59 | 	void fill3Bit(int *pins) const
 60 | 	{
 61 | 		pins[0] = r4;
 62 | 		pins[1] = g4;
 63 | 		pins[2] = b3;
 64 | 		pins[3] = -1;
 65 | 		pins[4] = -1;
 66 | 		pins[5] = -1;
 67 | 		pins[6] = hSync;
 68 | 		pins[7] = vSync;
 69 | 	}
 70 | 
 71 | 	void fill6Bit(int *pins) const
 72 | 	{
 73 | 		pins[0] = r3;
 74 | 		pins[1] = r4;
 75 | 		pins[2] = g3;
 76 | 		pins[3] = g4;
 77 | 		pins[4] = b2;
 78 | 		pins[5] = b3;
 79 | 		pins[6] = hSync;
 80 | 		pins[7] = vSync;
 81 | 	}
 82 | 
 83 | 	void fill14Bit(int *pins) const
 84 | 	{	
 85 | 		pins[0] = r0;
 86 | 		pins[1] = r1;
 87 | 		pins[2] = r2;
 88 | 		pins[3] = r3;
 89 | 		pins[4] = r4;
 90 | 		pins[5] = g0;
 91 | 		pins[6] = g1;
 92 | 		pins[7] = g2;
 93 | 		pins[8] = g3;
 94 | 		pins[9] = g4;
 95 | 		pins[10] = b0;
 96 | 		pins[11] = b1;
 97 | 		pins[12] = b2;
 98 | 		pins[13] = b3;
 99 | 		pins[14] = hSync;
100 | 		pins[15] = vSync;
101 | 	}
102 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/VGA/VGA.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | 
 14 | #include "../I2S/I2S.h"
 15 | #include "Mode.h"
 16 | #include "PinConfig.h"
 17 | 
 18 | class VGA : public I2S
 19 | {
 20 |   public:
 21 | 	VGA(const int i2sIndex = 0);
 22 | 	void setLineBufferCount(int lineBufferCount);
 23 | 	bool init(const Mode &mode, const int *pinMap, const int bitCount, const int clockPin = -1);
 24 | 	virtual bool init(const Mode &mode, const PinConfig &pinConfig) = 0;
 25 | 
 26 | 	static const Mode MODE320x480;
 27 | 	static const Mode MODE320x240;
 28 | 	static const Mode MODE320x120;
 29 | 	static const Mode MODE320x400;
 30 | 	static const Mode MODE320x200;
 31 | 	static const Mode MODE360x400;
 32 | 	static const Mode MODE360x200;
 33 | 	static const Mode MODE360x350;
 34 | 	static const Mode MODE360x175;
 35 | 
 36 | 	static const Mode MODE320x350;
 37 | 	static const Mode MODE320x175;
 38 | 
 39 | 	static const Mode MODE400x300;
 40 | 	static const Mode MODE400x150;
 41 | 	static const Mode MODE400x100;
 42 | 	static const Mode MODE200x150;
 43 | 
 44 | 	static const Mode MODE500x480;
 45 | 	static const Mode MODE500x240;
 46 | 
 47 | 	static const Mode MODE1280x1024;
 48 | 	static const Mode MODE1280x960;
 49 | 	static const Mode MODE1280x800;
 50 | 	static const Mode MODE1024x768;
 51 | 	static const Mode MODE800x600;
 52 | 	static const Mode MODE720x400;
 53 | 	static const Mode MODE720x350;
 54 | 	static const Mode MODE640x480;
 55 | 	static const Mode MODE640x400;
 56 | 	static const Mode MODE640x350;
 57 | 
 58 | 	static const PinConfig VGAv01;
 59 | 	static const PinConfig VGABlackEdition;
 60 | 	static const PinConfig VGAWhiteEdition;
 61 | 	static const PinConfig PicoVGA;
 62 | 
 63 | 
 64 | 	Mode mode;
 65 | 
 66 | 	virtual int bytesPerSample() const = 0;
 67 | 
 68 |   protected:
 69 | 	
 70 | 	virtual void initSyncBits() = 0;
 71 | 	virtual long syncBits(bool h, bool v) = 0;
 72 |  
 73 | 	int lineBufferCount;
 74 | 	int vsyncPin;
 75 | 	int hsyncPin;
 76 | 	int currentLine;
 77 | 	long vsyncBit;
 78 | 	long hsyncBit;
 79 | 	long vsyncBitI;
 80 | 	long hsyncBitI;
 81 | 
 82 | 	int totalLines;
 83 | 	volatile bool vSyncPassed;
 84 | 
 85 | 	void *vSyncInactiveBuffer;
 86 | 	void *vSyncActiveBuffer;
 87 | 	void *inactiveBuffer;
 88 | 	void *blankActiveBuffer;
 89 | 
 90 | 	void allocateLineBuffers(const int lines);
 91 | 	virtual void allocateLineBuffers();
 92 | 	virtual void allocateLineBuffers(void **frameBuffer);
 93 | 	virtual void propagateResolution(const int xres, const int yres) = 0;
 94 | 
 95 |   protected:
 96 | 	virtual void interrupt();
 97 | 	virtual void vSync();
 98 | 	virtual void interruptPixelLine(int y, unsigned long *pixels, unsigned long syncBits);
 99 | };
100 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/VGA/VGA14Bit.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "VGA.h"
 14 | #include "../Graphics/GraphicsR5G5B4S2Swapped.h"
 15 | 
 16 | class VGA14Bit : public VGA, public GraphicsR5G5B4S2Swapped
 17 | {
 18 |   public:
 19 | 	VGA14Bit(const int i2sIndex = 1)
 20 | 		: VGA(i2sIndex)
 21 | 	{
 22 | 	}
 23 | 
 24 | 	bool init(Mode &mode,
 25 | 			  const int R0Pin, const int R1Pin, const int R2Pin, const int R3Pin, const int R4Pin,
 26 | 			  const int G0Pin, const int G1Pin, const int G2Pin, const int G3Pin, const int G4Pin,
 27 | 			  const int B0Pin, const int B1Pin, const int B2Pin, const int B3Pin,
 28 | 			  const int hsyncPin, const int vsyncPin, const int clockPin = -1)
 29 | 	{
 30 | 		int pinMap[16] = {
 31 | 			R0Pin, R1Pin, R2Pin, R3Pin, R4Pin,
 32 | 			G0Pin, G1Pin, G2Pin, G3Pin, G4Pin,
 33 | 			B0Pin, B1Pin, B2Pin, B3Pin,
 34 | 			hsyncPin, vsyncPin
 35 | 		};
 36 | 
 37 | 		return VGA::init(mode, pinMap, 16, clockPin);
 38 | 	}
 39 | 
 40 | 	bool init(const Mode &mode, const int *redPins, const int *greenPins, const int *bluePins, const int hsyncPin, const int vsyncPin, const int clockPin = -1)
 41 | 	{
 42 | 		int pinMap[16];
 43 | 		for (int i = 0; i < 5; i++)
 44 | 		{
 45 | 			pinMap[i] = redPins[i];
 46 | 			pinMap[i + 5] = greenPins[i];
 47 | 			if (i < 4)
 48 | 				pinMap[i + 10] = bluePins[i];
 49 | 		}
 50 | 		pinMap[14] = hsyncPin;
 51 | 		pinMap[15] = vsyncPin;			
 52 | 		return VGA::init(mode, pinMap, 16, clockPin);
 53 | 	}
 54 | 
 55 | 	bool init(const Mode &mode, const PinConfig &pinConfig)
 56 | 	{
 57 | 		int pins[16];
 58 | 		pinConfig.fill14Bit(pins);
 59 | 		return VGA::init(mode, pins, 16, pinConfig.clock);
 60 | 	}
 61 | 
 62 | 	virtual void initSyncBits()
 63 | 	{
 64 | 		hsyncBitI = mode.hSyncPolarity ? 0x4000 : 0;
 65 | 		vsyncBitI = mode.vSyncPolarity ? 0x8000 : 0;
 66 | 		hsyncBit = hsyncBitI ^ 0x4000;
 67 | 		vsyncBit = vsyncBitI ^ 0x8000;
 68 | 		SBits = hsyncBitI | vsyncBitI;
 69 | 	}
 70 | 
 71 | 	virtual long syncBits(bool hSync, bool vSync)
 72 | 	{
 73 | 		return ((hSync ? hsyncBit : hsyncBitI) | (vSync ? vsyncBit : vsyncBitI)) * 0x10001;
 74 | 	}
 75 | 
 76 | 	virtual int bytesPerSample() const
 77 | 	{
 78 | 		return 2;
 79 | 	}
 80 | 
 81 | 	virtual float pixelAspect() const
 82 | 	{
 83 | 		return 1;
 84 | 	}
 85 | 
 86 | 	virtual void propagateResolution(const int xres, const int yres)
 87 | 	{
 88 | 		setResolution(xres, yres);
 89 | 	}
 90 | 
 91 | 	virtual Color **allocateFrameBuffer()
 92 | 	{
 93 | 		return (Color **)DMABufferDescriptor::allocateDMABufferArray(yres, mode.hRes * bytesPerSample(), true, syncBits(false, false));
 94 | 	}
 95 | 
 96 | 	virtual void allocateLineBuffers()
 97 | 	{
 98 | 		VGA::allocateLineBuffers((void **)frameBuffers[0]);
 99 | 	}
100 | 
101 | 	virtual void show(bool vSync = false)
102 | 	{
103 | 		if (!frameBufferCount)
104 | 			return;
105 | 		if (vSync)
106 | 		{
107 | 			//TODO read the I2S docs to find out
108 | 		}
109 | 		Graphics::show(vSync);
110 | 		if(dmaBufferDescriptors)
111 | 			for (int i = 0; i < yres * mode.vDiv; i++)
112 | 				dmaBufferDescriptors[(mode.vFront + mode.vSync + mode.vBack + i) * 2 + 1].setBuffer(frontBuffer[i / mode.vDiv], mode.hRes * bytesPerSample());
113 | 	}
114 | 
115 | 	virtual void scroll(int dy, Color color)
116 | 	{
117 | 		Graphics::scroll(dy, color);
118 | 		if (frameBufferCount == 1)
119 | 			show();
120 | 	}
121 | 
122 |   protected:
123 | 	virtual void interrupt()
124 | 	{
125 | 	}
126 | };


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/VGA/VGA14BitI.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "VGA.h"
 14 | #include "../Graphics/GraphicsR5G5B4A2.h"
 15 | 
 16 | class VGA14BitI : public VGA, public GraphicsR5G5B4A2
 17 | {
 18 |   public:
 19 | 	VGA14BitI(const int i2sIndex = 1)
 20 | 		: VGA(i2sIndex)
 21 | 	{
 22 | 		interruptStaticChild = &VGA14BitI::interrupt;
 23 | 	}
 24 | 
 25 | 	bool init(const Mode &mode, 
 26 | 		const int R0Pin, const int R1Pin, const int R2Pin, const int R3Pin, const int R4Pin,
 27 | 		const int G0Pin, const int G1Pin, const int G2Pin, const int G3Pin, const int G4Pin,
 28 | 		const int B0Pin, const int B1Pin, const int B2Pin, const int B3Pin, 
 29 | 		const int hsyncPin, const int vsyncPin, const int clockPin = -1)
 30 | 	{
 31 | 		int pinMap[16] = {
 32 | 			R0Pin, R1Pin, R2Pin, R3Pin, R4Pin,
 33 | 			G0Pin, G1Pin, G2Pin, G3Pin, G4Pin,
 34 | 			B0Pin, B1Pin, B2Pin, B3Pin,
 35 | 			hsyncPin, vsyncPin
 36 | 		};
 37 | 		return VGA::init(mode, pinMap, 16, clockPin);
 38 | 	}
 39 | 
 40 | 	bool init(const Mode &mode, const int *redPins, const int *greenPins, const int *bluePins, const int hsyncPin, const int vsyncPin, const int clockPin = -1)
 41 | 	{
 42 | 		int pinMap[16];
 43 | 		for (int i = 0; i < 5; i++)
 44 | 		{
 45 | 			pinMap[i] = redPins[i];
 46 | 			pinMap[i + 5] = greenPins[i];
 47 | 			if (i < 4)
 48 | 				pinMap[i + 10] = bluePins[i];
 49 | 		}
 50 | 		pinMap[14] = hsyncPin;
 51 | 		pinMap[15] = vsyncPin;		
 52 | 		return VGA::init(mode, pinMap, 16, clockPin);
 53 | 	}
 54 | 
 55 | 	bool init(const Mode &mode, const PinConfig &pinConfig)
 56 | 	{
 57 | 		int pins[16];
 58 | 		pinConfig.fill14Bit(pins);
 59 | 		return VGA::init(mode, pins, 16, pinConfig.clock);
 60 | 	}
 61 | 
 62 | 	virtual void initSyncBits()
 63 | 	{
 64 | 		hsyncBitI = mode.hSyncPolarity ? 0x4000 : 0;
 65 | 		vsyncBitI = mode.vSyncPolarity ? 0x8000 : 0;
 66 | 		hsyncBit = hsyncBitI ^ 0x4000;
 67 | 		vsyncBit = vsyncBitI ^ 0x8000;
 68 | 	}
 69 | 
 70 | 	virtual long syncBits(bool hSync, bool vSync)
 71 | 	{
 72 | 		return ((hSync ? hsyncBit : hsyncBitI) | (vSync ? vsyncBit : vsyncBitI)) * 0x10001;
 73 | 	}
 74 | 
 75 | 	virtual int bytesPerSample() const
 76 | 	{
 77 | 		return 2;
 78 | 	}
 79 | 
 80 | 	virtual float pixelAspect() const
 81 | 	{
 82 | 		return 1;
 83 | 	}
 84 | 
 85 | 	virtual void propagateResolution(const int xres, const int yres)
 86 | 	{
 87 | 		setResolution(xres, yres);
 88 | 	}
 89 | 
 90 | 	virtual void show(bool vSync = false)
 91 | 	{
 92 | 		if (!frameBufferCount)
 93 | 			return;
 94 | 		if (vSync)
 95 | 		{
 96 | 			vSyncPassed = false;
 97 | 			while (!vSyncPassed)
 98 | 				delay(0);
 99 | 		}
100 | 		Graphics::show(vSync);
101 | 	}
102 | 
103 |   protected:
104 | 	bool useInterrupt()
105 | 	{ 
106 | 		return true; 
107 | 	};
108 | 
109 | 	static void interrupt(void *arg);
110 | 
111 | 	static void interruptPixelLine(int y, unsigned long *pixels, unsigned long syncBits, void *arg);
112 | };
113 | 
114 | 
115 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/VGA/VGA3Bit.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "VGA.h"
 14 | #include "../Graphics/GraphicsR1G1B1A1X2S2Swapped.h"
 15 | 
 16 | class VGA3Bit : public VGA, public GraphicsR1G1B1A1X2S2Swapped
 17 | {
 18 |   public:
 19 | 	VGA3Bit() //8 bit based modes only work with I2S1
 20 | 		: VGA(1)
 21 | 	{
 22 | 	}
 23 | 
 24 | 	bool init(const Mode &mode, const int RPin, const int GPin, const int BPin, const int hsyncPin, const int vsyncPin, const int clockPin = -1)
 25 | 	{
 26 | 		int pinMap[8] = {
 27 | 			RPin,
 28 | 			GPin,
 29 | 			BPin,
 30 | 			-1, -1, -1,
 31 | 			hsyncPin, vsyncPin
 32 | 		};
 33 | 
 34 | 		return VGA::init(mode, pinMap, 8, clockPin);
 35 | 	}
 36 | 
 37 | 	bool init(const Mode &mode, const PinConfig &pinConfig)
 38 | 	{
 39 | 		int pins[8];
 40 | 		pinConfig.fill3Bit(pins);
 41 | 		return VGA::init(mode, pins, 8, pinConfig.clock);
 42 | 	}
 43 | 
 44 | 
 45 | 	virtual void initSyncBits()
 46 | 	{
 47 | 		hsyncBitI = mode.hSyncPolarity ? 0x40 : 0;
 48 | 		vsyncBitI = mode.vSyncPolarity ? 0x80 : 0;
 49 | 		hsyncBit = hsyncBitI ^ 0x40;
 50 | 		vsyncBit = vsyncBitI ^ 0x80;
 51 | 		SBits = hsyncBitI | vsyncBitI;
 52 | 	}
 53 | 		
 54 | 	virtual long syncBits(bool hSync, bool vSync)
 55 | 	{
 56 | 		return ((hSync ? hsyncBit : hsyncBitI) | (vSync ? vsyncBit : vsyncBitI)) * 0x1010101;
 57 | 	}
 58 | 
 59 | 	virtual int bytesPerSample() const
 60 | 	{
 61 | 		return 1;
 62 | 	}
 63 | 
 64 | 	virtual float pixelAspect() const
 65 | 	{
 66 | 		return 1;
 67 | 	}
 68 | 
 69 | 	virtual void propagateResolution(const int xres, const int yres)
 70 | 	{
 71 | 		setResolution(xres, yres);
 72 | 	}
 73 | 
 74 | 	void *vSyncInactiveBuffer;
 75 | 	void *vSyncActiveBuffer;
 76 | 	void *inactiveBuffer;
 77 | 	void *blankActiveBuffer;
 78 | 
 79 | 	virtual Color **allocateFrameBuffer()
 80 | 	{
 81 | 		return (Color **)DMABufferDescriptor::allocateDMABufferArray(yres, mode.hRes * bytesPerSample(), true, syncBits(false, false));
 82 | 	}
 83 | 
 84 | 	virtual void allocateLineBuffers()
 85 | 	{
 86 | 		VGA::allocateLineBuffers((void **)frameBuffers[0]);
 87 | 	}
 88 | 
 89 | 	virtual void show(bool vSync = false)
 90 | 	{
 91 | 		if (!frameBufferCount)
 92 | 			return;
 93 | 		if (vSync)
 94 | 		{
 95 | 			//TODO read the I2S docs to find out
 96 | 		}
 97 | 		Graphics::show(vSync);
 98 | 		if(dmaBufferDescriptors)
 99 | 		for (int i = 0; i < yres * mode.vDiv; i++)
100 | 			dmaBufferDescriptors[(mode.vFront + mode.vSync + mode.vBack + i) * 2 + 1].setBuffer(frontBuffer[i / mode.vDiv], mode.hRes * bytesPerSample());
101 | 	}
102 | 
103 | 	virtual void scroll(int dy, Color color)
104 | 	{
105 | 		Graphics::scroll(dy, color);
106 | 		if (frameBufferCount == 1)
107 | 			show();
108 | 	}
109 | 
110 |   protected:
111 | 	virtual void interrupt()
112 | 	{
113 | 	}
114 | };
115 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/VGA/VGA3BitI.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | 	Author: bitluni 2019
 3 | 	License: 
 4 | 	Creative Commons Attribution ShareAlike 4.0
 5 | 	https://creativecommons.org/licenses/by-sa/4.0/
 6 | 	
 7 | 	For further details check out: 
 8 | 		https://youtube.com/bitlunislab
 9 | 		https://github.com/bitluni
10 | 		http://bitluni.net
11 | */
12 | #pragma once
13 | #include "VGA.h"
14 | #include "../Graphics/GraphicsR1G1B1A1.h"
15 | 
16 | class VGA3BitI : public VGA, public GraphicsR1G1B1A1
17 | {
18 |   public:
19 | 	VGA3BitI()	//8 bit based modes only work with I2S1
20 | 		: VGA(1)
21 | 	{
22 | 		interruptStaticChild = &VGA3BitI::interrupt;
23 | 	}
24 | 
25 | 	bool init(const Mode &mode, const int RPin, const int GPin, const int BPin, const int hsyncPin, const int vsyncPin, const int clockPin = -1)
26 | 	{
27 | 		int pinMap[8] = {
28 | 			RPin,
29 | 			GPin,
30 | 			BPin,
31 | 			-1, -1, -1,
32 | 			hsyncPin, vsyncPin
33 | 		};
34 | 		return VGA::init(mode, pinMap, 8, clockPin);
35 | 	}
36 | 
37 | 	bool init(const Mode &mode, const PinConfig &pinConfig)
38 | 	{
39 | 		int pins[8];
40 | 		pinConfig.fill3Bit(pins);
41 | 		return VGA::init(mode, pins, 8, pinConfig.clock);
42 | 	}
43 | 
44 | 	virtual void initSyncBits()
45 | 	{
46 | 		hsyncBitI = mode.hSyncPolarity ? 0x40 : 0;
47 | 		vsyncBitI = mode.vSyncPolarity ? 0x80 : 0;
48 | 		hsyncBit = hsyncBitI ^ 0x40;
49 | 		vsyncBit = vsyncBitI ^ 0x80;
50 | 	}
51 | 
52 | 	virtual long syncBits(bool hSync, bool vSync)
53 | 	{
54 | 		return ((hSync ? hsyncBit : hsyncBitI) | (vSync ? vsyncBit : vsyncBitI)) * 0x1010101;
55 | 	}
56 | 
57 | 	virtual int bytesPerSample() const
58 | 	{
59 | 		return 1;
60 | 	}
61 | 
62 | 	virtual float pixelAspect() const
63 | 	{
64 | 		return 1;
65 | 	}
66 | 
67 | 	virtual void propagateResolution(const int xres, const int yres)
68 | 	{
69 | 		setResolution(xres, yres);
70 | 	}
71 | 
72 | 	virtual void show(bool vSync = false)
73 | 	{
74 | 		if (!frameBufferCount)
75 | 			return;
76 | 		if (vSync)
77 | 		{
78 | 			vSyncPassed = false;
79 | 			while (!vSyncPassed)
80 | 				delay(0);
81 | 		}
82 | 		Graphics::show(vSync);
83 | 	}
84 | 
85 |   protected:
86 | 	bool useInterrupt()
87 | 	{ 
88 | 		return true; 
89 | 	};
90 | 
91 | 	static void interrupt(void *arg);
92 | 
93 | 	static void interruptPixelLine(int y, unsigned long *pixels, unsigned long syncBits, void *arg);
94 | };
95 | 
96 | 
97 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/VGA/VGA6Bit.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "VGA.h"
 14 | #include "../Graphics/GraphicsR2G2B2S2Swapped.h"
 15 | 
 16 | class VGA6Bit : public VGA, public GraphicsR2G2B2S2Swapped
 17 | {
 18 |   public:
 19 | 	VGA6Bit() //8 bit based modes only work with I2S1
 20 | 		: VGA(1)
 21 | 	{
 22 | 	}
 23 | 
 24 | 
 25 | 	bool init(Mode &mode,
 26 | 			  const int R0Pin, const int R1Pin,
 27 | 			  const int G0Pin, const int G1Pin,
 28 | 			  const int B0Pin, const int B1Pin,
 29 | 			  const int hsyncPin, const int vsyncPin, const int clockPin = -1)
 30 | 	{
 31 | 		int pinMap[8] = {
 32 | 			R0Pin, R1Pin,
 33 | 			G0Pin, G1Pin,
 34 | 			B0Pin, B1Pin,
 35 | 			hsyncPin, vsyncPin
 36 | 		};
 37 | 
 38 | 		return VGA::init(mode, pinMap, 8, clockPin);
 39 | 	}
 40 | 
 41 | 	bool init(const Mode &mode, const int *redPins, const int *greenPins, const int *bluePins, const int hsyncPin, const int vsyncPin, const int clockPin = -1)
 42 | 	{
 43 | 		int pinMap[8];
 44 | 		for (int i = 0; i < 2; i++)
 45 | 		{
 46 | 			pinMap[i] = redPins[i];
 47 | 			pinMap[i + 2] = greenPins[i];
 48 | 			pinMap[i + 4] = bluePins[i];
 49 | 		}
 50 | 		pinMap[6] = hsyncPin;
 51 | 		pinMap[7] = vsyncPin;			
 52 | 		return VGA::init(mode, pinMap, 8, clockPin);
 53 | 	}
 54 | 
 55 | 	bool init(const Mode &mode, const PinConfig &pinConfig)
 56 | 	{
 57 | 		int pins[8];
 58 | 		pinConfig.fill6Bit(pins);
 59 | 		return VGA::init(mode, pins, 8, pinConfig.clock);
 60 | 	}
 61 | 
 62 | 	virtual void initSyncBits()
 63 | 	{
 64 | 		hsyncBitI = mode.hSyncPolarity ? 0x40 : 0;
 65 | 		vsyncBitI = mode.vSyncPolarity ? 0x80 : 0;
 66 | 		hsyncBit = hsyncBitI ^ 0x40;
 67 | 		vsyncBit = vsyncBitI ^ 0x80;
 68 | 		SBits = hsyncBitI | vsyncBitI;
 69 | 	}
 70 | 		
 71 | 	virtual long syncBits(bool hSync, bool vSync)
 72 | 	{
 73 | 		return ((hSync ? hsyncBit : hsyncBitI) | (vSync ? vsyncBit : vsyncBitI)) * 0x1010101;
 74 | 	}
 75 | 
 76 | 	virtual int bytesPerSample() const
 77 | 	{
 78 | 		return 1;
 79 | 	}
 80 | 
 81 | 	virtual float pixelAspect() const
 82 | 	{
 83 | 		return 1;
 84 | 	}
 85 | 
 86 | 	virtual void propagateResolution(const int xres, const int yres)
 87 | 	{
 88 | 		setResolution(xres, yres);
 89 | 	}
 90 | 
 91 | 	void *vSyncInactiveBuffer;
 92 | 	void *vSyncActiveBuffer;
 93 | 	void *inactiveBuffer;
 94 | 	void *blankActiveBuffer;
 95 | 
 96 | 	virtual Color **allocateFrameBuffer()
 97 | 	{
 98 | 		return (Color **)DMABufferDescriptor::allocateDMABufferArray(yres, mode.hRes * bytesPerSample(), true, syncBits(false, false));
 99 | 	}
100 | 
101 | 	virtual void allocateLineBuffers()
102 | 	{
103 | 		VGA::allocateLineBuffers((void **)frameBuffers[0]);
104 | 	}
105 | 
106 | 	virtual void show(bool vSync = false)
107 | 	{
108 | 		if (!frameBufferCount)
109 | 			return;
110 | 		if (vSync)
111 | 		{
112 | 			//TODO read the I2S docs to find out
113 | 		}
114 | 		Graphics::show(vSync);
115 | 		if(dmaBufferDescriptors)
116 | 		for (int i = 0; i < yres * mode.vDiv; i++)
117 | 			dmaBufferDescriptors[(mode.vFront + mode.vSync + mode.vBack + i) * 2 + 1].setBuffer(frontBuffer[i / mode.vDiv], mode.hRes * bytesPerSample());
118 | 	}
119 | 
120 | 	virtual void scroll(int dy, Color color)
121 | 	{
122 | 		Graphics::scroll(dy, color);
123 | 		if (frameBufferCount == 1)
124 | 			show();
125 | 	}
126 | 
127 |   protected:
128 | 	virtual void interrupt()
129 | 	{
130 | 	}
131 | };
132 | 


--------------------------------------------------------------------------------
/arduino/gameboy/ESP32Lib/VGA/VGA6BitI.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	Author: bitluni 2019
  3 | 	License: 
  4 | 	Creative Commons Attribution ShareAlike 4.0
  5 | 	https://creativecommons.org/licenses/by-sa/4.0/
  6 | 	
  7 | 	For further details check out: 
  8 | 		https://youtube.com/bitlunislab
  9 | 		https://github.com/bitluni
 10 | 		http://bitluni.net
 11 | */
 12 | #pragma once
 13 | #include "VGA.h"
 14 | #include "../Graphics/GraphicsR2G2B2A2.h"
 15 | 
 16 | class VGA6BitI : public VGA, public GraphicsR2G2B2A2
 17 | {
 18 |   public:
 19 | 	VGA6BitI()	//8 bit based modes only work with I2S1
 20 | 		: VGA(1)
 21 | 	{
 22 | 		interruptStaticChild = &VGA6BitI::interrupt;
 23 | 	}
 24 | 
 25 | 	bool init(const Mode &mode,
 26 | 			  const int R0Pin, const int R1Pin,
 27 | 			  const int G0Pin, const int G1Pin,
 28 | 			  const int B0Pin, const int B1Pin,
 29 | 			  const int hsyncPin, const int vsyncPin, const int clockPin = -1)
 30 | 	{
 31 | 		int pinMap[8] = {
 32 | 			R0Pin, R1Pin,
 33 | 			G0Pin, G1Pin,
 34 | 			B0Pin, B1Pin,
 35 | 			hsyncPin, vsyncPin
 36 | 		};
 37 | 		return VGA::init(mode, pinMap, 8, clockPin);
 38 | 	}
 39 | 
 40 | 	bool init(const Mode &mode, const int *redPins, const int *greenPins, const int *bluePins, const int hsyncPin, const int vsyncPin, const int clockPin = -1)
 41 | 	{
 42 | 		int pinMap[8];
 43 | 		for (int i = 0; i < 2; i++)
 44 | 		{
 45 | 			pinMap[i] = redPins[i];
 46 | 			pinMap[i + 2] = greenPins[i];
 47 | 			pinMap[i + 4] = bluePins[i];
 48 | 		}
 49 | 		pinMap[6] = hsyncPin;
 50 | 		pinMap[7] = vsyncPin;			return VGA::init(mode, pinMap, 8, clockPin);
 51 | 	}
 52 | 
 53 | 	bool init(const Mode &mode, const PinConfig &pinConfig)
 54 | 	{
 55 | 		int pins[8];
 56 | 		pinConfig.fill6Bit(pins);
 57 | 		return VGA::init(mode, pins, 8, pinConfig.clock);
 58 | 	}
 59 | 
 60 | 	virtual void initSyncBits()
 61 | 	{
 62 | 		hsyncBitI = mode.hSyncPolarity ? 0x40 : 0;
 63 | 		vsyncBitI = mode.vSyncPolarity ? 0x80 : 0;
 64 | 		hsyncBit = hsyncBitI ^ 0x40;
 65 | 		vsyncBit = vsyncBitI ^ 0x80;
 66 | 	}
 67 | 
 68 | 	virtual long syncBits(bool hSync, bool vSync)
 69 | 	{
 70 | 		return ((hSync ? hsyncBit : hsyncBitI) | (vSync ? vsyncBit : vsyncBitI)) * 0x1010101;
 71 | 	}
 72 | 
 73 | 	virtual int bytesPerSample() const
 74 | 	{
 75 | 		return 1;
 76 | 	}
 77 | 
 78 | 	virtual float pixelAspect() const
 79 | 	{
 80 | 		return 1;
 81 | 	}
 82 | 
 83 | 	virtual void propagateResolution(const int xres, const int yres)
 84 | 	{
 85 | 		setResolution(xres, yres);
 86 | 	}
 87 | 
 88 | 	virtual void show(bool vSync = false)
 89 | 	{
 90 | 		if (!frameBufferCount)
 91 | 			return;
 92 | 		if (vSync)
 93 | 		{
 94 | 			vSyncPassed = false;
 95 | 			while (!vSyncPassed)
 96 | 				delay(0);
 97 | 		}
 98 | 		Graphics::show(vSync);
 99 | 	}
100 | 
101 |   protected:
102 | 	bool useInterrupt()
103 | 	{ 
104 | 		return true; 
105 | 	};
106 | 
107 | 	static void interrupt(void *arg);
108 | 
109 | 	static void interruptPixelLine(int y, unsigned long *pixels, unsigned long syncBits, void *arg);
110 | };
111 | 


--------------------------------------------------------------------------------
/arduino/gameboy/Emulator/Keyboard/PS2Kbd.h:
--------------------------------------------------------------------------------
 1 | #include "../../def/hardware.h"
 2 | #include "../../def/keys.h"
 3 | #include <Arduino.h>
 4 | 
 5 | #define KB_INT_START attachInterrupt(digitalPinToInterrupt(KEYBOARD_CLK), kb_interruptHandler, FALLING)
 6 | #define KB_INT_STOP detachInterrupt(digitalPinToInterrupt(KEYBOARD_CLK))
 7 | 
 8 | extern byte lastcode;
 9 | 
10 | void IRAM_ATTR kb_interruptHandler(void);
11 | void kb_begin();
12 | boolean isKeymapChanged();
13 | boolean checkAndCleanKey(uint8_t scancode);
14 | boolean checkKey(uint8_t scancode);
15 | 
16 | // inject key from wiimote, for not modifying OSD code
17 | void emulateKeyChange(uint8_t scancode, uint8_t isdown);
18 | 


--------------------------------------------------------------------------------
/arduino/gameboy/MartianVGA.h:
--------------------------------------------------------------------------------
 1 | //#pragma once
 2 | #ifndef _MARTIANVGA_H
 3 |  #define _MARTIANVGA_H
 4 | 
 5 |  #include "ESP32Lib/VGA/VGA14Bit.h"
 6 |  #include "ESP32Lib/VGA/VGA14BitI.h"
 7 |  #include "ESP32Lib/VGA/VGA3Bit.h"
 8 |  #include "ESP32Lib/VGA/VGA3BitI.h"
 9 |  #include "ESP32Lib/VGA/VGA6Bit.h"
10 |  #include "ESP32Lib/VGA/VGA6BitI.h"
11 | #endif
12 | 


--------------------------------------------------------------------------------
/arduino/gameboy/PS2Kbd.cpp:
--------------------------------------------------------------------------------
 1 | #include <Arduino.h>
 2 | #include "gbConfig.h"
 3 | 
 4 | #ifdef lib_compile_vga32
 5 | 
 6 | unsigned int shift = 0;
 7 | byte lastcode = 0;
 8 | boolean keyup = false;
 9 | boolean shift_presed = false;
10 | boolean symbol_pressed = false;
11 | byte rc = 0;
12 | //volatile byte keymap[256];
13 | //volatile byte oldKeymap[256];
14 | volatile unsigned char keymap[256];
15 | volatile unsigned char oldKeymap[256];
16 | 
17 | void IRAM_ATTR kb_interruptHandler(void) {
18 |     static uint8_t bitcount = 0;
19 |     static uint8_t incoming = 0;
20 |     static uint32_t prev_ms = 0;
21 |     uint32_t now_ms;
22 |     uint8_t n, val;
23 | 
24 |     int clock = digitalRead(KEYBOARD_CLK);
25 |     if (clock == 1)
26 |         return;
27 | 
28 |     val = digitalRead(KEYBOARD_DATA);
29 |     now_ms = millis();
30 |     if (now_ms - prev_ms > 250) {
31 |         bitcount = 0;
32 |         incoming = 0;
33 |     }
34 |     prev_ms = now_ms;
35 |     n = bitcount - 1;
36 |     if (n <= 7) {
37 |         incoming |= (val << n);
38 |     }
39 |     bitcount++;
40 |     if (bitcount == 11) {
41 | 
42 |         if (1) {
43 |             if (keyup == true) {
44 |                 if (keymap[incoming] == 0) {
45 |                     keymap[incoming] = 1;
46 |                 } else {
47 |                     // Serial.println("WARNING: Keyboard cleaned");
48 |                     for (int gg = 0; gg < 256; gg++)
49 |                         keymap[gg] = 1;
50 |                 }
51 |                 keyup = false;
52 |             } else
53 |                 keymap[incoming] = 0;
54 | 
55 |             if (incoming == 240)
56 |                 keyup = true;
57 |             else
58 |                 keyup = false;
59 |         }
60 |         bitcount = 0;
61 |         incoming = 0;
62 |     }
63 | }
64 | 
65 | void kb_begin() {
66 |     pinMode(KEYBOARD_DATA, INPUT_PULLUP);
67 |     pinMode(KEYBOARD_CLK, INPUT_PULLUP);
68 |     digitalWrite(KEYBOARD_DATA, true);
69 |     digitalWrite(KEYBOARD_CLK, true);
70 |     attachInterrupt(digitalPinToInterrupt(KEYBOARD_CLK), kb_interruptHandler, FALLING);
71 | 
72 |     memset((unsigned char *)keymap, 1, sizeof(keymap));
73 |     memset((unsigned char *)oldKeymap, 1, sizeof(oldKeymap));
74 |     //}
75 | }
76 | 
77 | // Check if keymatrix is changed
78 | boolean isKeymapChanged() { return (keymap != oldKeymap); }
79 | 
80 | // Check if key is pressed and clean it
81 | boolean checkAndCleanKey(uint8_t scancode) {
82 |     if (keymap[scancode] == 0) {
83 |         keymap[scancode] = 1;
84 |         return true;
85 |     }
86 |     return false;
87 | }
88 | 
89 | //*****************************************
90 | boolean checkKey(uint8_t scancode) {
91 |     if (keymap[scancode] == 0)        
92 |         return true;
93 |     return false;
94 | }
95 | 
96 | #endif
97 | 


--------------------------------------------------------------------------------
/arduino/gameboy/PS2Kbd.h:
--------------------------------------------------------------------------------
 1 | #include "keys.h"
 2 | #include <Arduino.h>
 3 | #include "gbConfig.h"
 4 | 
 5 | #ifdef lib_compile_vga32
 6 | 
 7 |  #define KB_INT_START attachInterrupt(digitalPinToInterrupt(KEYBOARD_CLK), kb_interruptHandler, FALLING)
 8 |  #define KB_INT_STOP detachInterrupt(digitalPinToInterrupt(KEYBOARD_CLK))
 9 | 
10 |  extern byte lastcode;
11 | 
12 |  void IRAM_ATTR kb_interruptHandler(void);
13 |  void kb_begin();
14 |  boolean isKeymapChanged();
15 |  boolean checkAndCleanKey(uint8_t scancode);
16 |  boolean checkKey(uint8_t scancode);
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/arduino/gameboy/VGA14BitI.cpp:
--------------------------------------------------------------------------------
 1 | #include "ESP32Lib/VGA/VGA14BitI.h"
 2 | 
 3 | void IRAM_ATTR VGA14BitI::interrupt(void *arg)
 4 | {
 5 | 	VGA14BitI * staticthis = (VGA14BitI *)arg;
 6 | 	
 7 | 	unsigned long *signal = (unsigned long *)staticthis->dmaBufferDescriptors[staticthis->dmaBufferDescriptorActive].buffer();
 8 | 	unsigned long *pixels = &((unsigned long *)staticthis->dmaBufferDescriptors[staticthis->dmaBufferDescriptorActive].buffer())[(staticthis->mode.hSync + staticthis->mode.hBack) / 2];
 9 | 	unsigned long base, baseh;
10 | 	if (staticthis->currentLine >= staticthis->mode.vFront && staticthis->currentLine < staticthis->mode.vFront + staticthis->mode.vSync)
11 | 	{
12 | 		baseh = (staticthis->hsyncBit | staticthis->vsyncBit) * 0x10001;
13 | 		base = (staticthis->hsyncBitI | staticthis->vsyncBit) * 0x10001;
14 | 	}
15 | 	else
16 | 	{
17 | 		baseh = (staticthis->hsyncBit | staticthis->vsyncBitI) * 0x10001;
18 | 		base = (staticthis->hsyncBitI | staticthis->vsyncBitI) * 0x10001;
19 | 	}
20 | 	for (int i = 0; i < staticthis->mode.hSync / 2; i++)
21 | 		signal[i] = baseh;
22 | 	for (int i = staticthis->mode.hSync / 2; i < (staticthis->mode.hSync + staticthis->mode.hBack) / 2; i++)
23 | 		signal[i] = base;
24 | 
25 | 	int y = (staticthis->currentLine - staticthis->mode.vFront - staticthis->mode.vSync - staticthis->mode.vBack) / staticthis->mode.vDiv;
26 | 	if (y >= 0 && y < staticthis->mode.vRes)
27 | 		staticthis->interruptPixelLine(y, pixels, base, arg);
28 | 	else
29 | 		for (int i = 0; i < staticthis->mode.hRes / 2; i++)
30 | 		{
31 | 			pixels[i] = base | (base << 16);
32 | 		}
33 | 	for (int i = 0; i < staticthis->mode.hFront / 2; i++)
34 | 		signal[i + (staticthis->mode.hSync + staticthis->mode.hBack + staticthis->mode.hRes) / 2] = base;
35 | 	staticthis->currentLine = (staticthis->currentLine + 1) % staticthis->totalLines;
36 | 	staticthis->dmaBufferDescriptorActive = (staticthis->dmaBufferDescriptorActive + 1) % staticthis->dmaBufferDescriptorCount;
37 | 	if (staticthis->currentLine == 0)
38 | 		staticthis->vSyncPassed = true;
39 | }
40 | 
41 | void IRAM_ATTR VGA14BitI::interruptPixelLine(int y, unsigned long *pixels, unsigned long syncBits, void *arg)
42 | {
43 | 	VGA14BitI * staticthis = (VGA14BitI *)arg;
44 | 	unsigned short *line = staticthis->frontBuffer[y];
45 | 	for (int i = 0; i < staticthis->mode.hRes / 2; i++)
46 | 	{
47 | 		//writing two pixels improves speed drastically (avoids memory reads)
48 | 		pixels[i] = syncBits | (line[i * 2 + 1] & 0x3fff) | ((line[i * 2] & 0x3fff) << 16);
49 | 	}
50 | }
51 | 


--------------------------------------------------------------------------------
/arduino/gameboy/VGA3BitI.cpp:
--------------------------------------------------------------------------------
 1 | #include "ESP32Lib/VGA/VGA3BitI.h"
 2 | 
 3 | void IRAM_ATTR VGA3BitI::interrupt(void *arg)
 4 | {
 5 | 	VGA3BitI * staticthis = (VGA3BitI *)arg;
 6 | 	
 7 | 	unsigned long *signal = (unsigned long *)staticthis->dmaBufferDescriptors[staticthis->dmaBufferDescriptorActive].buffer();
 8 | 	unsigned long *pixels = &((unsigned long *)staticthis->dmaBufferDescriptors[staticthis->dmaBufferDescriptorActive].buffer())[(staticthis->mode.hSync + staticthis->mode.hBack) / 4];
 9 | 	unsigned long base, baseh;
10 | 	if (staticthis->currentLine >= staticthis->mode.vFront && staticthis->currentLine < staticthis->mode.vFront + staticthis->mode.vSync)
11 | 	{
12 | 		baseh = (staticthis->hsyncBit | staticthis->vsyncBit) * 0x1010101;
13 | 		base = (staticthis->hsyncBitI | staticthis->vsyncBit) * 0x1010101;
14 | 	}
15 | 	else
16 | 	{
17 | 		baseh = (staticthis->hsyncBit | staticthis->vsyncBitI) * 0x1010101;
18 | 		base = (staticthis->hsyncBitI | staticthis->vsyncBitI) * 0x1010101;
19 | 	}
20 | 	for (int i = 0; i < staticthis->mode.hSync / 4; i++)
21 | 		signal[i] = baseh;
22 | 	for (int i = staticthis->mode.hSync / 4; i < (staticthis->mode.hSync + staticthis->mode.hBack) / 4; i++)
23 | 		signal[i] = base;
24 | 
25 | 	int y = (staticthis->currentLine - staticthis->mode.vFront - staticthis->mode.vSync - staticthis->mode.vBack) / staticthis->mode.vDiv;
26 | 	if (y >= 0 && y < staticthis->mode.vRes)
27 | 		staticthis->interruptPixelLine(y, pixels, base, arg);
28 | 	else
29 | 		for (int i = 0; i < staticthis->mode.hRes / 4; i++)
30 | 		{
31 | 			pixels[i] = base;
32 | 		}
33 | 	for (int i = 0; i < staticthis->mode.hFront / 4; i++)
34 | 		signal[i + (staticthis->mode.hSync + staticthis->mode.hBack + staticthis->mode.hRes) / 4] = base;
35 | 	staticthis->currentLine = (staticthis->currentLine + 1) % staticthis->totalLines;
36 | 	staticthis->dmaBufferDescriptorActive = (staticthis->dmaBufferDescriptorActive + 1) % staticthis->dmaBufferDescriptorCount;
37 | 	if (staticthis->currentLine == 0)
38 | 		staticthis->vSyncPassed = true;
39 | }
40 | 
41 | void IRAM_ATTR VGA3BitI::interruptPixelLine(int y, unsigned long *pixels, unsigned long syncBits, void *arg)
42 | {
43 | 	VGA3BitI * staticthis = (VGA3BitI *)arg;
44 | 	unsigned char *line = staticthis->frontBuffer[y];
45 | 	int j = 0;
46 | 	for (int i = 0; i < staticthis->mode.hRes / 4; i++)
47 | 	{
48 | 		int p0 = (line[j] >> 0) & 7;
49 | 		int p1 = (line[j++] >> 4) & 7;
50 | 		int p2 = (line[j] >> 0) & 7;
51 | 		int p3 = (line[j++] >> 4) & 7;
52 | 		pixels[i] = syncBits | (p2 << 0) | (p3 << 8) | (p0 << 16) | (p1 << 24);
53 | 	}
54 | }
55 | 


--------------------------------------------------------------------------------
/arduino/gameboy/VGA6BitI.cpp:
--------------------------------------------------------------------------------
 1 | #include "ESP32Lib/VGA/VGA6BitI.h"
 2 | 
 3 | void IRAM_ATTR VGA6BitI::interrupt(void *arg)
 4 | {
 5 | 	VGA6BitI * staticthis = (VGA6BitI *)arg;
 6 | 	
 7 | 	unsigned long *signal = (unsigned long *)staticthis->dmaBufferDescriptors[staticthis->dmaBufferDescriptorActive].buffer();
 8 | 	unsigned long *pixels = &((unsigned long *)staticthis->dmaBufferDescriptors[staticthis->dmaBufferDescriptorActive].buffer())[(staticthis->mode.hSync + staticthis->mode.hBack) / 4];
 9 | 	unsigned long base, baseh;
10 | 	if (staticthis->currentLine >= staticthis->mode.vFront && staticthis->currentLine < staticthis->mode.vFront + staticthis->mode.vSync)
11 | 	{
12 | 		baseh = (staticthis->hsyncBit | staticthis->vsyncBit) * 0x1010101;
13 | 		base = (staticthis->hsyncBitI | staticthis->vsyncBit) * 0x1010101;
14 | 	}
15 | 	else
16 | 	{
17 | 		baseh = (staticthis->hsyncBit | staticthis->vsyncBitI) * 0x1010101;
18 | 		base = (staticthis->hsyncBitI | staticthis->vsyncBitI) * 0x1010101;
19 | 	}
20 | 	for (int i = 0; i < staticthis->mode.hSync / 4; i++)
21 | 		signal[i] = baseh;
22 | 	for (int i = staticthis->mode.hSync / 4; i < (staticthis->mode.hSync + staticthis->mode.hBack) / 4; i++)
23 | 		signal[i] = base;
24 | 
25 | 	int y = (staticthis->currentLine - staticthis->mode.vFront - staticthis->mode.vSync - staticthis->mode.vBack) / staticthis->mode.vDiv;
26 | 	if (y >= 0 && y < staticthis->mode.vRes)
27 | 		staticthis->interruptPixelLine(y, pixels, base, arg);
28 | 	else
29 | 		for (int i = 0; i < staticthis->mode.hRes / 4; i++)
30 | 		{
31 | 			pixels[i] = base;
32 | 		}
33 | 	for (int i = 0; i < staticthis->mode.hFront / 4; i++)
34 | 		signal[i + (staticthis->mode.hSync + staticthis->mode.hBack + staticthis->mode.hRes) / 4] = base;
35 | 	staticthis->currentLine = (staticthis->currentLine + 1) % staticthis->totalLines;
36 | 	staticthis->dmaBufferDescriptorActive = (staticthis->dmaBufferDescriptorActive + 1) % staticthis->dmaBufferDescriptorCount;
37 | 	if (staticthis->currentLine == 0)
38 | 		staticthis->vSyncPassed = true;
39 | }
40 | 
41 | void IRAM_ATTR VGA6BitI::interruptPixelLine(int y, unsigned long *pixels, unsigned long syncBits, void *arg)
42 | {
43 | 	VGA6BitI * staticthis = (VGA6BitI *)arg;
44 | 	unsigned char *line = staticthis->frontBuffer[y];
45 | 	int j = 0;
46 | 	for (int i = 0; i < staticthis->mode.hRes / 4; i++)
47 | 	{
48 | 		int p0 = (line[j++]) & 63;
49 | 		int p1 = (line[j++]) & 63;
50 | 		int p2 = (line[j++]) & 63;
51 | 		int p3 = (line[j++]) & 63;
52 | 		pixels[i] = syncBits | (p2 << 0) | (p3 << 8) | (p0 << 16) | (p1 << 24);
53 | 	}
54 | }
55 | 


--------------------------------------------------------------------------------
/arduino/gameboy/cpu.h:
--------------------------------------------------------------------------------
 1 | #ifndef CPU_H
 2 | #define CPU_H
 3 | #include "rom.h"
 4 | void cpu_init(void);
 5 | int cpu_cycle(void);
 6 | int CPUIncCycle(int aux);
 7 | unsigned int cpu_get_cycles(void);
 8 | void cpu_interrupt(unsigned short);
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/arduino/gameboy/dataFlash/gbrom.h:
--------------------------------------------------------------------------------
 1 | #ifndef _GB_ROM_H
 2 |  #define _GB_ROM_H
 3 | 
 4 |  //#include <stddef.h>
 5 |  #include "roms/romLastCrown.h"
 6 |  #include "roms/romRetroid.h"
 7 | 
 8 |  #define max_list_rom 2
 9 | 
10 | 
11 |  //roms
12 |  //Titulos
13 |  static const char * gb_list_rom_title[max_list_rom]={
14 |   "LastCrown",
15 |   "Retroid"
16 |  };
17 | 
18 |  //Datos rom
19 |  static const unsigned char * gb_list_rom_data[max_list_rom]={
20 |   gb_rom_LastCrown,
21 |   gb_rom_Retroid
22 |  };
23 | 
24 |  //Tamanio en bytes
25 |  //static const int gb_list_rom_size[max_list_rom]={
26 |  // 262144//,
27 |  // 262144
28 |  //};
29 | 
30 | #endif
31 | 


--------------------------------------------------------------------------------
/arduino/gameboy/def/Font.h:
--------------------------------------------------------------------------------
1 | extern unsigned char Font6x8Pixels[];
2 | extern Font Font6x8;
3 | 


--------------------------------------------------------------------------------
/arduino/gameboy/def/ascii.h:
--------------------------------------------------------------------------------
1 | #define ASCII_NL 10
2 | 


--------------------------------------------------------------------------------
/arduino/gameboy/def/hardware.h:
--------------------------------------------------------------------------------
 1 | #ifndef _HARDWARE_H
 2 |  #define _HARDWARE_H
 3 | 
 4 |  #include "../gbConfig.h"
 5 | 
 6 |  #define SPEAKER_PIN 25
 7 | 
 8 |  #define KEYBOARD_DATA 32
 9 |  #define KEYBOARD_CLK 33
10 | 
11 |  //#define MOUSE_DATA 27
12 |  //#define MOUSE_CLK 26
13 | 
14 | 
15 |  // 3 bit pins
16 |  //#define RED_PIN_3B 22
17 |  //#define GRE_PIN_3B 19
18 |  //#define BLU_PIN_3B 5
19 | 
20 |  // 6 bit pins
21 |  //#define RED_PINS_6B 21, 22
22 |  //#define GRE_PINS_6B 18, 19
23 |  //#define BLU_PINS_6B  4,  5
24 | 
25 |  // VGA sync pins
26 |  //#define HSYNC_PIN 23
27 |  //#define VSYNC_PIN 15
28 | 
29 |  #ifdef use_lib_vga8colors  //       BGR 
30 |   #define BLACK   0x08      // 0000 1000
31 |   #define BLUE    0x0C      // 0000 1100
32 |   #define RED     0x09      // 0000 1001
33 |   #define MAGENTA 0x0D      // 0000 1101
34 |   #define GREEN   0x0A      // 0000 1010
35 |   #define CYAN    0x0E      // 0000 1110
36 |   #define YELLOW  0x0B      // 0000 1011
37 |   #define WHITE   0x0F      // 0000 1111
38 |  #else
39 |   #define BLACK       0xC0      // 1100 0000
40 |   #define BLUE        0xE0      // 1110 0000
41 |   #define RED         0xC2      // 1100 0010
42 |   #define MAGENTA     0xE2      // 1110 0010
43 |   #define GREEN       0xC8      // 1100 1000
44 |   #define CYAN        0xE8      // 1110 1000
45 |   #define YELLOW      0xCA      // 1100 1010
46 |   #define WHITE       0xEA      // 1110 1010
47 |  #endif
48 | 
49 | #endif
50 | 


--------------------------------------------------------------------------------
/arduino/gameboy/def/keys.h:
--------------------------------------------------------------------------------
 1 | #define KEY_F1 0x05
 2 | #define KEY_F2 0x06
 3 | #define KEY_F3 0x04
 4 | #define KEY_F4 0x0C
 5 | #define KEY_F5 0x03
 6 | #define KEY_F6 0x0B
 7 | #define KEY_F7 0x83
 8 | #define KEY_F8 0x0A
 9 | #define KEY_F9 0x01
10 | #define KEY_F10 0x09
11 | #define KEY_F11 0x78
12 | #define KEY_F12 0x07
13 | #define KEY_ESC 0x76
14 | #define KEY_CURSOR_LEFT 0x6B
15 | #define KEY_CURSOR_DOWN 0x72
16 | #define KEY_CURSOR_RIGHT 0x74
17 | #define KEY_CURSOR_UP 0x75
18 | #define KEY_ALT_GR 0x11
19 | #define KEY_ENTER 0x5A
20 | #define KEY_HOME 0xE06C
21 | #define KEY_END 0xE069
22 | #define KEY_PAGE_UP 0xE07D
23 | #define KEY_PAGE_DOWN 0xE07A
24 | #define KEY_PAUSE 0xE11477E1F014E077
25 | #define KEY_BACKSPACE 0x66
26 | #define KEY_DELETE 0x71
27 | 


--------------------------------------------------------------------------------
/arduino/gameboy/def/types.h:
--------------------------------------------------------------------------------
1 | // Types
2 | typedef int32_t dword;
3 | typedef signed char offset;
4 | 


--------------------------------------------------------------------------------
/arduino/gameboy/gbConfig.h:
--------------------------------------------------------------------------------
 1 | #ifndef _GB_CONFIG_H
 2 |  #define _GB_CONFIG_H
 3 |  
 4 |  //Ya no se usa lib_compile_fabgl
 5 |  //lib_compile_vga32 - compile vga32
 6 |  #define lib_compile_vga32
 7 | 
 8 |  //Usar sonido con libreria fabgl aunque se elija bitluni vga32 
 9 |  //#define use_lib_vga8colors
10 |  #define use_lib_vga64colors
11 |  //Modo vga sin doble buffer problemas con modos fast
12 |  //#define use_lib_vga_low_memory 
13 |  #define use_lib_200x150
14 |  //#define use_lib_320x175 
15 | 
16 |  //Opciones para bitluni vga32 con sonido
17 |  //#define use_lib_fabgl_sound
18 | 
19 |  //modos solo para bitluni vga opcion lib_compile_vga32
20 |  //#define use_lib_fast_vga
21 |  //#define use_lib_fast_vgaBLUE8colors
22 |  //#define use_lib_fast_vgaRED8colors
23 |  
24 |  //Modo hilos muy lento por ahora
25 |  //#define use_lib_vga_thread
26 |  
27 |  //No usa font bitluni, ahorra memoria
28 |  //#define use_lib_tinyFont
29 | 
30 |  //log serial usb
31 |  #define use_lib_log_serial
32 | 
33 |  //skip frames fast mode
34 |  //#define gb_frame_crt_skip
35 | 
36 |  //use_max_ram - max ram comsume, all bank cache
37 |  //use_half_ram - half ram consume, half bank cache
38 |  //user_min_ram - min ram consume, not bank cache
39 |  //#define use_max_ram
40 |  //#define use_half_ram
41 |  #define use_min_ram
42 | 
43 |  //Bank switch optimice speed
44 |  //#define usb_lib_optimice_checkchange_bankswitch
45 | 
46 |  //buffer circular 4  8 elementos solo si se usa max ram
47 |  #ifdef use_max_ram
48 |   //#ifdef lib_compile_fabgl 
49 |   // #define maxBankSwitch 4
50 |   //#endif
51 |   //#ifdef lib_compile_vga32
52 |    #define maxBankSwitch 8
53 |   //#endif
54 |  #else
55 |   #ifdef use_half_ram
56 |    //#ifdef lib_compile_fabgl 
57 |    // #define maxBankSwitch 4
58 |    //#endif
59 |    //#ifdef lib_compile_vga32
60 |     #define maxBankSwitch 4
61 |    //#endif
62 |   #endif
63 |  #endif 
64 | 
65 |  #ifdef lib_compile_vga32
66 |   //Pin keyboard PS2
67 |   #define KEYBOARD_DATA 32
68 |   #define KEYBOARD_CLK 33
69 |  #endif 
70 | 
71 |  #ifdef use_lib_fast_vgaBLUE8colors
72 |   #ifndef use_lib_fast_vga
73 |    #define use_lib_fast_vga
74 |   #endif 
75 |  #endif
76 | 
77 |  #ifdef use_lib_fast_vgaRED8colors
78 |   #ifndef use_lib_fast_vga
79 |    #define use_lib_fast_vga
80 |   #endif 
81 |  #endif
82 | 
83 |  //Milliseconds read joystick 1000 div 60 fps
84 |  #define gb_ms_joy 16
85 | 
86 | #endif
87 | 


--------------------------------------------------------------------------------
/arduino/gameboy/gb_globals.h:
--------------------------------------------------------------------------------
 1 | #ifndef _GB_GLOBALS_H
 2 |  #define _GB_GLOBALS_H
 3 |  #include "gbConfig.h"
 4 |  #include "MartianVGA.h"
 5 | 
 6 |  #ifdef lib_compile_vga32  
 7 |   #define hsyncPin 23
 8 |   #define vsyncPin 15
 9 |   #ifdef use_lib_vga8colors 
10 |    #ifdef use_lib_vga_low_memory
11 |     extern VGA3BitI vga;
12 |    #else
13 |     extern VGA3Bit vga;
14 |    #endif
15 |   #else
16 |    #ifdef use_lib_vga_low_memory
17 |     extern VGA6BitI vga;
18 |    #else
19 |     extern VGA6Bit vga;  //Fin seccion VGA32
20 |    #endif
21 |   #endif 
22 |  #endif
23 | 
24 | 
25 |  extern unsigned char gb_show_osd_main_menu;
26 |  extern unsigned char gb_lcd_current_frame;
27 |  extern int gb_lcd_line;
28 | 
29 |  extern unsigned char *gb_ptrMem_raw;
30 | 
31 |  //gamepad
32 |  extern unsigned char button_start, button_select, button_a, button_b, button_down, button_up, button_left, button_right;
33 | 
34 |  extern unsigned char gb_current_ms_poll_joy;
35 |  #ifdef use_lib_fabgl_sound
36 |   extern unsigned char gb_silence_all_channels;
37 |   extern unsigned char gb_sound_off;
38 |  #endif 
39 | 
40 |  #ifdef use_lib_vga_thread
41 |   extern unsigned char* gb_video_buffer_backup_gb;
42 |  #endif
43 | 
44 | #endif
45 | 
46 |  
47 | 


--------------------------------------------------------------------------------
/arduino/gameboy/interrupt.cpp:
--------------------------------------------------------------------------------
  1 | #include "interrupt.h"
  2 | #include "cpu.h"
  3 | 
  4 | static int enabled;
  5 | static int pending;
  6 | 
  7 | /* Pending interrupt flags */
  8 | static unsigned int vblank;
  9 | static unsigned int lcdstat;
 10 | static unsigned int timer;
 11 | static unsigned int serial;
 12 | static unsigned int joypad;
 13 | 
 14 | /* Interrupt masks */
 15 | static unsigned int vblank_masked = 1;
 16 | static unsigned int lcdstat_masked = 1;
 17 | static unsigned int timer_masked = 1;
 18 | static unsigned int serial_masked = 1;
 19 | static unsigned int joypad_masked = 1;
 20 | 
 21 | /* Returns true if the cpu should be unhalted */
 22 | int inline interrupt_flush(void)
 23 | {
 24 | 	/* Flush the highest priority interrupt and/or resume the cpu */
 25 | 	if(pending == 2)
 26 | 	{
 27 | 		pending--;
 28 | 		return 0;
 29 | 	}
 30 | 
 31 | 	pending = 0;
 32 | 
 33 | 	/* There's a pending interrupt but interrupts are disabled, just resume the cpu */
 34 | 	if(!enabled && ((vblank && !vblank_masked) 
 35 | 		|| (lcdstat && !lcdstat_masked)
 36 | 		|| (timer && !timer_masked)
 37 | 		|| (serial && !serial_masked) 
 38 | 		|| (joypad && !joypad_masked))
 39 | 	)
 40 | 		return 1;
 41 | 
 42 | 	/* Interrupts are enabled - Check if any need to fire */
 43 | 	if(vblank && !vblank_masked)
 44 | 	{
 45 | 		vblank = 0;
 46 | 		cpu_interrupt(0x40);
 47 | 	}
 48 | 	else if(lcdstat && !lcdstat_masked)
 49 | 	{
 50 | 		lcdstat = 0;
 51 | 		cpu_interrupt(0x48);
 52 | 	}
 53 | 	else if(timer && !timer_masked)
 54 | 	{
 55 | 		timer = 0;
 56 | 		cpu_interrupt(0x50);
 57 | 	}
 58 | 	else if(serial && !serial_masked)
 59 | 	{
 60 | 		serial = 0;
 61 | 		cpu_interrupt(0x58);
 62 | 	}
 63 | 	else if(joypad && !joypad_masked)
 64 | 	{
 65 | 		joypad = 0;
 66 | 		cpu_interrupt(0x60);
 67 | 	}
 68 | 
 69 | 	return 0;
 70 | }
 71 | 
 72 | void interrupt_enable(void)
 73 | {
 74 | 	enabled = 1;
 75 | 	pending = 2;
 76 | }
 77 | 
 78 | void interrupt_disable(void)
 79 | {
 80 | 	enabled = 0;
 81 | }
 82 | 
 83 | void interrupt(unsigned int n)
 84 | {
 85 | 	/* Add this interrupt to pending queue */
 86 | 	switch(n)
 87 | 	{
 88 | 		case INTR_VBLANK:
 89 | 			vblank = 1;
 90 | 		break;
 91 | 		case INTR_LCDSTAT:
 92 | 			lcdstat = 1;
 93 | 		break;
 94 | 		case INTR_TIMER:
 95 | 			timer = 1;
 96 | 		break;
 97 | 		case INTR_SERIAL:
 98 | 			serial = 1;
 99 | 		break;
100 | 		case INTR_JOYPAD:
101 | 			joypad = 1;
102 | 		break;
103 | 	}
104 | 
105 | 	/* If interrupts are already enabled, flush one now, otherwise wait for
106 | 	 * interrupts to be re-enabled.
107 | 	 */
108 | 	if(enabled)
109 | 		interrupt_flush();
110 | }
111 | 
112 | unsigned char interrupt_get_IF(void)
113 | {
114 | 	unsigned char mask = 0xE0;
115 | 
116 | 	mask |= (vblank  << 0);
117 | 	mask |= (lcdstat << 1);
118 | 	mask |= (timer   << 2);
119 | 	mask |= (serial  << 3);
120 | 	mask |= (joypad  << 4);
121 | 
122 | 	return mask;
123 | }
124 | 
125 | void interrupt_set_IF(unsigned char mask)
126 | {
127 | //	printf("IF set to %02x\n", mask);
128 | 	vblank  = !!(mask & 0x01);
129 | 	lcdstat = !!(mask & 0x02);
130 | 	timer   = !!(mask & 0x04);
131 | 	serial  = !!(mask & 0x08);
132 | 	joypad  = !!(mask & 0x10);
133 | 
134 | 	if(enabled && mask)
135 | 		pending = 1;
136 | }
137 | 
138 | unsigned char interrupt_get_mask(void)
139 | {
140 | 	unsigned char mask = 0;
141 | 
142 | 	mask |= (!vblank_masked  << 0);
143 | 	mask |= (!lcdstat_masked << 1);
144 | 	mask |= (!timer_masked   << 2);
145 | 	mask |= (!serial_masked  << 3);
146 | 	mask |= (!joypad_masked  << 4);
147 | 
148 | 	return mask;
149 | }
150 | 
151 | void interrupt_set_mask(unsigned char mask)
152 | {
153 | 	vblank_masked  = !(mask & 0x01);
154 | 	lcdstat_masked = !(mask & 0x02);
155 | 	timer_masked   = !(mask & 0x04);
156 | 	serial_masked  = !(mask & 0x08);
157 | 	joypad_masked  = !(mask & 0x10);
158 | }
159 | 


--------------------------------------------------------------------------------
/arduino/gameboy/interrupt.h:
--------------------------------------------------------------------------------
 1 | #ifndef INTERRUPT_H
 2 | #define INTERRUPT_H
 3 | 
 4 | void interrupt(unsigned int);
 5 | void interrupt_disable(void);
 6 | void interrupt_enable(void);
 7 | unsigned char interrupt_get_IF(void);
 8 | void interrupt_set_IF(unsigned char);
 9 | unsigned char interrupt_get_mask(void);
10 | void interrupt_set_mask(unsigned char);
11 | int interrupt_pending(void);
12 | int interrupt_flush(void);
13 | 
14 | enum {
15 | 	INTR_VBLANK  = 0x01,
16 | 	INTR_LCDSTAT = 0x02,
17 | 	INTR_TIMER   = 0x04,
18 | 	INTR_SERIAL  = 0x08,
19 | 	INTR_JOYPAD  = 0x10
20 | };
21 | #endif
22 | 


--------------------------------------------------------------------------------
/arduino/gameboy/keys.h:
--------------------------------------------------------------------------------
 1 | #define KEY_F1 0x05
 2 | #define KEY_F2 0x06
 3 | #define KEY_F3 0x04
 4 | #define KEY_F4 0x0C
 5 | #define KEY_F5 0x03
 6 | #define KEY_F6 0x0B
 7 | #define KEY_F7 0x83
 8 | #define KEY_F8 0x0A
 9 | #define KEY_F9 0x01
10 | #define KEY_F10 0x09
11 | #define KEY_F11 0x78
12 | #define KEY_F12 0x07
13 | #define KEY_NUM_0 0x45
14 | #define KEY_NUM_1 0x16
15 | #define KEY_NUM_2 0x1E
16 | #define KEY_NUM_3 0x26
17 | #define KEY_NUM_4 0x25
18 | #define KEY_NUM_5 0x2E
19 | #define KEY_NUM_6 0x36
20 | #define KEY_NUM_7 0x3D
21 | #define KEY_NUM_8 0x3E
22 | #define KEY_NUM_9 0x46
23 | //#define KEY_F12 0x07
24 | //#define KEY_ESC 0x76
25 | //#define KEY_HOME 0xE06C
26 | //#define KEY_END 0xE069
27 | //#define KEY_PAGE_UP 0xE07D
28 | //#define KEY_PAGE_DOWN 0xE07A
29 | //#define KEY_PAUSE 0xE11477E1F014E077
30 | //#define KEY_ALT_GR 0x11
31 | 
32 | #define KEY_CURSOR_LEFT 0x6B
33 | #define KEY_CURSOR_DOWN 0x72
34 | #define KEY_CURSOR_RIGHT 0x74
35 | #define KEY_CURSOR_UP 0x75
36 | #define KEY_ENTER 0x5A
37 | #define KEY_A 0x1C
38 | #define KEY_Z 0x1A
39 | #define KEY_SPACE 0x29
40 | #define KEY_MINUS 0x7B
41 | #define KEY_PLUS 0x79
42 | #define KEY_ASTERISK 0x7C
43 | 
44 | 
45 | 


--------------------------------------------------------------------------------
/arduino/gameboy/lcd.h:
--------------------------------------------------------------------------------
 1 | #ifndef LCD_H
 2 | #define LCD_H
 3 | #include <Arduino.h>
 4 | //int lcd_cycle(void);
 5 | //JJ int lcd_get_line(void);
 6 | 
 7 | enum {
 8 |  SPEED_NORMAL = 0x00,
 9 |  SPEED_TURBO  = 0x01,
10 |  SPEED_MEGATURBO = 0x03
11 | };
12 | 
13 | static byte gb_speed=SPEED_NORMAL;
14 | 
15 | void lcdAssignSDLFrameBuffer(void);
16 | void LCDSetSpeed(byte auxSpeed);
17 | void LCDAssignLookup160lines(unsigned short int *ptr);
18 | void drawColorIndexToFrameBuffer(byte x, byte y, byte idx);
19 | int lcd_get_line(void);
20 | unsigned char lcd_get_stat();
21 | void lcd_write_control(unsigned char);
22 | void lcd_write_stat(unsigned char);
23 | void lcd_write_scroll_x(unsigned char);
24 | void lcd_write_scroll_y(unsigned char);
25 | void lcd_write_bg_palette(unsigned char);
26 | void lcd_write_spr_palette1(unsigned char);
27 | void lcd_write_spr_palette2(unsigned char);
28 | void lcd_set_window_y(unsigned char);
29 | void lcd_set_window_x(unsigned char);
30 | void lcd_set_ly_compare(unsigned char);
31 | void lcd_cycle_fast();
32 | #endif
33 | 


--------------------------------------------------------------------------------
/arduino/gameboy/mbc.cpp:
--------------------------------------------------------------------------------
 1 | #include "mbc.h"
 2 | #include "mem.h"
 3 | #include "rom.h"
 4 | 
 5 | enum {
 6 | 	NO_FILTER_WRITE,
 7 | 	FILTER_WRITE
 8 | };
 9 | 
10 | static unsigned int bank_upper_bits;
11 | static unsigned int ram_select;
12 | 
13 | /* Unfinished, no clock etc */
14 | unsigned int MBC3_write_byte(unsigned short d, unsigned char i)
15 | {
16 | 	int bank;
17 | 
18 | 	if(d < 0x2000)
19 | 	{
20 | 		return FILTER_WRITE;
21 | 	}
22 | 
23 | 	if(d < 0x4000)
24 | 	{
25 | 		bank = i & 0x7F;
26 | 
27 | 		if(bank == 0)
28 | 			bank++;
29 | 
30 | 		mem_bank_switch(bank);
31 | 
32 | 		return FILTER_WRITE;
33 | 	}
34 | 
35 | 	if(d < 0x8000)
36 | 		return FILTER_WRITE;
37 | 
38 | 	return NO_FILTER_WRITE;
39 | }
40 | unsigned int MBC1_write_byte(unsigned short d, unsigned char i)
41 | {
42 | 	int bank;
43 | 
44 | 	if(d < 0x2000)
45 | 	{
46 | 		return FILTER_WRITE;
47 | 		/* TODO: Enable/disable SRAM */
48 | 	}
49 | 
50 | 	/* Switch rom bank at 4000-7fff */
51 | 	if(d >= 0x2000 && d < 0x4000)
52 | 	{
53 | 		/* Bits 0-4 come from the value written to memory here,
54 | 		 * bits 5-6 come from a seperate write to 4000-5fff if
55 | 		 * RAM select is 1.
56 | 		 */
57 | 		bank = i & 0x1F;
58 | 		if(!ram_select)
59 | 			bank |= bank_upper_bits;
60 | 
61 | 		/* "Writing to this address space selects the lower 5 bits of the
62 | 		 * ROM Bank Number (in range 01-1Fh). When 00h is written, the MBC
63 | 		 * translates that to bank 01h also."
64 | 		 * http://nocash.emubase.de/pandocs.htm#mbc1max2mbyteromandor32kbyteram
65 | 		 */
66 | 
67 | 		if(bank == 0 || bank == 0x20 || bank == 0x40 || bank == 0x60)
68 | 			bank++;
69 | 
70 | 		mem_bank_switch(bank);
71 | 
72 | 		return FILTER_WRITE;
73 | 	}
74 | 
75 | 	/* Bit 5 and 6 of the bank selection */
76 | 	if(d >= 0x4000 && d < 0x6000)
77 | 	{
78 | 		bank_upper_bits = (i & 0x3)<<5;
79 | 		return FILTER_WRITE;
80 | 	}
81 | 
82 | 	if(d >= 0x6000 && d <= 0x7FFF)
83 | 	{
84 | 		ram_select = i&1;
85 | 		return FILTER_WRITE;
86 | 	}
87 | 	return NO_FILTER_WRITE;
88 | }
89 | 


--------------------------------------------------------------------------------
/arduino/gameboy/mbc.h:
--------------------------------------------------------------------------------
1 | #ifndef MBC_H
2 | #define MBC_H
3 | unsigned int MBC1_write_byte(unsigned short, unsigned char);
4 | unsigned int MBC3_write_byte(unsigned short, unsigned char);
5 | #endif
6 | 


--------------------------------------------------------------------------------
/arduino/gameboy/mem.h:
--------------------------------------------------------------------------------
 1 | #ifndef MEM_H
 2 |  #define MEM_H
 3 | 
 4 | //JJ #ifdef __cplusplus
 5 | 
 6 | //JJ extern "C" {
 7 | //JJ 
 8 | //JJ #endif
 9 | 
10 | #include "rom.h"
11 | #include "gbConfig.h"
12 | 
13 | //static unsigned char *mem; //memoria al principio
14 | static unsigned char *mem; //memoria al principio
15 | //static unsigned char mem[0x10000];
16 | 
17 | //void MemPrintROMWIFI(void);
18 | //void MemInitPendingWIFI(void);
19 | //unsigned char * MEMGetMEM();
20 | //void MEMResetROM(void);
21 | //void MEMUpload(unsigned char *auxBuf, int auxLen);
22 | //void mem_initWIFI(void);
23 | void MemAssignPtrMem(unsigned char *);
24 | void ResetDMAPending(void);
25 | #if defined(use_max_ram) || defined (use_half_ram)
26 |  void MemPreparaBankSwitchPtr(unsigned char **ptr);
27 |  void MemBankSwitchClear();
28 | #endif 
29 | unsigned char * MemGetAddressMem(void);
30 | void MemAssignROMPtrMemory(void);
31 | void mem_init(void);
32 | unsigned char mem_get_byte(unsigned short);
33 | unsigned short mem_get_word(unsigned short);
34 | void mem_write_byte(unsigned short, unsigned char);
35 | void mem_write_word(unsigned short, unsigned short);
36 | void mem_bank_switch(unsigned short int);
37 | unsigned char mem_get_raw(unsigned short);
38 | //JJ #ifdef __cplusplus
39 | 
40 | //JJ   }
41 | 
42 | //JJ #endif /* end of __cplusplus */
43 | #endif
44 | 


--------------------------------------------------------------------------------
/arduino/gameboy/osd.h:
--------------------------------------------------------------------------------
 1 | #ifndef OSDFILE_H
 2 |  #define OSDFILE_H
 3 |  #include "gbConfig.h"
 4 |  
 5 |  void changeSna2Flash(unsigned char id);
 6 |  void do_tinyOSD(void);
 7 |  //void SDLAssignSDLSurfaceOSD(SDL_Surface *surface,SDL_Event * ptrEvent);
 8 |  void SDLActivarOSDMainMenu();
 9 |  void SDLOSDClear(void);
10 |  //SDL_Surface * SDLOSDGetSurface();
11 |  void SDLEsperaTeclado(void);
12 |  #ifdef use_lib_tinyFont
13 |   void SDLprintChar(char car,short int x,short int y,unsigned char color,unsigned char backcolor);
14 |   void SDLprintText(const char *cad,short int x, short int y, unsigned char color,unsigned char backcolor);
15 |  #endif  
16 | #endif
17 | 


--------------------------------------------------------------------------------
/arduino/gameboy/rom.h:
--------------------------------------------------------------------------------
 1 | #ifndef ROM_H
 2 | #define ROM_H
 3 | #ifdef __cplusplus
 4 | 
 5 | extern "C" {
 6 | 
 7 | #endif
 8 | //int rom_initWIFI(unsigned char * auxPointer);
 9 | //int rom_load(const char *filename);
10 | int rom_init(const unsigned char *);
11 | const unsigned char *rom_getbytes(void);
12 | unsigned int rom_get_mapper(void);
13 | 
14 | enum {
15 | 	NROM,
16 | 	MBC1,
17 | 	MBC2,
18 | 	MMM01,
19 | 	MBC3,
20 | 	MBC4,
21 | 	MBC5,
22 | };
23 | #ifdef __cplusplus
24 | 
25 |   }
26 | 
27 | #endif /* end of __cplusplus */
28 | #endif
29 | 


--------------------------------------------------------------------------------
/arduino/gameboy/sdl.h:
--------------------------------------------------------------------------------
 1 | #include <Arduino.h>
 2 | #include "gbConfig.h"
 3 | #ifndef SDL_H
 4 | #define SDL_H
 5 | 
 6 | #define GAMEBOY_HEIGHT 144
 7 | #define GAMEBOY_WIDTH 160
 8 | 
 9 | static unsigned char * pixels = NULL; //(byte *)malloc(5760);
10 | //#ifdef use_lib_vga_thread
11 | // static unsigned char * gb_pixels_backup = NULL;
12 | // //static byte * gb_pixels_backup = NULL; //(byte *)malloc(5760); //GAMEBOY_HEIGHT * GAMEBOY_WIDTH / 4];
13 | //#endif
14 | 
15 | //Joystick
16 | //struct StructButtons {
17 | // unsigned char b_select;
18 | // unsigned char b_start;
19 | // unsigned char b_right;
20 | // unsigned char b_left;
21 | // unsigned char b_up;
22 | // unsigned char b_down;
23 | // unsigned char b_a;
24 | // unsigned char b_b;
25 | //};
26 | 
27 | enum {
28 |  MODE_GRAY = 0x00,
29 |  MODE_FAST_RED  = 0x01 
30 | };
31 | 
32 | static byte gb_mode_visual=MODE_GRAY;
33 | 
34 | //JJint sdl_update(void);
35 | //void sdl_init(void);
36 | void SDL_AssignPtrPixels(unsigned char * auxPtr);
37 | //#ifdef use_lib_vga_thread
38 | // void SDL_AssignBackupPtrPixels(unsigned char * auxPtr);
39 | //#endif
40 | unsigned char * SDL_GetPointerPixels();
41 | //void SDLAssignLookup160lines(unsigned short int *ptr); //No se usa fabgl
42 | //void SDL_FlipLineRedFastFabgl(int aLine);
43 | //void SDL_FlipLineFastFabgl(int aLine);
44 | unsigned char SDLGetModeVisual();
45 | void SetModeVisual(byte auxMode);
46 | //void SDL_AssignVGA(uint8_t **aux_scanline_p);
47 | //void SDL_InitBuffers(void);
48 | void sdl_frame(void);
49 | //void sdl_quit(void);
50 | byte* sdl_get_framebuffer(void);
51 | byte sdl_get_buttons(void);
52 | byte sdl_get_directions(void);
53 | //void SDL_Flip_fast();
54 | //void SDL_Flip();
55 | //int jj_sdl_update(fabgl::PS2Controller auxPS2Controller);
56 | //void jj_sdl_joystick(StructButtons * auxButtons);
57 | //byte jj_getColorIndexFromFrameBuffer(byte x, byte y);
58 | #endif
59 | 


--------------------------------------------------------------------------------
/arduino/gameboy/timer.cpp:
--------------------------------------------------------------------------------
  1 | #include "timer.h"
  2 | #include "interrupt.h"
  3 | #include "cpu.h"
  4 | 
  5 | static unsigned int prev_time;
  6 | static unsigned int elapsed;
  7 | static unsigned int ticks;
  8 | 
  9 | static unsigned char tac;
 10 | static unsigned int started;
 11 | static unsigned int speed;
 12 | static unsigned int counter;
 13 | static unsigned int divider;
 14 | static unsigned int modulo;
 15 | 
 16 | void timer_set_div(unsigned char v)
 17 | {
 18 | 	(void) v;
 19 | 	divider = 0;
 20 | }
 21 | 
 22 | unsigned char timer_get_div(void)
 23 | {
 24 | 	return divider;
 25 | }
 26 | 
 27 | void timer_set_counter(unsigned char v)
 28 | {
 29 | 	counter = v;
 30 | }
 31 | 
 32 | unsigned char timer_get_counter(void)
 33 | {
 34 | 	return counter;
 35 | }
 36 | 
 37 | void timer_set_modulo(unsigned char v)
 38 | {
 39 | 	modulo = v;
 40 | }
 41 | 
 42 | unsigned char timer_get_modulo(void)
 43 | {
 44 | 	return modulo;
 45 | }
 46 | 
 47 | void timer_set_tac(unsigned char v)
 48 | {
 49 | 	int speeds[] = {64, 1, 4, 16};
 50 | 	tac = v;
 51 | 	started = v&4;
 52 | 	speed = speeds[v&3];
 53 | }
 54 | 
 55 | unsigned char timer_get_tac(void)
 56 | {
 57 | 	return tac;
 58 | }
 59 | 
 60 | static void timer_tick(void)
 61 | {
 62 | 	/* 1/262144Hz has elapsed */
 63 | 	ticks++;
 64 | 
 65 | 	/* Divider updates at 16384Hz */
 66 | 	if(ticks == 16)
 67 | 	{
 68 | 		divider++;
 69 | 		ticks = 0;
 70 | 	}
 71 | 
 72 | 	if(!started)
 73 | 		return;
 74 | 
 75 | 	if(ticks == speed)
 76 | 	{
 77 | 		counter++;
 78 | 		ticks = 0;
 79 | 	}
 80 | 
 81 | 	if(counter == 0x100)
 82 | 	{
 83 | 		interrupt(INTR_TIMER);
 84 | 		counter = modulo;
 85 | 	}
 86 | }
 87 | 
 88 | void timer_cycle(void)
 89 | {
 90 | 	/* The amount of ticks since we last ran */ 
 91 | 	unsigned int delta = cpu_get_cycles() - prev_time;
 92 | 	prev_time = cpu_get_cycles();
 93 | 
 94 | 	elapsed += delta * 4; /* 4 cycles to a timer tick */
 95 | 	if(elapsed >= 16)
 96 | 	{
 97 | 		timer_tick();
 98 | 		elapsed -= 16;	/* keep track of the time overflow */
 99 | 	}
100 | }
101 | 


--------------------------------------------------------------------------------
/arduino/gameboy/timer.h:
--------------------------------------------------------------------------------
 1 | #ifndef TIMER_H
 2 | #define TIMER_H
 3 | void timer_set_tac(unsigned char);
 4 | void timer_cycle(void);
 5 | unsigned char timer_get_div(void);
 6 | unsigned char timer_get_counter(void);
 7 | unsigned char timer_get_modulo(void);
 8 | unsigned char timer_get_tac(void);
 9 | void timer_set_div(unsigned char);
10 | void timer_set_counter(unsigned char);
11 | void timer_set_modulo(unsigned char);
12 | #endif
13 | 


--------------------------------------------------------------------------------
/arduino/include/nada.txt:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
 1 | # Contributor Covenant Code of Conduct
 2 | 
 3 | ## Our Pledge
 4 | 
 5 | In the interest of fostering an open and welcoming environment, we as
 6 | contributors and maintainers pledge to making participation in our project and
 7 | our community a harassment-free experience for everyone, regardless of age, body
 8 | size, disability, ethnicity, sex characteristics, gender identity and expression,
 9 | level of experience, education, socio-economic status, nationality, personal
10 | appearance, race, religion, or sexual identity and orientation.
11 | 
12 | ## Our Standards
13 | 
14 | Examples of behavior that contributes to creating a positive environment
15 | include:
16 | 
17 | * Using welcoming and inclusive language
18 | * Being respectful of differing viewpoints and experiences
19 | * Gracefully accepting constructive criticism
20 | * Focusing on what is best for the community
21 | * Showing empathy towards other community members
22 | 
23 | Examples of unacceptable behavior by participants include:
24 | 
25 | * The use of sexualized language or imagery and unwelcome sexual attention or
26 |  advances
27 | * Trolling, insulting/derogatory comments, and personal or political attacks
28 | * Public or private harassment
29 | * Publishing others' private information, such as a physical or electronic
30 |  address, without explicit permission
31 | * Other conduct which could reasonably be considered inappropriate in a
32 |  professional setting
33 | 
34 | ## Our Responsibilities
35 | 
36 | Project maintainers are responsible for clarifying the standards of acceptable
37 | behavior and are expected to take appropriate and fair corrective action in
38 | response to any instances of unacceptable behavior.
39 | 
40 | Project maintainers have the right and responsibility to remove, edit, or
41 | reject comments, commits, code, wiki edits, issues, and other contributions
42 | that are not aligned to this Code of Conduct, or to ban temporarily or
43 | permanently any contributor for other behaviors that they deem inappropriate,
44 | threatening, offensive, or harmful.
45 | 
46 | ## Scope
47 | 
48 | This Code of Conduct applies both within project spaces and in public spaces
49 | when an individual is representing the project or its community. Examples of
50 | representing a project or community include using an official project e-mail
51 | address, posting via an official social media account, or acting as an appointed
52 | representative at an online or offline event. Representation of a project may be
53 | further defined and clarified by project maintainers.
54 | 
55 | ## Enforcement
56 | 
57 | Instances of abusive, harassing, or otherwise unacceptable behavior may be
58 | reported by contacting the project team at fdivitto2013@gmail.com. All
59 | complaints will be reviewed and investigated and will result in a response that
60 | is deemed necessary and appropriate to the circumstances. The project team is
61 | obligated to maintain confidentiality with regard to the reporter of an incident.
62 | Further details of specific enforcement policies may be posted separately.
63 | 
64 | Project maintainers who do not follow or enforce the Code of Conduct in good
65 | faith may face temporary or permanent repercussions as determined by other
66 | members of the project's leadership.
67 | 
68 | ## Attribution
69 | 
70 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
71 | available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
72 | 
73 | [homepage]: https://www.contributor-covenant.org
74 | 
75 | For answers to common questions about this code of conduct, see
76 | https://www.contributor-covenant.org/faq
77 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/README.md:
--------------------------------------------------------------------------------
 1 | # FabGL
 2 | ### Display Controller, PS/2 Mouse and Keyboard Controller, Graphics Library, Sound Engine, Graphical User Interface (GUI), Game Engine and ANSI/VT Terminal for the **ESP32**
 3 | 
 4 | **[Please look here for full API documentation](http://www.fabglib.org)**
 5 | 
 6 | 
 7 | You can support development by purchasing my own [development board](https://www.tindie.com/products/fabgl/fabgl-development-board/).
 8 | 
 9 | This library works with ESP32 revision 1 or upper. See [**Compatible Boards**][Boards].
10 | 
11 | FabGL is mainly a Graphics Library for ESP32. It implements several display drivers (for direct VGA output and for I2C and SPI LCD drivers).
12 | FabGL can also get input from a PS/2 Keyboard and a Mouse. FabGL implements also: an Audio Engine, a Graphical User Interface (GUI), a Game Engine and an ANSI/VT Terminal.
13 | 
14 | This library works with ESP32 revision 1 and upper.
15 | 
16 | VGA output requires a digital to analog converter (DAC): it can be done by three 270 Ohm resistors to have 8 colors, or by 6 resistors to have 64 colors.
17 | 
18 | There are several fixed and variable width fonts embedded.
19 | 
20 | Unlimited number of sprites are supported. However big sprites and a large amount of them reduces the frame rate and could generate flickering.
21 | 
22 | When there is enough memory (on low resolutions like 320x200), it is possible to allocate two screen buffers, so to implement double buffering.
23 | In this case primitives are always drawn on the back buffer.
24 | 
25 | Except for double buffering or when explicitly disabled, all drawings are performed on vertical retracing (using VGA driver), so no flickering is visible.
26 | If the queue of primitives to draw is not processed before the vertical retracing ends, then it is interrupted and continued at next retracing.
27 | 
28 | There is a graphical user interface (GUI) with overlapping windows and mouse handling and a lot of widgets (buttons, editboxes, checkboxes, comboboxes, listboxes, etc..).
29 | 
30 | Finally, there is a sound engine, with multiple channels mixed to a mono output. Each channel can generate sine waveforms, square, etc... or custom sampled data.
31 | 
32 | 
33 | 
34 | ### Installation Tutorial (click for video):
35 | 
36 | [![Everything Is AWESOME](https://img.youtube.com/vi/8OTaPQlSTas/hqdefault.jpg)](https://www.youtube.com/watch?v=8OTaPQlSTas "")
37 | 
38 | ### Space Invaders Example (click for video):
39 | 
40 | [![Everything Is AWESOME](https://img.youtube.com/vi/LL8J7tjxeXA/hqdefault.jpg)](https://www.youtube.com/watch?v=LL8J7tjxeXA "")
41 | 
42 | ### Serial Terminal for MBC2 Z80 Board (click for video):
43 | 
44 | [![Everything Is AWESOME](https://img.youtube.com/vi/Ww_pH_ZOLqU/hqdefault.jpg)](https://www.youtube.com/watch?v=Ww_pH_ZOLqU "")
45 | 
46 | ### Graphical User Interface - GUI (click for video):
47 | 
48 | [![Everything Is AWESOME](https://img.youtube.com/vi/84ytGdiOih0/hqdefault.jpg)](https://www.youtube.com/watch?v=84ytGdiOih0 "")
49 | 
50 | ### Sound Engine (click for video):
51 | 
52 | [![Everything Is AWESOME](https://img.youtube.com/vi/RQtKFgU7OYI/hqdefault.jpg)](https://www.youtube.com/watch?v=RQtKFgU7OYI "")
53 | 
54 | ### Altair 8800 emulator - CP/M text games (click for video):
55 | 
56 | [![Everything Is AWESOME](https://img.youtube.com/vi/y0opVifEyS8/hqdefault.jpg)](https://www.youtube.com/watch?v=y0opVifEyS8 "")
57 | 
58 | ### Commodore VIC20 emulator (click for video):
59 | 
60 | [![Everything Is AWESOME](https://img.youtube.com/vi/ZW427HVWYys/hqdefault.jpg)](https://www.youtube.com/watch?v=ZW427HVWYys "")
61 | 
62 | ### Simple Terminal Out Example (click for video):
63 | 
64 | [![Everything Is AWESOME](https://img.youtube.com/vi/AmXN0SIRqqU/hqdefault.jpg)](https://www.youtube.com/watch?v=AmXN0SIRqqU "")
65 | 
66 | ### Network Terminal Example (click for video):
67 | 
68 | [![Everything Is AWESOME](https://img.youtube.com/vi/n5c27-y5tm4/hqdefault.jpg)](https://www.youtube.com/watch?v=n5c27-y5tm4 "")
69 | 
70 | ### Modeline Studio Example (click for video):
71 | 
72 | [![Everything Is AWESOME](https://img.youtube.com/vi/Urp0rPukjzE/hqdefault.jpg)](https://www.youtube.com/watch?v=Urp0rPukjzE "")
73 | 
74 | ### Loopback Terminal Example (click for video):
75 | 
76 | [![Everything Is AWESOME](https://img.youtube.com/vi/hQhU5hgWdcU/hqdefault.jpg)](https://www.youtube.com/watch?v=hQhU5hgWdcU "")
77 | 
78 | ### Double Buffering Example (click for video):
79 | 
80 | [![Everything Is AWESOME](https://img.youtube.com/vi/TRQcIiWQCJw/hqdefault.jpg)](https://www.youtube.com/watch?v=TRQcIiWQCJw "")
81 | 
82 | ### Collision Detection Example (click for video):
83 | 
84 | [![Everything Is AWESOME](https://img.youtube.com/vi/q3OPSq4HhDE/hqdefault.jpg)](https://www.youtube.com/watch?v=q3OPSq4HhDE "")
85 | 
86 | 
87 | 
88 | 
89 | [Donations]: https://github.com/fdivitto/FabGL/wiki/Donations
90 | [Boards]: https://github.com/fdivitto/FabGL/wiki/Boards
91 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/fabgl GPIOs assignment.txt:
--------------------------------------------------------------------------------
 1 | ** FabGL GPIOs assignment summary - fabgl dev board rev2 **
 2 | 
 3 | VGA
 4 |   HSync => 23
 5 |   VSync => 15
 6 |   R0    => 22
 7 |   R1    => 21
 8 |   G0    => 19
 9 |   G1    => 18
10 |   B0    => 5
11 |   B1    => 4
12 | 
13 | PS/2 - Keyboard
14 |   DAT   => 32
15 |   CLK   => 33
16 | 
17 | PS/2 - Mouse
18 |   DAT   => 27
19 |   CLK   => 26
20 | 
21 | Audio
22 |   AUD   => 25
23 | 
24 | SDCard - HSPI
25 |   MOSI  => 17
26 |   MISO  => 16
27 |   CLK   => 14
28 |   CS    => 13
29 | 
30 | UART - UART2
31 |   RX    => 34
32 |   TX    => 2
33 | 
34 | I2C (not usable with VGA)
35 |   SDA   => 4  (conflicts with VGA B1)
36 |   SCL   => 15 (conflicts with VGA VSync)
37 | 
38 | SPI Display - VSPI (not usable with VGA)
39 |   CLK   => 18 (conflicts with VGA G1)
40 |   MISO  => 19 (conflicts with VGA G0)
41 |   MOSI  => 23 (conflicts with VGA HSync)
42 |   CS    => 5  (conflicts with VGA B0)
43 |   D/C   => 22 (conflicts with VGA R0)
44 |   RESET => 21 (conflicts with VGA R1)
45 |   
46 |   
47 |   


--------------------------------------------------------------------------------
/arduino/lib/FabGL/library.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "FabGL",
 3 |   "keywords": "sprite, terminal, VT100, ANSI, keyboard, mouse, VGA, SSD1306, OLED, DS3231, I2S, I2C, game, engine, PS2, graphics, audio, sound, font, arduino, ESP32, display",
 4 |   "description": "VGA Controller, PS/2 Mouse and Keyboard Controller, Graphics Library, Sound Engine, Game Engine and ANSI/VT Terminal for the ESP32.",
 5 |   "repository":
 6 |   {
 7 |     "type": "git",
 8 |     "url": "https://github.com/fdivitto/FabGL.git"
 9 |   },
10 |   "authors":
11 |   [
12 |     {
13 |       "name": "Fabrizio Di Vittorio",
14 |       "email": "fdivitto2013@gmail.com",
15 |       "url": "https://github.com/fdivitto",
16 |       "maintainer": true
17 |     }
18 |   ],
19 |   "version": "0.9.0",
20 |   "frameworks": "arduino",
21 |   "platforms": "espressif32"
22 | }
23 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/library.properties:
--------------------------------------------------------------------------------
 1 | name=FabGL
 2 | version=0.9.0
 3 | author=Fabrizio Di Vittorio <fdivitto2013@gmail.com>
 4 | maintainer=Fabrizio Di Vittorio <fdivitto2013@gmail.com>
 5 | sentence=VGA, SSD1306 Controller, PS/2 Mouse and Keyboard Controller, Graphics Library, Graphical User Interface (GUI), Sound Engine, Game Engine and ANSI/VT Terminal for the ESP32
 6 | paragraph=VGA, SSD1306 Controller, PS/2 Mouse and Keyboard Controller, Graphics Library, Graphical User Interface (GUI), Sound Engine, Game Engine and ANSI/VT Terminal for the ESP32
 7 | url=https://github.com/fdivitto/fabgl
 8 | architectures=esp32
 9 | includes=fabgl.h
10 | category=Other
11 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/comdrivers/ps2controller.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |   All rights reserved.
  5 | 
  6 |   This file is part of FabGL Library.
  7 | 
  8 |   FabGL is free software: you can redistribute it and/or modify
  9 |   it under the terms of the GNU General Public License as published by
 10 |   the Free Software Foundation, either version 3 of the License, or
 11 |   (at your option) any later version.
 12 | 
 13 |   FabGL is distributed in the hope that it will be useful,
 14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |   GNU General Public License for more details.
 17 | 
 18 |   You should have received a copy of the GNU General Public License
 19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 |  */
 21 | 
 22 | 
 23 | #pragma once
 24 | 
 25 | 
 26 | 
 27 | /**
 28 |  * @file
 29 |  *
 30 |  * @brief This file contains fabgl::PS2Controller definition.
 31 |  */
 32 | 
 33 | 
 34 | #include "freertos/FreeRTOS.h"
 35 | #include "freertos/task.h"
 36 | 
 37 | #include "fabutils.h"
 38 | #include "fabglconf.h"
 39 | 
 40 | 
 41 | namespace fabgl {
 42 | 
 43 | 
 44 | /** \ingroup Enumerations
 45 |  * @brief This enum defines what is connected to PS/2 ports
 46 |  */
 47 | enum class PS2Preset {
 48 |   KeyboardPort0_MousePort1,   /**< Keyboard on Port 0 and Mouse on Port 1 */
 49 |   KeyboardPort0,              /**< Keyboard on Port 0 (no mouse) */
 50 |   MousePort0,                 /**< Mouse on port 0 (no keyboard) */
 51 | };
 52 | 
 53 | 
 54 | /** \ingroup Enumerations
 55 |  * @brief This enum defines how handle keyboard virtual keys
 56 |  */
 57 | enum class KbdMode {
 58 |   NoVirtualKeys,           /**< No virtual keys are generated */
 59 |   GenerateVirtualKeys,     /**< Virtual keys are generated. You can call Keyboard.isVKDown() only. */
 60 |   CreateVirtualKeysQueue,  /**< Virtual keys are generated and put on a queue. You can call Keyboard.isVKDown(), Keyboard.virtualKeyAvailable() and Keyboard.getNextVirtualKey() */
 61 | };
 62 | 
 63 | 
 64 | class Keyboard;
 65 | class Mouse;
 66 | 
 67 | 
 68 | /**
 69 |  * @brief The PS2 device controller class.
 70 |  *
 71 |  * The PS2 controller uses ULP coprocessor and RTC slow memory to communicate with up to two PS2 devices.<br>
 72 |  * The ULP coprocessor continuously monitor CLK and DATA lines for incoming data. Optionally can send commands to the PS2 devices.
 73 |  */
 74 | class PS2Controller {
 75 | 
 76 | public:
 77 | 
 78 |   PS2Controller();
 79 | 
 80 |   // unwanted methods
 81 |   PS2Controller(PS2Controller const&)   = delete;
 82 |   void operator=(PS2Controller const&)  = delete;
 83 | 
 84 |   /**
 85 |   * @brief Initializes PS2 device controller.
 86 |   *
 87 |   * Initializes the PS2 controller assigning GPIOs to DAT and CLK lines.
 88 |   *
 89 |   * Because PS/2 ports are handled by the ULP processor, just few GPIO ports are actually usable. They are:
 90 |   * GPIO_NUM_2, GPIO_NUM_4, GPIO_NUM_12 (with some limitations), GPIO_NUM_13, GPIO_NUM_14, GPIO_NUM_15, GPIO_NUM_25, GPIO_NUM_26, GPIO_NUM_27, GPIO_NUM_32 and GPIO_NUM_33.
 91 |   *
 92 |   * @param port0_clkGPIO The GPIO number of Clock line for PS/2 port 0.
 93 |   * @param port0_datGPIO The GPIO number of Data line for PS/2 port 0.
 94 |   * @param port1_clkGPIO The GPIO number of Clock line for PS/2 port 1 (GPIO_UNUSED to disable).
 95 |   * @param port1_datGPIO The GPIO number of Data line for PS/2 port 1 (GPIO_UNUSED to disable).
 96 |   */
 97 |   void begin(gpio_num_t port0_clkGPIO, gpio_num_t port0_datGPIO, gpio_num_t port1_clkGPIO = GPIO_UNUSED, gpio_num_t port1_datGPIO = GPIO_UNUSED);
 98 | 
 99 |   /**
100 |   * @brief Initializes PS2 device controller using default GPIOs.
101 |   *
102 |   * Initializes the PS2 controller assigning:
103 |   *   - GPIO_NUM_33 (CLK) and GPIO_NUM_32 (DATA) as PS/2 Port 0
104 |   *   - GPIO_NUM_26 (CLK) and GPIO_NUM_27 (DATA) as PS/2 Port 1
105 |   *
106 |   * @param preset Specifies what is connected to PS/2 ports (mouse, keyboard or boths).
107 |   * @param keyboardMode Specifies how handle keyboard virtual keys.
108 |   *
109 |   * Example:
110 |   *
111 |   *     // Keyboard connected to port 0 and mouse to port1
112 |   *     PSController.begin(PS2Preset::KeyboardPort0_MousePort1);
113 |   */
114 |   void begin(PS2Preset preset = PS2Preset::KeyboardPort0_MousePort1, KbdMode keyboardMode = KbdMode::CreateVirtualKeysQueue);
115 | 
116 |   /**
117 |    * @brief Gets the number of scancodes available in the controller buffer.
118 |    *
119 |    * @param PS2Port PS2 port number (0 = port 0, 1 = port1).
120 |    *
121 |    * @return The number of scancodes available to read.
122 |    */
123 |   int dataAvailable(int PS2Port);
124 | 
125 |   bool waitData(int timeOutMS, int PS2Port);
126 | 
127 |   /**
128 |    * @brief Gets a scancode from the queue.
129 |    *
130 |    * @param PS2Port PS2 port number (0 = port 0, 1 = port1).
131 |    *
132 |    * @return The first scancode of the queue (-1 if no data is available).
133 |    */
134 |   int getData(int PS2Port);
135 | 
136 |   /**
137 |    * @brief Sends a command to the device.
138 |    *
139 |    * @param data Byte to send to the PS2 device.
140 |    * @param PS2Port PS2 port number (0 = port 0, 1 = port1).
141 |    */
142 |   void sendData(uint8_t data, int PS2Port);
143 | 
144 |   /**
145 |    * @brief Injects a byte into the RX buffer.
146 |    *
147 |    * Injects a byte as if it were actually sent by the device.
148 |    *
149 |    * @param value Byte to inject.
150 |    * @param PS2Port PS2 port number (0 = port 0, 1 = port1).
151 |    */
152 |   void injectInRXBuffer(int value, int PS2Port);
153 | 
154 |   /**
155 |    * @brief Suspends PS/2 ports operations
156 |    */
157 |   void suspend();
158 | 
159 |   /**
160 |    * @brief Resumes PS/2 ports operations
161 |    */
162 |   void resume();
163 | 
164 |   /**
165 |    * @brief Returns the instance of Keyboard object automatically created by PS2Controller.
166 |    *
167 |    * @return A pointer to a Keyboard object
168 |    */
169 |   Keyboard * keyboard() { return m_keyboard; }
170 | 
171 |   void setKeyboard(Keyboard * value) { m_keyboard = value; }
172 | 
173 |   /**
174 |    * @brief Returns the instance of Mouse object automatically created by PS2Controller.
175 |    *
176 |    * @return A pointer to a Mouse object
177 |    */
178 |   Mouse * mouse() { return m_mouse; }
179 | 
180 |   void setMouse(Mouse * value) { m_mouse = value; }
181 | 
182 |   /**
183 |    * @brief Returns the singleton instance of PS2Controller class
184 |    *
185 |    * @return A pointer to PS2Controller singleton object
186 |    */
187 |   static PS2Controller * instance() { return s_instance; }
188 | 
189 |   void warmInit();
190 | 
191 | private:
192 | 
193 |   static void IRAM_ATTR rtc_isr(void * arg);
194 | 
195 |   static PS2Controller * s_instance;
196 | 
197 |   // Keyboard and Mouse instances can be created by PS2Controller in one of the begin() calls, or can be
198 |   // set using setKeyboard() and setMouse() calls.
199 |   Keyboard *            m_keyboard;
200 |   Mouse *               m_mouse;
201 | 
202 |   // address of next word to read in the circular buffer
203 |   volatile int          m_readPos[2];
204 | 
205 |   // task that is waiting for TX ends
206 |   volatile TaskHandle_t m_TXWaitTask[2];
207 | 
208 |   // task that is waiting for RX event
209 |   volatile TaskHandle_t m_RXWaitTask[2];
210 | 
211 |   intr_handle_t         m_isrHandle;
212 | 
213 |   int16_t               m_suspendCount;       // 0 = not suspended, >0 suspended
214 | };
215 | 
216 | 
217 | 
218 | 
219 | 
220 | } // end of namespace
221 | 
222 | 
223 | 
224 | 
225 | 
226 | 
227 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/comdrivers/ps2device.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |   All rights reserved.
  5 | 
  6 |   This file is part of FabGL Library.
  7 | 
  8 |   FabGL is free software: you can redistribute it and/or modify
  9 |   it under the terms of the GNU General Public License as published by
 10 |   the Free Software Foundation, either version 3 of the License, or
 11 |   (at your option) any later version.
 12 | 
 13 |   FabGL is distributed in the hope that it will be useful,
 14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |   GNU General Public License for more details.
 17 | 
 18 |   You should have received a copy of the GNU General Public License
 19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 |  */
 21 | 
 22 | 
 23 | #pragma once
 24 | 
 25 | 
 26 | 
 27 | #include "freertos/FreeRTOS.h"
 28 | #include "freertos/semphr.h"
 29 | 
 30 | #include "fabglconf.h"
 31 | #include "ps2controller.h"
 32 | 
 33 | 
 34 | /**
 35 |  * @file
 36 |  *
 37 |  * @brief This file contains fabgl::PS2Device definition.
 38 |  */
 39 | 
 40 | 
 41 | namespace fabgl {
 42 | 
 43 | 
 44 | 
 45 | /** \ingroup Enumerations
 46 |  * @brief Represents the type of device attached to PS/2 port.
 47 |  */
 48 | enum class PS2DeviceType {
 49 |   UnknownPS2Device,             /**< Unknown device or unable to connect to the device */
 50 |   OldATKeyboard,                /**< Old AT keyboard */
 51 |   MouseStandard,                /**< Standard mouse */
 52 |   MouseWithScrollWheel,         /**< Mouse with Scroll Wheel */
 53 |   Mouse5Buttons,                /**< Mouse with 5 buttons */
 54 |   MF2KeyboardWithTranslation,   /**< Standard MF2 keyboard with translation */
 55 |   M2Keyboard,                   /**< Standard MF2 keyboard. This is the most common value returned by USB/PS2 modern keyboards */
 56 | };
 57 | 
 58 | 
 59 | 
 60 | /**
 61 |  * @brief Base class for PS2 devices (like mouse or keyboard).
 62 |  *
 63 |  * PS2Device connects to one port of the PS2 Controller class (fabgl::PS2Controller).<br>
 64 |  * The PS2 controller uses ULP coprocessor and RTC slow memory to communicate with the PS2 device.<br>
 65 |  */
 66 | class PS2Device {
 67 | 
 68 | public:
 69 | 
 70 |   /**
 71 |    * @brief Identifies the device attached to the PS2 port.
 72 |    *
 73 |    * @return The identification ID sent by keyboard.
 74 |    */
 75 |   PS2DeviceType identify() { PS2DeviceType result; send_cmdIdentify(&result); return result; };
 76 | 
 77 |   /**
 78 |    * @brief Gets exclusive access to the device.
 79 |    *
 80 |    * @param timeOutMS Timeout in milliseconds to wait before fail.
 81 |    *
 82 |    * @return True if the device has been locked.
 83 |    */
 84 |   bool lock(int timeOutMS);
 85 | 
 86 |   /**
 87 |    * @brief Releases device from exclusive access.
 88 |    */
 89 |   void unlock();
 90 | 
 91 | protected:
 92 | 
 93 |   PS2Device();
 94 |   ~PS2Device();
 95 | 
 96 |   void begin(int PS2Port);
 97 | 
 98 |   int dataAvailable();
 99 |   int getData(int timeOutMS);
100 | 
101 |   void requestToResendLastByte();
102 | 
103 |   bool sendCommand(uint8_t cmd, uint8_t expectedReply);
104 | 
105 |   bool send_cmdLEDs(bool numLock, bool capsLock, bool scrollLock);
106 |   bool send_cmdEcho();
107 |   bool send_cmdGetScancodeSet(uint8_t * result);
108 |   bool send_cmdSetScancodeSet(uint8_t scancodeSet);
109 |   bool send_cmdIdentify(PS2DeviceType * result);
110 |   bool send_cmdDisableScanning();
111 |   bool send_cmdEnableScanning();
112 |   bool send_cmdTypematicRateAndDelay(int repeatRateMS, int repeatDelayMS);
113 |   bool send_cmdSetSampleRate(int sampleRate);
114 |   bool send_cmdSetDefaultParams();
115 |   bool send_cmdReset();
116 |   bool send_cmdSetResolution(int resolution);
117 |   bool send_cmdSetScaling(int scaling);
118 | 
119 | private:
120 | 
121 |   int               m_PS2Port;
122 |   SemaphoreHandle_t m_deviceLock;
123 | };
124 | 
125 | 
126 | 
127 | struct PS2DeviceLock {
128 |   PS2DeviceLock(PS2Device * PS2Device) : m_PS2Device(PS2Device) { m_PS2Device->lock(-1); }
129 |   ~PS2DeviceLock() { m_PS2Device->unlock(); }
130 | 
131 |   PS2Device * m_PS2Device;
132 | };
133 | 
134 | 
135 | 
136 | 
137 | 
138 | 
139 | 
140 | } // end of namespace
141 | 
142 | 
143 | 
144 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/comdrivers/tsi2c.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |   All rights reserved.
  5 | 
  6 |   This file is part of FabGL Library.
  7 | 
  8 |   FabGL is free software: you can redistribute it and/or modify
  9 |   it under the terms of the GNU General Public License as published by
 10 |   the Free Software Foundation, either version 3 of the License, or
 11 |   (at your option) any later version.
 12 | 
 13 |   FabGL is distributed in the hope that it will be useful,
 14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |   GNU General Public License for more details.
 17 | 
 18 |   You should have received a copy of the GNU General Public License
 19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 |  */
 21 | 
 22 | 
 23 | #include "freertos/FreeRTOS.h"
 24 | #include "freertos/task.h"
 25 | 
 26 | #include "tsi2c.h"
 27 | 
 28 | 
 29 | 
 30 | namespace fabgl {
 31 | 
 32 | 
 33 | #define I2C_COMMTASK_STACK    1000
 34 | #define I2C_COMMTASK_PRIORITY 5
 35 | #define I2C_DEFAULT_FREQUENCY 100000
 36 | 
 37 | 
 38 | #define EVTGROUP_READY (1 << 0)
 39 | #define EVTGROUP_WRITE (1 << 1)
 40 | #define EVTGROUP_READ  (1 << 2)
 41 | #define EVTGROUP_DONE  (1 << 3)
 42 | 
 43 | 
 44 | I2C::I2C(int bus)
 45 |   : m_i2c(nullptr),
 46 |     m_bus(bus),
 47 |     m_commTaskHandle(nullptr),
 48 |     m_eventGroup(nullptr)
 49 | {
 50 | }
 51 | 
 52 | 
 53 | I2C::~I2C()
 54 | {
 55 |   end();
 56 | }
 57 | 
 58 | 
 59 | bool I2C::begin(gpio_num_t SDAGPIO, gpio_num_t SCLGPIO)
 60 | {
 61 |   m_SDAGPIO   = SDAGPIO;
 62 |   m_SCLGPIO   = SCLGPIO;
 63 | 
 64 |   m_eventGroup = xEventGroupCreate();
 65 | 
 66 |   // why a task? Because esp32 i2c communications must be done on the same core
 67 |   // must be pinned to one core (0 in this case)
 68 |   xTaskCreatePinnedToCore(&commTaskFunc, "", I2C_COMMTASK_STACK, this, I2C_COMMTASK_PRIORITY, &m_commTaskHandle, 0);
 69 | 
 70 |   // wait for commTaskFunc() ends initialization
 71 |   xEventGroupWaitBits(m_eventGroup, EVTGROUP_DONE, true, false, portMAX_DELAY);
 72 | 
 73 |   // ready to accept jobs
 74 |   xEventGroupSetBits(m_eventGroup, EVTGROUP_READY);
 75 | 
 76 |   return m_i2c != nullptr;
 77 | }
 78 | 
 79 | 
 80 | void I2C::end()
 81 | {
 82 |   if (m_commTaskHandle)
 83 |     vTaskDelete(m_commTaskHandle);
 84 |   m_commTaskHandle = nullptr;
 85 | 
 86 |   if (m_i2c)
 87 |     i2cRelease(m_i2c);
 88 |   m_i2c = nullptr;
 89 | 
 90 |   if (m_eventGroup)
 91 |     vEventGroupDelete(m_eventGroup);
 92 |   m_eventGroup = nullptr;
 93 | }
 94 | 
 95 | 
 96 | bool I2C::write(int address, uint8_t * buffer, int size, int frequency, int timeOutMS)
 97 | {
 98 |   // wait for I2C to be ready
 99 |   xEventGroupWaitBits(m_eventGroup, EVTGROUP_READY, true, false, portMAX_DELAY);
100 | 
101 |   m_jobInfo.frequency = frequency;
102 |   m_jobInfo.address   = address;
103 |   m_jobInfo.buffer    = buffer;
104 |   m_jobInfo.size      = size;
105 |   m_jobInfo.timeout   = timeOutMS;
106 | 
107 |   // unlock comm task for writing
108 |   // wait for comm task to finish job
109 |   xEventGroupSync(m_eventGroup, EVTGROUP_WRITE, EVTGROUP_DONE, portMAX_DELAY);
110 | 
111 | 
112 |   bool ret = (m_jobInfo.lastError == I2C_ERROR_OK);
113 | 
114 |   // makes I2C ready for new requests
115 |   xEventGroupSetBits(m_eventGroup, EVTGROUP_READY);
116 | 
117 |   return ret;
118 | }
119 | 
120 | 
121 | int I2C::read(int address, uint8_t * buffer, int size, int frequency, int timeOutMS)
122 | {
123 |   // wait for I2C to be ready
124 |   xEventGroupWaitBits(m_eventGroup, EVTGROUP_READY, true, false, portMAX_DELAY);
125 | 
126 |   m_jobInfo.frequency = frequency;
127 |   m_jobInfo.address   = address;
128 |   m_jobInfo.buffer    = buffer;
129 |   m_jobInfo.size      = size;
130 |   m_jobInfo.timeout   = timeOutMS;
131 | 
132 |   // unlock comm task for reading
133 |   // wait for comm task to finish job
134 |   xEventGroupSync(m_eventGroup, EVTGROUP_READ, EVTGROUP_DONE, portMAX_DELAY);
135 | 
136 |   int ret = m_jobInfo.readCount;
137 | 
138 |   // makes I2C ready for new requests
139 |   xEventGroupSetBits(m_eventGroup, EVTGROUP_READY);
140 | 
141 |   return ret;
142 | }
143 | 
144 | 
145 | 
146 | void I2C::commTaskFunc(void * pvParameters)
147 | {
148 |   I2C * ths = (I2C*) pvParameters;
149 | 
150 |   i2c_t * i2c = i2cInit(ths->m_bus, ths->m_SDAGPIO, ths->m_SCLGPIO, I2C_DEFAULT_FREQUENCY);
151 |   if (!i2c) {
152 |     ESP_LOGE("unable to init I2C");
153 |     abort();
154 |   }
155 | 
156 |   i2cFlush(i2c);
157 | 
158 |   ths->m_i2c = i2c;
159 | 
160 |   // get initial default frequency
161 |   int freq = i2cGetFrequency(i2c);
162 | 
163 |   I2CJobInfo * job = &ths->m_jobInfo;
164 | 
165 |   // main send/receive loop
166 |   while (true) {
167 | 
168 |     // unlock waiting task
169 |     xEventGroupSetBits(ths->m_eventGroup, EVTGROUP_DONE);
170 | 
171 |     // wait for another job
172 |     auto bits = xEventGroupWaitBits(ths->m_eventGroup, EVTGROUP_WRITE | EVTGROUP_READ, true, false, portMAX_DELAY);
173 | 
174 |     // setup frequency if necessary
175 |     if (freq != job->frequency) {
176 |       freq = job->frequency;
177 |       i2cSetFrequency(i2c, freq);
178 |     }
179 | 
180 |     if (bits & EVTGROUP_WRITE)
181 |       job->lastError = i2cWrite(i2c, job->address, job->buffer, job->size, true, job->timeout);
182 |     else if (bits & EVTGROUP_READ)
183 |       job->lastError = i2cRead(i2c, job->address, job->buffer, job->size, true, job->timeout, &job->readCount);
184 | 
185 |   }
186 | 
187 | }
188 | 
189 | 
190 | 
191 | } // end of namespace
192 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/comdrivers/tsi2c.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |   All rights reserved.
  5 | 
  6 |   This file is part of FabGL Library.
  7 | 
  8 |   FabGL is free software: you can redistribute it and/or modify
  9 |   it under the terms of the GNU General Public License as published by
 10 |   the Free Software Foundation, either version 3 of the License, or
 11 |   (at your option) any later version.
 12 | 
 13 |   FabGL is distributed in the hope that it will be useful,
 14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |   GNU General Public License for more details.
 17 | 
 18 |   You should have received a copy of the GNU General Public License
 19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 |  */
 21 | 
 22 | 
 23 | #pragma once
 24 | 
 25 | 
 26 | #include <stdint.h>
 27 | #include <stddef.h>
 28 | 
 29 | #include "freertos/FreeRTOS.h"
 30 | #include "freertos/queue.h"
 31 | #include "freertos/semphr.h"
 32 | 
 33 | #include "esp32-hal.h"
 34 | 
 35 | #include "fabglconf.h"
 36 | 
 37 | 
 38 | 
 39 | /**
 40 |  * @file
 41 |  *
 42 |  * @brief This file contains fabgl::I2C definition.
 43 |  */
 44 | 
 45 | 
 46 | namespace fabgl {
 47 | 
 48 | 
 49 | struct I2CJobInfo {
 50 |   int32_t   frequency;
 51 |   uint8_t * buffer;
 52 |   uint8_t   address;
 53 |   uint16_t  size;
 54 |   uint16_t  timeout;
 55 |   uint32_t  readCount;
 56 |   i2c_err_t lastError;
 57 | };
 58 | 
 59 | 
 60 | /**
 61 |  * @brief I2C class allows multiple tasks to communicate with I2C devices, serializing read/write jobs.
 62 |  *
 63 |  * A single instance of I2C class can be shared among multiple tasks or timers (not interrupts).
 64 |  *
 65 |  * Example:
 66 |  *
 67 |  *     fabgl::I2C I2C;
 68 |  *
 69 |  *     void setup() {
 70 |  *       I2C.begin(GPIO_NUM_4, GPIO_NUM_15);  // 4 = SDA, 15 = SCL (WARN: disconnect VGA connector!!)
 71 |  *     }
 72 |  */
 73 | class I2C {
 74 | 
 75 | public:
 76 | 
 77 |   /**
 78 |    * @brief I2C class constructor
 79 |    *
 80 |    * @param bus I2C bus to use. Allowed 0 or 1 (default is 0).
 81 |    */
 82 |   I2C(int bus = 0);
 83 | 
 84 |   ~I2C();
 85 | 
 86 |   /**
 87 |    * @brief Initializes I2C instance associating GPIOs to I2C signals.
 88 |    *
 89 |    * @param SDAGPIO Pin to use for SDA signal
 90 |    * @param SCLGPIO Pin to use for SCK signal
 91 |    *
 92 |    * Example:
 93 |    *
 94 |    *     // 4 = SDA, 15 = SCL (WARN: disconnect VGA connector!!)
 95 |    *     I2C.begin(GPIO_NUM_4, GPIO_NUM_15);
 96 |    */
 97 |   bool begin(gpio_num_t SDAGPIO, gpio_num_t SCLGPIO);
 98 | 
 99 |   void end();
100 | 
101 |   /**
102 |    * @brief Sends a buffer to I2C bus.
103 |    *
104 |    * This is a thread-safe operation. Multiple tasks can call this method concurrently.
105 |    *
106 |    * @param address I2C address of the destination slave device
107 |    * @param buffer Buffer to send.
108 |    * @param size Number of bytes to send. Maximum size is the return value of getMaxBufferLength().
109 |    * @param frequency Clock frequency
110 |    * @param timeOutMS Operation timeout in milliseconds
111 |    *
112 |    * @return True on success
113 |    */
114 |   bool write(int address, uint8_t * buffer, int size, int frequency = 100000, int timeOutMS = 50);
115 | 
116 |   /**
117 |    * @brief Receives a buffer from I2C bus
118 |    *
119 |    * This is a thread-safe operation. Multiple tasks can call this methods concurrently.
120 |    *
121 |    * @param address I2C address of the source slave device
122 |    * @param buffer Buffer where to put received data (must have space for at least "size" bytes)
123 |    * @param size Number of bytes to receive. Maximum size is the return value of getMaxBufferLength().
124 |    * @param frequency Clock frequency
125 |    * @param timeOutMS Operation timeout in milliseconds
126 |    *
127 |    * @return Number of actually read bytes
128 |    */
129 |   int read(int address, uint8_t * buffer, int size, int frequency = 100000, int timeOutMS = 50);
130 | 
131 |   /**
132 |    * @brief Returns maximum size of read and write buffers
133 |    *
134 |    * @return Maximum size in bytes
135 |    */
136 |   int getMaxBufferLength() { return 128; }
137 | 
138 | 
139 | private:
140 | 
141 |   static void commTaskFunc(void * pvParameters);
142 | 
143 | 
144 |   i2c_t *            m_i2c;
145 | 
146 |   uint8_t            m_bus;
147 |   gpio_num_t         m_SDAGPIO;
148 |   gpio_num_t         m_SCLGPIO;
149 | 
150 |   TaskHandle_t       m_commTaskHandle;
151 | 
152 |   EventGroupHandle_t m_eventGroup;
153 | 
154 |   I2CJobInfo         m_jobInfo;
155 | };
156 | 
157 | 
158 | 
159 | 
160 | 
161 | 
162 | 
163 | 
164 | 
165 | 
166 | } // end of namespace
167 | 
168 | 
169 | 
170 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/devdrivers/DS3231.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |   All rights reserved.
  5 | 
  6 |   This file is part of FabGL Library.
  7 | 
  8 |   FabGL is free software: you can redistribute it and/or modify
  9 |   it under the terms of the GNU General Public License as published by
 10 |   the Free Software Foundation, either version 3 of the License, or
 11 |   (at your option) any later version.
 12 | 
 13 |   FabGL is distributed in the hope that it will be useful,
 14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |   GNU General Public License for more details.
 17 | 
 18 |   You should have received a copy of the GNU General Public License
 19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 |  */
 21 | 
 22 | 
 23 | #include <string.h>
 24 | #include <time.h>
 25 | 
 26 | #include "freertos/FreeRTOS.h"
 27 | 
 28 | #include "DS3231.h"
 29 | 
 30 | 
 31 | 
 32 | #define DS3231_ADDR 0x68
 33 | #define DS3231_FREQ 400000
 34 | 
 35 | 
 36 | namespace fabgl {
 37 | 
 38 | 
 39 | 
 40 | ////////////////////////////////////////////////////////////////////////////////////////
 41 | ////////////////////////////////////////////////////////////////////////////////////////
 42 | 
 43 | 
 44 | 
 45 | DateTime::DateTime(int seconds_, int minutes_, int hours_, int dayOfMonth_, int month_, int year_)
 46 |   : seconds(seconds_),
 47 |     minutes(minutes_),
 48 |     hours(hours_),
 49 |     dayOfMonth(dayOfMonth_),
 50 |     month(month_),
 51 |     year(year_)
 52 | {
 53 |   calcDayOfWeek();
 54 | }
 55 | 
 56 | 
 57 | // 1 = sunday
 58 | void DateTime::calcDayOfWeek()
 59 | {
 60 |   static const int8_t t[] = { 0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4 };
 61 |   int y = year - (month < 3);
 62 |   dayOfWeek = 1 + (y + y / 4 - y / 100 + y / 400 + t[month - 1] + dayOfMonth) % 7;
 63 | }
 64 | 
 65 | 
 66 | // has 2038 unix bug!!
 67 | time_t DateTime::timestamp(int timezone)
 68 | {
 69 |   tm m;
 70 |   m.tm_sec   = seconds;
 71 |   m.tm_min   = minutes;
 72 |   m.tm_hour  = hours;
 73 |   m.tm_mday  = dayOfMonth;
 74 |   m.tm_mon   = month - 1;
 75 |   m.tm_year  = year - 1900;
 76 |   m.tm_isdst = 0;
 77 |   return mktime(&m) - 3600 * timezone;
 78 | }
 79 | 
 80 | 
 81 | ////////////////////////////////////////////////////////////////////////////////////////
 82 | ////////////////////////////////////////////////////////////////////////////////////////
 83 | 
 84 | 
 85 | DS3231::DS3231()
 86 |   : m_i2c(nullptr),
 87 |     m_available(false),
 88 |     m_dateTimeValid(false)
 89 | {
 90 | }
 91 | 
 92 | 
 93 | void DS3231::begin(I2C * i2c)
 94 | {
 95 |   m_i2c = i2c;
 96 | 
 97 |   // check oscillator stop flag
 98 |   uint8_t status = readReg(0x0F);
 99 |   if (m_available)
100 |     m_dateTimeValid = (status & 0x80) == 0;
101 | }
102 | 
103 | 
104 | uint8_t DS3231::readReg(int reg)
105 | {
106 |   uint8_t b = reg;
107 |   m_i2c->write(DS3231_ADDR, &b, 1, DS3231_FREQ);
108 |   m_available = m_i2c->read(DS3231_ADDR, &b, 1, DS3231_FREQ);
109 |   return b;
110 | }
111 | 
112 | 
113 | bool DS3231::writeReg(int reg, int value)
114 | {
115 |   uint8_t buf[2] = { (uint8_t)reg, (uint8_t)value };
116 |   return m_i2c->write(DS3231_ADDR, buf, 2, DS3231_FREQ);
117 | }
118 | 
119 | 
120 | DateTime const & DS3231::datetime()
121 | {
122 |   // read 7 registers starting from reg 0
123 |   uint8_t b = 0;
124 |   m_i2c->write(DS3231_ADDR, &b, 1, DS3231_FREQ);
125 |   uint8_t buf[7];
126 |   m_available = m_i2c->read(DS3231_ADDR, buf, 7, DS3231_FREQ);
127 | 
128 |   // decode
129 |   if (m_available) {
130 |     m_datetime.seconds = (buf[0] & 0x0f) + ((buf[0] & 0x70) >> 4) * 10;
131 |     m_datetime.minutes = (buf[1] & 0x0f) + ((buf[1] & 0x70) >> 4) * 10;
132 |     m_datetime.hours   = (buf[2] & 0x0f) + ((buf[2] & 0x10) >> 4) * 10;
133 |     if (buf[2] & (1 << 6)) {
134 |       // 12 hours mode (convert to 24)
135 |       if (buf[2] & (1 << 5))
136 |         m_datetime.hours += 12;
137 |     } else {
138 |       // 24 hours mode
139 |       m_datetime.hours += ((buf[2] & 0x20) >> 4) * 10;
140 |     }
141 |     m_datetime.dayOfWeek  = buf[3] & 7;
142 |     m_datetime.dayOfMonth = (buf[4] & 0x0f) + ((buf[4] & 0x30) >> 4) * 10;
143 |     m_datetime.month      = (buf[5] & 0x0f) + ((buf[5] & 0x10) >> 4) * 10;
144 |     m_datetime.year       = (buf[6] & 0x0f) + ((buf[6] & 0xf0) >> 4) * 10 + 2000;
145 |   }
146 |   return m_datetime;
147 | }
148 | 
149 | 
150 | bool DS3231::setDateTime(DateTime const & value)
151 | {
152 |   // write 7 registers starting from reg 0
153 |   uint8_t buf[8];
154 |   buf[0] = 0; // starting reg address
155 |   buf[1] = (value.seconds % 10) | ((value.seconds / 10) << 4);
156 |   buf[2] = (value.minutes % 10) | ((value.minutes / 10) << 4);
157 |   buf[3] = (value.hours % 10) | ((value.hours / 10) << 4);  // bit6=0 -> 24 hours mode
158 |   buf[4] = value.dayOfWeek;
159 |   buf[5] = (value.dayOfMonth % 10) | ((value.dayOfMonth / 10) << 4);;
160 |   buf[6] = (value.month % 10) | ((value.month / 10) << 4);
161 |   buf[7] = ((value.year - 2000) % 10) | (((value.year - 2000) / 10) << 4);
162 |   m_i2c->write(DS3231_ADDR, buf, 8, DS3231_FREQ);
163 | 
164 |   // update oscillator stop flag (make date no more invalid)
165 |   uint8_t st = readReg(0x0f);
166 |   writeReg(0x0f, st & 0x7f);
167 | 
168 |   return m_available;
169 | }
170 | 
171 | 
172 | double DS3231::temperature()
173 | {
174 |   if ((readReg(0x0f) & (0b100)) == 0) {
175 |     // not busy, force "convert temperature"
176 |     uint8_t r = readReg(0x0e) | 0x20;
177 |     writeReg(0x0e, r);
178 |     // wait for not busy
179 |     vTaskDelay(2 / portTICK_PERIOD_MS);
180 |     while ((readReg(0x0f) & (0b100)) != 0 && m_available) {
181 |       vTaskDelay(1);
182 |     }
183 |   }
184 | 
185 |   // read 2 registers starting from reg 0x11
186 |   uint8_t b = 0x11;
187 |   m_i2c->write(DS3231_ADDR, &b, 1, DS3231_FREQ);
188 |   uint8_t buf[2];
189 |   m_available = m_i2c->read(DS3231_ADDR, buf, 2, DS3231_FREQ);
190 | 
191 |   return (int8_t)buf[0] + 0.25 * (buf[1] >> 6);
192 | }
193 | 
194 | 
195 | void DS3231::clockEnabled(bool value)
196 | {
197 |   uint8_t r = readReg(0x0e);
198 |   writeReg(0x0e, value ? (0x7f & r) : (0x80 | r));
199 | }
200 | 
201 | 
202 | }
203 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/devdrivers/DS3231.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |   All rights reserved.
  5 | 
  6 |   This file is part of FabGL Library.
  7 | 
  8 |   FabGL is free software: you can redistribute it and/or modify
  9 |   it under the terms of the GNU General Public License as published by
 10 |   the Free Software Foundation, either version 3 of the License, or
 11 |   (at your option) any later version.
 12 | 
 13 |   FabGL is distributed in the hope that it will be useful,
 14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |   GNU General Public License for more details.
 17 | 
 18 |   You should have received a copy of the GNU General Public License
 19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 |  */
 21 | 
 22 | 
 23 | #pragma once
 24 | 
 25 | 
 26 | /**
 27 |  * @file
 28 |  *
 29 |  * @brief This file contains the DS3231 (Real Time Clock) device driver.
 30 |  */
 31 | 
 32 | 
 33 | 
 34 | 
 35 | #include <stdint.h>
 36 | #include <stddef.h>
 37 | 
 38 | #include "freertos/FreeRTOS.h"
 39 | 
 40 | #include "fabglconf.h"
 41 | #include "fabutils.h"
 42 | #include "comdrivers/tsi2c.h"
 43 | 
 44 | 
 45 | 
 46 | namespace fabgl {
 47 | 
 48 | 
 49 | /**
 50 |  * @brief Represents date and time
 51 |  */
 52 | struct DateTime {
 53 |   int8_t  seconds;      /**< 0..59             */
 54 |   int8_t  minutes;      /**< 0..59             */
 55 |   int8_t  hours;        /**< 0..23             */
 56 |   int8_t  dayOfWeek;    /**< 1..7 (1 = sunday) */
 57 |   int8_t  dayOfMonth;   /**< 1..31             */
 58 |   int8_t  month;        /**< 1..12             */
 59 |   int16_t year;         /**< 1900..9999 (2000..2099 for DS3231, and 1900..2038 using timestamp() */
 60 | 
 61 |   DateTime() { }
 62 |   DateTime(int seconds_, int minutes_, int hours_, int dayOfMonth_, int month_, int year_);
 63 | 
 64 |   /**
 65 |    * @brief Calculates Unix timestamp
 66 |    *
 67 |    * @param timezone Timezone (hours)
 68 |    *
 69 |    * @return Unix timestamp
 70 |    */
 71 |   time_t timestamp(int timezone);
 72 | 
 73 | private:
 74 |   void calcDayOfWeek();
 75 | };
 76 | 
 77 | 
 78 | /**
 79 |  * @brief DS3231 Real Time Clock driver
 80 |  *
 81 |  * Example:
 82 |  *
 83 |  *     fabgl::I2C    I2C;
 84 |  *     fabgl::DS3231 DS3231;
 85 |  *
 86 |  *     void setup() {
 87 |  *       I2C.begin(GPIO_NUM_4, GPIO_NUM_15);  // 4 = SDA, 15 = SCL (WARN: disconnect VGA connector!!)
 88 |  *       DS3231.begin(&I2C);
 89 |  *
 90 |  *       auto dt = DS3231.datetime();
 91 |  *       Serial.printf("%02d/%02d/%d  %02d:%02d:%02d\n", dt.dayOfMonth, dt.month, dt.year, dt.hours, dt.minutes, dt.seconds);
 92 |  *       Serial.printf("temp = %0.3f C\n", DS3231.temperature());
 93 |  *     }
 94 |  *
 95 |  */
 96 | class DS3231 {
 97 | 
 98 | public:
 99 | 
100 |   DS3231();
101 | 
102 |   /**
103 |    * @brief Initializes DS3231 driver
104 |    *
105 |    * @param i2c Pointer to I2C handler
106 |    */
107 |   void begin(I2C * i2c);
108 | 
109 |   /**
110 |    * @brief Determines if DS3231 is reachable
111 |    *
112 |    * @return True if the device has been correctly initialized.
113 |    */
114 |   bool available() { return m_available; }
115 | 
116 |   /**
117 |    * @brief Determines the validity of datetime
118 |    *
119 |    * After calling setDateTime() the datetime becomes valid.
120 |    *
121 |    * @return False indicates that the oscillator either is stopped or was stopped for some period and may be used to judge the validity of the timekeeping data.
122 |    */
123 |   bool dateTimeValid() { return m_dateTimeValid; }
124 | 
125 |   /**
126 |    * @brief Queries DS3231 for current date and time
127 |    *
128 |    * @return A DateTime structure containing current date and time
129 |    */
130 |   DateTime const & datetime();
131 | 
132 |   /**
133 |    * @brief Sets current date and time
134 |    *
135 |    * This methods also resets the invalid date flag.
136 |    *
137 |    * @param value Date and time to set
138 |    */
139 |   bool setDateTime(DateTime const & value);
140 | 
141 |   /**
142 |    * @brief Forces DS3231 to read current temperature
143 |    *
144 |    * @return Current temperature in Celsius Degrees
145 |    */
146 |   double temperature();
147 | 
148 |   /**
149 |    * @brief Enables or disables DS3231 oscillator
150 |    *
151 |    * @param value If true oscillator is enabled (date and time are always maintained by external battery)
152 |    */
153 |   void clockEnabled(bool value);
154 | 
155 | private:
156 | 
157 |   uint8_t readReg(int reg);
158 | 
159 |   bool writeReg(int reg, int value);
160 | 
161 |   I2C *    m_i2c;
162 |   bool     m_available;
163 |   bool     m_dateTimeValid;
164 | 
165 |   DateTime m_datetime;
166 | 
167 | 
168 | };
169 | 
170 | 
171 | 
172 | 
173 | 
174 | 
175 | 
176 | }
177 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/devdrivers/swgenerator.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |   All rights reserved.
  5 | 
  6 |   This file is part of FabGL Library.
  7 | 
  8 |   FabGL is free software: you can redistribute it and/or modify
  9 |   it under the terms of the GNU General Public License as published by
 10 |   the Free Software Foundation, either version 3 of the License, or
 11 |   (at your option) any later version.
 12 | 
 13 |   FabGL is distributed in the hope that it will be useful,
 14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |   GNU General Public License for more details.
 17 | 
 18 |   You should have received a copy of the GNU General Public License
 19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 |  */
 21 | 
 22 | 
 23 | #pragma once
 24 | 
 25 | 
 26 | 
 27 | /**
 28 |  * @file
 29 |  *
 30 |  * @brief This file contains fabgl::GPIOStream definition.
 31 |  */
 32 | 
 33 | 
 34 | #include <stdint.h>
 35 | #include <stddef.h>
 36 | 
 37 | #include "rom/lldesc.h"
 38 | 
 39 | #include "fabglconf.h"
 40 | 
 41 | 
 42 | 
 43 | 
 44 | 
 45 | namespace fabgl {
 46 | 
 47 | 
 48 | 
 49 | /*
 50 |  * This is a square wave generator or DMA->GPIO stream generator that uses APLL internal Audio PLL clock.
 51 |  *
 52 |  * When FABGLIB_USE_APLL_AB_COEF = 0 (the default) the frequency range is 2651514 Hz to 62500000 Hz.<br>
 53 |  * Average error is 21 Hz, Minimum error is 0, Maximum error is 1000 Hz except for range 41666667 Hz to 42708333 Hz while
 54 |  * frequency remains fixed at 41666666 Hz (error from 0 Hz to 1041666 Hz) and except for range 42708334 hz to 43748999 Hz while
 55 |  * frequency remains fixed at 43750000 Hz (error from 750001 Hz to 1041666 Hz).
 56 |  *
 57 |  * When FABGLIB_USE_APLL_AB_COEF = 1 the frequency range is 82500 Hz to 62500000 Hz. Unfortunately the output has lot of frequency jittering.<br>
 58 |  * Average error is about 7 Hz, Minimum error is 0, Maximum error is 6349 Hz.
 59 |  */
 60 | class GPIOStream {
 61 | 
 62 | public:
 63 | 
 64 |   void begin();
 65 | 
 66 |   /*
 67 |    * Initializes GPIOStream and associate GPIOs to the outputs.
 68 |    *
 69 |    * div1_onGPIO0 If true the undivided frequency is delivered on GPIO0.
 70 |    * div2 Specifies the GPIO where to send frequency / 2 (set GPIO_UNUSED to disable output).
 71 |    * div4 Specifies the GPIO where to send frequency / 4 (set GPIO_UNUSED to disable output).
 72 |    * div8 Specifies the GPIO where to send frequency / 8 (set GPIO_UNUSED to disable output).
 73 |    * div16 Specifies the GPIO where to send frequency / 16 (set GPIO_UNUSED to disable output).
 74 |    * div32 Specifies the GPIO where to send frequency / 32 (set GPIO_UNUSED to disable output).
 75 |    * div64 Specifies the GPIO where to send frequency / 64 (set GPIO_UNUSED to disable output).
 76 |    * div128 Specifies the GPIO where to send frequency / 128 (set GPIO_UNUSED to disable output).
 77 |    * div256 Specifies the GPIO where to send frequency / 256 (set GPIO_UNUSED to disable output).
 78 |    *
 79 |    * Example:
 80 |    *
 81 |    *     // Outputs 25Mhz on GPIO0 and 6.25Mhz on GPIO5, for 5 seconds
 82 |    *     GPIOStream.begin(true, GPIO_UNUSED, GPIO_NUM_5);
 83 |    *     GPIOStream.play(25000000);
 84 |    *     delay(5000);
 85 |    *     // Outputs 20Mhz on GPIO and 5Mhz on GPIO5, for 10 seconds
 86 |    *     GPIOStream.play(20000000);
 87 |    *     delay(10000);
 88 |    *     GPIOStream.stop();
 89 |    */
 90 |   void begin(bool div1_onGPIO0, gpio_num_t div2 = GPIO_UNUSED, gpio_num_t div4 = GPIO_UNUSED, gpio_num_t div8 = GPIO_UNUSED, gpio_num_t div16 = GPIO_UNUSED, gpio_num_t div32 = GPIO_UNUSED, gpio_num_t div64 = GPIO_UNUSED, gpio_num_t div128 = GPIO_UNUSED, gpio_num_t div256 = GPIO_UNUSED);
 91 | 
 92 |   /*
 93 |    * Disables all outputs.
 94 |    */
 95 |   void end();
 96 | 
 97 |   /*
 98 |    * Sets the main frequency.
 99 |    *
100 |    * freq Frequency in Hertz.
101 |    * dmaBuffers Use only to provide custom DMA buffers.
102 |    *
103 |    * Example:
104 |    *
105 |    *     // Set 25MHz as main frequency
106 |    *     GPIOStream.play(25000000);
107 |    */
108 |   void play(int freq, lldesc_t volatile * dmaBuffers = nullptr);
109 | 
110 |   /*
111 |    * Disables all outputs.
112 |    */
113 |   void stop();
114 | 
115 | private:
116 | 
117 |   void setupClock(int freq);
118 |   static void setupGPIO(gpio_num_t gpio, int bit, gpio_mode_t mode);
119 | 
120 |   bool                m_DMAStarted;
121 |   volatile lldesc_t * m_DMABuffer;
122 |   volatile uint8_t *  m_DMAData;
123 | };
124 | 
125 | 
126 | 
127 | 
128 | 
129 | } // end of namespace
130 | 
131 | 
132 | 
133 | 
134 | 
135 | 
136 | 
137 | 
138 | 
139 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/dispdrivers/TFTControllerSpecif.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
 3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
 4 |   All rights reserved.
 5 | 
 6 |   This file is part of FabGL Library.
 7 | 
 8 |   FabGL is free software: you can redistribute it and/or modify
 9 |   it under the terms of the GNU General Public License as published by
10 |   the Free Software Foundation, either version 3 of the License, or
11 |   (at your option) any later version.
12 | 
13 |   FabGL is distributed in the hope that it will be useful,
14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 |   GNU General Public License for more details.
17 | 
18 |   You should have received a copy of the GNU General Public License
19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
20 |  */
21 | 
22 | 
23 | #pragma once
24 | 
25 | 
26 | 
27 | /**
28 |  * @file
29 |  *
30 |  * @brief This file contains TFT controllers definitions.
31 |  */
32 | 
33 | 
34 | #include <stdint.h>
35 | #include <stddef.h>
36 | 
37 | #include "fabglconf.h"
38 | #include "fabutils.h"
39 | #include "TFTControllerGeneric.h"
40 | 
41 | 
42 | 
43 | 
44 | namespace fabgl {
45 | 
46 | 
47 | 
48 | class ST7789Controller : public TFTController {
49 | protected:
50 |   void softReset();
51 | };
52 | 
53 | 
54 | class ILI9341Controller : public TFTController {
55 | protected:
56 |   void softReset();
57 | };
58 | 
59 | 
60 | 
61 | 
62 | 
63 | 
64 | 
65 | } // end of namespace
66 | 
67 | 
68 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/fabfonts.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |  Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |  All rights reserved.
  5 | 
  6 |  This file is part of FabGL Library.
  7 | 
  8 |  FabGL is free software: you can redistribute it and/or modify
  9 |  it under the terms of the GNU General Public License as published by
 10 |  the Free Software Foundation, either version 3 of the License, or
 11 |  (at your option) any later version.
 12 | 
 13 |  FabGL is distributed in the hope that it will be useful,
 14 |  but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |  GNU General Public License for more details.
 17 | 
 18 |  You should have received a copy of the GNU General Public License
 19 |  along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 | */
 21 | 
 22 | 
 23 | 
 24 | #define FABGL_FONT_INCLUDE_DEFINITION
 25 | 
 26 | #include "fabfonts.h"
 27 | 
 28 | 
 29 | 
 30 | namespace fabgl {
 31 | 
 32 | 
 33 | // do not include all fonts in "font" folder to avoid waste of flash
 34 | // for apps that uses getPresetFontInfo() (used in Terminal class), getPresetFontInfoFromHeight()
 35 | // and getPresetFixedFont().
 36 | static const FontInfo * FIXED_WIDTH_EMBEDDED_FONTS[] = {
 37 |   // please, bigger fonts first!
 38 |   &FONT_8x14,
 39 |   &FONT_8x8,
 40 |   &FONT_8x9,
 41 |   &FONT_6x8,
 42 |   &FONT_5x7,
 43 |   &FONT_4x6,
 44 | };
 45 | 
 46 | 
 47 | static const FontInfo * VAR_WIDTH_EMBEDDED_FONTS[] = {
 48 |   // please, bigger fonts first!
 49 |   &FONT_std_24,
 50 |   &FONT_std_22,
 51 |   &FONT_std_18,
 52 |   &FONT_std_17,
 53 |   &FONT_std_16,
 54 |   &FONT_std_15,
 55 |   &FONT_std_14,
 56 |   &FONT_std_12,
 57 | };
 58 | 
 59 | 
 60 | 
 61 | FontInfo const * getFixedWidthFont(int index)
 62 | {
 63 |   return FIXED_WIDTH_EMBEDDED_FONTS[index];
 64 | }
 65 | 
 66 | 
 67 | int getFixedWidthFontCount()
 68 | {
 69 |   return sizeof(FIXED_WIDTH_EMBEDDED_FONTS) / sizeof(FontInfo*);
 70 | }
 71 | 
 72 | 
 73 | FontInfo const * getVarWidthFont(int index)
 74 | {
 75 |   return VAR_WIDTH_EMBEDDED_FONTS[index];
 76 | }
 77 | 
 78 | 
 79 | int getVarWidthFontCount()
 80 | {
 81 |   return sizeof(VAR_WIDTH_EMBEDDED_FONTS) / sizeof(FontInfo*);
 82 | }
 83 | 
 84 | 
 85 | FontInfo const * getPresetFontInfo(int viewPortWidth, int viewPortHeight, int columns, int rows)
 86 | {
 87 |   FontInfo const * fontInfo = nullptr;
 88 |   for (int i = 0; i < getFixedWidthFontCount(); ++i) {
 89 |     fontInfo = getFixedWidthFont(i);
 90 |     if (viewPortWidth / fontInfo->width >= columns && viewPortHeight / fontInfo->height >= rows)
 91 |       return fontInfo;
 92 |   }
 93 |   // not found, return the smallest
 94 |   return fontInfo;
 95 | }
 96 | 
 97 | 
 98 | FontInfo const * getPresetFontInfoFromHeight(int height, bool fixedWidth)
 99 | {
100 |   FontInfo const * fontInfo = nullptr;
101 |   if (fixedWidth) {
102 |     for (int i = 0; i < getFixedWidthFontCount(); ++i) {
103 |       fontInfo = getFixedWidthFont(i);
104 |       if (height >= fontInfo->height)
105 |         return fontInfo;
106 |     }
107 |   } else {
108 |     for (int i = 0; i < getVarWidthFontCount(); ++i) {
109 |       fontInfo = getVarWidthFont(i);
110 |       if (height >= fontInfo->height)
111 |         return fontInfo;
112 |     }
113 |   }
114 |   // not found, return the smallest
115 |   return fontInfo;
116 | }
117 | 
118 | 
119 | FontInfo const * getPresetFixedFont(int width, int height)
120 | {
121 |   FontInfo const * fontInfo = nullptr;
122 |   for (int i = 0; i < getFixedWidthFontCount(); ++i) {
123 |     fontInfo = getFixedWidthFont(i);
124 |     if (height == fontInfo->height && width == fontInfo->width)
125 |       return fontInfo;
126 |   }
127 |   // not found, return the smallest (TODO: find a way to get meaningful result)
128 |   return fontInfo;
129 | }
130 | 
131 | 
132 | 
133 | }
134 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/fabfonts.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |   All rights reserved.
  5 | 
  6 |   This file is part of FabGL Library.
  7 | 
  8 |   FabGL is free software: you can redistribute it and/or modify
  9 |   it under the terms of the GNU General Public License as published by
 10 |   the Free Software Foundation, either version 3 of the License, or
 11 |   (at your option) any later version.
 12 | 
 13 |   FabGL is distributed in the hope that it will be useful,
 14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |   GNU General Public License for more details.
 17 | 
 18 |   You should have received a copy of the GNU General Public License
 19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 |  */
 21 | 
 22 | 
 23 | 
 24 | #pragma once
 25 | 
 26 | 
 27 | #include "fabutils.h"
 28 | #include "fabglconf.h"
 29 | 
 30 | 
 31 | // Embedded fonts
 32 | 
 33 | // fixed width
 34 | #include "fonts/font_4x6.h"
 35 | #include "fonts/font_5x7.h"
 36 | #include "fonts/font_5x8.h"
 37 | #include "fonts/font_6x8.h"
 38 | #include "fonts/font_6x9.h"
 39 | #include "fonts/font_6x10.h"
 40 | #include "fonts/font_6x12.h"
 41 | #include "fonts/font_6x13.h"
 42 | #include "fonts/font_7x13.h"
 43 | #include "fonts/font_7x14.h"
 44 | #include "fonts/font_8x13.h"
 45 | #include "fonts/font_8x8.h"
 46 | #include "fonts/font_8x9.h"
 47 | #include "fonts/font_8x14.h"
 48 | #include "fonts/font_9x15.h"
 49 | #include "fonts/font_9x18.h"
 50 | #include "fonts/font_10x20.h"
 51 | 
 52 | // variable width
 53 | #include "fonts/font_std_12.h"
 54 | #include "fonts/font_std_14.h"
 55 | #include "fonts/font_std_15.h"
 56 | #include "fonts/font_std_16.h"
 57 | #include "fonts/font_std_17.h"
 58 | #include "fonts/font_std_18.h"
 59 | #include "fonts/font_std_22.h"
 60 | #include "fonts/font_std_24.h"
 61 | 
 62 | 
 63 | namespace fabgl {
 64 | 
 65 | 
 66 | 
 67 | /**
 68 |  * @brief Gets the font info that best fits the specified number of columns and rows.
 69 |  *
 70 |  * This method returns only fixed width fonts.
 71 |  *
 72 |  * @param viewPortWidth Viewport width where to fit specified columns
 73 |  * @param viewPortHeight Viewport height where to fit specified rows
 74 |  * @param columns Minimum number of required columns.
 75 |  * @param rows Minimum number of required rows.
 76 |  *
 77 |  * @return The font info found.
 78 |  */
 79 | FontInfo const * getPresetFontInfo(int viewPortWidth, int viewPortHeight, int columns, int rows);
 80 | 
 81 | 
 82 | /**
 83 |  * @brief Gets the font info that best fits the specified height.
 84 |  *
 85 |  * @param height Required font height in pixels.
 86 |  * @param fixedWidth If True returns only fixed width fonts, if False returns only variable width fonts.
 87 |  *
 88 |  * @return The font info found.
 89 |  */
 90 | FontInfo const * getPresetFontInfoFromHeight(int height, bool fixedWidth);
 91 | 
 92 | 
 93 | /**
 94 |  * @brief Gets the fixed width font info with the specified sizes
 95 |  *
 96 |  * @param width Font width
 97 |  * @param height Font height
 98 |  *
 99 |  * @return The font info found.
100 |  */
101 | FontInfo const * getPresetFixedFont(int width, int height);
102 | 
103 | 
104 | };
105 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/images/bitmaps.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #pragma once
 3 | 
 4 | 
 5 | 
 6 | namespace fabgl {
 7 | 
 8 | 
 9 | const uint8_t infoBitmap_data[] = {
10 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
11 |   0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00, 0x00, 0x00,
12 |   0x00, 0x00, 0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00, 0x00,
13 |   0x00, 0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00,
14 |   0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00,
15 |   0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00,
16 |   0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00,
17 |   0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00,
18 |   0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00,
19 |   0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00,
20 |   0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00,
21 |   0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00,
22 |   0x00, 0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00,
23 |   0x00, 0x00, 0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00, 0x00,
24 |   0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00, 0x00, 0x00,
25 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
26 | };
27 | const Bitmap infoBitmap = Bitmap(16, 16, &infoBitmap_data[0], PixelFormat::RGBA2222);
28 | 
29 | 
30 | 
31 | const uint8_t errorBitmap_data[] = {
32 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
33 |   0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00, 0x00,
34 |   0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00,
35 |   0x00, 0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00, 0x00, 0x00,
36 |   0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc0, 0xc0, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00, 0x00,
37 |   0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc0, 0xc0, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00,
38 |   0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc0, 0xc0, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00,
39 |   0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc0, 0xc0, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00,
40 |   0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc0, 0xc0, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00,
41 |   0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc0, 0xc0, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00,
42 |   0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00,
43 |   0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc0, 0xc0, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00, 0x00,
44 |   0x00, 0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc0, 0xc0, 0xc3, 0xc3, 0xc3, 0xc3, 0x00, 0x00, 0x00,
45 |   0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00,
46 |   0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00, 0x00,
47 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
48 | };
49 | const Bitmap errorBitmap = Bitmap(16, 16, &errorBitmap_data[0], PixelFormat::RGBA2222);
50 | 
51 | 
52 | 
53 | const uint8_t questionBitmap_data[] = {
54 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
55 |   0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00, 0x00, 0x00,
56 |   0x00, 0x00, 0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00, 0x00,
57 |   0x00, 0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00,
58 |   0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0x00, 0x00,
59 |   0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0x00,
60 |   0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0x00,
61 |   0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00,
62 |   0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00,
63 |   0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00,
64 |   0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00,
65 |   0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00,
66 |   0x00, 0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xff, 0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00,
67 |   0x00, 0x00, 0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00, 0x00,
68 |   0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00, 0x00, 0x00,
69 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
70 | };
71 | const Bitmap questionBitmap = Bitmap(16, 16, &questionBitmap_data[0], PixelFormat::RGBA2222);
72 | 
73 | 
74 | 
75 | const uint8_t warnBitmap_data[] = {
76 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
77 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
78 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
79 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xcf, 0xcf, 0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
80 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xcf, 0xcf, 0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
81 |   0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xcf, 0xc0, 0xc0, 0xcf, 0xcf, 0x00, 0x00, 0x00, 0x00, 0x00,
82 |   0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xcf, 0xc0, 0xc0, 0xcf, 0xcf, 0x00, 0x00, 0x00, 0x00, 0x00,
83 |   0x00, 0x00, 0x00, 0x00, 0xcf, 0xcf, 0xcf, 0xc0, 0xc0, 0xcf, 0xcf, 0xcf, 0x00, 0x00, 0x00, 0x00,
84 |   0x00, 0x00, 0x00, 0x00, 0xcf, 0xcf, 0xcf, 0xc0, 0xc0, 0xcf, 0xcf, 0xcf, 0x00, 0x00, 0x00, 0x00,
85 |   0x00, 0x00, 0x00, 0xcf, 0xcf, 0xcf, 0xcf, 0xc0, 0xc0, 0xcf, 0xcf, 0xcf, 0xcf, 0x00, 0x00, 0x00,
86 |   0x00, 0x00, 0x00, 0xcf, 0xcf, 0xcf, 0xcf, 0xc0, 0xc0, 0xcf, 0xcf, 0xcf, 0xcf, 0x00, 0x00, 0x00,
87 |   0x00, 0x00, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0x00, 0x00,
88 |   0x00, 0x00, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xc0, 0xc0, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0x00, 0x00,
89 |   0x00, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xc0, 0xc0, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0x00,
90 |   0x00, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0x00,
91 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
92 | };
93 | const Bitmap warnBitmap = Bitmap(16, 16, &warnBitmap_data[0], PixelFormat::RGBA2222);
94 | 
95 | 
96 | 
97 | }
98 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/network/ICMP.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |   All rights reserved.
  5 | 
  6 |   This file is part of FabGL Library.
  7 | 
  8 |   FabGL is free software: you can redistribute it and/or modify
  9 |   it under the terms of the GNU General Public License as published by
 10 |   the Free Software Foundation, either version 3 of the License, or
 11 |   (at your option) any later version.
 12 | 
 13 |   FabGL is distributed in the hope that it will be useful,
 14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |   GNU General Public License for more details.
 17 | 
 18 |   You should have received a copy of the GNU General Public License
 19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 |  */
 21 | 
 22 | 
 23 | #include "ICMP.h"
 24 | 
 25 | #include "Arduino.h"
 26 | #include "WiFiGeneric.h"
 27 | 
 28 | 
 29 | namespace fabgl {
 30 | 
 31 | 
 32 | ICMP::ICMP()
 33 |   : m_queue(xQueueCreate(1, sizeof(uint8_t))), m_waitingID(rand() & 0xFFFF), m_waitingSeq(-1)
 34 | {
 35 | }
 36 | 
 37 | 
 38 | ICMP::~ICMP()
 39 | {
 40 |   vQueueDelete(m_queue);
 41 | }
 42 | 
 43 | 
 44 | // -1 = timeout
 45 | // -2 = cannot resolve name
 46 | int ICMP::ping(char const * host)
 47 | {
 48 |   IPAddress hostIP((uint32_t)0);
 49 |   if (!WiFiGenericClass::hostByName(host, hostIP))
 50 |     return -2;
 51 |   return ping(hostIP);
 52 | }
 53 | 
 54 | 
 55 | // -1 = timeout
 56 | int ICMP::ping(IPAddress const &dest)
 57 | {
 58 |   static int32_t const TIMEOUT        = 1000;
 59 |   static int32_t const TIMEOUT_RESULT = -1;
 60 | 
 61 |   m_destIP = dest;
 62 | 
 63 |   int result = TIMEOUT_RESULT;
 64 | 
 65 |   // generate seq
 66 |   ++m_waitingSeq;
 67 | 
 68 |   // prepare packet to send
 69 |   pbuf * hdrbuf = pbuf_alloc(PBUF_IP, sizeof(icmp_echo_hdr), PBUF_RAM);
 70 |   icmp_echo_hdr * hdr = (icmp_echo_hdr *) hdrbuf->payload;
 71 |   hdr->type   = ICMP_ECHO;
 72 |   hdr->code   = 0;
 73 |   hdr->chksum = 0;
 74 |   hdr->id     = htons(m_waitingID);
 75 |   hdr->seqno  = htons(m_waitingSeq);
 76 |   hdr->chksum = inet_chksum((uint16_t *) hdr, sizeof(icmp_echo_hdr));
 77 | 
 78 |   // send Echo request
 79 |   raw_pcb * pcb = raw_new(IP_PROTO_ICMP);
 80 |   raw_recv(pcb, ICMP::raw_recv_fn, this);
 81 |   raw_bind(pcb, IP_ADDR_ANY);
 82 | 
 83 |   ip_addr_t addr;
 84 |   addr.type = IPADDR_TYPE_V4;
 85 |   addr.u_addr.ip4.addr = dest;
 86 |   raw_sendto(pcb, hdrbuf, &addr);
 87 |   pbuf_free(hdrbuf);
 88 | 
 89 |   result = -1;
 90 |   int32_t t1 = micros();
 91 |   uint8_t c;
 92 |   if (xQueueReceive(m_queue, &c, pdMS_TO_TICKS(TIMEOUT)))
 93 |     result = micros() - t1;
 94 |   raw_remove(pcb);
 95 | 
 96 |   return result;
 97 | }
 98 | 
 99 | 
100 | uint8_t ICMP::raw_recv_fn(void * arg, raw_pcb * pcb, pbuf * p, const ip_addr_t * addr)
101 | {
102 |   ICMP * this_ = (ICMP *)arg;
103 | 
104 |   ip_hdr * iphdr = (ip_hdr *)p->payload;
105 | 
106 |   int ttl = IPH_TTL(iphdr);
107 | 
108 |   if (p->tot_len >= sizeof(ip_hdr) + sizeof(icmp_echo_hdr) && pbuf_header(p, -(s16_t)sizeof(ip_hdr)) == 0) {
109 |     icmp_echo_hdr * hdr = (icmp_echo_hdr *) p->payload;
110 |     if (ntohs(hdr->id) == this_->m_waitingID && ntohs(hdr->seqno) == this_->m_waitingSeq) {
111 |       this_->m_receivedBytes = p->tot_len;
112 |       this_->m_receivedTTL = ttl;
113 |       uint8_t c = 0;
114 |       xQueueSendToBack(this_->m_queue, &c, portMAX_DELAY);
115 |     }
116 |     pbuf_free(p);
117 |     return 1;
118 |   }
119 | 
120 |   return 0;
121 | }
122 | 
123 | 
124 | 
125 | }
126 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/network/ICMP.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |   All rights reserved.
  5 | 
  6 |   This file is part of FabGL Library.
  7 | 
  8 |   FabGL is free software: you can redistribute it and/or modify
  9 |   it under the terms of the GNU General Public License as published by
 10 |   the Free Software Foundation, either version 3 of the License, or
 11 |   (at your option) any later version.
 12 | 
 13 |   FabGL is distributed in the hope that it will be useful,
 14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |   GNU General Public License for more details.
 17 | 
 18 |   You should have received a copy of the GNU General Public License
 19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 |  */
 21 | 
 22 | 
 23 | #pragma once
 24 | 
 25 | 
 26 | /**
 27 |  * @file
 28 |  *
 29 |  * @brief This file contains ICMP (ping) class
 30 |  */
 31 | 
 32 | 
 33 | 
 34 | #include "Client.h"
 35 | 
 36 | #include "freertos/FreeRTOS.h"
 37 | 
 38 | #include "lwip/netdb.h"
 39 | #include "lwip/raw.h"
 40 | #include "lwip/icmp.h"
 41 | #include "lwip/inet_chksum.h"
 42 | 
 43 | 
 44 | #include "fabglconf.h"
 45 | #include "fabutils.h"
 46 | 
 47 | 
 48 | 
 49 | namespace fabgl {
 50 | 
 51 | 
 52 | 
 53 | /**
 54 |  * @brief ICMP Implementation
 55 |  *
 56 |  * Used to ping a network device using its IP or its host name.
 57 |  *
 58 |  * Example:
 59 |  *
 60 |  *     fabgl::ICMP icmp;
 61 |  *     while (true) {
 62 |  *
 63 |  *       // CTRL-C ?
 64 |  *       if (Terminal.available() && Terminal.read() == 0x03)
 65 |  *         break;
 66 |  *
 67 |  *       int t = icmp.ping("www.fabgl.com");
 68 |  *       if (t >= 0) {
 69 |  *         Terminal.printf("%d bytes from %s: icmp_seq=%d ttl=%d time=%.3f ms\r\n", icmp.receivedBytes(), icmp.hostIP().toString().c_str(), icmp.receivedSeq(), icmp.receivedTTL(), (double)t/1000.0);
 70 |  *         delay(1000);
 71 |  *       } else if (t == -2) {
 72 |  *         Terminal.printf("Cannot resolve %s: Unknown host\r\n", host);
 73 |  *         break;
 74 |  *       } else {
 75 |  *         Terminal.printf("Request timeout for icmp_seq %d\r\n", icmp.receivedSeq());
 76 |  *       }
 77 |  *
 78 |  *     }
 79 |  *
 80 |  */
 81 |  class ICMP {
 82 | 
 83 | public:
 84 | 
 85 |   ICMP();
 86 |   ~ICMP();
 87 | 
 88 |   // send Echo Request and wait for Echo Reply
 89 |   // returns "measured" echo time in microseconds. ret -1 on timeout or error
 90 |   int ping(IPAddress const &dest);
 91 |   int ping(char const * host);  // host can be IP or host name
 92 | 
 93 |   int receivedBytes() { return m_receivedBytes; }
 94 | 
 95 |   int receivedTTL() { return m_receivedTTL; }
 96 | 
 97 |   int receivedSeq() { return m_waitingSeq; }
 98 | 
 99 |   IPAddress const& hostIP() { return m_destIP; }
100 | 
101 | private:
102 | 
103 |   static uint8_t raw_recv_fn(void * arg, raw_pcb * pcb, pbuf * p, const ip_addr_t * addr);
104 | 
105 |   IPAddress     m_destIP;
106 |   QueueHandle_t m_queue;
107 |   int           m_waitingID;
108 |   int           m_waitingSeq;
109 |   int           m_receivedBytes;
110 |   int           m_receivedTTL;
111 | };
112 | 
113 | 
114 | 
115 | 
116 | }
117 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/scene.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |   All rights reserved.
  5 | 
  6 |   This file is part of FabGL Library.
  7 | 
  8 |   FabGL is free software: you can redistribute it and/or modify
  9 |   it under the terms of the GNU General Public License as published by
 10 |   the Free Software Foundation, either version 3 of the License, or
 11 |   (at your option) any later version.
 12 | 
 13 |   FabGL is distributed in the hope that it will be useful,
 14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |   GNU General Public License for more details.
 17 | 
 18 |   You should have received a copy of the GNU General Public License
 19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 |  */
 21 | 
 22 | 
 23 | #include "freertos/FreeRTOS.h"
 24 | #include "freertos/task.h"
 25 | #include "freertos/semphr.h"
 26 | 
 27 | #include "fabutils.h"
 28 | #include "scene.h"
 29 | 
 30 | 
 31 | 
 32 | 
 33 | 
 34 | 
 35 | namespace fabgl {
 36 | 
 37 | 
 38 | Scene::Scene(int maxSpritesCount, int updateTimeMS, int width, int height, int stackSize)
 39 |  : m_width(width),
 40 |    m_height(height),
 41 |    m_updateTimeMS(updateTimeMS),
 42 |    m_collisionDetector(maxSpritesCount, width, height),
 43 |    m_suspendedTask(nullptr),
 44 |    m_running(false)
 45 | {
 46 |   m_mutex = xSemaphoreCreateMutex();
 47 |   xSemaphoreTake(m_mutex, portMAX_DELAY);  // suspend update task
 48 |   xTaskCreate(updateTask, "", FABGL_DEFAULT_SCENETASK_STACKSIZE, this, 5, &m_updateTaskHandle);
 49 | }
 50 | 
 51 | 
 52 | Scene::~Scene()
 53 | {
 54 |   stop();
 55 |   xSemaphoreTake(m_mutex, portMAX_DELAY); // suspend update task
 56 |   vTaskDelete(m_updateTaskHandle);
 57 |   vSemaphoreDelete(m_mutex);
 58 | }
 59 | 
 60 | 
 61 | void Scene::start(bool suspendTask)
 62 | {
 63 |   if (!m_running) {
 64 |     m_running = true;
 65 |     m_updateCount = 0;
 66 |     init();
 67 |     xSemaphoreGive(m_mutex);  // resume update task
 68 |     if (suspendTask) {
 69 |       m_suspendedTask = xTaskGetCurrentTaskHandle();
 70 |       vTaskSuspend(m_suspendedTask);
 71 |     } else
 72 |       m_suspendedTask = nullptr;
 73 |   }
 74 | }
 75 | 
 76 | 
 77 | void Scene::stop()
 78 | {
 79 |   if (m_running) {
 80 |     // are we inside update task?
 81 |     if (xTaskGetCurrentTaskHandle() != m_updateTaskHandle)
 82 |       xSemaphoreTake(m_mutex, portMAX_DELAY); // no, suspend update task
 83 |     m_running = false;
 84 |     if (m_suspendedTask)
 85 |       vTaskResume(m_suspendedTask);
 86 |   }
 87 | }
 88 | 
 89 | 
 90 | void Scene::updateTask(void * pvParameters)
 91 | {
 92 |   Scene * scene = (Scene*) pvParameters;
 93 | 
 94 |   while (true) {
 95 | 
 96 |     xSemaphoreTake(scene->m_mutex, portMAX_DELAY);
 97 | 
 98 |     int64_t t0 = esp_timer_get_time();  // us
 99 | 
100 |     if (scene->m_running) {
101 |       scene->m_updateCount += 1;
102 |       scene->update(scene->m_updateCount);
103 |     }
104 | 
105 |     xSemaphoreGive(scene->m_mutex);
106 | 
107 |     int64_t t1 = esp_timer_get_time();  // us
108 |     int delayMS = (scene->m_updateTimeMS - (t1 - t0) / 1000);
109 |     if (delayMS > 0)
110 |       vTaskDelay(delayMS / portTICK_PERIOD_MS);
111 |   }
112 | }
113 | 
114 | 
115 | void collisionDetectionCallback(void * callbackObj, Sprite * spriteA, Sprite * spriteB, Point collisionPoint)
116 | {
117 |   ((Scene*)callbackObj)->collisionDetected(spriteA, spriteB, collisionPoint);
118 | }
119 | 
120 | 
121 | void Scene::updateSpriteAndDetectCollisions(Sprite * sprite)
122 | {
123 |   m_collisionDetector.updateAndDetectCollision(sprite, collisionDetectionCallback, this);
124 | }
125 | 
126 | 
127 | 
128 | 
129 | } // end of namespace
130 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/scene.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |   All rights reserved.
  5 | 
  6 |   This file is part of FabGL Library.
  7 | 
  8 |   FabGL is free software: you can redistribute it and/or modify
  9 |   it under the terms of the GNU General Public License as published by
 10 |   the Free Software Foundation, either version 3 of the License, or
 11 |   (at your option) any later version.
 12 | 
 13 |   FabGL is distributed in the hope that it will be useful,
 14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |   GNU General Public License for more details.
 17 | 
 18 |   You should have received a copy of the GNU General Public License
 19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 |  */
 21 | 
 22 | 
 23 | #pragma once
 24 | 
 25 | 
 26 | 
 27 | /**
 28 |  * @file
 29 |  *
 30 |  * @brief This file contains fabgl::Scene definition.
 31 |  */
 32 | 
 33 | 
 34 | #include "freertos/FreeRTOS.h"
 35 | 
 36 | #include "fabglconf.h"
 37 | #include "collisiondetector.h"
 38 | 
 39 | 
 40 | 
 41 | #define FABGL_DEFAULT_SCENETASK_STACKSIZE 2048
 42 | 
 43 | 
 44 | namespace fabgl {
 45 | 
 46 | 
 47 | 
 48 | /**
 49 |  * @brief Scene is an abstract class useful to encapsulate functionalities of a scene (sprites, collision detector and updates).
 50 |  */
 51 | class Scene {
 52 | 
 53 | public:
 54 | 
 55 |   /**
 56 |    * @brief The Scene constructor.
 57 |    *
 58 |    * @param maxSpritesCount Specifies maximum number of sprites. This is required to size the collision detector object.
 59 |    * @param updateTimeMS Number of milliseconds between updates. Scene.update() is called whenever an update occurs.
 60 |    * @param width The scene width in pixels.
 61 |    * @param height The scene height in pixels.
 62 |    * @param stackSize Size of update task stack.
 63 |    */
 64 |   Scene(int maxSpritesCount, int updateTimeMS, int width, int height, int stackSize = FABGL_DEFAULT_SCENETASK_STACKSIZE);
 65 | 
 66 |   virtual ~Scene();
 67 | 
 68 |   /**
 69 |    * @brief Determines scene width.
 70 |    *
 71 |    * @return Scene width in pixels.
 72 |    */
 73 |   int getWidth()  { return m_width; }
 74 | 
 75 |   /**
 76 |    * @brief Determines scene height.
 77 |    *
 78 |    * @return Scene height in pixels.
 79 |    */
 80 |   int getHeight() { return m_height; }
 81 | 
 82 |   /**
 83 |    * @brief Starts scene updates and suspends current task.
 84 |    *
 85 |    * @param suspendTask If true (default) current calling task is suspended immeditaly.
 86 |    *
 87 |    * Example:
 88 |    *
 89 |    *     void loop()
 90 |    *     {
 91 |    *       GameScene gameScene;
 92 |    *       gameScene.start();
 93 |    *     }
 94 |    */
 95 |   void start(bool suspendTask = true);
 96 | 
 97 |   /**
 98 |    * @brief Stops scene updates and resumes suspended task.
 99 |    */
100 |   void stop();
101 | 
102 |   /**
103 |    * @brief This is an abstract method called when the scene needs to be initialized.
104 |    */
105 |   virtual void init() = 0;
106 | 
107 |   /**
108 |    * @brief This is an abstract method called whenever the scene needs to be updated.
109 |    *
110 |    * @param updateCount Indicates number of times Scane.update() has been called.
111 |    */
112 |   virtual void update(int updateCount) = 0;
113 | 
114 |   /**
115 |    * @brief This is an abstract method called whenever a collision has been detected.
116 |    *
117 |    * This method is called one o more times as a result of calling Scene.updateSpriteAndDetectCollisions() method when
118 |    * one o more collisions has been detected.
119 |    *
120 |    * @param spriteA One of the two sprites collided. This is the same sprite specified in Scene.updateSpriteAndDetectCollisions() call.
121 |    * @param spriteB One of the two sprites collided.
122 |    * @param collisionPoint Coordinates of a collision point.
123 |    */
124 |   virtual void collisionDetected(Sprite * spriteA, Sprite * spriteB, Point collisionPoint) = 0;
125 | 
126 |   /**
127 |    * @brief Adds the specified sprite to collision detector.
128 |    *
129 |    * The collision detector is updated calling Scene.updateSprite() or updateSpriteAndDetectCollisions().<br>
130 |    * The number of sprites cannot exceed the value specified in Scene constructor.
131 |    *
132 |    * @param sprite The sprite to add.
133 |    */
134 |   void addSprite(Sprite * sprite)    { m_collisionDetector.addSprite(sprite); }
135 | 
136 |   /**
137 |    * @brief Removes the specified sprite from collision detector.
138 |    *
139 |    * @param sprite The sprite to remove.
140 |    */
141 |   void removeSprite(Sprite * sprite) { m_collisionDetector.removeSprite(sprite); }
142 | 
143 |   /**
144 |    * @brief Updates collision detector.
145 |    *
146 |    * When a sprite changes its position or size it is necessary to update the collision detector.<br>
147 |    * This method just updates the detector without generate collision events.<br>
148 |    * To generate collision events call Scene.updateSpriteAndDetectCollisions instead.
149 |    *
150 |    * @param sprite The sprite to update.
151 |    */
152 |   void updateSprite(Sprite * sprite) { m_collisionDetector.update(sprite); }
153 | 
154 |   /**
155 |    * @brief Updates collision detector and generate collision events.
156 |    *
157 |    * When a sprite changes its position or size it is necessary to update the collision detector.<br>
158 |    * This method updates the detector and generates collision events accordly.
159 |    *
160 |    * @param sprite The sprite to update and to check for collisions.
161 |    */
162 |   void updateSpriteAndDetectCollisions(Sprite * sprite);
163 | 
164 | private:
165 | 
166 |   static void updateTask(void * pvParameters);
167 | 
168 | 
169 |   int               m_width;
170 |   int               m_height;
171 | 
172 |   TaskHandle_t      m_updateTaskHandle;
173 |   int               m_updateCount;
174 |   int               m_updateTimeMS;
175 |   SemaphoreHandle_t m_mutex;
176 | 
177 |   CollisionDetector m_collisionDetector;
178 | 
179 |   TaskHandle_t      m_suspendedTask;
180 | 
181 |   volatile bool     m_running;
182 | 
183 | };
184 | 
185 | 
186 | 
187 | 
188 | 
189 | } // end of namespace
190 | 
191 | 
192 | 
193 | 
194 | 
195 | 
196 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/terminfo.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  3 |   Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  4 |   All rights reserved.
  5 | 
  6 |   This file is part of FabGL Library.
  7 | 
  8 |   FabGL is free software: you can redistribute it and/or modify
  9 |   it under the terms of the GNU General Public License as published by
 10 |   the Free Software Foundation, either version 3 of the License, or
 11 |   (at your option) any later version.
 12 | 
 13 |   FabGL is distributed in the hope that it will be useful,
 14 |   but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 |   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 |   GNU General Public License for more details.
 17 | 
 18 |   You should have received a copy of the GNU General Public License
 19 |   along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 20 |  */
 21 | 
 22 |  
 23 | #pragma once
 24 | 
 25 | 
 26 | /**
 27 |  * @file
 28 |  *
 29 |  * @brief This file contains terminal emulation definitions.
 30 |  */
 31 | 
 32 | 
 33 | #include "devdrivers/keyboard.h"
 34 | 
 35 | 
 36 | namespace fabgl {
 37 | 
 38 | 
 39 | 
 40 | 
 41 | constexpr int EmuTerminalMaxChars = 8;
 42 | 
 43 | 
 44 | enum class ConvCtrl {
 45 |   END,
 46 |   CarriageReturn,
 47 |   LineFeed,
 48 |   CursorLeft,
 49 |   CursorUp,
 50 |   CursorRight,
 51 |   EraseToEndOfScreen,
 52 |   EraseToEndOfLine,
 53 |   CursorHome,
 54 |   AttrNormal,
 55 |   AttrBlank,
 56 |   AttrBlink,
 57 |   AttrBlinkOff,
 58 |   AttrReverse,
 59 |   AttrReverseOff,
 60 |   AttrUnderline,
 61 |   AttrUnderlineOff,
 62 |   AttrReduce,
 63 |   AttrReduceOff,
 64 |   CursorPos,
 65 |   CursorPos2,
 66 |   InsertLine,
 67 |   InsertChar,
 68 |   DeleteLine,
 69 |   DeleteCharacter,
 70 |   CursorOn,
 71 |   CursorOff,
 72 |   SaveCursor,
 73 |   RestoreCursor,
 74 | };
 75 | 
 76 | 
 77 | // converts from emulated terminal video control code to ANSI/VT control codes
 78 | struct TermInfoVideoConv {
 79 |   const char * termSeq;        // input terminal control code to match. 0xFF matches any char
 80 |   int          termSeqLen;     // length of termSeq string
 81 |   ConvCtrl     convCtrl[5];    // output video action (will be converted to ANSI control code). Last ctrl must be ConvCtrl::End
 82 | };
 83 | 
 84 | 
 85 | // converts from emulated terminal keyboard virtual key to ANSI/VT control codes
 86 | struct TermInfoKbdConv {
 87 |   VirtualKey   vk;             // input virtual key
 88 |   const char * ANSICtrlCode;   // output ANSI control code
 89 | };
 90 | 
 91 | 
 92 | struct TermInfo {
 93 |   char const *              initString;
 94 |   TermInfoVideoConv const * videoCtrlSet;
 95 |   TermInfoKbdConv const *   kbdCtrlSet;
 96 | };
 97 | 
 98 | 
 99 | 
100 | /** \ingroup Enumerations
101 |  * @brief This enum defines supported terminals
102 |  */
103 | enum TermType {
104 |   ANSI_VT,        /**< Native ANSI/VT terminal */
105 |   ADM3A,          /**< Emulated Lear Siegler ADM-3A terminal */
106 |   ADM31,          /**< Emulated Lear Siegler ADM-31 terminal */
107 |   Hazeltine1500,  /**< Emulated Hazeltine 1500 terminal */
108 |   Osborne,        /**< Emulated Osborne I */
109 |   Kaypro,         /**< Emulated Kaypro */
110 |   VT52,           /**< Emulated VT52 terminal */
111 |   ANSILegacy      /**< Legacy ANSI emulation */
112 | };
113 | 
114 | 
115 | struct SupportedTerminals {
116 |   static int count()            { return (int)ANSILegacy - (int)ANSI_VT + 1; }
117 |   static char const * * names() {
118 |     static char const * TERMS[] = { "ANSI",  "ADM 3A", "ADM 31", "Hazeltine 1500", "Osborne", "Kaypro", "VT52", "ANSI Legacy" };
119 |     return TERMS;
120 |   }
121 |   static TermType * types() {
122 |     static TermType TYPES[]     = { ANSI_VT, ADM3A,    ADM31,    Hazeltine1500,    Osborne,   Kaypro,   VT52,   ANSILegacy };
123 |     return TYPES;
124 |   }
125 | };
126 | 
127 | 
128 | 
129 | // Lear Siegler ADM-3A
130 | extern const TermInfo term_ADM3A;
131 | 
132 | // Lear Siegler ADM-31
133 | extern const TermInfo term_ADM31;
134 | 
135 | // Hazeltine 1500
136 | extern const TermInfo term_Hazeltine1500;
137 | 
138 | // Osborne I
139 | extern const TermInfo term_Osborne;
140 | 
141 | // Kaypro
142 | extern const TermInfo term_Kaypro;
143 | 
144 | // VT52
145 | extern const TermInfo term_VT52;
146 | 
147 | // ANSI Legacy
148 | extern const TermInfo term_ANSILegacy;
149 | 
150 | 
151 | 
152 | 
153 | }
154 | 


--------------------------------------------------------------------------------
/arduino/lib/FabGL/src/ulp_macro_ex.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | 
 4 | 
 5 | #include "esp_attr.h"
 6 | #include "esp_err.h"
 7 | #include "esp_log.h"
 8 | #include "esp32/ulp.h"
 9 | 
10 | #include "soc/soc.h"
11 | #include "soc/rtc_cntl_reg.h"
12 | #include "soc/sens_reg.h"
13 | 
14 | 
15 | 
16 | esp_err_t ulp_process_macros_and_load_ex(uint32_t load_addr, const ulp_insn_t* program, size_t* psize);
17 | 


--------------------------------------------------------------------------------
/arduino/platformio.ini:
--------------------------------------------------------------------------------
 1 | ; PlatformIO Project Configuration File
 2 | ;
 3 | ;   Build options: build flags, source filter
 4 | ;   Upload options: custom upload port, speed and extra flags
 5 | ;   Library options: dependencies, extra library storages
 6 | ;   Advanced options: extra scripting
 7 | ;
 8 | ; Please visit documentation for the other options and examples
 9 | ; https://docs.platformio.org/page/projectconf.html
10 | 
11 | [platformio]
12 | src_dir = gameboy/
13 | 
14 | [env:lolin32]
15 | platform = espressif32
16 | board = lolin32
17 | framework = arduino
18 | ; change microcontroller
19 | board_build.mcu = esp32
20 | 
21 | ; change MCU frequency
22 | board_build.f_cpu = 240000000L
23 | ; set frequency to 40MHz
24 | board_build.f_flash = 40000000L
25 | 
26 | 
27 | upload_port = COM45
28 | upload_protocol = esptool
29 | 
30 | monitor_speed = 115200
31 | board_build.partitions = huge_app.csv
32 | build_flags =
33 |  -w -O2
34 | ; -DBOARD_HAS_PSRAM
35 | ; -mfix-esp32-psram-cache-issue
36 | 


--------------------------------------------------------------------------------
/arduino/platformio.ini.linux:
--------------------------------------------------------------------------------
 1 | [platformio]
 2 | src_dir = gameboy/
 3 | 
 4 | [env:lolin32]
 5 | platform = espressif32
 6 | board = lolin32
 7 | framework = arduino
 8 | ; change microcontroller
 9 | board_build.mcu = esp32
10 | 
11 | ; change MCU frequency
12 | board_build.f_cpu = 240000000L
13 | ; set frequency to 40MHz
14 | board_build.f_flash = 40000000L
15 | 
16 | 
17 | upload_port = /dev/ttyUSB0
18 | upload_protocol = esptool
19 | 
20 | monitor_speed = 115200
21 | board_build.partitions = huge_app.csv
22 | build_flags =
23 |     -w -O2
24 | ;    -DBOARD_HAS_PSRAM
25 | ;    -mfix-esp32-psram-cache-issue
26 | 
27 | 


--------------------------------------------------------------------------------
/arduino/platformio.ini.osx:
--------------------------------------------------------------------------------
 1 | [platformio]
 2 | src_dir = gameboy/
 3 | 
 4 | [env:lolin32]
 5 | platform = espressif32
 6 | board = lolin32
 7 | framework = arduino
 8 | ; change microcontroller
 9 | board_build.mcu = esp32
10 | 
11 | ; change MCU frequency
12 | board_build.f_cpu = 240000000L
13 | 
14 | upload_port = /dev/cu.SLAB_USBtoUART
15 | upload_protocol = esptool
16 | 
17 | monitor_speed = 115200
18 | board_build.partitions = huge_app.csv
19 | build_flags =
20 |     -w -O3
21 | ;    -DBOARD_HAS_PSRAM
22 | ;    -mfix-esp32-psram-cache-issue
23 | 
24 | 


--------------------------------------------------------------------------------
/arduino/tools/input/roms/onehour.gb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rpsubc8/esp32gameboy/634939a2be9976a79f71dce1981a571cc126873e/arduino/tools/input/roms/onehour.gb


--------------------------------------------------------------------------------
/arduino/tools/output/dataFlash/gbrom.h:
--------------------------------------------------------------------------------
 1 | #ifndef _GB_ROM_H
 2 |  #define _GB_ROM_H
 3 | 
 4 |  //#include <stddef.h>
 5 |  #include "roms/romonehour.h"
 6 | 
 7 |  #define max_list_rom 1
 8 | 
 9 | 
10 |  //roms
11 |  //Titulos
12 |  static const char * gb_list_rom_title[max_list_rom]={
13 |   "onehour"
14 |  };
15 | 
16 |  //Datos rom
17 |  static const unsigned char * gb_list_rom_data[max_list_rom]={
18 |   gb_rom_onehour
19 |  };
20 | 
21 |  //Tamanio en bytes
22 |  //static const int gb_list_rom_size[max_list_rom]={
23 |  // 32768
24 |  //};
25 | 
26 | #endif
27 | 


--------------------------------------------------------------------------------
/arduino/tools/rom2h.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rpsubc8/esp32gameboy/634939a2be9976a79f71dce1981a571cc126873e/arduino/tools/rom2h.exe


--------------------------------------------------------------------------------
/preview/preview.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rpsubc8/esp32gameboy/634939a2be9976a79f71dce1981a571cc126873e/preview/preview.gif


--------------------------------------------------------------------------------
/preview/previewArduinoIDElibrary.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rpsubc8/esp32gameboy/634939a2be9976a79f71dce1981a571cc126873e/preview/previewArduinoIDElibrary.gif


--------------------------------------------------------------------------------
/preview/previewArduinoIDEpreferences.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rpsubc8/esp32gameboy/634939a2be9976a79f71dce1981a571cc126873e/preview/previewArduinoIDEpreferences.gif


--------------------------------------------------------------------------------
/preview/previewGameboyYoutube.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rpsubc8/esp32gameboy/634939a2be9976a79f71dce1981a571cc126873e/preview/previewGameboyYoutube.gif


--------------------------------------------------------------------------------
/preview/previewOSD.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rpsubc8/esp32gameboy/634939a2be9976a79f71dce1981a571cc126873e/preview/previewOSD.gif


--------------------------------------------------------------------------------
/preview/previewPlatformIO.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rpsubc8/esp32gameboy/634939a2be9976a79f71dce1981a571cc126873e/preview/previewPlatformIO.gif


--------------------------------------------------------------------------------
/preview/previewPlatformIOinstall.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rpsubc8/esp32gameboy/634939a2be9976a79f71dce1981a571cc126873e/preview/previewPlatformIOinstall.gif


--------------------------------------------------------------------------------
/preview/ttgovga32v12.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rpsubc8/esp32gameboy/634939a2be9976a79f71dce1981a571cc126873e/preview/ttgovga32v12.jpg


--------------------------------------------------------------------------------