LeafLabs Garden » Topic: Considering Maple

LeafLabs Garden » Topic: Considering Maple - some questions http://forums.leaflabs.com/topic.php?id=1029 A place to share, learn, and grow... en-US Fri, 22 Jan 2016 00:14:13 +0000 http://bbpress.org/?v=1.0.2 <![CDATA[Search]]> q http://forums.leaflabs.com/search.php mbolivar on "Considering Maple - some questions" http://forums.leaflabs.com/topic.php?id=1029#post-6318 Tue, 13 Sep 2011 07:00:56 +0000 mbolivar 6318@http://forums.leaflabs.com/ <blockquote> in Chapter 6 "Backup registers (BKP)" I haven't noticed any code showing how to use them. </blockquote> this has been part of libmaple for quite some time :) <a href="http://leaflabs.com/docs/libmaple/api/bkp.html" rel="nofollow">http://leaflabs.com/docs/libmaple/api/bkp.html</a> here is some (old and slightly embarrassing, but still hopefully serviceable) example code: <a href="https://github.com/leaflabs/libmaple/blob/master/examples/test-bkp.cpp#L1" rel="nofollow">https://github.com/leaflabs/libmaple/blob/master/examples/test-bkp.cpp#L1</a> tdc218 on "Considering Maple - some questions" http://forums.leaflabs.com/topic.php?id=1029#post-6314 Mon, 12 Sep 2011 19:30:59 +0000 tdc218 6314@http://forums.leaflabs.com/ The FRAM sounds like an ideal solution and I'll be looking at those a bit closer. I have done PCBs but never with surface mounts parts, but I have a couple of acquaintances who have offered to help me out so I'm looking forward to expanding my skill set. I considered using flash but the 10,000 write life is too short. It might take me a couple of years to exceed it but I'd hate to zorch a $60 board when there's a $2 solution. So yeah, eeprom or fram will be the way to go. Many thanks for all the info and ideas. poslathian on "Considering Maple - some questions" http://forums.leaflabs.com/topic.php?id=1029#post-6307 Mon, 12 Sep 2011 13:07:04 +0000 poslathian 6307@http://forums.leaflabs.com/ you could try using a page of the onbaord FLASH memory as nonvolatile storage, they are 1KB each on Maple and mini, 2KB each on RET6 and Native. They only get ~10,000 r/w cycles (officially...probably way more) so dont write to them in a loop or anything. I would go with the I2C eeprom, though. These are cheap and work fine. gbulmer on "Considering Maple - some questions" http://forums.leaflabs.com/topic.php?id=1029#post-6304 Mon, 12 Sep 2011 05:53:27 +0000 gbulmer 6304@http://forums.leaflabs.com/ tdc218 - You might also look at the STM32F103's DMA controller. The DMA controller will shift a whole buffer full of characters without interruption. Frankly though, 9600 bps is only be an interrupt at, roughly, each millisecond, so the CPU overhead is minimal. Certainly have a go at porting the Arduino SerialTXManager code, that is likely simpler than using DMA. The SPI interface is simpler to use, and quicker than I2C. As well as EEPROM, you might want to consider FRAM. A friend uses it, and it has the nice property that you can read or write as fast as the interface will go, it is genuinely non-volatile RAM: <a href="http://uk.farnell.com/jsp/search/browse.jsp?N=203669+102138&Ns=P_PRICE_FARNELL_UK%7C0&locale=en_UK&appliedparametrics=true&getResults=true&suppressRedirect=true&originalQueryURL=/jsp/search/browse.jsp%3FN%3D203669%26No%3D0%26getResults%3Dtrue%26appliedparametrics%3Dtrue%26locale%3Den_UK%26divisionLocale%3Den_UK%26catalogId%3D%26prevNValues%3D203669" rel="nofollow">http://uk.farnell.com/jsp/search/browse.jsp?N=203669+102138&Ns=P_PRICE_FARNELL_UK%7C0&locale=en_UK&appliedparametrics=true&getResults=true&suppressRedirect=true&originalQueryURL=/jsp/search/browse.jsp%3FN%3D203669%26No%3D0%26getResults%3Dtrue%26appliedparametrics%3Dtrue%26locale%3Den_UK%26divisionLocale%3Den_UK%26catalogId%3D%26prevNValues%3D203669</a> Have you got facilities to make a PCB, or must it be a DIL part? (The FRAM is surface mount) tdc218 on "Considering Maple - some questions" http://forums.leaflabs.com/topic.php?id=1029#post-6301 Sun, 11 Sep 2011 20:29:22 +0000 tdc218 6301@http://forums.leaflabs.com/ Many thanks everyone. That gives me lots to ponder. The info about the backup registers was especially useful in that my understanding of the Maple's CPU took a quantum leap. On the serial front, I'm constrained by my serial device that only runs at 9600 bps. There's a Arduino library called SerialTXManager that gets around the blocking issue by using a buffer and poling the UART TXE flag via a call from the main loop. Me thinks I'll have to look at porting the relevant bits of that. I2C EEPROMS are looking better all the time. ;) gbulmer on "Considering Maple - some questions" http://forums.leaflabs.com/topic.php?id=1029#post-6296 Sat, 10 Sep 2011 19:54:27 +0000 gbulmer 6296@http://forums.leaflabs.com/ A Farad is approximately the capacity to supply 1 Ampere for 1 second with a voltage change of 1 Volt 6 months is approximately 15.75 million seconds. So, at 2uA, it'd need 2uA*15.75million = 31.5 Ampere seconds crenn on "Considering Maple - some questions" http://forums.leaflabs.com/topic.php?id=1029#post-6295 Sat, 10 Sep 2011 19:35:15 +0000 crenn 6295@http://forums.leaflabs.com/ The Maple needs to be modified to have the Vbat pin broken out, however, this isn't the case with the Maple Mini which does have it broken out. You can also look at using a super capacitor to hold enough charge for the backup registers and RTC, but you most likely won't get 6 months of life out of it (assuming disconnection for that period of time), but that's dependant on the supercapacitor. gbulmer on "Considering Maple - some questions" http://forums.leaflabs.com/topic.php?id=1029#post-6288 Sat, 10 Sep 2011 13:17:57 +0000 gbulmer 6288@http://forums.leaflabs.com/ <blockquote>1. Is serial.print blocking or non blocking? </blockquote> Blocking. <blockquote>... IOW, if I do, say serial1.begin(300); serial1.println("Hello, world"); will control be returns to me in a few microseconds, or in 40+ milliseconds after the entire string has printed? </blockquote> 300bits/second would give 30 characters/second (accounting for start and stop bits). strlen("Hello, world\n") is 14! (last time I looked the single character '\n' is expanded to two ASCII/UTF-8 characters on output). print/println will normally return after the last character has been accepted into the USART send buffer (before the character is sent), so we could reasonably expect it to return after 13 characters (it might be double buffered, making it a character faster). Hence control would return after 13/30th of a second, or roughly 430+ milliseconds. BUT, there may be choices available to you. 1. USART 1 will run at 4.5 Mbit/s, and the other two USARTs at 2.25 Mbit/s 2. You might be able to use SerialUSB, which is much faster than 300bits. 3. You might implement DMA which would return quickly (microseconds), and continue to operate in parallel with your program, while the DMA hardware moves characters to the USART autonomously. This mightbe too complex for you to feel comfortable. Edit: As an observation: if your Arduino program is currently doing I/O at 300bits, then a lot of CPU time will be wasted blocking. If you could use interrupts to output instead, then that might free up an enormous amount of CPU cycles, sufficient for your purposes. <blockquote>How long will the battery hold the contents of the backup registers? My need is 6 months. </blockquote> The backup registers are part of the Real Time Clock (RTC) domain. The current used is under 2microAmps (2uA), according to Figure 17. "Typical current consumption on VBAT with RTC on versus temperature at different VBAT values" on page 43 of the STM32F103x8/xB datasheet: <a href="http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/DATASHEET/CD00161566.pdf" rel="nofollow">http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/DATASHEET/CD00161566.pdf</a> A 3V lithium button cell (hearing aid battery) <a href="http://en.wikipedia.org/wiki/List_of_battery_sizes#Lithium_cells" rel="nofollow">http://en.wikipedia.org/wiki/List_of_battery_sizes#Lithium_cells</a> has a capacity of roughly 30mAhour to 260mAhour At 2uA, a 30mAhour cell might last 30,000uAhours/2uA = 15,000 hours = 625days, or almost 21 months. BUT, you would have to modify a Maple as the Vbat pin is connected to the rest of the power supply system, and it would need to be isolated or the battery would power the entire STM32F103, and be exhausted very quickly. The Backup registers are described in the RM0008 manual <a href="http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf" rel="nofollow">http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf</a> in Chapter 6 "Backup registers (BKP)" I haven't noticed any code showing how to use them. The RM0008 manual describes the steps needed to access them. They are not writable when the processor powers up to prevent them being accidentally overwritten, and the steps are to give access. The registers are memory mapped, so you should be able to get at them by something like <pre><code>(*uint16)0x40006C04 = ...; uint16 myval = *((*uint16)0x40006C04);</code></pre> or uint16 *bkp_registers = (*uint16)0x40006C04; bkp_registers[0] = ...;` Noting that the 2byte/16bit registers are not contigous, but instead exist at addresses 4 bytes apart (so bkp_registers[0] and bkp_registers[2] might be valid, but bkp_registers[1] and bkp_registers[3] would not be valid) (full diclosure: I am not a member of LeafLabs staff) tdc218 on "Considering Maple - some questions" http://forums.leaflabs.com/topic.php?id=1029#post-6284 Fri, 09 Sep 2011 20:31:06 +0000 tdc218 6284@http://forums.leaflabs.com/ Greetings all. I've been building a project with the Arduino and have run out of IO and am getting pretty tight on memory and cpu cycles, hence the Maple (probably the Ret6) looks very attractive to me. I have a few questions: 1. Is serial.print blocking or non blocking? IOW, if I do, say serial1.begin(300); serial1.println("Hello, world"); will control be returns to me in a few microseconds, or in 40+ milliseconds after the entire string has printed? 2. I need a couple of dozen bytes of non-volatile storage which the EEPROM in the Arduino was handy for. Hanging an external eeprom on the Maple is a possibility but seems kind of silly given my small storage needs and using flash doesn't seem like a good idea as the 10,000 write limit is uncomfortably low, so I'm looking at the back up registers in the CPU. How long will the battery hold the contents of the backup registers? My need is 6 months. Can anyone point me to code examples for accessing the backup regs? Are there any I should avoid using? Thanks in advance.