A m I – a smart music composer (?)

Last update: 2018 Sep 23 – Added final version working folder (C sources)

A lot of (nerd) humour in this title ūüôā It can be read in two ways. The first is: “Am I a smart music composer ?” (the answer is: no) and the second is: “Artificial musical Intelligence – a smart music composer”. In practice, the purpose of this small project is to test an algorithm able to randomly generate a “decent” music. It could be easily done with a PC, using its huge HW / SW resources, but I want to do it with a very small microcontroller circuit based on STM8S001J micro, using my own firmware written in C language.

The software project is splitted in two parts: the first is “the player”, the part that just plays a melody stored in the microcontroller’s memory; the second is the algorithm that generates such melody in a random way. Let’s start from the first part, the “music player”.

First of all, we must build the circuit and test the music player firmware. The schematic is very simple (see below)

Differences from the prototype picture: R6 is 330R on the prototype and R3 was added to reduce sound level while recording the song with PC audio software.

You can download the schematic in PDF format from this link. The circuit is very simple and can be easily built on a prototype board. The piezo buzzer LS1 has low audio volume (it’s just a local “monitor”), but you can take the audio signal from J2 connector and send it to an amplifier. I decided to create a very small ADSR (Attack-Decay-Sustain-Release) in order to have a sound like a “ding” and not the usual “beep”. The I/Os PC5-PC4-PC3 (pin 7) are used all together to give the current necessary to charge the 100uF capacitor used in ADSR. The envelope of such ADSR circuit has the shape that you can see in the next image. There is a screenshot of the Audacity¬†open-source software used to record the default song “Happy Birthday to you” produced by the test firmware.

If you want to hear such recording, try this:

Here is how such “song” is stored in the microcontroller’s memory. In this first section, the notes and their durations are stored as a constants array (FLASH memory), but in the final version the random song will be generated in a RAM array. The player, however, will act in the same way. The duration of every note is expressed in 50mS steps. The note “0” is a pause.

If you want to build this circuit, and improve or modify the first version of the firmware, click the link¬†AmI¬†for the full project folder, with C sources, ready to be edited, compiled and debugged using the free Cosmic-C and STM tools (read my previous articles on this subject). The working folder is zipped, so use the 7Z program with password eficara to extract it. The two buttons “like” and “unlike”, in this test firmware, are used just to start and stop the sequence. Note that the stop button is sampled only at the end of a note, so you must press and hold it down up to the end of a note to stop the song.

The algorithm and how it improves itself

Artificial musical Intelligence: what do we need to create a machine that can autonomously produce an acceptable music or melody ? First of all, we must implement a random numbers generator. This is the heart of the algorithm and simulates that magical element that we have no control over, like fate or destiny. After this, we have to set some rules that will be picked up randomly and used to generate a sequence of notes and pauses. Finally, the most important element: the feedback. The machine needs a feedback to improve itself. The feedback, in this case, is supplied by the human that listens to the music (you) via two buttons. Such buttons are labelled “like” and “unlike”. After listening to the music, you can press “like” if you appreciated the composition, or “unlike” if it was nearly horrible; or, you can simply refuse to press any button to say “not bad, but nothing special”. The result of such feedback is that the implemented rules will change their importance. All the rules, at beginning, start with the same importance, so all of them have the same probability to be extracted by the fate (the random number generator). If we press “like” after listening to the freshly composed melody, the rules involved in such creation will increase their importance, so they will have more probability to be used in the next composition. As opposite, if you press “unlike”, all the used rules will decrease their importance, so the probability to be used in the next composition is reduced. Well, what happens if one rule reaches the “zero” probability (in practice, if it can’t be extracted anymore)? Well, in such case the system will generate a new random rule that will substitute the one just erased. The new rule will start with a probability of 50%. Note that the new rule is really very “casual” and may contain some bad notes combination (or a touch of genius, who knows). All the probabilities of the rules and the rules themselves are stored in the non-volatile memory of the micro (Eeprom) in order to be available after a new power-on of the device. The device, when powered-on, will start composing a new melody (this is a very fast process), then will start to play that melody. After playing the whole melody, the program will wait 5 seconds for a feedback (button pressed) then will restart from the beginning, with a new melody. When you are tired to listen to such melodies, just turn OFF the device…

The rules

Rules are important. They permit to follow an ordered path in the chaos induced by random numbers. Here is an example of the first melody generated by the circuit using just the random numbers generator, without any rule:

In this test project, the rules are 8. The random number generator selects one of such rules for 8 times. At end of this operation, the resultant melody will be played. Every rule contains four “events”. An event is a note or a pause. The rules are arbitrarily chosen by me and I’m not a musician ! Anyway, when one of my initial rules will reach a zero probability, it will be regenerated by random numbers, so my own fingerprint will disappear in a short time. Every event is expressed in 4 bits. These are all the values:

0 = pause               8 = repeat last note
1 = 1 semitone over     9 = 1 semitone under
2 = 2 semitones over   10 = 2 semitones under
3 = 3     "      "     11 = 3     "       "
4 = 4     "      "     12 = 4     "       "
5 = 5     "      "     13 = 5     "       "
6 = 6     "      "     14 = 6     "       "
7 = 7     "      "     15 = 7     "       "

When there is a new event, it is applied starting from previous one (so, it’s a displacement). For example, if last note played was F and the selected value is 4, the new note played will be A (higher frequency); if the value is 9, the new note will be E (lower frequency) and if the value is 8, the new note will be equal to the last played note, so F again. If the value is 0, the new note will be a pause, so no sound, but the value of last played note will be retained in order to be used in next event. With 4 events for rule and each event defined in 4 bits, we¬† need one word (16 bits) for rule, but one note doesn’t have just a frequency, but also a duration. So there is a second part of the rule that contains such information. The duration just requires 2 bits, so the 4 events are contained in a single byte. These are the available duration values:

00 = 1/8 (4 * 50ms)
01 = 1/4 (8 * 50mS)
10 = 2/4 (16 * 50mS)
11 = 1/4 + 1/8 (12 * 50mS) 

The rules are stored in Eeprom, starting from address 0x4010. Here is an example of the Eeprom area mapping: (notes in yellow, duration in blue)

In order to test the rules, I used a program written by me in Visual Basic Express 2005 for Windows, many years ago. This is the screenshot of the application:

If you want to try with this small application, download the midimio.zip file from my website (look at the page PC Music). It’s a very small and simple program, but it is enough to write simple melodies. To compose a melody, use the checkboxes to select the note and the duration, then click the red button to save the event. The arrows at the sides of the red button move back and forward in the melody. When all the melody has been entered, you can play it with the buttons at the top right of the screen (play, stop, begin, end). The musical instrument can be changed modifying the value in the box “Strumento“. Your PC must be able to play MIDI, to use this program. Note that there are no editing functions !¬†If you want to modify an event, just use the arrows to move to such event and replace it with a new one, selecting it with the checkboxes, then click the red button. To clear all, restart the program. You can save / reload melodies using the “File” menu tab.


I said that the algorithm changes the probabilities of the rules. I used a simple way to do this. Imagine a dice: it has 6 faces with 6 numbers, so the probability for each number is 1/6. What happens if I modify one face changing its value from 1 to 5, for example ? If I am in Las Vegas, probably I will finish my days in jail ! No, no. This is just an example… In this case the probabilities of the number 5 are 2/6 (and 0 for the number 1) so, even though the dice still have 6 faces, we modified the probabilities of the numbers. In this program we have the numbers from 0 to 7 repeated 4 times, and our “dice” has 32 faces. The random numbers generator (RNG) gives us a number from 0 to 31 and the program checks if the selected “face” is present (bit at 1) or absent (bit at 0). If absent, the RNG is called again, until it finds a 1 bit. So, the rules with more bits at 1 have higher probabilities to be extracted. Here is an example:

Initial status: the rules from 0 to 7 all have two bits each set, so all of them have the same probability (2 of 4, or 50%)

bit position 33222222 22221111 11111100 00000000
             10987654 32109876 54321098 76543210
bit status   11111111 11111111 00000000 00000000

Now, suppose we have pressed “unlike” after a melody that used the rules 6, 2 and 0. In such case, the table will be modified as:

bit position 33222222 22221111 11111100 00000000
             10987654 32109876 54321098 76543210
bit status   10111010 11111111 00000000 00000000
              ^   ^ ^

It’s evident that the rules 6,2 and 0 now have less chances to be extracted. Another example here: we pressed “like” after a melody where rules 7,4 and 1 have been used. The table will be modified as follow:

bit position 33222222 22221111 11111100 00000000
             10987654 32109876 54321098 76543210
bit status   10111010 11111111 10010010 00000000
                               ^  ^  ^

In this case, the rules 7,4 and 1 have more chances to be extracted. So, every “like” and “unlike” will change the probabilities of the rules of 1 of 4, so 25%. The initial values for the rules are set to 2 of 4, or 50%. When all the bits for a rule are filled (all at 1), no additional increment can be done, while if all bits for a rule are erased (all at 0), a new rule will be randomly generated, with 50% of probability (2 of 4 bits). The 4 bytes (32 bits) containing this table are stored, like the rules, in non-volatile memory (Eeprom).

Random Numbers Generator

There are many algorithms to generate (pseudo) random numbers. In this experiment I used a very simple one, taken from an IC used in some old keyboards: the MM5837 Digital Noise Source. You can easily find the datasheet on the Internet.The operation principle is simple. There is a 17 bits shift register and the input is computed with a simple xor of the bits 17 and 14. One mandatory rule is that the initial value of the shift register MUST be different from zero. Here is my personal version of the algorithm:

As you can see, I used two 16 bits shift registers slrand[0] and slrand[1] with two different feedbacks. The first uses bits 14 and 11 as shift input, while the second uses bits 15 and 10. As additional randomness, I used the last bit of previous generated random value to select which register must be used to update the output. The function doesn’t return a value, but just modifies the global variale rand that is used in various parts of the program. The function is continuously called in the main loop of the program to randomize the rumber more often. The output range of the byte rand is 0 to 255.

The shift registers must be initialized with a non-zero value. I used this small function for the initialization. The function is called the first time one button is pressed to start the song generation and takes the seed from the timer TIM4, that is started immediatly after the reset.

End of job: results

After many tests, the music produced by the machine is still bad (in my opinion). May be the music needs some “magic” part that isn’t available on logic circuits, or the algorithm must be improved. Here are two tables containing the rules and the probabilities at the first launch of the program¬† and after some feedback given by me pressing the “like” or “unlike” buttons (rules in yellow, probabilities in blue):

Initial condition of Eeprom

Eeprom modified by the algorithm

If you want to try by yourself, load the zipped file AmI_2.zip, decompress it using the 7Z program with password: eficara and then you will have the full project folder, with the C sources and the .S19 files. In the sub-folder named “release” there are the files: AmI.s19 to burn the program area of the microcontroller and the file rules.s19 to burn the eeprom area of the micro. If you want to start from more advanced rules and probabilities (based on my feedbacks), use the third file newrules.s19 to burn the eeprom area. The option bytes are untouched, leave them as they are in a new STM8S001J device.

Look at the main program, executed after reset:

Once started, the program makes a special sound high-to-low and low-to-high (Glide) to inform you that is waiting for a key pressure. When you press a key, the random number generator is initialized and the main starts, generating a new melody. Look at the SongPlayer state machine and what happens when the generated song ends:

If you press PLUS1 (like), the program calls the routine that increments the probabilities for the used rules (UpgradeProbs). If you press MINUS1 (unlike) the called routine is the one that diminishes the probabilities of the rules used (DowngradeProbs) and eventually generates a new rule if the probabilities reached zero. Finally, if you don’t press any key in the 5 seconds time, the probabilities are not modified. Note that if you press both the keys, you will have first an increment, then a decrement… I did it just for testing purposes. You can use the swim interface to read the eeprom and observe the variations in the rules and in the probabilities after giving your feedback (the micro will be reset).

Here is a melody generated with the eeprom data taken from the file newrules.s19 :

Obviously, the melody will be different if you run your own device, ‘cause it’s a collection of random rules. Have fun experimenting ! Bye.

STM8S UART test in Single Wire (half duplex) mode

I received an answer from an STM engineer after my question in the forum at this link: https://community.st.com/thread/46397-stm8s001j3-uart-remap . The question was about the loss of UART_RX if remapping the TX on the pin 5 (PA3). The answer confirmed my opinion about a mistake in documentation, but the engineer suggested the use of the UART in single-wire half-duplex mode, where only the UART_TX pin is used. So, I tested this operative mode and it worked. Then, I decided to publish the full project folder (schematics and C sources) in order to expand my tutorial about the STM8S microcontroller (hope it helps).

The working prototype

Using a single wire UART means that you must “mix” the output and input line to have your communication. In the microcontroller such mixing circuit is inside the chip, but if you want to use (for example) an USB-Serial converter standard to drive the micro, you will add some hardware. Not so much: just a diode and a resistor. Look at the schematic here below:

The diode used in this case is the BAT43, a Schottky diode with low forward voltage drop. This is necessary in order to have a “zero” level inside the microcontroller VIL limits. Note that such “mixer” isn’t very good if you plan to use the serial interface at very high speed, ‘cause the “high” level comes from the pull-up (10K) only, being the serial line “open drain” like. So, the rising time of the signal depends upon the capacitive loads on the line. Using a transmission speed of 115200 BPS, means that every bit is about 8.7 uS long and the internal sampler of the UART takes 3 samples at the ideal center of the bit. I recommend to use transmission speeds not higher than 19200 BPS. In this experiment I used the quite good 9600 BPS (104 uS per bit) with 8 data bit, one stop bit, no parity.

The firmware in C language is available in a fully working folder with all the necessary files to edit / compile / debug the experiment. Please read the starting point for setting-up the working environment at my previous article here.

The program is very simple. You can use any terminal program on your PC as the controller part, setting the communication speed as mentioned before. You have just two valid commands: AT0<cr> to turn OFF the led on the microcontroller board or AT1<cr> to turn it ON. In both cases you will receive an answer “OK”<cr><lf>. Every different input will produce an answer like “Error”<cr><lf>. The max length of the command string is 4 characters. Look at the terminal window:

Firmware description

First of all, we have to set the options bytes in the STM8S001J microcontroller. We connect the SWIM interface and run the ST programmer. We now modify the AFR1 and AFR0 bits in order to remap the UART_TX on pin PA3 (pin 5). The options can be written from the C program in the micro (it’s almost like write to the EEPROM), but for this test we just use the STM programmer, before loading the test program in the microcontroller. This is the screenshot of the modified option bits:

click the image to enlarge

With the microcontroller’s options programmed in this way, we can try to start debugging the test program. The folder that contain all the files can be downloaded from this link:¬†SingleWire.zip. Please expand the zip file using the program 7Z and the password: eficara.

Now, some details about the C source. First of all, we have to set the port PA3 to be output open-drain. When the serial TX transmits a “zero” the line is pulled down from the internal mosfet; when the TX sends a “one” the line is “open”, so the high level is supplied by the pull-up resistor (10K, see schematic). Here are the C source lines:

After this, we set the UART registers to have 9600,N,8,1 protocol in Single wire, half-duplex mode. In such mode, the micro uses only the I/O PA3 for both TX and RX.

Now we create a function to transmit a character on the serial port. Note that every character sent will be received in the same time ! So, I set a flag called echo that will be used in RX interrupt to discard the data just received (such echoed data will not be stored in RX queue).

It’s better to take a look at the RX interrupt to clarify the concept. The serial RX interrupt will save the received data in a circular buffer. If the echo flag is set, the received data is NOT stored, so it is filtered out.

The data stored in the circular RX buffer will be used to fill the command buffer that is asynchronously handled in the main program as part of TimedEvents.

If head and tail pointer of the circular buffer are different, there is some data pending, so the data is taken from the buffer and the tail index is incremented. The received data is then compared with 0x0D (the CR) and if it’s equal, the received command can be executed. Note that the program also tries to execute the program if the buffer is filled (command too long). The command execution is very simple (this is just a proof of concept !). Look at the parser:

So, the accepted commands are “AT0” and “AT1” followed by CR,¬† that respectively turn OFF and ON the led on PB4. You can read all of the program on the main.c and stm8_interrupt_vector.c files in the project folder. Hope it will be interesting for you. Have fun!

IrSwitch: remote switch uses any TV controller (IR)

After my recent tutorial (in Italian language) for the STM8S microcontroller, I decided to realize a small device using the STM8S001J (8 pins) microcontroller, in order to expand the tutorial itself. This device has a practical application: I don’t live anymore in a B&B, but in a “residence” and I’m going to solve the problems that I face in this new location. The first problem to solve is that I don’t have any switch close to my bed to turn off the lights when I go to sleep. So, I decided to make a remotely controlled switch. Well, I don’t want to build also a remote controller, so I used the one that currently works for the TV.

This remote switch is based on IR reception from any TV controller that has a protocol like the NEC or equivalent. The schematic is very simple as you can see in the picture here below (click this link to download the schematic in PDF format):

The question is: how can I control my switch without disturbing my TV (or viceversa) ? I don’t want to read a specific keycode coming from TV remote; I just want to detect that one key has been pressed (or released), I don’t mind what key.

The algorithm is very simple. Look at these steps:

– define “key pressed” event as an IR burst detected for at least 3mS (the NEC protocol has 4.5mS header, even in repeated keycode). After the header there is the data, followed by a pause (no signal) for at least 20mS.
– define “key released” event as the absence of any “key pressed” event for a certain time.

This part of the algorithm is executed in the TIM4 interrupt (1mS tick). The IRIN is the input connected to the IR receiver TSOP4838 that gives a low output when a 38KHz burst is received.

The next steps are executed in the main program (TimedActions) every 256mS:
– wait for “key pressed” event

If the “key pressed” event arises, the red led turns ON, the state machine goes to the next state and a time counter of 8 * 256 mS is started. In such time no others “key pressed” events must occur or the time counter will be restarted.

– wait for “key release” event

– start a “time window” of 8 * 256mS (with red led blinking) where you can press a key to toggle the remote switch

If a key is pressed in this time, the relay toggles and the state machine immediatly changes to the next step. In any case, this step terminates with the red led off and a delay of 4 * 256mS in which no events are taken.

– close the “time window” and restart from idle

That’s all. The remote switch will be activated by any key pressed on your TV remote control. The red led light will turn on and stay on for all the time you continuously press the key. When you release the key, the red led will blink for 2 seconds and any key pressed in such time will toggle the relay. If you don’t press any key while the led is blinking, the command will be aborted and the cycle will start again. I assumed that when you use the remote control for the TV, you often press the key for a short time (as for program change) or repeatly (such in volume control). Using the “time window” after key released is a good way to activate the remote switch without disturbing the TV and viceversa. If you have on your TV remote control some “special key” that hasn’t any relevant effect on the video, use it ! Obviously, if the TV is turned off, you can use any button excluding the “ON” ūüôā that will turn on the TV set !

The full project folder is available for download from here: IrSwitch. Please, use the 7Z program with password: eficara to decompress it. Look at the STM8 tutorial for the working environment. You have the C sources, so you will be able to improve, modify or completely change the algorithm that I developed for my specific situation. Have fun !

WiFi to IR interface

Last update: 2018-02-25 15:30 (See the note at end)

Once again a project realized in the B&B during my free time, far from home. The circuit described here will be capable to drive almost any device that currently uses an IR remote control, by means of WiFi connection, as to say: with your smartphone. This time I want to show all the route from the idea to the running device. I had the idea some years ago (look at my previous articles regarding IR and WiFi), but I completely forgot it until today.

When I start a new project, there is the first step that I call: “sofa time”. I spend such time lying down on the sofa, without any computer, pen, document or tool. I just think about how to realize the project with the minimal effort.

After this time, I take a block-notes and draw with a pencil (or a pen) a very minimal schematic. In practice, it’s just a brief list of essential connections for the various components that I’m going to use. Here is such minimal schematic:

I don’t need a full schematic, at this time. I will draw it “seriously” with a CAD in the final steps. Well, now I can start building the prototype. First of all I search in my “junk box” what components are available and eventually I change the schematic in order to make it possible to be realized with available components. Usually my laboratory is very complete, but currently I have only few parts, being far from home. This is the prototype, wired on a proto board :

If you are curious to see how this circuit is wired, look at the bottom part :

Note the presence of some SMD components. Sometimes I put such components mixed with the through-hole parts for space saving or just to substitute missing parts of the required value. It’s a simple circuit, but requires soldering skills to be built !

Did you noticed that I used a 16MHz crystal? Did you also noticed that I used a linear 3.3V regulator for powering the microcontroller ATmega88 and the WiFi module ESP-01? Well, there is a mistake ! A 16 MHz crystal is out of specs at 3.3V as you can see in the next picture:

The diagram is taken from the ATmega88 datasheet and says that the maximum crystal frequency at 3.3V is about 13.3MHz, evaluated with dF=(20-10)MHz and dV=(4.5-2.7)V. The nearest value that I have in my junk box is 12.288MHz, then I’m going to replace the component onto the circuit (it will be an easy job).

I plan to power my circuit with a 5V wall adapter, probably a phone charger, but during the tests I will use a Li-Ion battery, just to limit the number of cables on my unfair working place. Note that the LM1117-3.3 IC does NOT stabilize very well with the power supply taken from a Li-Ion battery. Look at this picture taken from the component’s datasheet :

A fully charged battery has 4.2V voltage, so it’s under the minimal dropout at 100mA to have a stable 3.3V output. Consider that the ESP-01 can have current peaks greater than 250mA, so the regulator output may be unstable. This situation will degrade more when the battery discharges to 3.7V (its nominal voltage) and the residual charge is about 10% of the nominal capacity. I used a 100uF capacitor connected to the ESP-01 power lines in order to absorb part of the current spikes in WiFi transmission and if necessary I will increase such capacity. In the “real life” the circuit, powered with a 5V-700mA wall adapter, will work fine ; for this test version I can accept some limitations.

Here is the first version of the circuit schematic (still subject to change):

For a better view, you can download the drawing in PDF format from this link. The pinout for the wifi module ESP-01 in the schematic diagram corresponds to this figure:

Note: if you want to replicate this project, you must program the ESP-01 module to use a 9600 BPS communication speed. There is an AT version created with such default speed on this website: http://wiki.aprbrother.com/wiki/Firmware_For_ESP8266 ; go there and look for ai-thinker- You can also alter (in a permanent way) the current communication speed of your ESP-01 module using AT commands. There are two, that works depending upon the version of firmware installed. Try both of them; the first that gives answer ‚ÄúOK‚ÄĚ is the right one.

For additional information and useful SW tools, take a look at my previous articles here:
Interfacciare il modulo ESP-01 con una porta USB
AT-commands tool

The firmware – Part 1

At this moment I don’t want to write an App to test the device, so the first version of the firmware contains a very basic webserver, just to check if I can connect to the device with my smartphone using the default browser. The first release of the firmware (about 3 KBytes) is available at this link. The file is zipped with password. Use the program 7Z with password: eficara to expand it. The zip contains the .hex file to program the micro and the following image for the fuses map:

When the microcontroller has been programmed, you can try to check if it works. First of all, connect your smartphone to the AP that is presented by the Esp-01 module. You will be informed, obviously, that you are NOT connected to the Internet:

Note that the last 6 characters of the AP SSID will differ from the ones showed in the image, being the representation of last 3 bytes of the MAC address of the module and also the ESP_  part can differ if there is another release of the AT firmware in the module.

After connecting your smartphone to the Esp-01 AP, you can open the default browser and navigate to the single page available on this minimal webserver implementation. Here is an example:The page is always located at (the Esp-01 IP) /cmd.htm (the single implemented web page) and the command ?k= followed by 4 hexadecimal digits. You will receive an html page with the same hex digits. This is just for test purposes. Please note that the hex digits that you will use in your requests must be in capital letters, or you will receive wrong answers:IR protocols – Tools

Now I must indagate the IR protocols that I want to use in this device. Many, many years ago, I realized an IR protocol analyzer under MS-DOS using Borland C and some subroutines in Asm 8086. It worked  with direct I/O control of the pins of a COM port. Here is the hardware I used for IR protocol analysis:

At the left, the “receiver” part ; in the middle, a more recent wired prototype used with a microcontroller and at the right the “transmitter” part, from¬† the same MS-DOS tools suite.

Well, I will NOT present here such old MS-DOS programs because I have found on the internet a great page published by OndŇôej Stanńõk at this link: http://www.ostan.cz/IR_protocol_analyzer/ that has a freely downloadable tool that is much more complete and powerful than mine. It works under Windows and the involved hardware is very simple to build. Here is a screenshot of the program running on my PC:

The software uses the MIC (audio) input of your PC / Notebook to capture the IR signals from a remote controller. You can use a simple photodiode like this :

My interface, mounted on a 3.5 mm stereo jack

Or, if you can’t find the photodiode, you can try with a normal IR emitter (LED) using this circuit. I made it ‘cause I haven’t any photodiode in my “mobile laboratory”, but I have an IR emitter (LED) mounted on a small proto-board. I tested this unconventional circuit on my notebook and after a couple of tries it worked (the previous screenshot was taken with this interface).

Another detector that uses a normal IR LED as receiver. Don’t consider the other components on the board. Those parts are from another circuit !

Here are some audio settings I used on my notebook in order to make it work:

Here is a list of some articles on my website about the IR remote controls:

WM8650 tablet as remote control for Sony TV
Using Android tablet as SIRC remote control (#2)
General purpose infrared remote control receiver with RS232 output
Usare lo smartphone come telecomando TV
Un altro telecomando TV per smartphone Android

The firmware – Part 2

Well, I finished this project or, better, this “proof of concept”. It works, I can control my TV using the browser of my smartphone. The IR protocols used here are NEC and RC5. Due to the low power of IR led, driven directly by uC Port with a single resistor, the distance from the device to the TV (or other apparatus) will be 1 meter max. Add a transistor interface if you want long distance.

Note (Feb, 25 2018): I tested the circuit in the picture below and the distance now is over 3.5 meters. I can’t test if it works over 3.5 meters ‘cause my B&B room is very small !

One reader from Hackaday proposed to use multiple output pins in parallel to drive the IR LED with more power.¬† It’s a good idea, but the software needs to be modified ‘cause I used the SBI I/O,#bit and CBI I/O,#bit instructions respectively to turn OFF (remember, negative logic for LED) and ON the port bit.

Part of the C source (commented ASM listing) – Section: Nec protocol – Xtal: 12.288MHz – Interrupts: disabled

Controlling multiple port bits at the same time needs the OUT I/O,R instruction. Using the OUT instruction also involves to get the port status (in order to save other bits not used for IR led) and save it to 2 different registers, one to be used when you want low level on the IR outputs and the other when you want high level, without affecting the “non IR led” bits. Such approach changes the number of clock cycles needed to generate the 38KHz (Nec) and 36KHz (RC5) frequencies.¬† This is absolutely not difficult to realize, but at this moment I closed my test firmware, so the transistor solution is simpler.

At power-on (reset) the microcontroller automatically sends one command for testing the NEC and RC5 protocol as you can see in the Main procedure.

After sending the test commands, the main procedure loops in the wifi section (function: Parameters) waiting for commands from any browser. The same IR code used in the test procedure can be sent with the smartphone, with the same  effect.

The command 0x0408 (address, 0x04, cmd 0x08) turns on¬† or off the TV in my B&B room ūüôā This is the screenshot of the IR tester, splitted in two parts ‘cause is a bit long:

In the Main procedure there is also a transmission of one RC5 code. This is the screenshot of the actual code set (RC5 is smaller)

Note that in order to send RC5 protocol IR commands, you must use another string in the browser. In place of:¬†cmd.htm?k= you must use: cmd.htm?r= . This informs the firmware that the following 4 characters (hex) must be used as address and command for RC5 protocol, not for NEC. Please, remember that the standard RC5 protocol has 5 bits address (0x00..0x1F) and 6 bits command (0x00..0x3F). Codes out of the limits will be cut out with a simple “and” operation.

Finally, the new release of the firmware. It’s only 3034 bytes long. In the zip file you can find the .hex to burn the micro and a picture of the fuses configuration. Download the file from here and use the program 7Z to expand it. The password is: eficara.

Have fun !

Note (Feb,21 2018): this article was linked by Hackaday and then I’ve seen many comments there about the “unuseful” ATmega88 micro used in my circuit. Someone assumed (wrongly) that I used the Arduino IDE to create this project ! Well, there is a big misunderstanding. May be that someone leaves his opinion before reading the article or simply thinks that reading the article is just an option. Ok, I just want to make clear that I wrote all the firmware in C language (some ASM code was optimized to C) and without using any “pre-cooked” library for ESP-01 or IR functions. All the webserver via AT commands and the IR RC5 and NEC protocols are mine, not copied from other people’s works. I know that the Esp8266 itself is a fully programmable device, but my target was to use a preprogrammed part (Ai-Thinker ESP-01 module with AT firmware) and just control that part how it comes “out-of-the-box”, without any modification, to create my “proof of concept”. I also know that there is a Lubuntu virtual machine (VirtualBox) with the complete environment to develop C language applications for the ESP8266. I have such VM enabled and working on my desktop computer, at home.

Micro PLC – 2 In 2 Out

Questo progetto ha un’origine molto “antica”. Realizzai la prima versione nel 2001 per due prodotti commerciali su microcontrollori Mitsubishi M16C (oggi Renesas). Poi, nel 2007 ne feci una versione molto ridotta con il micro Zilog Z8 ; venne anche pubblicata sulla rivista CQ Elettronica (vedi pubblicazioni e http://ficara.altervista.org/zilog_z8.php#linsem). Successivamente (nel 2013) modificai, semplificandoli ancora, il circuito e il firmware per un amico che aveva la necessit√† di fare dei “programmi” per saldare delle gabbiette di fil di ferro. In sostanza, a lui serviva qualcosa che fosse azionato da uno o due pulsanti e che potesse azionare uno o due rel√® con tempi programmabili per attivare la saldatrice. Per realizzare l’oggetto, utilizzai un display LCD a caratteri 1×16 recuperato da una vecchia centrale d’allarme e un microcontrollore ATmega88 “di recupero”.

Oggi mi ritrovo, dopo qualche anno, ad avere l’esigenza di un dispositivo del genere per me stesso. Ho quindi deciso di “trasportare” il firmware su un nuovo circuito che ha come base una piccola scheda “Nano3” comprata on-line a circa 2 Euro. Il microcontrollore √® l’ATmega328P, che ha molta pi√Ļ memoria del precedente ; tuttavia, ho modificato il programma solo per lo stretto indispensabile, senza sfruttare le pi√Ļ ampie possibilit√† offerte dal nuovo hardware. Anche se la board Nano3 √® venduta come “compatibile Arduino”, il firmware √® scritto esclusivamente in C e viene trasferito nel microcontrollore attraverso il connettore ICSP senza l’uso di bootloader. Nella figura sottostante potete vedere come si presenta l’oggetto:

Appena acceso, il display mostra due opzioni: ESEGUI o SCRIVI. La prima manda in esecuzione il programma che √® stato precedentemente registrato nella memoria EEPROM del microcontrollore ; la seconda ci permette di inserire (scrivere) il nostro programma tramite i pulsantini che vediamo nella foto in alto a sinistra. I pulsanti hanno le classiche funzioni di Up, Down, Left, Right, Ok, Esc con cui si pu√≤ fare praticamente di tutto…

Se ci spostiamo sul campo SCRIVI con il pulsante Right e quindi premiamo Ok, ci troveremo nel men√Ļ di programmazione e potremo quindi scegliere quale programma scrivere. Ce ne sono a disposizione 8, ognuno con un massimo di 32 istruzioni.

Con i pulsanti Up e Down potremo scegliere il numero di programma ; con Ok entreremo nella fase di scrittura delle istruzioni. Vediamo come si compone una linea di programma:

Il programma va da 1 a 8 ed indica una delle 8 sequenze di istruzioni programmabili. Ogni programma pu√≤ avere un massimo di 32 passi, che vanno da 0 a 31. Ogni istruzione occupa 1 byte delle memoria EEPROM del microcontrollore e cos√¨ risulta che l’occupazione massima di tale memoria √® di 8 * 32 bytes, cio√® 256 bytes. Nella EEPROM del micro c’√® quindi parecchio spazio ancora libero per aumentare sia il numero dei passi, sia quello dei programmi. Veniamo ora ai codici operativi, le istruzioni vere e proprie. Sono davvero pochi ! Questo s√¨ che √® un RISC (Reduced Instruction Set Computer) !

Organizzazione dei codici operativi nel file sorgente in C

Vediamo tutti i codici in dettaglio:

- ACCESO   (operando R1 o R2)
- SPENTO   (operando R1 o R2)
- ATTESA-A (operando S1 o S2)
- ATTESA-C (operando S1 o S2)
- RITARDO  (operando da 01 a 99)
- RIPETI   (senza operando)
- FINE     (senza operando)

[ACCESO  ] - è il codice operativo per accendere un relè.
           L'operando può essere R1 (relè 1) o R2 (relè 2).
[SPENTO  ] - è il codice operativo per spegnere un relè.
           L'operando può essere R1 (relè 1) o R2 (relè 2).
[ATTESA_A] - è il codice operativo per attendere che uno
           switch (input) sia aperto.
           L'operando può essere S1 (switch 1) o S2 (switch 2).
[ATTESA_C] - è il codice operativo per attendere che uno
           switch (input) sia chiuso.
           L'operando può essere S1 (switch 1) o S2 (switch 2).
[RITARDO ] - è il codice operativo per attendere un certo tempo.
           L'operando può andare da 01 a 99 ed indica il tempo
           d'attesa in passi da 0.1 Sec.
[RIPETI  ] - è il codice operativo per ripetere il programma a
           partire dalla prima istruzione.
[FINE    ] - è il codice operativo per terminare il programma.

I pulsanti Right e Left servono per muoversi tra i campi Passo, Codice Operativo e Operando, mentre Up e Down per modificare i valori relativi al campo interessato. Il pulsante Ok accetta a salva l’istruzione corrente, mentre Esc termina la programmazione.

Vediamo un paio di esempi:

Programma 2, passo 0: Attesa switch #1 chiuso

Programma 2, passo 2: Ritardo di 40 unità di tempo (40 x 0.1 Sec = 4 Secondi)

Chiaramente, dopo aver scritto un programma, ci verr√† voglia di mandarlo in esecuzione ! Per fare questo, ci sposteremo nella posizione Esegui del men√Ļ principale e premeremo Ok. A questo punto con i tasti Up e Down selezioneremo il programma da avviare (da 1 a 8) e quando sul display comparir√† il numero desiderato, premeremo ancora Ok per avviarne l’esecuzione.

Vediamo ora lo schema elettrico. Per le prove, ho alimentato il prototipo attraverso la presa mini-usb presente sulla Nano3, collegata ad un caricabatterie per telefono. Conviene, per√≤, usare un alimentatore esterno da 6 a 9V collegato al connettore JP1, pi√Ļ che altro per l’affidabilit√† dei contatti. Sulla Nano3 c’√® un regolatore lineare low-drop a 5V con una corrente di uscita sufficiente per questo circuito.

Se stiamo alimentando il circuito attraverso la presa USB e se abbiamo installato il driver per il convertitore USB-Serial presente sulla Nano3 (nel mio caso un CH340G) potremo anche attivare un terminale seriale a 9600,N,8,1 (se non lo avete, qui ce n’√® uno scritto da me). Con il terminale collegato, vedremo che resettando la Nano3 tramite il pulsantino presente on-board, apparir√† la scritta V171217 che √® la release del software (yymmdd – 17 Dic 2017). Per testare anche la trasmissione seriale potremo dare da terminale un ctrl-G (ASCII 0x07) e il buzzer sul circuito emetter√† un beep di conferma.

Per una migliore visione dello schema, è possibile scaricare il file in formato PDF.

Veniamo ora al firmware. Il file da programmare nel modulo Nano3 √® fornito in formato .hex e sar√† inviato al microcontrollore tramite connettore ICSP (6 pin), mediante un tool idoneo. Io uso un mySmartUSB light, ma ce ne sono a decine con prestazioni simili. Come software di “burning” qui ho usato myAvr ProgTool, abbinato al tool hardware.

Per la configurazione dei “fuses”, guardate la riga 11 in questo screenshot del file in C:

Infine, il file .hex può essere scaricato da questo link. Il file è zippato con password. Per decomprimerlo usate il programma 7Z e la password: eficara. Buona sperimentazione !

Your HotSpot is a presence detector

note: USB connector used only to power the circuit

I never connect my devices to “free wifi” hotspots. I’ve seen what a (bad) hacker can do, using one laptop, a battery powered Raspberry PI board and a collection of software tools. He can spy (almost) any smartphone that is connected to the same “free wifi” hotspot.

For this reason, I always use my own LTE 4G connection and my smartphone is always enabled to share such internet connection with my other devices (one laptop, another smartphone and some other) using an access filter based on MAC address of every device. This is more secure than use “free wifi” hotspots and I suggest to everyone the same approach. However, this isn’t the subject of my post.

Having my own hotspot, with the SSID choosen by myself, I can use the smartphone for a lot of nice services. In this article I will describe one of them.

The presence blinker

I’m currently living in a B&B, ‘cause I’m far from home, due to a contract job. When I am in my room, I don’t make too much noise. I just read or write documents; the TV is turned off and also the music is off. So, it happens that other hosts of the B&B, when going out, lock the main door with the key! This makes me a bit claustrophobic! To avoid this unfair situation, I decided to build a flashing light that will be visible from the low side of my room’s door, just to warn the other hosts that I am in my room

I thought about a passive IR sensor, but such devices work only if there is a movement in the room, and I don’t move so often. Also microwave sensors based on Doppler effect work in the same way; they activate the output when there is a movement. Finally, I decided to use my smartphone as a presence detector… I built a small device based on the well known ESP-01 module. This device has an ATtiny2313 microcontroller and a blue led (high luminosity) that blinks when I am in the room (with my smartphone). When my smartphone goes out (with me) the led stops blinking…

The working principle is very simple. The microcontroller sends AT commands to the ESP-01 to get the list of active hotspots in the area. One of such hotspots is my smartphone, so the SSID string is taken and compared with the one programmed in the internal flash memory. If the two strings match, the led blinks; otherwise the led remains off. So simple…

Note that no connection is active between the module and the smartphone; there is only a periodic check of the visible hotspots. This timed check happens every six seconds and the led lights for 250 mS each time (if your SSID is found).

Note that the SSID of your smartphone must be programmed in the flash memory of the microcontroller (the default is “myHotspot_15car”) so I added an application for PC that modifies the original .hex file to change the default SSID to the one that you like. The max number of characters allowed for your SSID is 15. This limit comes from the low amount of ram memory available on the ATtiny2313 microcontroller (just 128 bytes). Remember that you can choose your SSID in the smartphone using the appropriate menu, so write down one that has max 15 characters and the job is done. Another limit imposed by low ram resources (lack of buffers for serial communication), is that you must program the ESP-01 module to use a 9600 BPS communication speed. There is an AT version created with such default speed on this website:


go there and look for ai-thinker- You can also modify (in a permanent way) the current communication speed of your ESP-01 module using AT commands. There are two, that works depending upon the version of firmware installed. Try both of them; the first that gives answer “OK” is the right one ūüôā

For additional information and tools, take a look at my previous articles here:

You could also look at another my article, that was the “starting point” for this project. There you can find a downloadable executable and the relative source program in FreeBasic. It can be useful to better understand how it works. The link is:

Someone can say: “Hey, I can program the same SSID on my smartphone and fool your device so it thinks that you’re in the room, while you aren’t” ! Then I can answer: “so, I will add to my firmware a check of the WPA2 password of my hotspot, that’s invisible to you” ! Such password check option opens the road to many applications where your smartphone will be the key to unlock your car, your door, to turn on lights at home and every thing you want, simply having it near to you. No buttons to click, no Apps to run, just the “native” HotSpot feature active. It’s easy !

In the downloadable file you can find the .hex file that must be programmed in the microcontroller and the .exe that allows you to insert your SSID in the flash memory, prior to program the micro ! The firmware is very small (less than 1 Kb) and has been written in pure C without any special library.

The schematic of the device is simple. Here below there is a picture of it. You can also download it in PDF format for a better view (click this link).

Disclaimer of Liability.
The program or software described, freely downloadable from the site, has to be considered a free “demo” and therefore the author Emilio P.G. Ficara will not provide any support nor will be responsible for any problem, damage, or consequence that may occur during download or execution of the application.

By clicking this link to download the file, you implicitly declare that you have read and understood the non-assumption clause and to accept it.

Always check the MD5 checksum for the files you download! In this case, it must be FC211B2DCBF05C7874489AC32C7D9641 . If it is different, the file is corrupted or is not the original one, so do not unpack it and throw it away! If it is all right, you can unzip it (use the 7Z program with the password: eficara).

You can also run the executable on a USB memory stick as it does not need installation, being a pure executable.

Have fun !!!

Localizzatore GPS con SMS

Aggiornato il 25 Apr 2017 – Finito!
Ho deciso di progettare e costruire un semplice localizzatore GPS dopo un viaggio in macchina. Quando, dopo centinaia di Km di strada, sono arrivato a destinazione, ho parcheggiato l’auto ed ho citofonato alle persone che ero andato a trovare. Ho detto: “Posso lasciare qui la macchina ?” e mi √® stato risposto: “S√¨, c’√® la telecamera”. Bene, avevamo punti di vista diversi sul lasciare l√¨ la macchina! Io intendevo: “d√† fastidio se la lascio qui ?” e loro: “lasciala pure l√¨, che se tentano di fregartela lo vediamo dalla telecamera”… Cos√¨ ho deciso di realizzare questo localizzatore, da nascondere nell’auto quando vado fuori. La mia automobile non √® “preziosa”, ma andare in auto e tornare in treno √®… scocciante!

Inizialmente avevo pensato di realizzare la cosa usando un vecchio smartphone, creando una App in grado di fare ci√≤ che mi serviva; poi, invece, ho deciso di usare un paio di modulini comprati su Internet. Ho sempre scritto volentieri le mie App, che poi ho pubblicato in forma gratuita su Google Play, ma recentemente ne ho dovute cancellare un paio perch√© mi √® arrivato l’avviso di pubblicare una pagina di “privacy policy” a causa dell’uso della telecamera interna del telefono. Ora, l’uso della telecamera era assolutamente “pulito”, non carpivo dati sensibili dell’utente (non me ne pu√≤ fregare di meno), ma la “dura lex” impone di scrivere una pagina in linguaggio “da legali” per avvisare l’utente che scarica l’App dal Market. Allora, dato il mio odio profondo per la burocrazia e per le cose inutili, ho deciso di rimuovere le App coinvolte e di non scriverne altre che richiedano di seguire la vigente normativa europea. In un tempo in cui tutti pubblicano ogni cosa della loro vita, VOLONTARIAMENTE, sui “Social”, le leggi europee sulla privacy mi sembrano delle autentiche fesserie. Purtroppo, per√≤, le multe per inadempienza sono molto, molto salate e quindi io smetto di pubblicare App gratuite e stop.

La struttura hardware

Il localizzatore è molto semplice; usa un modulo GPS con uscita seriale che si compra su Internet a meno di 8 Euro e un modulo GSM M-590 in kit che ho pagato addirittura meno di 3 Euro!  I moduli sono collegati ad un microcontrollore Atmel ATmega48V che gestisce tutte le operazioni necessarie con un apposito firmware che ho scritto in C. Per quanto riguarda il modulo GSM, consiglio di leggere questo mio articolo che lo descrive in modo approfondito. Attenzione: il modulo GSM dovrà essere inizializzato preventivamente (vedi articolo citato, comando: AT+IPR=2400^M^J) per forzare la velocità della porta seriale. Questo è necessario in quanto il micro ATmega48V ha una sola UART e questa è usata per il modulo GPS con protocollo 9600,N,8,1. Ho dovuto quindi implementare una seconda seriale da software e prudentemente ho usato una velocità bassa (2400 BPS) per il GSM.

Se volete ulteriori notizie sul modulo GPS¬†GY-NEO6 MV2, questo √® il link da cui si pu√≤ scaricare il datasheet. Nella figura sottostante potete vedere un esempio dell’output seriale, catturato con il programma di terminale seriale RealTerm impostato a 9600,N,8,1. Le righe evidenziate in giallo sono quelle che vengono usate dal firmware per determinare la posizione (latitude-longitude) attuale.

Il modulo GPS pu√≤ essere utilizzato senza alcuna modifica hardware. La cosa veramente importante √® di non superare mai il limite di 3.6V per l’alimentazione.

Il modulo GSM M-590, invece, arriva in kit (scatola di montaggio) e deve essere costruito. Il montaggio non √® complicato, anche se si tratta di componenti smd. La parte difficile √® saldare i led, che… tendono a rompersi! Quelli forniti con il kit sono molto, molto delicati. Consiglio di comprarne altri in package 0805 e usare molta pazienza e accuratezza nella saldatura. E’ imperativo l’uso di un buon saldatore. Lo schema del modulino √® riportato nella figura sottostante.

Le zone evidenziate indicano le modifiche da fare. Il diodo D2 non sarà montato. Al suo posto si metterà un ponticello. La resistenza R4 da 4.7 KOhm sarà montata sui pin del connettore (vedi figura sotto), così come i condensatori C2 da 100nF e C3 da 22 pF. Il condensatore C1 non sarà montato. In pratica, il modulo sarà collegato al circuito a microcontrollore con 4 fili: Vgsm, GND, GSM_RX e GSM_TX.

Vediamo infine lo schema del circuito a microcontrollore. Come anticipato, si basa sul micro Atmel ATmega48V che ha 4KB di Flash, 256 Bytes di EEprom e 512 Bytes di Ram.

Se volete leggere lo schema con maggior chiarezza, scaricate il PDF da questo link. Nello schema √® prevista l’alimentazione tramite una batteria ricaricabile Li-ion da 3.7V. L’assorbimento del circuito pu√≤ andare da 50 a 250mA, con brevi picchi di 2A in funzione delle varie fasi operative dei moduli GPS e GSM. La durata della batteria, quindi, dipende dalla sua capacit√†. Una cella Li-ion a piena carica ha una tensione di 4.2V e scende a 3.7V quando la carica residua √® circa del 10%. La tensione ideale per l’alimentazione del circuito √® di 3.9V ; funziona anche con qualcosa di meno, ma il rischio √® che il modulo GSM non riesca pi√Ļ ad inviare gli SMS. Notate che alcune batterie Li-ion di formato AA mostrano in etichetta una capacit√† molto elevata, ma spesso questa indica che la cella stessa pu√≤ dare quella corrente, superiore alla nominale, per un periodo limitato di tempo. In pratica, in alcune applicazioni (in genere dove c’√® un motorino elettrico) √® necessario avere un corrente alta per un periodo di tempo breve e allora, queste batterie sono idonee allo scopo. Per un consumo “leggero” e continuativo, invece, bisogna guardare alla capacit√† reale della batteria. Un metodo infallibile per misurare questa capacit√† √® quello di mettere in carica la batteria con una sorgente di cui si conosca l’erogazione di corrente. Facciamo un esempio: se io ho un caricabatterie settato per dare una corrente max di 300mA e la batteria si ricarica completamente in 4 ore, potr√≤ dire con una certa sicurezza che √® una cella da 1200mA (anche se c’√® scritto sopra “4800mA”). Attenzione ! Se alimentate il circuito a batteria, dovete assicurarvi di disconnetterla quando si scarica oltre una certa soglia. Le celle Li-ion, se scendono al di sotto di 2.75V, perdono la capacit√† di ricaricarsi ! Alcuni modelli di celle sono protetti da un circuito interno contro l’over-charge e l’under-voltage, ma questa caratteristica NON √® comune. Gran parte delle batterie low-cost non sono protette, quindi √® compito vostro averne cura…

Se invece vogliamo alimentare il circuito a 12V, possiamo usare un regolatore lineare o uno switching. Nella figura sotto potete osservare lo schema di un regolatore lineare (super collaudato) in grado di fornire 3.9V stabilizzati. Sul regolatore andrà montato un piccolo dissipatore.

La struttura del software

Il software √® scritto in linguaggio C ed √® strutturato in due tasks indipendenti: 1) il gestore del modulo GPS e 2) il gestore del modulo GSM. I due tasks sono non-bloccanti e un watchdog si occupa di resettare il micro qualora uno di essi dovesse restare bloccato per pi√Ļ di 2 secondi.

Il task GPS si occupa di rilevare la posizione Lat – Lon quando il modulo la invia da seriale. Viene utilizzato il record NMEA di tipo $GPGGA, che viene generato quando il ricevitore ha “agganciato” un numero sufficiente di satelliti. I dati vengono salvati in un array di bytes in Ram che sar√† poi utilizzato come testo dello SMS inviato a seguito di una richiesta. Il buffer √® organizzato in modo da contenere la posizione corrente e 5 posizioni precedenti, prese a distanza di 60 campionamenti validi ognuna. In questo modo, se il ricevitore non vede pi√Ļ il cielo, in memoria restano almeno le ultime 5 posizioni valide prima della perdita della visuale. Questa memoria non viene azzerata al reset del micro (l’array √® definito con la clausola __no_init), ma viene solo formattata in modo adeguato. Al primo reset (al power-on) la Ram ha dati casuali e quindi la routine di inizializzazione sostituisce con degli “spazi” ogni carattere fuori range. Se il reset √® a caldo, quindi con il circuito gi√† alimentato, i dati contenuti nel buffer saranno probabilmente validi e quindi l’inizializzazione non apporter√† correzioni.

Il task GSM si occupa di verificare se ci sono chiamate dai numeri abilitati e in caso ci siano, si occupa di inviare un SMS con il testo elaborato dal task GPS, con le coordinate del dispositivo. La prima operazione dopo il reset √® quella di aspettare la stringa “+PBREADY” dal modulo. Questa stringa ci conferma che il modulo √® attivo e registrato sulla rete dell’operatore. La SIM deve essere preparata in modo da non richiedere un PIN per l’attivazione. E’ inoltre opportuno disabilitare ogni servizio non necessario (segreteria, messaggi automatici, ecc). Una volta ricevuta la conferma di registrazione, il software invia al modulo il comando “AT+CLIP=1” che avvia il servizio di identificazione del chiamante. In pratica, quando si riceve una chiamata, oltre alla classica stringa “RING” si riceve un altro messaggio “AT+CLIP:” seguito dal numero di telefono del chiamante. Il numero ricevuto √® comparato con i due numeri abilitati (memorizzati in EEPROM, vedremo poi come) e se il confronto √® positivo il messaggio SMS viene inviato al chiamante quando questo chiude la chiamata (nota: il dispositivo non “risponde” alla chiamata, non ci sono costi addebitati sul telefono che chiama). La chiusura della chiamata viene recepita con il messaggio “NO CARRIER”. Il task quindi invia l’SMS e attende la conferma dell’avvenuto invio e poi riprende il suo ciclo con la fase di attesa di nuove chiamate. Se invece qualcosa va storto, il task esegue un reset del modulo GSM togliendo brutalmente alimentazione al modulo stesso, pilotando un pin di uscita del microcontrollore che √® collegato ad uno switch elettronico realizzato con due mosfet P-N (vedi schema). Questa soluzione pu√≤ sembrare eccessiva e costosa, ma il datasheet del costruttore del modulo M-590 consiglia, in casi in cui non si riesca a ripristinare il modulo con il comando software, di togliere alimentazione… e cos√¨ ho deciso di tagliar corto e di usare questa soluzione comunque, senza perdere tempo con il comando software. Ovviamente, dopo questa operazione di riavvio del modulo, il task GSM riparte dallo stato iniziale, attendendo il messaggio “+PBREADY” prima di ogni altra operazione.

Costruzione ed utilizzo

Come si vede dalla foto del dispositivo in testa all’articolo, non c’√® un circuito stampato per il microcontrollore, ma il tutto √® assemblato su di una scheda “millefori” per prototipi. Data la semplicit√† del circuito e data la natura “sperimentale” del progetto, ho deciso per questa soluzione. I componenti sono pochi e chiunque abbia una certa pratica di costruzioni elettroniche pu√≤ riuscire a realizzare il localizzatore, con un po’ di pazienza. Naturalmente, non √® il progetto ideale per chi √® alle prime armi e non ha la padronanza del saldatore e un po’ di pratica con i prototipi elettronici.

Una volta costruito il circuito, si dovr√† programmare il microcontrollore. Per la programmazione del microcontrollore io utilizzo il programma AvrDude, disponibile a questo link. Troverete, nel file zip di questo progetto, tre files batch che servono a programmare, rispettivamente, la memoria Flash, la EEPROM e i FUSES (fusibili) con la configurazione necessaria per questa applicazione. I files batch prevedono che il programma AvrDude sia installato e raggiungibile con il percorso impostato. Modificate i files batch secondo le vostre esigenze, adattandoli per il percorso dell’applicazione e per il modello di programmatore usato.

1_wrFlash.bat per la programmazione della memoria Flash:

avrdude -P com14 -p m48 -c stk500 -e -U flash:w:localizer.hex

2_wrEeprom.bat per la programmazione della memoria EEPROM:
avrdude -P com14 -p m48 -c stk500 -U eeprom:w:earom-wr.bin

3_wrFuses.bat per la programmazione dei FUSES:
avrdude -P com14 -p m48 -c stk500 -U hfuse:w:0xC5:m -U lfuse:w:0xFC:m

Come si vede dal contenuto dei files batch, il programmatore che uso √® di modello stk500 ed √® collegato sulla porta com14. Le operazioni di programmazione saranno eseguite nell’ordine: 1) scrittura della memoria Flash, 2) scrittura della memoria Eeprom, 3) scrittura dei Fuses.

Per rendere il dispositivo in grado di funzionare, dobbiamo modificare il file earom-wr.bin per inserire i due numeri di telefono che saranno autorizzati a comandare l’invio del messaggio SMS da parte del dispositivo. Vediamo un esempio di tale file aperto con l’applicazione FrHed, scaricabile a questo link.

Evidenziati in giallo ci sono i due numeri. Quelli nell’immagine non sono numeri “veri”, servono solo per far capire dove e come scrivere quelli “reali”. Con FrHed √® possibile modificare i valori sia in ASCII, spostando il cursore di editing sulla finestra a destra, sia in Hexadecimal, spostandolo a sinistra. Il numero programmato dovr√† essere preceduto dal prefisso internazionale, perch√© cos√¨ viene ricevuto dal modulo GSM (vedi esempio sotto).

In pratica, se usiamo un telefono con SIM italiana, il numero inizier√† con 39. E’ fondamentale chiudere il numero con il valore Hex 00, che viene usato come terminatore di stringa dal linguaggio C. Nell’immagine di esempio i due numeri programmati sono: 39 333 1234567 e 39 339 7654321; modificateli secondo le vostre esigenze e quindi salvate il file aggiornato. Ora sar√† possibile trasferire i numeri nella EEPROM del microcontroller eseguendo il file batch WrEarom.bat.

Il file che contiene il firmware del micro √® localizer.hex, che contiene il codice compilato dall’indirizzo 0x0000 a 0x096F. Rimane quindi molto spazio per eventuali aggiornamenti e migliorie.

Una volta programmato il micro, si potr√† accendere il dispositivo. Nello schema potete vedere un connettore di uscita denominato USB SERIAL. A che serve ? E’ uno strumento di debug. Dato che il modulo GPS occupa solo il pin di ingresso della UART del micro, ho pensato di usare quello di uscita come pin di debug. Su questo pin, infatti, viene inviata tutta una serie di messaggi di testo, con protocollo 9600,N,8,1. Quando il modulo GPS determina una nuova posizione valida, i dati “filtrati” vengono inviati sull’uscita di debug e cos√¨ sono visibili su un terminale seriale connesso alla porta. Oltre a questo, anche le comunicazioni con il modulo GPS vengono replicate su questa porta, permettendo cos√¨ di analizzare tutta la comunicazione tra il micro e i due moduli. E’ una “feature” molto importante e molto utile per capire cosa c’√® che non va (se c’√® qualcosa che non va).

Ora portiamo il circuito funzionante all’aperto e facciamo un giro per almeno 5 minuti, cercando di spostarci in modo da avere diverse localizzazioni in memoria. Se siamo pigri, mettiamo il circuito sul terrazzo e lasciamolo l√¨ fermo… Dopo 5 o sei minuti, con uno dei telefoni il cui numero √® abilitato in Eeprom, facciamo una chiamata al numero della SIM contenuta nel localizzatore. Facciamo fare uno o due squilli e poi chiudiamo. Il localizzatore invier√† immediatamente uno SMS di risposta con i dati memorizzati (ci pu√≤ essere un ritardo nella ricezione del messaggio se l’operatore √® “intasato”). Riceveremo quindi un messaggio di questo tipo (ho pixellato alcune cifre per la privacy -la mia-) :

Vediamo in prima posizione la locazione attuale, l’ultima rilevata dal GPS al momento della chiamata. Nelle successive righe ci sono le ultime 5 posizioni memorizzate, in base ad un temporizzatore che agisce ogni 60 localizzazioni valide (record $GPGGA del protocollo NMEA).

Le coordinate ricevute dal modulo sono in formato ggxx.xxxxxN(S) per la latitudine e gggxx.xxxxxE(W) per la longitudine. Purtroppo, se proviamo ad inserire i dati esattamente così come li riceviamo su un programma tipo Maps, non otterremo risultati. Dobbiamo quindi fare un paio di semplici operazioni.

Supponiamo di avere ricevuto questo messaggio: 3804.373568N01538.944818E; le prime cifre (fino a N) sono la latitudine e le ultime (fino a E) sono la longitudine. Per convertire questo formato in uno accettabile per Maps, dobbiamo agire cos√¨: latitudine 3804.373568N dove 38 sono i gradi; ora dividiamo 04.373568 per 60 e otteniamo 0,0728928; in totale, la latitudine risultante sar√†: 38.0728928. Ripetiamo la stessa operazione per la longitudine: 01538.944818E dove 015 sono i gradi; ora dividiamo 38.944818 per 60 e otteniamo¬† 0,6490803; in totale, la longitudine √® 15.6490803. Ora possiamo andare su Maps ed inserire nella barra di ricerca questi numeri:¬†38.0728928, 15.6490803 ed otterremo la mappa della localit√† indicata. Notare, nel formato, che come separatore per i decimali viene usato il “punto”, mentre per dividere i due campi lat – lon viene usata la “virgola”. Per convenzione, la latitudine √® indicata per prima e la longitudine per seconda. Nel nostro esempio abbiamo usato latitudine Nord (N) e longitudine Est (E). Se usiamo il programma in altre parti del mondo, potremmo ricevere dal GPS coordinate S (Sud) e W (West). In questi casi, dovremo inserire un segno “meno” prima della latitudine o della longitudine. In breve, N √® “pi√Ļ” (si pu√≤ omettere) ed S √® “meno”, cos√¨ come E √® “pi√Ļ” e W √® “meno”.

Infine, qui sotto, dopo la clausola di non assunzione di responsabilit√†, trovate il link al file Localizer-v1.zip liberamente scaricabile, che contiene la prima release del firmware. L’applicazione √® stata provata in condizioni “normali” e funziona perfettamente, ma se scoprir√≤ errori nascosti, far√≤ le opportune correzioni e pubblicher√≤ l’aggiornamento.

Clausola di non assunzione di responsabilità.
Il programma o software descritto, liberamente prelevabile dal sito, √® da considerarsi una ‚Äúdemo‚ÄĚ gratuita e pertanto l‚Äôautore Emilio P.G. Ficara non fornir√† alcun supporto, n√© si assumer√† alcuna responsabilit√† per ogni eventuale problema, danno o conseguenza che dovesse presentarsi nel download o nell‚Äôesecuzione dell‚Äôapplicazione.

Cliccando questo link per effettuare il download del file implicitamente dichiarate di aver letto e capito la clausola di non assunzione di responsabilità e di accettarla.

Verificate sempre il checksum MD5 dei files che scaricate ! In questo caso deve essere: F0E6090B3CB2A96E4FEF0C5D5A0BB131 ; se è diverso, il file è corrotto o non è quello originale, quindi non scompattatelo e buttatelo via ! Se invece è tutto ok, potete scompattarlo (usate il programma 7Z e la password: eficara).

w5500 Рrelè controllato da Internet

‚ÄĒ aggiornato il 19 Mar 2017 – finito! ‚ÄĒ
Correva l’anno 1997. In Ottobre decisi di fare un contratto con il locale provider di Internet. Nella mia cittadina di 19mila abitanti (allora), il provider (l’unico) aveva 3 (dico tre) modem, e quindi il massimo numero di connessioni contemporanee era… tre. E bastavano ! S√¨, a qualsiasi ora si riusciva a trovare un modem libero. Si pagavano sia l’abbonamento al provider, sia la telefonata. Eravamo in pochi, davvero.

Durante le prime navigazioni, finii sul sito di una universit√† in Australia. Il sito aveva tre telecamere (B/N) che inquadravano un piano di lavoro a tre assi X,Y, Z con un braccio che poteva essere comandato via web (a linea di comando) per muoversi e afferrare dei pezzi (costruzioni per bambini) per costruire qualcosa. Ne rimasi affascinato e mi meravigliai di cosa si potesse fare cos√¨, da una parte all’altra del mondo. Fu una rivelazione e decisi che mi sarei messo a studiare come fare anch’io qualcosa del genere. Ammiravo quelle persone che erano cos√¨ competenti da aver realizzato questa cosa fantastica, mentre io non sapevo ancora niente di Internet e dei vari protocolli coinvolti. Mi misi quindi a studiare e dopo qualche mese, nella primavera del 1998, realizzai il mio primo “rover” controllato via Internet tramite un web browser (c’era Internet Explorer 3 e prima bisognava lanciare lo stack TCP con Trumpet). Il mio rover aveva a bordo una telecamera B/N del Game Boy, collegata ad un microcontrollore Mitsubishi (ora Renesas) M16C che aveva ben 20KB di RAM interna ! L’immagine, da 128×128 pixel, veniva inviata dal rover al PC (su cui girava il mio piccolo web server elementare) tramite un modulino RTX a 866 MHz. Funzionava ! Era primitivo, goffo, lento, rispondeva con una decina di secondi di ritardo, ma funzionava !

My first Rover, built in 1998, controllable via a standard browser on the Internet.

Oggi abbiamo una situazione leggermente diversa. Si parla sempre di IoT e io pensavo che fosse “Internet of Thieves” perch√© come clicchi il bottone sbagliato ti svuotano la carta di credito. Invece NO, pare che tutti i dispositivi di casa vogliano davvero collegarsi a Internet, per darvi una vita migliore (???).

Bene, a prescindere dalle considerazioni filosofiche, abbiamo molte diverse possibilit√† per controllare un rel√® in casa tramite Internet. Ci sono apparecchi professionali o anche da hobbisti che fanno gi√† questa cosa ; se non avete tempo da perdere, compratevi uno di questi dispositivi gi√† pronti e via…

Per comandare un rel√® da remoto, dobbiamo creare una connessione Internet tra il ricevitore (il dispositivo con il rel√®) e il trasmettitore (un PC o un Tablet o uno Smartphone). Possiamo creare una connessione Server-Client HTTP, ma dovremo fare un abbonamento ad un servizio tipo dyndns, per avere un “nome” con un IP “statico” a cui collegarci. Dovremo inoltre programmare il nostro modem / router in modo che vada ogni tanto ad aggiornare il servizio dyndns. Inoltre, sar√† necessario aprire una “porta” che lasci passare, sul firewall incorporato nel modem / router, il traffico “in-going” verso il server.

Se non vogliamo fare tutto questo, potremmo creare un dispositivo che si comporta da MQTT subscriber, cio√® mettere un client MQTT sul nostro dispositivo ed utilizzare un “broker” pubblico per fare la connessione. Per√≤ i broker pubblici e gratuiti non sono garantiti per funzionare sempre e poi dovremo comunque usare un client MQTT anche sul dispositivo di comando (PC, Tablet, Smartphone) per modificare lo stato del nostro rel√®. Il vantaggio di questa soluzione √® che non dobbiamo eseguire alcun settaggio sul modem / router e l’attivazione / disattivazione del rel√® √® praticamente immediata dopo aver azionato il comando “Publish” su PC / Tablet / Smartphone.

Poi, c’√® la soluzione che ho deciso di adottare per questo esperimento. Non dovremo aprire porte sul router o fare un abbonamento a dyndns, ma ci serve un nostro sito web personale, in grado di eseguire scripts PHP.

I siti web gratuiti sono molto diffusi. Questo articolo che state leggendo √® pubblicato su un hosting gratuito. Se andate su: https://it.altervista.org/ potete farvi un sito gratis, con un ottimo servizio e molti tools. Nella descrizione di questo esperimento, per√≤, far√≤ riferimento ad un altro web hosting gratuito che √®: http://www.freewebhostingarea.com/ . Cercate on-line la soluzione che pi√Ļ vi aggrada. L’unica cosa importante √® che ci sia la possibilit√† di far girare scripts PHP. Quindi, il prerequisito per andare avanti √® quello di avere lo spazio web. Preso lo spazio, ci dobbiamo mettere dentro un po’ di cose. Useremo un client FTP per accedere ai nostri files, con le credenziali che ci saranno fornite dal web hosting. Di solito, come client FTP, io uso WinSCP (sotto Windows) e quindi gli esempi che seguiranno si basano su questo tool.

Sì, ma come funziona ?

Il funzionamento √® veramente semplice. Il nostro rel√®-box, con il chip w5500, andr√† ogni 3 minuti a caricare dal nostro sito un file che si chiama cmd.htm ; il contenuto (minimale) di questo file √® una semplice stringa di testo che pu√≤ essere #On oppure #Off. In funzione di questo valore, il rel√® si accender√† o si spegner√†. Pi√Ļ facile di cos√¨…

Dato che il nostro rel√®-box va a fare il “polling” ogni 3 minuti, avremo un certo tempo di latenza, cio√®, nel caso peggiore, dovremo aspettare 3 minuti perch√© il nostro comando ON o OFF venga recepito e quindi il rel√® assuma lo stato desiderato. Questo √® uno dei limiti del sistema, ma per un’applicazione generica, tipo quella di accendere le luci di casa per scoraggiare i ladri, √® accettabile.

Ora, chi √® che modifica il file cmd.htm in modo da far cambiare stato al rel√® ? Ci pensa uno script PHP che risiede sul nostro sito. Con un qualsiasi browser, su un qualsiasi dispositivo connesso ad Internet, inseriamo l’indirizzo del nostro sito e navighiamo. Facciamo un esempio:¬† abbiamo creato il nostro sito come ilmiosito.eu5.org ed abbiamo salvato sulla root tutti i files necessari (li trovate pi√Ļ avanti). Ora, avviamo il browser sul nostro dispositivo e scriviamo nella barra degli indirizzi : http://ilmiosito.eu5.org/remote e diamo l’invio. Ci troveremo su una pagina di accesso protetta da password.

A sinistra vediamo la schermata di accesso. Dovremo inserire il nostro nome utente e password, cos√¨ come sono stati salvati sul file .htpasswd . Una volta inserite le credenziali ci troveremo con la schermata a destra. Toccando l’icona #On vedremo il men√Ļ di selezione con le due opzioni possibili:

Selezioniamo, ad esempio, #Off e quindi premiamo “invio”. Se tutto √® a posto, il file cmd.htm sar√† modificato e vedremo la schermata a destra che ci conferma che non ci sono stati errori. Vediamo quindi la struttura del nostro sito web :

Non c’√® molta roba… Abbiamo una sottocartella chiamata “remote” e due files. La pagina web index.htm √® semplicemente quella principale del sito “in costruzione”, mentre cmd.htm √® quella che sar√† richiamata dal nostro rel√®-box per sapere quale stato deve assumere il rel√®. A seconda del web hosting utilizzato, potremmo avere un errore di scrittura quando cerchiamo di modificare lo stato del rel√®. Ci√≤ √® dovuto ai permessi di scrittura del file cmd.htm sul server. Per modificare tali permessi, usando WinSCP, basta cliccare sul file cmd.htm (nella cartella remota) con il tasto destro del mouse e poi su properties, come nell’immagine (a seconda del server, sar√† 644, 664 o 666) :

I files che ci permettono di fare l’accesso con password sono due: .htaccess e .htpasswd. Il primo informa il server sul fatto che la directory dove esso stesso √® contenuto ha l’accesso limitato. Il suo formato sar√† questo:

E’ importante dare il percorso completo (path) giusto per il file .htpasswd, quello che contiene la lista di utenti / passwords autorizzati all’accesso. Se il percorso non √® corretto, riceveremo un errore dal server, tipicamente il #500. La riga evidenziata di giallo andr√† modificata con il percorso completo del vostro sito, naturalmente. Per l’editing di tutti i files di testo, io uso il programma Geany, che √® gratuito e fondamentale anche per programmare in diversi linguaggi.

Il secondo file, quello chiamato .htpasswd, contiene, come detto, username e password per i vari utenti abilitati, uno per linea. Nella figura sotto vediamo il file di default che ha l’utente: user e la password: password (che fantasia !)

La password non √® “in chiaro”. Per creare le password con la cifratura standard, possiamo usare vari tools presenti su internet. Ne ho uno anche io sul mio sito a questo link : http://robotop.eu5.org/php/pswmaker.php. Inserendo user e password e cliccando Encrypt si otterr√† la linea da inserire, con copia-incolla, nel proprio file .htpasswd.

Il file index.php nella cartella remote √® quello che fornisce la pagina di accesso, con la lista #On / #Off e il pulsante Invio. La destinazione del form √® lo script PHP chiamato write.php, che si occupa di modificare il file¬†cmd.htm sulla cartella principale. E’ tutto qui. Se ogni cosa √® stata fatta bene, potremo testare il corretto funzionamento del sito e osservare se puntando con il browser sul file cmd.htm leggiamo #On o #Off in seguito alle nostre operazioni. Se tutto √® OK, possiamo passare all’elettronica e alla scatoletta rel√®-box con il w5500.

I files per realizzare il sito web “minimalistico” sono in uno zip scaricabile dal link che trovate qui sotto.

Clausola di non assunzione di responsabilità:
Il programma o software descritto, liberamente prelevabile dal sito, √® da considerarsi una ‚Äúdemo‚ÄĚ gratuita e pertanto l‚Äôautore Emilio P.G. Ficara non fornir√† alcun supporto, n√© si assumer√† alcuna responsabilit√† per ogni eventuale problema, danno o conseguenza che dovesse presentarsi nel download o nell‚Äôesecuzione dell‚Äôapplicazione.
Cliccando questo link per effettuare il download del file ilmiosito.zip implicitamente dichiarate di aver letto e capito la clausola di non assunzione di responsabilità e di accettarla.

Verificate sempre il checksum MD5 dei files che scaricate ! In questo caso deve essere: 7C5D035C9EDE39827ED747E5DBCE5895 ; se è diverso, il file è corrotto o non è quello originale, quindi non scompattatelo e buttatelo via ! Se invece è tutto ok, potete scompattarlo (usate il programma 7Z e la password: eficara).

Hardware e firmware

Veniamo ora al circuito e al firmware di quello che da ora in poi chiameremo, per brevità, RBox (Relay Box). Dallo schema si nota che è del tutto simile a quello presentato nel precedente articolo Esperimenti con W5500 con la sola aggiunta del relè e di un diodo di protezione.

Per una visione pi√Ļ dettagliata, √® possibile scaricare il file in formato PDF da questo link. Qui sotto c’√® una foto del prototipo modificato con il rel√®. Ho usato un rel√® a 5V con una bobina da 167 Ohm, preso da un vecchio circuito telefonico.

Come nei precedenti esperimenti con il chip W5500, sarà possibile personalizzare il firmware mediante un programma su PC (Windows) che modifica il file HEX usato per programmare il microcontrollore ATmega88. Rispetto a prima, sono stati aggiunti dei nuovi parametri, come si vede dalla figura:

Il microcontrollore usato √® un ATmega88, ma se si eliminasse la sezione di firmware che fa da debug / monitor (sulla seriale), si potrebbe tranquillamente utilizzare un ATmega48, con la met√† di memoria Flash e Ram ; per quanto riguarda la EEprom, questa non √® usata affatto. Per l’utilizzo del programma di personalizzazione, rimando a quanto scritto nel precedente articolo (Esperimenti con W5500). A parte i campi in pi√Ļ, il funzionamento √® identico.

Il flusso di programma

Il programma è molto semplice. Vediamolo nelle sue fasi successive :

:: al reset il micro legge i parametri dalla memoria flash e li scrive nel chip W5500 e nei buffers di Ram che saranno utilizzati nei comandi successivi, quindi avvia la procedura principale, programmando il primo evento temporizzato dopo 5 secondi. Durante tutti i tempi di attesa, il led lampeggia con cadenza di circa un secondo..

:: appena il contatore del tempo arriva al valore impostato per l’evento temporizzato, parte la prima fase di connessione ad Internet, che consiste nell’interrogazione del server DNS il cui IP √® stato impostato nei parametri programmabili. Di default questo IP √® che √® il DNS server di Google. Viene quindi aperto un socket UDP sulla porta 53 e viene inviata la richiesta con la URL del nostro sito web, quella impostata nei parametri programmabili. Se tutto va bene, riceviamo l’IP del web server e questo viene salvato in un buffer in Ram che costituisce l’indirizzo IP di destinazione per le operazioni successive. Se invece ci sono problemi, il programma riparte dalla fase iniziale.

:: una volta ottenuto l’IP del nostro web server, il programma inizia una connessione HTTP GET a tale indirizzo IP, usando nello header (come Host:) l’URL del server e come PATH la restante parte dell’indirizzo. Ad esempio, l’URL sar√† ilmiosito.eu5.org e come PATH ci sar√† /cmd.htm. La porta di destinazione sar√† ovviamente la 80, dato che facciamo una connessione a un server web. Se tutto va bene, riceveremo un pacchetto di dati che contiene la pagina web a cui abbiamo fatto riferimento ; verr√† quindi analizzato il testo tra i tag <html> e </html> per vedere se c’√® il comando #On oppure #Off. Se tutto va bene, il rel√® sara impostato di conseguenza ; se invece ci sono errori, il ciclo comincer√† di nuovo. In caso di esito positivo, tutto il ciclo sar√† riavviato, ma con il tempo del prossimo evento settato a 3 minuti. Nel frattempo, il led continuer√† a lampeggiare.

Durante tutte le fasi, sulla porta seriale (con protocollo 9600,N,8,1), viene prodotto il log delle operazioni eseguite. Collegando alla porta di debug una interfaccia USB-TTL e avviando un programma di terminale seriale (se volete, ce n’√® uno di mia creazione nel file di download), sar√† possibile effettuare un efficiente debug ed eventualmente intervenire per modificare alcuni valori.

I comandi da seriale sono aumentati, rispetto alla versione precedente (Esperimenti con W5500). I nuovi comandi sono:

: : (trattino) ferma l’applicazione che effettua automaticamente la richiesta DNS e l’HTTP GET e quindi il sistema rimane in attesa di comandi da seriale.

: 1 : (cifra 1) accende il relè

: 0 : (cifra 0) spegne il relè


Tutti i files necessari per programmare il microcontrollore sono contenuti in uno zip che potete scaricare liberamente. Il contenuto della cartella è questo:

Analizziamo i vari files:

1_wrFlash.bat √® un file batch per lanciare l’applicazione avrdude per programmare la memoria Flash del micro. Le impostazioni per il mio programmatore sono: porta=Com14 e tipo=STK500. Modificate i valori per le vostre esigenze.

2_wrFuses √® il batch per programmare i “fuses” del micro.

com3-9600.bat è il batch per avviare il terminale seriale miterm sulla Com3 a 9600 BPS. Modificatelo per le vostre impostazioni.

miterm.exe √® l’eseguibile che fa da terminale seriale. L’ho scritto in FreeBasic e gira anche su una chiavetta USB, non serve installazione.

rbox.hex è il file originale in formato intel-hex che viene usato come base di partenza dal programma di personalizzazione.

rbox-mf.hex è il file in formato intel-hex che è stato modificato tramite il programma di personalizzazione. Sarà utilizzato per programmare il microcontrollore.

RBoxprog.exe √® l’applicazione per Windows che consente di modificare i parametri del firmware per personalizzarlo secondo le proprie esigenze. Anche questo l’ho scritto in FreeBasic e gira anche su una chiavetta USB, senza installazione.

Clausola di non assunzione di responsabilità:
Il programma o software descritto, liberamente prelevabile dal sito, √® da considerarsi una ‚Äúdemo‚ÄĚ gratuita e pertanto l‚Äôautore Emilio P.G. Ficara non fornir√† alcun supporto, n√© si assumer√† alcuna responsabilit√† per ogni eventuale problema, danno o conseguenza che dovesse presentarsi nel download o nell‚Äôesecuzione dell‚Äôapplicazione.
Cliccando questo link per effettuare il download del file implicitamente dichiarate di aver letto e capito la clausola di non assunzione di responsabilità e di accettarla.

Verificate sempre il checksum MD5 del file scaricato ! Questo deve essere: 632CA2A7244552F141384D70A6975971 ; se è diverso, il file è corrotto o non è quello originale. In questo caso, non scompattatelo e buttatelo via !
Se invece è tutto ok, potete scompattarlo (è richiesta una password che è: eficara).

Considerazioni finali

Alcune cose importanti da considerare : il dispositivo √® “sicuro” ? NO! E’ possibile intercettare i dati (user e password) quando date il comando sul sito web, dato che non si effettua una connessione sicura HTTPS. Inoltre, ci sono altri metodi per dirottare le richieste DNS in modo da andare a prendere la pagina web cmd.htm da un’altra parte (un sito fittizio). Questo √® un esperimento, un esercizio e perci√≤ la sicurezza √® limitata. Tenete presente, per√≤, che anche i sistemi “professionali” hanno le loro vulnerabilit√†. Ricordate che anche i server dei BIG dell’informatica vengono attaccati con successo dagli hackers “cattivi”, cos√¨ come i siti istituzionali di potenti Nazioni. Un vecchio detto dell’informatica afferma: “un computer sicuro √® un computer con la spina staccata, chiuso in una cassaforte di cui si sono perse le chiavi“. E’ la pura verit√†. Un altro detto che fa parte della mia filosofia di vita (e di progettazione) √® “non usare un cannone per sparare alle zanzare” e quindi usate gli strumenti adeguati in funzione dello scopo da raggiungere. Se avete in casa gioielli per 5mila euro, non comprate un impianto antifurto da 50mila euro, tanto per intenderci. In questo caso, per accendere e spegnere da remoto le luci di casa, mentre siamo fuori per il week-end, il circuito proposto va pi√Ļ che bene. Ricordate che la migliore sicurezza si ottiene con… la segretezza! Non fate pubblicit√† ai vostri controlli remoti, non parlatene con gli amici al bar, non date username e password ad altri, non usate il WiFi pubblico per inviare informazioni personali e… forse sarete al sicuro!

Il sistema descritto in questo esperimento pu√≤ essere usato, naturalmente, anche per conoscere da remoto lo stato di uno switch, la temperatura di un ambiente o qualsiasi altro valore. Se continuer√≤ a fare esperimenti, pubblicher√≤ un nuovo articolo a questo proposito. Al momento, penso di non farlo perch√© sto dedicando tutte le mie energie alla ricerca di un nuovo lavoro. E’ complicato, sia in Italia che all’estero. Incrocio le dita…

Esperimenti con W5500

aggiornato il 7 Mar 2017- Finito !
Dopo aver progettato alcuni dispositivi con i modulini WiFi basati sul componente ESP8266, ho deciso di passare in modalit√† “wired”, perch√© mi hanno fatto notare che molte persone spengono la sezione WiFi del modem / router quando non serve loro per “navigare” e quindi gli eventuali dispositivi di domotica basati su wireless diventano inutilizzabili !

A questo punto, ho deciso di realizzare una versione dei miei dispositivi anche su wired LAN e ho quindi cercato un componente adatto. Ci sono diverse opzioni, ma dopo alcune considerazioni su costi e reperibilità ho deciso di puntare sul chip W5500.

Il sito del produttore mette a disposizione una vasta e accurata documentazione, sia per l’hardware che per il software. Ci sono librerie software aggiornate e molti esempi relativi alla gestione dei vari protocolli, ma (come sempre) io ho deciso di studiare il datasheet del componente e scrivere i miei programmi di test a partire da zero.

Per cominciare a fare delle prove pratiche, ho comprato on-line un modulino che ospita il componente, con il minimo essenziale di hardware per la connessione al microcontrollore esterno e alla rete LAN.

A destra il modulo collegato con un flat-cable al micro; a sinistra il dettaglio del pinout

Purtroppo, non ho potuto riutilizzare nulla del software scritto per i moduli ESP-01, ESP-07 eccetera, perch√© il W5500 ha un’architettura e una modalit√† di pilotaggio completamente diversi. Intanto, dal punto di vista hardware, la connessione avviene tramite SPI (quindi una seriale sincrona) e non tramite UART ; poi, lo stack TCP embedded richiede una programmazione a un livello pi√Ļ basso, una gestione dei “socket” un po’ pi√Ļ complessa.

Per questa prima parte dell’esperimento ho riciclato una mia vecchia scheda, basata sul microcontrollore Atmel ATmega88, che avevo realizzato in passato per pilotare il noto ENC28J60 della Microchip. Dato che anche quel chip si pilotava tramite SPI, ho rimosso l’integrato (che era in versione DIP e montato su zoccolo) e ho collegato i vari segnali della seriale sincrona al connettore del modulino W5500. Ho cos√¨ potuto riutilizzare anche la parte di software che gestiva la comunicazione SPI. Il circuito di prova si presenta cos√¨ :

Il primo prototipo: scheda con micro ATmega88, modulo W5500 e interfaccia USB-TTL per il debug del programma.

Lo schema elettrico della scheda a microcontrollore, modificato e semplificato dalla versione originale con il chip ENC28J60, è questo:

Per una visione pi√Ļ dettagliata, √® possibile prelevare il file in formato PDF da questo link.

Come si vede dalla nota sullo schema, al momento attuale le linee di I/O del micro che non sono state utilizzate sono “floating”, in attesa di definire un hardware aggiuntivo, ma a progetto finito ogni linea non usata deve essere opportunamente collegata ad un riferimento. Tipicamente, dato che il micro al reset pone tutto l’I/O in condizioni di Input (alta impedenza), √® possibile collegare tra loro tutti i pin inutilizzati ed usare una resistenza sola per collegarli tutti a GND. Ovviamente, nella fase di inizializzazione delle linee di I/O del firmware, bisogna tenere conto di questa soluzione circuitale.

Breve descrizione del componente

L’integrato mette a disposizione del progettista un completo stack TCP, con 8 sockets indipendenti e un’area di memoria RAM dedicata. Il controllo del funzionamento avviene scrivendo o leggendo alcuni registri e aree di memoria tramite interfaccia seriale sincrona SPI. I blocchi di memoria sono tre:

Common Register Block, dove troviamo i registri di controllo
Socket Register Block, dove troviamo i registri relativi agli 8 Sockets
Memory, dove troviamo i buffers di lettura / scrittura degli 8 Sockets

La seriale SPI pu√≤ essere usata in modo da leggere / scrivere una quantit√† fissa (1,2,4 bytes – FDM) o variabile (n Bytes – VDM) di dati. Per utilizzare quest’ultima modalit√†, √® necessario pilotare la linea /CS (Chip Select) per informare il chip dell’inizio e fine di uno stream di dati. Nel mio progetto ho usato esclusivamente questa modalit√†. Uno stream di scrittura / lettura √® costituito da tre fasi: Address Phase, Control Phase, Data Phase.

Nella Address Phase vengono inviati 2 bytes che costituiscono l’indirizzo di offset rispetto all’origine del blocco di memoria selezionato ; nella Control Phase viene inviato un singolo byte che indica il blocco di memoria che si vuole selezionare, il modo RD / WR e la modalit√† FDM / VDM ; ¬† infine, nella Data Phase vengono scritti o letti i dati (quindi, in caso di modo VDM questa fase ha un numero variabile di bytes).

Per poter effettuare una qualsiasi operazione √® necessario inizializzare alcuni registri principali. Al reset il chip assegna dei valori di default ; molti di questi non avranno bisogno di essere modificati, perch√© sono i pi√Ļ adatti ad un funzionamento normale. Per esempio, i registri che determinano la quantit√† di memoria RAM assegnata agli 8 sockets vengono inizializzati con il valore di 2K Bytes. Cos√¨ facendo, avremo lo spazio di memoria uniformemente distribuito tra gli 8 sockets, per un totale di 16K Bytes in scrittura e altrettanti in lettura. Naturalmente lo spazio di memoria pu√≤ essere distribuito in modo differente, purch√© si rispetti la quantit√† massima di RAM disponibile che √®, appunto, di 16K Bytes per i buffers di TX e 16K Bytes per quelli di RX.

L’accendiamo ? S√¨, l’accendiamo !

Bene, il circuito c’√®, partiamo con il primo step: colleghiamo il nostro dispositivo alla LAN e proviamo a vedere se risponde al “ping”. Come al solito, non ho utilizzato “librerie precotte”, ma ho scritto il programma a partire dallo studio di ci√≤ che mi serve, riflettendo bene sul minimo indispensabile per raggiungere lo scopo. Non mi piace l’approccio che (purtroppo) ha preso piede negli ultimi anni, cio√® quello di fare strutture di software immense e poi definirle “scalabili”. Questo “scalabile” spesso significa che se a me serve solo una minima parte, devo prendere un grosso blocco e poi togliere quello che √® in eccesso. Nella mia lunga esperienza ho potuto appurare che si fa molto prima a scrivere da zero l’essenziale che non a togliere il 90% dell’inutile ; √® come costruire una¬† tazzina da caff√® partendo da un blocco di marmo di due metri di lato, con grande fatica di scalpello e martello. Io, preferisco usare una “stampante 3D” e creare ci√≤ che mi serve usando solo il materiale necessario.

Il nostro dispositivo si collega ad una rete LAN, tipicamente fornita dal modem / router che ci connette al provider. Teniamo presente che il chip w5500 non ha protocolli gi√† pronti, ma ci mette a disposizione alcuni sockets TCP / UDP e poi… il protocollo lo dobbiamo scrivere noi ! Dunque, non c’√® un DHCP pronto all’uso e quindi programmeremo nei registri interni del chip un IP statico, che sar√† quello che poi proveremo a “pingare”. Un altro importantissimo dato da scrivere nei registri √® l’indirizzo fisico del nostro dispositivo, comunemente chiamato MAC address. Il MAC address √® costituito da 6 bytes; i primi tre identificano il produttore dell’hardware ed i secondi tre sono a discrezione del produttore, che li codifica nel modo che pi√Ļ gli aggrada, mantenendo per√≤ l’univocit√† della terzina. Particolarmente importante √® il primo byte della prima terzina e in particolare, di questo, il secondo bit meno significativo. Questo bit, infatti, determina se il MAC address √® OUI (Organizationally Unique Identifier) oppure se √® “locally administered”. In pratica, se il primo byte del MAC √® xxxxxx1x, il dispositivo non appartiene ad una delle industrie registrate come produttori, ma √® amministrato localmente. L’ultimo bit (il meno significativo) del primo byte determina se la connessione √® multicast o unicast. Noi useremo solo unicast e quindi questo bit sar√† sempre a zero.

Un trucco per creare un indirizzo fisico OUI, che ho visto usare nei tablets cinesi “very cheap” di prima generazione (nel 2011), √® quello di utilizzare come MAC del tablet quello del router a cui ci si collega, modificando l’ultimo byte di +1 o -1. Ingegnoso, ma non si dovrebbe fare ! Se volete sapere qual √® il MAC del vostro router e usare lo stesso trucco, potete usare il comando ARP da finestra DOS di Windows.

Questo comando chiede al sistema di restituire il MAC address (attraverso il protocollo ARP) del dispositivo che ha IP (tipicamente il router di casa). Gli altri due dati essenziali da programmare nei registri del W5500 saranno l’IP del Gateway (il nostro modem / router) e la Network Mask. Tutti questi dati risiedono nella memoria flash del micro ATmega88, allocati in modo statico con questa assegnazione:

Come si vede in figura, alla locazione 0x0EC0 troviamo 64 bytes di memoria flash riservati ai dati per la personalizzazione del dispositivo. Si noti che c’√® un solo byte definito nel sorgente in ‘C‘ ! Questo serve unicamente a far generare dal compilatore una linea nel file di uscita raslan.hex con il riferimento all’indirizzo 0x0EC0. Poi, sar√† un’applicazione su PC ad aggiungere al file .hex i dati personalizzati. Ecco come si presenta la schermata iniziale di tale applicazione:

Nella finestra in alto a destra potremo scrivere, un dato per riga, i valori corretti per personalizzare il nostro dispositivo in funzione della rete a cui dovremo collegarlo. Il programma, quando si clicca il pulsante [ Modify HEX file ], genera un nuovo file chiamato raslan-mf.hex che contiene, nell’area flash dedicata, i parametri personalizzati. A questo punto potremo usare tale file per effettuare la programmazione del microcontrollore.

In questa prima versione di programma, il micro invia su porta seriale (9600, N,8,1) i parametri letti dalla propria memoria flash. Dopo aver trasmesso ogni messaggio,  il micro scrive i medesimi dati nei relativi registri del w5500 e quindi resta in attesa di comandi da seriale o di richieste ICMP Ping.

Come si vede nel listato, la prima operazione che viene effettuata sui registri è la lettura della versione del chip. Il w5500 risponde con il valore 04. Questa lettura è utile anche per verificare che le routines di lettura/scrittura tramite SPI siano efficaci. Di seguito, troviamo la scrittura dei vari parametri di cui abbiamo parlato.

Colleghiamo ora un convertitore USB-Seriale al circuito e lanciamo un programma di terminale seriale. Nel file zip messo a disposizione per il download troverete anche un mio piccolo programma di terminale, che potrete utilizzare per visualizzare l’output del micro e per inviare comandi. In questa primissima release del software, l’unico comando accettato da seriale √® il carattere ‘+’ che provoca un reset da watchdog del micro, facendo quindi ripetere la procedura di inizializzazione. Ecco cosa leggiamo sulla finestra del terminale:

A questo punto vedremo il led rosso del circuito mandare un piccolo lampeggio ogni 3 secondi, segno che tutto gira regolarmente. Dall’immagine precedente vediamo che il Device IP √® settato a e quindi proviamo a fare un ping da un computer collegato sulla stessa sottorete. Il risultato sar√† questo:

BENE ! Il circuito risponde al Ping ! Il primo passo √® fatto ! I registri sono stati inizializzati correttamente. Possiamo ora, per prova, lanciare di nuovo il programma w5500prog.exe per modificare i parametri e riprogrammare il micro con un altro Device IP. Quindi, possiamo provare a “pingare” il nuovo IP e vedere se ci risponde (lo far√†).

Nota importante: quando si programma la memoria flash del micro, si devono anche settare i “fuses” secondo questa configurazione: Hfuse: 0xCD Lfuse: 0xFC Efuse: 0xF9.

Nel file w5500-v1.zip messo a disposizione per il download troverete questi elementi:
miterm.exe – il terminale seriale
raslan.hex – il file hex di base, senza parametri
raslan-mf.hex – il file hex con i parametri, da usare per programmare il micro
w5500prog.exe – l’applicazione per modificare i parametri

La prova del Socket

Finita questa primissima prova, cominciamo la seconda e ultima parte dell’esperimento: la prova di un “socket” TCP. Per dare un po’ di flessibilit√† al programma, ho aggiunto una serie di comandi che possono essere inviati da porta seriale. Il primo di questi permette di inserire un IP al quale ci si vuole collegare. Da seriale scriveremo ” i ” e comparir√† un ” ? “, quindi scriveremo l’ IP che ci interessa. Dato che ancora non abbiamo programmato un client DNS sul micro, useremo un terminale cmd di Windows e il comando nslookup per ottenere l’ IP del server a cui collegarci. Ecco un esempio:

Con questo nslookup chiediamo al server DNS (quello di Google) l’attuale IP del sito robotop.eu5.org, che √® un mio sito di test ospitato su uno spazio web gratuito.

Un altro comando da seriale permette di settare la Porta a cui ci si vuole collegare. Sul terminale seriale scriveremo ” p ” e verr√† mostrato il carattere ” ? ” e quindi inseriremo il numero della Porta, in questo caso 80 perch√© vogliamo collegarci a un server web che ci restituir√† una pagina HTML.

Vediamo ora il comando che ci permette di selezionare il percorso della pagina a cui vogliamo accedere, sul sito di cui abbiamo ottenuto l’ IP . Sul terminale seriale scriveremo ” s ” e riceveremo il solito ” ? ” e a questo punto scriveremo il percorso, ad esempio: /php/ipget.php. La lunghezza massima accettata per la stringa, come in tutti gli altri comandi, √® di 31 caratteri.

Ora abbiamo il comando per inserire l’URL del sito. Scriveremo da terminale seriale ” u ” e ci verr√† mostrato il solito ” ? ” ; a questo punto, inseriremo la stringa, per esempio robotop.eu5.org. Qualcuno si chieder√† perch√© inseriamo l’URL del sito, dato che ne abbiamo gi√† ricavato l’IP con nslookup. La ragione √® che lo stesso host contiene molti siti (√® un hosting gratuito) e quindi nella richiesta GET HTTP che faremo, dovremo aggiungere il campo “Host: ” che specificher√† a quale sito vogliamo accedere, sul server che gira a quell’indirizzo IP.

L’ultimo comando che possiamo dare da seriale √®: ” g “. Questo comando avvia una richiesta GET HTTP con i parametri impostati da seriale e quelli programmati nella flash. I dati ricevuti (se la richiesta va a buon fine) sono limitati a 255 bytes. Gli eventuali dati in eccesso vengono troncati.

Vediamo un esempio sul terminale seriale:

Ho utilizzato il comando ctrl-r del terminale seriale per registrare tutta la procedura, a partire dal reset del circuito effettuato inviando il carattere ” + “. Eccolo di seguito:

> Boot
> Chip version: 04
> Device MAC: 02-00-00-00-00-01
> Device IP:
> Gateway IP:
> Network Mask:

> i ? err: editing not allowed !
> i ?
> Destination IP:
> p ? 80
> Destination PORT: 80
> s ? /php/ipget.php
> Server's path: /php/ipget.php
> u ? robotop.eu5.org
> Server's URL: robotop.eu5.org
> g
# socket open; src port:1326
# socket initialized OK
# connect socket to server...
# [3] status=15
# socket connected
# sending data...
# data received on socket - bytes:00AD
HTTP/1.1 200 OK
Date: Tue, 07 Mar 2017 16:33:20 GMT
Server: Apache
X-Powered-By: PHP/5.4.17
Content-Length: 11
Connection: close
Content-Type: text/html
# closing socket...
# closed

Ecco cosa abbiamo fatto: ci siamo connessi a http://robotop.eu5.org/php/ipget.php ed abbiamo ricevuto una risposta. La risposta √®… il nostro IP pubblico, quello con il quale il nostro router viene visto dalla rete. Il contenuto del file ipget.php √® veramente minimale.. eccolo qui: <?php echo $_SERVER[REMOTE_ADDR]; ?> .

L’esperimento √® concluso. Nel nuovo file w5500-v2.zip troverete i programmi aggiornati.

Nel prossimo articolo descriver√≤ un’applicazione pratica di quanto sperimentato fin qui. Sar√† un rel√® che potremo accendere / spegnere via Internet, usando come comando remoto un qualsiasi dispositivo mobile provvisto di connessione ad internet (con il browser di serie). Non dovremo abilitare particolari porte sul modem / router e potremo usare anche un router 3G/4G (come quello che sto usando adesso) che non ha un IP pubblico (fa parte di una sottorete del provider). Noi riusciremo ugualmente a comandare il nostro rel√® (con qualche minuto di latenza), grazie a un paio di scripts PHP che scriveremo su un hosting gratuito qualsiasi, dopo aver fatto la nostra registrazione.

Provare per credere ! Arrivederci…

Clausola di non assunzione di responsabilità:
Il programma o software descritto, liberamente prelevabile dal sito, √® da considerarsi una ‚Äúdemo‚ÄĚ gratuita e pertanto l‚Äôautore Emilio P.G. Ficara non fornir√† alcun supporto, n√© si assumer√† alcuna responsabilit√† per ogni eventuale problema, danno o conseguenza che dovesse presentarsi nel download o nell‚Äôesecuzione dell‚Äôapplicazione.
Cliccando questo link per effettuare il download del file implicitamente dichiarate di aver letto e capito la clausola di non assunzione di responsabilità e di accettarla.

Verificate il checksum MD5 del file w5500-v2.zip scaricato ! Questo deve essere: E71F4C2707932F8A2EBCC8C5815D109B ; se è diverso, il file è corrotto o non è quello originale. In questo caso, non scompattatelo e buttatelo via ! Se invece è tutto ok, potete scompattarlo (usate il programma 7Z e la password: eficara). Potete usare i programmi anche su una chiavetta di memoria USB, in quanto non hanno bisogno di installazione, essendo eseguibili puri.

Multimetro connesso in MQTT

In questo articolo descrivo come il mio multimetro DT-4000ZC pubblica su Internet le misure effettuate, utilizzando un microcontrollore Atmel e un modulo WiFi ESP-01 (basato sul chip ESP8266) ed il protocollo MQTT. Per comprendere meglio le fasi di questo progetto, vi invito a leggere i vari articoli pubblicati precedentemente che sono gli “studi preliminari” per arrivare a questo risultato.

MQTT Client tester per modulo ESP-01
DT-4000ZC logger per Android
Interfacciare il modulo ESP-01 con una porta USB
Single 3.7V Li-ion cell battery back-up for Raspberry Pi

Parte prima: l’alimentatore

Il modulino WiFi ESP-01 funziona a 3.3V, quindi tutto il circuito utilizzer√† questa tensione. Ho pensato di usare un alimentatore tipico da carica batterie per telefonini, con uscita a 5V e un regolatore lineare per i 3.3V, ma ho deciso anche di aggiungere una batteria da 3.7V Li-ion di formato AA come backup di alimentazione in caso di mancanza rete. Il circuito √® simile a quello gi√† mostrato nell’articolo Single 3.7V Li-ion cell battery back-up for Raspberry Pi, ma in questo caso invece di avere uno step-up in uscita, abbiamo uno step-down (anche se non switching, ma lineare). Di sotto vedete la foto del circuito appena costruito e collaudato.

Alimentatore 3.3V con batteria Li-Ion di backup

Alimentatore 3.3V con batteria Li-Ion di backup

Lo schema √® vergognosamente disegnato a mano, perch√© non credo che metter√≤ “in produzione” questo dispositivo. Eccolo qui (solo la parte di alimentazione) :

lo schema MAD (Manually Aided Design) della sezione di alimentazione

Lo schema MAD (Manually Aided Design) della sezione di alimentazione

Ho utilizzato un modulino carica batterie Li-Ion acquistato su internet (1 Euro, spedizione inclusa…ma come fanno ?) basato sul chip TP4056. Ho modificato la resistenza che stabilisce la corrente di carica, portandola a 5KOhm (due da 10K in parallelo). Nella foto sottostante si vede il punto da modificare.

0501set-resistorLa ragione di questa modifica √® che l’alimentatore esterno a 5V deve “reggere” sia la corrente di ricarica della batteria, sia la corrente di funzionamento del resto del circuito. Considerando che tanti alimentatori “very cheap” hanno una corrente di uscita max di 500-750mA, mi √® sembrata una scelta razionale. Notate che sullo schema ho aggiunto anche una morsettiera a 2 poli per dare i 5V anche con un alimentatore diverso, senza uscita su connettore Mini-USB. Se alimentate il circuito attraverso questo morsetto, STATE BEN ATTENTI a non superare i 6 Volts ; sul datasheet del TP4056 c’√® scritto che la Vin massima √® di 8 Volts, ma io sarei prudente, onde evitare “fumate”, scintille e bruciature miste.

Il regolatore low-drop con uscita a 3.3V √® di tipo LM3940 ; il link al datasheet √® questo: www.ti.com/lit/ds/symlink/lm3940.pdf . Dalle caratteristiche tecniche si vede che con 5V d’ingresso non c’√® problema, stabilizza a 3.3V fino ad 1A (a noi serve MOLTO meno). Il problema √® quando manca la tensione di rete e invece dei 5V ci si ritrova con i 4.2V che vengono dalla cella Li-Ion a piena carica. Con questa differenza tra Vin e Vout, la stabilizzazione decade un po’, ma per correnti basse (150-200 mA) si dovrebbe restare nel range operativo di tutto il resto del circuito, modulino WiFi e microcontrollore compresi. Eventualmente, per fare le cose a regola d’arte, si pu√≤ scegliere un altro regolatore che sia very-low-drop e quindi in grado di stabilizzare l’uscita anche con una Vin pi√Ļ bassa oppure, meglio ancora, usare un regolatore step-down switching che prolungher√† anche il tempo operativo del circuito quando alimentato a batteria. Se usate un altro tipo di regolatore lineare, fate attenzione al pinout ! Molti regolatori low drop con lo stesso package hanno una disposizione diversa dei pin ! Controllate bene e modificate lo schema di conseguenza. Per quanto riguarda la tensione, teniamo presente che la cella Li-Ion scender√† a 3.7V (la tensione nominale) solo quando la carica residua sar√† ormai solo del 10%. Ricaricate la batteria quando si scarica e tenete presente che le celle Li-Ion non devono scendere mai sotto la tensione di 2.75 V circa, pena la perdita della capacit√† di ricaricarsi (diventano da buttare). Le celle con protezione interna hanno gi√† un circuito che evita questo rischio.

Infine passiamo al mosfet che fa da switch tra l’alimentazione esterna e la cella Li-Ion. Io ho usato un PMV48XP che avevo tra i miei campioni (il datasheet √® qui), ma dato che questo ha un package smd SOT-23 (bello piccolo), √® un po’ difficile da saldare su una scheda prototipo come quella mostrata in figura. Chi non ha un’esperienza pi√Ļ che buona nella saldatura, far√† bene a cercare un altro componente dalle stesse caratteristiche elettriche, ma con un package pi√Ļ “umano”. Comunque, la funzione di questo switch √® di mandare al regolatore la 5V presente sul connettore fino a quando c’√®. Appena viene a mancare, invece, √® la cella Li-Ion a diventare la sorgente di alimentazione. Il mosfet aperto permette al circuito di ricarica di non “vedere” tutto il carico che c’√® dietro (regolatore, modulino wifi, microcontrollore) e di eseguire quindi il normale ciclo di carica con le soglie prefissate. Vi invito, per maggiori dettagli a leggere l’articolo Single 3.7V Li-ion cell battery back-up for Raspberry Pi menzionato in precedenza.

Parte seconda: il microcontrollore

Per il micro, ho “riciclato” un vecchio circuito realizzato nel 2011 per collegare degli economici tablet Android “Made in China” ad un bus RS485 per il controllo di unit√† di potenza in dispositivi biomedicali. A quei tempi i tablet avevano di serie, internamente, la porta seriale TTYS0 con livelli a 3.3V e bastava modificare la Flash di sistema per poterla utilizzare con i propri programmi. Il circuito comprende un micro ATmega48V e un integrato¬† SP3072E come interfaccia RS485. Il micro dispone di 4KB di Flash, 512Bytes di Ram e 256 Bytes di EEprom. Queste risorse, sebbene limitate, bastano per realizzare il programma.

img_20161119_181150Purtroppo il micro ha solo una UART asincrona, mentre a me ne servono due: la prima per leggere i dati provenienti dal multimetro e la seconda per pilotare il modulino ESP-01 con i comandi AT. La UART “hardware” l’ho usata per il pilotaggio del modulo ESP-01 a 9600 BPS. Per fortuna, il multimetro comunica con un baud rate “basso” (2400 BPS) e cos√¨ la seconda UART l’ho realizzata in software. Il multimetro non invia i dati “in chiaro”, come caratteri ASCII, ma come una bitmap dei segmenti accesi sul display LCD. Se qualcuno √® interessato a come vengono codificati i dati seriali, il protocollo √® descritto in un articolo a questo link (paragrafo: Fortune_Semiconductor_FS9721_LP3).

Questo √® lo schema della scheda a microcontrollore. L’interfaccia RS485 verr√† utilizzata in modo “creativo” per leggere i dati seriali dal multimetro (la resistenza segnata in rosso √® stata cambiata proprio per questo scopo). E’ possibile semplificare il circuito ed ottenere lo stesso risultato, ma avendo una scheda gi√† funzionante, ho deciso di usarla senza troppe modifiche.

microcontrollerPer una visione dello schema pi√Ļ nitida e dettagliata, √® possibile scaricare il file in formato PDF da questo link: rs485-andro-micro.

Parte terza: mettere tutto insieme

Nello schema seguente (sempre disegnato a mano) potete vedere i vari blocchi (alimentatore, microcontrollore e modulo wifi) interconnessi tra loro.

I tre blocchi del circuito connessi tra loro

I tre blocchi del circuito con le necessarie connessioni

E questa è la realizzazione pratica:

Il circuito completo montato su una scheda per prototipi

Il circuito completo montato su una scheda per prototipi

Per fare un po’ di debug del software, ho aggiunto un altro circuitino che si collega al connettore ICSP (di programmazione) che rimane libero una volta trasferito il firmware nel micro. Il circuito ha due led (uno giallo e uno rosso) e due pulsanti. Uno di questi √® per resettare il microcontrollore e l’altro √® un generico input per eseguire routines di test. Il circuito √® nella figura sottostante:

Il circuitino di debug che si collega al connettore ICSP (schema)

Il circuitino di debug che si collega al connettore ICSP (schema)

Di seguito, come appare il circuito costruito e collegato:

Il circuito costruito e collegato al connettore ICSP

Il circuito costruito e collegato al connettore ICSP

Un altro utilissimo strumento di debug pu√≤ essere costruito in brevissimo tempo. Si tratta di una “spia” per il traffico dei dati seriali tra il microcontrollore e il modulino WiFi. In generale, si pu√≤ utilizzare in tutte quelle comunicazioni seriali half-duplex basate su domanda / risposta. Lo schema √® il seguente (i diodi devono essere Schottky, low drop)

serialspy-schE questa è la realizzazione pratica :

serialspy-picCon questo piccolo strumento, insieme ad un programma di terminale seriale, si riesce a intercettare tutta la comunicazione tra il micro e l’ESP-01 ed √® facile scoprire gli errori. Come programma di terminale seriale, se non lo scrivo personalmente, mi affido all’ottimo RealTerm .

Il software e il firmware

La sezione software √® divisa in due parti : una √® il firmware per il microcontrollore e l’altra √® un’applicazione per PC (Windows) che permette di programmare i numerosi parametri necessari per personalizzare la connessione al broker MQTT e quella al router WiFi. Normalmente, i dati di personalizzazione vengono salvati nella EEprom del micro, ma dopo centinaia di progetti fatti con i micro Atmel ho potuto verificare che c’√® una certa “debolezza” di questa zona di memoria e in ambienti elettricamente rumorosi o in presenza di circuiti non realizzati “a regola d’arte” √® possibile ritrovarsi con dei dati corrotti in memoria. Normalmente, nei prodotti commerciali che realizzo, utilizzo una doppia copia dei dati in EEprom, ognuna delle quali ha un CRC relativo ai dati memorizzati. Ad ogni reset del micro e anche in base ad un timer di verifica integrit√†, il firmware si occupa di verificare entrambe le copie dei dati in EEprom e se ne trova una corrotta, usa l’altra per ripristinare i dati. Se entrambe le copie hanno un CRC errato, allora il firmware segnala un errore su una delle periferiche disponibili (led, display, cicalino, uscita seriale, eccetera). Questa procedura, ovviamente, richiede una certa quantit√† di codice e allora, in questo particolare caso in cui ho a disposizione solo 4K di Flash per l’intero firmware, ho deciso di usare un approccio differente : i parametri vengono salvati nella memoria programma (Flash), ma NON sono contenuti nel file sorgente in C, bens√¨ vengono “aggiunti” al file di uscita .hex grazie all’applicazione su PC. Questo permette ad un utente di crearsi un proprio file .hex personalizzato ed utilizzarlo per programmare il microcontrollore. La memoria Flash nei microcontrollori Atmel, per la mia esperienza personale, √® “sicura”, cio√® non mi √® mai capitato, in tanti dispositivi costruiti e attualmente presenti sul mercato, di riscontrare una corruzione dei dati programmati.

Nel sorgente in C, l’area di flash destinata ai parametri programmabili √® definita semplicemente cos√¨ :

mqtt-fw1In pratica, viene creata una costante flashdata che nel sorgente √® di soli 2 bytes, ma che servir√† solo a creare un riferimento per l’applicativo su PC per aggiungere tutti i dati necessari. L’area √® allocata all’indirizzo 0x0F00, quindi all’inizio dell’ultimo blocco da 256 bytes della memoria flash. I dati vengono salvati con uno “header” che contiene l’indirizzo (relativo) di partenza di un messaggio e la sua lunghezza. In pratica, uno header di 2 bytes per ognuno dei messaggi (parametri) disponibili. Ecco un esempio di accesso ai dati:

mqtt-fw2Il sorgente in C così compilato, non contiene quindi alcun parametro / messaggio. Infatti, se andiamo a vedere il file .hex risultante dalla compilazione, troveremo questa situazione:

mqtt-fw3Per chi non conosce lo standard dei file intel-hex, il record alla linea 130 indica esattamente all’indirizzo di Flash 0x0F00 i due bytes {0xFF, 0xFF} definiti come ‘flashdata’ nel sorgente in C e sar√† proprio questa “chiave” ad essere utilizzata dall’applicativo su PC per inserire tutti i parametri programmati dall’utente. In sostanza, la riga 130 sar√† eliminata e al suo posto saranno inserite 16 righe (nel caso di 256 bytes) con i dati “veri”. Naturalmente, il numero di riga 130 √® relativo ad una versione iniziale del firmware. Nella versione definitiva troverete gli stessi dati, ma su un numero di riga successivo. Un esempio (incompleto) della sostituzione operata dal programma MQTTprog.exe su PC √® visualizzato nell’immagine sottostante:

mqtt-fw4In pratica, quando programmeremo il microcontrollore attraverso l’apposito connettore, useremo come file di origine questo .hex modificato e poi il firmware andr√† a “pescare” i vari messaggi (da 0 a 7) usando questo “indirizzamento indiretto”.

Ed ecco la prima versione del software per PC e del firmware per il microcontrollore. Si noti che quest’ultimo non fa uso di “librerie” per il protocollo MQTT ed √® realizzato in linguaggio C a partire dallo studio delle specifiche del¬† protocollo stesso. Nella cartella zippata si trovano: l’eseguibile per Windows MQTTprog.exe, il file intel-hex mqttclient.hex e un file di testo con la lista dei possibili errori e delle abbreviazioni usate per il multimetro, nominato docs.txt. Il file zip si chiama multimqtt-v5.zip e pu√≤ essere scompattato con il programma 7Z usando¬† la password: eficara. L’occupazione di memoria flash per questa versione √® la seguente: programma=0x0000..0x0BE3 ; parametri=0x0F00..0x0FFF.

Per verificare l’integrit√† del file zippato, controllate che Il codice MD5 del file sia: 0AECDF122EB1B5A1700F9FADE625B438. Se lo MD5 √® diverso da quello indicato, non scompattate il file perch√© non √® quello originale oppure √® corrotto o scaricato parzialmente.

Clausola di non assunzione di responsabilità:
Il programma o software descritto, liberamente prelevabile dal sito, √® da considerarsi una ‚Äúdemo‚ÄĚ gratuita e pertanto l‚Äôautore Emilio P.G. Ficara non fornir√† alcun supporto, n√© si assumer√† alcuna responsabilit√† per ogni eventuale problema, danno o conseguenza che dovesse presentarsi nel download o nell‚Äôesecuzione dell‚Äôapplicazione.
Cliccando questo link per effettuare il download del file multimqtt-v5.zip implicitamente dichiaro di aver letto e capito la clausola di non assunzione di responsabilità e di accettarla.

La prima operazione da fare per creare un file .hex personalizzato per le nostre esigenze è di avviare il programma MQTTprog.exe. Ci troveremo davanti una schermata fatta così:

mqttprog-ssIl riquadro in alto a sinistra contiene una descrizione del significato di ogni parametro; nel riquadro a destra (editabile) inseriremo i nostri parametri personalizzati, uno per riga.

Io non ho il “telefono fisso” e quindi non ho l’ADSL, ma uso il mio cellulare per fare da hot-spot e per collegarmi ad Internet. Come potete vedere dalla prima riga dei parametri, lo SSID del mio hot-spot √®¬† warmyGun e la password √® m2mqtt55. Ovviamente, voi potrete modificare questi dati per accedere al vostro hot-spot personale. I pulsanti Read Param file e Write Param file servono, rispettivamente, a leggere da disco una configurazione pre-salvata e a scrivere su disco la configurazione correntemente mostrata sullo schermo. Il pulsante Modify HEX file serve invece per produrre un nuovo file hex personalizzato partendo dalla base di quello “standard” mqttclient.hex. Il file di uscita prodotto si chiama sempre¬†mqttclient-mf.hex ed √® questo che dovr√† essere utilizzato per programmare il microcontrollore. Potete copiare la cartella scompattata anche su una chiavetta di memoria usb, perch√© l’eseguibile non richiede installazione. In ogni caso, copiate la cartella su una directory o un disco con i permessi di scrittura.

Per la programmazione dei microcontrollori Atmel, in generale, io uso il noto programma Avrdude, scaricabile presso il sito:¬†www.nongnu.org/avrdude. La configurazione per i “fuses” del microcontrollore ATmega48V in questo caso √®: Hfuse=0xCD Lfuse=0xFC. C’√® da tenere presente che alcuni registri interni del micro ATmega48 (o ATmega48V) non sono esattamente identici a quelli dell’ ATmega48P o ATmega48AP. E’ quindi possibile che un circuito che utilizzi uno di questi micro possa presentare qualche problema. Appena avr√≤ il tempo di realizzare un circuito “commerciale”, user√≤ un micro di ultima generazione e compiler√≤ il sorgente in C per una completa compatibilit√†.

Flusso di programma

Al reset, il led giallo lampeggia 3 volte e poi rimane spento per un paio di secondi, quindi ricomincia a lampeggiare velocemente mentre i vari comandi AT vengono inviati dal micro al modulo WiFi ESP-01 (v0.9.5.2 AT Firmware.bin – 9600 BPS). Le varie fasi successive del programma sono:

1) connessione al router (hot-spot) WiFi
2) attraverso la connessione wifi stabilita, apertura socket TCP su IP:Port del broker
3) invio al broker del comando mqtt CONNECT ; al parametro programmabile ClientId viene aggiunto automaticamente un numero random da 10 a 73, in modo da mantenere una parte fissa e una variabile ad ogni nuova accensione / reset del circuito.
4) attesa dal broker per la risposta CONNACK ; il led rosso si accende in modo fisso.

5) attesa 40 secondi con il led giallo che lampeggia lentamente
6) si spegne il led rosso e viene inviato un comando mqtt PINGREQ
7) attesa dal broker per la risposta PINGRESP ; si riaccende il led rosso fisso

Le fasi da 5 a 7 si ripetono per 2 volte e poi :

8) attesa 40 secondi con il led giallo che lampeggia lentamente
9) si spegne il led rosso e viene inviato un comando mqtt PUBLISH con flag di retain = 1 e QoS = 1. Nel campo Topic verr√† inviato il corrispondente paramentro programmato, il Packet Identifier partir√† dal valore 0x0101 (incrementato dopo la risposta) e infine nel Payload verr√† inviata l’ultima lettura del multimetro, in ASCII, con un limite di 28 caratteri.
10) attesa dal broker per la risposta mqtt PUBACK ; se il Packet Identifier corrisponde a quello inviato, ne viene modificato il valore per la prossima trasmissione.

A questo punto la procedura riprende dalla fase 5. Teoricamente, potremmo spegnere il nostro dispositivo in qualsiasi momento, lasciando che il broker chiuda la connessione per esaurimento del tempo di Keep-Alive (60 secondi, in questa versione), ma per fare le cose in modo “educato”, ho aggiunto anche il comando mqtt DISCONNECT che chiude la connessione in modo canonico. Questo comando pu√≤ essere attivato premendo il pulsantino TST (TeST, vedi schema) durante le fasi 5 o 8 (attesa 40 secondi). Se il comando viene accettato dal broker, si avr√† una immediata disconnessione del socket TCP e i due led rosso e giallo cominceranno a lampeggiare velocemente, alternativamente. Il micro rester√† in questa fase finch√© non toglieremo l’alimentazione o premeremo il pulsantino RST (ReSeT, vedi schema).

Se una delle fasi termina con un errore,¬† il led rosso far√† da “monitor”, indicandoci il numero dell’errore. I vari codici di errore sono contenuti nel file docs.txt ; un lampeggio lungo indica 5 e un lampeggio corto 1. Per esempio, se il codice d’errore fosse 7, avremmo un lampeggio lungo e due brevi. Dopo la visualizzazione dell’errore il micro eseguir√† un reset da watchdog e tutto ricomincer√† dall’inizio, con i tre lampeggi del led giallo e cos√¨ via.

Bene, il programma √® completo ! Si tratta di una prima versione e forse far√≤ aggiunte o correzioni ; nel caso, pubblicher√≤ le variazioni in un nuovo articolo. That’s all, folks !