1

(0 odpowiedzi, napisanych Software, Gry - 8bit)

The #FujiNet NOS for #Atari8bit is progressing nicely, thanks to the hard work of Michael Sternberg (@16kRAM). https://youtu.be/hp0fjKt2w3g

Version 0.3.0 adds:

* an on-line help system (which pulls its pages from GitHub!)
* simple batch processing (using the SOURCE command)
* TYPE command to view files

Still to be done, is a COPY command.

But even at this stage, I am sure you will agree, that this DOS Replacement shows significant flexibility and usefulness.

Do you want to hack on it?
The code is here: https://github.com/FujiNetWIFI/fujinet-nhandler in the nos/ folder.

It can be done. I challenge anyone to patch M.U.L.E. to work via FujiNet.

You do not need the N: CIO driver at all, because you can make the calls over SIOV.

Even if all that's being done is replicating joystick movements, it's a start!

Who's up for it? :)

-Thom

#FujiNet working on idea: block (sector) to network redirect.

Would allow for a program to mark a sector such that:

given a mounted disk. A sector or block # could be marked with a N: URL.

* On read of sector, it would read from the N: URL
* On write of sector, it would write the sector data  to N: URL.

This would allow for existing games that write their hi-score data out to disk, to be sent to a server to be processed and filtered.

I will be using it on the #ColecoAdam Super Games to implement high score leaderboards for Buck Rogers, Donkey Kong, Donkey Kong Jr., Sub-Roc, and Zaxxon.

Anyone wanna hack on it too?

#Atari8bit #FujiNet Thanks to Jan Krupa, a major bug in the N: handler was fixed.

You can get copies here: TNFS://atari-apps.irata.online/fnc-tools.atr, and all the DOS disks have been updated, along with an updated FCONFIG tool.
The fujinet-nhandler.atr disk is also updated.

Thank you to everybody who showed up! This is the entire teleconference walking through the #FujiNet #ESP32 firmware, showing both #Atari8bit and #ColecoAdam as examples. If you want to know where everything is, this is the video for you. https://youtu.be/-WhMVHUGoRE

Does anyone want to attend a walkthrough of the #ColecoAdam #FujiNet firmware (the ESP32 side?), this weekend, as e.g. a Zoom conference?

We'll talk about how the firmware works, how it connects to the Adam side, and how one would add new device types.

Topic: #FujiNet Firmware walk-through
Time: Jan 8, 2022 11:00 AM Central Time (US and Canada)

Join Zoom Meeting
https://us02web.zoom.us/j/77752008521

Meeting ID: 777 5200 8521
One tap mobile
+13462487799,,77752008521# US (Houston)
+16699009128,,77752008521# US (San Jose)

Dial by your location
        +1 346 248 7799 US (Houston)
        +1 669 900 9128 US (San Jose)
        +1 253 215 8782 US (Tacoma)
        +1 312 626 6799 US (Chicago)
        +1 646 558 8656 US (New York)
        +1 301 715 8592 US (Washington DC)
Meeting ID: 777 5200 8521
Find your local number: https://us02web.zoom.us/u/kdc4IeHWjp

7

(2 odpowiedzi, napisanych Fabryka - 16/32bit)

Sure. Code is all open, take a look:
https://github.com/FujiNetWIFI/fujinet-platformio/

-Thom

8

(2 odpowiedzi, napisanych Fabryka - 16/32bit)

Calling all #AtariST hardware and firmware hackers

It should be possible to make a version of #FujiNet that uses the ASCI port, to act as a full fledged network adapter and virtual disk drive adapter.

What is #FujiNet? Watch this video here for the #Atari8bit version. https://www.youtube.com/watch?v=izdCLDQ1ZxU It is a WiFi network adapter based on the #ESP32 which provides virtual disk, printer, WiFi Modem, and a network adapter with protocol offloading.

The Virtual disk drive should be a no-brainer. It is the no.1 use case for the current installed base of FujiNet users, being able to access disk images directly from the network beyond or from a local SD card storage has proven to be the biggest win. It is useful within 30 seconds of coming out of the box.

The Virtual printer is the no.2 use case, and it provides a complete PDF rasterizer, emulating a variety of printers, so that you can quickly print something on modern printers by just opening it up in the web interface.

There is a WiFi modem in the firmware, how this would be exposed on the ST, would be up for debate, so I won’t go too far into it.

But the most powerful aspect of the #FujiNet comes from its network adapter functionality, which is designed in a way similar to a mainframe channel processor, in that the #FujiNet handles all the network protocol arbitration, and presents a nice clean and simple I/O channel that the target computer can sample at its leisure.

One of the problems with accessing the modern Internet, has to do with lackluster support for modern encryption. Offloading this onto the FujiNet fixes this problem completely, and #FujiNet has support for protocols like TLS(SSL) and SSH out of the box. There is also support for JSON and XML parsing of the channel, which means that coupled with the encryption support, modern web APIs can be directly accessed by FujiNet equipped machines. Wins all around.

All of this, in a device with an average target price between $60 to $80.

So why not see if we can bootstrap an effort? There are already efforts underway for the #ColecoAdam, #Apple2, and #C64, in addition to the #Ataribit version which has been in production for over a year, and has over 2000 happy customers.

What say you all? :) Come to our discord, https://discord.gg/7MfFTvD and let’s talk about trying to make this a reality. -Thom

I was at VCF East 2021, and gave a talk in adapting an existing #Atari8bit BASIC game (Reversi) to the #FujiNet.
https://www.youtube.com/watch?v=A9jflXkSef4

#FujiNet I have added a new page to the wiki detailing the changes for supporting more than #Atari8bit systems (currently also #ColecoAdam and #C64), here:

https://github.com/FujiNetWIFI/fujinet- … nt-Systems

@apc has been hard at work on both the FujiNet over UDP tunneling protocol, and the Altirra device server for said protocol. With this video, you'll see two instances of #fujinet started and connected to two instances of Altirra. (Yes, this protocol is being checked into the ESP32 version as well in parallel)

https://www.youtube.com/watch?v=xY7R_q8CXOE

For anyone who is building the firmware:

Can you:

(1) make sure you've upgraded to latest ESP-IDF
(2) make sure you've fixed dirent.h as here: https://gist.github.com/tschak909/1ad20 … fde9dac2c3
(3) delete your copy of the sdkdefaults.fujinet-v1
(4) pull the latest fujinet-platformio
(5) clean
(6) build

and make sure that the fujinet completely initializes?

I had to make a change to sdkdefaults to tweak static memory allocation parameters, with the latest ESP-IDF framework, and would like a few more pairs of eyes to see if things are still ok after the latest change.

https://github.com/FujiNetWIFI/fujinet- … 595de011a1

13

(390 odpowiedzi, napisanych Scena - 8bit)

FujiNet connected demos :)

we're trying to find ways to make it more useful, without vastly increasing the memory footprint.

Gibstov will put it up on GitHub shortly, so hopefully everybody will run with it, but for now, you can load it on #FujiNet by connecting to atari-apps.irata.online and mounting neon.atr in the Networking folder :)

-Thom

Pin napisał/a:
bocianu napisał/a:

Więc w zasadzie mamy pierwszy internetowy browser na Atari ;) Można go zobaczyć w akcji tutaj:

Po pierwsze drugi (po Contiki), a po drugie to jeśli to jest na Fujinet i dalej na UDP i SIO to będzie słabo bo notorycznie wali to błędami, więc można to potraktować co najwyżej w kategorii egzotycznej ciekawostki.

@Bocianu - tak zapytam, bo widzę na fujinet.pl wsad do Floba - flasher sprawdza odczytywane dane, czy zapisuje karta "pa pałę"? :)

Somebody is not paying attention. :)

Neon itself has NO networking or FujiNet code inside it at all. It relies entirely on CIO, so the N: handler provides the networking. Any protocol that N: can handle, Neon can handle.

But go ahead, and keep blabbing about Contiki, something that has had next to zero growth in the last 20 years, and is literally a dead end. :)

-Thom

I am currently working on a set of commands to put the FujiNet into a UDP streaming mode, so that programs and games that need to constantly send and receive data without waiting for the SIO routines can work.

But I need some help on the Atari side:

So basically, when it goes into stream mode, it takes over the entire SIO bus, and an input routine would need to be provided to read the data from the fujinet.

Of course, we have the PROCEED line to tell us when new data comes across.

Does somebody want to put together a set of asm routines that:

(1) Initializes the pokey to the appropriate baud rate (divisor), and installs:
(2) a VPRCED interrupt routine to know when something is ready for receipt
(3) a SERIN interrupt routine to grab the resulting data
(4) a shutdown routine that puts everything back

while I work on the firmware side of things?

-Thom

How about a multi-player version of Scorched Earth? ;) https://www.youtube.com/watch?v=c4hEARQW9C4

18

(2 odpowiedzi, napisanych Sprzęt - 8bit)

xxl napisał/a:

Fujinet sie rozpedza :-)

https://atariage.com/forums/topic/31729 … yone-care/


obsluga filesystemu przeniesiona na urzadzenie, koniec z probelmami roznych FSow Sparty, Dos2, Fatow, koniec z przeladowanymi sterownikami D:

czy opor userow przywiazanych do pewnego dosa wystapi? zobaczymy ;-)

#Atari8bit #FujiNet shown here is an example of what an IMAP adapter for N: would look like, and how it would function, to deal with e-mail boxes at the OS level. https://atariage.com/forums/topic/32000 … nt=4816568

Naprawdę muszę przedstawić argumenty za NOS, i dlaczego byłby to ogromny krok naprzód:

W skrócie, stworzyłoby to ścieżkę, w której można nie tylko zrobić menedżera plików, który działa całkowicie przez sieć, ale może wykorzystać pełną moc ESP32 do abstrakcji operacji systemu plików.

Każdy adapter protokołu dla N: działa całkowicie na samym ESP32 i może być dowolny. Dla systemów plików będą to :

* FTP
* SMB
* HTTP
* TNFS
* NFS
* SCP/SFTP

etc.

Ale można też stworzyć inne adaptery systemu plików, np. adapter DISK, który mógłby być wskazany pośrednio przez slot urządzenia, lub bezpośrednio przez ścieżkę, do (np.) obrazu dysku ATR. Samo ESP32 wykonywałoby całą abstrakcję odczytu i zapisu do ATR; łącznie z zajmowaniem się wszystkimi aspektami systemu plików.

Ta abstrakcja jest krytyczna, ponieważ oznacza, że nie tylko te metody dostępu do systemu plików nie muszą być przykręcone do kodu Atari (co skutkuje znacznie mniejszym MEMLO!), ale oznacza to, że ta abstrakcja zapewnia ścieżkę do odczytu i zapisu z dowolnie sformatowanego obrazu dysku, niezależnie od tego, jaki FMS może być uruchomiony na Atari.

Tak więc są tu dwa zwycięstwa:

(1) NOS, z niskim memlo, który może czytać i pisać do czegokolwiek.
(2) możliwość transparentnego odczytu i zapisu do czegokolwiek, pliku lub obrazu, z dowolnego innego DOSu.

Dlatego właśnie staram się zainteresować ludzi używaniem lub pracą na N:, wiele możliwości nagle otwiera się z tą abstrakcją, dzięki ESP32.

-Thom

20

(0 odpowiedzi, napisanych Programowanie - 8 bit)

Another example of using the #FujiNet from Forth is to do things like view the host or disk slots currently in use. This example focuses on the FLH word, which will display the available host slots.

We start with a set of constants that map to memory locations that SIO uses. These make the code easier to read, and are used by all of the words in the FUJINET vocabulary in Forth:

```forth
SCR # 1
  0 ( #FN SIO CONSTANTS 1 )
  1
  2 BASE @ HEX
  3
  4 VOCABULARY FUJINET
  5
  6 0300 CONSTANT DDEVIC                  0301 CONSTANT DUNIT
  7 0302 CONSTANT DCOMND                  0303 CONSTANT DSTATS
  8 0304 CONSTANT DBUF                    0306 CONSTANT DTIMLO
  9 0307 CONSTANT DRESVD                  0308 CONSTANT DBYT
10 030A CONSTANT DAUX1                   030B CONSTANT DAUX2
11 030A CONSTANT DAUX
12
13 E459 CONSTANT SIOV
14
15 -->
```

We also need screen 3, which provides the (DO-SIOV) word that actually tells the Atari to perform the SIO operation.

```forth
SCR # 3
  0 ( SIOV )
  1
  2 CODE (DO-SIOV)
  3
  4 XSAVE STX,                            ( SAVE X REGISTER )
  5 SIOV JSR,
  6 XSAVE LDX,                            ( REST X REGISTER )
  7 NEXT JMP,                             ( RET TO INTERPRET )
  8
  9
10
11
12
13
14
15 -->
```

We need a place in memory to store the results of our host list, as well as a way to easily retrieve each host slot from this memory. We can do this by specifying a word that gives us these properties, HOST-ARRAY. HOST-ARRAY allocates a 256 byte area of memory, when we create it, and when we use it, it will return the offset for the host slot for which we ask. This is possible because Forth can define words that do one thing when being created, and another while being used. This is a concept called meta-programming. The <BUILDS word allows the programmer to specify what words are to be executed when the definition is compiled, or "built", and DOES> allows the programmer to specify what words are executed when the word is encountered.

```forth
SCR # 70
  0 ( FLH - Data Structures )
  1
  2 : HOST-ARRAY ( 8 entries 32 bytes )
  3       <BUILDS 256 ALLOT      ( 256 Bytes )
  4       DOES>   SWAP 32 * + ;  ( each entry 32 bytes )
  5
  6 ( Create a HOST-ARRAY called FLHBUF )
  7
  8 HOST-ARRAY FLHBUF
  9
10
11
12
13
14
15 -->
```

HOST-ARRAY is defined as a compiler word, and it is immediately used to create a HOST-ARRAY called FLHBUF, which is where the host list will be stored.

the <BUILDS section is straightforward enough, it creates a 256 byte area in which data can be stored. This divides into 8 slots, each holding 32 characters.

The DOES> section, is a bit more involved, as DOES> puts an address which corresponds to the first available byte of data onto the stack, and we then swap the stack around slightly (because it is currently backwards) so that we can multiply that address by (32 * n) with n being the parameter passed in.

This creates a data type that works like this:

```forth
0 FLHBUF . 16304  ( the address in memory of the first host slot )
1 FLHBUF . 16336  ( the address in memory of the second host slot )
2 FLHBUF . 16368  ( the third entry ... and so on )
```

So we have a data type that does all the heavy lifting for us when we want to start reading it.

With this, we can now create a word, (FLH) that reads the host list into our newly created buffer.

```
SCR # 71
  0 ( FLH - Get Host List )
  1
  2 BASE @   HEX
  3
  4 : (FLH)      ( -- )
  5         70 DDEVIC C!
  6         01 DUNIT  C!
  7         F4 DCOMND C!
  8         40 DSTATS C!
  9   0 FLHBUF DBUF   !
10         0F DTIMLO C!
11       0100 DBYT   !
12       0000 DAUX   !
13        (DO-SIOV) ;
14
15 BASE ! -->
```

(FLH) uses the FN SIO constants defined above to make the code easier to read, putting all of the values we need into the device control block (DCB) table in memory.

* DDEVIC is set to $70, which is the SIO device ID for the #FujiNet control device
* DUNIT is set to $01, because we want to refer specifically to device $70
* DCOMND is set to $F4, which is the Get Host Slot List command defined here: ( https://github.com/FujiNetWIFI/fujinet- … Host-Slots )
* DSTATS is $40, which specifies that the Atari is expected to get a payload of data from the FujiNet.
* DBUF is set to the address of the very top of FLHBUF. Since all of the host slots in FLHBUF are contiguous, we just need to specify the top of the buffer, and we can read them all in at once.
* DTIMLO is set to $0F, a standard value meaning to wait 15 seconds for an answer.
* DBYT is set to $0100, which is 256 in hex, meaning we are expecting a payload of 256 bytes from the FujiNet.
* DAUX is set to $0000. It isn't used.

Once these values are set, the (DO-SIOV) word is used to perform the SIO operation.

The (FLH) word does nothing to the stack and outputs nothing. It is purely a procedural word that is needed to get the host list and put it into our buffer.

If we were to peek into the buffer we would see something like this:

```forth
0 FLHBUF 256 CDUMP

3000 SD--------------
3010 ----------------
3020 irata.online----
3030 ----------------
3040 fujinet.online--
3050 ----------------
3060 fujinet.pl------
3070 ----------------
3080 ----------------
3090 ----------------
30A0 ----------------
30B0 ----------------
30C0 ----------------
30D0 ----------------
30E0 ----------------
30F0 ----------------
```

the dashes here represent the null character, and on the Atari they would be represented by the heart character. Since the FujiNet firmware is implemented in C, the strings are null terminated, and the most straightforward way to display the data is to simply not display the null character. We can do this via a conditional that only uses the EMIT word to display the character if it is not null. Here we make a word HEMIT, that does just that:

```forth
SCR # 72
  0 ( FLH - HEMIT word )
  1
  2
  3
  4 ( EMIT, but ignore null chars )
  5
  6 : HEMIT      ( n -- )
  7     DUP      ( because 0= consumes it )
  8     0= IF    ( is char a null? )
  9        DROP  ( yes, drop it. )
10     ELSE     ( otherwise ... )
11        EMIT  ( Display it. )
12     THEN ;   ( Done.)
13
14
15 -->
```

HEMIT, like EMIT expects a single byte number. If that number is 0, nothing is displayed.

```forth
HEMIT 65 Aok
HEMIT 66 Bok
HEMIT 0 ok
```

Upon entering HEMIT, we immediately DUPlicate the number coming in, because 0= will consume it and replace it with a 1 if it matches, or a 0 if it doesn't. IF will consume the 0 or the 1. If the value is 1, then we were passed in a NULL, and the number we previously duplicated is DROPped (if you make a mess, clean it up.), otherwise, we pass that duplicated number to EMIT, which displays it.

With the HEMIT word in hand, we now have everything we need to create a word, .FLH" that will display the name of one host slot. It takes one parameter, the host slot number we wish to display.

```forth
SCR # 73
  0 ( FLH - Display Host slot n )
  1
  2 0 VARIABLE HOSTSLOT   ( Temporary variable for slot )
  3
  4
  5 : .FLH"    ( n -- )
  6     HOSTSLOT C!           ( save n )
  7     32 0 DO
  8        HOSTSLOT C@ FLHBUF ( Beginning of Hostslot )
  9         I +               ( next character )
10         C@                ( Get Character )
11         HEMIT             ( And display it.)
12     LOOP ;                ( Done. )
13
14
15 -->
```

To make this code easier to read (and not have to resort to return stack juggling), a variable called HOSTSLOT is defined, and is set to the parameter passed in. We then set up a loop that first gets the address of the host slot, adds the loop index to it, gets the byte number at that address, and then passes it to HEMIT for printing, then looping back until all 32 characters are printed.

This produces a word that acts like the following:

```forth
(FLH) ok
0 .FLH" SD ok
1 .FLH" irata.online ok
2 .FLH" fujinet.online ok
```

...and so on.

It then becomes a trivial matter to write a simple word that does this for all 8 slots:

```forth
SCR # 74
  0 ( FLH - Display all Host Slots )
  1
  2
  3
  4 : FLH         ( -- )
  5   CR          ( start on new line )
  6   (FLH)       ( Get host slots )
  7   8 0 DO      ( 0 to 7 )
  8       I U. ." : "  ( show slot # )
  9       I .FLH" ( Display host slot I )
10       CR      ( CR )
11   LOOP ;      ( done. )
12
13
14
15 ;S
```

The FLH word starts by using the CR word to make sure that output starts on the next line, otherwise the output would immediately start on the same line as FLH.  The (FLH) word is called to fetch the host list, and a new loop of 8 iterations is done. Inside this loop, the I index variable is used by the U. word to display the current slot number, followed by an inline ." : " to print a colon afterwards. I is then also used as the input for .FLH" to display the value of that host slot. We then make sure to use the CR word again, to move the cursor to the next line, and terminate the loop.

The result looks like this:

```forth
FLH
0 : SD
1 : fujinet.online
2 : atari-apps.irata.online
3 : fujinet.pl
4 : TMA-2
5 : RASPBERRYPI
6 :
7 :
ok
```

At the end of the day we have a word, FLH, built on previous words to output a host list. But this is more than a command, this is a word that is now part of the language. This means it can not only be used interactively, but it can be used from within other words:

```forth
: MYHOSTLIST ." This is my host list: " CR FLH ;
```

And even the individual words that make up FLH can be used in other words. In essence, the language is extended with a set of words that can do meaningful things with the FujiNet.

In the same way, other words can be added, extending the capabilities of the environment. This is part of what attracted some people to Forth, its unique ability to solve problems by extending the language.

-Thom

#Atari8bit #FujiNet FNC-TOOLS został zaktualizowany o obsługę symboli wieloznacznych dla NCOPY, a także o poprawki dla FLS. Zaktualizowano także katalog DOS i ROM-y Ultimate1MB. Wszystko jest na TNFS atari-apps.irata.online w /.

22

(8 odpowiedzi, napisanych Fabryka - 8bit)

Please, somebody attempt making a cartridge version. Why do people WAIT for others to do it?

-Thom

it occurs to me that it should be possible to modify this game for fujinet:

http://www.atarimania.com/game-atari-40 … g_888.html

There is a file version in the homesoft collection that could be used as a starting point.

Basically it would need four things:

(0) a screen to connect to host or listen on port 6502.

(1) send the maze data from player 1 to player 2 (no translation or anything needed, just SIO WRITE the buffer, the other side just SIO READs it into the same place.)

(2) only send joystick changes

(3) automatically select 2 player, and have player 1 select invader or defender.

If I'm right, the result should be highly playable. :)

Thoughts?
-Thom

#Atari8bit to conclude this two part video series, we make the Light Cycles game that we created in part 1, able to be played across the network on another Atari with a #FujiNet. https://youtu.be/D0JIOcIzUL8

#Atari8bit In this video, I show how to write the core logic for a light cycle game. The result is a simple racing against opponent barrier game that is controlled by two joysticks, and will be modified for network in part 2.
https://youtube.com/watch?v=fc289lLSPGI