maehw

On the bottom right corner it reads "verkauft" — German for "sold". I didn't have the budget at that time. That has been sold to Daniel.

Hi all and merry Christmas! Could you please reference the exact post? If it is the ebay one, we'd have to ask Daniel Schmatz because I didn't obtain those newsletters in printed form and the image above very much looks like a photo and not a screenshot. Still in touch with Daniel about the software BTW, so we might get a German version of Lego Lines some day.

Hi @Gunners TekZone, that was indeed also not very clear to me in the beginning, but I found some convincing hints around the interwebs: websites, a book and finally the auction with the mentioned unobtanium @Toastiementioned above. 😅

Yes, unfortunately not really any progress. I've been in touch with Daniel recently. He's expecting some kind of expense allowance to compensate the invested time to save the data from the disks. So maybe we could start throwing together a pile of money. What do yous think?

Hi Thorsten, no worries. I've just re-read the code and slightly modified it: https://github.com/maehw/BrickLines/blob/main/hardware/serial2parallel_converter/arduino_sketch/arduino_sketch.ino Should work the same - just added another bitmask for the status bits. However, I haven't tried this version yet.. so if it turns out not to work as you'd expect, please let me know. The previous version worked fine for me™. And thanks for your original code contribution. Mine is just heavily based on yours, I only remember to have cleaned it up a bit. I do not have an IBM XT here, so I cannot test that but I haven't touched baud rate settings from your code, IIRC. Still having a visit at the Deutsche Nationalbibliothek in my mind to acquire the data from that book diskette... even if it will not give us the LEGO Lines code for IBM PC. I'll ask Daniel if he was successful with the precious disks from LEGO.

Hi everyone. I don't think that any variant of LEGO Lines offers power levels. The UI also only allows zeros and ones (and "don't care" for inputs). So only binary — on or off. Also, I don't think there was a hidden option — for Block Lines I reverse engineered the file formats and the encoding also would not support that.

Hi Evan (and all), I read about your post in my e-mails and got interested so I was planning to help this morning (before seeing your edit). I stumbled across this tool: https://github.com/monkeyman79/dfsimage - and was able to extract the files, too. Actually I was quite surprised that you were expecting BASIC source code files... I'd have expected binary (compiled) executables instead. But that may not be how the BBC Micro worked. Maybe you can enlighten us (me?) here. Honestly, I haven't done any research on my own here but it might be interesting to hear from someone directly who's familiar with systems from back then. Looking at LINES, the file doesn't seem to contain only printable characters (from an UTF-8 perspective) - so I guess there's a bunch of control characters in every line. Looking at TITLE.. at least the very end looks like assembler mnemonics. Again surprised, because why would you ship them in this encoding? Was runtime compilation of assembly a thing?

Thanks for elaborating on the details! Is this actually you(r blog)? https://lukazi.blogspot.com/2014/07/lego-legos-first-programmable-product.html?m=1 — If so, I didn't get it until now. Thanks for sharing the instructions! I am most excited about the robot arm 1090 E), the crane (1092 E) and the plotter (1092 A) models. Thanks for sharing the zip/pdf files. Unfortunately 1092 E seems incomplete. It's really interesting how LEGO had multiple plotter models — interface A, Technic Control Center and also interface B I guess? I had played around with Technic Control Center's plotter model and used it with the RCX earlier this year. Cheers Edit: also thanks to everyone for having good hints about fixing the wobbly cable connections! PS: Thanks for pointing me to the C64 and Apple ][ disk files. I knew about them and had extracted the save files and uploaded them as examples in the git repo. They do work with BRICK Lines out of the box.

Hi all, I am happy to tell you that BRICK Lines works now... also for reading the inputs. I've committed the @Toastie's slightly modified code to the git repo and added the pinout details here: https://github.com/maehw/BrickLines/tree/main/hardware/serial2parallel_converter I've also fixed the always-serial-write-then-serial-read mechanism in BRICK Lines. I can still observe that the first character sent to the Arduino is not properly "echoed". (Actually ASCII capital letters A, B, C, ... make up for a good binary testing patterns as A = 0x41 which is masked to 0x01, B to 0x02 etc). I am not 100% sure if this is due to sending the first character very soon after the serial connection is opened... or this is a platform-specific problem on my macOS machine. However, not a big deal as I've implemented a workaround for this. Thanks for pointing out that the input can be shorted and nothing will light up in magic smoke. This made it easy for me to test the inputs and make a special cable which I can plug in to simulate a touch sensor. This allowed me to load and execute LEGO Lines program BTEST: ┌ IN ───┬ OUT ──────────────────┐ BRICK Lines ├───┬───┼───┬───┬───┬───┬───┬───┤ │ 7 │ 6 │ 5 │ 4 │ 3 │ 2 │ 1 │ 0 │ ┌─ # ──┬─ LABEL ──────┼───┼───┼───┼───┼───┼───┼───┼───┼───────┐ │ 1 │ light │▒▒▒│▒▒▒│ 0 │ 1 │ 0 │ 0 │ 0 │ 0 │ │ │ 2 │ REPEAT │▒▒▒│▒▒▒│ │ │ │ 3 │ UNTIL │▒▒▒│ 1 │ │ │ │ 4 │ open │▒▒▒│▒▒▒│ 0 │ 0 │ 0 │ 0 │ 0 │ 1 │ 2 │ │ 5 │ close │▒▒▒│▒▒▒│ 0 │ 0 │ 0 │ 0 │ 1 │ 0 │ 2 │ └──────┴──────────────┴───┴───┴───┴───┴───┴───┴───┴───┴───────┘ BTW: I also thought about embedding a LEGO Lines program to BASIC code and/or TClogo code converter into BRICK Lines. Let me know if you'd find this useful. :) I think the cable-motor or cable-lamp connections do not work very reliably. It seems that for some cables (or light bricks?) I need to wobble to get a connection. Especially for motors... the vibrations can loosen existing connections. Any helpful hints if this is normal wear-out, has always been like this or something else? Next logical step would be to re-create models for LINES and play around with them. Do you know which instruction manual I'd have to look at (and check if I have those bricks available here)? Can you tell if the instructions for LINES and TClogo used the same models or different ones? PS: I'd be happy to join a call but I'll be at 38C3 congress in Hamburg during the last week of this year.

Thanks for the motivating words, @Toastie! Sounds good, let's give Daniel some more time until February until we start asking how the floppies are doing. That seems to be a good attitude. I am happy to tell that today, I've been able to use my Interface A for the very first time. I've got a DC power supply which does the trick, I've also got an Arduino Nano which still works and some wires. Thanks to your Arduino software and my preparations in BRICK Lines, this was quite a quick starter. (I haven't tried the TC Logo version modified for the serial interface yet. Also no DOSBox-X experiments so far.. I am running BRICK Lines on native Windows, Linux and macOS.) You can find the BRICK Lines software on GitHub: https://github.com/maehw/BrickLines - it's free and open... (MIT license). (It comes with a README.md!) This is where I'd also like to add the Arduino code snippet which does the serial/parallel conversion. As the code is originally yours, I ask you kindly to license it under MIT as well, so that I can add it along with some pinout/hardware wiring info which I added. I also think that the software still has a small bug where I can see issues when applying outputs for the first time. This might not be visible when outputs are set using TC Logo at a rate of 1 kHz but it is in (BRICK) Lines where outputs are only set when specific instructions are executed (all that are not equal to LEGO Lines keywords). I'll try to narrow this down and report with more details. There may also still be a bug in my code and/or wrong assumptions. It already seemed suspicious to me when I tried to talk with the Arduino with a serial terminal and it replied with different characters when I typed in the same character several times... As you may have guessed, I only do have the Interface A (70455, i.e. the later 1987 version) without any cables or interface cards -- only the Arduino Nano as USB-to-parallel-adapter. Sorry, I think I did not make my point clear... or should have rephrased my question. Your code does a `Serial.write()` for every `Serial.read()`. This implies that code running in the machine is always writing outputs before it can read the inputs - because serial is async. This brought up the following questions/assumptions: Does TC Logo write the outputs before it does read the inputs? Always? LEGO BRICK Lines can have instruction that only depend on the inputs (conditions such as `IF` or `UNTIL` or the `COUNT` statement). There's no need in setting the outputs before. Of course, to make this compatible with BRICK Lines, it could adapt the behaviour working with TC Logo and just re-transmit the last-known outputs it has set before to be able to receive the current input levels. (Note: Oops, that's actually what I should have added in the Python code here: https://github.com/maehw/BrickLines/blob/8ba5b78e233419ed867500548f6be82b21c972c7/brick_lines.py#L456 - it seems that I have tested outputs-only programs so far! Probably because I do not have received any sensors so far (neither touch nor opto)! Expected behaviour until I modify the code: the program should get stuck because it's waiting for a receive byte which never comes... and it's a blocking serial receive function.) As this "need to write outputs in order to know the inputs" dependency may be problematic/unintended (see 2), I asked myself if it would also work when the Arduino Nano polled the inputs regularly (or implemented edge detection on the two pins) and sent the data periodically (at the polling rate; or event-based when an edge = level change has been detected). But: this could result in many many bytes being sent from the Arduino to the PC without being read from there... and could overflow a receive buffer until `receive()` is called. But this might not be a problem for "old serial" interfaces which just overwrote a single byte buffer and it was the application's responsibility to read the received input data just fast enough before it got overwritten by more recent data. Not clear if this description let's you get my point... I'd be happy if some of you would like to try BRICK Lines. But it requires the Arduino Nano serial/parallel device as a hack... and so far I am only aware that Toastie has this and somebody else attempted to build another one for themself. So maybe this is a 2 people world only so far.

Hi all, a short update from my side! I had contacted both authors Helmut Albrecht and Herbert Hödl. I've gotten a reply from Helmut who seemed very nice and helpful - however, no software files in the end. And Helmut also mentioned that he was in touch with you Thorsten and Evan. Regarding the book and its floppy, I must confess that I had made some wrong assumptions: I was thinking that it contained the MS DOS/IBM PC version of LEGO Lines. But nope, of course not. You had to have LEGO's master flopy along with the license to make copies. So the book's floppy "only" contains programs I guess - still very valuable and I'd like to get access. I found out that the German national library in Frankfurt actually does have the book. It seems that due to legal reasons, they don't want you to copy the floppy contents - or at least you should not get caught when doing so. Well, maybe some day... I haven't contacted TLG about LEGO Lines - as you've written that this likely is a dead end. But: Some weeks ago, I found the precious LEGO Lines floppy for DOS on ebay by a German seller. As at the time I didn't have the equipment to read old 5.25" floppies, I got in touch with Daniel Schmatz (the guy from eitle kinderkram/YouTube mentioned above). Also: it comes with a pile of paper for use in schools (DACTA 950026), so I think Daniel is the best fit with his "museum" near Vienna. In the meantime I do have a 5.25" floppy drive and a Greaseweazle and cabling. I am missing a power supply and some more time, though. Daniel got the floppy and may read it some day using his old equipment - he might be willing to read and archive it by himself or lend it for archiving, we will see. In the meantime, I got myself an Interface A including a ribbon cable, two motors and IIRC opto-sensors and lights should be on their way. I haven't unpacked everything yet even though I am every excited to try things out soon! And I still need an AC or DC power supply - though I probably have one that already fits. Also: I have started to re-create LEGO Lines using Python and am willing to share it - probably another software I've written which the world has _not_ been looking for. It will be able to import Commodore and Apple ][ LEGO lines files and run them (I tried to understand the save file formats and fortunately, they are not that complex). The following screenshot shows my remake "BRICK Lines" on the left and the LEGO Lines software for Commodore (C64, C128, ...) on the right. Interestingly, the Commodore and the Apple ][ versions look completely different and also have different sets of functionalities! Still curious about the DOS version... I might even add functionality to edit your own programs if I or anybody else is willing to use this. I am aiming to use this with a USB/serial converter - so this could run under Windows, Linux and Mac OS! I will base it on @Toastie's Arduino project. But this finally leads me to some questions concerning the serial interface: * The project assumes that before the input ports are read, they are always written. Is this how TC Logo works? Has this been confirmed to be working with other LEGO Interface A software? * How do the emulated serial ports work? Would it also be an option that the Arduino detects edges on the inputs and sends them? Or polls the pins every millisecond and just sends an update? Or would the serial buffer in the emulated DOS machine "overflow" because the software does not read them? Or would it just.. work? * Would the old parallel ports be able to detect edges on the input pins or were they polled (e.g. every millisecond as this is the frequency which as been observed with PWM)? * A general Interface A question: did I get this right that the PC must feed a 5V voltage back into interface A to power LEDs or something or am I mixing things up here?

Thanks. Yeah, I anyway contacted Evan. Actually, there's a German book called "Steuern und Regeln mit LEGO Lines und dem LEGO TC Controller" (1989/1990). It's also avaliable on the archive.org website IIRC. I am currently trying to reach out to the authors from back then. It mentions an IBM compatible disk but also that LEGO Lines had only been available for two types of machines — but does not mention which ones (edit: from the details in the chapter: it is Commodore C64 resp. the IBM PC running DOS). This would not match with the info from above. But it's still possible that the software has been posted to other machines. Who knows.

Hey all, I am asking myself if anyone has access to LEGO Lines for the IBM PC/DOS? http://lukazi.blogspot.com/2014/07/lego-legos-first-programmable-product.html mentions it with number 9537 as "the IBM-PC version" -- so it must have existed https://archive.org/details/vintagelegorobotics currently lists versions for the BBC Micro, the Apple II, the C64.. but not the IBM PC https://lgauge.com/technic/LEGOInterfaceA/9750(1093).htm is "very much interested in the IBM (DOS) software, if anyone has it for download or even the original diskettes" Is this piece of software really lost? Or maybe only slumbering on floppy disks in attics? Has it really not found its way to the interwebs? I'd really like to see this piece of software running in DOSBox-X as well.

This is not a sponsored ad — I just thought that this might interest some of you: >Do you like Lego? Do you like the Apple IIe/IIgs? > >Blocko is an interface card that allows you to control Lego Technics machines with the LOGO programming language, just like we did in elementary school! > >Available in November 2024 > >https://blocko.net

Wow, what a nice thread! Thanks everyone for sharing their knowledge, insights, experiments and so on! While reading through the thread and before stumbling across @Toastie's diagrams, I've started to create my own one to get an overview of the hardware+software from that era... as I am more a "visual learning type": This may be wrong (please help me fix it) - and for sure is incomplete. Also special thanks to @evank for publishing videos! Do you have an update on the Philips P2000? And: are you still wanting to sell a hardware bundle? If I find time - and a 9750 - I'd like to use @Toastie's approach with a USB/serial converter + an Arduino acting as serial/parallel converter + DOSBox-X + @alexGS' modified TC Logo version for the serial port (on either Mac OS, Linux or Windows - preferably one of the first two)... and also see if there's other software we can run (or bring it to the browser such as I tried with WebPBrick). Cheers!