When a tipster came to us with the line “One dollar BASIC computer”, it intrigued us enough to have a good look at [Stan6314]’s TinyBasRV computer. It’s a small PCB that forms a computer running BASIC. Not simply a microcontroller with a serial header, this machine is a fully functioning BASIC desktop computer that takes a PS/2 keyboard and a VGA monitor. Would that cheap price stand up?
The board uses a CH32 microcontroller, a RISC-V part that’s certainly very cheap indeed and pretty powerful, paired with an I2C memory chip for storage. The software is TinyBASIC. There’s some GPIO expandability and an I2C bus, and it’s claimed it can run in headless mode for a BASIC program to control things.
We haven’t added up all the parts in the BoM to check, but even if it’s not a one dollar computer it must come pretty close. We can see it could make a fun project for anyone. It’s certainly not the only small BASIC board out there, it’s got some competition.
Thanks [Metan] for the tip.
A dollar seems doable for qty10k. Probably more like $50-$70 for the hobbyist board house MoQs and low-qty component orders. Been a couple of years since I’ve done a PCB like this but that’s always where they seemed to end up
From the usual Chinese assembly/fab houses, I’d expect $10‐15 in quantity 10 with careful parts selection, and not accounting for tariffs for some customers.
We just made an order for 10 large boards with almost 1000 parts per board (not all unique), and they came to not more than a few hundred dollars per board.
This stuff is getting silly cheap these days.
Is that including assembly? Wild.
Yep, the whole thing to finished boards in our hands.
Dope project, though. I haven’t done basic since my dad taught me back in the day. Not my preferred language, but it’s iconic and I know some people love it
Do those that love it still actually use it though? Or do they love it only because it was their first?
Don’t get me wrong though even if it is only for the nostalgic remembered joy that gives it enough value, especially when its so cheap a board to play with.
I love it, because it was my first, and I also use it regularly to this day. So, both (at least for me)
QBasic and QuickBASIC is still in use by retro computing community, I think.
Because you can quickly make a proto-type application or game.
It also doesn’t required line numbers, has lots of third-party support (DirectQB is like DirectX on DOS): http://www.petesqbsite.com/
There’s QB64 for modern computers, too.
Same goes for Visual Basic Classic, I think.
It has several free alternatives (DarkBasic; some run on Java) and allows easy RAD prototyping.
On Linux, there’s Gambas as a counterpart, I think.
I think Bascom AVR has some popularity still. I know a guy who did really impressive project with it.
The 8052AH-BASIC interpreter was (is) really, really sophisticated.
A lot of Tiny, Nano, Micro something Basics can learn from it how to do serious business.
I built a ‘BasicEngine’ once (https://basicengine.org/esp8266.html). Really fun project. But well, it ended up like my ZX81+38: in a box, having no time, motivation or incentive to actually do anything with it. The building was the fun part.
But then again, I’m already a software developer and already know the exhilarating feeling of when you write a program and the computer starts doing what you asked it. I had that in 1982, writing my first Tiny Basic program on a Nascom 1.
BASIC is great for your first time programming. There is nog formal anything, don’t have to think before you write, I would say that it was the prototype ‘vibe coding’ language. ;)
BASIC used to be a problem-oriented language, also.
Way back in the 1970s it was a serious tool.
Then the homecomputers arrived in the 1980s and it deteriorated to a funny kids language, like Logo.
But that’s not BASIC was meant to be, it never tried to be a toy computer language/command prompt in fitst place.
It had certain standards, too.
Here are two examples of serious 1970s era Basic computers:
https://en.wikipedia.org/wiki/Tektronix_4050
https://en.wikipedia.org/wiki/Wang_2200
Serious Basic implementations are M-BASIC, QuickBasic/TurnboBasic or MS PDS 7.1, for example.
Or Locomotive Basic v2 (GEM), Amiga Basic, GFA Basic. Etc pp.
Modern BASIC languages have adopted certain Pascal language elements, also.
Early ’80s, I hacked a Program called AP Mail, this could do Mail Sorting by Zipcode or Alphabet, of 300 Names.. on a Single 5 1/4 Floppy.. Apple ][ MS Basic.
I took it to 2,400 Names and running 4 Disk Drives at the Same Time, made it a Linked Pointer File System to Speed things up. Could not afford a Hard Drive System. It was for Business Mailings I was doing..
Basic is a Great Language.. Later I was involved in using Basic as a Machine Controller Computer.. ended up Compiling it to get the Speed up..
Cap
When I was in the USAF our EW Shop got ahold of a surplus HP-85 than ran basic, so one of my coworkers wrote a BASIC program to calculate boresight constants.
I later used BASIC to solve a differential equation using the Euler method for a college course, everyone else already had FORTRAN and access to the computer lab, but being a active duty air force and part-time student, this was faster. And more important, it worked.
BASIC was never meant to be a “toy” language, and the first implementations were compiled, not interpreted. I think it was the PDP-8 BASIC that made the success, so much that Gates and Allen wrote their microcomputer version – with the rest being history.
Without BASIC, the home computer flood in the 80’s along with the software engineering education probably would not have happened, and we would still have wind-up timers in our microwave ovens and washing machines.
The 8052AH BASIC was great, especially after the patches published in Elektor magazine. Good for control applications, only the string handling was missing. I remember having written the add-on string primitives – left, mid, right a’la Microsoft as add-ons.
@OH3MVV Excellent write-up! Thank you!
What I meant to express was that something like the C64’s Basic v2 caused a certain stigma about BASIC.
Things like over-use of peek/poke, goto and spagetti code in general.
This is relant in so far, because the C64 is often being remembered as the very role model of an home computer.
That’s why I wrote “deteriorated”. The C64 Basic was poor on purpose, to save memory and money.
It wasn’t state-of-the art, yet it became a symbol of BASIC.
Which really hurts all the people which worked with full implementations of BASIC (M-BASIC on CP/M was a classic).
But I don’t mean to be so hard on Commodore.
The C128’s Basic v7 and third-party extensions such as Simons’ Basic were excellent, by comparison.
The older PETs (CBM’s 70s era businesses line) had better BASIC in ROM than the ViC-20/C64, even.
How about TinyFortran then? Or Turbo Pascal, the frenemy of BASIC?
Turbo Pascal 3, 4 had been popular on CP/M and DOS in the 80s.
Version 4 added EXE file format to break 64KB barrier (which had required use of overlay files previously).
There also was GRAPHIX TOOLBOX and BGI graphics drivers.
In the 90s, Turbo Pascal 6, 7 and Borland Pascal 7 were popular on DOS platform.
The Borland Pascal version was full version and had offered Turbo Vision library for your own programs.
Pascal/Turbo Pascal had been used by profs and students on colleague, I heard.
So highschool was more at BASIC level, while universities focused on Unix/C..
(Speaking under correction, it’s just meant as an analogy, no offense.)
On Windows 3.x, there was Turbo Pascal for Windows 1.0+1.5,
Borland Pascal 7 for Windows, Delphi 1.0..
On 32-Bit Windows, Delphi 3 Professional and Delphi 7 used to be classics for a very long time.
On Linux, Kylix used to be a fine Delphi port.
Now we have Lazarus IDE with Free Pascal instead.
Note that the computer described here has the capability of having up to two EEPROM memory chips of up to 512 kb each, an I/O expander, a 24 MHz crystal oscillator, and audio output, but all of that is optional and clearly not included in the $1 BOM. The $1 assumes the MPU, a single 32 kb EEPROM, and very little else. Two versions of the firmware are supplied, for either internal clock or external 24 MHz oscillator, and either one detects what hardware is actually installed to enable the optional instructions as appropriate.
It has an interesting (imho) VGA bit-bangging stuff. Displaying only characters and only in monochrome, but nicely done (aka: very simple and readable).
I did the same with less and with an actual product by Olimex: the RVPC
https://github.com/arduinousergroupcagliari/RVPC_TinyBasic
https://www.olimex.com/Products/Retro-Computers/RVPC/open-source-hardware
It’s indeed very similar.
Hey man that is super cool :) I will probably order a few to play with and gift for Christmas now that the tariff situation has settled down a bit. High five on a nice project :)
You even got to HaD:
https://hackaday.com/2024/05/31/ch32v003-makes-for-dirt-cheap-risc-v-computer/
Betteridge’s Law of Headlines. If the headline asks the a question, the answer is always “no”.
No, this is not a proper computer for a dollar.
There’s always an argument over what constitutes a “proper computer”. By using a $7 “cheap yellow display” ESP32 dev module, you can use the built-in display for an on-screen keyboard, and these generally include a microSD card socket, and always WiFi and Bluetooth. I would challenge anybody to argue that such a thing would not be a “proper computer”, which I could claim is $1 for the computer itself and $6 for the I/O peripherals, but even that would require a separate power supply.
Thumbs up for supporting VGA! 🙂👍
Admit it: you knew it was clickbait when you clicked on it.
Leonardo may have clicked on it only to decry the clickbait.
fuzix working?
Need to write an i8080 emulator and add an external SPI interface to be shared between serial RAM and Flash ROM for the filesystem. It will no longer be a one dollar computer, but still a fun project to try :)
indeed … Jenny pls stop sniffing glue/soldering fumes/contact cleaner/wd40 whatever..
Used BASIC on a Z80-CP/M box to write a simplified version of SPICE, which I used to analyze some audio circuits for an amp I was designing. It could even draw response plots on a hacked HP analog lab plotter. To get things to run in the whopping 56k of RAM, there was a lot of intermediate result storage onto floppy, which was then read in again for the next phase of processing.
Ditto. I did this shortly before the launch of the IBM PC-XT (and clones).
I still use basic occasionally Oshonsoft’s basic they have a great basic compiler, assembler and simulator for several microcontroller families. Avr, pic, z80etc. They are still actively developing with new versions coming out every few months.
Commercial and industrial uses of tiny BASICs?
1 Initialize hardware both interactive and batch with tiny Basic OS/language
2 Query hardware initialization setting both in batch and interactively.
3 Load then run small binaries … stored in DATA statements.
4 Load then run HUGE apps which now run on Linux platforms.
High level tiny BASIC with interactive incremental assemblers for many
platforms will help, or course.?
HAhaha :( —
|AI Overview
Why the “boot into Tiny BASIC” idea faces practical challenges The idea of a
computer booting into Tiny BASIC for hardware initialization, and then loading
an OS only if necessary, has a certain elegance for simplifying the boot process
and offering direct hardware interaction. However, this approach faces significant
challenges in modern computing due to Tiny BASIC’s limitations and the
complexities of current hardware. 1. Limitations of Tiny BASIC for complex
hardware initialization
In conclusion, while the concept of a mandatory minimalist OS boot has some
theoretical advantages, the practical implications for most users, coupled with
existing alternative methods, suggest it might not be the most universally
desirable or feasible approach for general computing. However, for
specialized applications or educational purposes, a scenario
like this could prove valuable.
Does Google AI have an agenda?
Speaking about “minimalist” OSes..
Back in the 1970s there had been so-called “monitor” programs.
(The term used to be part of CP/M, too: Control Program and Monitor.)
They essentially were a piece of small firmware that could be used to
boot-strap load software from cassette or floppy, do some hardware testing and initialization.
They had a hex editor or debugging utility built-in, often.
Let’s think of t like MS-DOS’ DEBUG.COM utility, but stored in ROM and available upon power-on.
The Sharp MZ line had such monitors in ROM instead of BASIC like all the other home computers had.
The German c’t-86 personal computer also had a boot loader/monitor in ROM..
In PC sector, the OpenFirmware would most likely be the modern day equivalent to a BIOS/Monitor.
It is a firmware that initializes the hardware, but also has a simple command line with DEBUG.COM like syntax.
Anyway, just saying. On home computers such as C64, the KERNAL/BASIC combo served as sort of a monitor program.
The “direct mode” (immediate mode) of BASIC basically played the role of a command prompt.
I think PropForth (FORTH for Parallax Propeller microcontroller) is a FORTH implementation of such.
It loads from EEPROM, ie, boots into Propeller (1 or 2, the two seem to be similar somewhat) and since Propeller is really eight separate cores, one core runs the FORTH, while the other takes care of the UART.
Whoops.
Does Google AI have a Big Tech software technology agenda?
why does big tech software favor batch technology software?
AI Overview
The preference for batch processing among big tech companies stems from a
confluence of factors, driven primarily by the need to handle massive datasets
efficiently, reliably, and cost-effectively, according to Number Analytics.
Here’s why:
While stream processing offers the advantage of real-time insights and is gaining
traction in scenarios requiring immediate action (like fraud detection or live
monitoring), batch processing continues to be a cornerstone for big tech due to i
ts strengths in handling massive datasets, optimizing costs, and ensuring data
quality for critical applications. Many companies are also adopting hybrid
architectures that combine both approaches to leverage the best of both worlds.
is big tech ibatch software bugg, malware vulnerable and unmaintainable?
AI Overview
Big tech companies utilize both batch and real-time processing in their operations,
with batch processing remaining crucial for many tasks, despite the increasing
prominence of real-time systems.
Batch processing and its implications for big tech.
Buggy
Malware vulnerable
Unmaintainable
In conclusion, big tech batch software faces inherent challenges related
to potential bugs, malware vulnerabilities, and maintainability, particularly
for older systems. However, with the evolution of technology and the
implementation of robust security measures and maintenance strategies,
these challenges can be effectively addressed. Modern batch processing
tools and cloud-native solutions contribute to building scalable, efficient,
and increasingly secure systems.
does PEEK and POKE give tiny basic about the same power as
FIG Forth C@ and C, to write boot software?
AI Overview
In essence, both Tiny BASIC’s PEEK/POKE and FIG-Forth’s C@ / C! allow direct access
and manipulation of memory, which is crucial for writing boot software.
However, the question of whether they grant the same power is more nuanced:
In conclusion, while both PEEK/POKE and C@/C! offer low-level memory access, the
context in which they are used—the entire language and development environment—
makes a significant difference. Hackaday explains that Forth’s design philosophy and
features like interactiveness and direct hardware control make it a more powerful
and efficient choice for writing boot software compared to Tiny BASIC.
Where did he get that tiny VGA screen – I would love one for retro projects.
I requested Google AI modify.
Here’s why your suggested extension offers a more complete picture:
…
Therefore, describing Forth as an “interactive, single-task incremental
interpreting/compiling OS” highlights some of its unique characteristics
and historical uses, particularly in embedded systems, where it often
served as the primary system software. However, it’s important to
recognize that modern Forth implementations also exist for mainstream
operating systems like Windows, Linux, and macOS, where they run as
applications rather than standalone operating systems.
is there a fourth for the esp32?
AI Overview
Yes, there is a Forth implementation available for the ESP32.
It’s commonly referred to as ESP32forth.
Here’s why this is relevant:|
ESP32forth Features: This specific implementation, developed through the
collaboration of Brad Nelson and Dr. Hanson Ting, allows you to leverage the
ESP32’s capabilities like WiFi, Bluetooth, file systems (SPIFFS, SD cards), and
various peripherals using Forth.
Benefits: Using Forth on the ESP32 offers
advantages like: Faster Development Cycles: The interactive
nature of Forth allows for quicker code writing and testing.
Low-Level Hardware Access: Forth provides granular control over the
ESP32’s hardware, crucial for embedded applications. Compact Code: Forth
often results in smaller code size compared to languages like C.
In short, if
you are looking to explore the ESP32 with Forth, ESP32forth is a
viable and feature-rich option. :)++
Does flashing an Espressif ESP32 involve
initializing hardware registers before copying
the binary into flash memory?
AI Overview
Essentially, yes, there is some degree of hardware interaction
and initialization involved, but it’s largely handled automatically
by the process and tools you use, rather than requiring explicit
register manipulation on your part.
Here’s a breakdown of the process:
1 Placing the ESP32 into “Download Mode”: You’ll typically
need to put the ESP32 into a specific “download” or “flash”
mode, often by holding down a BOOT button while resetting the
chip. This allows the chip’s built-in ROM bootloader to take
control and communicate with the flashing tool.
2 Communication via Bootloader and Flashing Tools: Once
in download mode, the ESP32’s ROM bootloader
communicates with a host flashing tool, like esptool.py,
over a serial (UART) connection.
3 Hardware Configuration during Flashing: The esptool.py
(or similar flashing utility) interacts with the ROM bootloader
to configure the necessary hardware for flashing. This includes:
Setting up the SPI flash controller to communicate with the
external flash memory where the firmware will reside.
Potentially setting up other registers related to the flash memory’s
operations, such as clock speed or flash mode.
4 Copying the Binary: After initial configuration and communication
is established, the flashing tool copies the compiled firmware binary
(including the bootloader, partition table, and application) into the
ESP32’s flash memory at the specified addresses.
5 Flash Encryption (Optional): If flash encryption is enabled, the
firmware is initially flashed as plaintext, and then the ESP32 encrypts
it in place on the first boot.
In summary, while there is a hardware initialization stage before the
binary is copied to flash, the tools like esptool.py and the ESP32’s ROM
bootloader handle the low-level details of configuring the necessary
hardware registers. You typically won’t need to manually deal with these
registers unless you are developing highly specialized flashing procedures
or interacting with the chip at a very low level.
FORTH … I haven’t used that language since the days of the Z-80 CPU and a Kaypro DOS “portable”.
is there a tiny basic for a risc-v platform?
AI Overview
Yes, there is a Tiny BASIC implementation that runs on a
RISC-V platform.
Specifically, there’s a project called TinyBasRV that utilizes a
CH32 microcontroller (a RISC-V part) to run TinyBASIC. This
project reportedly creates a “fully functioning BASIC desktop
computer” with features like PS/2 keyboard and VGA monitor
support.
It’s important to note that Tiny BASIC is a minimalist version of
the BASIC programming language, designed for microcomputers
with limited memory. While not as feature-rich as modern BASIC
dialects, its small footprint makes it suitable for systems like the
RISC-V based microcontrollers used in the TinyBasRV
gotBASIC.com
For all people interested in the continued usage and
evolution of the BASIC programming language.
TinyBasicLike: A Target-Independent BASIC Interpreter.
does the arduino ano esp32 run freertos?
AI Overview
Yes, the Arduino Nano ESP32 does run FreeRTOS, as the
Arduino core for ESP32 is built on top of the Espressif IoT
Development Framework (ESP-IDF), which natively uses
FreeRTOS. You don’t need to install FreeRTOS separately;
you can directly use its task management, scheduling, and i
nter-task communication features in your Arduino sketches.
How it works.
does the arduino ano esp32 run esp32forth?
AI Overview Yes, the Arduino Nano ESP32 can run ESP32-Forth.
Since the Arduino Nano ESP32 uses an ESP32-S3 microcontroller,
and the ESP32-Forth project was developed to run on the ESP32
platform, the Nano is fully compatible.
The process of getting ESP32-Forth to run on the
Arduino Nano ESP32 involves the following steps:
Profile photo for William Payne
William Payne
·To Mohammed Islam.
Your conclusion about first learning c appears correct?
Nanocomputer new hardware technology reason:
which compiler is most commonly used for esp32 projects?
AI Overview
The compiler most commonly used for ESP32 projects is the GNU
Compiler Collection (GCC). It is the standard toolchain that comes
with the Espressif IoT Development Framework (ESP-IDF), which is
the official development platform for the ESP32.
You will encounter GCC
indirectly through one of the following development environments:
Espressif IDF: Espressif’s official framework uses a GCC-based
toolchain to compile C and C++ code. This method provides
the most control over the device and is standard for professional
developers.
PlatformIO: This popular plugin for Visual Studio Code uses
GCC under the hood to compile code for various platforms,
including the ESP32. It offers a more advanced and feature-rich
development experience than the Arduino IDE.
Arduino IDE: The “esp32” board package for the Arduino
IDE uses the same GCC toolchain to compile your code.
This is the most common and user-friendly entry point for
hobbyists and beginners.
Nanocomputer software goals.
1 No bugs.
2 no malware.
3 all software modules certified.
All other programmer concerns irrelevant to
goal achievements?
who sells counterfeit esp32 computer systems?
AI Overview
You cannot get a definitive list of who sells counterfeit
ESP32 computer systems, as this is an illegal activity
conducted by unauthorized and often anonymous
sellers. However, the primary sources for these
counterfeit and knockoff components are specific
e-commerce platforms and unvetted online
marketplaces, particularly those based in China.
Common sources of counterfeit ESP32 modules
AliExpress and Alibaba:
….
Unvetted independent brokers:
…
Third-party sellers on other e-commerce sites:
How to report a potential counterfeit.
ESP32 counterfeit devices technically exist,
but that’s not the full story.