Arca

added memory address register and memory data register, also realised that a mux is a bunch of tri state buffers connected together

Finally found time to work on it again! the jump buffer is done

Deployment is done

Added a bunch of content to the site, not sure if this time should count towards SoM as I was mainly making markdown files, not actually coding things

Atom feeds and lists of projects and interesting things are done! Also <hr>s make the website look so much nicer

added some 88x31 buttons :)

currently making a custom no-css/js theme for jekyll

Collisions are now fixed

Uhhh i think i broke collisions even more

Added the ability for player sprite animations to change depending on the state of the player, so jumping doesn't look stupid now ig. Also did some work on fixing collisions but im going to continue that tomorrow, spent a while thinking of the best way to do it and i think i came up with something half-decent perhaps

collisions are done!!!!!! here's a test scene (the artifacting is because phone camera)

oh my god ive been debugging this for the last 30 min and it's this max here that needs to be a min instead. collisions are close to done, it says 4h44min but it's probably a bit less in terms of normal human brain coding time, i code slowly when i'm low on sleep

Loading sounds from files works now! here's e1m1 because it seemed fitting

Static objects are a thing now, next I'll probably add level importing from LDTK, collisions and then start working on the demo! I'll probably delay font support until the third ship.

sprite animations!!!

i added the ability to flip sprites in the x-axis and also a 2d camera so that can be moved around, for example when the player moves to a different part of the level the camera moves too so that the player isn't offscreen. also spritesheet animation support is almost done, just need to write the tick function. got a lot done today.

writing this thing made me feel like an absolute genius, i think i'm starting to understand properly how rust works now. non-static lifetimes can die in hell, but other than that it's a decent language

Sprite loading works now!!! I encoded the png file from my pc using https://github.com/ArcaEge/embedded-encoder (that's my #siege project, so the time spent for that bit doesn't count here). I'm basically embedding the encoded spritesheet into the binary and it seems to work pretty well

screw memory usage and reliability, i gave up with static allocation and am now using dynamic allocation everywhere (fyi the size of my heap is only 64kb, this probably won't end well...)

why did i not write this in c???????? ughhhhhhhhhhh

i love rust lifetimes so much o_o

Audio in wasm works now, thanks a lot to whoever made the oscillator api

Sound support is done!! Well, not really, I still need to do the wasm bit but that's pretty simple and (hopefully) won't take too long. Also thanks @555 timer for permanently lending me these 15 passive buzzers

Busy trying to get sound working, here's a nice long comment I wrote :D

Implemented an actor-world system similar to greenfoot java, i.e. spent 6 hours building a fancy abstraction system to be able to draw this box:

Rectangles, yay!

Finally fixed that stupid bug causing the ssd1306 to get desynced. here's a cat because I don't have a better image to post.

Completely overhauled the input system to be a lot less stupid, this is across the last two devlogs. Also added a loading indicator to the canvas

yay, inputs work properly now on the pico!

Just did some soldering and stuff to repurpose this old controller I made a while ago, don't look at the solder joints on the back side :)

It's now on github pages!!!1!1!!!11!! https://arcaege.github.io/embedded-engine/

Got the demo working! Just need to compile it for the pico (I need to add the inputs to the pico HAL for that, maybe another hour or so of work, then I'm ready to deploy the demo somewhere and ship!)

Keyboard inputs in wasm work now!! That was quite annoying to do because it turns out that there's no API to get the current state of a key, you have to work it out yourself using event listeners. Time to make the demo! Then I'll do the first ship, and then add some quality-of-life features like builtin sprite rendering, but the core engine is basically done.

Display output in wasm is working! That went smoother than expected and I also made it a nice colour scheme. The canvas is pixel-perfect responsive (and all that logic is in rust because I'm not touching javascript with a metre stick if I can avoid it).

Lesson of the day: mixing async + non-async code = pure pain and suffering. I somehow made it work but it's pain. Also I still don't understand what the hell static lifetimes are but they seem to make the compiler happy. Anyway, delays in wasm work now and the code doesn't crash the main thread anymore. yay.
Next up is figuring out how to render to a canvas.

Refactored the project to be able to use wasm-pack and added a little webpack npm runner to run the devserver, printing stuff to the console works so we should be good. Just need to implement the HAL for wasm now, then I'll get inputs working, make a simple demo (maybe a dot moving around the screen controlled by wasd/arrows) and then ship the first version. I hope I can get that done by tonight.

Did some more work on individual pixel addressing and framebuffer stuff, here's a nice little pixel scanning across the screen row by row. Also ticks work now, I set the tick rate to ~60 ticks/sec. I need to work on the wasm side of things now, just need to create a HAL for web assembly.

Writing to the display now works! Here are some nice horizontal lines :D

Other stuff I've been up to:
- Added a 64KiB heap using embedded-alloc for dynamic memory allocation (don't need it now but will need it in the future)
- Implemented a generic framebuffer
- Found a bug/oversight in rp2040_hal (no good way to make two back-to-back i2c transactions without a stop/restart in between. logic analyser came in clutch for that one)

I added the function to initialise the display (the display's buffer is not cleared at startup so it makes this nice random pattern from the noise in the buffer, this isn't an issue as it goes away when you display the first frame). Next what I need to add is some function to put the pico's framebuffer data onto the display's framebuffer

I think I'm starting to figure out how Rust works but everything is taking 4x as long as it should because I'm still a clueless beginner to embedded Rust. I decided to say screw it, let's refactor the code because the old structure was stupid and hard to maintain, especially with 2 compile targets for pico and wasm. Speaking of wasm, I haven't done much in terms of that but I have started work on the ssd1306 driver code to drive the screen (I'm not using external crates for this because who likes to use libraries when you can do it yourself? It's pretty simple anyway because I'm just porting over the display driver code from my pico flappy bird project, which also used an ssd1306 but was written in C). Pictures are mandatory on devlogs, so here's a picture of the current setup I guess.

Clock and peripherals initialisations for the Pico are done, it took a while because this is one of my first projects using Rust and I was busy playing karate with the compiler

Did some boilerplate stuff, mostly just initialising the project structure and getting compilation to both RP2040 and WASM working.

I swapped out the 12V regulator because apparently JLCPCB can't place that component. Now it's actually done, I think I'm ready to ship.

I think the PCB is done!

Component arrangement is done, time to route!

The high current outputs are arranged now, no routing yet

Finished laying out the stepper motor connections

The schematics are done!

Well that took way too much effort, but we now have a high-current MOSFET-based switching circuit for a high current load like a CNC spindle or hotend/heated bed if it's being used as a 3D printer board. In theory this can handle 110A but obviously physics is a thing.

First devlog! Started work on the schematics. Even though the time recorded is ~2hrs, I spent way more than that picking components and looking at datasheets, too bad Hackatime can't track that :(

Implemented a scrolling VGA text buffer with support for colours. Also added a nice blue screen of death for when a kernel panic occurs

Didn't write too much code, just did a whole bunch of reading on the OSDev wiki and a bunch of experimentation (that's why hackatime recorded 2.5 hours). Managed to get a simple paged mode boot with vga text output but then decided to switch to Rust because a) I cba with C tooling, cargo is much better, b) I'd like to learn rust and c) rust cool and also memory safety I guess. Also updated README. Number 1 long term goal is to run Doom (doomgeneric makes that pretty simple by providing a hardware abstraction layer). But to do that, I first need other things (filesystem, proper colour and display output)

Got a simple hello world working, it loads kernel.c. For now almost all of the code is copy-paste from the OSDev wiki, just trying to get things working right now. Also, I added newline support to the VGA display

ALU is done. I added in extra flags because why not add flags? everyone likes flags. One for every pin of the accumulator and four general purpose flags too. Also logisim is glitchy now, the circuit decides whether it'll work or not depending on how and where you place it. yay.

Uhhhh i may have broken logisim

ALU is now mostly complete!

So it turns out I way overcomplicated bit shifters and I can just do this. Was messing about with muxes and d-type flip flops and tri-state buffers and all that and turns out they can all be replaced by the wires here.

Instruction fetcher is done. It uses the ring counter to fetch the opcode and operand into registers.

Here's a cool 8 bit register with increment + decrement inputs and carry + borrow outputs too! This allows you to make a 16 bit register pretty easily, which I might use 74LS193 counter ICs are pretty cool I guess.

Added a ring counter

8-bit registers! And they're made out of logic gates only!

Finally managed to compile and set up the cross compiler!

Added the demo video to the readme, I think I'm ready to ship!

It's done! I'm resetting the game by soft resetting the entire pi pico. Turns out that the Pico SDK didn't have a soft reset function (you can use watchdogs but that's janky and results in the pico locking up after reset occasionally for some reason? I think it might be an I2C-related thing as I wasn't resetting the display). So I had to write a value to the AIRCR register (standard register across many ARM cortex M-series chips I believe) in order to reset the RP2350. Anyway, the entire game is fully functional and done now :D

Almost done!

Got around to writing the function that draws pipes, they look pretty good imo

Rectangles! And player death detection too!
Player logic is basically complete.

Animations are complete! It feels much more alive now

Added gravity! I'm still tweaking the jump velocity and gravity acceleration values so that it feels more natural, but gravity is done!

The bitmap drawing function now returns the number of pixels that were already on. I'll be using this for collision checking (if this number is > 0, we have a collision)

Input handling is done! I decided to use interrupts because it's better for handling button presses even at low tick rates, as it isn't limited to the same poll rate as the tick speed. (I know that there are ways to get around that, but interrupts probably simpler).

Finally, we can display sprites!

Who knew drawing a monochrome bird would be the hardest part of the project? It took way longer than 20 min btw (more like 1.5 hours), it just didn't track on Hackatime because I didn't have the plugin installed for aseprite :(

Finally figured out how to control the SSD1306, so I can control the state of each pixel now. All that's left to do is the game logic for flappy bird.

Started work on the display write function, trying to decipher the SSD1306 datasheet

Managed to somehow figure out the I2C interface, so now we have blink running on the entire screen (the chonky line in the middle of the screen is because of screen tearing, it looks normal in-person).

Finally managed to set up the Pico SDK (yay!), though I had to configure a bunch of udev rules for openocd to work properly without sudo (so that VSCode debugging could work properly).