The World’s Cheapest Computer. Prices Start At $20

Olimex's new web shop has been so successful, that dealers are feeling the pinch, so we have decided to sell off all Olimex stock at 30% off the normal Olimex retail prices. This includes all Olinuxino  and DuinoMite boards.

So don't spend time hunting down the best prices. The best price is right here.

This will bring the price of a Olimex-iMX233-OLinuXino-Micro down to $24.85AUD (approx. $22.70 USD) (plus gst if applicable.)
This will bring the price of a DuinoMite-Mini down to $20.65AUD (approx. $18.80 USD) (plus gst if applicable.)

http://www.dontronics-shop.com/olimex-ltd.html

Dontronics has been in business since 1964.
 


DuinoMite, the Dynamite MaxiMite Compatible from Olimex.
By Don McKenzie.

All DuinoMite boards can be purchased from: http://www.dontronics-shop.com/the-maximite-computer.html

Don's DuinoMite Discount Deals
Around $25 for a complete computer system, such as the DuinoMite-Mini:

http://www.dontronics-shop.com/olimex-duinomite-mini.html

Prices start at around $25-$50, just add PS2 keyboard, VGA Monitor, or TV. Runs BASIC language, or C. Save programs to uSD card, or internal flash memory. Or simply run via a terminal program from any PC. Arduino Shield foot print on many boards.

 

INTRODUCTION:

DuinoMite is a MaxiMite Compatible Basic computer, originally designed by Geoff Graham, with additional features and Arduino shield like layout. DuinoMite allows you to program in the BASIC language and have VGA and Keyboard interface, so you can develop and write your code in Basic without the need of any computer. You can store your code on the SD-CARD and execute it on power up though autoexec.bas main code. BASIC programs can easily be exchanged and saved to a PC using either a terminal program and a USB connection, or the SD card. An internal flash memory drive can also be used to save up to 256K of programs and files. Development can be done on the USB only connection. Fantastic user support via a very active user forum group.

COMPATIBILITY:

SOFTWARE:

The BASIC is 100% software compatible with the original MaxiMite Version 2.7a, however additional commands and features have been added to the DuinoMite.

HARDWARE:

On the MaxiMite, you have access to 20 external I/O connections, compared to a possibility of 22 on the DuinoMite.

There has been BASIC commands added to control both the SD card, and VGA settings for the five pins that are shared on the DuinoMite. However with the internal A: Ram drive, the shared pins of the SD card shouldn't be of any real concern in most cases. With control over both the SD card and the VGA, this means the full 22 GPIOs can be accessed for most applications.

See: http://www.duinomite.com/duinomite-how-many-gpios-can-duinomite-drive-independantly/

The DuinoMite uses three real UARTs at full speed. There are no real UARTs in the original MaxiMite design, as all serial I/O is bit banged.

UEXT:

Olimex have designed a special serial port using a 10 pin IDC header. It is available on all DuinoMite boards. In fact, the MEGA has two. One internal, and one external. The DuinoMite is capable of high speed data transfers via this serial port, and carries UART serial communications, SPI, and I2C protocols. The I2C protocol is in theory, capable of having 100+ boards cascaded to the 10 pin IDC header, via a flat ribbon cable daisy chain.

For more information:

http://www.dontronics-shop.com/duinomite-uext-boards.html

http://olimex.com/dev/OTHER/UEXT.pdf

PDF Manual:

The DuinoMite manual currently is 230 pages and growing. The origional MaxiMite manual is 37 pages.

All DuinoMite Documents Link

PRICING and QUALITY:

You will find MaxiMite kits on the market with prices right up to $90. There may be $20 or less worth of parts, including the case. These parts are nothing special, however the retail margin certainly is.

DuinoMite assembled boards can be as little as a third of this price in some cases. And all Olimex DuinoMite boards have carefully selected components to work reliably in an INDUSTRIAL temperature range -25+85C so the board can be used in INDUSTRIAL applications. Check the voltage regulation, and low power battery operation for each board. (NOTE Mini board only has +5 Volt input).

MODES OF OPERATION:

MODE 1 Stand Alone:

Run as a PC, by attaching a VGA monitor, or TV, and a PS2 Keyboard. Save files to the SD card, or the internal flash drive.

MODE 2 Terminal Mode from a PC:

Use any computer that supports a USB port, and a Terminal program, and you can run BASIC Programs, and develop directly from your computer. Save files to the SD card, the internal flash drive, or your PC.

MODE 3 Any combination of the above:

You can run two keyboards, and two screens in parallel, or remove any single item, and the unit will still operate. If you are running the standard DuinoMite board as a controller, and you don't need a keyboard, or screen, you can disconnect the IO board completely.

FEATURES: (Check individual boards for correct specifications as not all boards have all features.)

  • PIC32MX795 microcontroller
  • micro SD card
  • USB OTG which allow it to act both as Host and Device, so it can accept Android ADK, Printers, Cameras, Keyboards, Mouses, etc USB devices.
  • VGA connector
  • Composite Video connector
  • CAN driver and connector
  • RS232 driver and connector
  • two UEXT connectorsallowing Olimex modules to be connected one inside the box one outside the box
  • PS-2 keyboard
  • Audio output connector
  • Arduino like format i.e. can work with Arduino shields

DOCUMENTS:

Unfortunately Olimex provide links to files and documents on their product pages, that are file name specific, instead of simply pointing to a directory. When they update a version number for instance, the link is broken, and so is every link on the web that every dealer that has gone to the trouble of placing. I have to edit those links when I get customer complains. As such, I don't intend to chase new links for DuinoMite, as I believe there will be many. I would rather edit an external link, or upload a new file, than to edit multiple products all the time. Please let me know if my file or link is out of date.

All DuinoMite Documents Link

HARDWARE:

The DuinoMite versions will have additional features because of the hardware serial ports ect., plus any other new features Ken Segler Designs, or anyone else adds, like the Full Screen Editor and Terminal program. If Geoff Graham wants to add these to the MaxiMite source, then in the spirit of open source, Geoff, or anyone can add it back into the MaxiMite firmware for the benefit of all users.

DuinoMite New Commands:

DuinoMite "help" Command:

Unzip and save the help zip files onto your SD card in B:\help and type "help" without the quotes.

 

DuinoMite "setup Command:

Type "setup" without the quotes.

 

DuinoMite, the MaxiMite Compatible

There are three new boards being produced by Olimex. Because of the re-mapping of the schematic, we have had to get software assistance with a new boot loader and get the existing MM-Basic firmware patched to match. I chose Ken Segler, (http://www.kenseglerdesigns.com) a Back Shed Forum regular, to carry out this task, as Ken has shown his proficiency with porting the MaxiMite code to other platforms, as well as adding many new routines to MM-Basic.

All DuinoMite boards can be purchased from: http://www.dontronics-shop.com/the-maximite-computer.html

New Boards:

Schematics and all other relevant files are available from:

http://www.duinomite.com/files/index.php?dir=Hardware%2FDontronics%2FOlimex%2F

 

DuinoMite-Mega:

http://www.dontronics-shop.com/olimex-duinomite-mega.html

This fits nicely into a plastic box 130mm x 100mm x 30mm.

The box will be laser cut to allow easy fitting.

Arduino footprint can be seen in the middle of the board, however to make use of this, you would need to remove the cover, or remove the board fully from the case. An external shield adapter board will be available, and is listed below.

DuinoMite Board:

http://www.dontronics-shop.com/olimex-duinomite.html

DuinoMite-I/O Board:

http://www.dontronics-shop.com/olimex-duinomite-io-board.html

This will be two boards that plug into each other with a small IDC flat ribbon cable. It was felt that the VGA and Keyboard connectors could interfere with any shields being added, because of the height of these connectors. It would also allow the board to be more readily used as a stand alone microcontroller without the extra connectors, if the user chose to do this.

Connector to the left of the DuinoMite board, is for the I/O board, and the one to the right is the UEXT Connector. More on this later.

DuinoMite-Mini Board:

http://www.dontronics-shop.com/olimex-duinomite-mini.html

This is without the Arduino shield and is built as a minimum low cost system, yet it will still run as a full Maximite Computer as both Keyboard and VGA connectors are installed on the front edge of the board. This board is 64mm x 50m

DuinoMite-Shield Board:

http://www.dontronics-shop.com/olimex-duinomite-shield-board.html

Can be used on either the DuinoMite-Mega, or the DuinoMite-Mini boards, to add the Arduino footprint to the 26 pin IDC header via a flat ribbon cable.

NOTE **** Shield Adapter Boards:

Dontronics DonDuino Cross was designed for the Maximite, however it will also work on the DuinoMite.

DuinoMite-Shield Board was designed for the for the DuinoMite range from Olimex, however it will also work on the MaxiMite.

DuinoMite Features:

These features will vary with board type, and possibly there will be various levels of component population, so that users may be able to order boards at reduced costs. Again, to be determined.

Standard features:

- USB

- VGA

- PS/2

- SD card

- GPIO 26 pin connector

- Audio connector

- Composite video connector

- User button, Reset button

- Two LEDs

Possible Additional Features:

(May not be fitted to all boards)

- Arduino connector with compatibe port arrangement i.e. SPI, I2C etc connected on proper pins to make maximal compatibility with Arduino shields

- Real Time Clock with battery backup

- RS232 connector and driver as host i.e. male DB9 connector as on PC

- CAN will open industrial and automotive applications

- USB-OTG functionality i.e. USB host/USB device, this is not so expensive but I think it important to have as will allow this board to be used as Android ADK as well, if you do not know what is this, it's easy way to interface Android tablets and phones, here is demo on Microchip site http://www.microchip.com/microchip.webcontent.provider/Video.aspx?id=HXhgJvFQ6v8

- DC/DC power supply to allow wide range 9-30V input power supply adapters to be used

- Li-polimer charger and battery connector, this will allow the board to work with Li-Po batteries

- UEXT enables WiFi, Zigbee, Ethernet, RELAY-IO, RFID etc modules to be connected

- Ethernet on board will just rise the cost, once we have UEXT we can connect MOD-ENC28J60 or MOD-WIFI to implement internet /ethernet connectivity.

NOTE ****

UEXT Connector is available on all boards.

Please Note:

Dontronics ships world wide at a current cost of around $12USD internationally for all packages. As an Australian company, we have no mechanism to charge VAT or any state taxes. As most items are low value, customs usually allows these items through. You will generally find our prices cheaper than places like Element14 (Farnell) and Mouser. Order today, we ship tomorrow. In business since 1964, and on email 365 days a year.

Firmware Alternatives:

How about a 12 pin GPIO DuinoMite that is a 100% hardware compatible MaxiMite?

DuinoMite hardware is now supported by Geoff Graham, the MaxiMite designer. Please note that this is limited hardware support, in as much as only 12 of the 20 IDC GPIOs are supported by Geoff's firmware, which is to be expected.

But it does give you a 12 pin GPIO Maximite at a third of the price.

It takes only a few minutes to do a firmware change from the DuinoMite hex file, to the MaxiMite hex file, and just as easy to roll it back into a DuinoMite, if you choose to do so. This means you can build it into what you want very quickly and easily, so you can choose the features you want.

This new MaxiMite version for the DuinoMite  is available for download from: http://geoffg.net/maximite.html#Downloads

Our thanks to Geoff Graham for making this available.

Wish to program the DuinoMite in C?

Olimex Pinguino IDE supports the DuinoMite even now. No need for a special linker script as there is one for the 795 already. Use the existing bootloader that is programmed into the board.

Tsvetan of Olimex.

The World's First Arduino Computer

I believe the DuinoMite-Mega version is the correct model to call "The World's First Arduino Computer", as it is not only boxed, but is a complete computer system in the true sense of the word. OK, you can't get to the Arduino footprint without an adapter, or taking the top cover off, but the shield footprint is there for users, if they choose to go this way.

But I know there will still be the knockers that will spin the facts around, and say otherwise. :-)

If one of these boards doesn't cover the definition of "Arduino and Computer", then nothing ever will.

And there may well be a user application that needs perhaps the CAN feature, as well as an off the shelf Arduino shield, so they may fit it all into a new case, or not even have a case at all.

Already the Maximite has been adapted to run TRS-80 Basic, as well as Unix, and there is no reason why it can't be used for C language development, the same as the Pinquino board has done in the past.

TRS-80 Model I, level II on a PIC32 See:

http://kenseglerdesigns.com/cms/sites/default/files/trs-80.jpg

for the thread:

http://www.thebackshed.com/forum/forum_posts.asp?TID=3937&PN=1

Maximite Computer now running Unix, 2.11BSD. Thread at:

http://www.thebackshed.com/forum/forum_posts.asp?TID=3925&PN=1

All DuinoMite boards can be purchased from: http://www.dontronics-shop.com/the-maximite-computer.html

Posted in News | Tagged , , , , , , | 7 Comments

DuinoMite MEGA and the CAN commands.

DuinoMite-MEGA and the CAN commands.

Posted with a view to promoting the CAN Bus commands on the DuinoMite-MEGA.
(Pronounced Dynamite)

DuinoMite-Mega

In July of 2012, John Lopez (username:opezjm2001) of Australia ordered a DuinoMite-MEGA from Dontronics, with a view to getting it running with the existing CAN bus commands resident in the DuinoMite firmware, and started this thread in the Prius chat room:
http://priuschat.com/threads/my-duinomite-mega-canview-v4-equivalent-project.112429/

I have been keeping a daily eye on the direction the thread has been going, but haven't been in a position to offer any real assistance, as I am not a C programmer, and don't use the CAN bus myself.

It has become a very lengthy thread, and as you will see, John Harding of the US (Username: JDH2250) became very interested, then committed himself to re-writing the CAN commands, as he explained in the thread.

I have had an email exchange with both Johns, and have added their comments below:

===============================
John Lopez (username: opezjm2001) -2012-09-07

Hi Don,
 
As you are probably aware John Harding's CAN implementation is still being debugged. Your summarisation is correct. Anyhow I will forward this email to John Harding so he can make a reply. I read how Geoff might attempt to modify the DuinoMite Mega to use colour. I hope he does. I think Geoff may still be holidaying.
 
Thanks,
john lopez
===============================
John Harding of the US (Username: JDH2250) -2012-09-07

Hi Don & John,

One additional thing to add is that the reason I started to look at Frank's code was to improve it so that we could better use the built-in hardware filtering of messages.  This reduces the amount of work that the BASIC interpreted code has to do and is an important part of making the CAN commands more powerful.  JLo and I both discovered these issues as soon as we got beyond the simple examples that were provided.  

I started doing these modifications to Frank's code – but hit a wall regarding licensing (which you know about).  Also, I was becoming frustrated with some of the ways Frank had coded things (they weren't bad but they made adding the features I wanted to more difficult).  So, at that point I abandoned Frank's code and re-wrote from the ground up.  

The new version has two major technical benefits (1) access to built in hardware filtering (2) dynamic memory management of CAN buffers.

The software is still in "beta".  Hopefully we'll get to a stable release in the not too distant future (mainly requires me finding the time to work on this).

Happy to answer any other questions (and like JLo I'm hoping for Geoff to figure out how we can get color on our DuinoMites, heck – I'd even settle for colour (which my spell checker says doesn't exist – ahh, to be an ignorant American!! ;-) )

All the best,
John H.

==============================

Original CAN libraries made by Frank Voorburg – http://www.feaser.com
https://github.com/OLIMEX/DuinoMite

==============================

I noticed John Harding posted a message on TBS forum:
http://www.thebackshed.com/forum/forum_posts.asp?TID=5167&PN=1
I will add a pointer on TBS forum back to this posting.

I will update this post if and when the need arises.

Don…

Posted in Applications, News | 4 Comments

MaxiMite-15Pin-DM-Mini

Product: 17011
All Dontronics MaxiMite Computer products are located at:
 
http://www.dontronics-shop.com/the-maximite-computer.html

MaxiMite-15Pin-DM-Mini

You want to join in the fun that users are experiencing with the MaxiMite computer, and be able to create hardware and software applications in minutes, and not hours or days, but the $90AUD for a kit, is far too high to even think about it.

How about an assembled and tested unit at about a third of that price?

There simply is no cheaper way of getting any MaxiMite up and running, unless you are building your own from scratch.

This product will have 15 GPIO pins compared to the normal 20 GPIO pins of a standard MaxiMite, but at a third of the price, you could actually have three talking to each other, and still have a lot more pins than a standard MaxiMite.

I believe that 85% of all home-brew hardware applications use 15 or less GPIO pins. See: http://www.duinomite.com/duinomite-ultra-budget-computer-system-for-slot-cars/ for what can be achieved with a 15 pin DuinoMite running under MaxiMite MM-Basic.

I hear you say: "This board looks suspiciously like a DuinoMite-Mini". It should, as it is a DuinoMite-Mini.

Geoff Graham has been good enough to compile a DuinoMite version of his MM-Basic for the DuinoMite, with the 15 pin GPIO limitation.

All you need to do is to update the firmware version from the factory version, to the latest MMBasic version for the DuinoMite, and use the Silicon Chip serial drivers.

DuinoMite Firmware Update Guide:
http://www.duinomite.com/duinomite-firmware-update-guide/

Geoff Graham's MaxiMite Page (for all documentation, manuals etc.)
http://geoffg.net/maximite.html
 
Geoff Graham's MaxiMite Download Page (for all files)

http://geoffg.net/Downloads/Maximite/

MaxiMite "The Back Shed" Support Forum:
http://www.thebackshed.com/forum/forum_topics.asp?FID=16&PN=1

All of these Dontronics DuinoMite Products can all be converted to 15 Pin MaxiMites:
http://www.dontronics-shop.com/olimex-duinomite-mini.html
http://www.dontronics-shop.com/olimex-duinomite.html
http://www.dontronics-shop.com/olimex-duinomite-mega.html

All Dontronics MaxiMite-DuinoMite Products:
http://www.dontronics-shop.com/the-maximite-computer.html

The original DuinoMite firmware still needs some work done on it before it can be considered stable.

It was initially designed to support the Arduino Shield footprint. The DuinoMite firmware uses the PIC32s internal peripherals for UART, SPI etc. and also adds a UEXT connector for another range of add-on peripherals.

If and when the DuinoMite firmware reaches a point where it covers your specific application, it is very easy to upgrade to the latest DuinoMite version, so you can test it as a DuinoMite. It is also very easy to roll back to make it a 15 Pin MaxiMite.

Please Note:

The DuinoMite uses the PIC32s internal peripherals for UART, SPI etc.

By setting this product up as a MaxiMite, you will lose the DuinoMite features, such as the software drivers that support the Olimex UEXT connector, and the real UARTs, as all of your UARTs will be bit banged in MaxiMite Mode.

 

The above table was provided by: Andrew Rich VK4TEC

Support:

MaxiMite "The Back Shed" Support Forum:
http://www.thebackshed.com/forum/forum_topics.asp?FID=16&PN=1

  1. Do you need additional support on this product?

  2. You can't find the information you need in the documentation?

  3. You wish to know what is included in the package?

  4. The download links on this product page aren't working correctly?

  5. Any questions not covered in the above list?

Then please click here.

A DuinoMite specific support Forum is also available at Ken Segler Designs.

The DuinoMite Newsletter Subscription page is at:
http://www.dontronics-shop.com/mailing-list-dontronics-newsletter.html
This will keep you up to date with DuinoMite Firmware and other News

 Back To Top
Posted in News | Tagged , , , | Comments Off

DuinoMite Firmware Update Guide.

DuinoMite Firmware Update Guide.
By Don McKenzie

DuinoMite range: http://www.dontronics-shop.com/the-maximite-computer.html

To update the firmware of the DuinoMite, you must first place the board into the update mode.

This can be done in one of two ways:

1) Hold the button marked "BUT" down, while you power up the unit. Release the button after you have powered up.

2) Hold the button marked "BUT" down, then press and release the button marked "RST", then release the button marked "BUT".

This should place the board into the update mode, and indicate it has done so by flashing the yellow and green LEDs alternatively at a fast, but visible rate.

Click on the picture below to view the video of these LEDs flashing in the update mode.

You will need some files from: http://www.duinomite.com/

If you have a look at the horizontal black navigation bar with the white text, you will see the word Files. Place your mouse over that, and click on Firmware.

Grab the file called: Olimex firmware updater & bootloader hex.zip

And also the correct serial driver files to match your firmware..

And store these in a suitable directory on your hard drive. You will need to unzip the first file after downloading.

You will also need to grab the latest firmware file. This may be in a file with either a ZIP or RAR file extension, and will also need unzipping.

You then need to run: HIDBootLoader.exe

 

If the board isn't in the correct mode, you will get the message below:

 

If the board is in the correct mode, you will get the message below:

 

You then need to select the hex file to update you board with.

 

Then select the Erase/Program/Verify Device.

 

After programming, the screen should look like this with no errors.

 

You can now hit RST, or power cycle the board, and you should be good to go.

With a bit of luck, your PC will ask for the serial driver location. You can point it to the directory you created for these files.

With a windows PC, you should be able to use Device Manager to point the directory that you downloaded the serial drivers to, and install them from there.

Both early version MaxiMites and DuinoMites had SD card problems. Microchip updated the SPI driver, and sometime around Jan-Feb 2012, both MM and DM had this new SPI driver, so most SD cards now work fine on both variants.


DuinoMite Early Version without Mass Storage Device:
(Possibly also factory default)

Looking with device manager, you should be able to see the following:


DuinoMite Latest Versions with Mass Storage Device:

Looking with device manager, you should be able to see the following:


MaxiMite:

You can also upgrade to Geoff Graham's MMBasic V3.x for the DuinoMite using the above method, however once you have done this, you have created a 12 pin MaxiMite, and the Silicon Chip serial driver must be used. This can be found on Geoff's site, along with the correct manual and other files.

Looking with device manager, you should be able to see the following:


Here is an alternative explanation for upgrading a DuinoMite Mini to the latest MM-Basic by Andrew Rich.
Perhaps this will help users still having problems with it.

See: http://www.thebackshed.com/forum/forum_posts.asp?TID=4982&PN=1 for the origional post.

How to re-flash a DuinoMite Mini

Remove all power from the board
Ensure the jumper EXT / USB is across "USB"
Now connect the USB cable to the board
You should have red LED and yellow LED ON
Hold down the reset button ( black ) AND then press the user button ( cream )
Keep holding down the USR ( cream button ) and release the black reset button.
As soon as you release the reset button, yellow and green LED flash back and forth
Run program "HIDprogrammer.exe" USB bootloader V2.90a for Olimex Boards
Program should say "Device Attached" "Connecting…." "Device Ready"
Files "import Firmware Image"
Select .hex file containing image.
Says "Opened: DuinoMite_MMBasic_V3.2A.hex"
Now "Program" , "Erase/Program/Verify" device
LED will stop flash, then flash some more
Bar will progress

//

Starting Erase/Program/Verify Sequence.
Do not unplug device or disconnect power until the operation is fully complete.

Erasing Device… (no status update until complete, may take several seconds)
Erase Complete (3.172s)

Writing Device Program Memory…
Writing Complete (6.109s)

Verifying Device's Program Memory…
Verifying Complete (141.469s)

Erase/Program/Verify Completed Successfully.
You may now unplug or reset the device.

//

Now reset ( black button ) and exit program
LED stop flashing, just yellow and red LED

- Andrew -

Posted in GPIO & Firmware | Tagged , , , , , , | 7 Comments

Duinomite Clock

Posted in Applications | Tagged , , , , | Comments Off

DuinoMite: Chop off keyboard USB connector and fit PS/2 connector

Chop off keyboard USB connector and fit PS/2 connector

Postby dangermouse » Mon May 07, 2012 2:17 am

For a while I've been using a cheap USB keyboard on my Duinomite together with a USB-to-PS/2 adapter.

There's nothing clever inside those little adapters, they're just wires inside.

So I chopped off my USB plug and fitted my own 6-pin mini-DIN connector. It reduces the bulk considerably and looks so much neater. Indeed, having the USB connector and the USB-to-PS/2 adpater looks unwieldy compared to the tiny dimensions of the Duinomite mini.

First I tested the USB-to-PS/2 connector to see what was connected to what. Here it is in colour coded form:

USB_PS2_adpater.gif
USB to PS/2 Adapter
USB_PS2_adpater.gif (24.48 KiB) Viewed 6 times

So using the same connection pattern, I connected up the freshly chopped cable to a new PS/2 style connector. The connector is available from many places, I got mine from Farnell:
http://uk.farnell.com/jsp/search/productdetail.jsp?CMP=i-ddd7-00001003&sku=152209

The wires on my keyboard were red, black, white and green. Be aware that other keyboards may use different colours or even the same colours but in different orders. So it's best to use a continuity check on the chopped-off-USB plug to see what connects to what.

Anyway, with my keyboard, I connected it up as so:

direct_ps2_keyboard_wiring.gif
Direct PS/2 keyboard connection
direct_ps2_keyboard_wiring.gif (10.79 KiB) Viewed 10 times

And the result is much neater than using the USB adapter:

new_ps2_connector.jpg
New lightweight keyboard connection
new_ps2_connector.jpg (151.79 KiB) Viewed 10 times

Cheers all,

Jez

 

 

 

 

 

User avatar
dangermouse
 

Re: Chop off keyboard USB connector and fit PS/2 connector

Postby Dontronics » Mon May 07, 2012 2:48 am

Nice Jez,

 

 

we chatted about this some time ago on the TBS forum. Here are some other thoughts:

http://www.thebackshed.com/forum/forum_posts.asp?TID=4308&KW=Keyboard+revisted
http://www.thebackshed.com/forum/forum_posts.asp?TID=3882&KW=USB+Keyboard

Cheers Don…

 

Posted in Applications, I/O | Tagged , , , | Comments Off

DuinoMite: 4×3 Keypad on 1 analog pin

-2013-11-30

The old Ken Segler site is up and down like the proverbial, so click on this link below for more detailed info:

http://www.thebackshed.com/forum/forum_posts.asp?TID=4941&PN=1

 

4×3 Keypad on 1 analog pin

Postby dangermouse » Sun May 06, 2012 11:04 pm

Continuing on my theme of getting the most out of a single pin as possible(!), here is a very simple way to monitor a 4×3 keypad (12 keys) using a single analogue input.

 

 

keypad_schematic.gif
Schematic of 12 key keypad going into 1 analog pin
keypad_schematic.gif (29.64 KiB) Viewed 16 times

The keypad is a standard 12 key type that is already wired as a matrix. It's easy to make your own too out of normal push buttons.

The 4 row wires and the 3 column wires are connected to a few resistors and that then presents you with a single pair of wires whose resistance is completely determined by which key is pressed. Using the values shown in the schematic, the keypad will give you a resistance from 0k to 11k in 1k steps for all 12 keys.

keypad_with_resistor_network.jpg
Keypad with resistors and just 2 wires
keypad_with_resistor_network.jpg (196.94 KiB) Viewed 16 times

By feeding the "keypad resistance" with a constant current source, you end up with a voltage that is linearly affected by the keypad's resistance. This ensures a good spread of voltages with equal steps between them.

keypad_constant_current_source.jpg
Simple constant current source for keypad
keypad_constant_current_source.jpg (68.35 KiB) Viewed 16 times

It is possible to do away with the constant current source and use a resistor instead but the noise immunity is much worse due to the bunching up of voltages at one end of the curve.

In this implementation it's not possible to sensibly identify multiple simultaneous button presses, but for a keypad, that is rarely required for most applications. A simple combination lock for example will never need more than 1 key pressed at a time.

Code: Select all
Cls
SetPin 1,1              'Pin 1 is analogue input
SetTick 10,timer_int    'Sample keypad every 10mS
Font #2,2

 

Do
  If keypress$<>"" Then 'This variable is set with a keypress on the keypad
    Print keypress$;    'Print the keypress on the screen
    keypress$=""        'Clear that keypress, ready for next one.
  EndIf
Loop Until Inkey$<>""

End

timer_int:            'This is called every 10mS to sample the pin(1) volts
                      'Only keys that generate 2 consequetively identical
                      'key codes will be considered valid.
                      'Jitter and errors are automatically eliminated.
                      'Valid keypressed are put into keypress$
maxR=11               'Max keypad resistance in kOhms
constcurrent=0.246    'Current source in mA
vkey=Pin(1)
keynum=Cint(vkey*11/(maxR*constcurrent))  'Convert to nice integer
keypattern$="2315648970#*xxx"             'Keymapping for keypad resistances
keyhistory$=Right$("xxxx"+keyhistory$+Mid$(keypattern$,keynum+1,1),4)
If Right$(keyhistory$,3)="xxx" Then keyoff=1
If keyoff=1 And Mid$(keyhistory$,3,1)<>"x" And Mid$(keyhistory$,4,1)<>"x" Then
  If Mid$(keyhistory$,3,1)=Mid$(keyhistory$,4,1) Then
    keypress$=Right$(keyhistory$,1)
    keyoff=0
  EndIf
EndIf

IReturn

The software measures the input voltage with a 10mS interrupt and converts it to an integer representing 0 to 11 (12 values). In fact a value of 13 is generated for "no key press". That integer is then converted to a specific key by using a simple string pattern and mid$.

The keypress is then stored in a rolling history string (called keyhistory$) that is 4 characters long and is updated every 10mS. This is used to eliminate errors, provide debouncing and to correctly identify the actual keypress event (and key release event).

Any keypress is automatically plopped into keypress$. So to get a keypress, just inspect keypress$ and see if it's null or not. If it's not null then it contains a valid keypress event. When you've got that keypress, make sure you clear it by keypress$="" to make way for the next keypress.

The program here simply shows this all working and displays the keypresses in big characters on the screen.

It works very reliably and has seems to suffer from no mis-reads at all, even with 10m of bell wire between the keypad(and resistor network) and the main circuit!

I hope it's of use to someone.

Jez

PS. This software is for MMBasic V3.2A (other V3.x may also work).

 

Last edited by dangermouse on Mon May 07, 2012 3:07 am, edited 1 time in total.

 

 

User avatar
dangermouse
 

 

Re: 4×3 Keypad on 1 analog pin

Postby dangermouse » Sun May 06, 2012 11:11 pm

I was limited to 3 attachments, so here's some more supporting piccies.

 

keypad_on_dm.jpg
Keypad, current source and DM. Note only 2 wires from keypad!
keypad_on_dm.jpg (178.42 KiB) Viewed 15 times

I know it's easy to fake, but here is a genuine screenshot after typing in a number very rapidly into the keypad. I really haven't been able to get it to fail, it reacts extremely quickly and without errors.

keypad_screenshot.gif
A familiar number. I know, it's very sad.
keypad_screenshot.gif (927 Bytes) Viewed 15 times

One more thing, to match the keypresses to the desired characters, I've used a simple string "mapping" in the program, the line is:
keypattern$="2315648970#*xxx" 'Keymapping for keypad resistances

As you can see, the key characters are in a slightly odd order, that's a result of the resistor/wiring order. Note also that I've made my keypad generate the star and hash characters too, therefore using all 12 keys.

Ensure the end of the string is padded out with some "x" characters as they are used to determine when no keys are being pressed.

I urge you to make one of these, it really is an easy way to get a keypad talking to the DM without worrying about keyscanning, debouncing etc. And only 2 wires between the keypad and the circuit. Oh, and only 1 I/O pin on the DM. I know, it's a small obsession I have at the moment. :)

Regards to all.
Jez

 

 

Posted in Applications, I/O | Tagged , , | 2 Comments

The evolution of DuinoMite, and the differences between MaxiMite and DuinoMite.

The evolution of DuinoMite, and the differences between MaxiMite and DuinoMite.

21-OCT-2011

It all started back on the 19th of July 2011, when Don McKenzie from Dontronics sent me an e-mail asking if we at Olimex were interested in modifying our PIC32-PINGUINO to run a Basic interpreter.

Don pointed me to the MaxiMite project (http://geoffg.net/maximite.html) which uses a PIC32 to generate VGA signals, and interfaces with a PS2 keyboard, so that you end up with a single chip, complete BASIC computer system. This project became very popular in Australia after a string of articles in the local Australian Silicon Chip Magazine, but hasn’t yet gained much popularity outside Australia. MaxiMite gives you the ability to write small embedded applications without using a PC, compilers, debuggers etc. All you need is the small one PIC computer plus a PS2 keyboard, and a VGA monitor.

Perhaps best of all is that Geoff Graham made the MaxiMite an open source software, and open source hardware project, so you can modify the code or the hardware, and make your own boards and firmware.

We liked the idea straight away, so we built a team inside of Olimex and started working on the schematic. There are three more people that got involved in the development: Don McKenzie and Mick Gulovsen from Dontronics, and Ken Segler of Ken Segler Designs, to help with the firmware.

Don's idea was to make the new board compatible with the popular Arduino (http://www.arduino.cc) shields as there is a vast range of shields developed already, and a lot of open source projects done with them which could be used to build projects with the MaxiMite. The MaxiMite has a 26 pin GPIO connector with 20 IO signals on it, which you can be easily manipulated in Basic by defining their function like: analog input, analog output, digital input, digital output, frequency counter, etc.

To make the MaxiMite with an Arduino shield was fairly easy, as our PIC32-PINGUINO had the same shield layout, and an earlier PIC32 micro, so we already knew which signals we should connect to the Arduino shield layout for maximum compatibility. The problem we saw is that many of these signals were already used for other purposes on the MaxiMite.

Once we decided to run with the project, we had to find a knockout name for it. MaxiMite is an explosive invented by Hudson Maxim (http://www.magnumarchive.com/c/encyclopedia-americana-volume-18/Maximite.html). As we wanted to make it Arduino compatible we tossed around many names and eventually Mick Gulovsen came up with the name DuinoMite. The team fell in love with this name straight away. We now pronounce it “Dynamite”, so we have kept the explosion in the name.

When we began to compare the MaxiMite with the PIC32-PINGUINO, we found that the MaxiMite schematic did not use all of the features that the PIC32 could offer, and that we had already implemented in PIC32-PINGUINO, so many changes had to be made to take advantage of these PIC32 features, so they could be used in the new DuinoMite Computer.

Low Power

MaxiMite was not designed to be a low power device. It runs a high frequency crystal so you can either shut down the processor and lose timekeeping functionality, or run it at high speed and consume about 140mA.

DuinoMite was built to work as a hand-held data logger. We used ultra low power voltage regulators, which draw only 1.6 uA current, and the consumption on this board could be as low as 30uA while keeping the RTC functionality, as the board has a 32kHz low frequency crystal.

On the MaxiMite the RC13 PIC32 port where the low frequency crystal should be connected is used for the Boot-loader button, so the MaxiMite can’t run on lower frequency without this schematic change. Our DuinoMite schematic allows the PIC32 to be put into low power mode with a working 32 Khz oscillator, and consuming only 30 uA with all peripherals shut down. To keep the power at minimum we had to add a FET, which will power on and off the SD-card, CAN, and RS232 drivers.

 

 

 

Battery Operation

DuinoMite can run on a Li-Po battery stand alone with some restrictions.

For example, the keyboard can’t be used as it requires +5V power and the Li-Po battery allows only 3.7V.

The battery voltage can be measured with the AN2/PB2 ADC. Also the DuinoMite design allows the DuinoMite firmware to be aware when the board runs on battery power supply, by monitoring the USBFAULT line, which can monitor when there is no USB or external power connected (logic LOW).

 

 

 

Power Supply

We decided to add a Lithium Polimer battery charger and connector for LiPo battery.

Also, as the PIC32-PINGUINO was designed with Industrial applications in mind, we decided to keep the complete power supply from Pinguino i.e. 9-30Vdc input power supply and industrial temperature range -20+85C operation.

The original MaxiMite used a linear LM7805 which can’t handle much power dissipation at room temperature.

If you look at the DuinoMite-Mega schematic:

http://www.olimex.com/dev/DUINO/DUINOMITE/DUINOMITE-MEGA-REV-A.pdf

it seems quite complicated and unnecessary, but it allows the board to be powered from 3 sources – External Power Supply / USB / Battery. Switching between the power sources is done automatically.

If you have no external power and no USB connected, the board takes power from the battery.

If USB is connected, the power automatically switches to the USB, and if the battery is not charged at 100%, it will start charging

If external power is applied, the power will be sourced from the external connector.

On the MaxiMite you have a jumper to select the power source, either USB or external supply, and when you alter the jumper from one to other, the MaxiMite will power down.

NOTE!! The DuinoMite-Mini board only supports +5VDC External Power Supply. Of course, it can also be powered by USB. This was to keep costs down for an entry level (or student model) DuinoMite. A cheap source of external Power Supply is an AC to USB +5V Power Supply, which can be found for under $2 on Ebay, and is used for iPODs, cameras, eReaders, etc.

RS232

For some reason the MaxiMite design has no real UART on the GPIO pins, although this is a very common interface in the embedded world.

Most of the peripheral devices such as GSM, GPS, Bluetooth, even Camera modules, use UARTs to transmit and receive data. The PIC32 has 6 hardware UARTs available with interrupts, buffering, DMA etc., which

normally releases the CPU from any overhead time to handle it, but in the MaxiMite the UART has to be achieved by bit-banging, and GPIO polling, as none of the hardware UARTs are available on the GPIO pins.

This just adds unnecessary overhead to the CPU as it polls GPIO lines instead of doing something useful, which effectively slows down the code execution. We had to fix this in our DuinoMite design. As the PIC32 multiplexes the UART lines with other ports it was not possible to use all 6 UARTS on the DuinoMite, as some ports were used for the VGA generation, and also shared with UART functionality.

DuinoMite offers 3 UARTs for users:

UART5 goes directly to the RS-232 driver chip and RS-232 connector, (Mega Version Only) and is also available on pins D0 and D1 of the Arduino Shield and the GPIO. Both of these signals are fully isolated with un-populated resistor positions R2, and R3. If you wish to connect UART5 to the GPIO and the shield, then you must populate these positions with zero Ohm resistors, or shorting links.

UART1 is available on pins D11 and D12 of the Arduino Shield, and also the GPIO connector.

UART2 goes directly to the UEXT connector, which interfaces to our range of external modules. (see UEXT later in this document)

 

 

 

USB-OTG

The PIC32 has USB On-The-Go which allows the PIC32 to act not only as a USB Device, but also as a USB Host interface. This means when you initialize the USB as host you can use peripherals such as: USB mouse, USB keyboard, USB camera, USB printers, USB Bluetooth, WiFi modules etc.

Of course all of these devices need proper drivers to be implemented, but in the original MaxiMite this USB-OTG feature is not available although the PIC32 has it.

We have this in the PIC32-PINGUINO so we decided to keep it in our DuinoMite schematic too. A good application for USB-OTG is that it allows Android devices to be connected to the PIC32 and DuinoMite, and to use the Android ADK to interface to sensors, etc. with it.

With the board drawing about 30uA in low power mode, building Android phone accessories can be very easy to do with DuinoMite.

Here are few videos which you can look at to see what you can do with Android device and DuinoMite:

http://www.youtube.com/watch?v=SXyc8uE5YuI
http://www.youtube.com/watch?feature=player_embedded&v=CJ0j_vZ4AeM

When you consider that the DuinoMite is low power, you can easily make hand-held sensor accessories to any Android device.

 

 

 

Buttons

We decided to add a User button with noise filtering (remember, we designed this board to work in industrial applications, and in noisy environments). This same User button in conjunction with the reset button, allows the board to go into the Bootloader mode, for updating the firmware.

 

 

 

Noise Immunity

DuinoMite was built to work in Industrial environments. The USB, reset, user button, SD card and all peripheries were carefully designed to be `noise immune’. MaxiMite has no protection for the USB, buttons, etc., so it should work OK at home, but may not work as well in industrial or noisy environments.

 

 

 

VGA/composite Video

The original MaxiMite has a jumper selector to manually configure the output mode. Ken Segler came up with a proposal to use the monitor itself as a means of selecting the output. The VGA connector has multiple grounds, so we have used two pins as a jumper select. The DuinoMite firmware can recognize if a VGA monitor is attached and start generating the correct output. If nothing is attached to VGA connector, it automatically switches to composite video output mode.

CAN – (DuinoMite Mega Only)

Controller Area Network (CAN or CAN-bus) is a vehicle bus standard designed to allow micro-controllers and devices to communicate with each other within a vehicle, and without a host computer.

MaxiMite uses the PIC32MX795 which has CAN, but MaxiMite doesn't make use of it. CAN is a very useful interface, it’s the de-facto standard for the automotive bus applications, so by having CAN it would be possible to connect to your car and read all of the data sensors for speed, temperatures, fuel consumption, etc . This video can give you rough idea what you can do with CAN and DuinoMite.

http://www.youtube.com/watch?v=PbA_bOO2mMw

Ken is working on firmware which will allow you to see CAN as a COM port on DuinoMite basic so you can use INPUT #5 and PRINT #5 to receive and send CAN messages.

Being a robust and noise immune protocol, CAN is used not only in automotive but also in industrial robot applications – For more information see the following links

http://en.wikipedia.org/wiki/DeviceNet

http://en.wikipedia.org/wiki/CANopen

 

 

 

 

 

UEXT

This is our universal connector we developed here at Olimex, to allow external modules to be connected. The list of modules currently available can be found at:

http://www.olimex.com/dev/OTHER/UEXT.pdf One of the most interesting modules for DuinoMite users may be the RS485 module which allows a UART to be connected to a RS485 network using the MOD-IO module, which will allow, virtually, an unlimited number of relays, digital opto-isolated inputs, and analog inputs to be cascaded, all fully supported in MaxiMite/ DuinoMite Basic. Ken is working on firmware where you will be able to access MOD-IO inputs and outputs with Basic commands.

Having all these enhancements, we simply couldn’t keep the original MaxiMite schematic and port assignments the same, so here is brief summary of the GPIO port differences between the MaxiMite and the DuinoMite:

Both the MaxiMite and the DuinoMite have 20 GPIOs (General Purpose I/O Pins) which can be accessed with PIN() in basic, but there are some distinct differences in the way these GPIOs can be configured between the MaxiMite and DuinoMite.

Refer to the following GPIO Table:

SetPin #

I/O Type

Maximite GPIO Pin()

DuinoMite GPIO Pin()

1

Analog Input

1-10

1-7,19,20

2

Digital Input

1-20; (11-20 are 5V tolerant)

1-10, 12-20; (8-10, 13-18 are 5V tolerant)

3

Frequency Input

11-14

5-7

4

Period Input

11-14

5-7

5

Counting Input

11-14

5-7

6

Interrupt (L-H)

1,2,10-14

1,2,5-7

7

Interrupt (H-L)

1,2,10-14

1,2,5-7

8

Digital Output

1-20

1-20

9

Digital Output (+5V Open Collector)

11-20

8-10,13-18

Also special care should be taken when using DuinoMite GPIOs 7-10,19,20 as these are shared with the SD card and VGA signals. DuinoMite firmware has provision for the VIDEO ON/OFF command which will shut down the VGA signal generation to lower the power, and in this case the multiplexed GPIOs could be used. Same applies to the SD card multiplexed pins.

What does this mean? When you want to move code from the MaxiMite to the DuinoMite, you should take care to re-map the GPIO pins you use so that they have the functionality you require. For instance if you use frequency input on the MaxiMite PIN(11) you can’t use the same code but should modify it to use PIN(5) on the DuinoMite for instance, and vice versa. Code which is written for the DuinoMite and does not use some of the special features such as CAN, RS232, Low power mode, USB-OTG may be ported to work on the MaxiMite if the GPIOs are re-mapped.

The PINGUINO connection (http://www.pinguino.cc) – DuinoMite is very similar to the PIC32-PINGUINO as functionality, and the support for this board in Pinguino IDE will be pretty easy to implement, so the people that use this board will have a choice – to program it in Basic, or to program it in an Arduino like language, or to program it directly in C as there is a C compiler on the back-end of Pinguino environment.

Another option is to develop in Assembler, or with a C32 compiler via MPLAB and PIC-KIT3

So in the near future, DuinoMite will give you these 4 different programming options:

MaxiMite basic language extended with additional Basic commands which exploit the new features of DuinoMite offers over MaxiMite.

Pinguino IDE development via Arduino like sketches

Pinguino IDE development in C language

MPLAB and C32 development and PIC-KIT3 as programmer

 

 

 

 

Posted in News | Tagged , , , , | Comments Off

MaxiMite-DuinoMite and SimmStick.

I have recently received some private email regarding interfacing the MaxiMite and DuinoMite to the SimmStick bus, and felt some sort of explanation of events is in order to help explain the situation.

There has been some recent chat on TBS forum that reminded me that I should produce some up to date answers: http://www.thebackshed.com/forum/forum_posts.asp?TID=4876&PN=1

And there has been a couple of recent spin-off features from the Test-a-Mite MM-DM-CGMMSTICK1 GPIO tester board.

1) CGMMSTICK1 to Maximite-DuinoMite 26 pin GPIO Adapter.
2) Maximite or DuinoMite board, to SimmStick Adapter.

Read on…

SimmStick was designed around 1994 by Antti Lukats, a friend of mine living in Estonia. Geoff Graham (MaxiMite designer) recently credits Antti with producing the world's smallest Maximite:
http://www.youtube.com/watch?v=LUMnO5p-fjg&lr=1

In 1995 I designed a large range of SimmSticks and started selling them via Dontronics. Basically the platform was based on the then PC-XT 30 pin memory module socket, which was abundant at the time. My initial designs favoured PIC and AVR micro usage, and included a whole range of peripheral devices.

As an example, this was the world's first AVR third party prototype PCB manufactured:

It supported both the old Atmel 8051 family, as well as the new AVR family of micros.

The PCB had to be thinner than a normal PCB to fit into the memory socket, and it needed a notch up one end.

As the years rolled on, many new designs from independent third parties, added to the range. One of them was from another friend of mine, Rob Severson of the US.

Rob designed the DT209:
http://www.dontronics.com/dt209.html
http://www.dontronics-shop.com/dt209-2.html
and gave me the PCB artwork, so I could manufacture them for all users.

His description of this product:
The DT209 I/O expansion board utilizes three I2C bus expansion integrated circuits to provide a total of 24 expansion lines. Each of the three port chips provides 8 i/o lines. These 24 i/o lines allow for input and output expansion without sacrificing any of the general control lines on the SimmBus, i.e. the lines labelled D0 – D15.

The SimmStick bus and the range of boards has declined over the years. One of the main reasons is that the memory sockets have become hard to get, however standard .1" male and female headers can be used with any thickness PCB. See: http://www.dontronics-shop.com/connectors.html

I have been selling out my old stock of SimmStick boards at prices from $1 to $2. See: http://www.dontronics-shop.com/simmstick-and-related.html

Recently Rob Severson came up with his CGMMSTICK1, which is a MaxiMite basically on a SimmStick compatible bus. Close enough that at least we shouldn't see any blue smoke, when they are mated together.

See:
http://www.circuitgizmos.com/products/cgmmstick1/cgmmstick1.shtml

Following on from this, Mick Gulovsen designed the MM-CGMMSTICK1-DM compatible Test-a-Mite that would allow testing of not only Rob's 30 pin bus, but also the 26 pin GPIO outputs from both the MaxiMite and DuinoMite.

Interestingly, this Test-a-Mite product has produced two new potential features.

1) CGMMSTICK1 to Maximite-DuinoMite 26 pin GPIO Adapter.

See picture below:

This is a MaxiMite CGMMSTICK1 board, connected via a blank Test-a-Mite board, to a right angle male 26 pin IDC connector.

 

2) Maximite or DuinoMite board, to SimmStick Adapter. See picture below:
This is a MaxiMite or DuinoMite, connected via a blank Test-a-Mite board, to a SimmStick board.

The boards pictured are a DuinoMite-Mini connected to a SimmStick DT203 LEDs and Switches board.

 

The Test-a-Mite boards can be purchased from:
http://www.dontronics-shop.com/test-a-mite.html

Or we can post off the Test-a-Mite bare printed circuit board in a letter, world wide at a very cheap rate. In fact, we will do it for an extra $2.
http://www.dontronics-shop.com/test-a-mite-letter.html

I really don't know what the future of mating up SimmStick with MaxiMite and DuinoMite is, or even if there is a future, but as Rob has extended the useful life of the platform, I felt it was at least worth visiting the facts, and what is currently available.

Links:

http://www.dontronics-shop.com/simmstick-fifteen-years-on.html

http://www.dontronics-shop.com/simmstick-and-related.html

http://www.dontronics.com/ssinfo.html

http://www.dontronics.com/ssinfo_dg.html

http://www.dontronics.com/ssinfo_dg.html#pin
 

Cheers Don…

Posted in Applications | Tagged , , , , | Comments Off

DuinoMite: REMEMBER OLD TIMER GAMES PACMAN AND SPACE INVADERS?

REMEMBER OLD TIMER GAMES PACMAN AND SPACE INVADERS?

PACMAN and SPACE INVADERS retro games are rewritten in BASIC and available for Duinomite. You can even use the MOD-WII-UEXT-NUNCHUCK to play with them.

Here is the start page of MAXMAN (Pacman) for Duinomite:

Image

and video of the game in action:

This is the SPACE INVADERS picture:

Image

and video of the game in action:

 

 

Posted in Applications | Tagged , , , , , , | Comments Off