LeafLabs Garden » Topic: Maple Native getting HOT when operating transistors

LeafLabs Garden » Topic: Maple Native getting HOT when operating transistors http://forums.leaflabs.com/topic.php?id=1184 A place to share, learn, and grow... en-US Fri, 22 Jan 2016 00:07:19 +0000 http://bbpress.org/?v=1.0.2 <![CDATA[Search]]> q http://forums.leaflabs.com/search.php gbulmer on "Maple Native getting HOT when operating transistors" http://forums.leaflabs.com/topic.php?id=1184#post-7265 Wed, 30 Nov 2011 16:13:05 +0000 gbulmer 7265@http://forums.leaflabs.com/ rosendo <blockquote>Although the second one has "i" and "j" while the first one has only "state", I believe the second is better because "i" and "j" are 1 byte each, while "state" has 4 bytes. </blockquote> I think it is difficult to deduce much without looking in detail at the code generated by the compiler, and doing some measurements. I would definitely advise everybody to avoid jumping to conclusions, and get some evidence instead. if RAM is an issue, then: <code>for (uint16 state = 0x0001; state != 0; state <<= 1) {</code> uses the same amount as: <pre><code>byte j=31; for (byte i = 0; i < 16; i++) {</code></pre> (One 4 byte variable would use less than two 1 byte variables if the compiler flag for 'word alignment of variables' is used.) My reading of RM0008 9.2.5 "Port bit set/reset register (GPIOx_BSRR) (x=A..G)" is all 16 bits in a port are cleared by a <code>GPIOx_BASE->BSRR = 0xffff0000;</code> but an assignment to one of the bottom 16 'set' bits takes precedence. So to set BIT(i) on, and clear every other bit, in a 16bit port: <code>GPIOx_BASE->BSRR = 0xffff0000 | BIT(i);</code> would clear all 16 bits in the port except BIT(i). There is no need for "<code>BIT(i) | BIT(j)</code>" or "<code>state = 0x00010002</code>". Redoing the bit-shifting version gives: <pre><code>void loop() { for (uint16 state = 0x0001; state != 0; state <<= 1) { GPIOD_BASE->BSRR = 0xffff0000 | state; // clear all 16 bits, except the bit set by state GPIOE_BASE->BSRR = 0xffff0000 | state; GPIOF_BASE->BSRR = 0xffff0000 | state; GPIOG_BASE->BSRR = 0xffff0000 | state; delay(400); } GPIOD_BASE->BSRR = 0xffff0000; // switch all 16 port bits off GPIOE_BASE->BSRR = 0xffff0000; GPIOF_BASE->BSRR = 0xffff0000; GPIOG_BASE->BSRR = 0xffff0000; }</code></pre> I haven't dumped the assembler, but I'd expect the bit-shift to be smaller than the code: <pre><code>void loop() { byte j=31; for (byte i = 0; i < 16; i++) { GPIOD_BASE->BSRR = BIT(i) | BIT(j); GPIOE_BASE->BSRR = BIT(i) | BIT(j); GPIOF_BASE->BSRR = BIT(i) | BIT(j); GPIOG_BASE->BSRR = BIT(i) | BIT(j); j = i+16; delay(400); } GPIOD_BASE->BSRR = BIT(31); GPIOE_BASE->BSRR = BIT(31); GPIOF_BASE->BSRR = BIT(31); GPIOG_BASE->BSRR = BIT(31); }</code></pre> which I'd expect to be bigger because <code>BIT(i) | BIT(j)</code> expressions are calculated at run time, and it does <code>j+=16</code> extra and 'i<16<code>instead of</code>state != 0<code>. It is possible the compiler is smart enough to convert this counting version into bit shifting (and the compiler can be very smart, so I would need to examine the assembler to be sure). But it won't know enough to convert to</code>0xffff0000 | BIT(i);`. Of course, if this code makes more sense to you, use it, but I don't think it is 'better' than bit-shifting in any technical sense. If we look at the assembler code generated, we might find that there are several other issues to consider before judging something 'better'. One which is potentially more important than RAM, is the number of registers consumed. If i and j are stored in two registers, whereas state consumes one, the code sequence for a function using i and j may be bigger because the code might need to move register values back to memory to free-up registers more often, or the code needs to use 32-bit instructions to manage the registers. Further, slightly longer code inside a <code>for</code> loop might force the compiler to use a different, larger instruction to branch back around a loop because a compact branch can't jump far enough. Summary: IMHO it is more important to write clear code, and measure performance if it becomes an issue, than making assumptions. rosendo on "Maple Native getting HOT when operating transistors" http://forums.leaflabs.com/topic.php?id=1184#post-7261 Tue, 29 Nov 2011 22:23:53 +0000 rosendo 7261@http://forums.leaflabs.com/ Thanks for the advice! I will take a look and see if I can buy one of these! becker on "Maple Native getting HOT when operating transistors" http://forums.leaflabs.com/topic.php?id=1184#post-7255 Mon, 28 Nov 2011 20:33:40 +0000 becker 7255@http://forums.leaflabs.com/ I'm curious why you didn't select MOSFETs for the output drivers, instead of bipolar transistors. Parts with a 2V or 2.5V threshold can be directly driven without dropping resistors, and consume essentially no power when not switching. Admittedly the best parts are available only in SO8 and smaller packages, but you can find acceptable through-hole parts. Better, search for "inductive load drivers" which include gate protection and an internal zener diode pair to handle the turn-off 'freewheel' spike. rosendo on "Maple Native getting HOT when operating transistors" http://forums.leaflabs.com/topic.php?id=1184#post-7240 Thu, 24 Nov 2011 21:20:21 +0000 rosendo 7240@http://forums.leaflabs.com/ gbulmer, I used your solution to create a "One bit at a time" solution, which is as follows (Just remember that before using it YOU SHOULD COMMENT THE FLASH.LD FILE to free the SRAM from the output pins) void loop() { //delay(30); for (unsigned int state = 0x00010002; state != 0x80010000; state <<= 1) { GPIOD_BASE->BSRR = state; GPIOE_BASE->BSRR = state; GPIOF_BASE->BSRR = state; GPIOG_BASE->BSRR = state; delay(200); } GPIOD_BASE->BSRR = 0xf0000001; GPIOE_BASE->BSRR = 0xf0000001; GPIOF_BASE->BSRR = 0xf0000001; GPIOG_BASE->BSRR = 0xf0000001; delay(200); } In which I could also compare to another fast writing method: void loop() { byte j=31; for (byte i = 0; i < 16; i++) { GPIOD_BASE->BSRR = BIT(i) | BIT(j); GPIOE_BASE->BSRR = BIT(i) | BIT(j); GPIOF_BASE->BSRR = BIT(i) | BIT(j); GPIOG_BASE->BSRR = BIT(i) | BIT(j); j = i+16; delay(400); } GPIOD_BASE->BSRR = BIT(31); GPIOE_BASE->BSRR = BIT(31); GPIOF_BASE->BSRR = BIT(31); GPIOG_BASE->BSRR = BIT(31); } Although the second one has "i" and "j" while the first one has only "state", I believe the second is better because "i" and "j" are 1 byte each, while "state" has 4 bytes. I hope this is useful for anybody that wishes to use all these 62 pins offered by Ports DEFG, leaving Ports A and B for Analog Input and C for the SDcard. rosendo on "Maple Native getting HOT when operating transistors" http://forums.leaflabs.com/topic.php?id=1184#post-7239 Thu, 24 Nov 2011 20:14:21 +0000 rosendo 7239@http://forums.leaflabs.com/ gbulmer, I forgot to delete the last "b" from that stateb, but I already tried your solution and works like a charm! Thank you, man! Now I'm operating 32 valves and the chip is warmer than when it is off (which I believe is natural). The book looks interesting and I`m really thinking about buying it. Thanks so much man, and I wish there were more tutorials on how to use all these outputs that this board has to offer. There are not so many boards with 100+ outputs around the internet. gbulmer on "Maple Native getting HOT when operating transistors" http://forums.leaflabs.com/topic.php?id=1184#post-7238 Thu, 24 Nov 2011 18:20:28 +0000 gbulmer 7238@http://forums.leaflabs.com/ rosendo - A good source for Electronic Design is The Art of Electronics, by Paul Horowitz and Winfield Hill: <a href="http://en.wikipedia.org/wiki/The_Art_of_Electronics" rel="nofollow">http://en.wikipedia.org/wiki/The_Art_of_Electronics</a> They recommend that you don't skimp on base current, because if you are using a transistor as a switch, you want it to switch quickly. Switching slowly will have the device in an 'in between' state (not fully on, or fully off) where it dissipates more heat. I think tcd218's calculations are likely accurate, but if the transistors are getting hot, you might want to *reduce* the base-resitance to see if the transistors need to be driven faster. gbulmer on "Maple Native getting HOT when operating transistors" http://forums.leaflabs.com/topic.php?id=1184#post-7237 Thu, 24 Nov 2011 18:09:20 +0000 gbulmer 7237@http://forums.leaflabs.com/ rosendo - does that code actually work? Maybe you have pasted the wrong version? <pre><code>void loop() { for (int i = 0; i < 32; i++) { GPIOD_BASE->BSRR = state; GPIOE_BASE->BSRR = state; GPIOF_BASE->BSRR = state; GPIOG_BASE->BSRR = state; stateb <<= 1; //Changing the state moving one bit to the side delay(20); } if(int i=32){ //state = 0x00000001; } }</code></pre> <code>stateb</code> isn't declared, so the compiler should print an error, and give up, never loading the program into your Maple. Further, <code>stateb <<= 1;</code> isn't effecting any of the output pins, because they all use <code>state</code>, so the pattern should not change. Also the test <code>if(int i=32)</code> is always true ... IMHO, a more elegant approach might be something like: <pre><code>void loop() { for (unsigned int state = 0x00000001; state != 0; state <<= 1) { GPIOD_BASE->BSRR = state; GPIOE_BASE->BSRR = state; GPIOF_BASE->BSRR = state; GPIOG_BASE->BSRR = state; delay(20); } }</code></pre> <code>for</code> loops aren't restricted to counting, any expressions can be used to update variables. (WARNING: I haven't compiled and checked that code) (full disclosure: I am not a member of LeafLabs staff.) rosendo on "Maple Native getting HOT when operating transistors" http://forums.leaflabs.com/topic.php?id=1184#post-7232 Thu, 24 Nov 2011 00:14:08 +0000 rosendo 7232@http://forums.leaflabs.com/ Thanks man! I could prove that this board is dumb-proof! If it still didn<code>t blow up with me, it won</code>t blow with anybody else! I tried 1.2 k and it worked fine! There are no snubbers here and I will leave like this for a while. If some transistor blows up, I`ll think about it! Just in case it is helpful for anybody, the commenting at the flash.ld file was: /* Commented to avoid using the external RAM _lm_heap_start = 0x60000000; _lm_heap_end = 0x60100000;*/ Usually this part is not commented, so doing this will avoid using the 1Mb RAM, allowing you to use the 56-100 GPIO. For the programming I`m using fast GPIO writing: int state = 0x00000001; //This is just an integer with which I change the states of outputs void setup() { for (int i = 56; i < 101; i++) { //Just telling the board that I will output throughout the FSMC // initialize the output pins: pinMode(i, OUTPUT); } void loop() { for (int i = 0; i < 32; i++) { GPIOD_BASE->BSRR = state; GPIOE_BASE->BSRR = state; GPIOF_BASE->BSRR = state; GPIOG_BASE->BSRR = state; stateb <<= 1; //Changing the state moving one bit to the side delay(20); } if(int i=32){ //state = 0x00000001; } } Thanks for the help tdc218, and for the guys in Maple thanks for the board (and the candy!) tdc218 on "Maple Native getting HOT when operating transistors" http://forums.leaflabs.com/topic.php?id=1184#post-7231 Wed, 23 Nov 2011 23:46:33 +0000 tdc218 7231@http://forums.leaflabs.com/ 2k would probably be fine. Here's some transistor design 101: According to the C1815 data sheet, it has the following characteristics: Maximum collector current: 150mA (.15A) Minimum gain: 70 Base-Emitter saturation voltage 1v So, Ohm's law is R=E/I The minimum base current we need is .15/70 = .00214A (2.14ma). This is I The voltage is the output voltage of the Maple 3.3v - the B-E voltage of the transistor 1v = 2.3v R = 2.3 / .00214 = 1075 ohms. 1k might be better, however in most cases you won't be drawing the max current of the transistor (I hope) and it's gain will be higher than minimum, so a higer resistor, like your 2k, would be fine. And just because I'm an electronics geek from way back, do you have snubbers on your pneumatic valves to protect the transistor from the voltage spike when it turns off? rosendo on "Maple Native getting HOT when operating transistors" http://forums.leaflabs.com/topic.php?id=1184#post-7230 Wed, 23 Nov 2011 23:34:47 +0000 rosendo 7230@http://forums.leaflabs.com/ Hehehe... No, I didn't. Accepting suggestions! 2k is ok? tdc218 on "Maple Native getting HOT when operating transistors" http://forums.leaflabs.com/topic.php?id=1184#post-7229 Wed, 23 Nov 2011 23:33:24 +0000 tdc218 7229@http://forums.leaflabs.com/ You do have a resistor between the output pin of the Maple and the base of the transistor, don't you? If you don't, you need one and I'm surprised you haven't blown anything up yet. If you do, what value is it? rosendo on "Maple Native getting HOT when operating transistors" http://forums.leaflabs.com/topic.php?id=1184#post-7228 Wed, 23 Nov 2011 22:59:03 +0000 rosendo 7228@http://forums.leaflabs.com/ As we all know Maple Native has many GPIO pins. Although some are related to the SRAM, I could manage to "unleash" them by modifying the flash.ld file, so that only the internal 64k RAM is used. (There is some post on this forum about it, and it works!) Happy for seeing all my 3.3V outputs working at the same time and the program still running, I decided I wanted to operate my 12V pneumatic valves, so I plugged 32 of these bad boys to 32 transistors and while the valves are working just fine I touched the ARM chip and he was really HOT! I could`t leave my finger on it for more than 1 sec! So I thought that maybe I screwed up and used the PORTC (pins 7-22) to operate only 16 of them, and it was still HOT (less hot than before, but still pretty HOT). Since the first trial was at some circuit board, I thought that maybe I did something wrong. Then I changed to my breadboard and still HOT. The battery is cold and the transistor I`m using is C1815. Am I doing anything wrong or the microcontroller really gets this hot?