- Manual del usuario (Spanish, PDF) and its sources for Libre Office (ODT). This is the official User’s Manual in Spanish, equivalent to this online documentation. The ODT file can be modified by the users with a very permissive license.
- Curso de Robótica, guía de teoría y actividades (Spanish, PDF). This is a complete tutorial with a lot of examples (using both Arduino and Minibloq), published by RobotGroup.
- Minibloq + Arduino (Spanish, PDF). This is a guide full with examples written by José Manuel Ruiz Gutiérrez.
- Sparkfun Inventor’s Kit for Arduino tutorials (English, ZIP). This is a package containing PDFs, ODTs (LibreOffice sources for the documents), and Minibloq code.
- Control e robótica (Galician, website). These are nice online tutorials on automation and robotics using Minibloq, written by Antonio Lomba.
Minibloq is a graphical programming environment for Arduino™, Multiplo, physical computing devices and robots. One of it’s main goals is to bring closer physical computing and robotic platforms to primary schools, kids and beginners. If you want to see a short intro, you can take a look to the video used for the Kickstarter campaign.
3. Getting started
Minibloq runs under Windows (XP, Vista, or Windows 7) without installation. Just download, unzip (you can use 7-Zip) and run MinibloqRun.exe. It even runs from a flash drive. The only extra software you may need to install, are the drivers for the specific boards you want to program (DuinoBot, Seeeduino, Arduino™…). Every board may come with it’s own driver installation instructions. For a list of supported boards, please read the section Supported hardware below (Minibloq also includes the drivers for most of the supported hardware in the \Components\Drivers directory). There are some known issues, as you can read here (recommended).
Minibloq runs under Linux using Wine. It’s being tested on different Linux flavors, but mainly in Ubuntu and Fedora (specifically, the version of Fedora deployed with the OLPC XO). Since Minibloq is a native application, and since Wine doesn’t do any CPU emulation (hence the name “Wine Is Not an Emulator.”) the performance under Linux is good (more on this here).
Here are the steps (thanks Marco André Ferreira Dias!) to run Minibloq under Ubuntu (the OLPC XO has it’s own subsection below):
sudo usermod -aG dialout
sudo ln -sf /dev/ttyUSB0 ~/.wine/dosdevices/com1
sudo ln -sf /dev/ttyACM0 ~/.wine/dosdevices/com2
is not literal, it’s your own user name.
- In the example, “Minibloq.v0.8.Beta” must be replaced with the name of the current version (or the version you have downloaded).
- Please take into account that the first command (sudo apt-get install wine) may take some time to finish.
- The winecfg command will open a window. To start with, it’s not necessary to configure anything in that window, but you have to run the winecfg command anyway.
- With the previous commands, COM1 represents an Arduin Duemilanove and COM2 an Arduino™ Uno. Other boards may be listed with another name in the /dev directory.
- On openSuse, the command to install Wine will be yast2 –install wine (the other commands were not tested yet).
- There are some known issues, as you can read here (recommended).
Here are the steps to install Minibloq in the OLPC XO:
1) Switch to the GNOME interface (NOTE: Not all the OLPC XO computers come with this software installed from factory).
2) Ensure the laptop has Internet connection (more information about this here).
3) Install Wine:
yum install wine
sudo ln -sf /dev/ttyUSB0 ~/.wine/dosdevices/com1
sudo ln -sf /dev/ttyACM0 ~/.wine/dosdevices/com2
4) Copy your Minibloq zip file to a flash drive.
5) Plug the flash driver, and copy Minibloq zip file to some place in your OLPC laptop.
6) Unzip the file (you can do that with the “Archive Manager” -that appears with a right-click on the zip file-).
7) Right click on the MinibloqRun.exe file and click “Open With Wine Windows Program Loader” from the context menu.
Please read the notes in the Linux section above (they are also valid for the Linux deployed OLPC XO). There are some known issues, as you can read here (recommended).
Ulises Mendoza, from Spain, has been working on a Wineskin wrapper for Minibloq. Thanks Ulises! Here are the steps to get Minibloq running on Mac OS X (the screenshoots were also taken by Ulises). Please take into account that this is a preliminary work:
1) Download Wineskin.
2) Install Wineskin.
3) Download WineBottler.
4) Install WineBottler.
5) Install the Wine version that comes with WineBottler.
6) Downlad Minibloq (Wineskin wrapper version).
7) Run the wrapper (just like a native app: double click on it -you may see something like a “path error”, but, at least in the tests, it wasn’t important-):
Ports: The wrapper was preconfigured to use the /dev/tty.usbmodem411 port, which belongs to an Arduino Uno installed on the computer used for the tests. This may change from computer to computer, and it may change also depending on the board to be programmed. If you don’t know wich port is used for your hardware, a good way to detect it, is by using the Arduino IDE’s menu Tools->Serial Port. Once you know that, you can create a symbolic link (you will need to open a terminal for this). For example, in our case, we used:
ln –s /dev/tty.usbmodem411 com1
This will create a link (called “com1″) in your personal folder, as shown below:
So now, you will need to copy it to the wrapper (this means inside the wrapper). To do this, you can right click on the wrapper, and select “Show package content”:
The link must be copied into Contents/Resources/DosDevices:
Here is a screenshot of Minibloq running:
We hope we can improve and simplify the installation process in the future. There are some known issues, as you can read here (recommended).
Minibloq is under development. These are the implemented features in the last working version:
- Easy: Just a few clicks and your first program is running.
- Real-time code generator: It creates the code while you are adding blocks or modifying param values, showing the code in a syntax colored window. This way, Minibloq facilitates the transition to text-based programming.
- Real time error checking.
- Basic drag& drop with autopan.
- Advanced interface: Zoom, cut and paste, dockable windows, and keyboard navigation are just some of the Minibloq GUI’s features. And there is more…
- Embedded terminal: There is an embedded terminal that lets you send and receive data to your board through serial/USB ports.
- All-in-one-ready-to-use-solution: This is “batteries included software”. The package includes everything to start working.
- Portable: It does not requires installation (except for the drivers required for specific boards, like Arduino™). It can run from a pen drive too. Oh, and it runs completely off-line, all in your own computer. More: You can have parallel copies of Minibloq, even with different settings running in the same computer.
- Fast: I’ts a native application, compiled with C++ (gcc), using wxWidgets. For this reason, Minibloq is suitable for low end computers and netbooks. And, it also includes precompiled cores, it builds and downloads your programs really fast. Try it!
- Modular and expandable: The user can easily create it’s own new blocks.
And here are two more videos (showing real time error-checking in the variables subsystem, etc.):
- Free and ¡with sources!: The program will be available for free, in its full version. No fees for advanced features or the like. Just download and start using it. In addition, the full source code will be available too. The license? Something called RMPL (RobotGroup-Multiplo-Pacifist-License). This license is basically a MIT license, but with a restriction that bans military projects. More on this below. By now, you can see the Spanish version of this license here.
- Easy integration with new hardware: Adding support for new platforms and boards will be straightforward. This may be not a feature for beginners, but it will not be so difficult anyway. Even different compilers and languages could be added.
- Internationalization: The first release will be available in English and Spanish, but the user and the community can contribute with new translations, since this only implies editing a text file.
We have a lot of ideas for the future of Minibloq. Stay connected!
Here is a screenshoot of Minibloq’s main window, as seen when it starts the first time:
In this window you can select both the type of board and the port to which that board is connected. It shows a simplified board image, with labels showing where to connect some external hardware (like certain kinds of sensors, motors, etc.). We are working to make these connections user-configurable in the future, but most of them are fixed in the current software version. This window is dockable and to hide or show it, you can both use the View->Hardware menu or press Alt + H:
6.4. Component Editor
This terminal features zoom (by now, it only works by holding the Ctrl key while moving the mouse wheel). And you can send text as well as receive. The terminal has two views: Single (default) and Split. The only difference is that in the Split view, the sent characters appear in a different text box. Both in the Single and in the Split views, received text will be shown in green, while sent text will be in blue (these colors will probably be user configurable in the future).
6.9. Generated code viewer
Every change you made in the Component Editor is inmediately reflected on the Code Viewer. Green dots will appear on the right margin, between the first and the last modified lines (this behavior may change in the future, but by now it helps to easily see the changes in the code). The generated code can be copied, and there is even a context menu (in English, because that menu has not been internationalized by now). The generated code can also be found easily: go to the menu Component->Open folder (or press Ctrl + D). It will open the component’s folder. Inside that folder there is a subdirectory called: ComponentName_Files/Output. Inside it you will find a pde file (along with the final hex and other intermediate files).
There are blocks that are included in Minibloq’s official distribution. But the blocks can be added, modified or deleted by users. We will improve the way to add and edit blocks in future Minibloq releases. For a detailed description of the blocks currently deployed with Minibloq, please see the Blocks page.
Minibloq has to be simple. As simple as possible. There are a lot of sensors supported by the environment, but most of them can be read with the AnalogRead or the IOPin getter (equivalent to digitalRead()) blocks:
But when a sensor requires specialized code, there is a sensor block in the appropiate picker (note: some of the following blocks will be present in the next Minibloq version, so they are not available in the current v0.8.Beta):
7.3. Analog values
All the values in relation with analog devices have (in general) a range from 0.0 to 100.0 (always in floating point). Here are some examples:
- The PWM (or AnalogWrite) block receives a parameter between 0.0 and 100.0 to specify the duty cycle.
- The Motor block receives a parameter between -100.0 and +100.0 to specify the speed (in fact, it’s a duty cycle for a PWM signal). The sign determines the direction of rotation.
- All the analog sensors (except some specific sensors, like the rangers which work in metric units) return a value between 0.0 and 100.0.
- It’s more hardware independent. You don’t need to worry about the resolution of the analog to digital converter (ADC), or about a PWM’s resolution either. Minibloq aims to be a multihardware IDE, so this will let the user to write more portable code.
- In general, this results in more compact code when the program has to use an analog input value to set an analog output:
- We think the code is clearer, since you can think in the concept of a percentage, rather on a power of 2 (like the ranges 0 to 1024, or 0 to 255).
Minibloq verifies most errors in real time, marking them with red. Here are the cases detected by the environment:
Wrong formatted numbers
Although non valid chars can’t be typed in numeric fields, it’s still possible to write a wrong formatted number. Minibloq will show it in red:
There are errors that are implicity prevented with Minibloq. For example, it’s not possible for the user to confuse the operator “=” (assignment) with the operator “==” (comparison), since the environment will generate the right code automatically. Other common errors, like forgetting a “;” are not possible either. Due to the contextual pickers, it’s also imposible for the user to add wrong data type parameters to a block. Finally, upper and lower case errors are also prevented automatically, thanks to the automatic variable name management (see next section).
8.2. Automatic variable name management
This is a very important feature, since it prevents a lot of potential syntactic errors, wich is a main goal in graphical programming. Minibloq detects automatically when a variable name is changed by the user (in a declaration), and updates all the ocurrences (both getters and setters):
9. Supported hardware
Minibloq is an environment that can work with different boards and hardware. Here you will find a list with the boards that can be selected by name in Minibloq’s official distribution (we call them “directly working hardware”):
Arduino™ Duemilanove Mega328 (tested with a clon)
Arduino™ Duemilanove Mega168 (not tested)
Arduino™ Mega 2560
Arduino™ Mega 1280 (tested with a clon)
Seeeduino v2.2 Mega328
Seeeduino Mega 1280
Maple Rev 5 (preliminary)
Maple Rev 3 (preliminary)
ATTiny25/45/85 (preliminary, with AVR-Doper programmer or with ArduinoISP)
There are boards that, although not listed on Minibloq’s GUI, may work selecting another compatible board from the list. Some of them will be mentioned here, with the board that must be selected between [brackets]:
Arduino™ Mega ADK [Arduino™ Mega 2560] (not tested / no USB Host support)
Arduino™ Diecimila [Arduino™ Duemilanove Mega168] (not tested)
Arduino™ Nano Mega328 [Arduino™ Duemilanove Mega328] (tested with a clon)
Arduino™ Nano Mega168 [Arduino™ Duemilanove Mega168] (not tested)
More hardware will be added to the list of supported boards. We are working to have a future Minibloq version which will enable advanced users to add more hardware by themselves.
The idea is to provide full keyboard navigation in the future. By now, these are the implemented shortcuts:
- Alt + Delete: Deletes the selected block.
- Alt + Arrow keys: Moves the current block.
- Alt + Home: Goes to the first block in the same line.
- Alt + End: Goes to the last block in the same line.
- Ctrl + Home: Goes to the first block.
- Ctrl + End: Goes to the last block.
- Ctrl + Arrow keys: Scroll.
- Ctrl + Alt + Home: No matter where you scrolled the program, this restores it to home position.
- Ctrl + “+” / Ctrl+”-”: Zoom in / Zoom out.
- Ctrl + 0: Restores zoom to 100% (just like some web browsers).
The shortcuts for Minibloq’s menus will be the same, regardless of the selected user interface language (some programs change their shorcuts if the user selects Spanish, English, Italian, etc., but that’s not the idea with Minibloq). Here are the current shortcuts for menus:
- Alt + F: Unfolds the File menu.
- Alt + E: Unfolds the Edit menu.
- Alt + C: Unfolds the Component menu.
- Alt + V: Unfolds the View menu.
- Ctrl + O: File->Open.
- Ctrl + S: File->Save.
- Alt + F4: File->Exit.
- Ctrl + X: Edit->Cut.
- Ctrl + V: Edit->Paste.
- Alt + Del: Edit->Delete.
- Ctrl + U: Component->Run.
- Ctrl + R: Component->Build.
- Alt + D: Component->Open folder.
- Ctrl + H: View->Help and Resource Center.
- Alt + Q: View->Quick toolbar.
- Alt + G: View->Generated code.
- Alt + H: View->Hardware.
- Alt + M: View->Messages.
- Alt + T: View->Terminal.
10.3. Mouse and mouse wheel
If you have a mouse with mouse wheel, this are the possible usages in the Component Editor:
- Mouse wheel only: Vertical Scroll.
- Mouse wheel + Shift: Horizontal Scroll.
- Mouse wheel + Ctrl: Zoom in / Zoom out
- Left click over a block: Selects it as the current block.
- Right click over a block: Displays the context menu.
- By pressing the middle button (or the wheel in most modern mouses) over the Component Editor’s background, you can drag the complete set of blocks in your program.
Other GUI elements also have actions associated with the mouse wheel and with mouse clicks. The following applies to the Code Viewer (or “Generated code window”), the Terminal and the Messages window:
- Mouse wheel only: Vertical Scroll.
- Mouse wheel + Ctrl: Zoom in / Zoom out
- Right click over the background or over selected text: Displays the context menu (NOTE: This context menu does not support internationalization by now, so you will always see it in English, no matter which language is selected in Minibloq’a GUI).
11. Development tools
- Minibloq’s forum.
- Arduino English forum thread.
- Maple forum thread.
- Sparkfun forum thread.
- RoboCore forum thread.
- AVRFreaks forum thread.
- Adafruit forum thread.
- Lets Make Robots forum thread.
- Foro de Minibloq (aunque está en inglés, se puede postear en Español, por supuesto).
- Foro de uControl.
- Foro de TodoPIC.
- Seeedstudio’s Blog (2011.10.27).
- Seeedstudio’s Blog (2011.05.04).
- Arduino’s Blog.
- Four Walled Cubicle (LUFA’s home).
- tecnoloxia.com (Tutorials using Minibloq, in Galician).
- BricoGeek (Español).
- Hack a Day (2011.04.15).
- Hack a Day (2011.10.16).
- Maker Masters (2011.10.24).
- Maker Masters (2011.09.20).
- Maker Masters (2011.09.13).
- Maker Masters (2011.09.11).
- Maker Masters (2011.07.07).
- Maker Masters (2011.06.17).
- Maker Masters (2011.06.09).
- Maker Masters (2011.06.02).