EEVblog Electronics Community Forum
Electronics => Open Source Hardware => Topic started by: awallin on May 14, 2013, 12:20:48 pm
-
Hi all,
I'm looking for opinions on a user-interface + controller solution for various lab-instrument ideas I have.
Desirable features:
- touch-screen 4" or larger for user input and display
- open-source toolchain (compilers, programmers, etc). programming/debugging over USB or some other common standard.
- existing real-time OS + graphics/touch-screen library
- application programming in C or similar high-level language
- SPI bus for communicating with one or more DAC/ADC chips (I'd want probably up to 5, maybe 8 SPI-chips connected for some projects)
- enough processing power to run PID-loops, digital filters, and datalogging on 24-bit or more (32-bit) numbers at 1 Hz to 1+kHz loop frequency. integer math is probably enough (i.e. floating-point not a strict requirement)
- datalogging onto e.g. SD-card
- possible ethernet connectivity for publishing data, pushing it to a database-server, or remote operation/monitoring of device
- possible battery/LiPo operation (charger circuit would be nice also)
- small, affordable
I've been looking at a standard PC (ITX-motherboard) + FPGA-card based solution, but this is overkill in terms of size and performance for e.g. simple temperature-controllers or data-logger applications.
Then there is e.g. Olinuxino
https://www.olimex.com/Products/OLinuXino/ (https://www.olimex.com/Products/OLinuXino/)
but again a whole linux-distribution, a possible xenomai real-time kernel, etc. seems a bit overkill.
I'm not sure how easy/hard it is to do SPI on the olinuxino.
Or indeed the quite similar BeagleBoard and its derivatives.
So any opinions on a microcontroller-based approach? Any suitable dev-kits out there?
Any opinions on how to choose between PIC / AVR / ARM / other?
I'm more constrained by time than money, I need something that "just works", preferably open-source, easy to program, where I can develop the analog IO cards myself and just plug them via SPI into the UI/controller board - at least that's my plan now... :D
thanks for your input,
Anders
-
Raspberry pi
-
Raspberry pi
is there an affordable and available 4" or 7" touch-screen solution for the Pi? last I checked it was so-so.
Also, does the screen use the dedicated lcd-connector, or the GPIO/SPI which I would want to leave free for my application to use?
-
PID loops in a RPi that is running a full blown OS with undetermined response time seems like a great idea :palm:
-
Well you must use another micro for this
-
I've spent a bit of time on this subject. My conclusion was, for display and touch screen around the 6-10" size nothing can touch (no pun intended) the tablet market. Android tablets with 800x480 resolution displays and dual core processors are available from a local shop for the same price as I can buy the bare TFT LCD off ebay. Seriously I've got one of these LCDs sitting here, and that's all it does, it's just not worth the significant time investment required.
This is an really interesting trend in the low volume user interface market too now, as you can go to any shopping center here and see IPads mounted in acrylic holders where a custom build UI would have once lived.
The dev tools for these devices rock (I've only used android eclipse but I here apples is just as good.)
Then you just need to pick your interface into the device. 32bit ARM micros that have USB hosts are a relatively easy tethered option for droid based tablets (examples are shipped with pretty much every dev board.) Or you can pick a bluetooth or Wifi solution depending on the requirements.
You will no doubt spend extra time understanding whatever communications stack you're going to use to get data in and out. But, you get massive time savings from using apple/droid dev tools for the tablets.
-
But you'll get a massive decrease in quality and reliability
-
I've spent a bit of time on this subject.
But not on his subject. Read the specs, Luke.
- existing real-time OS + graphics/touch-screen library
...
- SPI bus for communicating with one or more DAC/ADC chips (I'd want probably up to 5, maybe 8 SPI-chips connected for some projects)
- enough processing power to run PID-loops, digital filters, and datalogging on 24-bit or more (32-bit) numbers at 1 Hz to 1+kHz loop frequency. integer math is probably enough (i.e. floating-point not a strict requirement)
-
PID loops in a RPi that is running a full blown OS with undetermined response time seems like a great idea :palm:
I've worked with LinuxCNC(formerly EMC2) in the past. It uses a real-time linux kernel (previously RTAI, but more recently Xenomai), to achieve roughly 10-20 us timing jitter on standard PC hardware. This is fine for PID loops at 1 ms.
There are xenomai ports for ARM, but they are fairly new and in development/testing.
Maybe a full linux system with a xenomai-kernel is the way to go? It's a bit overkill and heavyweight, but at least I don't have to learn any new vendor/processor-specific RT-OS and programming techniques.
This approach does require dedicated hardware for SPI-comminucation at ~MHz, and some buffering of the SPI-data before it can be read/written at 1ms update-rate by a real-time thread.
-
I think you might be missing what I was trying to say.
Get something like a nexus 7 tablet for the UI aspects. Then get as powerful a uC as you need that's got a USB host interface to communicate with the tablet.
PID aspects, SPI etc would all be done on the uC. The tablet would then take care of any UI requirements.
I don't see how that doesn't meet the OP's requirements or would be any less reliable than other suggested solutions.
Further, it's pretty much off the shelf for the digital hardware aspects. Just get an ARM dev board with the USB host connector, put whatever RTOS you want on it, use the example USB stack as an android accessory, then sort the rest of your design.
-
Because this cheap tablet has an expected life of 2 year
So, 2 years fo me is not reliable
-
I kinda glossed over the specs you were after, but I have something similar to this:
Kentec touchscreen with a kentec ribbon adapter plugged into a STM32F4DISCOVERY
Screen:
http://nz.element14.com/kentec-electronics/k430wqc-v3-ff/lcd-module-4-3-480x272-touch-screen/dp/1893551 (http://nz.element14.com/kentec-electronics/k430wqc-v3-ff/lcd-module-4-3-480x272-touch-screen/dp/1893551)
adapter:
http://nz.element14.com/kentec-electronics/eb-stm32f4discovery/expansion-board-lcd-stm32fdiscovery/dp/2216779 (http://nz.element14.com/kentec-electronics/eb-stm32f4discovery/expansion-board-lcd-stm32fdiscovery/dp/2216779)
Micro:
http://nz.element14.com/stmicroelectronics/stm32f4discovery/stm32f407-usb-otg-discovery-kit/dp/2009276 (http://nz.element14.com/stmicroelectronics/stm32f4discovery/stm32f407-usb-otg-discovery-kit/dp/2009276)
I went for the 3.5" screen with a stm32F0 (but the adapter didnt support the touchscreen, even though the screen has it :palm:).
It also appears that the bigger screens can just be swapped for the smaller ones.
-
I have such a screen and the stm32 dev board but the refresh rate is very slow unless you want to do some DMA stuff etc...
Even if you get it working it will influence the performance of the rest of the system (if use use it also to do PID stuff etc).
I have looked a the same problem for a while but a tablet seems the best solution for UI. And a tablet can handle a few years easy. And if it breaks you just need a random brand Android tablet. Another way would be a small ITX board or something like that but that will be more expensive and bigger.
-
Because this cheap tablet has an expected life of 2 year
Extraordinary claims require extraordinary evidence. Where do you get the 2-year life expectancy rating from?
I've not seen a tablet die in under 2 years that wasn't being seriously abused. I still have a first-generation iPad that works like a freeking champ (used several hours per day). In fact, I kind of wish it would break so I would have an excuse to buy a new one with one of those pretty Retina displays... but the thing just won't die. And all of the Android tablets I have seen were similarly robust.
-
if you want to put a tablet inside something you cant buy a 700$ ipad..
-
if you want to put a tablet inside something you cant buy a 700$ ipad..
no, if you want to put a tablet somewhere put a $43.80 tablet there
http://dx.com/p/jxd-s18-4-3-resistive-screen-android-4-0-mini-pad-tablet-pc-w-tf-wi-fi-g-sensor-black-161536 (http://dx.com/p/jxd-s18-4-3-resistive-screen-android-4-0-mini-pad-tablet-pc-w-tf-wi-fi-g-sensor-black-161536)
this has better specs than any dev kit :) and you can learn android on it
-
PID loops in a RPi that is running a full blown OS with undetermined response time seems like a great idea :palm:
No problem at all. Just use a timer interrupt like on a microcontroller.
-
PID loops in a RPi that is running a full blown OS with undetermined response time seems like a great idea :palm:
No problem at all. Just use a timer interrupt like on a microcontroller.
interrupts have non deterministic response time under linux (or any other preemptive os)
-
If that where true then a lot of hardware wouldn't work. You shouldn't expect nanosecond accuracy on the execution of an interrupt (just like on a microcontroller) but sub millisecond shouldn't be a problem at all.
-
Use a pc type processor to control this tipe of things is just complicated and unreliable.
I will never buy something done that way.
-
And yet some industrial control systems work that way. Often the ethercat protocol is used to control I/O modules where the processing is done on a PC (and sometimes time critical things are done inside the interrupt service routine of the ethernet card!). If you are willing to pay then HP offers a wide range of very stable PCs.
Besides. I thought we where talking about some embedded (ARM) device.
-
Why si much trouble when you can use a 5$ micro
-
Why si much trouble when you can use a 5$ micro
5$ micros dont have fancy touchscreen UIs
-
But 5$ micro can do pid!
And work, work without a boot, an os, a fu****g java virtual machine and a damn touchscreen!!!!!
Do you understand?
-
So can a quad opamp and a few passives, and lasts generally decades in industrial service.
-
I'm in the process of building a similar lab instrument and it will all be controlled from an Android tablet or phone since it's the easiest way to go. There will be some buttons, knobs and plain LCDs/digit displays but most of the stuff will be done via bluetooth.
There is no single solution for everything, I went with a modular design. Since a micro is <5$, even a dev board could be less than 10$ it's easier to just build a separate module for everything: programmable supply, battery charger, mini voltmeter/scope, signal generator, analyser/decoder, data logger, component tester, ...
A central module could handle all the connectivity (bluetooth, even serving a web page), RPi comes to mind here. Everything else communicates via a serial protocol to that module. You can also set up bootloaders on each module so that you can update the firmware via the central module.
-
A central module could handle all the connectivity (bluetooth, even serving a web page), RPi comes to mind here. Everything else communicates via a serial protocol to that module. You can also set up bootloaders on each module so that you can update the firmware via the central module.
If the tablet and central module have access to a wifi router, another option is using wifi. Using something like a RPi and android tablet with wifi and sockets is a rather pleasant experience to develop with, and potentially cheap. Sockets isn't any harder than serial once you get your head around it.
I'm sure bluetooth is fine to, it's just another option.
-
I mean the small embedded modules communicate via serial (rs232, i2c, spi, ...) to the central module. Of course the central module talks to the outside world via TCP/IP or BT.
Unfortunately 802.11a/b/g does not have such a huge reach on the hobbyist market, perhaps this will change in the future.
-
Because this cheap tablet has an expected life of 2 year
Extraordinary claims require extraordinary evidence. Where do you get the 2-year life expectancy rating from?
I've not seen a tablet die in under 2 years that wasn't being seriously abused. I still have a first-generation iPad that works like a freeking champ (used several hours per day). In fact, I kind of wish it would break so I would have an excuse to buy a new one with one of those pretty Retina displays... but the thing just won't die. And all of the Android tablets I have seen were similarly robust.
A iPad isn't a cheap tablet, even the first one. You're spoiled. Check out some of those $69 Android gingerbread hunks of garbage if you want to see a cheap tablet. I think 2 years is generous for some of them.
-
@Topic Starter:
Seeing those specs I had to think of the NXP LPC178x (http://www.nxp.com/documents/data_sheet/LPC178X_7X.pdf) / LPC185x (http://www.nxp.com/documents/data_sheet/LPC185X_3X_2X_1X.pdf) or FreeScale Kinetis K70 (http://www.freescale.com/webapp/sps/site/prod_summary.jsp?code=K70_120) as possible candidates.
Devkits: LPC1788 (http://www.nxp.com/demoboard/OM13020.html); LPC1857 (http://www.keil.com/mcb1800/); FreeScale Tower System (http://www.freescale.com/webapp/sps/site/homepage.jsp?code=TOWER_HOME)
For an RTOS take a look at FreeRTOS (http://www.freertos.org/).
NXP has a nice deal with Segger that includes free (commercial) use of their emWIN GUI libraries (no source code though) as long as you use an LPC micro. Also NXP has some free USB libraries for their micro's. Haven't used either myself yet though.
The thing is, I'm not sure if any solution that fits your needs will be really small and cheap. Those micro's with LCD, Ethernet etc will cost anywhere from €8 to €15 depending on peripherals, supplier and how many you buy. On the other hand, maybe you could go for a multiple small (and dedicated) micro solution.
-
Hi all,
I'm looking for opinions on a user-interface + controller solution for various lab-instrument ideas I have.
Desirable features:
- touch-screen 4" or larger for user input and display
- open-source toolchain (compilers, programmers, etc). programming/debugging over USB or some other common standard.
- existing real-time OS + graphics/touch-screen library
- application programming in C or similar high-level language
- SPI bus for communicating with one or more DAC/ADC chips (I'd want probably up to 5, maybe 8 SPI-chips connected for some projects)
- enough processing power to run PID-loops, digital filters, and datalogging on 24-bit or more (32-bit) numbers at 1 Hz to 1+kHz loop frequency. integer math is probably enough (i.e. floating-point not a strict requirement)
- datalogging onto e.g. SD-card
- possible ethernet connectivity for publishing data, pushing it to a database-server, or remote operation/monitoring of device
- possible battery/LiPo operation (charger circuit would be nice also)
- small, affordable
I've been looking at a standard PC (ITX-motherboard) + FPGA-card based solution, but this is overkill in terms of size and performance for e.g. simple temperature-controllers or data-logger applications.
Then there is e.g. Olinuxino
https://www.olimex.com/Products/OLinuXino/ (https://www.olimex.com/Products/OLinuXino/)
but again a whole linux-distribution, a possible xenomai real-time kernel, etc. seems a bit overkill.
I'm not sure how easy/hard it is to do SPI on the olinuxino.
Or indeed the quite similar BeagleBoard and its derivatives.
So any opinions on a microcontroller-based approach? Any suitable dev-kits out there?
Any opinions on how to choose between PIC / AVR / ARM / other?
I'm more constrained by time than money, I need something that "just works", preferably open-source, easy to program, where I can develop the analog IO cards myself and just plug them via SPI into the UI/controller board - at least that's my plan now... :D
thanks for your input,
Anders
How about a NXP LPC1768 dev board called Landtiger? It costs about $60, has a 3.2 inch display with touch screen and a LOT of other goodies (incl. Ethernet and SD card slot). It also has all the pins broken out, so SPI is no problem. It is a Chinese board, but it comes with a lot of example code (of varying quality), and a Dutch guy has written an English manual for it. It is my go-to board when I need something done without making a PCB from scratch.
It has a J-Link clone on board, so you can program it with USB. I've used it with Rowley Crossworks myself, but I think it will work with the free Coocox IDE.
http://mbed.org/users/wim/notebook/landtiger-baseboard/ (http://mbed.org/users/wim/notebook/landtiger-baseboard/)
-
Hi all,
I'm looking for opinions on a user-interface + controller solution for various lab-instrument ideas I have.
Desirable features:
- touch-screen 4" or larger for user input and display
- open-source toolchain (compilers, programmers, etc). programming/debugging over USB or some other common standard.
- existing real-time OS + graphics/touch-screen library
- application programming in C or similar high-level language
- SPI bus for communicating with one or more DAC/ADC chips (I'd want probably up to 5, maybe 8 SPI-chips connected for some projects)
- enough processing power to run PID-loops, digital filters, and datalogging on 24-bit or more (32-bit) numbers at 1 Hz to 1+kHz loop frequency. integer math is probably enough (i.e. floating-point not a strict requirement)
- datalogging onto e.g. SD-card
- possible ethernet connectivity for publishing data, pushing it to a database-server, or remote operation/monitoring of device
- possible battery/LiPo operation (charger circuit would be nice also)
- small, affordable
I've been looking at a standard PC (ITX-motherboard) + FPGA-card based solution, but this is overkill in terms of size and performance for e.g. simple temperature-controllers or data-logger applications.
Then there is e.g. Olinuxino
https://www.olimex.com/Products/OLinuXino/ (https://www.olimex.com/Products/OLinuXino/)
but again a whole linux-distribution, a possible xenomai real-time kernel, etc. seems a bit overkill.
I'm not sure how easy/hard it is to do SPI on the olinuxino.
Or indeed the quite similar BeagleBoard and its derivatives.
So any opinions on a microcontroller-based approach? Any suitable dev-kits out there?
Any opinions on how to choose between PIC / AVR / ARM / other?
I'm more constrained by time than money, I need something that "just works", preferably open-source, easy to program, where I can develop the analog IO cards myself and just plug them via SPI into the UI/controller board - at least that's my plan now... :D
thanks for your input,
Anders
OK, opinions :)
-An Atmel processor
32 bit UC3 or ARM chips come with touch support, DSP libraries and Atmel's Framework that at least gets you up to speed relatively fast even if you don't want to use the actual code in you final prject.
-Atmel Studio toolchain (AVR-gcc, includes everything you need out of the box, very good debugging using genuine Atmel tools (JTAGICE II or 3). While the IDE is closed source, the compiler/linker is not. Debugger - why care when it just works.
-FreeRTOS or ChibiOS, possibly the latter in this case. Lean & mean, no needless fluff. Open source.
Touch library from Atmel, graphics libs - should be findable from Inet.
-C and C++ as supported by gcc, uncrippled.
-More SPI, I2C, CAN whatever, more than you will ever need, subject to chip choice.
-Processing power - sure. Required things no problem.
-SD card doable
-Ethernet doable. At least UC3A AVR series has Ethernet MAC, as well as AT91SAM ARMs
-No battery chargers in MCUs...
-Small - yes. Affordable - i guess.
Me an Atmel fan? Naa...
But really, in some sense this is like a shopping list for a high end Atmel chip. Of course the same might apply to other mfgs as well. The downside is that you need to design the actual dircuit/board. But then that's where the fun is for me, hence this kind of answer. As for ready made solutions - let others bother.
-
Just something I stumbled over lately:
http://www.mikroe.com/add-on-boards/display/connecteve/ (http://www.mikroe.com/add-on-boards/display/connecteve/)
4.3", SPI, resistive touchscreen, but with intelligent controller, so usable without the need for a large RAM in the µC.
Price is ~60€ including VAT.
-
Sounds nice but their website says:
Compiler support
We provide free FT800 library for all of our mikroC, mikroBasic and mikroPascal compilers.
While the price for their "mikroC-Arm" compiler is 249$ which does not mean "free" to me :D
I haven't really thought about just taking a hole tablet as the frontend. I always thought of only taking a display via LVDS but the driver stuff can really be a pain in the ass. So doing some Android-UI with an IDE may be definitely worth considering. Especially because the Android port of QT is already in beta-stadium so maybe you could even get rid of most of the Java stuff and do the UI in C++ in the near future.
As a uC I would personally choose an ARM Cortex M4 in form of a STM32 on a F4 discovery board.
A few reasons why:
1.STM32F4 disco board is cheap as chips and has got a quite good debugger on board
2.Cortex M4 in general offers some DSP functionality in comparison to M3 (e.g. LPC17xx which are also available quite cheap on dev boards from NXP)
3. grown community incl. RTOS support etc. and free choice of IDE, including free IDEs Eclipse and Coocox (e.g. in comparison to TI TM4C)
There are a few more that compete in performance like the Freescale Kinetis K series and the Infineon XMC4500 series, while Kinetis K development boards are a little bit more expensive and I do not know too much about the community support of Infineon but I hardly believe it's as good as with STM or NXP devices. Furthermore Infineon uses its own IDE called Dave3, which is based on so called "Apps" which you can graphically combine and let the IDE write your code. But what looks great on first glance seems as a nightmare to me in the end because you are no longer in charge of the code and debugging must be a pain because you do not exactly know what "your" code is really doing.
So in my opinion you get the most bang for the buck with the STM32F4. You may have a look at http://www.wvshare.com (http://www.wvshare.com) were you can get a lot of development and breakout boards from (not only for STM). Only thing is that shipping is a bid pricey. As far as I have seen you get most of the peripheral boards e.g. for ethernet, a microsd or a 3.2" touchscreen on fleabay as a single board and they come quite cheap (ethernet 10$, microsd 15$ and touchscreen 20$, all inc. shipping) if you need only one feature but you would have to wire them manually with jumper wire if you do not have the baseboard. Should be no problem though. ;)
-
Writing your own library is part of the fun for me ;)
Regarding STM32F4: sure the price is great, but IMHO it's not really a good base for a project because there's too much connected that you might not need in the end. Also it's kinda unpredictable how long it will be easily available.
Generally, an evaluation board with a lot of features looks interesting in the beginning, but for an own project, this easily gets limiting.
What I like as base for a project is just a bare board which just the most basic stuff that gives you access to all pins with a proper header. This one is pretty much perfect from my point of view:
http://www.ebay.com/itm/NXP-LPC1768-minimum-System-Board-Core-Board-/170896978026?pt=LH_DefaultDomain_0&hash=item27ca40f06a (http://www.ebay.com/itm/NXP-LPC1768-minimum-System-Board-Core-Board-/170896978026?pt=LH_DefaultDomain_0&hash=item27ca40f06a)
-
Regarding STM32F4: sure the price is great, but IMHO it's not really a good base for a project because there's too much connected that you might not need in the end. Also it's kinda unpredictable how long it will be easily available.
Generally, an evaluation board with a lot of features looks interesting in the beginning, but for an own project, this easily gets limiting.
What I like as base for a project is just a bare board which just the most basic stuff that gives you access to all pins with a proper header.
Not quite. The F4DISCO board has a SWD programmer (maybe that's what you mean by too much connected), the M4F, an I2C audio DAC that just sits on two lines, MEMs sensor, a button and half a dozen LEDs. There as cut pads (I don't know their real name) to disconnected most of the LEDs and button. If you care enough you can cut easily remove the DAC , pull up resistors resistors and MEMs sensor. All IO pins (including those used) are brought out to headers on the side. So in my opinion, I'm very happy with it. The only real things I'd like are the Vref pin brought out so you don't have to hack it like I did in another post, and more ground pins (like a third strip on either side of grounds.)
BTW that's obviously an M3 board you linked to. Is there a similar thing for M4F? Again in my opinion the draw card of the F4DISCO board is $15 gets you a 168MHz cortex with DSP instruction set and Floating point unit. Pretty amazing when the parts on the board total over $30 on digikey.
If it's a personal project who cares if they stop making them next year? You're only going to use them in one off designs, otherwise you'd just plonk the device straight into your own board.
-
if you want to put a tablet inside something you cant buy a 700$ ipad..
Or a new Nexus 7" and one of these IO boards for less than $300
http://www.amazon.com/IOIO-Android-Interface-Board-DEV-10748/dp/B007KOHOCQ (http://www.amazon.com/IOIO-Android-Interface-Board-DEV-10748/dp/B007KOHOCQ)
Android is an open OS. You can modify and rebuild it yourself if you need (e.g. cyanogen). The Nexus line comes ready to be rooted if you need (fastboot).
-
I would go with 7" Android table (e.g. Nexus 7) + an IO board (e.g. https://github.com/ytai/ioio/wiki ). A great combination of UI, connectivity and development tools for less than $300 in small quantities. You can switch any time to cheaper or fancier tablet (e.g. Nexus 10) with no code change.
Imagine this, your lab equipment will be able to post its reading directly to your Facebook page, or even better, Twit it. Can't be better than that ;-)
If you want be fancy you can even root it and have a modded system (ASOP, cyanogen, etc).
-
See if embedded artists have something for you. I love their LPC1769 boards for €20.- They also have nice ts lcd,s with example code however not very cheap.
-
The cheapest way would be getting a cheap (12-13€) touchscreen panel on eBay:
http://www.ebay.de/itm/370668505157 (http://www.ebay.de/itm/370668505157)
http://www.ebay.de/itm/250906574590 (http://www.ebay.de/itm/250906574590)
Both are using the SSD1289 as display controller and an ADS7843 clone (XPT2046) as touch controller.
Then you just need a cheap CPU board like this one and you're done with ~30€:
www.ebay.de/itm/170896978026 (http://www.ebay.de/itm/170896978026)
-
The cheapest way would be ...>$50
how is that cheaper than
http://dx.com/p/a13-7-capacitive-touch-screen-android-4-0-tablet-pc-w-tf-camera-wi-fi-g-sensor-white-148468 (http://dx.com/p/a13-7-capacitive-touch-screen-android-4-0-tablet-pc-w-tf-camera-wi-fi-g-sensor-white-148468)
?
-
Well, firstly, this thread is about "uC + touch-screen", not about el cheapo android tablets.
Secondly, you brazenly edited your own fantasy price into the text after quoting me. Which is somewhere between disturbing and fishy.
For your education: 30€ are roughly $41 ($US) considering today's exchange course. Also the quoted prices contain a 19% VAT. So the equivalent price in US$ without VAT would be around $33.
Now compare this to your $50 for the cheap Android tabled PLUS $50 for the IO interface and you compare $33 to $100.
And yes, surprisingly $33 IS cheaper than $100. Plus it's what the thread is about.
-
auctions you linked are about $45 not 30 :)
you can interface android tablets with something as simple as attiny, either internal serial or usb using V-USB, not to mention this particular tables uses A13 soc and has gpios you can reuse
-
I guess it would make no sense to explain it to you again.
Anyway, think what you want, but don't quote me with manipulated quotes.
-
The cheapest way would be getting a cheap (12-13€) touchscreen panel on eBay:
http://www.ebay.de/itm/370668505157 (http://www.ebay.de/itm/370668505157)
http://www.ebay.de/itm/250906574590 (http://www.ebay.de/itm/250906574590)
Both are using the SSD1289 as display controller and an ADS7843 clone (XPT2046) as touch controller.
Thanks :-+ , I just ordered one to play around with, do you use emWin or other SW , any URL of free source code?
-
Honestly while I ordered one of these LCDs a while ago and I plan to do something with it in the distant future, I have quite a lot of other things I want to do first. If I ever come to this, I think I'll write my own library for it which will allow to draw text and bitmap graphics at a certain location of the screen but not much more. Mostly because I guess most freely available libraries for simple display controllers will expect a RAM buffer as large as the display buffer. But also cause I think that writing your own low level stuff is part of the fun.
Note that the LPC1768 which I favor for my private projects has only 64k of RAM - which is however split into two non-adjacent sections. So you can't draw to a full offscreen buffer and then send it to the display (letting aside that even with a linear buffer, there would be not much RAM left for other variables).
So instead I'd take a raster line based approach where I'd prepare only one 320 pixel line at once, send it to the buffer, then continue with the next line.
I want to try something like this in the nearer future with an ePaper display and an even smaller controller (LPC812), so maybe I can reuse some code if I ever get to the 320x240 color display again.
Anyway. I guess it should be not so difficult to find some examples or libraries for the SSD1289 and ADS7843. As far as I recall even one of the eBay dealers had some code for download.
-
LPC1768 and 69 are very nice, the 1788 has an LCD peripheral and I believe there is a free version of an emWin library for that controller but only for the Keil uVision or Codered development environment. I will have a look at that some time in the future however i have the same kind of time problems.
-
The cheapest way would be getting a cheap (12-13€) touchscreen panel on eBay:
http://www.ebay.de/itm/370668505157 (http://www.ebay.de/itm/370668505157)
http://www.ebay.de/itm/250906574590 (http://www.ebay.de/itm/250906574590)
Both are using the SSD1289 as display controller and an ADS7843 clone (XPT2046) as touch controller.
Then you just need a cheap CPU board like this one and you're done with ~30€:
www.ebay.de/itm/170896978026 (http://www.ebay.de/itm/170896978026)
The latter display is exactly the same which comes with the Landtiger dev board I mentioned way back in this thread. I attached the example code that came with it - it's not the prettiest, but I hope it saves you some time. I also recommend you remove all the always_inline directives.