Technology for a sustainable future

Privacy Policy

noreply@blogger.com (Ringmaster) — Tue, 08 Aug 2023 22:55:00 +0000

Welcome to "Sustainable Growth". This Privacy Policy aims to inform you about our practices regarding the collection, use, and sharing of information you might provide through our blog.

Information We Collect

Automatic Information: Like many other websites, we automatically collect information through cookies, web logs, and other technologies. This information might include your IP address, browser type, language, access times, and referring website addresses.

Information You Provide: We collect personal information that you provide voluntarily, such as when you leave a comment or subscribe to our updates.

Use of the Information

We use the collected information to:Improve and personalize the user experience.
Respond to your comments or inquiries.
Send newsletters or updates if you've subscribed.
Analyze blog statistics.

Sharing of Information

We do not sell, rent, or share your personal information with third parties without your consent, except under specific circumstances, like complying with legal requirements or in case of merger, acquisition, or sale of blog assets.

Cookies and Other Technologies

We use cookies and other technologies to improve user experience and analyze how users engage with our blog. You can set your browser to reject cookies, but this might affect some functionalities of our site.

Links to Other Sites

Our blog may contain links to other websites beyond our control. We are not responsible for the privacy policies of other sites. We recommend you read the privacy policies of each site you visit.

Changes to this Privacy Policy

We may occasionally update our privacy policy. We will post any changes on this page, and if they are significant, we will provide a more prominent notice.

Contact

If you have questions about this privacy policy, please contact us at david.losadag (at) gmail dot com.

Last Updated: 2023/08/09

Start Menu does not work in Windows 10: Solution

noreply@blogger.com (Ringmaster) — Fri, 26 Jan 2018 10:22:00 +0000

Clicked but no menu appears (with the right button we get a hidden menu but not complete)

Oddly, the problem is from the display driver, the included one by Windows . Especially if we see the "Windows Shell experience host" tasks process consumes all the time 10% of the CPU or more.

It is because the controller of the graphics card is outdated or not 100% compatible with Windows 10, so generates loops and problems that the program does not show.

The solution is to search the manufacturer 's website graphics card the latest driver available; eg integrated plate-VSTA ASROCK NF6G card is an Nvidia GeForce 6150SE and Nforce chipset 430, and googling with "driver" in the text we yields this result:

So it seems that the driver 309.08 is the most modern available (rather than those available on the website of the manufacturer of the motherboard, of course), and to remove doubts you can search directly on the website of Nvidia, and after installing the 64 or 32 bits driver (which one corresponds to your operating system), voilà! , the problems disappear.

If this solution worked for you, please leave a comment, thank you! :). See you soon!

Building a photovoltaic solar panel using transparent polycarbonate (Updated)

noreply@blogger.com (Ringmaster) — Sat, 29 Apr 2017 15:48:00 +0000

Update: Before you continue reading, please let me discourage you to use polycarbonate, (as I explain at the end of the post): You will be loosing money for the only reason that the cells and the polycarbonate doesn't have same expansion coefficient and lets the water go through it (very slowly), and all the efforts to avoid this disadvantages will fail miserably.

In this post we will see how to build a photoelectric panel DIY the most economical way, yet it is safe and durable (has to endure 25 years). As we shall see, the difficulty of manufacturing is very high, so I recommend it only for the handyman ;). In addition the process is long, but very satisfying if you like the "do it yourself" and are fascinated photovoltaic panels.

I have seen many examples in Internet short - lived home panels , some prepared with wooden frame , I doubt that last more than ten years, or in sealed with silicone tight box (so that moisture comes but then condenses inside unable to leave quickly, corroding cells), whereby the potential savings to the panel in a home goes for the short duration of efficiently it.

As discussed in the previous post , my intention was to use polycarbonate, three times it economical than glass, plus much safer and lightweight whose only problem is that dilates 3 times more than glass, and has a light output somewhat lower than the glass (and falling further to whiten with the sun), but stays within a reasonable range during the first 30 years, which is what interests us.

To fasten the solar cells, I have sought more easily and economically; unused support or back cover, but linking them directly to the polycarbonate, and thus kill several birds with one stone :

Reduces material costs,
Quicken the panel,
Avoid possible accumulation of moisture and / or water, as the polycarbonate is not totally impermeable (no plastic is, unless a barrier metal), so it is desirable that no gaps where moist air can accumulate.
It allows some light to pass between the cells, so that the bottom remains partially illuminated.
Cells give one the more "fresh" are higher performance; per ° C above 25, panel lose 0.5% efficiency. If we let the rear "air" only with a protective coating (paint, epoxy or silicone), will be best refrigerarán, last longer and give more electricity.

In addition to being glued to the plastic cells, no air pockets barely possible eliminate corrosion problems in the cells by condensation.

Note: That was my intention, but as we shall seethe end, if you join me in this beloved adventure reader will see that attach the cells to polycarbonate is not the best option, but it's better separate leave, so that the plastic dilate freely and heat cells not pass directly thereto . You learn from everything. However, we will detail the procedure used in case you want to use glass as this technical solution itself that would in case of using glass as having the same dilatation cells themselves (the endtheare but you wafers very fine crystalline silicon).

The only problem that this configuration may have a failure to put back cover and use polycarbonate, is that it is less strong against wind gusts (although I used iron colorless transparent polycarbonate of 5 mm. To strengthen it ), so there I install it so that the wind can not affect him violently ; for example putting totally glued to the smooth surface of the roof or wall, without gap behind where the wind can sneak and "pry" pulling it as being anchored polycarbonate in few points, wind stress> 50 kms / nr may be overkill coming from the area of the anchors. We can also avoid this problem by placing it in an area protected from wind,

The great discovery was the neutral silicone , as we saw in the previous post; It allows us a lot of play thanks to its UV resistance, high transparency, good adhesion on all types of materials, economical and easy to use.
It would have been ideal to use transparent liquid silicone glue (although it is no longer necessary as we shall see), but I have not found anywhere, I found liquid type Rubson to waterproof roofs but are colored. Transparent only in cartridge format and quite dense.

The silicone layer must be sufficient to stress the polycarbonate delay does not directly affect the cells, but in the silicone cushion . I calculated eye might be a layer of 2.3 mm,

Buying the polycarbonate sheet

Plates 5 mm. PC's have stores (Plasinco eg.) in plate format 3050 x 2050 mm. which can then supply cut into the format you want.

Note: I have chosen to 5 mm. thickness for added stiffness, but 4 mm. no big difference,addition, as discussed below, we have more constructive options ; We could have opted for a plate of 3 mm. and another 2 mm. as a back cover, in Whereby cells will "float" together with silicone dots and the rear plate also connected to multiple points of silicone to the faceplate; I think now is the most durable and tough choice , and so I will do in the next panel to within a month.

A whole plate costs 270 euros, and to seize materials, have tried to make the panel as large as possible looking for the balance between overall size and weight , so I opted to buy midplane (1525 x 2050) cut in two to make two panels 1525 x 1025 mm.
With that size gives me to place 5 rows x 9 columns 156x156 mm cell; 45 cells in series produces 0,56V each give me maximum total 25 volts each panel, which will connect in parallel using a diode double schottky with common positive .

Note: We can make the configuration of rows x columns you better come to us for our project , we can always leaveleast 5 mm. betweencells to make connections, and trying toall panels that go tosame micro-inverter have similar voltage (even of different power). There could also be put 6 rows x 8 columns, but there was no room at the extreme sides for planned expansion of polycarbonate.

As the Chinese investor who've bought I accept up to 28V input, no problem:

Preparing the frame

For fastening of polycarbonate sheet have to prepare a framework or frame of the required size, in any material that can withstand 30 years outdoors without significantly deteriorate. Ideally the same size or 1 cm. smaller, so that the protruding polycarbonate and protect it from the rain.
I have recycled a square tube, leaving a gap between the sensor and the upper berths to separate a little from the wall, as shown in the sketch.

Sketch frame and panel with slit for dilation and wall tie

Materials required : Machine 's welding, small grinder discs and cutting 125x3x22 125x1x22 mm, screen automatic shading ruler, set square, tube 50x50x1,5 mm, electrodes of 2mm steel, etc. We prepare two identical tubes throughout and two for the width considering the extent of the panel, as mentioned.

Using a square and a large smooth surface presented slats ; subject and punteamos with plaque size. You can use wood, but do not recommend it because it is rapidly deteriorating weather.

We finished welds and we have to be something like this. Then I applied paint style forging in the welded areas and which were most exposed to corrosion, this painting carries metal particles and is very good corrosion, very durable with only give a hand.

In the center lack of placing a reinforcement , which fails to end to facilitate placement of the photovoltaic cells.

As indicated in the previous drawings, to attach the plate to the support allowing it to be resized freely we prepare oblong holes in the direction of expansion . In areas where much space is reinforce the attachment flanges, as being plastic allow some movement and are very durable (10 years without significant deterioration).

I have prepared a template for tearing holes, I will use to mark their position and then finish them with the drill bit and drill:

Template torn 8mm. x 2.5 cm long

For this I used large washers 25 mm diameter rubber. Therebelow I will place pieces of polycarbonate of 1.5 mm. so that it can slide (gum would remain engaged, and also deteriorates).

The tapping screws I used are 8 mm., Just pass through the washer. You can also use a slightly smaller.

Once dry paint the panel put in place a presentation subject with jaws.

And proceed to the marking torn, and with an HSS drill 8 mm. polycarbonate drilled and the top metal, without traverse . If the screw-tapping was chosen smaller, we would have to drill with a drill 1 mm. smaller than the inner diameter of the screw thread.

It is very important to make holes in the innermost part possible to leave enough plate material on the sides ; 2 cms. It is more than enough, to make it strong and not break too easily.

To finish cutting torn'll use a sharp drill bit that has good lateral cut, and holding the template, we help the drill to continue tearing,

also we will tear slightly outward, so that the panel also hold contractions possible frost, and not screw the latching break where. It is a delicate operation that needs to be done with skill and patience.

In my case, as the screws are very long, they moored on the other side, so I finish through the tube with a 6 mm drill. and then put the screws with washers and separator polycarbonate, but not too tight, leaving half mm. about slack to permit free movement of the plate .

To fix them, as they are lazy, I have given them a spot weld on the other side and I cut.

Placing solar cells on the plate

For this first remove the protective film of the inside plate; thanks to the same panel has been preserved without any chafe (remember that it is very easy to scratch):

It's time to mark lines that will guide us to place the cells. Using a plastic the same size as a guide check the distances; We have to consider leaving at least 2 cms. at each end for the dilations of the panel, and between cell and cell minimum 4 mm. to facilitate connections.

Hacemos unas marcas con las divisiones necesarias, e improvisando una regla marcamos con el bolígrafo o rotulador que se pueda eliminar fácilmente una línea discontinua.

Colocando las células

Una vez que tenemos las células fotoeléctricas preparadas con la pista soldada en su lado negativo, con la longitud suficiente para unirlas después al lado positivo en su unión en serie unas con otras, las vamos a ir poniendo sobre el policarbonato.

No explicaré aquí cómo se sueldan, pues hay numerosos vídeos en internet, y tan sólo necesitamos un bote de flux, pistas de cobre estañadas, y un soldador de 60W mínimo con una punta con una zona de la anchura de la pista, y mucha maña y paciencia.

Atención: Las células son obleas de cristal sumamente frágiles, hay que manejarlas con mucho cuidado. No os preocupéis, porque aunque en un principio os cueste, enseguida os acostumbraréis a manejarlas como si fueran discos de CD extremadamente frágiles. ¿He dicho frágiles? Frágiles no, lo siguiente ;).

Celulas policristalinas 156x156 mm de 14,4% de eficiencia y 3,5W de potencia adquiridas en Ebay

Colocamos las celulas a presentación para ver qué espacio hemos de dejar entre ellas, ya que iré colocando una a una sobre un colchón de silicona neutra.

Empezamos el proceso en el lado donde van a ir las pistas sueltas para que éstas no nos estorben según vayamos colocando células. Primero echamos un cordón de silicona suficiente del tamaño de la célula.

I smoothed with a spatula trying to leave the same thickness throughout the frame:

And then we carefully cell, pressing them against the silicone. So we must use a smooth surface of the cell size, with a thin rubber on the side that touches the cell to fit and tighten carefully, to reduce air pockets. (However this is not necessary if you use another more correct than this method and we will see in the next post ).

Si oímos un crujido, es que la célula se ha agrietado o roto. Ésto no supone un problema grave siempre y cuando no quede ningún trozo de la célula separada del resto. Y aunque así fuera no reduce la capacidad de las demás células. El problema puede venir si la rotura afecta a la zona de las pistas. En definitiva: Si rompes una célula y la grieta se puede ver a simple vista, es mejor cambiarla.

El hecho de separar la célula del policarbonato con silicona nos va a permitir luego soldarlas con facilidad una vez la silicona esté seca.

Como veremos en la entrada siguiente, no es conveniente hacer una capa de silicona, sino que es mejor aplicarle una finísima capa de protección directamente a la célula en el lado de contacto con el policarbonato, para proteger, y una vez seca colocarla en su sitio, con un cordón de silicona sólo por el contorno para sujetarla y que quede flotando sobre el policarbonato (antes soldarlas usando un cuadrado de cristal del tamaño de la célula para aislar del policarbonato); os lo explicaré mejor en la siguiente entrada con un vídeo. De esta forma evitaremos los problemas relacionados con la dilatación, mejoraremos la transferencia lumínica y gastaremos menos material, facilitando a su vez el posible cambio de una célula averiada.

But you elijáis you elijáis materials, the construction process of a panel is similar; we placing the cells with heads of each row to a different side, and next to the opposite side to then join them easily in series (typically 36 cells, put 45):

In the pictures below you can see how they look.

When I finished I left over a quarter of a cartridge silicone so I applied on the sides of two rows.

You can see that the cells are placed zigzag by

Now we are left to wait a week for the silicone to dry thoroughly . It takes a week because the glass wafer is opaque to the passage of air molecules, so that silicone can only be hardened by the action of air molecules that can enter through the front polycarbonate and narrow lateral space on all.

Tracks welding cells

The next step is finished soldering the cells together . We need a powerful 60W soldering iron, and about 50 mts roll track 100 cells 156x156 mm. tinned copper 2mm. width of good quality.

We verified that the tracks are well in place. The gray side is the positive part of the cells, while the side that faces the sun is the N (negative) semiconductor.

As you see in the next image, given the expansion of the polycarbonate is very important to leave a bent portion in the tracks between the cells so that they can freely stretch and shrink about 5 mm.

Once prepared, we can apply liquid flux or pencil brush (without welding is very difficult, since it is necessary to remove the oxide layer of conductive thin layer):

We spent the welder holding the track on your site slowly letting the cell tin melts. A single pot of 15 ml flux. I will come to prepare 10 solar panels as this . I bought on Ebay for € 5 + postage.

If you want to avoid having to remove any of the cells after soldering, it is highly recommended that prove the tester before bonding ; in my case one of them, I do not know for what reason, I was very low resistance, only 5 ohms, indicating a clear short (perhaps damaged when welding the track on the other side) while normal is between 200 ohms and 1 K, depending on the light incident on them (the brighter, lower resistance).

Appearance gap after starting the cutter damaged cell.

Finally we have joined the ranks. Usually it uses a wider cable , but you only have to use two tracks joined together to allow a greater flow of electricity . As you can see, I have placed flat cables inward to make room at the ends and to rid the frame when the plate dilate. Very important to isolate the positive side, I used two layers of duct tape. To bend the cables, seek not to touch the corner of the cell to avoid a possible short.

The thickness and width of the tracks used is sufficient to withstand 300W lossless, so we should not always worry that the welds are well done.

Detail connects two rows in series with double welded wire

Checking performance panel

And time of truth arrived; We will check panel performance before finishing seal the back of the cells with Brushed silicone.
As you can see in the picture looks very good, and although they have been air bags, they do not affect their performance as we shall see.

Panel sun of February 18, 2014; Note the flanges that I placed to improve the attachment

I have tried to put as facing the possible sun panel, and a theoretical maximum power of 3.5W per cell, ie a total of 157W, I have obtained peaks 132W , so at first appeared to be a success (taking into account losses of 10% of the investor, the small positioning error that may have), tells us that we lose about 5% yield for polycarbonate and silicone, which is not bad, and which confirms that these cells do not exploit the UV range of light (because this plate Lexan reflected; both sides are protected against UV ).

I think solar radiation in winter and summer is almost the same, the only difference is the angle of the impinging sunlight (in fact in winter the sun is a little closer). Why panel production fits the theoretical.

An electronic meter (measures the flow of electricity in both directions) serves ( source )

Note: If only one cell is left in the shade , panel production will be 0 watts. And if half of a cell stays in the shade, the production will be half. In this situation the panel does not produce shadow, and the shaded area behaves as a resistance preventing passing electricity consuming production and the rest. So are important blocking diodes , as discussed in a subsequent input when dealing tilt and protection panels.

However the one hour in the sun, the problems started . As shown in the figure below, 3 cells that were already weakened by microcracks to place them , they could not stand the strain and crack are finished (you can see the cracks illuminated):

Carefully examining said cells, we see the severity of the case. When removing the panel temperature was 35 ° C polycarbonate, and about 45 cells. If this has happened to these winter temperatures, I can not imagine what will happen in summer .

Cracks in cells: When cooled hardly appreciated

And not only that, but the downside being attached to polycarbonate, the same electrically loaded, attracting pollen particles in the air that had been statically charged by the sun . in one hour the presence of pollen was quite evident. Possible solution to this unexpected? Maybe it's because it was isolated from ground (on a wood), and when placing tied to the wall this load deviates naturally.

Given the relative failure of the experiment (I should have tested samples different ways of placing the cells before anything), ~~I have to separate all cells that are intact with a sharp knife :(, and place more separation. I will now tell What's it going, should not be recoverable,~~

02/24/14 Today I retested the panel and continues to 130W in full sun. Since releasing cells is unfeasible without breaking, I'll leave them as they are, and see what happens with the rest in summer; as in 156 mm. measuring cells expands only 1 mm. , You may have just broken that were already weakened. I will install and continue with the other, placing them otherwise on the polycarbonate.

In the next post we see how placing separate PC floating, with a thin layer of silicone to protect cells first, and once dry, place them and we subject with a bead of silicone around only by the outline to keep in place and get best sensor performance while reducing work.

update 05/05/2014

DEFINITELY as you can see in this post, pasting polycarbonate cells it has been bad idea. Not only dilation broken half cells but silicone reflects light where it has been taken off, reflecting light and hardly passes light, reducing the maximum power of 100W of a theoretical 160W, and also electrons cells have chemically changed to silicone, amarronándola (by destroying the links I guess) and even damaging the polycarbonate partially (one of them I hit only about replacing another broken and still perfect, indicated in red, the rest of silicone badly retired are the previous one).
In addition, when much heats the sensor, the power delivered is reduced to 20W to separate some of the cells into several pieces. Still it works, but delivers 100W briefly (if the temperature is low).

To use it better, I can only remove all cells with a knife to clean glass ceramic and back to hold them otherwise they do not put at risk by placing them directly against the polycarbonate and then sticking them with a bead of silicone around as I finished doing and I comment on this entry . Or better put some support and above polycarbonate ...). We continue to investigate ... but it seems it is best to use glass and then a layer of epoxy as does the handyman:

Part 2

Part 3

Sources:

http://www.electricidad-gratuita.com/multimetro_solar.html

Project photovoltaic panel polycarbonate (Apparently I was not the first;)
Encapsulation of photovoltaic panels home
photocell Spanish Wikipedia

Maintenance of the DIY solar thermal collector

noreply@blogger.com (Ringmaster) — Wed, 19 Apr 2017 15:49:00 +0000

Getter and repaired

Hello dear readers, I do not know in your area, but here in northern Spain we have had a February 2017 very very windy, with gusts over 100 km / h (some kind of cyclogenesis ), so strong that it removed literally one of the panels of cellular polycarbonate, and after the noise we heard, we have found, pushed by the wind literally against a tree!

So light it is (1 cm wide and 1 mm wall), who knows where we have found it if the tree was not in the middle of his path. Even it had a brown mark, a sign that before it arrived there, it hit the tiles of the house, partially breaking it.

But this would not have happened if the panels had been properly anchored, and better protected from the wind. On the one hand, the wood of extreme suffering the ravages of rain, rotting it, it should put more sheltered. And secondly, the screws that secured panels only the timber were fastened, when should having crossed and fastened to the rigid metal under it much safer.

So we had to repair the collector, because it works very well saving on the energy bill.

Now with the Arduino screen , it calculates approximately the KW of energy saved, and within three months of operation, already has 15,000 kW (of which 60% would be from biomass). So in a year I estimate that at least saved 24,000 kW of gas, at the actual price, we have saved nearly 1,000 € per year using the energy from the sun, and in 7 years since the system is working... has already paid itself various times. I am never tired of insisting that we must use more energy from the sun to heat the water at least, we are wasting energy not doing so, which is fossil (gas) and produces CO2.

Let's do it

The first to do was unscrewed the remaining bolts with a socket wrench and screwdriver battery, release the tubes and remove them where they do not clog:

You can see the condition of the wood, it was worth watching:

We take the reform to improve the insulation of the bottom. I placed extruded polystyrene strips, glued together with some silicon in the contact areas with the metal floor:

I helped to cut a ruler and a knife or cutter, with cuts sloped according to the shape of the floor:

To let dry the silicon, I placed weights, firebricks, 1 kg. each, to ensure they stay in place. The length would be approximately the same as would clog the base of the sensor, shorter than before so it avoids rain:

Then I placed thin wooden plates, in this case box lids, with a thickness of 4 mm. in the center and 2 cm. in the frame. The process is very similar to the already made above in the previous version of the collector; silicone covering the joints to prevent air leaks:

Let screwing with screws thread-plate 10 mm. head and 9 cm long timber to the peaks of the metal roof first making a through hole with a drill HSS-Co thinner than the bolts to avoid cracking the timber and expedite the work.

Before painting of black, I applied a protective paint for wood (pine this is sleazy) to protect longer, in areas where it will be exposed to climate:

Once all screwed, I painted with matt black paint the entire base:

Subsequently placed under where the transparent cover, slats of the same height would anchor tubes of moisture resistant wood (used to baseboards) and screwed with large screws to the wood, and then painted as the rest:

At this point I had another improvement. To better protect from the wind and rain, the lower end is left without raising up, so that the polycarbonate curved left, closing better, and also anchor the edge directly to the metal:

We put back the circuit stainless tube. with aluminum plates, and we connect again:

I will paint again, but not before some wood screws hold the base so that it does not move:

This time the connections and temperatura sensor are on the outside, so it will be easier to maintain:

With the paint dry, the next day we put back the polycarbonate sheets in place, they still retain 90% of its transparency. To avoid losses, before I put them, a aplied a bead of silicone all around (in the picture had not yet applied):

A powerful screwdriver and the same procedure, but this time looking for the ridge of metal floor, to make it very safe and much more durable. It is advisable to leave 30 cms between screw and screw for possible expansion of the summer heat.

It is essential to place the screws with rubber washer to catch more surface and stay safer, as the polycarbonate hardens and weakens the sun.

We put the panels 10 cm one over other, wherein neutral translucent silicone applied, leaving spaces of 20 cms screwless margin for expansion zone.

And this is the aspect that taked:

Finally screwing, each 40 cm, also the corner to the plate:

A greater drop that will help drain the end shown , in turn preventing that wind gusts have a greater hole through which pressure meter:

And this is all, the thermal collector is repaired, hopefully for 20 years (we'll just change it when whiten too).

In the next post we will see how best I have isolated 20 m of tubing that cames to the water accumulator. Thanks for reading me!

Update 04/06/17: You can see how the first heats, the top folds up, as it did before; It is important to allow between tie and tie as indicated, with the screw holes with 3 mm. slack to avoid cracking / breaking:

Cleaning and drying a smartphone that has fallen into water: Eg. the NEXUS 5X

noreply@blogger.com (Ringmaster) — Fri, 10 Mar 2017 20:26:00 +0000

To repair wet electronic boards , like a mobile that has entered him water, as this Nexus 5X that, despite rapid action he took water by charging connector, speakers and hole cards, it is best use pure alcohol or distilled water and an ultrasound machine , in addition to rub with a soft brush on the visible parts (and still no full guarantees, as if you were running shorts could damage a chip).

If you do not want to complicate , and you have 30 or 50 € which typically charge for repairing these problems, better take it to a repair center phones with good professionals, you will leave no trace of water or debris and running (but do not light after the accident), or try the Waterrevive liquid (which works very well if turned off immediately).

But if the water has not reached penetrate into the metal lids of the base plate (where sensitive to interference electronics is hidden), we can obtain very good results without ultrasound machine with brush and distilled water or alcohol (alcohol It has the advantage that evaporates easily later).

Waterrevive : A couple of young Spaniards have developed a liquid that promises that your phone back up and running in 98% of cases, they say. This liquid (possibly alcohol, distilled water or other solvent of mineral salts) introduced displaces water (containing mineral salts) preventing depositing causing short circuiting. Using this system has good result if we turned off / disconnected the battery quickly, before the lime and salt is deposited. If that system will not work, you can try these indications (100% of cases so far) .

Have you purchased Waterrevive and has not worked for you? Try this system. As I said in another entry , if not completely disarm mobile and apply ethanol with a small brush or brush to remove the remains of minerals deposited by the evaporation of water electrolysis or temperature occur, the mobile will failures, crashes and random reboots. A moisture absorbent used only if the water has not reached the circuits.

I will explain how to clean and dry a moving step by step, basically:

We can find a tutorial on Youtube to disarm our model .
We will loose the motherboard to clean it well debris with brush and 96º alcohol (ethanol).
Secaremos parts with a hairdryer an hour or leaving them near a heat source (and stay between 40 and 50 ° C for about 8 hours to ensure that there is no water or alcohol).
We mount everything again and if no internal damage to the chips, will run again.

Of course, the guarantee, as wet, active humidity sensors that void.

The Nexus 5X released with a scalpel or sharp like (plastic if possible not to scratch the top), and after releasing the cover screws electronics, see the motherboard. This model takes the well attached battery and could be damaged by forcing her to pull away, but not necessary:

First of all, we release the battery connector to continue working:

Disconnect all connecting strips levering with a piece of plastic to separate the motherboard, including the display connector:

Both in this area and the white card limescale appreciated with chips

Affected areas calcareous / depositions minerals causing electrical offsets

You will find whitened areas like these do not go out without applying a brush

And carefully took it off the plate , the most expensive part of the phone (apart from the screen):

See marker moisture under the active plate, red:

A loose once the pieces, the hardest part is rub gently with a moistened with alcohol brush to remove traces of lime and water still present (can appreciate with a magnifying glass), especially in areas where areas look shutouts, which is usually around tantalum capacitors (rectangular pieces brown) and transistors. With next to fix I will engrave a video of it (I never remember to do so).

Then we dry everything well, first with an absorbent cloth , then you can give the dryer or left overnight next to a heater or stove (I put the pieces together with the pellet stove), controlling not to go up to 50 temperature with an infrared sensor or touch:

Remount the phone, and voila! The scare arranged ;).

Adding hot bed BQ Hephestos 3D Printer: Compiling and installing new firmware

noreply@blogger.com (Ringmaster) — Thu, 09 Mar 2017 20:25:00 +0000

If we want to print in ABS, heated table need

There are instructions on how to do this on the official website of Spain BQ, but are outdated and only explain how to do it in version 1.4.2 , which differs substantially from the latest firmware more refined versions , such as 2.3.1 or 2.4.0 ( do not not try it with 2.4.0, it gives compilation error at the very beginning).

Well, in short, I will show how to compile the firmware to serve you for these and subsequent versions , with optional hot bed activated and working properly. But first, I show how I've ridden (and there tutos on youtube so I save this part - The guy in this video , although physical and clothing clavadito me, not me lol).

A clause ... is a company of the stature of BQ should have precompiled firmwares with different options , and let the user choose (even versions with height sensors for self - calibration table), it is outrageous that a user who does not have know anything about compilers, have to eat the head ... even though deep down that is when you ride a printer that whole piece yourself ... but it is a trifle compile and save many headaches (there are several threads forums questions about this topic).

Before anything else, apart from the table, cables and thermistor, to feed the table need a power supply of at least 12V 8A ( best of 11 or more); the more heat amps before the table and more easily keep you warm. The most economical and reliable is to use an old power source ATW at least 300W, by looking at the indicating amperes for connection + 12V, are durable and well refrigerated fan:

To turn on the power, simply bypass the green wire with a black, or better put a switch on if you want to leave it off when you wear PLA:

The plate BQ bring printers bring a MOSFET with heatsink 20A can handle perfectly , but better to avoid passing all that power by feeding the Arduino 2560 board and do apart with a relay.

This is the electronic solid state relay that will use up about 80A peak.

When using a relay independently of the Ramps / Arduino electronics, you can also use a source other voltage (5 to 20V) because all the energy is converted into heat, we discuss Watts, if the transformer is 12V we 132W and 11A, with an atmosphere of 20 ° C is enough to warm the bed in 3 minutes keep warm at 70, although obviously you take less the more powerful. BQ sells one of 25A for 30 €.

To operate power to the relay, I have bridged two wires from the main power to the bed, in the green power terminal block (the relay does not consume almost anything, so it can be thin wires):

Below left, indicated by V + and V- feeding large bed

I will not go into too much detail in the placement of the table; not to stir too leads me what I did was to prepare the first where happen so that they could be bent without stretching or caught anywhere by moving the table back and forth and back.

The thermistor is connected bed right next to the thermistor injector, gives the same polarity

I used Kapton tape to tie them together and stiffen the set , and each cable not to walk by.

Then I cut calculating that with maximum extension, something left over cable , passing beneath into place each:

Then I've soldered them, with the thermistor stuck in the hole and protected too (at this point it is convenient to put on the other a piece of Kapton tape and transparent silicone to fix the thermistor)

and finally we tied well with Kapton tape.

The bed is then tied with springs and screws replacing the original base , and just below the glass. The glass isolated over a little heat, and there are people who directly use hot base without glass at a lower temperature, but I don't recommend it, sooner or later we will damage the tracks that hot.

I have placed the relay in the back, when fed 12V it triggers on the flow of current, which directly feeds the hot bed. One pole transformer to feed the bed is connected directly, and the other int the relay switch. Once everything is connected and updated the firmware, you can leave just below the electronic board, but fixed with a plastic hose:

It is necessary to tie the relay so it will not move with the movement of the cables to the table

To connect the power to the table I used a MOLEX female connector, to disconnect in the necessary maintenance (the yellow cable is ATX 12V source):

And now the hard time... compiling the firm with support for the table

First of all, download the source code from github repository 2.3.1 BQ, (or the latest version where they are different updates ), it is the "source code (zip)" file. 2.4.0 I not compiled with me (missing files)

We unpack in a folder, where da same, but it is advisable to leave for example. C: \ Marlin to simplify the steps.

Requires Arduino installed in C: \ (see instructions in the documentation of the web) , plus USB drivers, so we installed in C: \ Arduino with drivers (which also allows us to easily find out which COM port is assigned tools -> Port to open the IDE, you need to know to start compiling).

Installs finally open code compiler Make for Windows, downloading it from this site .

Recently they have made improvements so that the same code support all BQ printers (bravo for them, easier to maintain and improvements apply to all), so that before compilation we asked for the printer model (Hephestos in my case), language (Spanish) and COM port Windows has assigned to the printer.

It is no longer necessary as in previous versions use the Arduino IDE, have created a script that does it all for us; compiles and flash directly, making sure that everything went well.

For the warm bed to work, we need to make a couple of changes in the configuration.h file that is within our printer folder, in my case \ Marlin \ config \ hephestos. If you see complicated, here you can download and modified sources for this printer, version 2.3.1, which only need to compile.

We need to find and uncomment (remove the two principle //):

// #define HEATED_BED_SUPPORT -> #define HEATED_BED_SUPPORT

And finally change this text 0 for 1 :

#define TEMP_SENSOR_BED 0 -> #define TEMP_SENSOR_BED 1

Save the file and we can compile. First of all, connect the USB cable from the card to the computer, and open a command window with 'cmd' and running it as administrator (usually in the Startup folder -> 'System Windows' in Win10 or accessories in Win7 and earlier).

We write in the command window:

' Cd .. ' until we get to the root C: \ (if we are not in C :, change with 'C').

' Cd Marlin ' (the directory where the files to compile left)

run 'make.cmd ' (all without the quotes), and answer the questions (model, language and COM port number, as we have said above we can check with the Arduino IDE).

If you've installed everything correctly, the IDE and the GNU Make installed properly , you should be to compile and within seconds get to burn the firmware on the plate (you'll see the flashing lights of the plate communicating through the serial port). The command window will look something like this:

Now, when you restart the printer, you will see a change on the screen :

Previously with the previous firmware we saw this:

And now we see this , indicating the temperature of the bed and the desired temperature by the program to the right of the bar (and will not get printed to achieve, and which is set in the generator program Gcode like Cura or another):

Keep in mind that the previous programs, made no warm bed, not activated, so not worth us to ABS or other requiring warm bed.

I use different profiles in the Cura, one for PLA, one for ABS and another for Filaflex (facilitates the task of change of material);

In the Advanced Settings tab, indicate that it has hot table (Hotbed).
Completely deactivate the cooling fan, it is better to cool slowly to avoid cracking (it is extremely hard).
Injection temperature 235 ° C and at 70 table.

The ABS to grip it tightly to the glass is best to mix acetone with traces of ABS in a ratio 6/1 (expected to go dissolving) in a spray to spray on the glass (if still not well attached, a polished glass or frosted white grips better).

The PLA to be environmentally friendly and cheaper, I use for prototyping or confectionery pieces or children 's toys (non - toxic), whereas the ABS for more durable and resistant parts that are exposed to moisture or want to last more than 2 years with high humidity (the PLA for its organic nature from sugars, moisture becomes brittle and then dissolves).

In addition the ABS , if we print in a closed and much much local generates noxious fumes, so it is advisable to keep ventilated, but without sudden changes in temperature, q ue it become brittle during printing.

Bibliography:

https://github.com/bq/Marlin/blob/master/Documentation/Windows_Compilation.md

BQReaders Forum (English)

Repairing and updating a Lacie NAS (Fvdw version at Plugout.net)

noreply@blogger.com (Ringmaster) — Wed, 08 Mar 2017 08:16:00 +0000

If you have a Lacie NAS with a broken hard drive, it is very difficult to recover the Lacie firmware/partitions, but we can replace the HDD and install the Fvdw firmware version with this tutorial and improve its possibilities by the way.

Previously I explained several improvements with hard drives (NAS) I drive, Lacie brand with Linux firmware.

These small file servers have as main advantage that allows us to have servers of various types, in addition to files with very low power consumption (less than 10W in general).

The fact is that there is an alternative firmware developed improved from the LaCie sources that have compiled Plugout.net guys that we can install in our NAS, which greatly improved the performance of our network disks , adding possibilities as possible choose media server (ideal for home), NFS, VPN, etc servers and download torrent files, among others. And it also serves to revive the NAS if the hard disk fails, and see, step by step, the installation process.

Faster , it is having been optimized with the latest software versions, up to 40% more agile list of directories and copy files.
More reliable, uses file systems safer.
More complete , with all the features expected from a small server.

On this page you can navigate and explore virtually all of its features , which summarizes Fvdw (creator and main administrator) in the following list:

fvdw-sl is software (firmware) package for controlling and operating NAS devices,
Currently suported devices by esta firmware:
Lacie: network space VS1 and VS2, internetspace VS1, edmini_v2, internet space VS1 (VS2 Present but not tested yet), Cloudbox ( White & case).
Philips: spd8020

The firmware has following features can be controlled using That a webinterface. Two interfaces are available web (v13.0: new)
web interface The administrator has 14 menu's, each with Several sub menu's.
The user web interface has only 3 menus
Menus list of the web administrator interface:
1. System management
information, setup date time, language of web interface (Inglés, french, german, dutch), enabling https protocol for web server, LAN setup,

This firmware is compatible with:

Lacie: Network Space 1 and 2, InternetSpace 1 (2 also but has not been tested yet), Edmini_v2, Cloudbox (white box).

Philips: spd8020

Anyway, I do not advise installation on the Network Space 1 (I still maintain a copy its partitions on google drive), because it takes up more memory than the original and the very poor 16 Mbytes of that NAS can make it go slower than the original version Lacie.

To install, you can download files of version 16.1 this link ( do not forget to read the steps File "install_fvdw_sl_firmware_hlp") or register on the forum and access the latest versions of the firmware . If you find the software useful, thank considers the hours spent Fvdw the developer through a donation.

Before installation, please Leete all steps . In case of a Network Space 2, there are two different versions; The lite version supports GPT more than 2 TB, whereas the classic version needs an update u-boot to support it , so it requires a "dangerous" update program that is responsible for loading the linux system disk, and if we're wrong we can leave the NAS unusable; if you're not sure know how to do, you can always use disks of 2TB, for daredevils, in the "help" directory you have the "flash_uboot_hlp.html" file with precise instructions.

NWS2 differences between the lite and the classical NWS2; the classic has a sink touching metal

STEPS FOR INSTALLATION

It is convenient to read the first indications for a first installation (also in the "install_fvdw_sl_firmware_hlp" archive).

For the installation no problem (with virtual network connections), it is best to turn off all network connections in Windows unless you're using :

Then temporarily disable the firewall (disconnect the router from internet security):

With the NAS off, we open the fvdw-sl-console.exe program and configure the NAS IP known (if not we know we can use the fvdw-sl-assistant.exe to search on the net) and the IP of our PC (the password in the password file):

And we give to install firmware on the Action menu :

Asks for confirmation of whether we are sure you read the instructions:

And before choosing kernel, explains briefly what kernel corresponds to each type of NAS:

Select the appropriate kernel (if wrong, simply will not work as it loads it into memory with the u-boot boot, but in principle it does not spoil our NAS):

And by accepting us automatically open the FTP "tftpd32" Windows server, which will send the files:

And the command window with information about the process, waiting for the boot program responds to a request for update on the NAS. It is at this time when you connect and turn on:

If all goes well (right IP, etc.), we the process of sending the file appears to memory as soon as we light:

And after a while, you run the file in memory, which is a binary with the kernel chosen (has not yet touched the hard drive, which is where the firmware Lacie is, so if we can try another hard drive if something goes wrong ):

Showing typical checks available hardware makes Linux:

And finally shows a login window:

E indicate the root user and password giveit2me

If not automatically open the script with blue background, then we have to do some steps manually to copy and run it (read the help file above):

Alternatively uploading the install script to NAS ( If the installer does not automatically open)
In the telnet window put: tftp -r installer- fvdw-sl- x .sh -l fvdw-sl-installer -g ip-of-your-pc Replace xy for reviewing the script (usually 3-0) in the tftp directory and ip-of-your-pc with the IP of the computer from which you are upgrading, indicated in the main window program fvdw-sl-console.
After the script is transferred to the NAS, make it executable by typing: chmod 755 fvdw-sl-installer
Start the installer running on the telnet client: / fvdw-sl-installer ip-pc (replace ip-pc by ip computer)

When the installation program running on the hard drive, the installer will appear:

Again select the corresponding kernel (the same one that has allowed us to start); if something goes wrong, just repeat the whole process:

It warns that the disk be deleted:

We asked whether the disk is larger than 2TB, if so give itself:

It warns that it will proceed to create partitions (if> 2TB GPT, if it is <2tb 1="" and="" div="" he="" him="" is="" it="" mbr="" more="" nbsp="" network="" only="" other="" put="" so="" some="" space="" support="" to="" up="" useless="">

Then proceeds to copy the firmware via FTP server hard disk:

And already it is installed, so we can restart with the "reboot -f" command without the quotes:

You will be assigned a new IP address by DHCP to restart, so we found using the search wizard:

And with any browser can access the brand new firmware indicating the IP found:

The first thing I did was change the network settings , and check that everything was correct. Now you have more possibilities and the NAS is more mine than ever :)

I hope you will enjoy your file servers with this improvement, and do not forget to re-enable the firewall and network connections! :)

Improving the Ebike with Arduino to monitorize battery and add anti-theft alarm 2/2

noreply@blogger.com (Ringmaster) — Fri, 13 Jan 2017 08:40:00 +0000

As discussed in the previous post, my goals to put a microcontroller programmed with Arduino on electric bike they were:

With an RGB LED display the charge / status of the battery monitoring one of the (weaker if possible) cells, to avoid surprises of not having enough charge for the trip the next day, showing orange when needed recharging (between 20 and 40%).
With an accelerometer and a powerful piezoelectric speaker (and a mosfet to activate) we can add an anti-theft alarm, easy disabled with a button hidden from view, which is very handy against foreign's friends.
And even (this slope time), add light automatic brake using the accelerometer (which changes from low intensity to high intensity when the accelerometer receives a deceleration in the axis of the fly), to keep usage statistics (number of refills, airtime, or adding small OLED display to show instant consumption in Ah with a Hall sensor (such as Allegro ACS75x, etc), battery charging, etc.

So this Christmas I could get down to work, and start to test in a breadboard to get something functional:

And this is the current version of the program, with LED and accelerometer for alarm ( also on Github ):

 /*  ==================================================================

  Sketch control pensado para un Atmel 328
  Activa un LED RGB según el voltaje y tipo batería (Divisor voltaje)
  Morado sobrecarga, azul 90-100%, verde 50-90%, amarillo del 30 al 40%,
  naranja del 20 al 30%, rojo 10 al 20% y rojo parpadeante por debajo del 10%

  Además, cuando está "dormido" vigila si alguien mueve la vici con el GY-521,
  haciendo sonar la alarma en ese caso.

  Autor: David Losada, basado en trabajos previos de otros autores:
  Parte de código de la referencia rápida del Digispark: http://digistump.com/wiki/digispark/quickref

  Code for the MPU-6050 Accelerometer + Gyro
  By arduino.cc user "Krodal".
  July 2013
  Open Source / Public Domain

  Version: 0.91 bajo licencia GPLv3
  Fecha: enero 2017

  Includes NeoPixel Ring simple sketch code from (c) 2013 Shae Erisson
  released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library

  ==================================================================   */

//#include  //La librería Neopixel ocupa demasiado en el ATtiny; anulo toda la parte de guardado de datos estadísticos
#include  //Para el control del led

//from https://bigdanzblog.wordpress.com/2014/08/10/attiny85-wake-from-sleep-on-pin-state-change-code-example/
#include 
//Librerías para dormir al procesador y ahorrar energía cuando no hace nada
#include 
#include 
#include   //creo que al final no se usa, pero mejor dejarla (el compilador no la incluye si no se usa, por lo que no ocupa)

//******************* A CAMBIAR SEGÚN TU CONFIGURACIÓN ********************************

//Relación de voltaje y estado de carga de la batería; se puede agregar para cualquier tipo de batería, siempre teniendo en cuenta que estaremos comprobando sólo una celda de hasta 5V
//por lo que es imprescindible utilizar un BMS de equilibrado de celdas en la carga para evitar problemas con las celdas no monitorizadas
//Descomentamos el tipo de batería que queramos utilizar
//(VALORES %: 1%,8%,20%,30%,40%,90%,100%)
const double mVoltCarga[7] = {2.75, 3.10, 3.17, 3.198, 3.22, 3.4, 3.6}; //tabla de relación de voltajes y carga de LIFEPO  (recomendado calibrar (más abajo se indica), por la pequeña diferencia entre estados)
//const double mVoltCarga[7]={3,3.2,3.3,3.6,3.65,4.05,4.2}; //tabla de relación de voltajes y carga de LiCo y LiPo
#define ajusteVolt  0.03 //Voltaje de calibración según el chip

#define luminLED    140 //De 20 a 255, el valor de luminosidad máxima según el LED (para ahorro de energía y duración del LED recomendado valores <150 -40="" -512="" -="" 0="" 0x40="" 0x68.="" 0x6b="" 0x75="" 10="" 13="" 16-bits.="" 1="" 20="" 2="" 30="" 340="" 35="" 3="" 4="" 500="" 5="" 7="" 9-axis="" a="" accuracy="" aceleraci="" activa="" activar="" activarlo="" adafruit_neopixel="" al="" alarma="" alida="" all="" alores="" alquien="" an-mpu-6000evb.pdf="" anal="" and="" anterior="" anteriores="" antirrobo.="" anular="" apaga="" apagar="" ara="" arduino="" are="" at="" attiny85="" b="" baje="" bater="" bici="" board="" boolean="" byte="" celsius="" change="" color="" comprobaci="" comprobado="" comprobar="" comunicaci="" con="" conectados="" conectarlo="" config="" configuraci="" connected="" contador="0;" contalarma="resetAlarmaSeg;" cr="" crudo="" cuando="" datos="" de="" debajo="" define="" definiciones="" degrees.="" degrees="" del="" desconectada="" desconectamos="" desconectar="" descriptions="" desde="" digital="" documentation="" documents:="" double="" e="" efinici="" egunda="" ejecute="" el="" electr="" en="" encender="" encendido="true;" entradas="" equipo="" ero="" error="" es="" espera="" espu="" est="" estim="" estos="" evaluation="" example="" except="" for="" formato="" from="" gicos="" gnd="" guardar="" guide="" ha="" hacerlo="" hasta="" hay="" horas="" how="" http:="" iempo="" ierra="" in="" include="" incorporado="" information="" int0="" intermitentemente="" interruptor="" intpin="" invensense="" ire.h="" is="" it="" l="" la="" las="" led="" ledpin="" library="" lmacenar="" lo="" long="" los="" ltimo="" luces="" manipulando="" many="" map="" mero="" might="" millisinicio="0;" millisvoltaje="0;" minutos="" monitorizaci="" more="" movido="" movimiento="" mpara="" mpu-6050:="" mpu-6050="" muestras="" n="" ndose="" need="" neo_grb="" neo_khz800="" neopixel="" neopixels="" nica="" no="" note="" ntrada="" numpixels="" obtenido="" obtenidos="" older="" oltaje="" on="" onectar="" ontrolamos="" or="" p0="" p1="" p4="" para="" parameter--see="" parpadea="false;" parpadear="" parte="" pasen="" paso="" per="" personalizada="" pin="" pines="" pixels="Adafruit_NeoPixel(NUMPIXELS," pl-9823-f5="" playing-with-the-pl9823-f5-a-breadboardable-neopixel-compatible-led="" pod="" ponemos="" poner="" por="" possible="" power-up="" product="" ps-mpu-6000a.pdf="" puntualmente="" pwm="" que="" raw="" read="" register="" registers="" rel="" relepin="" resetalarmaseg="" resetear="" rgb="" rm-mpu-6000a.pdf="" rojo="" rs-mpu-6000a.pdf="" s="" se="" seg.="" seg="" segundos="" send="" sensibilidad="" sensibilidadaccel="" sensor="" setup="" si="" signals.="" siguiente="" son="" specification="" strandtest="" strips="" superan="" surrealitylabs.com="" tell="" temperature="" that="" the="" these="" third="" tico="" tiempo="" tiempocritica="" tiempoespera="" timeled="0;" to="" toleramos="" transcurrido="" two:="" uando="" umbral="" unsigned="" us="" usamos="" use="" user="" valor="" valores="" value="0;" values.="" veces="" voltaje="" voltajepin="" vuestro="" we="" when="" which="" y="" you="" zero="" zumbador="" zumbpin="">
long accelX = 0; //Para comparar los datos raw con los anteriores
long accelY = 0;
long accelZ = 0;
long accelXAnt = 0;
long accelYAnt = 0;
long accelZAnt = 0;
int alarmaAct = 0; //Contador de movimientos detectados
byte esperaAlarma = tiempoEspera; //Espera x segundos desde que se apaga sin movimiento a activar la alarma
//byte bateriaCriticaSeg=tiempoCritica; //Tiempo de espera con batería baja antes de apagar todo

// The name of the sensor is "MPU-6050".
// For program code, I omit the '-',
// therefor I use the name "MPU6050....".


// Register names according to the datasheet.
// According to the InvenSense document
// "MPU-6000 and MPU-6050 Register Map
// and Descriptions Revision 3.2", there are no registers
// at 0x02 ... 0x18, but according other information
// the registers in that unknown area are for gain
// and offsets.
//
#define MPU6050_AUX_VDDIO          0x01   // R/W
#define MPU6050_SMPLRT_DIV         0x19   // R/W
#define MPU6050_CONFIG             0x1A   // R/W
#define MPU6050_GYRO_CONFIG        0x1B   // R/W
#define MPU6050_ACCEL_CONFIG       0x1C   // R/W
#define MPU6050_FF_THR             0x1D   // R/W
#define MPU6050_FF_DUR             0x1E   // R/W
#define MPU6050_MOT_THR            0x1F   // R/W
#define MPU6050_MOT_DUR            0x20   // R/W
#define MPU6050_ZRMOT_THR          0x21   // R/W
#define MPU6050_ZRMOT_DUR          0x22   // R/W
#define MPU6050_FIFO_EN            0x23   // R/W
#define MPU6050_I2C_MST_CTRL       0x24   // R/W
#define MPU6050_I2C_SLV0_ADDR      0x25   // R/W
#define MPU6050_I2C_SLV0_REG       0x26   // R/W
#define MPU6050_I2C_SLV0_CTRL      0x27   // R/W
#define MPU6050_I2C_SLV1_ADDR      0x28   // R/W
#define MPU6050_I2C_SLV1_REG       0x29   // R/W
#define MPU6050_I2C_SLV1_CTRL      0x2A   // R/W
#define MPU6050_I2C_SLV2_ADDR      0x2B   // R/W
#define MPU6050_I2C_SLV2_REG       0x2C   // R/W
#define MPU6050_I2C_SLV2_CTRL      0x2D   // R/W
#define MPU6050_I2C_SLV3_ADDR      0x2E   // R/W
#define MPU6050_I2C_SLV3_REG       0x2F   // R/W
#define MPU6050_I2C_SLV3_CTRL      0x30   // R/W
#define MPU6050_I2C_SLV4_ADDR      0x31   // R/W
#define MPU6050_I2C_SLV4_REG       0x32   // R/W
#define MPU6050_I2C_SLV4_DO        0x33   // R/W
#define MPU6050_I2C_SLV4_CTRL      0x34   // R/W
#define MPU6050_I2C_SLV4_DI        0x35   // R  
#define MPU6050_I2C_MST_STATUS     0x36   // R
#define MPU6050_INT_PIN_CFG        0x37   // R/W
#define MPU6050_INT_ENABLE         0x38   // R/W
#define MPU6050_INT_STATUS         0x3A   // R  
#define MPU6050_ACCEL_XOUT_H       0x3B   // R  
#define MPU6050_ACCEL_XOUT_L       0x3C   // R  
#define MPU6050_ACCEL_YOUT_H       0x3D   // R  
#define MPU6050_ACCEL_YOUT_L       0x3E   // R  
#define MPU6050_ACCEL_ZOUT_H       0x3F   // R  
#define MPU6050_ACCEL_ZOUT_L       0x40   // R  
#define MPU6050_TEMP_OUT_H         0x41   // R  
#define MPU6050_TEMP_OUT_L         0x42   // R  
#define MPU6050_GYRO_XOUT_H        0x43   // R  
#define MPU6050_GYRO_XOUT_L        0x44   // R  
#define MPU6050_GYRO_YOUT_H        0x45   // R  
#define MPU6050_GYRO_YOUT_L        0x46   // R  
#define MPU6050_GYRO_ZOUT_H        0x47   // R  
#define MPU6050_GYRO_ZOUT_L        0x48   // R  
#define MPU6050_EXT_SENS_DATA_00   0x49   // R  
#define MPU6050_EXT_SENS_DATA_01   0x4A   // R  
#define MPU6050_EXT_SENS_DATA_02   0x4B   // R  
#define MPU6050_EXT_SENS_DATA_03   0x4C   // R  
#define MPU6050_EXT_SENS_DATA_04   0x4D   // R  
#define MPU6050_EXT_SENS_DATA_05   0x4E   // R  
#define MPU6050_EXT_SENS_DATA_06   0x4F   // R  
#define MPU6050_EXT_SENS_DATA_07   0x50   // R  
#define MPU6050_EXT_SENS_DATA_08   0x51   // R  
#define MPU6050_EXT_SENS_DATA_09   0x52   // R  
#define MPU6050_EXT_SENS_DATA_10   0x53   // R  
#define MPU6050_EXT_SENS_DATA_11   0x54   // R  
#define MPU6050_EXT_SENS_DATA_12   0x55   // R  
#define MPU6050_EXT_SENS_DATA_13   0x56   // R  
#define MPU6050_EXT_SENS_DATA_14   0x57   // R  
#define MPU6050_EXT_SENS_DATA_15   0x58   // R  
#define MPU6050_EXT_SENS_DATA_16   0x59   // R  
#define MPU6050_EXT_SENS_DATA_17   0x5A   // R  
#define MPU6050_EXT_SENS_DATA_18   0x5B   // R  
#define MPU6050_EXT_SENS_DATA_19   0x5C   // R  
#define MPU6050_EXT_SENS_DATA_20   0x5D   // R  
#define MPU6050_EXT_SENS_DATA_21   0x5E   // R  
#define MPU6050_EXT_SENS_DATA_22   0x5F   // R  
#define MPU6050_EXT_SENS_DATA_23   0x60   // R  
#define MPU6050_MOT_DETECT_STATUS  0x61   // R  
#define MPU6050_I2C_SLV0_DO        0x63   // R/W
#define MPU6050_I2C_SLV1_DO        0x64   // R/W
#define MPU6050_I2C_SLV2_DO        0x65   // R/W
#define MPU6050_I2C_SLV3_DO        0x66   // R/W
#define MPU6050_I2C_MST_DELAY_CTRL 0x67   // R/W
#define MPU6050_SIGNAL_PATH_RESET  0x68   // R/W
#define MPU6050_MOT_DETECT_CTRL    0x69   // R/W
#define MPU6050_USER_CTRL          0x6A   // R/W
#define MPU6050_PWR_MGMT_1         0x6B   // R/W
#define MPU6050_PWR_MGMT_2         0x6C   // R/W
#define MPU6050_FIFO_COUNTH        0x72   // R/W
#define MPU6050_FIFO_COUNTL        0x73   // R/W
#define MPU6050_FIFO_R_W           0x74   // R/W
#define MPU6050_WHO_AM_I           0x75   // R


// Defines for the bits, to be able to change
// between bit number and binary definition.
// By using the bit number, programming the sensor
// is like programming the AVR microcontroller.
// But instead of using "(1< (accelXAnt + sensibilidadAccel) or accelY > (accelYAnt + sensibilidadAccel) or accelZ > (accelZAnt + sensibilidadAccel)) {
    movimiento=true;
    contador=0; //Contador para la cuenta atrás de tiempo para apagarlo
  }
  else {
    contador++;
    movimiento=false;
  }

  //DEBUG
  //    Serial.print("Alarma en: ");
  //    if (accelX>accelXAnt+sensibilidadAccel) {
  //      Serial.println("X");
  //    }
  //    if (accelY>accelYAnt+sensibilidadAccel) {
  //      Serial.println("Y");
  //    }
  //    if (accelZ>accelZAnt+sensibilidadAccel) {
  //      Serial.println("Z");
  //    }
  //    Serial.print(F("accel x,y,z: "));
  //    Serial.print(accelX, DEC);
  //    Serial.print(F(", "));
  //    Serial.print(accelY, DEC);
  //    Serial.print(F(", "));
  //    Serial.print(accelZ, DEC);
  //    Serial.println(F(""));
  //    Serial.println(esperaAlarma);
 
  //Guardamos valores anteriores
  accelXAnt = accelX;
  accelYAnt = accelY;
  accelZAnt = accelZ;

  
  //Para velocidad de respuesta; si se detecta activación manual del interruptor, apagamos LED indicador y desconectamos relé
  //El resto del código se ejecutará 1 vez cada 1 segundos.
  //for(int x=1; x<5 --------------------------------------------------------="" -="" 0="" 1.0.1.="" 100="" 1023="" 10="" 10k="" 14="" 1="" 4="" 5="" 5v="" 6="" :="" a="" able="" acar="" accel="" accel_t_gyro="" accel_t_gyro_union="" acceleration="" aceleraci="" activar="" address="" after="" ahorrando="" ahorrar="" ajustevolt="" al="" alarma="" alarmaact="0;" algo="" alguien="" also="" alto="" amos="" amp="" an="" analogread="" and="" apagamos="" apagatodo="" aparcada="" ar="" ara="" arduino="" are="" around="" asamos="" at="" attiny="" ay="" baja="" bajo="" bater="" be="" bici="" black="" boolean="" buffer="" byte.="" byte:="" bytes="" c="" caso="" center="" coge="" coger="" color:="" common="" con="" conectamos="" conectar="" const="" consumption.="" contador="0;" containing="" continue="" control="" convenient="" could="" cpu="" ctivamos="" ctualizamos="" cualquiera="" cuando="" cuenta="" data="" datos="" de="" decimales="" default="" define="" dejar="" del="" delay="" descartar="" desconectamos="" description:="" despierta="" detecci="" detectar="" device.="" digitalread="" digitalwrite="" digo="" disable="" do="" donalmorrissey.blogspot.com.es="" dormido="" dormimos="" dormir="" dos="" double="" doublemap="" dt="" duda="" durante="" ead="" easier="" ecoge="" edit:="" eemos="" ejecute="" ejemplo="" ejes="" el="" else="" en="" enabled="" encendemos="" encendido="true;" enciende="" enciendetodo="" energ="" enter="" enters="" entersleep="" entre="" equipo="" erial.println="" error="));
      //  Serial.println(error,DEC);
  
  
      // Swap all high and low bytes.
      // After this, the registers values are swapped,
      // so the structure name like x_accel_l does no
      // longer contain the lower byte.
      uint8_t swap;
      #define SWAP(x,y) swap = x; x = y; y = swap
  
      SWAP (accel_t_gyro.reg.x_accel_h, accel_t_gyro.reg.x_accel_l);
      SWAP (accel_t_gyro.reg.y_accel_h, accel_t_gyro.reg.y_accel_l);
      SWAP (accel_t_gyro.reg.z_accel_h, accel_t_gyro.reg.z_accel_l);
      SWAP (accel_t_gyro.reg.t_h, accel_t_gyro.reg.t_l);
      SWAP (accel_t_gyro.reg.x_gyro_h, accel_t_gyro.reg.x_gyro_l);
      SWAP (accel_t_gyro.reg.y_gyro_h, accel_t_gyro.reg.y_gyro_l);
      SWAP (accel_t_gyro.reg.z_gyro_h, accel_t_gyro.reg.z_gyro_l);
  
  
      // Print the raw acceleration values
      accelX = accel_t_gyro.value.x_accel;
      accelY = accel_t_gyro.value.y_accel;
      accelZ = accel_t_gyro.value.z_accel;
      //MPU6050_write_reg (MPU6050_PWR_MGMT_1, 1); //Volvemos a desactivar para ahorrar energía
} 
</code></pre><br><b>The program basically does this</b>: Informs, changing every second the color of an RGB LED, charge of the first cell (without resistance), which is very reliable, for me varied only -0,03V (with the adjustment is 0,03V). And with the accelerometer, checks on the one hand, when it is on, if there is no movement in 5 minutes (configurable parameter), disconnect the relay, turning off the bike and lights. In that state, after 20 seconds activates transistor alarm if no movement (first briefly as a warning, and then intermittently for several minutes). Each time the program is run, to save some energy, we slept the processor and accelerometer for a second.<br><div style=" es="" eseteamos="" espera="" esperaalarma="tiempoEspera;" exactitud="" executed="" externa="" extra="" false="" filter="" first="" font-family:="" font-size:="" for="" from="" function="" gastando="" gy-521="" gyro.="" gyro="" habr="" has="" hay="" here="" high="" hold="" http:="" i2c-bus.="" i2c-bus="" i2c="" i="" if="" imes="" implemented="" in="" in_max="" in_min="" independiente="" int="" interese="" intermitente="" interrupt="" interruptor="" into="" intpin="" ire.available="" is="" isr="" it="" just="" la="" las="" lectura="" lecturas="" led="" lee_mpu6050="" less="" lo="" los="" low.="" low="" luminled="" m="" make="" mantenga="" margen="" media="" medias="" medium="" memoria="" menos="" merece="" milivoltios="" mode.="" movimiento="" mpu-6050.="" mpu-6050="" mpu6050_read="" mpu6050_write="" mpu6050_write_reg="" mpu="" mpu_6050_write="" mpu_6050_write_reg="" muestras="" mueve="" multiple="" mvoltcarga="" n="" name:="" necesitamos="" new="" nimo="" no="" none.="" nos="" not="" nothing.="" now="" nulamos="" number="" o="" ode="" of="" oltaje=");
    Serial.println(value);
    delay(200);

    //Aquí se evalúa el color del led según los valores del voltaje, para evitar que fluctúe se tiene en cuenta
    //qué color tenía antes, y no cambia hasta que haya una variación mayor de 0,02V
    if (value <= mVoltCarga[2] and value > mVoltCarga[1]) { //ROJO; Recargar lo antes posible
      //Si el color no estaba establecido o era el mismo o ha variado suficientemente el voltaje
      if (color == 0  or color == 1 or (color == 2 and value <= mVoltCarga[2] - 0.02)) {
        color = 1;
        pixels.setPixelColor(0, pixels.Color(0, luminLED, 0));
      }
    }
    else if (value <= mVoltCarga[3] && value > mVoltCarga[2]) { //NARANJA; se parece más al rojo
      if (color == 0  or color == 2 or (color == 3 and value <= mVoltCarga[3] - 0.02) or (color == 1 and value > mVoltCarga[2] + 0.02) ) {
        color = 2;
        pixels.setPixelColor(0, pixels.Color(luminLED * 0.3, luminLED * 0.7, luminLED * 0.1)); //Entre el 20 y el 30%; momento de recargar la batería
      }
    }
    else if (value <= mVoltCarga[4] && value > mVoltCarga[3]) { //AMARILLO color 3
      if (color == 0  or color == 3 or (color == 4 and value <= mVoltCarga[4] - 0.02) or (color == 2 and value > mVoltCarga[3] + 0.02) ) {
        color = 3;
        pixels.setPixelColor(0, pixels.Color(luminLED * 0.4, luminLED * 0.5, 0)); //Aconsejable recargar batería
      }
    }
    else if (value <= mVoltCarga[5] && value > mVoltCarga[4]) { //VERDE color 4
      if (color == 0  or color == 4 or (color == 5 and value <= mVoltCarga[5] - 0.02) or (color == 3 and value > mVoltCarga[4] + 0.02) ) {
        color = 4;
        pixels.setPixelColor(0, pixels.Color(luminLED * 0.5, 0, 0)); //Le bajo la intensidad todavía más; al fin y al cabo, siempre estará encendido
      }
    }
    else if (value <= mVoltCarga[6] && value > mVoltCarga[5]) { //AZUL color 5
      if (color == 0 or color == 5 or (color == 6 and value <= mVoltCarga[6] - 0.02) or (color == 4 and value > mVoltCarga[5] + 0.02) ) {
        color = 5;
        pixels.setPixelColor(0, pixels.Color(0, 0, luminLED)); //Se ha sobrecargado; recomendable no llegar al azul para maximizar vida útil
      }
    }
    else  if (value > mVoltCarga[6]) { //>100% VIOLETA 6
      color = 6;
      pixels.setPixelColor(0, pixels.Color(0, luminLED * 0.6, luminLED * 0.75)); //Por encima de lo recomendado; PELIGROSO
    }
    pixels.show(); //Actualizamos el color del led

    //DEBUG
    //Serial.print(" once="" only="" or="" out.="" out_max="" out_min="" p3="" pagamos="" para="" parameter="" parameters:="" parpadearojo="" pasamos="" pdata="" pena="" peripherals.="" pero="" pido="" pin="" pines="" pixels.color="" pixels.setpixelcolor="" pixels.show="" podr="" pointer="" ponemos="" ponerlo="" por="" power="" power_all_enable="" preestablecidas="" procesador="" program="" pull-up="" qu="" que="" quedan="" queremos="" quot="" r="" rabajamos="" raw="" rdenamos="" re-enable="" read.="" read="" real="" recogida="" refiero="" reg="" register.="" register="" relase="" release="" relepin="" resistencia="" return="" returns:="" rojo="" roman="" rutina="" rutinas="" s="" sacar="" salidas="" se="" segundo="" ser="" serial.print="" service.="" set_sleep_mode="" settings="" si="" sigue="" single="" size="" sizeof="" sleep.="" sleep="" sleep_disable="" sleep_enable="" sleep_mode="" sleep_mode_pwr_save="" sleeping-arduino-part-5-wake-up-via.html="" soltar="" stable.="" start="" suficiente="" tambi="" temp="" temperature="" tener="" text-align:="" the="" there="" thing="" third="" this="" tiempo="" tierra="" timed="" timeout="" to="" todo="" todos="" true:="" true="" uint8_t="" un="" una="" use="" used="" uses="" utina="" valores="" value="value" values.="" values="" vect="" very="" viso="" void="" voltaje="" voltajeant=");
    //Serial.println(voltajeAnt);

    //Si detectamos que la bici no se usa durante el tiempo indicado, apagamos todo, hasta que no se pulse en interruptor del P2 no vuelve a continuar
    if (contador > (minutos * 60)) { //Al hacer tres comprobaciones dentro del tiempo marcado, nos aseguramos
      //Ha pasado el tiempo sin uso; apagamos todo
      apagaTodo();
    }

    //si baja del valor de 1% hacemos sonar alarma brevemente y apagamos todo
    //if (value<=mVoltCarga[0]) {
    //  digitalWrite(relePIN,LOW);
    //  for(int x=1; x<20; x++) {
    //    digitalWrite(zumbPIN,HIGH);
    //    delay(100);
    //    digitalWrite(zumbPIN, LOW); //Desactivamos alarma por si quedaba activada
    //    delay(100);
    //  }
    //  apagaTodo();
    //}
  } //**** FIN IF ENCENDIDO
  else { //Está en modo bajo consumo, led APAGADO
      //Comprobamos si hay movimiento
      if (esperaAlarma>0) { //Descontamos tiempo de espera
        esperaAlarma--;
       }

    //Comprobamos la aceleración comparando con datos anteriores; si se superan en sensibilidadAccel, alquien lo está manipulando
    if (movimiento==true) {
      if (esperaAlarma>0) { //Mientras no pase el tiempo de reposo, ignoramos el movimiento
        esperaAlarma=tiempoEspera;
      }
      else {
        alarmaAct++;
        pixels.setPixelColor(0, pixels.Color(0, luminLED, 0));
        pixels.show();
        if (alarmaAct > 2 and alarmaAct <= 6) {
          digitalWrite(relePIN, HIGH); 
          for (int x = 0; x < (alarmaAct * 3); x++) { //Intermitencia de zumbador
            digitalWrite(zumbPIN, HIGH);
            delay(100);
            digitalWrite(zumbPIN, LOW);
            delay(140);
            if (x>1) {
              digitalWrite(relePIN, LOW); //Activamos sólo por 0,5 Segundos el relé y luces
            }
          }
        }
      }
    }

    if (alarmaAct > 6) { //Estando la alarma activada se desactiva la espera final, por lo que es constante la alarma
      alarmaAct++;
      digitalWrite(relePIN, HIGH);  //Enciende relé y con ello luces
      for (int x = 0; x < 10; x++) { //Hace sólo 10 veces esta operación, dejando quitar la alarma con el botón
        if (x>4) {
          digitalWrite(relePIN, LOW); //Apaga tras 0,6 segundos (respuesta lenta del foco, hacemos parpadear)
        }
        digitalWrite(zumbPIN, HIGH);
        digitalWrite(relePIN, HIGH); //Encendemos todo intermitentemente
        pixels.setPixelColor(0, pixels.Color(0, luminLED, 0));
        pixels.show();
        delay(50);
        digitalWrite(zumbPIN, LOW);
        pixels.setPixelColor(0, pixels.Color(0, 0, 0));
        pixels.show();
        digitalWrite(relePIN, LOW); 
        delay(60);
      }
      if (alarmaAct > 200) { //Para la alarma
        alarmaAct = 0;
      }
    }
    
    if (alarmaAct==0) { //No hay movimiento, apagamos LED
      pixels.setPixelColor(0, pixels.Color(0, 0, 0));
      pixels.show();
    }
} //Aquí termina el caso en que esté apagado

  //Esto se ejecuta en todos los casos
  if (value > mVoltCarga[0] and value < mVoltCarga[1] and alarmaAct==0) { //si la batería baja demasiado, avisamos
    if (encendido == false) { //No me interesa que pite mientras ando en la bici
      for (int x = 0; x < 2; x++) {
        digitalWrite(zumbPIN, HIGH);
        delay(150);
        digitalWrite(zumbPIN, LOW);
        delay(150);
      }
    }
    if (parpadea == false) {
      pixels.setPixelColor(0, pixels.Color(0, luminLED, 0)); //color rojo
      pixels.show();
      parpadea = true;
    }
    else {
      pixels.setPixelColor(0, pixels.Color(0, 0, 0)); //apagado
      pixels.show();
      parpadea = false;
    }
  }

  //Si alcanza un valor crítico
  if (value < mVoltCarga[0] and value>2 and encendido==true) { //Avisamos del estado de baja batería
    parpadeaRojo();
  }

  if (value < 2 and encendido==true) { //Celda desconectada (interruptor) o batería sin nada de energía
    apagaTodo();
  }
  //Utilizo la EEPROM para valores estadísticos únicamente; se puede eliminar si se considera
  /* DATOS GUARDADOS EN EEPROM *PENDIENTE DE HACER
      0: Horas funcionamiento Arduino
      3: Último voltaje Arduino, para controlar el número de recargas
      7: Contador de recargas de baterías
      11: Contador de viajes/encendidos
      15: Voltaje máximo histórico
      19: Voltaje mínimo histórico
      23:
      27:
      31:

  */

  ////Guardamos las horas de uso en la EEPROM
  //if ((millis()-millisInicio)>3600000) { //Ha pasado una hora
  //  millisInicio=millis();
  //  EEPROM.update(0,EEPROM.readLong(0)+1); //Añadimos una hora al contador
  //  }
  ////Comprobamos valor mínimo y actualizamos
  //if (EEPROM.readLong(19)>value)  {
  //  EEPROM.update(19,value);
  //}
  ////Comprobamos valor máximo y actualizamos
  //if (EEPROM.readLong(15)<value) {
  //  EEPROM.update(15,value);
  //}
  
  //Si pasa rato sin que la bici se mueva, se resetea contador de movimientos
  if (alarmaAct > 0 and alarmaAct < 7) {
    contAlarma--;
    if (contAlarma == 0) {
      alarmaAct = 0;
      contAlarma = resetAlarmaSeg;
    }
  }
  if (alarmaAct < 7) { //Para dar velocidad de respuesta
    enterSleep(); //Ahorramos batería ya que está el 99% del tiempo " voltajepin="" voltios="" watchdog="" wdt="" when="" while="" will="" wire.begintransmission="" wire.endtransmission="" wire.read="" wire.requestfrom="" with="" wrapper="" write.="" write="" write_reg="" written="" x="" y="" ya="">

Used materials

Arduino Nano (Atmel 328-16 Mhz), with 30 Ks Free FLASH and 2 Ks SRAM for variables, enough for everything you can think of :

Pictured with transparent protecting water EPOXI (I deleted the LED ON)

PL-9823 RGB LED with integrated micro, much better than a normal LED RGB, because it has many advantages ; we do not need resistors (5V supply and ready), and the blend color is exactly what we want (regulating digitally from 0 to 255 each color) with the Arduino.

It is fatter than a normal RGB to keep a microcontroller built

And you can be connected in series to geniuses like this :

These LEDS RGB are the latest advance by integrating the controller on the same chip , so just pass color data we want to indicated to immediately change without resistance to lower the voltage (in a normal RGB chip each Color uses a different resistance).

Image: Adafruit.com

I used the library Adafruit Neopixel to handle the indicator, but one is currando faster for projects multiple LEDs.

We have different heights; F8 8mm and 5mm F5

Accelerometer MPU-6050 (Encapsulated GY-521) with which we detect movements, acceleration, etc. (has to temperature sensor):

A 0.5A MOSFET N channel unless it is activated with 5V; the typical 2N2222 worth us to activate the speaker will alarm.
An electronic relay or SSR (Solid State Relay) 80A DC (real):

A speaker / piezo buzzer , as powerful as possible to discourage burglars:

Installing the LED RGB

I opened the throttle part of Golden Motor electronics; electronics was prepared to 48V so no use to me; 3 wires are used for the Hall sensor throttle (can not use mass accelerator as common ground for referrals that are in the BAC-0281P driver , and end up overheating the sensor, I checked) and the rest for electronics and reverse switch (which I will take to turn on / off the beam and to switch between 3 light intensities), and I used to the LED and hidden on / off the bike in the brief stops microswitch ( and activation of the burglar alarm).

The bike has no ignition key , but use a hidden from view switch to activate / deactivate, and another switch to turn off the voltage reading and avoid unbalancing the first cell when not in use.

I Blew one of the holes to introduce Led PL-9823, then fixing it with epoxy glue , and insulated with heat shrink tubing red once welded connections:

The lid is easy to remove ; They are only two screws to separate the side, which is press - fitted. Needless to release the handle.

And in the next picture with all cables already placed on your site (be careful that the movement does not touch the accelerator or engages in any of them):

The connection of the cables, referred to the Arduino Nano:

And here the nucleus of control: The MPU-6050 connected to the Arduino Nano (above epoxy to protect it from moisture / water that may enter).

To permanently feed and used a voltage regulator that supports up to 40V (with efficient LM2596S) and feeding it to 33V with my pack I can adjustable from 1V to 30V, very accurate, so I put it to 5V and food to the Nano directly 5V line to prevent loss of voltage regulator Nano.

Voltage regulator carrocero covered with tape exposing only the adjustment screw

This controller is identical to that used for feeding 3V LED lights , and I hit an aluminum sink to act, only to power the arduino is not necessary to put sink for low power consumption:

An efficient regulator 3-40V riding a LM2596S with a sink stuck with silicone

In the next picture is the NANO connected to the bike lie what I program with a change:

I think that is all; the initial scheme (put) speaks for itself, but if you have any questions comentaís.

On the other hand, I use a ceramic 50A slow fuse to protect the pack of batteries of any short:

Substituting one mechanical relay Solid State (semiconductor)

On the other hand, so far used on the bike a mechanical relay 100A and 12V (typically used in vehicles), which activated with a small switch connected to the third cell of the battery (3,3x3 = 9,9V), and occupied enough:

And I used to replace it with an electronic relay , for that to improve the bike.

Now it is not the first time that I use and I speak about this type of electronic relays , its advantages and disadvantages. I used one of them in a car (with bad result for its low quality), but very useful and long - lived if used within its limits.

The diode drift is the current to the battery in all cases to protect control before long hills.

Moreover, another very important point , as seen in the image above, you have to put a diode that allows engine power to flow to the batteries in case the relay is switched off , because if for any reason be disabled down a slope eventually could fry the MOSFET driver bike (as indicated in your manual), and it would have to dissipate all the energy in them can overheat and become damaged. And must be connected directly to the battery, avoiding the BMS, as seen in the image, as the BMS tends to disconnect the load if any cell exceeds a certain voltage (3,75V usually)

The downside of this type of economic relays is that it has enough losses in state of non-conduction; in this case 1Kohm, let 33 mAh (33V / 1000ohm Ohm 's law ) but no problem as consumption of motor control is less than that, and at least takes 1 month to drain the battery, and then the short BMS food. Anyway, if we want to eliminate almost all the loss, instead of solid state relay, we can use two MOSFETS in parallel with low current activation as the IRBL3036 :

or also transistors Darlington NPN (1 or more in parallel, depending on amperage), which come in a single package and have low losses, and activated with little amperage:

But he did not have them, so the moment I will leave with the SSR , and go down without checking how much it will be used and so I try to see how it behaves.

I have also isolated and protected from moisture BMS that I mentioned in the previous entry , applying a generous layer of transparent epoxy two components to electronics:

And this is the final aspect of all the electronics and wiring; I have taken up the free holes for the wires (protecting supporting more amperage with masking tape if the heat softens the insulation) and covering everything with masking tape so that there is no problem:

At the top next to the fuse 50A voltage regulator supplying seen the Arduino Nano

For ad. info: Previous tests with ATtiny85

At first I tried to get much of this with a small ATtiny85 ,

but I had no problems because of their limitations , forgetfulness, and was not able to program it to take advantage of a UNO 8 ks memory (plus the burglar alarm was out):

However, as voltage indicator for a single stack, it is most suitable due to its very low consumption if powered by the 5V input; one LiFePo4 cell has between 2.7 and 3.6V, so the Attiny work perfectly, and consuming very little:

and if libraries Low-Power (waking only every second or two to check the voltage) are installed, we leave it in the order of picoAmperes:

So I leave here as far as I got with the program for him , unpurified too, showed in RGB connected status LiFePo4 cell using colors, for what it's someone:

 /* ==================================================================  
  Sketch control de batería, pensado para su funcionamiento en un Attiny85  
  Activa un LED RGB según el voltaje y tipo batería (Divisor voltaje)  
  Morado sobrecarga, azul 90-100%, verde 50-90%, amarillo del 30 al 40%,  
  naranja del 20 al 30%, rojo 10 al 20% y rojo parpadeante por debajo del 10%  
  Autor: David Losada, basado en trabajos previos de otros autores:  
  Parte de código de la referencia rápida del Digispark: http://digistump.com/wiki/digispark/quickref  
  Version: 0.5 bajo licencia GPLv3  
  Fecha: octubre 2016  
  Includes NeoPixel Ring simple sketch code from (c) 2013 Shae Erisson  
  released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library  
  ==================================================================  */  
 //#include  //La librería Neopixel ocupa demasiado en el ATtiny; anulo toda la parte de guardado de datos estadísticos  
 #include  //Para el control del led  
 //from https://bigdanzblog.wordpress.com/2014/08/10/attiny85-wake-from-sleep-on-pin-state-change-code-example/  
 #include     
 #include  //creo que al final no se usa, pero mejor dejarla (el compilador no la incluye si no se usa, por lo que no ocupa)  
 //******************* A CAMBIAR SEGÚN TU CONFIGURACIÓN ********************************  
 //Relación de voltaje y estado de carga de la batería; se puede agregar para cualquier tipo de batería, siempre teniendo en cuenta que estaremos comprobando sólo una celda de hasta 5V  
 //por lo que es imprescindible utilizar un BMS de equilibrado de celdas en la carga para evitar problemas con las celdas no monitorizadas  
 //Descomentamos el tipo de batería que queramos utilizar  
 //(VALORES %: 1%,8%,20%,30%,40%,90%,100%)  
 const double mVoltCarga[7]={2.8,3.10,3.17,3.198,3.22,3.4,3.6}; //tabla de relación de voltajes y carga de LIFEPO (recomendado calibrar (más abajo se indica), por la pequeña diferencia entre estados)  
 //const double mVoltCarga[7]={3,3.2,3.3,3.6,3.65,4.05,4.2}; //tabla de relación de voltajes y carga de LiCo y LiPo  
 const byte luminLED=150; //De 20 a 255, el valor de luminosidad máxima según el LED (para ahorro de energía y duración del LED recomendado valores <150 -="" 0="" 12="" 1="" 255="" 2="" 4="" 512="" 5="" 6000="" 6="" 6v="" a="" acar="" acemos="" acer="" activar="" activarlo="" actualizado="" adafruit_neopixel="" ahorrando="" ahorrar="" ajustar="" ajustarlo="" al="" alarma="" alida="" alores="" alto="" amos="" anal="" analog="" analogread="" analogwrite="" and="" anterior="" apagado="" apagar="" aparecer="" ara="" arduino="" asamos="" attiny85="" attiny="" azul="" b="" baje="" bajo="" bater="" bici="" boolean="" borrado="" byte="" bytes="" cada="" calibra="" calibraci="" calibrar="" calibvolt="" change="" chequeo="" cimas="" coge="" coincidiera="" color="" colores="" como="" completo="" comprobaci="" comprobamos="" comprobar="" comunicaci="" con="" conectados="" conectarlo="" connected="" const="" contar="" convierte="" cuando="" cumplir="" d="" datos="" de="" deber="" decimales="" define="" del="" delay="" descartar="" desconectamos="" desconectar="" digital="" digitalwrite="" doble="" dos="" double="" doublemap="" ecoge="" eemos="" eeprom.update="" eeprom="" efinici="" efinir="" egunda="" el="" electr="" en="" encender="" entera="" entradas="" entre="" env="" erde="" erial.begin="" erial.println="" es="" escomentar="" ese="" esetea="" espacio="" espera="" espu="" est="" esto="" estos="" evitando="" exactitud="" example="" final="" for="" from="" funcionan="" gicos="" gnd="" guardar="" guardo="" ha="" hacerlo="" hacerse="" hardware.="" hasta="" have="" hay="" he="" hequeo="" high="" horas="" how="" http:="" i="" iempo="" ierra="" if="" in="" incorporado="" indicar="" indicativo="" information="" inicializado="" inicio="" initializes="" input="" int0="" int="" interferencias="" intermitente="" intermitentemente="" interna="" interruptor="" intpin="" is="" it="" justar="" l="" la="" lanco="" las="" later="" le="" lecturas="" led="" ledpin="" leds="" lee="" library.="" library="" liminar="" lmacenamos="" lmacenar="" lo="" long="" loop="" los="" ltima="" luces="" m="" many="" marcha="" media="" mediante="" medias="" memoria="" merece="" mero="" might="" milisegundos="" milivoltios="" millisinicio="millis();" millisuso="millis();" millisvoltaje="0;" minutos="" mode="" monitorizaci="" more="" motor="" mpara="" muestras="" n="" ncendemos="" necesitamos="" need="" neo_grb="" neo_khz800="" neopixel="" neopixels="" nica="" niciamos="" nimo="" no="" not="" note="" number.="" number="" numpixels="" o="" obtenido="" obtenidos="" older="" oltaje="" on="" onectar="" onemos="" orrado="" ou="" output="" p0="" p1="" p4="" para="" parada="" parameter--see="" parpadea="false;" parpadear="" parte="" pasamos="" paso="" pena="" physical="" pin="" pines="" pinmode="" pixels.begin="" pixels.color="" pixels.setpixelcolor="" pixels.show="" pixels="Adafruit_NeoPixel(NUMPIXELS," pl-9823-f5="" playing-with-the-pl9823-f5-a-breadboardable-neopixel-compatible-led="" poco="" posici="" possible="" preferiblemente="" primer="" primera="" probar="" programa="" pueda="" puede="" puesta="" pullup="" punto="" pwm="" qu="" que="" quitamos="" rabajamos="" raro="" rdenamos="" reactivar="" read="" readlong="" readvcc="" real="" recomendado="" ref.="" refintvolt="1.088;" rel="" relepin="" rellenamos="" reseteado="" resistencia="" rgb="" rojo="" rutina="" s="" saber="" sacar="" se="" seg="" seguidas="" send="" ser="" serial.println="" set="" setmaxallowedwrites="" setmempool="" setup="" si="" signals.="" son="" stablecemos="" strandtest="" strips="" su="" surrealitylabs.com="" tama="" tantas="" tarjeta="" tell="" tendr="" tengo="" terminado="" that="" the="" then="" third="" this="" though="" tiempo="" tiene="" tierra="" timeled="millis();" to="" todos="" transcurrido="" ttiny85="" uardar="" un="" unsigned="" us="" usamos="" usando="" usar="" use="" utilizada="" valor="" valores="" value="int((value-int(value))*100);" values.="" variaci="" variar="" veces="" verde="" vez="" void="" voltaje="" voltajeant="0;" voltigual="false;" voltios="" vuelve="" want="" we="" when="" where="" which="" x="" y="" ya="" you="" zul="" zumbador="" zumbpin=""> 9 pulsos del led)  
 //for(int x=0; x.5) { //ROJO PARPADEANTE, SE DAÑA LA BATERÍA; RECARGAR LO ANTES POSIBLE  
    color=0;  
    if (parpadea==false) {  
     pixels.setPixelColor(0, pixels.Color(0,luminLED,0));  
     parpadea=true;  
    }  
    else { pixels.setPixelColor(0, pixels.Color(0,0,0)); //apagado  
    parpadea=false;  
    }  
 }  
 else if (value<=mVoltCarga[2] && value>mVoltCarga[1]) { //ROJO; Recargar lo antes posible  
    //Si el color no estaba establecido o era el mismo o ha variado suficientemente el voltaje  
    if (color==0 or color==1 or (color==2 and value<=mVoltCarga[2]-0.02)) {   
     color=1;  
     pixels.setPixelColor(0, pixels.Color(0,luminLED,0));  
    }  
 }     
 else if (value<=mVoltCarga[3] && value>mVoltCarga[2]) { //NARANJA; se parece más al rojo  
    if (color==0 or color==2 or (color==3 and value<=mVoltCarga[3]-0.02) or (color==1 and value>mVoltCarga[2]+0.02) ) {   
     color=2;  
     pixels.setPixelColor(0, pixels.Color(luminLED*0.3,luminLED*0.7,luminLED*0.1)); //Entre el 20 y el 30%; momento de recargar la batería  
    }  
 }  
 else if (value<=mVoltCarga[4] && value>mVoltCarga[3]) { //AMARILLO color 3  
    if (color==0 or color==3 or (color==4 and value<=mVoltCarga[4]-0.02) or (color==2 and value>mVoltCarga[3]+0.02) ) {   
     color=3;  
     pixels.setPixelColor(0, pixels.Color(luminLED*0.4,luminLED*0.5,0)); //Aconsejable recargar batería  
    }  
 }  
 else if (value<=mVoltCarga[5] && value>mVoltCarga[4]) {//VERDE color 4  
    if (color==0 or color==4 or (color==5 and value<=mVoltCarga[5]-0.02) or (color==3 and value>mVoltCarga[4]+0.02) ) {   
     color=4;  
     pixels.setPixelColor(0, pixels.Color(luminLED*0.5,0,0)); //Le bajo la intensidad todavía más; al fin y al cabo, siempre estará encendido  
    }  
 }  
 else if (value<=mVoltCarga[6] && value>mVoltCarga[5]) {//AZUL color 5  
    if (color==0 or color==5 or (color==6 and value<=mVoltCarga[6]-0.02) or (color==4 and value>mVoltCarga[5]+0.02) ) {   
     color=5;  
     pixels.setPixelColor(0, pixels.Color(0,0,luminLED)); //Se ha sobrecargado; recomendable no llegar al azul para maximizar vida útil   
    }  
 }  
 else { //>100% VIOLETA 6  
    color=6;  
    pixels.setPixelColor(0, pixels.Color(0,luminLED*0.6,luminLED*0.75)); //Por encima de lo recomendado; PELIGROSO  
 }  
 pixels.show(); //Actualizamos el color del led  
 //Comprobamos si millis se ha desbordado (tras 50 días)  
 if (millisUso>millis()) {  
  millisUso=millis();  
 }  
 if (millisVoltaje>millis()) {  
  millisVoltaje=millis();  
 }  
 //Si detectamos que la bici no se usa durante el tiempo indicado, apagamos todo, hasta que no se pulse en interruptor del P2 no vuelve a continuar  
 if ((millis()-millisUso)>=20000*long(minutos)) { //Al hacer tres comprobaciones dentro del tiempo marcado, dividimos entre tres los minutos  
  millisUso=millis();  
  if (parada==false) {  
   parada=true;  
   voltajeAnt=value; //Para redondear a 3 dígitos (sólo nos interesa comparar con dos decimales)  
  }  
  else {   
   parada=false;  
   if (value<=voltajeAnt-0.01 and value<=voltajeAnt+0.01) {  
    voltIgual=true;  
    millisVoltaje=millis();  
   }  
  }  
 }  
 if (voltIgual==true && (millis()-millisVoltaje)>=20000*long(minutos)) {  
   millisVoltaje=millis(); //reseteamos tiempo  
   voltIgual=false;  
   if (voltajeAnt==value) {  
    //En dos chequeos durante el tiempo no ha cambiado voltaje, por lo que dormimos la cpu  
    apagaTodo();  
   }  
 }  
 //Para protección de batería  
 //Si baja del 4,5% la batería, activamos zumbador hasta que sea del 1% o menor  
 if (value<=(mVoltCarga[0]+mVoltCarga[1])/2 && value>=mVoltCarga[0]) {  
  if (alarma==false) {  
   alarma=true;  
   digitalWrite(zumbPIN,HIGH);  
  }  
  else {  
  alarma=false;  
  digitalWrite(zumbPIN, LOW);  
  }  
 }  
 //si baja del valor de 1% hacemos sonar alarma brevemente y apagamos todo  
 if (value<=mVoltCarga[0]) {  
  digitalWrite(relePIN,LOW);  
  for(int x=1; x<20 0:="" 11:="" 15:="" 19:="" 23:="" 27:="" 31:="" 3:="" 7:="" activada="" alarma="" apagatodo="" arduino="" as="" attiny85="" bater="" considera="" contador="" controlar="" da="" datos="" de="" del="" delay="" digitalwrite="" eeprom="" el="" eliminar="" en="" encendidos="" esactivamos="" estad="" funcionamiento="" guardados="" hacer="" hist="" horas="" if="" la="" las="" low="" ltimo="" m="" memoria="" mero="" millis="" millisinicio="" n="" nicamente="" nimo="" no="" para="" por="" puede="" puedo="" quedaba="" recargas="" rico="" se="" si="" sticos="" tilizo="" uardamos="" usarlo="" uso="" valores="" viajes="" voltaje="" x="" ximo="" zumbpin="">3600000) { //Ha pasado una hora  
 // millisInicio=millis();   
 // EEPROM.update(0,EEPROM.readLong(0)+1); //Añadimos una hora al contador  
 // }   
 ////Comprobamos valor mínimo y actualizamos  
 //if (EEPROM.readLong(19)>value) {  
 // EEPROM.update(19,value);  
 //}  
 ////Comprobamos valor máximo y actualizamos  
 //if (EEPROM.readLong(15)millis()) { //Cuando pasen 50 dias resetear  
   timeLED=millis();  
  }  
  if ((millis()-timeLED)>2000) {  
    analogWrite(ledPIN,100); //enciende LED brevemente indicando funcionamiento  
    timeLED=millis();  
    delay(50);  
    analogWrite(ledPIN,0);  
  }  
 //Para velocidad de respuesta; si se detecta activación manual del interruptor, ponemos a dormir la bici  
 //El resto del código se ejecutará 1,5 veces cada segundo aprox.  
 for(int x=1; x<20 -="" 1.1v="" 10k="" 1125300="1.1*1023*1000" 1="" 2="" _bv="" a="" above="" activar="" adc="" adch="" adcl="" adcsra="" admux="_BV(REFS0)" against="" al="" algo="" amos="" amp="" and="" apagamos="" apagatodo="" aqu="" arduino="" as="" attiny="" avcc="" ay="" bit="" bit_is_set="" both="" break="" c="" calculate="" calibraci="" change="" clear="" cli="" code="" con="" conectamos="" conectar="" continuar="" conversion="" cpu="" ctualizamos="" cuando="" cuenta="" de="" defined="" delay="" digitalread="" digitalwrite="" digo="" disable="" dormimos="" dormir="" double="" doublemap="" duda="" ejemplo="" el="" elif="" else="" en="" enable="" endif="" entrada="" entre="" es="" esta="" externa="" first="" for="" gastando="" gimsk="" habr="" hacer="" hay="" he="" high="ADCH;" if="" in="" in_max="" in_min="" independiente="" interna="" internal="" interrupci="" interrupt="" interruptor="" interrupts="" intpin="" isr="" it="" la="" las="" lectura="" led="" lido="" llama="" lo="" locks="" long="" los="" low.="" low="" mantenga="" mcucr="" measurement="" measuring="" mega1280__="" mega2560__="" mega32u4__="" menos="" millivolts="" must="" mv="" n="" necesito="" no="" ocurre="" off="" on="" ormimos="" out_max="" out_min="" p3="" p4="" pagamos="" para="" pb3="" pcmsk="" pero="" pin="" pines="" pixels.color="" pixels.setpixelcolor="" pixels.show="" podr="" ponemos="" ponerlo="" por="" preestablecidas="" preferido="" puede="" pull-up="" que="" quedan="" read="" readvcc="" reference="" referencia="" refiero="" register="" relepin="" replaces="" resistencia="" result="" resultado="" return="" rutina="" rutinas="" s="" salidas="" se="" sei="" ser="" set="" set_sleep_mode="" sets="" settle="" si="" sigue="" sleep="" sleep_cpu="" sleep_disable="" sleep_enable="" sobre="" soltar="" start="" statement="" suficiente="" tener="" teor="" the="" then="" tiempo="" tierra="" tiny24__="" tiny25__="" tiny44__="" tiny45__="" tiny84__="" tiny85__="" to="" todo="" todos="" tras="" turn="" uint8_t="" una="" unlocks="" usar="" utilizar="" variar="" vcc="" vect="" void="" voltaje="" vref="" wait="" while="" x="" y="" ya="">

It was used part of the code reference Digispark for the voltage on the same pin power (with the internal reference of 1.1V). As you have seen, in the end I opted for Nano , riding a Atmel 328 and is compact; we have 30 Ks flash memory available and 2 Ks SRAM, and enough inputs and outputs to do many things :). With these improvements the bike already has everything I wanted to have , now enjoy daily with her! (I hope not having to play their guts in a long season, bufff;)

PS: Thanks honey for your patience!

Extending the range and power of the bike by adding two cells in the luggage carrier

noreply@blogger.com (Ringmaster) — Thu, 12 Jan 2017 14:54:00 +0000

Before this project, the battery of my bike consisted of 8 cells in series of 6 batteries LiFePo4 A123 in parallel each, and I realized that I could have some more top speed and range by adding two cells with the previously left over LiFePO4 A123 batteries, and changing the BMS for the one I found of 10S and 60A (much better than the previous 15Ah only):

BMS / Control LiFePo4 charging battery cells 10 and 60A maximum.

I will not cease repeating that if ye ride yourselves a Lithium Ion battery, you must put always a BMS, as this is essential prottection for the battery, cutting the flow of current in both overload and over - discharge in any of the cells.

One important note: This only works if you use the SAME type and state of cells for the additional cells (or you will get an unballanced battery fast, or worse, damaged cells that can't cope with the current).

On the other hand, increasing only 6V maximum load, I can still use the configuration of the motor control for 24V (having automatic cut if they drop too low voltage with the BAC-281P ebike controller, we cut prematurely the current if we use 33V battery with a 36V configuration).

Features of BMS 10S LifePo4 60A load balancing ref. BMS-10SQZ6060LF375 :

Important data:

10 Cells LiFe 3.6V, 36V full.
Maximum peak current: 90A
Constant current approx. without sink: 30A
Standby power consumption: 0.1 mAh (100 microamperes / hour).
For the rolling is effective with only 70mAh per cell balancing, the load should be as slow as possible (depending on the difference of load cells), recommended < 500 mAh.

As I noted, the 12 could fit on a damaged old hard drive enclosure aluminum made.

There remained some slack, but could solve it with adhesive foam rubber to absorb shock well:

So I put hands to work. To have to go put them in groups of four , with the remaining in the center spread two to one side and two to another , so we must be careful not to make mistakes and connect, helping 2.5 mm cable. at least in the connection of the plants with the right poles of the other sides.

What first is to unite the end , positive with positive to put the four parallel welding the pole with copper strip wide enough to support the planned amperage (these batteries are the 2007 second hand, and no longer give more 7Ah instant by high internal resistance each, but still retain between 1900 and 2000 mAh its original 2300 mAh):

The plates got in his day the old drill batteries; you just have to sand them a little so that the tin (with internal flux) adheres well; for this I used the multi-tool Proxxon :

And as I explained in this video, I soldered cells:

Thus so are the two sides packs:

I put tape kapton high temperature where it could, heat, short-circuit one another

We must come to this; that is, a pack of 6 batteries in parallel connected in series with the other pack, but placing them in four 4:

Important protect high temperature Kapton tape all areas in contact with the wires

For this I joined the two packs with the center , leaving loose union of the 4 with the next 2 to be folded power as in the following image:

(Notice that the center joins only the positive side to the negative to the series)

This way you can fold, but lack join the other side by wiring:

Be very careful to protect both sides where the poles change and corresponding to the other cell, or will be guaranteed short , as shown in the figure below, where I soldered the cable between the two central positive to positive end of the 4:

A lack of support I helped legs;)

And finally I soldered two wires of 2.5 mm or more to positive and negative (positive blue) plus one green that is just fine for the BMS controls the voltage of the first cell, and wrapped in plastic tape, I used adhesive PVC:

Before putting them in place, also isolated the top of the box with wide PVC tape , so that the friction of the vibrations do not short with aluminum insulation descastarse time:

And and we put in place was very fair, but luckily the other side had ample space and was well adjusted:

And only the tops are placed, with a hole for cables and glued together with silicone:

And voila, we have a powerful battery with 10Ah LiFePo4 33V !, 0,33kW stored at 4 kg! And more than 1000W of peak power outputs What! (I add a video soon).

This is the former BMS , which was tied to the top (only used it to charge so, if I clueless, too discharged battery, partially damaging it ):

And the wiring diagram of the new BMS with rolling is as follows:

To connect, we need to have cables each connected cell and identified:

I have glued PVC tape that holds well behind:

And then silicone (enduring high temperatures) I have stuck in the central cavity of battery:

In this case, when 60A peak control and how rarely climb 30A consumption, control, after rising cost of 10% of 300 mt barely been heated, so I see no need to add heat sinks or attach to the top to dissipate excess heat:

And I have finished covering everything with masking tape (adhesive paper), which insulates enough, adheres better than the Kapton tape and also endures high temperatures:

Installation and improvements over an Hephestos Prusa i3 3D Printer from BQ

noreply@blogger.com (Ringmaster) — Sat, 17 Dec 2016 18:01:00 +0000

Those who follow me will have seen that I have uploaded some videos with the assembly of the i3 Prusa BQ, plus reducing vibration and the last has been adding LED light, adapting for printing flexible filament and isolating the extruder with silicone (spanish voice):

At the end the conclusion has been that we use perfectly the original extruder with filaflex printing between 20 and 40 mm / sec, as long as we place the piece or "router" thread to avoid traffic jams because of the flexible nature of the filament, recommended adding a lightly oiled filter cleaning filament (for this or any type of filament) and facilitate their way to the extruder. Important also the temperature between 220 and 230 ° C and that the environment does not fall below 20 ° C or put a warm bed at 30 ° C to ensure that the layers are joined.

If you do not want to complicate, we can always change the entire extruder one better than no need improvement, such as the DDG BQ .

The LED light can see it is quite simple ; it is looking for a pair of wires with 12V and regulate it at a low voltage to prevent the LED from deteriorating prematurely.

As for the isolation of the head, which can save us more than a burn, besides saving energy, it is very important to leave enough hours to harden the material (two days at least). I just waited eight hours and humbled that drew the inside of uncured was curious to say the least;).

In the next post on this subject I will give you some tips for starting printing in the infinite world of 3D printing to print successfully any type of piece. See you soon!

Improving cooling a powerful notebook graphics with a transistor and Arduino

noreply@blogger.com (Ringmaster) — Thu, 15 Dec 2016 17:56:00 +0000

Laptops that come with powerful graphics have an usually badly designed thermal control; This is the case of my dear Acer 5930G (already I spoke above ) wearing a removable Geforce graphics card.

Engineers Acer believed it was enough to regulate the fan with the processor temperature, since the sink joins both, but the graphics consume more, which can reach 70 easily while the CPU is 40 and the fan medium gas.

We'll see how we regulate the fan directly 5V , depending on the temperature of the area that interests us, with the advantage of being able to use any fan that can be coupled to our team, plus you can customize the level of cooling in the Arduino code.

The result : I got him down more than 20 to the graph regarding the regulation of factory, from 70 to about 45 ° C at rest. And in 90 games at maximum 70 ° C. You hear more, because almost constantly is 100% , but if that win in durability, I welcome the resulting hiss. Another advantage is that by taking the power from the USB port, turn it off when no temperature peaks but still cooling off while connected to the grid, until it cools completely and stops.

Materials Needed:
- Chip ATtiny85
- Transistor NPN 50V typical and 5Vgs ( 2N4401 I used myself).
- Capacitor 220uF 6V and min.
- Diode 5V and minimum hold 200mAh.
- Tubing.

As we saw recently, we can regulate fans (and we want) with a small chip , ideal for small projects where few inputs / outputs, the ATtiny85 are required.
In this case, reusing the code, instead of sending a signal to the chip PWM fan, will regulate directly the 5V voltage it receives, so that the minimum start on 1V.
But we can not do directly with the Attiny, but we have to use a small NPN transistor , with a small positive signal at its base, acting regulator current flow between the collector and emitter.

Note: It is called NPN because we regulate a negative signal (N negative), and the base will deliver a positive signal for it.

This is the code, also on Github :

 /*  ==================================================================

  Sketch control ventilador por PWM con ATTiny85 económico termistor NTC.
  Configurado para ventilador genérico; con autolimpieza al arranque.
  
    Autor: David Losada, basado en trabajos de Rafael Torrales y Antonio Moles.
  Version: 1.0
  Fecha: Octubre 2016. Última actualización 13/10/2016
  Compilado con Arduino 1.6.9

    ==================================================================   */

#include  //Instalar esta rutina si no la tenéis; está en el repositorio general de Arduino 1.6.9
//Si anduviéramos cortos de memoria, habría que eliminar la librería EEPROM y el código relacionado

//******************* A CAMBIAR SEGÚN TU CONFIGURACIÓN ********************************
//Control temperatura
const float resistor = 6800; //El valor en ohmnios de la resistencia del termistor a 25ºC
const float voltage = 5.0; // El voltaje real en el punto 5Vcc de tu placa Arduino

//Deltas de temperatura
int tempMin = 30; //Temperatura mínima de activación del ventilador
int tempMax = 50; //temperatura a la que funcionará al 100%
//0,85V=velocidad mínima de vent. PS3 y 1,25V vel. máxima
double PWMMin = 0.8; //Voltaje PWM de funcionamiento con temp. mínima (el de la PS3 se pone en marcha con 0,8V)
double PWMMax = 5; //Voltaje PWM de funcionamiento al máximo ventilador
//Hay que tener en cuenta que los voltajes se ajustan a las temperaturas pero no se ciñen a ellas,
//es decir, que a tempMin el voltaje será PWMMin, pero a menor temp. el voltaje bajará, y lo mismo
//con el voltaje máximo; si sigue subiendo la temperatura, el voltaje PWM aumentará en consecuencia,
//hay que tener cuidado porque podríamos dar más voltaje del necesario al ventilador

//Definición pines digitales para activar relés
int TempPIN=1; //En el ATTiny85 las entradas son (1)=P2; (2)=P4; (3)=P3; (0)=P5 -> Pin al que conectamos el termistor
int placaPIN=0; //
//(Entre el GND y ése pin soldaremos una resistencia del mismo valor del termistor)
int motorPWM=4; //Pin PWM de control motor; P0, P1, P4 el en ATTiny85
const int frecseg = 1; //Tiempo en segundos entre cada ejecución del programa (recomendado entre 1 y 5 segundos)
int ledPIN=1; //Según la placa, en este caso el LED del ATTiny85 B es el 1

//********************************************************************************
//Variables
float Temp= 0; //Valor entrada sensor temp
int fanSpeed= 0; //Velocidad de motor
long timeLED=0; //Para almacenar tiempo
unsigned long millisInicio=0; //Para comprobar paso de horas

//Parte del cálculo temperatura
//Para ahorrar cálculos lo definimos como constante en esta parte del programa
const float K= 273.15; //Para pasar a grados Kelvin
const float e = 2.718281828459045; //Constante matemática 
//const float B = log(RPto2/RPto1)/(1/(TPto2+K)-(1/(TPto1+K))); //Valor Beta de tu termistor calculado de dos puntos
const float B = 3850; //Valor Beta del Datasheet; comentar esta línea si se meten los datos de los dos puntos
const float unodivr = 1/(resistor * pow(e,(-B/298.15))); //Con pow elevamos e al resultado

float T = 0; //Declaramos la variable Temperatura
int grados, decimas; //Para ponerle coma al resultado (en español)

void setup()   { 
//Resetea la EEPROM la primera vez que la usamos
EEPROM.setMemPool(0,512); //Establecemos inicio y tamaño de EEPROM de la tarjeta utilizada
EEPROM.setMaxAllowedWrites(128); //Mínimo para que pueda hacerse el primer borrado completo
//rellenamos de 0 los datos de EEPROM
//Attiny85 tiene 512 Bytes de EEPROM; ajustar según el que uséis
if (EEPROM.readLong(508)!=7091976) { //En ese punto, preferiblemente al final, guardo un valor para saber si ya la he reseteado
  for(int i=0; i<502 -="" 0="" 10000="" 10="" 16="" 1:="" 25ms="" 2:="" 2="" 3:="" 3="" 5="" 5v="" :="" a="" acar="" actuamos="" alimentar="" anal="" analogwrite="" and="" ara="" arte="" b="(RPto2/RPto1);//(1/(TPto2+K)-(1/(TPto1+K)));" basandose="" beta.="" calcular="" caracteres="" coja="" con="" consecuencia="" consola="" convertimos="" correcta="" corresponde="" de="" dejamos="" del="" delay="" desde="" divisor="" ecoge="" ecuaci="" eeprom.update="" eeprom="" efinir="" egla="" el="" emp="" emppin="" en="" enciende="" entre="" erial.println="" espera="" filas="" final="" float="" for="" forma="" funcionamiento="" gico="" ha="" i="" if="" indicando="" indicativo="" inicializado="" input="" int="" justar="" la="" lcd.begin="" lecturas="" led="" ledpin="" leemos="" limpieza="" lmacenamos="" lo="" loop="" los="" ltima="" m="" media="" mediante="" medias="" mero="" millisinicio="millis();" motor="" motorpwm="" n="" o="" omprobamos="" onemos="" onvertimos="" orrado="" output="" pantalla="" para="" parar="" parte="" pines="" pinmode="" placapin="" ponemos="" posici="" progresiva="" puerto="" pwm="" pwmmax="(255*PWMMax)/5;" pwmmin="(255*PWMMin)/5;" que="" r1="r1a" r1a="(voltage*float(resistor))/v2;" rango="" resistance="" resistencia="" resistor="" revoluciones="" sacar="" se="" seg="" segundos="" so="" sobre="" speramos="" steinhart-hart="" t="B/log(r1*unodivr);" tama="" tarda="" temp="T-273.15;" temperatura="" tenemos="" terminado="" thermistor="" tope="" total="" tres="" un="" v2="(R2*V)/(R1+R2)" valor="" valores="" veces="" ventilador="" void="" voltage="4.83" voltaje="" voltios.="" voltios="" voltmax="" volvemos="" x="" ximas="" y="" ya="">=tempMin) { //No nos interesa ponerlo en marcha a menos que se alcance la temp. mínima
  analogWrite(ledPIN,150);//Marcamos indicando que activamos el ventilador
  fanSpeed = doubleMap(Temp, tempMin,tempMax,PWMMin,PWMMax); // Calcula la velocidad a la que corresponde estar
  //(Necesitamos que según aumente la temperatura, lo haga fanSpeed)
  //Valor PWM de 255 en el ATTiny85=5V
  analogWrite(motorPWM, fanSpeed);  // Modifica la velocidad para bajar temp
  delay(100);
  analogWrite(ledPIN,0);
}
else {
  analogWrite(motorPWM, 0);
}
  //DEBUG por serial (no disponible en el aTTiny)
  //Serial.print("Temp: ");
  //Serial.println(Temp);
  //Serial.print("Velocidad: ");
  //Serial.println(fanSpeed); 
  //Serial.print("V: ");
  //Serial.print(fanSpeed*5/255);
  //Serial.print(",");
  //Serial.print(int(fanSpeed*5/2.55));
  //Serial.println("V ");
  //Serial.print("Tiempo encendido: ");   

  //Hacemos parpadear al LED comprobando el tiempo desde la última activación
  if (timeLED>millis()) { //Cuando pasen 50 dias resetear
    timeLED=millis();
  }
  if ((millis()-timeLED)>frecseg*1000*2) {
      analogWrite(ledPIN,50); //enciende LED indicando funcionamiento
      timeLED=millis();
  }
    if ((millis()-timeLED)>frecseg*1000) {
      analogWrite(ledPIN,0); //apaga led
    }

//Si ha pasado una hora desde la puesta en marcha, comprobamos si >= Horas limpieza
//Y si es así, ponemos al tope el ventilador 5 segundos
if ((millis()-millisInicio)>3600000) { //Ha pasado una hora
  millisInicio=millis(); 
  EEPROM.update(0,EEPROM.readLong(0)+1); //Añadimos una hora
}

  delay(frecseg*900); //Ponemos en espera al Atmel
}

// *************** RUTINA MAP MEJORADA (admite fracciones)
double doubleMap(double x, double in_min, double in_max, double out_min, double out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

First of all, we open the fan zone, and took the opportunity to remove accumulated dust in recent months with an old brush teeth or the like:

Uauh! Amazing what comes to capture in a short time.

As we discussed above, for the thermistor sensor-we have to place between ground and the input resistance of the same value as the thermistor at 20 ° C ; in this case one of 6K8 ohms.

In my program I regulo the base of NPN 4401 with PIN 4, in the image preparing welding heat shrink tubing:

In the photo the thermistor is misplaced; one of the legs of the thermistor will 5V, not to GND, then changed

First of all relevant evidence should be made; in this case using two Li-ion batteries, total feeding 8V regulator ATtiny85, and the fan feeding the 5V regulated output and the negative connected to the emitter of NPN transistor 4401 positive:

Then I spent an afternoon watching to see how he could feed the 5V fan; I tried unsuccessfully to 11V that the plate has at some points, but had very few mAh and the fan barely moved.

So in the end the only solution was to use directly the 5V regulated used to power the USB and most of the plate, and opened completely computer and looking at the plate connecting 5V I found it easy to weld to connector side; if you have to look at your team the point, usually near the battery connection, where some voltage regulators are responsible for lowering the power to 5V:

Here we must be careful not to attach pins other than 5V, have to work without battery and power off:

Once you 've got the 5V, directly feed the chip 5V on pin (not the VIN, where would feed through the regulator because there need between 6 and 12V to get 5V).

For good thermal transfer I used thermal grease, but we can also stick with a drop of silicone to remain in contact with the surface to be measured:

Here you can see it with black tape to hold while drying her silicone:

Then I realized the buzz that got the engine to resonate the PWM pulses at low speed transistor; To avoid this simply a capacitor of 10V and a 470uF enough (just less well), it also is advisable to place a diode between positive and negative so that redirect power to the fan itself when disconnected (is covered by heat shrink in the Photo):

This capacitor is a bit cumbersome, smaller also applies

I am very happy with the result; yes it is almost constantly working to stop but do not bother me, it's pretty quiet. This time I did not take final photo with the rush, another day to clean it will update the entry.

Drivers for Windows 10 ATI RV370 (X300)

noreply@blogger.com (Ringmaster) — Tue, 13 Dec 2016 17:58:00 +0000

Here you have the direct download, without advertising, of drivers that work for this card in Windows 10 (64 - bit and ~~I think~~ also 32 bits).

If it gives you an error with the installation, you have to install them manually (by going to Device Manager -> Select Display driver (right mouse button) -> Update Driver, select it manually on the system, locate the driver directory).

I've gone crazy looking for them ... getting no more than incorrect drivers for it (Ati no longer supports it) so if I hope will save more than one headaches... :).

Reusing power sources to power devices of different voltages: voltage converters

noreply@blogger.com (Ringmaster) — Tue, 13 Dec 2016 17:53:00 +0000

42V DC Power 19V 2A regulated DC to charge a laptop that spends 3A

In this post we will see how to feed these appliances we have at home, whose power supplies had stopped working and left, forgotten, in a drawer.

For example, that portable power supply can have a second life and continue feeding any device that requires a power exceeding the capacity (watts) of the transformer. While we maintain the amps equal or exceeding the needings by the apparatus we want to power, we just have to make sure that the voltage output is the same or little less of your device needs.

If for example we need an e-bike charger, or need a charger of a given voltage, we can adapt economically the output voltage: This is where the boosters and converters come into play modifying voltage DC to DC.

We will see both types (there are also some that allow both functions), available for purchase Chinese - made but are quite reliable provided that takes into account their working conditions.

150W upconverter

It has entrance and exit to one side and a small screw adjustment (right) which regulate the output voltage

At least that's what they say hold on, but I guess that's the peak power; more than 60W will need a fan to cool the heat sinks or burn soon. There are other available similar, higher or lower power, better or worse designed, but the operating principle is the same.

Characteristics:

DC input of 10 to 32V to an output of between 12-35V (with a source of 12VDC can obtain regulated 30V output).
Up to 60W , for more power, better put a small fan heatsinks. From start to appreciate 30W a slight noise (similar to a large transformer) capacitors from working.
Based on the micro UC3843 , which controls the modulation on demand.
A MOSFET (diode) to feed the capacitor, and a voltage regulator are responsible for doing all the work.
He carries a large capacitor both input and output to eliminate crimped by high frequency.
No reverse polarity or fry quickly;).

Martin Jones has made an in deep analysis of this model on this page , and in short, it is an elevator that takes advantage of the ability of a coil to store energy, which is "loaded" during one of the states, and then empty adding the line voltage to be serially, increasing the available voltage, the second state. It is best explained in the Wikipedia .

I've added it to reduce twisting when asked a lot of power, a pair of capacitors over the same type as those carried by connecting the rear (then put them a longer cable to take them to the top and not stick with the transformer where use):

Keep in mind that does not have any protection; or reverse polarity, or temperature, or overload, or anything , so you have to consider not exceed 50W or else we have to put a fan.

I needed a transformer between 27 and 29V to feed my LiFePO4 battery 24V (8 cells in series) and between 300 and 500 mAh for load control properly sway cells, and I have built from source DC 12V 1Ah, which raised with this converter, and taking into account that will have an efficiency of 85% or so, we will give the 375mAh output :

Origin 12V * 1A = 12W

12W / 27.2V * 0.85 (sc.) = 0,375Ah Output

With what I recharge the battery half in 16 hours (capacity 6Ah / 0.375Ah load), ideal for leave loading afternoon until the next day.

I have peeled encintándolo on the transformer; as verify that it works, it is best to isolate it well, but there is no security problem because the maximum voltage of 35V will be, which is a safe voltage (<50v div="">

I've added output LED voltmeter 3 to 100V DC to verify that the voltage does not vary much (potentiometer regulation is not very stable to say, may vary 0.5V). White power cable indicator has a maximum of 35V (place a resistance line voltages with us to handle), and carries a small potentiometer that can calibremos and error to come up with 0.3V:

LED voltage indicator of Chinese economic 2,8-100V

Plugged into the wall looks like this, more like a bomb with your account-back;)

This LED can work between 2.8 and 90V

Update: At the end of the transformer did notenough "chicha" to power the bike, so I put a feeder for LED lamps 900mAh and 30VDC to load with a voltage regulator regulated to 30V, making the charge to 28V ( balancer circuit requires a higher voltage for losses). Thus the charge to a maximum of 90% (it did not matter we charge 100% not the regulator would be necessary, give between 30 and 32V balancer work well).
In addition it is perfect for outdoors as part of the high voltage is encapsulated inside with epoxy resin under the IP65 standard :

90W downconverter

To reduce the voltage of other power supply I have modified an AC-DC regulator that had, mounting two voltage regulators LM317 running in parallel, which has a capacity of 3A (1.5A each), but if we do not need so much power have with a single regulator for 1 € converters simple based on a LM317T (the T is for the tO-220 package) with your sink:

I modified the tracks and connections (before two sources regulated independently) to do it in parallel:

It is simple and can increase power by simply adding more as needed. And if you do not want complicaros, there are different powers available online, in Spain and the rest of the world ( do not ask me where).

Happy modifications!

More info:
Converters DC DC
150W Boost Converter

Improving the Ebike with Arduino to monitorize battery and other info 1/2

noreply@blogger.com (Ringmaster) — Thu, 08 Dec 2016 20:30:00 +0000

It is the second time it happens; I pick up the bike, and after the trip to work, the ebike left me without power in the middle of a slope... with the hassle of having to carry their 30 kgs. on a slopes over 14% (and the damage it does to the battery the depth discharge, fortunately are pretty well LiFePo that support this).

I have no charging indicator (the handle that provided me is to 48V) to calculate if you have enough power for 4 km I have to do, and also the LiFePo4 have a very small voltage variation between 20% and 80% of capacity (between 3,15V and 3,35V), which is easily neglected. And make it load every day is not practical or the best for the battery (ideally recharge when you reach the 20% to maximize battery life). And the battery charge indicators seem to me too "greedy" energy. So...

A solution for every need ...

01/09/17: In the end I finished using a Nano and MPU-6050 accelerometer for burglar alarm functions and voltage indicator, in the 2/2 post from january 2017 you can see the details.

I thought it would be nice monitor the status of the battery with an Arduino, and indicate with an RGB LED (green to red to yellow, orange ...) the need to recharge the battery. But I do not want to stay there alone; the advantage of the Arduino is that we can make this task intelligently, and turns red when it is considered that given the historical average consumption of travel (if for work usually similar), not reach us by the next trip , and we can charge it last night time (takes about 5 to 10 hours to fully charge a 2Ah charger, depending on what they are desigualadas cells). Or at least, not complicate both, we can tell our taste the percentage of battery with which we want to be marked in red (with 20% for example, as if it were the reserve indicator).

And not only that; once I forgot the light connected, and the next day I found her without battery. We may automatically turn off the power switchboard and accessories (with a solid state relay) if we detect that the voltage variation during the last half hour has been less than 0.10V (I figure that my battery capacity and minimum consumption, covers all cases), and prevent this from happening.

You could put a Hall ammeter to make accurate but the goal is to do something as simple as possible by measuring only the changes of voltages (Lithium batteries usually have curves similar discharge during its lifetime) and that can indicate parameters type battery. The problem I see is going to be whether the voltage is under load or not, to avoid false alarms by large fluctuations during high loads, one option is to average values every 5 min. eg. not to influence both.

You could even use the EEPROM to store the necessary historical data, and go calculating load point according to the latest consumption. The program could do the following:

After turning on the Attiny a switch, connect the main relay
We charge the EEPROM historical and see the average consumption per trip based on the voltage drop occurred,
and taking into account the capacity ratio / a LiFePo voltage (shown with A123 26650),
We started to monitor the battery voltage with a voltage divider and take data every minute, and every 5 minutes RGB color update.
If the voltage does not vary by more than half an hour 0.10V (must take into account the consumption equipment such as LED light bulb crossing), we consider that we have forgotten the connected and disconnected the main relay.
He had thought put to sleep the ATtiny ( consumption is the order of 5 microamperes (uA) in sleep mode ) while doing nothing, but its consumption is so small that not worth it, because it complicates the measurement of time elapsed. I will feed battery with a resistance of 100 ohms to protect the regulator.

All this we'll adjust according to the result, but I would like the program to "learn" to use, and it is not necessary shove values as battery capacity, etc. Simply be based on what is lacking to approach the minimum voltage and medium capacity was used in the last 10 trips, I guess.

Capacity curve as voltage LiFePo I monitored, by connecting the computer the iCharger 1010b +, downloading a LiFePo ANR26650A A123 9 years but with little use ( logview Studio 1 ), and a few mAh for the voltage / actual charge ratio (vary depending on the age of the battery and model) to adjust everything possible RGB LED indicator, but basically the general discharge curve in LiFePo4 is:

All the energy is stored between 3.1 and 3.3V Source

As shown, the load percentage is practically linear between 3.3 and 3,1V (at rest) , so between those voltages 80% of the cargo handled, which will charge indicator sufficiently reliable (the voltage divider has to be as accurate as possible). As I said, the problem will be whether we are accelerating or not (can lower the voltage enough in times of high engine stress, and never know if we accelerate unless we get this info on the other hand, as sensor hall engine or unit ...) but we can ignore this, and knowing that only rest well indicate the charging status, simplify the calculation .

Discharge curve at 40 mAh of a ANR26650A from A123 with 9 years ( Datasheet )

After this brainstorming and possibilities to implement an Arduino control in the next post I hope and have something functional and tell you the details.

Update 6/10: As usual, another came the same before me , even using the same RGB colors! However with the Digispark plate and connection process it is much simpler, and also serve to Li-ion batteries.

More info:
Measuring voltage with Arduino
Using Arduino to monitor battery cells
activate the Sleep mode easily in Arduino
Consumption ATtiny85: 5mA to 8 MHz and 5V

Sleep modes ATtiny85

Enabling deep sleep mode ATtiny85
Log view Studio; monitoring charge / discharge of battery

Types of Batterie Management Systems (BMS); building new batteries for our equipment

noreply@blogger.com (Ringmaster) — Thu, 06 Oct 2016 18:10:00 +0000

Complementing the already abundant information on this blog about batteries, recycling and repair, and BMS, I will analyze the types of BMS and qualities that we can find among Chinese BMS. The main reason for the short life of batteries any type is often their poor maintenance ; either because they remain flat or that are downloaded more than convenient (both lead as Li-ion do not tolerate discharges well below a certain level). To protect the batteries (particularly lithium dangerous if overloaded or short -circuited), the " battery Management Systems " or BMS come into play to good use and long battery life.

How to Choose the BMS we need

Before going into detail compare loading controls, beginners in this world often wonder what control they need for battery want to ride . I'll try to explain their concepts, but more to inform you that you may be experience with this issue. The BMS is linked to the battery ; the type of technology, discharge rate, number of cells is what we need to know before you even buy anything. Moreover , we have well -planned battery according to the demand of the apparatus in question before you even ask for the material. Imagine you have a baby carriage powered by lead - acid battery. If you have two 6V batteries in series, needs a total of 12V, and looking at the consumer (in this case is the motor is 100W, and what most consumed) then we will need to mount a battery that can deliver at least 8AH (100/12). If we take a battery of Lico from those used in laptops (Lithium ion and cobalt) we need at least 3 batteries in each cell (as they have 1C discharge capacity, in this case around 2,5Ah each), with 3 - cell 3.7V nominal (voltages between 9 and 12.6), which 2,6Ah batteries 9 each are covered. The BMS in this case will have to be 3S (3 cells in series) and 8A minimum (recommended 10A or more so there are no intermissions to cut the flow of current in grubbed more motor consumption) and LiCo or LiPo (they are often grouped under the name Li-ion, erroneously because of Li-ion there . many different) chemical I hope it now be a little clearer ...: P

BMS for lead batteries

A good control system balance between cells is always recommended, since no battery is factory exactly the same, always have some difference (internal resistance, capacity), but in systems of lead batteries sometimes unfeasible by high currents they handle, the resulting economic batteries, and overload tolerance, although there are balanced systems that lengthen its duration twice like this, highly recommended in large packs of accumulation of solar energy:

Balancer 12V (4x6V balancing a pack in cells 2S)

These balancers have poser consumption in vacuum up to 50mA (depending on model) because they are constantly matching, so it is only recommended for batteries that are recharged often (accumulation of solar energy and often used equipment). To this self - discharge of between 4 and 10% per month of this type of battery adds.

BMS for Lithium ion batteries

There are the controls sale Chinese cargo with very economic balancing, but we must be careful that simply protects the battery against overload / over - discharge, which must be avoided, because in a few cycles ended are crippling one of the cells. By testee example the following BMS 8S to LiFePo to put on my electric bike , fully discharging one of the cells, and load stopped when any of the cells reached the maximum, without actually loading of all the emptier. If we examine, we do not have any microcontroller , simply voltage control cascade stops loading or unloading if any cell voltage exceeds a predetermined level . And why in the page indicates that YES balances , and 70mA, which is not true:

This type of BMS only serve to protect the batteries in the charge / discharge

The following however, properly balanced , thanks to its microcontrollers, and can deliver up to 10A without problem (15 or 20A with proper ventilation).
The technical details indicated balancing with a current of up to 70mA, but I doubt pass 30mA :

You have to pay attention to where the cables are placed rolling.

Example BMS wiring (Ebikeschool.com)

I have found little LiFePo balancers offer, as this technology is rarely used in batteries, despite its incredible qualities. The same manufacturer, they also have to LiFePo 10S and 60A discharge current .

So, in summary, uid of BMS without central microcontroller .

Preparing a 12V battery for Sai and strollers

In this case, I took the remaining me to place on the old UPS originally employed two 6V batteries lead / gel placed in series (and ANR26650 / A1 batteries was using with old car batteries ), but well might be other uses as even a car or motorcycle starting large displacement, as protector 300A battery can deliverinstant to 12V (there are people using this system for ultralight by weight):

Protector cell battery without rolling

By delivering 13,3V end in recharging, the 4 packs of 2 batteries in series (4S2P) stay loaded in a healthy 3,32V each , representing a 90% load capacity, and not keep 100% lengthen their longevity:

Thus weighs less and has the same capacity, a very useful UPS to avoid losing parts in the 3D printer in case the lights go :)

As with the BMS, we must be careful when choosing the type of battery, since each chemical Li-ion makes them more suitable for some projects than others , but any battery can be used for any project as long as is dimensioned so not enough to overcome the load currents / recommended by the manufacturer for each battery discharge.

In this case, he needed the UPS to the 3D printer, which comes to consume 60W / hour maximum(no warm bed), so that walking cutlery and considering efficiency inverter UPS is 85% approx I need that the battery can deliver me 80W / h.

These ANR26650A LiFePO already have almost 10 years, but still retain a capacity between 1885 and 2000 mAh each, although the internal resistance has tripled degradation chemistry over the years.

The calculation passing amperes (W = V * A) is 80W / 12V = 6,66Ah

Types of Chemical Li-Ion

General summary properties of the most used batteries

I used LiFePO (iron phosphate) because its spectrum voltages between charged and discharged to 3.4V 2,9V varies, so with four serial and have required 12-13V . Moreover accept quick reloads more than 2C without damage very well (although I have not checked what amps gives the UPS to recharge), without forgetting that they can give quietly to 5C download the state they are (10A / h for holding current) so could suffice one in each cell, although in that case we would only have 2000 mAh capacity (with a consumption of 70W we would last 70 / 12V = 5,83A in an hour, with 2000 mAh would be 2000 * 60/5830 = 20 , 58 minutes).

Do not confuse the current that is capable of delivering a type of Li-ion battery with capacity.The current is usually indicated on C's that is the multiplier maximum intensity (value for loading and one for unloading) ; a higher C (LiPo can reach 50C in download but not more than 0,5-1C in download) can deliver more power without damage. I talked about it more widely when I made the first bike battery .

Welding the BMS

To connect the BMS I connect the main battery cables first; positive and negative , which usually come indicated with B + (swinging) and B- , and then I'm connecting one to one wire roll, starting with the positive or negative side, and going in order, with very careful not to mistake of polarity or we can load the BMS.

I usually play the BMS to see if any of the integrated heated , if heated much is a sign that something is not right since; then we have to drop everything quickly and review point by point.

The battery positive goes to positive motor / controller and charger positive in this case (image: Endless Sphere)

Connections vary BMS, and sometimes does not come clear or marks integrated or schemeprovided by the manufacturer laying cables swinging (sometimes even there) then you can find out connecting major battery (B + and B-) and measuring the voltage that there is in the cables; I indicate to which position corresponds (for example if the first da + 4.2V is a BMS LiPo / LiCo that cable and go into the first cell from the positive.

After everything is connected properly, if the BMS is OK (to me more than once has not worked for me some, because some vendors send them without testing), will be able to check that gives you the desired voltage at the P + connectors and P- that This is where a rule is loaded and unloaded and may use any charger with a tolerance between the total voltage of + 5V pack as the BMS is responsible for regulating the load and voltage and stop when fully charged.

In the near future I will make a video explaining when integrating the BMS on the bike (previously used by an external iCharger 1010+).

If you have any doubt, please coment!

Solar thermal collector configuration supporting gas/oil boiler

noreply@blogger.com (Ringmaster) — Tue, 04 Oct 2016 17:30:00 +0000

Antonio from Orense had a solar panel with a deposit of 150 lts connected to the same circuit ACS but separately, so that when it was sunny had to walk opening and closing keys to harness this energy and save fuel in the oil boiler.

With solar thermal energy (pre - heat the water with a solar collector) all are advantages. This renewable energy system is today the fastest amortized, usually in two years the installation is amortized, and lasts up to 30 years , with minimal maintenance. It's easy money, and who have not it installed, properly sized, they are throwing money to the trash, literally.

After analyzing your installation of ACS (ignoring the heating pipes), I advised him to use solar thermal as we do; supporting boiler (gas in our case).

The method is simple; it provides warm water tank directly to the boiler, so that it only has to provide sufficient energy to bring it to the temperature (usually 60 °), and so you forget.

Initial ACS circuit diagram

It goes without thermostat because it directly regulates the boiler. All diesel boilers I know carry a small exchanger regulated by temperature, and water in the boiler is maintained at about 60 to just open the tap, having already hot water. If we put water and preheated from the sensor, less time and sometimes you have to turn on , saving is complete and more perfect than if reguláramos the origin of the source with a solenoid valve.

Us instead of diesel, is a special gas heater for solar thermal , that all he does is adjust the flame according to the outlet water temperature, factory calibration at 60 ° C. Le I have connected the solar thermal storage tank to cold water, so that when water enters the flame 50 is practically turned off, or minimum, which saves a lot.

In the next picture you can see how the circuit was modified (indicated in black on the diagram) , changing the cold water connection ACS that goes to the boiler for solar thermal take it ; it's simple. You have to remove the plug from the general (is crossed out) so that there is no return (if you could not spend hot water by opening the cold at any point). Or put a check valve, but eventually chose to leave the connection behind the stopcock and keep it closed, as shown in the following photos.

You see how easy it is to use the sun to save on energy bills of your house. What do you expect to apply thermal panels on your roof?

Thanks Antonio for sharing!

DIY: Avoid overheating problems on your PS3 with a chip and sensor for 5 bucks

noreply@blogger.com (Ringmaster) — Sun, 02 Oct 2016 16:03:00 +0000

With a small chip Digispark ATtiny85 will see how to regulate the fan of the PS3 (or any PWM-controlled fan) depending on temperature, avoiding wear and tear prematurely.

Engineers PS3 gave priority to the silence of the PS3 , since it is intended to be a center of games and multimedia, so the processors can reach damaging temperatures for the welds thereof, and within a few years ends up breaking down by poor contact welding (reparable only with reflow or reballing).

The PS3 has a pulse PWM controlled fan, Atmel ATtiny85 and can be easily programmed with the Arduino IDE.

There are examples on Youtube and internet people that has regulated the fan fixedlyto go ever faster (with a resistance in the gray wire connected to the 12V, regulating 1V approx., Or with a potentiometer to do it manually) but is not the best solution because it does not consider the processor temperature (which can vary greatly depending on ambient temperature), and although it works, having to cover all cases, there isusually noisier. and with this solution we have the advantage that if we hear the very loud fan, you will surely have a problem of lack of ventilation dust or other problem.

materials

We just need the ATtiny85 ( very useful for small and simple projects as we saw in the previous tute , with 8 Ks capacity ) taking into account their differences:

The Digispark works with an Atmel ATtiny85 MCU - has some differences from the ATmega328 and some libraries do not work properly, but will improve over time.
The Digispark only 6 KB of memory available for our code (8 KB if we remove the virtual USB bootloader and we programmed directly with an Arduino UNO ).
Pin 3 and Pin 4 (P3 and P4) are used for communications and USB programming ; if only it interferes if we use the USB connection and can be used while not use the USB connection on the final design, but keep in mind that if the program acts dramatically on the voltage thereof, will be best to disconnect once we uploaded the program by USB.
Pin 3 (P3) is connected to a pull-up resistor 1.5 KQ required when P3 and P4 are used for USB communication (programming included). Your design will have to take that into account and you'd have to supercharge the pin to put it in LOW.
The Digispark does not have a serial port hardware or a converter to USB. A library of example (DigiUSB) as well as some sample code and a monitor program series, but communication with the computer will not always plug and play, especially when there are other libraries in use is provided.
On power does nothing until 4 seconds later , as it is the waiting time that is scheduled for programming USB (this I think can be eliminated by programming directly , but I have not tried), so must be taken into account if we need quick start the program.
While digital connections correspond to the pins (digitalRead (0) where 0 = Pin0), the correspondence of the analog pins change :

analogRead (1); // Read P2
analogRead (2); // Read P4
analogRead (3); // Read P3
analogRead (0); // Read P5

A we add a temperature sensor to regulate the PWM line (gray wire) Fan PS3 slim between 0.8V and 1.3V and less than 5 € we regulator.

In the next picture we see the cables and soldiers.

On pin 4 we have the PWM control,
2 in one side of the sensor (on the other hand the resistance needs mass) and the other side of the sensor chip to 5V out.
And the power supply connected directly to the fan (integrated controller supports between 6 and 15V).

I soldered directly 6K8 resistance you need this sensor NTC (such as those used in the previous tute for more info) on the back of this small plate:

Once programmed (Arduino at the end of this step by step program), we proceed to install. I will not go into the details of how to disarm; Internet is full of tutorials about it.

Once we have uncovered, we can see the three wires going to sink. Red is the positive + 12V, black is mass or -12V and gray is the voltage regulation pulse width ( PWM Wikipedia ).

We cut the gray, isolating the piece that comes from the motherboard with some duct tape to prevent touch anywhere and a short unwanted occurs. The part that interests us is coming out of the fan , and on which we regulate the fan.

To connect the red and black wires only I peeled a bit without being cut, to apply some solder with the soldering iron and feed them the ATtiny85.

IT IS VERY IMPORTANT well placed temperature sensor, to make good contact with the heatsink RSX, it depends which is adjusted correctly. I have attached silicone (can withstand high temperatures) once you've checked that everything worked well:

And it has already been us with the source placed on your site.

I have several chips ready programmed with the sensor and ready to install; if anyone is interested to contact me to do her a favor and send it by mail.

In the following video you can see all the steps and the difference of the original fan RPM and with our automatic controller:

The program is as follows ; I added code to do self-cleaning every time it is turned on, activating the fan at max speed and stoping it after 3 seconds:

 /*  ==================================================================

  Sketch control ventilador por PWM con ATTiny85 económico termistor NTC.
  Configurado para ventilador Playstation 3; con autolimpieza al arranque.
  
  Autor: David Losada, basado en trabajos de Rafael Torrales y Antonio Moles.
  Version: 1.32 (Ahora la autolimpieza la hace cada vez que se enciende la consola)
  Fecha: 20 de julio de 2016. Última actualización 7/02/2017
  Compila con Arduino 1.6.9

    ==================================================================   */

#include  //Instalar esta rutina si no la tenéis; está en el repositorio general de Arduino 1.6.9
//Si anduviéramos cortos de memoria, habría que eliminar la librería EEPROM y el código relacionado

//******************* A CAMBIAR SEGÚN TU CONFIGURACIÓN ********************************
//Control temperatura
const float resistor = 6800; //El valor en ohmnios de la resistencia del termistor a 25ºC
const float voltage = 5.0; // El voltaje real en el punto 5Vcc de tu placa Arduino

//Deltas de temperatura
int tempMin = 20; //Temperatura mínima de activación del ventilador
int tempMax = 37; //temperatura a la que funcionará al 100%
//0,85V=velocidad mínima de vent. PS3 y 1,25V vel. máxima
float PWMMin = 0.65; //Voltaje PWM de funcionamiento con temp. mínima (el de la PS3 se pone en marcha con 0,8V)
float PWMMax = 1.3; //Voltaje PWM de funcionamiento al máximo ventilador
//Hay que tener en cuenta que los voltajes se ajustan a las temperaturas pero no se ciñen a ellas,
//es decir, que a tempMin el voltaje será PWMMin, pero a menor temp. el voltaje bajará, y lo mismo
//con el voltaje máximo; si sigue subiendo la temperatura, el voltaje PWM aumentará en consecuencia,
//hay que tener cuidado porque podríamos dar más voltaje del necesario al ventilador

//Definición pines digitales para activar relés
int TempPIN=1; //En el ATTiny85 las entradas son (1)=P2; (2)=P4; (3)=P3; (0)=P5 -> Pin al que conectamos el termistor
int motorPWM=4; //Pin PWM de control motor; P0, P1, P4 el en ATTiny85
const int frecseg = 1; //Tiempo en segundos entre cada ejecución del programa (recomendado entre 1 y 5 segundos)
int ledPIN=1; //Según la placa, en este caso el LED del ATTiny85 B es el 1

//Variables
float Temp= 0; //Valor entrada sensor temp
int fanSpeed= 0; //Velocidad de motor
long timeLED=0; //Para almacenar tiempo
unsigned long millisInicio=0; //Para comprobar paso de horas

//Parte del cálculo temperatura
//Para ahorrar cálculos lo definimos como constante en esta parte del programa
const float K= 273.15; //Para pasar a grados Kelvin
const float e = 2.718281828459045; //Constante matemática 
//const float B = log(RPto2/RPto1)/(1/(TPto2+K)-(1/(TPto1+K))); //Valor Beta de tu termistor calculado de dos puntos
const float B = 3850; //Valor Beta del Datasheet; comentar esta línea si se meten los datos de los dos puntos
const float unodivr = 1/(resistor * pow(e,(-B/298.15))); //Con pow elevamos e al resultado

float T = 0; //Declaramos la variable Temperatura
int grados, decimas; //Para ponerle coma al resultado (en español)

void setup()   { 
//Resetea la EEPROM la primera vez que la usamos
EEPROM.setMemPool(0,512); //Establecemos inicio y tamaño de EEPROM de la tarjeta utilizada
EEPROM.setMaxAllowedWrites(128); //Mínimo para que pueda hacerse el primer borrado completo
//rellenamos de 0 los datos de EEPROM
//Attiny85 tiene 512 Bytes de EEPROM; ajustar según el que uséis
if (EEPROM.readLong(508)!=7091976) { //En ese punto, preferiblemente al final, guardo un valor para saber si ya la he reseteado
  for(int i=0; i<502 -="" 0="" 10000="" 10="" 16="" 1:="" 255="" 25ms="" 2:="" 2="" 3:="" 3="" 5="" 5v="" :="" a="" acar="" acemos="" activaci="" actuamos="" al="" alimentar="" alor="" anal="" analogwrite="" and="" ara="" arte="" attiny85="5V" attiny="" aumente="" ax="" b="(RPto2/RPto1);//(1/(TPto2+K)-(1/(TPto1+K)));" bajar="" basandose="" beta.="" calcula="" calcular="" caracteres="" coja="" comprobando="" con="" consecuencia="" consola="" convertimos="" correcta="" corresponde="" de="" dejamos="" del="" delay="" desde="" disponible="" divisor="" ecesitamos="" ecoge="" ecuaci="" eeprom.update="" eeprom="" efinir="" egla="" el="" elocidad:="" emp:="" emp="" emppin="" en="" encendido:="" enciende="" entre="" erial.print="" erial.println="" espera="" estar="" fanspeed="" filas="" final="" float="" for="" forma="" gico="" ha="" haga="" i="" iempo="" if="" in="" indicativo="" inicializado="" input="" int="" justar="" la="" lcd.begin="" lecturas="" led="" ledpin="" leemos="" limpieza="" lmacenamos="" lo="" loop="" los="" ltima="" m="" media="" mediante="" medias="" mero="" millisinicio="millis();" modifica="" motor="" motorpwm="" n="" no="" o="" omprobamos="" onemos="" onvertimos="" orrado="" output="" pantalla="" para="" parar="" parpadear="" parte="" pines="" pinmode="" ponemos="" por="" posici="" progresiva="" puerto="" pwm="" pwmmax="(255*PWMMax)/5;" pwmmin="(255*PWMMin)/5;" que="" r1="r1a" r1a="(voltage*float(resistor))/v2;" rango="" resistance="" resistencia="" resistor="" revoluciones="" sacar="" se="" seg="" segundos="" serial="" so="" sobre="" speramos="" steinhart-hart="" t="B/log(r1*unodivr);" tama="" tarda="" temp="" temperatura="" tempmax="" tempmin="" tenemos="" terminado="" thermistor="" tiempo="" timeled="" tope="" total="" tres="" un="" v2="(R2*V)/(R1+R2)" valor="" valores="" veces="" velocidad="" ventilador="" void="" voltage="4.83" voltaje="" voltios.="" voltios="" voltmax="" volvemos="" x="" ximas="" y="" ya="">millis()) { //Cuando pasen 50 dias resetear
    timeLED=millis();
  }
  if ((millis()-timeLED)>frecseg*1000*2) {
      analogWrite(ledPIN,100); //enciende LED indicando funcionamiento
      timeLED=millis();
  }
    if ((millis()-timeLED)>frecseg*1000) {
      analogWrite(ledPIN,0); //apaga led
    }

//Si ha pasado una hora desde la puesta en marcha, añadimos una hora
// al contador de la EEPROM, para estadística
if ((millis()-millisInicio)>3600000) { //Ha pasado una hora
  millisInicio=millis(); 
  EEPROM.update(0,EEPROM.readLong(0)+1); //Añadimos una hora
}

  delay(frecseg*1000); //Ponemos en espera al Atmel
}

// *************** RUTINA MAP MEJORADA (admite fracciones)
double doubleMap(double x, double in_min, double in_max, double out_min, double out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

In this video you can see how economic ATtiny85 program:

Another improvement: Increase cooling the power supply of the PS3

For those interested, first I had the idea to improve heat dissipation from the source by adding an aluminum plate of 1 mm. clipped and bolted to the two dissipators having, to more easily remove heat from regulators and MOSFET and last us:

I applied silicone or thermal plasta over both sinks:

Let it stick for a day at least and then drilled in every sink to put the screws to secure it well and improve contact (optional if we used silicone):

We must make room for the plastic holders, luckily 0.5 mm. Aluminum is easy to cut with strong scissors electrician eg .:

Thanks to this mod, our play "will play" much longer, it takes a month working and only slightly perceived the fan if you remove the sound, and its temperature has dropped at least 15 ° C of factory settings.

And that's all for now, thanks for your comments!

More information:

Connecting and programming your Digispark:

https://digistump.com/wiki/digispark/tutorials/basics

http://digistump.com/wiki/digispark/tutorials/connecting

Starting with ATtiny85

Thermistor 6K8:

http://www.farnell.com/datasheets/1458615.pdf http://uk.farnell.com/te-connectivity-neohm/ntc0805j6k8/thermistor-ntc-0805-6k8/dp/2042916

Centralized control Solar-Biomass mixed system with Arduino and TFT Shield

noreply@blogger.com (Ringmaster) — Fri, 30 Sep 2016 11:59:00 +0000

In this post I will share with you the improvements I've made to our biomass/Solar mixed system , which is basically to change the obsolete control system for thermostats with a centralized system based on Arduino fully customizable, flexible and expandable; we will see the assembly, components and source code.

Applied materials:

1 - Arduino MEGA 2560 (specifically I used a Funduino clone ), because the TFT shield does not leave me enough inputs / outputs Free UNO R3.

2 - Touch Screen TFT 2.4 " McuFriend , which will give us great freedom when it comes to display information on screen libraries that have worked best for me. Are the BUHOSOFT ; here you can download the version I used.

3 - relays to activate solenoid valves, with a fed to 5V that can handle 230V and 10A worth us to spare.Not to stress regulator Arduino board, the food independently with other L7805 regulator (handles between 7-30V and 1.5A max). Being so low consumption, nor need a heatsink:

- A speaker-buzzer for alarm warning in case of problems, which operates between 7 and 12V 100dB, enough.

- A relay SSR DC-DC to activate the buzzer ; only consumes between 3 and 25mA so we can turn directly to the Arduino pin. I used one of solid state more than anything because I had left the other, butsince it is an element that is to be activated soon, you better go to a mechanical more economical and compact:

- Another solid state relay AC-DC to activate the motor . Of at least 10A, will be the element that suffer the continuous activations, so that the durability and reliability of solid state relay will ensure a long maintenance free I've added a heatsink for if heated , although I have exceeded its size as I then checked, but better to err;).

- 4 sensors NTC 6K8 (at 25 ohm resistance is 6K8) plus 4 resistors 6K8 necessary, obtained from some old batteries, which measures temperatures between -25 and 125 ° C, ideal for the temperatures to be managed:

Such sensors are easy to get and set taking temperatures and resistance at two points (as I explained in the previous post ), these can be obtained from lithium batteries and large NI-MH ; the carry to regulate its temperature within safe margins, glued thereto. We also have them in batches very economical. Be sure that is the type that you have referred to in the schedule; in my case NTC (Negative Temperature Coefficient..); indicating rising temp. by lowering its resistance.

I preferred to use such sensors for price and convenience more than anything , instead of the usual transistors DS18B20, very common as well.
Note that not suitable for very humid environments; water is conductive and would raise the temperature indicated incorrectly. To avoid possible problems with rain, water leakage, etc. can be isolated with "liquid silicone" a hotmelt or silicone standard l, as I have done.

Mounting elements and debugged the program

With a prototype card I connect the resistors and sensors, and I tested the data on screen and the feedback we debugged by series errors.

(For those who need it, when I can prepare the scheme with Fritzing to clarify the connections).

After a couple of days working properly, I connect the elements definitively:

For simplicity I have soldered directly 6K8 resistance of each sensor (analog pins 11 to 14) behind the plate:

In the following video I try running surface ; when we launched last settings:

Replacing the old system

The first is to identify each cable ; the previous configuration they were not, and I would have saved time; between sensors, power, and engine elecroválvulas are a few wires and there can be errors:

We take the same box, leaving the screen in the center window slightly enlarging the alarm at the top:

I distributed all over the box, which had ample depth for all elements:

In the next picture it can not be seen, but there is a USB cable plate hanging out for possible updates and final program debugging :

Replace the temperature sensors

Those who had placed could have served, but since thermostats are compatible with a limited range of sensors, I preferred to reserve them to remove them.

To replace the tank, insert the new one in its place ; the tank has a housing 6 mm. x 50 cm long where the sensor is inserted until the middle of the tank; the new sensor was introduced without difficulty, finer than the old one you see in the image:

Also change the sensor. I could verify that after 7 years of use, is maintained in good condition, hardly have whitened polycarbonate, and thanks to the high temperatures fends off any moss or plant that wants to develop:

I used to change the board of the trap, which was already badly corroded.

In the image below we have placed the sensor on top of the hot water outlet of the solar collector(more details on its construction inputs), with white tape and more flanges. After white silicone will place above to isolate it better from the outside and does not distort the temperatures in winter, keeping the temperature as close to the actual water pipe.

The program is as follows (available in github) :

/*
 * ARCHIVO: Control sistema térmico mixto biomasa-solar
 *   AUTOR: David Losada
 *   FECHA: 8/08/2016
 *     URL: http://miqueridopinwino.blogspot.com.es/2016/08/control-centralizado-del-sistema-mixto-biomasa-solar-con-Arduino.html
 *   Versión 1.65 (7/01/17)
 *   - Se ha corregido el código de desconexión en caso de biomasa encendida, para evitar apagar el motor demasiado pronto con brasas
 *   - Se añade aviso de excesiva diferencia entre sondas, indicando en rojo la temperatura y activando alarma
 *   - Mejorada la alarma; se hace intermitente.
 *   - Añadido un 5º termistor en el serpentin biomasa (parte baja) por seguridad; Biomasa2, a veces se calienta antes en la parte inferior
 *   - Corregida la contabilización de horas funcionamiento
 *   - Cambiado el orden en pantalla
 *   - Se indican los KWh ahorrados por energía renovable :) (aproximado)
 *   - Cambiada la forma en que se comprueban temperaturas, dando prioridad real a biomasa (o estamos jodidos)
 *   - Ahora se activa cada 15 días la válvula de enfriado para evitar su agarrotamiento
 *   - Corregidos varios errores
 *   - 10/12/16 Mejorados varios puntos; no contabilizaba horas de motor, y la comprobación de temperaturas no era óptima con depósito
 *   - 12/12/16 Mejorado el código: añadido código para dormir el procesador, reducir los refrescos a lo mínimo necesario y sensor de pellets futuro
 *   - 15/12/16 Corregida la evaluación del tiempo
 *   - 07/01/16 Corregido error en la condición de apagado del motor en caso de activación por el captador solar
 *
 * OBJETIVO: Prototipo control de sistema casero mixto biomasa-solar térmica
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 */

// Uses TFTLCD sketch that has been Refurbished by BUHOSOFT
// If using an Arduino Mega make sure to use its hardware SPI pins, OR make
// sure the SD library is configured for 'soft' SPI in the file Sd2Card.h.

// Original code provided by Smoke And Wires
// http://www.smokeandwires.co.nz
// This code has been taken from the Adafruit TFT Library and modified
//  by us for use with our TFT Shields / Modules
// For original code / licensing please refer to
// https://github.com/adafruit/TFTLCD-Library

// adapted sketch by niq_ro from http://arduinotehniq.blogspot.com/
// ver. 1m5 - 13.11.2014, Craiova - Romania

//Librerías para dormir al procesador y ahorrar energía cuando no hace nada
#include 
#include 
#include 

//Librerías para la pantalla gráfica
#include 
#include 
#include 
#include 
#include 
#include 

#if defined(__SAM3X8E__)
    #undef __FlashStringHelper::F(string_literal)
    #define F(string_literal) string_literal
#endif

// The control pins for the LCD can be assigned to any digital or
// analog pins...but we'll use the analog pins as this allows us to
// double up the pins with the touch screen (see the TFT paint example).
// #define LCD_CS A3 // Chip Select goes to Analog 3
// #define LCD_CD A2 // Command/Data goes to Analog 2
// #define LCD_WR A1 // LCD Write goes to Analog 1
// #define LCD_RD A0 // LCD Read goes to Analog 0

// #define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin

// When using the BREAKOUT BOARD only, use these 8 data lines to the LCD:
// For the Arduino Uno, Duemilanove, Diecimila, etc.:
//   D0 connects to digital pin 8  (Notice these are
//   D1 connects to digital pin 9   NOT in order!)
//   D2 connects to digital pin 2
//   D3 connects to digital pin 3
//   D4 connects to digital pin 4
//   D5 connects to digital pin 5
//   D6 connects to digital pin 6
//   D7 connects to digital pin 7
// For the Arduino Mega, use digital pins 22 through 29
// (on the 2-row header at the end of the board).

//#define DEBUG
#include 
#include  //Para usar la memoria EEPROM
//Arduino con Tiny RTC I2C http://zygzax.com
//#include 
//#include 
#include  //Manejo reloj interno Arduino

#define LCD_CS A3
#define LCD_CD A2
#define LCD_WR A1
#define LCD_RD A0
// optional
#define LCD_RESET A4


#define YP A1 // Y+ is on Analog1
#define XM A2 // X- is on Analog2
#define YM 7 // Y- is on Digital7
#define XP 6 // X+ is on Digital6

#define TS_MINX 150
#define TS_MINY 120
#define TS_MAXX 920
#define TS_MAXY 940

// For better pressure precision, we need to know the resistance
// between X+ and X- Use any multimeter to read it
// For the one we're using, its 326 ohms across the X plate
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 326);

// Assign human-readable names to some common 16-bit color values:
#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF
//#define ROZ     0xFD20
#define ROZ     0xFBE0
#define GRI     0xBDF7
// http://stackoverflow.com/questions/13720937/c-defined-16bit-high-color
// http://wiibrew.org/wiki/U16_colors

Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);;
// If using the shield, all control and data lines are fixed, and
// a simpler declaration can optionally be used:
//Adafruit_TFTLCD tft;



////***************** COMIENZO DE PARÁMETROS CONFIGURABLES ***********************
//Control temperatura
//Para ahorrar cálculos, lo vamos a calcular antes del programa
//const float TPto1 = -6; //Temperatura en ºC punto 1 (A descomentar las siguientes cuatro líneas  si desconocemos el varor de B para el termistor utilizado)
//const float RPto1 = 40000; // Ohms en punto 1
//const float TPto2 = 96; // Temp. punto 2
//const float RPto2 = 970; // Ohms en punto 2
const long B = 3850; //Valor Beta del Datasheet; comentar esta línea si se meten los datos de los dos puntos
const int resistor = 6800; //El valor en ohmnios de la resistencia del termistor a 25ºC
const float voltage = 5.01; // El voltaje real en el punto 5Vcc de tu placa Arduino

//Deltas de temperatura
const byte DtFsolar = 6; //Delta temp ºC conexión de motor circuito panel solar
const byte Dtosolar = 1; //Delta temp. desconexión motor

const byte DtFbiomasa = 12; //Delta temp ºC conexión de motor y válvula circuito biomasa
const byte Dtobiomasa = 2; //Delta temp ºC desconexión de motor y válvula circuito biomasa

const byte DtFEnfriar = 65; //Temp. ºC conexión electroválvula circuito desvío exceso temp a calefacción
const byte DtoEnfriar = 60; //Temp. desconexión electroválvula desvío agua caliente a calefacción

const int frecseg = 1; //Tiempo en segundos X2 entre cada ejecución del programa (recomendado poner entre 1 y 3 para mantener la velocidad de respuesta)
const byte difTemp = 25; //Diferencia de temperatura máxima entre sondas considerada normal, a partir de la cual salta la alarma
const double ltsdeposito = 250; //para el cálculo de Kwh ahorrados; indicar aquí la capacidad del depósito de inercia

//Definición pines digitales para activar relés
#define ledPIN 13 //Led placa arduino
#define motorPIN 25 //Pin digital activar relé motor
#define valvbioPIN 27 //Pin digital activar relé electroválvula circuito biomasa
#define valvenfriaPIN 29 //Pin digital activar relé electroválvula circuito calefacción radiante
#define zumbadorPIN 31 //Conexión al Mosfet del zumbador electrónico de aviso
//En mi caso lo sensores están puestos en este orden desde el 11: Captador,Deposito,Biomasa1,Retorno,Biomasa2
#define primerSensor 11 //Pines analógicos para termistores; van correlativos desde este
#define numeroSensores 5 //Cantidad de sensores

float calibTemps[numeroSensores] = {0,0,0,0,0}; //Matriz de ajustes calibración sensores en ºC; se sumará a la temp. obtenida

int horasValvEnfria=120; //Cada este número de horas/3 se activará una vez la válvula de enfriado para evitar que se quede agarrotada

//***************** FIN DE PARÁMETROS CONFIGURABLES ***********************

//Variables 
double Msensores[numeroSensores] = {0,0,0,0,0}; //Matriz temperaturas obtenidas de sensores en orden de PIN
double Mtempsens[numeroSensores] = {0,0,0,0,0}; //Matriz temperaturas ordenadas a nuestro gusto
double MtempAnt[numeroSensores] = {0,0,0,0,0}; //Matriz temperaturas anteriores para borrado pantalla
const char* Mnombres[]={"Captador:","Biomasa1:","Biomasa2:","Retorno: ","Deposito:"}; //Matriz de arrays (*=pointers) de los nombres de los sensores
String TextoAnt;

#define captador 0 //Definimos la posición en la matriz de cada texto 
#define biomasa1 1
#define biomasa2 2
#define retorno  3
#define deposito 4
#define pellets  5

boolean motorON=false; //Para comprobar si está en marcha
boolean valvula=false; //control electroválvula 3 vías biomasa
//datos estadísticos y otras
long Mdatos[6] = {0,0,0,0,0,0}; //Matriz estadístias uso
//Matriz de arrays (*=pointers) de los nombres de los datos; No deberían tener más de 13 caracteres cada una (sumar 
const char* MnomDatos[]={"Hrs motor ON","Hrs Arduino","CTR RELE Motor","CTR VALVULA Fuego","CTR VALVULA Enfriar","KWh RENOVABLES"}; 
#define hrsMotorOn 0 //Para hacer referencia en código directamente
#define hrsArduino 1
#define ctrReleMotor 2
#define ctrValvulaFuego 3
#define ctrValvulaEnfriar 4
#define ctrKWh 5
double tempPrevia=0; //Temperatura cuando se activa el motor para el cálculo de Kwh ahorrados
double kwhAhorro=0; //Para cálculos
const double kwhGrado =  250 * (double(23)/double(859)); //Hacemos el cálculo de los kwh que suponen cada ºC que subimos la temp.; 1kWh son 859 kcal; 1 lt cuesta 23 Kcal

int activarValvEnfria=0; //Contador para activar la válvula de enfriado cada "horasValvEnfria" horas.

//Para ahorrar cálculos lo definimos como constante en esta parte del programa
const float K= 273.15; //Para pasar a grados Kelvin
const float e = 2.718281828459045; //Constante matemática 
//const float B = log(RPto2/RPto1)/(1/(TPto2+K)-(1/(TPto1+K))); //Valor Beta de tu termistor calculado de dos puntos
const float unodivr = 1/(resistor * pow(e,(-B/298.15))); //Con pow elevamos e al resultado

double T = 0; //Declaramos la variable Temperatura
int grados, decimas; //Para ponerle coma al resultado (en español)

float segundos=0; //Guardamos segundos funcionamiento (en sleepmode millis se para)
unsigned long millisAnterior=0; //Guardamos millis anterior
unsigned long segundosArduino=0; //Guardar horas funiconamiento Arduino
unsigned long segundosRefresca=0; //para refrescar pantalla
unsigned long segundosInicioMotor=0; //Guardar tiempo activado motor
unsigned long restoSegundosMotor=0; //Guardamos resto tiempo activación motor
unsigned long timeLED=0; //Tiempo funcionamiento LED placa
unsigned long segundosValvula=0; //Guardar momento activación válvula para desactivar después de 15 min.
byte error=0; //En caso de error será <> 0

int direccionInicial; //Dirección memoria EEPROM a partir de la cual se guardan los datos, asignado por la librería EEPROMex

void setup() {
  Serial.begin(9600);

//Descomentar las lÃneas siguientes para sincronizar tiempo por el Serial
//  if(Serial.available()) 
//  {
//     time_t t = processSyncMessage();
//     if(t >0)
//     {
//        RTC.set(t);   // set the RTC and the system time to the received value
//        setTime(t);          
//     }
//  }
//   digitalClockDisplay();  
//   delay(1000);
//}

  //sync internal time to the RTC
//  setSyncProvider(RTC.get);   // the function to get the time from the RTC
//  Serial.println();
//  if(timeStatus()!= timeSet) 
//     Serial.println("Unable to sync with the RTC");
//  else
//     Serial.println("RTC has set the system time");
//Wire.begin();
//RTC.begin();
//Si quitamos el comentario de la linea siguiente, se ajusta la hora y la fecha con la del ordenador
//RTC.adjust(DateTime(__DATE__, __TIME__));
  Serial.println("Arduino Working OK");

//Líneas de configuración del WatchDog Timer
/*** Setup the WDT ***/
  
  /* Clear the reset flag. */
  MCUSR &= ~(1<90) {
      error++; //Si se acumula algún error, haremos saltar la alarma en forma de zumbido
     }
 }  

//Guardamos valores anteriores
for(int i=0; i= DtFbiomasa or (Mtempsens[biomasa2]-Mtempsens[retorno])>= DtFbiomasa or (Mtempsens[biomasa1]-Mtempsens[deposito])>= DtFbiomasa) {
    valvula=true;
    motorON=true;
  }
else { //Si lo anterior no se cumple, comprobar si ya no está caliente y si temperatura captador también está frío, apagar
  if ((Mtempsens[biomasa1]-Mtempsens[retorno])<= Dtobiomasa and (Mtempsens[biomasa2]-Mtempsens[retorno])<= Dtobiomasa) {
    motorON=false;
  }
  //Si se activó por el captador, pero ya está frío, apagar motor
  if ((Mtempsens[captador]-Mtempsens[retorno])< Dtosolar and valvula==false) {
    motorON=false;
  }
  //Si captador solar está caliente activamos motor
  if ((Mtempsens[captador]-Mtempsens[deposito])>= DtFsolar) { //Si diferencia temp. captador y depósito mayor que el delta, activar motor
    motorON=true;
    }
 }

//Serial.print("Temp deposito: ");
//Serial.println(Mtempsens[deposito]);
//Serial.print("Temp previa: ");
//Serial.println(tempPrevia);

//Dependiendo del resultado de las anteriores comprobaciones, actuamos sobre el motor y electroválvula
if (motorON==true) {
    if (digitalRead(motorPIN)==LOW) { //Se activa relé; contamos el número de activaciones
    Mdatos[ctrReleMotor]++;
    tempPrevia=Mtempsens[deposito]; //Guardamos temperatura actual deposito
    segundosInicioMotor=segundos; //Y activamos el contador de tiempo uso motor
  }
  digitalWrite(motorPIN,HIGH);
  }
else  {
    //Cada vez que paramos el motor, comprobamos diferencia temp. depósito y añadimos kwh ahorrados
    if (Mtempsens[deposito]>tempPrevia and digitalRead(motorPIN)==HIGH) {
      Serial.print("Valor kwh");
      Serial.println(kwhGrado);
      kwhAhorro=(Mtempsens[deposito]-tempPrevia)*kwhGrado;
      Serial.print("Ahorro");
      Serial.println(kwhAhorro);
      Mdatos[ctrKWh]=Mdatos[ctrKWh]+int(kwhAhorro); //Guardamos el dato
      segundosValvula=segundos; //Iniciamos cuenta atrás
    }
    digitalWrite(motorPIN,LOW);
  }

if (motorON==false and (segundos-segundosValvula)>=600) { //Si el motor sigue apagado 10 minutos, apagamos válvula tres vías.
      valvula=false;  //Para evitar accionamientos innecesarios en las bajadas de temp por recargas de leña
}

if (valvula==true) {
    if (digitalRead(valvbioPIN)==LOW) { //Se activa relé; contamos el número de activaciones
      Mdatos[ctrValvulaFuego]++;
        }
    digitalWrite(valvbioPIN, HIGH);
}
else  {
    digitalWrite(valvbioPIN,LOW);
  }

//Si la temperatura del depósito es excesiva, o éste no absorve suficiente calor del serpentín, activar el relé de enfriamiento (desvío a calefacción)
if (((Mtempsens[deposito]> DtFEnfriar) and motorON==true) or (motorON==true and Mtempsens[biomasa1]>80)) {
    if (digitalRead(valvenfriaPIN)==LOW) { //Se activa relé; contamos el número de activaciones
    MnomDatos[ctrValvulaEnfriar]++;
  }
  Serial.println("Activar válvula desvío circuito enfriado");
  digitalWrite(valvenfriaPIN,HIGH);
}
else { //Desactivar la válvula enfriado si la temp depósito ha bajado suficiente o el motor se ha parado (ya no hay más aporte de calor)
    if ((Mtempsens[biomasa1]<70 a="" actualizamos="" ada="" and="" deposito="" digitalwrite="" dtoenfriar="" en="" estad="" hora="" if="" la="" lcd="" lo="" los="" mandamos="" motoron="=false" mtempsens="" or="" ostramos="" pantalla="" por="" primeros="" segundos-segundosrefresca="" segundos="" serial.println="" sticas="" texto="" ultimo="" valvenfriapin="" y="">=3600 or millis()<10000 abs="" actualizamos="" ada="" ahorro="" anal="" anterior="" atos="" c="" cimas="" co2:="" co2="" ctrkwh="" cuenta="" d="" datos="" de="" decimas="" else="" en="" estad="" evitado="" for="" gicos="" grado="" grados="" i="" if="" int="" kg="" kwh="" lento="" lo="" muy="" ndicamos="" nombres="" nomdatos="" numerosensores="" orramos="" pocos="" rados="" s="" scribimos="" seg.="" segundosrefresca="segundos;" sticas="" tempsens="" tenerlo="" termistores="" tft.fillscreen="" tft.print="" tft.println="" tft.setcursor="" tft.settextcolor="" tft.settextsize="" y="">-270) {
      if ((i==captador) || (i==biomasa1) || (i==biomasa2)) { //Si sonda captador o biomasa tienen mucha diferencia con respecto de depósito y retorno
        if ((Mtempsens[i]-Mtempsens[i+1])>difTemp) {
          tft.setTextColor(RED); //Ponemos la temperatura en rojo
          error++; //Activamos alarma
        }
      }
      grados=int(Mtempsens[i]);
      if (grados<10 _______________________________="" _______________________________________="" a="" abs="" acaba="" activada="" activado="" ahorro="" al="" and="" apagarse="" aviso="" biomasa="" cimas="" contador="" d="" de="" decimas="" del="" digitalread="" el="" else="" encendido="" enfria="" enfriado="" erial.print="" erial.println="" error="" es="" est="" estado="" extoant="" grado="" grados="" guardamos="" ha="" horas="" if="" illis:="" illismotor:="" incorrecta="" kwh="" la="" lectrov="" lo="" lvula="" millisiniciomotor="" motor="" motoron="=false" ndicamos="" nuevo="" off="" on="" onemos="" rados="" renovables="" reseteamos="" segundos="" segundosiniciomotor="" si="" stuvo="" sumamos="" temp="" textoant="String(TextoAnt" tft.print="" tft.println="" tft.setcursor="" tft.settextcolor="" tft.settextsize="" tiempo="" tiempos="" v="" valvbiopin="" valvenfriapin="" y="">0) { 
    Mdatos[hrsMotorOn]= Mdatos[hrsMotorOn] + ((segundos+restoSegundosMotor-segundosInicioMotor)/3600);
    restoSegundosMotor=(segundos+restoSegundosMotor-segundosInicioMotor)-(int((segundos+restoSegundosMotor-segundosInicioMotor)/3600)*3600);
    segundosInicioMotor=0;
}
//DEBUG ***********
//Serial.print("HrsMotorOn: ");
//Serial.println(Mdatos[hrsMotorOn]);
//Serial.print("restoHrsMotor: ");
//Serial.println(restoSegundosMotor);

//*** Cada 3 horas salvamos a la EEPROM los datos que han cambiado (no hacerlo mas frecuente para prevenir el envejecimiento prematuro de la FLASH)
if ((segundos-segundosArduino)>=(3600*3)) { //Si ha pasado tres horas
      Serial.println("Guardamos horas Arduino y resto de datos en EEPROM");
      Mdatos[hrsArduino]=Mdatos[hrsArduino]+3; //hrs Arduino
      segundosArduino=segundos; //Actualizamos
      //Comprobamos si el contador de activado de válvula de desvío enfriamiento ha llegado a cero para activarla 5 segundos
      //Evitamos posibles agarrotamientos por falta de uso.
      activarValvEnfria++;
      if (activarValvEnfria>=horasValvEnfria) {
        activarValvEnfria=0;
        digitalWrite(valvenfriaPIN,HIGH);
        delay(5000);
        digitalWrite(valvenfriaPIN,LOW);
      }
     //Salvamos los datos cambiados
     for(int i=0; i<6 acemos="" activaci="" al="" comprobando="" datos="" desde="" direccioninicial="" eeprom.writelong="" el="" hacemos="" i="" if="" la="" led="" ltima="" n="" parpadear="" segundos-timeled="" serial.println="" tiempo="">2) {
      digitalWrite(ledPIN,HIGH); //enciende LED indicando funcioanmiento
      timeLED=segundos;
  }
  else {
     digitalWrite(ledPIN,LOW); //apaga led
     }

if (error>0) { //Si hay algún problema, hacemos sonar la alarma intermitentemente
  for(int i=0; i=segundos) { //Tenemos en cuenta si se ha desbordado segundos
   segundosInicioMotor=segundos; 
   segundosArduino=segundos;
   segundosValvula=segundos;
   segundosRefresca=0;
   millisAnterior=millis();
    } 


//código para depuración
//    Serial.print(F("Valor kwh"));
//    Serial.println(kwhGrado);
//    kwhAhorro=(Mtempsens[deposito]-Mtempsens[retorno])*kwhGrado; //para depurar
//    Serial.print(F("Ahorro"));
//    Serial.println(kwhAhorro);

//THE END
}


//RUTINAS
//Code from http://donalmorrissey.blogspot.com.es/2010/04/sleeping-arduino-part-5-wake-up-via.html
/***************************************************
 *  Name:        ISR(WDT_vect)
 *
 *  Returns:     Nothing.
 *
 *  Parameters:  None.
 *
 *  Description: Watchdog Interrupt Service. This
 *               is executed when watchdog timed out.
 *
 ***************************************************/
ISR(WDT_vect)
{
 //Aquí el código que queremos se ejecute cuando el watchdog "despierta" al procesador

}



/***************************************************
 *  Name:        enterSleep
 *
 *  Returns:     Nothing.
 *
 *  Parameters:  None.
 *
 *  Description: Enters the arduino into sleep mode.
 *
 ***************************************************/
void enterSleep(void)
{
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);   /* EDIT: could also use SLEEP_MODE_PWR_SAVE for less power consumption. */
  sleep_enable();
  
  /* Now enter sleep mode. */
  sleep_mode();
  
  /* The program will continue from here after the WDT timeout*/
  sleep_disable(); /* First thing to do is disable sleep. */
  
  /* Re-enable the peripherals. */
  power_all_enable();
}

Isolating better tank

And finally, I improved isolation tank 150 lts with an old blanket and remains of an insulating sheet with aluminum layer (here recycles all) to protect it from the sun 's UV. This is essential if the deposit is in outside , it means lower losses, which in winter can be very high. to "hold" blankets have used pieces of old bike tire pressure tucked against the wall; to be elastic, it remains in place.

At the bottom I have also placed, but leaving easy access for maintenance of the deposit.

And finally I have secured with duct tape:

Maintenance of the expansion vessel

Every three years there to check the expansion vessel as it loses any tire pressure and stops properly perform its function of maintaining the pressure to 1.5 bar.

Below is a valve and vacuum we must fill air at a pressure of between 0.5 and 1 bar (takes more pressure to get water, so we must find a way that half full of water has 1.5 bar ). I spent a bit and did not come to get water, so it Regulate connected and letting out some pressure until it reached 10 kg approx (is 24 liters) and maintained between 1.5 and 2 bars .

The glass of my installation whole bottom was oxidized to splashed rain over the years, so I sanded with brushes sheets and drill and you've applied paint "forging" anti-oxide(carrying metal particles that severely limit the passage moisture), her anti - rust no need fora previous hand, it is very durable .

More info: Practical Guide to installing a solar thermal system Technical Manual installation Solar thermal energy

Save energy with a timed plug: Do it yourself with Arduino

noreply@blogger.com (Ringmaster) — Mon, 22 Aug 2016 20:11:00 +0000

I used this to build a wireless plug socket countdown

I had a Wireless programmable plug Contros of Broadlink with the wifi card damaged:

and I realized that I could come in handy a plug to be activated for a certain time simply by pressing the button, with increments of the same time with each pulse (similar to working electronic microwave, that with each press of the button quick heated adds 30 seconds to the time). A picture is worth a thousand words (explained in spanish, sorry):

We could use this plug in many cases; I for example have a Philips coffee with fairly inaccessible button to be switched on and off whenever used so it is not always consuming to keep warm. In this case , we are activating the morning with a simple push of the button and we would have prepared for an hour. Another example is the plugs mata-mosquitos (liquid or pills) often forget fired, polluting the environment with poison without because if you look, all die half an hour and two hours, and it is no longer necessary unless we leave an open window. In this case we avoid poison in our body that ultimately may affect our nervous system (or may not, and the maximum exposure for which these devices are regulated are healthy, but healthy is to avoid it ), in addition to saving in the consumable.

A plug so (I do not know if they will be available for sale) is very simple to build with Arduino, and is more useful than one connection in some cases. The problem is that if we do it as compact as possible, we use a plate as small as possible ( more than the Nano ) . And in this case more than contros recycled box is not wide precisely:

In these compact and simple necessities it is where comes into play Attiny Digispark plates,small but powerful .

Until I have not noticed that the number of analog input pin does not correspond to the plate (for digital yes), I have gone mad wondering what is failing, because it proved an Arduino Uno and working properly but not to put the same code in the ATtiny85. the sooner you you you read and memoricéis differences , before you can take advantage of their qualities in a plate just 20x20mm:

The Digispark works with an Atmel ATtiny85 MCU - has some differences from the ATmega328 and some libraries do not work properly, but will improve over time.
The Digispark only 6 KB of memory available for our code (8 KB if we remove the virtual USB bootloader and we programmed directly with an Arduino UNO ).
Pin 3 and Pin 4 (P3 and P4) are used for communications and USB programming ;if only it interferes if we use the USB connection and can be used while not use the USB connection on the final design, but keep in mind that if the program acts dramatically on the voltage thereof, will be best to disconnect once we uploaded the program by USB.
Pin 3 (P3) is connected to a pull-up resistor 1.5 KQ required when P3 and P4 are used for USB communication (programming included). Your design will have to take thatinto account and you'd have to supercharge the pin to put it in LOW.
The Digispark does not have a serial port hardware or a converter to USB. A library of example (DigiUSB) as well as some sample code and a monitor program series, but communication with the computer will not always plug and play, especially when there are other libraries in use is provided.
On power does nothing until 4 seconds later , as it is the waiting time that is scheduled for programming USB (this I think can be eliminated by programming directly , but I have not tried), so must be taken into account if we need quick start the program.
While digital connections correspond to the pins (digitalRead (0) where 0 = Pin0), the correspondence of the analog pins change :

analogRead (1); // Read P2
analogRead (2); // Read P4
analogRead (3); // Read P3
analogRead (0); // Read P5

To program the Digispark

We need to install version 1.6.6 or above and follow the instructions of your page . It took me make it work on Windows 10, but do not despair because either restarting or reinstalling drivers and rebooting, is arranged. The procedure is different from the Arduino programming ; the Digispark not have to have it connected, but first we give to dump program from the IDE, and we indicated that we connect (when connected by USB is 4 seconds waiting for a connection for programming), Windows notifies you of the connection and disconnection USB and finally the IDE will warn us in the status window that has been programmed correctly.

We will need the following material

A programmer or plug apparatus Bypass to activate or deactivate the connected;I used a Broadlink contros spoiled.
A transformer 85 / 240V AC to 5V DC at least 300mA to feed the Digispark and relay.
A Digispark (or Arduino Nano if you have space).
A relay of at least 10A and activate it with digital 5V (powered).
Soldering iron, tin, scissors, tape, thin wires; the usual.

I tried using a source of 9V with a voltage regulator L7805 but too heated and had no place to put sink; better to play an optimal source regulated 5V and efficient.

On the other hand I tried to take advantage of the relay that had the contros 16V, but overload the Arduino pin to activate it , due to its high consumption (had no separate power pins); you will see some photos of the preliminary designs with any of these changes, but always talk about the final design.

To take advantage contros must find out how the circuit of blue and white button and LED functions.

I am only interested regulate the intensity of the blue LED and LOW put on one of the digital pins with the switch; at the end I cut the track that linked the LED and the switch to + 5V as to put a pin LOW have to connect to GND (ground, earth). The good practice in a device that will be connected a long time is to define the input pins with pull-up resistor ( pinMode (botonPIN, INPUT); digitalWrite (botonPIN, HIGH);) to avoid possible short circuits caused by error or fluctuations . for indefinite status pin that can give us problems This would be the scheme Fritzing ; the relay is not well indicated as I have not found one like it , but I think it means:

You can download it here , and here the Digispark to include in your own projects

Connect everything according to the scheme (the regulator in the picture below is only necessary if the source is more than 5V DC):

I welded and reinforced tracks the connection to the relay , welding it directly instead of using the screws included; this is the pole that connects or disconnects to close the circuit with the device we connect. The other pole is connected directly and have only taken the power transformer:

Put everything in place is complicated , which have 3D printer fabricaros able to measure a box; we need to ensure isolate all right for there is no short. In the following images, the previous version where the relay contros advantage:

I later switched by a relay fed to avoid problems of wear Atmel chip:

The code for the plug would be as follows:

 /* ==================================================================  
   
  Sketch control relé temporizado por horas; cada vez que se pulsa el botón añade una tiempo predefinido de funcionamiento.  
    
  Autor: David Losada.  
  Version: 0.1  
  Fecha: 13 de julio de 2016  
   
   
   ==================================================================  */  
   
 //#include  //He utilizado primero un MEGA 2560 con pantalla LCD Keypad Shield para probar el código antes de pasarlo  
   
 // select the pins used on the LCD panel  
 //LiquidCrystal lcd(8, 9, 4, 5, 6, 7);+  
   
 //Definición pines digitales para activar relés  
   
 //PINES USADOS; no uso el 3 ni el 5 porque ambos me daban problemas mientras tenía el USB conectado  
 long timeBoton=3600; //Tiempo en segundos que añade por cada pulsación al temporizador  
 int botonPIN=0; //3 Pin de botón configuración  
 int relePIN=2; //4 Pin activación relé  
 int luzPIN=4; //Pin de luz indicadora  
 int ledPIN=1; //Led del aTTiny85 ver. B está en 1  
   
 //Variables programa  
 long timeLED=0; //Para encender el LED cada segundo  
 long tiempoRele=0; //Tiempo total al que configuramos para activarlo  
 long tPrevRele=0; //Momento en que ha empezado a funcionar el rele  
 boolean boton=false; //Botón ha sido pulsado  
 boolean luzON=false; //Si la luz azul está encendida  
   
 void setup()  {   
    
  //Definir pines  
 pinMode(botonPIN, INPUT);  
 pinMode(relePIN, OUTPUT);  
 pinMode(luzPIN,OUTPUT);  
 pinMode(ledPIN,OUTPUT);  
 digitalWrite(botonPIN,HIGH); //Evitamos fluctuaciones activando con LOW  
   
 //lcd.begin(16,2); //pantalla de 16 caracteres y 2 filas  
 }  
   
 void loop()   
 {  
   
 //Comprobamos si se pulsa el botón  
  if (digitalRead(botonPIN)==LOW && boton==false) {  
   boton=true;  
   luzON=false; //apagamos momentáneamente la luz como indicador de pulsación  
  }  
   
 //Si el botón se suelta añadimos hora al tiempo  
  if (digitalRead(botonPIN)==HIGH && boton==true) {  
   boton=false;  
   tiempoRele=tiempoRele+(timeBoton * 1000);  
   luzON=true;  
    }  
      
 //Se acaba de activar el tiempo; marcamos inicio  
 if (tPrevRele==0 && tiempoRele>0) {  
  tPrevRele=millis();  
 }  
   
 //Cuando pasan 50 días millis se resetea  
 if (tPrevRele>millis()) {  
  tPrevRele=0;  
 }  
   
 //Mientras no haya pasado el tiempo establecido, activar Relé  
 if (tiempoRele>0 && (millis()-tPrevRele)millis()) { //Cuando pasen 50 dias resetear  
   timeLED=millis();  
  }  
  if ((millis()-timeLED)>1000) {  
    analogWrite(ledPIN,100); //enciende LED indicando funcioanmiento  
    timeLED=millis();  
  }  
   if ((millis()-timeLED)>500) {  
    analogWrite(ledPIN,0); //apaga led  
   }  
  delay(100); //Más de este tiempo no es recomendable o el botón no responderá bien  
 }

This is just one example of the world of possibilities opened up by these economic and small plates Digispark programmable. Happy projects!

Modifying an insertable wood stove to add double combustion and fans

noreply@blogger.com (Ringmaster) — Sat, 20 Aug 2016 20:06:00 +0000

In this post, which had long been "waiting" for various reasons (my apologies to Alberto, intone the mea-culpa), an animated friend of sustainability we discuss how modified 2014 a stove without too much effort to optimize its performance , having fun how nice in the process.

Alberto tells us who dared to take pictures of it and write it done because it came in handy examples and information I put in this blog.

Adding steel tubes for double combustion and fans increase the combustion efficiency to deliver oxygen where it is needed, and also preheated, and fans are needed to optimize the extraction of heat to the room and extend the life of the stove by reducing the temperature of the structure , which otherwise would be very stressed by extreme temperature changes to increase performance. These modifications are safe (with the only danger plaster smoke, controllable and which will be discussed in detail).

So, without further ado, let him be himself who tell us (apologies for the quality of the photos):

Presentation and project

The first is to introduce Alberto and I am not a professional in this sector, but I like the tools and I dare all.

I needed an insertable for the house in Ávila, at 1360m above the sea, as the chimmenie fire never could heat the cold granite house. And of course I wanted to double and double combustion chamber.

I do not remember very well the extent of the gap in his fireplace; would be about 530mm, about, quite recently, I found an insertable fire made of that size. The sides of the fireplace are also granite but the problem is securing a roof beam in the middle of the house and did not make me any grace the walls shake too.

So I Have This Test was willing to custom. I was asking for tempered glass in the door to start ... phew... 'find materials that work !!.

By chance I found a home at a low price approaching the measures, and for 250 euros I found very interesting in Leroy Merlin especially since half the work had already been done.

I fixed that has markings and grooves on the overlap in the area that would stick to the wall on the inside, suggesting that it could be mounted with double chamber plate, ask for some advanced model with the camera and fans, but not I know answer ... In the end I'll take it.

Modifying the stove

I step by Rivera Street Tanners 16, stoves Martinez, and I buy fans (special aluminum high temperature), silicone cable, switches, temperature switch, plate heat insulator and good advice they gave me (highly recommended people if you want to undertake a similar project) ... 100 euros everything.

In addition, I buy the plates sheets and tubes that I need ... another 60 euros.

I'll take the people ... as it weighs jod ** I have to remove the door and all parts to manipulate home alone.

I start chopping the wall a few centimeters on each side, I use for hard granite hilti a ejectors nailers . They are great for starting small pieces of stone:

As the air outlet holes of dual chamber are marked on the overlap, I open based drill and lime.

I take this opportunity to give a shot to the flue-plated 1.5mm

Home "upside down", will I present the fans with aluminum blades and I will be measuring the metal structure as the hostel with the plate with the controls and electrical system:

White cardboard insulation is I got in Martinez, isolating the fan from direct contact with the melt.(Red arrows), also pay sheets to channel air and only pass by fans (blue arrow).

In the plate hole to place the switches. Finally I put some thick I had lying around. I put 3 to make an invention that then did not do for lack of time, but 2 work, each for a fan. I make the plate removable to repair or remove in the future fans:

Here is the bracket with fans installed with the electrical system and in the absence of superior insulation and thermal switch that is connected to the loose threads that are at the bottom:

Once amount all, I give special putty stoves enduring high temperatures in all the cracks to avoid losing forced by anywhere shot .

I start to weld the camera, with 1 mm plate in the photo is Mount Union fans with home, and the same substance. At the top a large plate for air vent, which will subsequently sealed with caulking hole:

Although I did before, I put it now to bring order; this drill 20mm diameter, passes through the molten soil of home, and gets into the double chamber air circulation fans, for them I will draw tubes with grid to the main chamber, which will double combustion entering part of fan air tubes in the grid:

And this is the grid. This is a hollow tube rack with 20 sides and 14 on the cross, with little holes 2.5 mm (I'm not sure or maybe 3mm) which is where the hot air will come out.

I anchor the grid in the 20mm hole made in the bottom of the home, using a shoe and screw m8, (you have to give the molten thread).

The following photos correspond to the fireplace lined with galvanized sheet metal and an insulator paste as those put behind radiators, which proved to be very useful because it took off and scorched the first power; that if .... It was lovely in the photos. (Note to David: I suggest placing high temperature insulation in place, as inconel textile enduring 1000C).

After screwing granite galvanized and seal the holes with putty sheets.

Chapon 3mm Nivelo one that will support the weight of the insert, and also leave room for cold air to pass underneath. Already it has done the hole where the power cord passes.

Then pay a shield platen that will received with cement to the wall with a pin, which is where the overlap of home support. On the top of the shield I put a metal grid inside so that the flue pipe is not seen. It will be attached with magnets

Finally I make the fireplace. It is a big problem that arises me, as the shot is not straight, but back in oblique, and also not for the hole in the base of the chimney with the hole is in the air vent, is much smaller. I have very little height space between home and vent. It forces me to entroncar, or twist the exit and as I am not very good boilermaker, and I also have no tools to do so, it strikes me make it through a square box, which was first thought to cross tubes 20mm with a fan behind and output hot on the grid ahead shield air (hence 3 switch controls), or what is the same a heat exchanger in the flue, but due to time constraints I leave it for another time. I only chimney-shaped drawer. The second picture is the position that is at home, with the top up, crossing the galvanized sheet and being free in the original hole of the chimney.

Total 410 euros materials, without light, electrodes, gas to get back and forth .... Later in another Leroy Merlin found the same home and become insertable with its fans etc ... that if, without double combustion and a very good price 550 euros .... It made me wonder if it was worth me so much grief work, I have concluded that if it was worth the hours of enjoyment doing things myself and almost self - taught , with the help that if the previously published materials in blogs and forums. Sure I will have made mistakes, but next time I'll do better.

Stove operation

In the winter of 2015, after several months of use, home works great , fuelwood consumption was once continuous, every so often had to put a couple of logs to keep the fire burning, but the room was never hot. It is a little isolated stone house in Avila (harsh winters area) as I said before, with the gabled roof, with fairly high ceilings, the living room and fireplace in the middle of it; The fireplace was not even able to heat the room.

With this new system consumption has considerably decreased, a single hard trunk several hours (keeping the shot reduced air), making the very comfortable lounge (too much for my taste, that if my delighted woman) even I open the doors of the other rooms to warm them.

The double combustion household works well , looks like enters the air above and burned by the smoke, as if gas is involved, but I have to try enlarge the holes, at least the center of the grill, because I It gives the feeling that not enough hot air enters and leaves still some smoke up the chimney.

A mistake I made was to put the temperature switch in a somewhat elevated and has already ruined my position, it is locked with the closed contact so that when I connect the switches are set to immediately turn the fans without waiting for is hot molten. I'll have to unmount it to peel it off or replace it.

As for safety, something that I am also pending is the ability to revoke or change of direction in the flow of smoke into the grid double combustion, entering it into the room. In Martinez they explained to me that good and expensive insertable have a check valve to prevent this, although not usually very common operation and insertable thermodynamics itself.

Note David : Alberto checked this possibility closing shot and in this case the fire was extinguished without plaster, I guess that's the difference of temperature and pressure, so the moment is safe, but it is recommended that there is a minimum opening calculated in the chimney flue so that in case of failure of the shot, the smoke continues to have the tendency to go until the wood runs out .

I hope these lines you like and give you ideas for your project.

Legend: GREY: The profile of the original stone.

BLACK: Original Home.

BROWN: The plate surrounding the home or double chamber.

BLUE: The double combustion grid.

MORADO: Fireplace with heat exchanger.

GREEN: Top fan heat exchanger and forced draft fans down.

Greetings and thanks to Alberto, Great job, congratulations on the success and thank you for sharing your ideas and impact on the Community! Surely more than one would fail.

Repairing a Chinese Li-ion battery charger 42V "Rait" brand

noreply@blogger.com (Ringmaster) — Thu, 18 Aug 2016 20:02:00 +0000

The circuit: in one UF1004 dissipating diode and a MOSFET 600V N MDP11N60 (left)

A collegue had broken his battery charger, he told me that he had left running, hitting an explosion when going to charge his battery 20Ah scooter for the last time .

Normally when a small explosion sounds, it is that any electronic component has gone to hell, so I checked the components and at first sight there was nothing broken, not even the MOSFET had been damaged.

It is quite simple transformer of 180 / 240VAC to 42 Vdc with 5A load capacity (although the actual output voltage 40,7V are even better for the longevity of the battery), of unknown Chinese brand that came with the battery of 20Ah Chinese acquired.

In reviewing the tracks below, we see what happened: the track that connects with the departure had not stood the peak intensity of the moment to connect to charge the battery (capacitors can deliver a significant current at the time of connection); It is that by design has 3 tracks (possibly to put resistors as a fuse in the Tinned areas) but only one was connected.

So we solve these welding points (green resistance I put a few ohms, as if he put it ) and tin reinforcing tracks :

However the test operation the fan was not working (active fan when consumption in the output); probably at the time of the peak of the energy it was derived the poor fan, burning his HAL chip or coil. We changed for another, and is already working.

To the left. burning fan

Maybe they left it like that on purpose as a fuse, but did not realize that is too thin for minimum 200W (peak of over 300 in the likely connection) that will circulate around electricity (5A * 42V) surely to save removed the "fuse" resistance without recalculating the capacity of that track, forgetting reinforce it with tin.

Hopefully now will last many years, because otherwise it is well chilled with 80mm fan and heat sinks (which is what really makes the difference in the duration of electronics, that and that is well dimensioned).

In the circuit shown that many welds are performed by hand:

And this is the case, where its characteristics are as follows:

"Rait Battery Technology"

Remember what we indicated on the right of the blog: Do not try to do this at home without proper knowledge and precautions; I am not responsible for the consequences of using the info of this entry.

Replacing the battery ARRAY Ni-MH battery with a Li-Ion one

noreply@blogger.com (Ringmaster) — Wed, 17 Aug 2016 17:21:00 +0000

In this post we will see another example of updating a NI-MH battery for Li-ion another , much more durable and with no memory effect, in addition to saving bucks in the long run on batteries. These modified batteries are two years running without any problem, and that they were batteries in its final cycle of use, recycled.

Disk arrays on servers usually have an acceleration unit with memory and a battery to prevent data loss in the event that there is a black-out.

Since the Ni-MH array accelerator many HP servers work with 3.6V (three 1.2V rechargeable batteries in series) is replaced by a single Li-ion protected working between 3 and 4 battery , 2V (at 3.6V is 40% capacity).

The original battery, spare ref. 307132-001 HP is 500mAh, so a Li-ion 2600 mAh far exceeds that capacity, so it will retain more energy and for more years than the original having no "memory effect" (probably last longer the server itself), protecting better against unexpected power outages data (also recommended a UPS).

Although the original voltage is 3.6V, in the end, because the charge controller always delivers something else to keep it fully charged, at the end I saw that the Li-ion reaches 100% load without damaging with those 4.2V circuit (checked after two years working with many off / on).

To replace be welded a Li-Ion that includes circuit protection (most are on the negative side), and if not, add one (I took one that was saved by not requiring it the application of other batteries to bring another control external).

Simply extract the battery (lifting the plastic tab on top), we opened a dremel or the like by the union, remove the old and with a pair of wires soldered to the positive and negativeconnections as appropriate (note well polarity before removing the old). with a little silicone or the like the we hold , and we put the battery in the cache, to continue performing its function.

128MB accelerator unit and the battery removed

And the end result is the following , I've also attached the lid on top, but not necessary:

Centralized control mixed system Solar-Biomass with Arduino and TFT Shield

noreply@blogger.com (Ringmaster) — Tue, 16 Aug 2016 17:18:00 +0000

In this post I will share with you the improvements I've made to -biomass Solar mixed system , which is basically to change the obsolete control system for thermostats with a centralized system based on Arduino fully customizable, flexible and expandable; We see assembly, components and source code.

Used materials:

1- Arduino MEGA 2560 (specifically I used one Funduino clone ), because the TFT shield does not leave me enough inputs / outputs Free UNO R3.

2 Touch Screen TFT 2.4 " McuFriend , which will give us great freedom when it comes to display information on screen libraries that have worked best for me. Are the BUHOSOFT ; here you can download the version I used.

3 - relays to activate solenoid valves, with a fed to 5V that can handle 230V and 10A worth us to spare. Not to stress regulator Arduino board, the food independently with other L7805 regulator (handles between 7-30V and 1.5A max). Being so low consumption, nor need a heatsink:

- A speaker-buzzer for alarm warning in case of problems, which operates between 7 and 12V 100dB, enough.

- A relay SSR DC-DC to activate the buzzer ; only consumes between 3 and 25mA so we can turn directly to the Arduino pin. I used one of solid state more than anything because I had left the other, but since it is an element that is to be activated soon, you better go to a mechanical more economical and compact:

- Another solid state relay AC-DC to activate the motor . Of at least 10A, will be the element that suffer the continuous activations, so that the durability and reliability of solid state relay willensure a long maintenance free I've added a heatsink for if heated , although I have exceeded its size as I then checked, but better to err;).

Such sensors are easy to get and set taking temperatures and resistance at two points (as I explained in the previous post ), these can be obtained from lithium batteries and large NI-MH ; the carry to regulate its temperature within safe margins, glued thereto. We also have them in batches very economical. Be sure that is the type that you have referred to in the schedule; in my case NTC(Negative Temperature Coefficient..); indicating rising temp. by lowering its resistance.

Mounting elements and debugged the program

With a prototype card I connect the resistors and sensors, and I tested the data on screen and the feedback we debugged by series errors.

(For those who need it, when I can prepare the scheme with Fritzing to clarify the connections).

After a couple of days working properly, I connect the elements definitively:

For simplicity I have soldered directly 6K8 resistance of each sensor (analog pins 11 to 14) behind the plate:

In the following video I try running surface ; when we launched last settings:

Replacing the old system

We take the same box, leaving the screen in the center window slightly enlarging the alarm at the top:

I distributed all over the box, which had ample depth for all elements:

In the next picture you are not seen, but d shaft connected to a USB cable plate hanging out for possible updates and final program debuggers :

Replacing the temperature sensors

Those who had placed could have served, but since thermostats are compatible with a limited range of sensors, I preferred to reserve them to remove them.

I used to change the board of the trap, which was already badly corroded.

In the image below we have placed the sensor on top of the hot water outlet of the solar collector (more details on its construction inputs), with white tape and more flanges. After white silicone will place above to isolate it better from the outside and does not distort the temperatures in winter, keeping the temperature as close to the actual water pipe.

The program is as follows :

 /*
 * ARCHIVO: Control sistema térmico mixto biomasa-solar
 *   AUTOR: David Losada
 *   FECHA: 8/08/2016
 *     URL: http://miqueridopinwino.blogspot.com.es/2016/08/control-centralizado-del-sistema-mixto-biomasa-solar-con-Arduino.html
 *   Versión 1.0
 *
 * OBJETIVO: Prototipo control de sistema casero mixto biomasa-solar térmica
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 */

// Uses TFTLCD sketch that has been Refurbished by BUHOSOFT
// If using an Arduino Mega make sure to use its hardware SPI pins, OR make
// sure the SD library is configured for 'soft' SPI in the file Sd2Card.h.

// Original code provided by Smoke And Wires
// http://www.smokeandwires.co.nz
// This code has been taken from the Adafruit TFT Library and modified
//  by us for use with our TFT Shields / Modules
// For original code / licensing please refer to
// https://github.com/adafruit/TFTLCD-Library

// adapted sketch by niq_ro from http://arduinotehniq.blogspot.com/
// ver. 1m5 - 13.11.2014, Craiova - Romania

#include 
#include 
#include 
#include 
#include 
#include 

#if defined(__SAM3X8E__)
    #undef __FlashStringHelper::F(string_literal)
    #define F(string_literal) string_literal
#endif

// The control pins for the LCD can be assigned to any digital or
// analog pins...but we'll use the analog pins as this allows us to
// double up the pins with the touch screen (see the TFT paint example).
// #define LCD_CS A3 // Chip Select goes to Analog 3
// #define LCD_CD A2 // Command/Data goes to Analog 2
// #define LCD_WR A1 // LCD Write goes to Analog 1
// #define LCD_RD A0 // LCD Read goes to Analog 0

// #define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin

// When using the BREAKOUT BOARD only, use these 8 data lines to the LCD:
// For the Arduino Uno, Duemilanove, Diecimila, etc.:
//   D0 connects to digital pin 8  (Notice these are
//   D1 connects to digital pin 9   NOT in order!)
//   D2 connects to digital pin 2
//   D3 connects to digital pin 3
//   D4 connects to digital pin 4
//   D5 connects to digital pin 5
//   D6 connects to digital pin 6
//   D7 connects to digital pin 7
// For the Arduino Mega, use digital pins 22 through 29
// (on the 2-row header at the end of the board).

//#define DEBUG
#include 
#include  //Para usar la memoria EEPROM
//Arduino con Tiny RTC I2C http://zygzax.com
//#include 
//#include 
#include  //Manejo reloj interno Arduino

#define LCD_CS A3
#define LCD_CD A2
#define LCD_WR A1
#define LCD_RD A0
// optional
#define LCD_RESET A4


#define YP A1 // Y+ is on Analog1
#define XM A2 // X- is on Analog2
#define YM 7 // Y- is on Digital7
#define XP 6 // X+ is on Digital6

#define TS_MINX 150
#define TS_MINY 120
#define TS_MAXX 920
#define TS_MAXY 940

// For better pressure precision, we need to know the resistance
// between X+ and X- Use any multimeter to read it
// For the one we're using, its 326 ohms across the X plate
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 326);

// Assign human-readable names to some common 16-bit color values:
#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF
//#define ROZ     0xFD20
#define ROZ     0xFBE0
#define GRI     0xBDF7
// http://stackoverflow.com/questions/13720937/c-defined-16bit-high-color
// http://wiibrew.org/wiki/U16_colors

Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);;
// If using the shield, all control and data lines are fixed, and
// a simpler declaration can optionally be used:
//Adafruit_TFTLCD tft;

////***************** COMIENZO DE PARÁMETROS CONFIGURABLES ***********************

//Control temperatura
//Para ahorrar cálculos, lo vamos a calcular antes del programa
//const float TPto1 = -6; //Temperatura en ºC punto 1 (A descomentar las siguientes cuatro líneas  si desconocemos el varor de B para el termistor utilizado)
//const float RPto1 = 40000; // Ohms en punto 1
//const float TPto2 = 96; // Temp. punto 2
//const float RPto2 = 970; // Ohms en punto 2
const long B = 3850; //Valor Beta del Datasheet; comentar esta línea si se meten los datos de los dos puntos
const int resistor = 6800; //El valor en ohmnios de la resistencia del termistor a 25ºC
const float voltage = 5.01; // El voltaje real en el punto 5Vcc de tu placa Arduino

//Deltas de temperatura
const byte DtFsolar = 10; //Delta temp ºC conexión de motor circuito panel solar
const byte Dtosolar = 4; //Delta temp. desconexión motor

const byte DtFbiomasa = 12; //Delta temp ºC conexión de motor y válvula circuito biomasa
const byte Dtobiomasa = 4; //Delta temp ºC desconexión de motor y válvula circuito biomasa
const byte minRetorno = 40; //La válvula de biomasa sólo se apagará si la temp. de cañería retorno baja de este valor para prevenir desgaste

const byte DtFEnfriar = 65; //Temp. ºC conexión electroválvula circuito desvío exceso temp a calefacción
const byte DtoEnfriar = 60; //Temp. desconexión electroválvula desvío agua caliente a calefacción

const int frecseg = 10; //Tiempo en segundos entre cada ejecución del programa (recomendado entre 5 y 20 segundos)

//Definición pines digitales para activar relés
#define ledPIN 13 //Led placa arduino
#define motorPIN 25 //Pin digital activar relé motor
#define valvbioPIN 27 //Pin digital activar relé electroválvula circuito biomasa
#define valvenfriaPIN 29 //Pin digital activar relé electroválvula circuito calefacción radiante
#define zumbadorPIN 31 //Conexión al Mosfet del zumbador electrónico de aviso
#define primerSensor 11 //Pines analógicos para termistores; van correlativos desde este

//***************** FIN DE PARÁMETROS CONFIGURABLES ***********************

//Variables 
float Mtempsens[4] = {0,0,0,0}; //Matriz temperaturas sensores para guardar las medias
const char* Mnombres[]={"Captador:","Deposito:","Biomasa: ","Retorno: "}; //Matriz de arrays (*=pointers) de los nombres de los sensores
float calibTemps[4] = {0,0,0,0}; //Matriz de ajustes calibración sensores en ºC

boolean motorON=false; //Para comprobar si está en marcha
//datos estadísticos y otras
long Mdatos[5] = {0,0,0,0,0}; //Matriz estadístias uso
//Matriz de arrays (*=pointers) de los nombres de los datos; No deberían tener más de 13 caracteres cada una (sumar 
const char* MnomDatos[]={"Hrs motor ON","Hrs Arduino","CTR RELE Motor","CTR VALVULA Fuego","CTR VALVULA Enfriar"}; 

//Para ahorrar cálculos lo definimos como constante en esta parte del programa
const float K= 273.15; //Para pasar a grados Kelvin
const float e = 2.718281828459045; //Constante matemática 
//const float B = log(RPto2/RPto1)/(1/(TPto2+K)-(1/(TPto1+K))); //Valor Beta de tu termistor calculado de dos puntos
const float unodivr = 1/(resistor * pow(e,(-B/298.15))); //Con pow elevamos e al resultado

float T = 0; //Declaramos la variable Temperatura
int grados, decimas; //Para ponerle coma al resultado (en español)

unsigned long millisHrsArduino=0; //Guardar horas funiconamiento Arduino
unsigned long millisMotor=0; //Guardar horas funcionamiento Motor
unsigned long millisInicioMotor=0; //Guardar tiempo activado motor
unsigned long timeLED=0; //Tiempo funcionamiento LED placa
unsigned long milisegundos=0; //Para almacenar temporalmente millis
byte error=0; //En caso de error será <> 0

int segundos=0; //Cuando lleguemos a 3600 segundos, habrá pasado una hora.
int direccionInicial; //Dirección memoria EEPROM a partir de la cual se guardan los datos, asignado por la librería EEPROMex

void setup() {
  Serial.begin(9600);

  Serial.println(F("Arduino Working OK"));

//#ifdef USE_ADAFRUIT_SHIELD_PINOUT
//  Serial.println(F("Using Adafruit 2.8\" TFT Arduino Shield Pinout"));
//#else
//  Serial.println(F("Using Adafruit 2.8\" TFT Breakout Board Pinout"));
//#endif

  Serial.print("TFT size is "); Serial.print(tft.width()); Serial.print("x"); Serial.println(tft.height());
  tft.reset();

  uint16_t identifier = tft.readID();

if(identifier == 0x9325) {
#ifdef DEBUG
    Serial.println(F("Found ILI9325 LCD driver"));
#endif // DEBUG
  } else if(identifier == 0x9328) {
#ifdef DEBUG
    Serial.println(F("Found ILI9328 LCD driver"));
#endif // DEBUG
  } else if(identifier == 0x7575) {
#ifdef DEBUG
    Serial.println(F("Found HX8347G LCD driver"));
#endif // DEBUG
  } else if(identifier == 0x9341) {
#ifdef DEBUG
    Serial.println(F("Found ILI9341 LCD driver"));
#endif // DEBUG
  } else if(identifier == 0x8357) {
#ifdef DEBUG
    Serial.println(F("Found HX8357D LCD driver"));
#endif // DEBUG
  } else if(identifier == 0x0154) {
#ifdef DEBUG
    Serial.println(F("Found S6D0154 LCD driver"));
#endif // DEBUG
    } else {
    #ifdef DEBUG
    Serial.print(F("Unknown LCD driver chip: "));
    Serial.println(identifier, HEX);
    Serial.print(F("I try use ILI9341 LCD driver "));
    Serial.println(F("If using the Adafruit 2.8\" TFT Arduino shield, the line:"));
    Serial.println(F("  #define USE_ADAFRUIT_SHIELD_PINOUT"));
    Serial.println(F("should appear in the library header (Adafruit_TFT.h)."));
    Serial.println(F("If using the breakout board, it should NOT be #defined!"));
    Serial.println(F("Also if using the breakout, double-check that all wiring"));
    Serial.println(F("matches the tutorial."));
    #endif // DEBUG
    identifier = 0x9341;
  }


  tft.begin(identifier);

  //tft.fillScreen(BLACK);
  tft.fillRect(0, 0, 320, 240, BLACK);
  tft.setRotation(1);
  tft.setTextSize(2);
  tft.print("    Arduino MEGA 2560");
  tft.setCursor(30, 100);
  tft.setTextColor(RED); 
  tft.setTextSize(3);
  tft.println("LCD driver chip: ");
  tft.setCursor(100, 150);
  tft.setTextColor(BLUE);
  tft.println(identifier, HEX);
  tft.setTextSize(1);
  tft.setCursor(70, 220);
  tft.println("Copyright 2016 Ringmaster v1.0");
  
  delay(6000);

  //Configuración TouchScreen
  #define MINPRESSURE 10
  #define MAXPRESSURE 1000
  
  // start reading from position memBase (address 0) of the EEPROM. Set maximumSize to EEPROMSizeUno 
  // Writes before membase or beyond EEPROMSizeUno will only give errors when _EEPROMEX_DEBUG is set
  EEPROM.setMemPool(20, EEPROMSizeMega);
  
  // Set maximum allowed writes to maxAllowedWrites. 
  // More writes will only give errors when _EEPROMEX_DEBUG is set
  EEPROM.setMaxAllowedWrites(200);
  //Coger la dirección inicial siempre en el mismo momento y en el mismo orden
  direccionInicial = EEPROM.getAddress(4); //Primera dirección Long disponible a partir de la cual guardar

//Reseteamos a 0 la zona de EEPROM necesaria durante la primera ejecución
if (EEPROM.readLong(direccionInicial+45)!= 4011983) { //Si se ha reseteado ya, no lo volvemos a hacer
for(int i=0; i<5 -="" 0="" 10000="" 25ms="" 2:="" 3:="" 5="" :="" a="" absoluto="" acar="" acumula="" adimos="" alarma="" alg="" alguna="" almacenados="" anal="" analogread="" and="" array="" arte="" atos="" basandose="" beta.="" c="" calcular="" calibraci="" calibtemps="" cero="" con="" convertidas="" correcta="" ctivamos="" de="" del="" delay="" desconectada="" digitalwrite="" direccioninicial="" divisor="" ecoge="" ecogidas="" ecuaci="" edias="" eeprom.writelong="" eeprom="" el="" emperaturas="" en="" entre="" error="" es="" espera="" est="" estar="" excesiva="" final="" float="" for="" forma="" gicos="" haremos="" hora="" i="" if="" input="" int="" la="" las="" lecturas="" ledpin="" loop-------------------------="" loop="" los="" mdatos="" mediante="" medias="" motorpin="" mtempsens="" n="" obtenidas="" ogemos="" oger="" ok="" omprobamos="" onvertimos="" orrado="" orrar="" output="" para="" parte="" pinmode="" primersensor="" r1="r1a" r1a="(voltage*float(resistor))/v2;" readlong="" recopilados="" reseteamos="" resistance="" resistencia="" resistor="" sacar="" saltar="" se="" serial.println="" si="" so="" sonda="" sondas="" steinhart-hart="" t="B/log(r1*unodivr);" temp="" temperatura="" temperaturas="" tempsens="" tenemos="" terminado="" termistores="" thermistor="" time_t="" v2="(R2*V)/(R1+R2)" valor="" valores="" valvbiopin="" valvenfriapin="" veces="" void="" voltage="4.83" voltaje="" voltios="" x="" y="" ya="" zumbadorpin="" zumbido="">90) {
          error++; //Si se acumula algún error, haremos saltar la alarma en forma de zumbido
         }
      }  

//***************************COMPARACIÓN DE TEMPERATURAS SONDAS****************************
//Comprobamos biomasa, y actuamos sobre motor y electroválvulas en consecuencia
Serial.println(F("Comparando temperaturas"));
if (motorON==false && (Mtempsens[2]-Mtempsens[3])>= DtFbiomasa) {//Si el fuego está encendido, activar motor y electroválvula circuito biomasa (PRIORITARIO)
    if (digitalRead(valvbioPIN)==LOW) { //Se activa relé; contamos el número de activaciones
    Mdatos[3]=Mdatos[3]+1;
        }
    digitalWrite(valvbioPIN, HIGH);
    motorON=true;
  }
//Si no hay razón para mantener la electroválvula de desvío biomasa, la desconectamos
    if (digitalRead(valvbioPIN)==HIGH && ((Mtempsens[2]-Mtempsens[3])< Dtobiomasa) && (Mtempsens[3]< minRetorno)) { //Comprobamos también temp. para evitar activados intermitentes
      digitalWrite(valvbioPIN, LOW);
    }

//Comprobamos panel solar, y activamos motor en consecuencia
if (motorON==false && (Mtempsens[0]-Mtempsens[1])>= DtFsolar) //Si diferencia temp. captador y depósito mayor que el delta, activar motor
{
  motorON=true;
}
else {
  if (motorON==true && (Mtempsens[0]-Mtempsens[1])< Dtosolar && (Mtempsens[2]-Mtempsens[3])< Dtobiomasa) {//Si el captador y biomasa están fríos
    motorON=false;
  }
}

//Dependiendo del resultado de las anteriores comprobaciones, activamos motor o no
if (motorON==true) {
    if (digitalRead(motorPIN)==LOW) { //Se activa relé; contamos el número de activaciones
    Mdatos[2]=Mdatos[2]+1;
    millisInicioMotor=millis(); //Y activamos el contador de tiempo uso motor
  }
  digitalWrite(motorPIN,HIGH);
//  if (millisInicioMotor==0) {
//    millisInicioMotor=millis();
//  }
  }
else  {
    digitalWrite(motorPIN,LOW);
  }

//Si la temperatura del depósito es excesiva, activar el relé de enfriamiento (desvío a calefacción)
if ((Mtempsens[1]> DtFEnfriar) and motorON==true) {
    if (digitalRead(valvenfriaPIN)==LOW) { //Se activa relé; contamos el número de activaciones
    Mdatos[4]=Mdatos[4]+1;
  }
  Serial.println(F("Activar válvula desvío circuito enfriado"));
  digitalWrite(valvenfriaPIN,HIGH);
}
else { //Desactivar la válvula enfriado si la temp depósito ha bajado suficiente o el motor se ha parado
    if ((Mtempsens[1]< DtoEnfriar) or motorON==false) {//
    digitalWrite(valvenfriaPIN,LOW);
  }
}
  
Serial.println(F("Mostramos en pantalla"));
// Y por ultimo lo mandamos a la pantalla LCD
//    tft.reset(); //Reseteamos la pantalla; lo hago cada minuto porque a veces se me quedaba en blanco
//    uint16_t identifier = tft.readID(); //Leemos el identificador de pantalla, en mi caso 9325
//    Serial.print("Display ID: ");
//    Serial.println(identifier);
//    tft.begin(identifier); //Inicializamos la pantalla
//    tft.setRotation(1); //Girada la pantalla 90Âº para ponerla horizontal   
    tft.fillScreen(BLACK); //Es muy lento, tenerlo en cuenta
    tft.setTextColor(YELLOW); 
    tft.setTextSize(3);
    tft.setCursor(0,0);
    for(int i=0; i<4 anal="" gicos="" i="" if="" nombres="" tempsens="" termistores="" tft.print="">-270) {
            grados=int(Mtempsens[i]);
            tft.print(grados); //Grados
            tft.print(",");
            decimas=(Mtempsens[i]-grados)*10;
            tft.print(abs(decimas)); //décimas de grado
            tft.println(" C");
          }
          else { //La temp es incorrecta
            tft.println("ERROR");
          }
      }  
      tft.setTextSize(2);
      tft.println(" ");
      tft.setTextSize(3);
      if (motorON==true) {
        tft.setTextColor(RED);
        tft.print("MOTOR ON");
      }
    else {
        tft.setTextColor(GREEN);
        tft.print("MOTOR OFF");
      }
     if (digitalRead(valvenfriaPIN)==HIGH) { //Indicamos si está la válvula de enfriado activada
      tft.setTextColor(WHITE);
      tft.print(" ENFRIA");
      }
    else {
      if (digitalRead(valvbioPIN)==HIGH) { //Está el fuego encendido
      tft.setTextColor(WHITE);
      tft.print(" BIOMASA");
      }
    }
    tft.println("");
    tft.setTextSize(2);
    tft.println(" ");
    tft.setTextColor(BLUE);
    for(int i=0; i<5 _______________________________="" _______________________________________="" activado="" atos="" datos="" el="" erial.print="" erial.println="" estado="" guardamos="" ha="" i="" if="" illis:="" illismotor:="" lo="" milisegundos="millis();" millis="" millisiniciomotor="" motor="" nomdatos="" si="" sumamos="" tft.print="" tft.println="" tiempo="" tiempos="" y="">=milisegundos) { //Tenemos en cuenta si se ha reseteado millis a los 50 días
   millisInicioMotor=0; 
    } 
//Si ha pasado una hora con el motor activado, la sumamos
if (motorON==true && millisInicioMotor>0 && (milisegundos-millisInicioMotor)>3600000) {
    millisMotor= millisMotor + ((milisegundos-millisInicioMotor)); //Sumamos la diferencia
    if (millisMotor>3600000) { //si es más de una hora, la pasamos al contador principal
      Mdatos[0]=Mdatos[0]+1;
      millisMotor=millisMotor-3600000;
    }
    millisInicioMotor=milisegundos; //Y volvemos a empezar la cuenta
}
//Estuvo encendido y acaba de apagarse; sumamos tiempo y reseteamos
if (motorON==false && millisInicioMotor>0) { 
    millisMotor= millisMotor + ((milisegundos-millisInicioMotor)); //Nunca va a estar más de unas horas en marcha
    millisInicioMotor=0;
}

//*** Cada hora salvamos a la EEPROM los datos que han cambiado (no hacerlo mÃ¡s frecuente para prevenir el envejecimiento prematuro de la FLASH)
if (millisHrsArduino>milisegundos) { //Comprobamos como siempre si se ha reseteado millis
  millisHrsArduino=milisegundos;
}
if ((milisegundos-millisHrsArduino>=3600000) || (millisHrsArduino>milisegundos)) { //Si ha pasado una hora o si millis se ha reseteado tras 50 días
      Serial.println(F("Guardamos horas Arduino y resto de datos en EEPROM"));
      Mdatos[1]=Mdatos[1]+1; //hrs Arduino
      millisHrsArduino=milisegundos; //Actualizamos
 for(int i=0; i<5 acemos="" activaci="" al="" alvamos="" cambiados="" comprobando="" datos="" desde="" direccioninicial="" eeprom.update="" el="" hacemos="" i="" if="" la="" led="" los="" ltima="" milisegundos="millis();" n="" parpadear="" serial.println="" tiempo="" timeled="">milisegundos) { //Cuando pasen 50 dias resetear
    timeLED=millis();
  }
  if ((milisegundos-timeLED)>frecseg*1000*2) {
      digitalWrite(ledPIN,HIGH); //enciende LED indicando funcioanmiento
      timeLED=milisegundos;
  }
  else {
     digitalWrite(ledPIN,LOW); //apaga led
     }

if (error>0) { //Tanto si alguna sonda está mal, como si alguna temp es excesiva
  digitalWrite(zumbadorPIN,HIGH); //Hace sonar la alarma
}
else {
  digitalWrite(zumbadorPIN,LOW);
}

    delay(frecseg*1000);  //Bucle se ejecuta cada frecseg segundos
    //lpDelay(frecseg*4); //Pone el procesador a descansar a la mínima velocidad; anulado, no funciona bien

}

Isolating better tank

At the bottom I have also placed, but leaving easy access for maintenance of the deposit.

And finally I have secured with duct tape:

Maintenance of the expansion vessel

Every three years there to check the expansion vessel as it loses any tire pressure and stops properly perform its function of maintaining the pressure to 1.5 bar.

The glass of my installation whole bottom was oxidized to splashed rain over the years, so I sanded with brushes sheets and drill and you've applied paint "forging" anti-oxide (carrying metal particles that severely limit the passage moisture), her anti - rust no need for a previous hand, it is very durable .

More info:
Practical Guide to installing a solar thermal system Technical Manual installation Solar thermal energy

Changing the battery of your tablet for a few bucks

noreply@blogger.com (Ringmaster) — Sun, 17 Jan 2016 15:03:00 +0000

In this post we will change a spent battery to a 9-inch tablet

Currently it is not uncommon to see every family with an Android or Apple tablet, and over time the piece gets more wear of this useful accessory is the li-ion battery, especially if it is of poor quality, and when it lasts less than an hour we should change it, improving the original capacity if possible. In this case we have a Edertix Tablet 9.7" whose battery lasts less than half of its original capacity.

If we remove the lid to any tablet, (you can search youtube how to do this) of plastic clips, we find something like this :

He wears a composite of two smaller parallel connected battery 2000 mAh each (note the centre union, and will replace it with a battery of the same size but wider than 1 mm., Since the cap gives us sufficient margin, with what we will gain in duration . The battery is as follows , I checked their capacity and actual 5500 mAh (very close to what was announced in Aliexpress 6000) 4.5 * 93 * 105mm and weight 100 grams, ideal for tablets 10 " . Also bring its own circuit protection (on a tablet is not necessary, so if we are short on space we can remove it).

First of all we remove weldings of the old battery with care so the cables do not touch on the board, it should be taped to the terminals as unsolder a soldering iron:

Then use a knife to cut the adhesive strip keeps glued to the screen, being careful that it does not slip and we cut a finger or a tablet cable.

CAREFUL WITH CUTTER, WE CAN DAMAGE THE TABLET

If there has been enough glue can be worth to the new battery (that being fatter also going to be tighter for the cover), but if not, it is convenient to put double sided tape to fit tightly and not damage other elements a fall.

We can only re-solder the terminals taking care to avoid mistakes polarity; I usually come screen printed on the plate if we have not set the release:

But all this you will see more clearly in the video on Youtube:

Extending the battery life of your phone past 3 DAYS

noreply@blogger.com (Ringmaster) — Tue, 12 Jan 2016 15:41:00 +0000

S5 with housing and battery Zerolemon What's hot?

Granted, cheating is so fashionable today... but if not, "you wouldn't go read" this entry. No, there are no magic tricks to make your smartphone lasts, in normal use, more than calculated by the manufacturer (beyond a few more hours); if you want your battery to last more, the only answer to your praye is to change the battery with a higher capacity one at the expense of giving more thickness to the mobile, yes, and if the change includes a cover that protects it from knocks great, welcome are the "fatphone"!

But do not go! This entry is not sponsored! The Zerolemon are not the typical Chinese fat batteries, with a shabby housing to accommodate them. It is quality batteries, yes manufactured in China, but with reliable Design and Quality; I tell you I've been using for the last year one for my S3 with results that have exceeded my expectations, with actual 6000 mAh .

It's like carrying two spare batteries already in place!

To insert the battery have to remove the back cover, as the innovative rubber casing serves as the back cover and protective cover to fall :

Dissasembling it you can see that are only three li-ion 3.7V flat batteries connected in parallel (one is stuck in the hole, and two next to each other attached to it, with the NFC antenna stuck on the back). One of them is the optimal use of space, so much that if you add a silicone protector to the mobile with its standard battery, it does not occupy much less than this technical solution.

In addition, suffering fewer cycles of loading / unloading a year, the battery also will age more slowly (although last longer, as all li-ion, we do not recommend downloading below 15% for longer shelf life twice).

Yes, there are phones that its battery lasts longer than 1 day, but can be counted with the fingers, and ... imagine how much would last with one of this!

For that, you do not need to go away to a phone that does not fit in the palm of your hand so you do not have to rely on a charger, since engineers Zerolemon make batteries for Top mobile sellers with a huge growing market.

On the other hand, from a time now have improved the design of its casing, making them more cool and protective; now they are rigid polycarbonate shells with a hollow rubber around the perimeter that acts as a bumper Zeroshock, absorbing impacts very well, and fully compatible with NFC :

We also have different designs available.

But there is a BUT ...?

The only but is that the phones that are splashproof as the S5, removing the back cover that protection is compromised, although I think it's worth the risk.
Besides charging the 6000 mAh battery with a 1 A standard charger will take all night, but no problem, don't you thing?

The Zerolemon batteries are available on Ebay (click) or Amazon USA

More info:
Frequently Asked Questions
Zerolemon Batteries