Escorna_bot_2_1

HID2AMI HID MOUSE AND GAMEPAD to AMIGA ADAPTOR (REV 2.0 board)Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public Licensehttps://github.com/EmberHeavyIndustries/HID2AMIHID2AMI Rev. 2.0 board (released in Autumn 2022) upgrades previous versions by adding capability of supporting Mousewheel and CD32 protocols, in a smaller compact shape.Current firmware v3.0.0 adds Mousewheel support (CD32 support will be added in future releases)If you like this project and want to contribute to its further development, please consider donate some $ or € (paypal friends & family, please or DO NOT select "Buying something" from money transfer frontpage).Donors of at least 5 EUR will receive the latest firmware revision available at the moment of request; donors of 10 EUR or more will also be added to the "firmware beta release" channel, and will receive all intermediate beta releases and all subsequent firmware updates. Donors will also be allowed to request new features and improvements (subjet to author's discretion).https://www.paypal.com/paypalme/mrkbrrUSE AT YOUR OWN RISK!

Turns your Raspberry PI into 3-channel voltage and current monitor for other devices. This HAT contains three INA219 chips connected to I2C bus and measuring current on three independent channels. Shunt resistor may be selected per each channel according to desired purpose of HAT and expected working conditions.Features3 separate channels, each with own INA219 chip and shunt resistorDifferent possible power sources (controlled by jumpers):external (separate input for each channel), provided on screw terminal,internal 5V from common DC inputmay be shorted to Raspberry's 5V pin using solderjumper on the bottom or left as separate circuit,internal 3.3V - powered from 5V using internal LDO regulatorFuse and an "ideal diode" circuit protecting DC source when shorted.4 LEDs:PWR (connected to 5V bus)3 LEDs, one for each channel, connected to selected channel's power sourceHeader for UART - to communicate with measured deviceTest points for I2CStandard ID EEPROM from hat specificationDevicesINA219 addresses:0x40 Channel 10x41 Channel 20x42 Channel 3Software exampleshttps://github.com/rafw87/hardware-modules/tree/master/modules/power-monitor-hat/applicationsExample deviceChannel 1 is set to external input (red jumper on External) provided from 9V battery and connected to the first LED.Channel 2 is set to internal 5V input (red jumper on Internal, yellow on 5V) provided from Raspberry's 5V pin and connected to the second LED.Channel 3 is set to internal 3.3V input (red jumper on Internal, yellow on 3.3V) provided from internal regulator and connected to the third LED.All 3 LEDs are limited with 1kΩ resistors.There is common ground so only one ground wire was required for all LEDs (here connected to channel 3).Example screenshot from provided `power-monitor-plot` application.

TL;DRThe module is a simple way, to connect the widely used (at least in germany) Buderus Logamatic 2107M control unit for oil based heating systems to your home network and your home automation. This is quite essential to get the relevant data from the heating system and can also be used to control it. If you want to optimize or upgrade your heating system, this is the most effective way, to get the data for the minimum forward temperature possible and to make a decision on the right new heating system (like a heat pump).More Info ;-)If you are interested, how I got to the current design and why I did this project, have a look at my blog. If you have the module already assembled and want to start over, this is the right place to look at.The module is just a simple way, to replace the original KM271-RS232-Extension board for the Buderus Logamatic heating control unit. The original has the disadvantage, that you still need something like a Raspberry Pi, a power supply, a USB-Serial converter with (old fashioned) level shifters and all that stuff from the 1970's.This module just integrates an ESP32 and directly connects to the 5V-TTL serial interface of the Logamatic. The ESP32 can be programmed in various ways and one of it is ESPhome (which I favour). The other way is to use Arduino. For the latter, you can also find a link on my blog to a GitLab project, that implements the Buderus protocol and uses MQTT on the network, ready to be integrated in almost every modern home automation system.Thanks to PCBwayThe first version (0.0.1) of the board was also sponsored by the cool people at PCBway. Thanks again for that. So it was a pleasure, to order 0.0.5 fully SMD assembled from the same people.If you are interested in buying the fully assembled version, you can visit my blog. If you need more than a single module, I'm sure, PCBway will make you a great offer :-)

Watchible is an NB-IOT add-on board for the Raspberry Pi Pico. It is low cost, and low power. It is meant to monitor any trigger with a low impedance interface. Both the Pico and the Quectel BCC-66 modem can be put to sleep for up to 12 hours, and will wake up if an alarm is triggered. This reduces power consumption and allows Watchible to be in remote locations, powered by a simple battery for months or years, depending on how big the battery is and how many times it has tow wake up to insure a connection to the network. With other add on boards the number of things that can be monitored is limitless. Examples are remote water detection, gas sensors, and any kind of switch.. The board can be used in fault analysis in remote places like buildings or bridges, using ultrasonic or vibration analysis. Because it sits on the Raspberry Pi Pico It can easily be programmed to use any cloud IOT service, such as AWS, Azure, Google, or HiveMQTT. It can be programmed in C/C++ and Python. When placed in a hardened enclose the Watch provides a small profile remote monitor that can be placed any where and simple run with little to no maintenance. I developed this to be water detector for my boat after my son's boat sank at a Marina. I have talked with many people about different uses and I believe there is a definite need for this device, in all kinds of monitoring situations. I have talked with T-Mobile and the service fees for NB-IOT is about $9.00 a year, and could be better depending on volume. This board is a better alternative to LoRa networks which require gateway build out and testing and much more maintenance, and have a single point of failure should the gateway fail. While it is not specified in NB-IOT applications, I have also tested it on a moving vehicle, and it worked. I believe there is a huge market for this board as IOT applications become more prevalent. I hope will consider the project

WheelOfJoy is an Open Hardware 8-player joystick adapter for the Commodore 16 and Plus/4.The original intent was to figure out how Solder's 3-joystick Adapter worked. It was pretty easy once I realized that the User Port has an output latch, but that also meant that even these 3 extra ports would suffer from the "bouncing ground" effect which prevents using powered controllers.So I began thinking how to replicate the adapter while avoiding that and suddenly I realized that a very simple solution could be used and that it could easily be extended to support 8 joystick while retaining compatibility with the original adapter.For more information please visit the GitHub Project Page.

https://martin-piper.itch.io/bomb-jack-display-hardwareModular audio and video hardware for retro machines like the Commodore 64. Designed to use 74 series TTL through hole ICs available back in the 1980s, something you can solder at home from parts or order ready assembled.This project started when old retro arcade hardware was being discussed. In the back of my mind was the often fabled "Mega games" by Imagine Software which were planned to use extra hardware on the Spectrum and Commodore 64 to augment the machine's capabilities. Since this hardware uses TTL logic available back from the same time period I was wondering exactly how much extra graphical grunt could have been engineered and interfaced with these old 8-bit computers.Truth be told, the Imagine hardware was pretty much just extra RAM https://www.gamesthatwerent.com/gtw64/mega-games/ but this was a fun project to see how far the arcade hardware was pushing the limits of board size and signal complexity.I was looking at Bomb Jack boards on ebay and pondering how they had enough fill-rate to draw 24 16x16 sprites and have the option for some to use 32x32 mode as well. A friend and I were discussing the clock speed and fill-rate while trying to deduce the operation of the hardware just by inspecting the hand drawn schematics, as you do.In the end to get some clarity on the sprite plotting specifically I started to transcribe what was thought to be the sprite logic portion of the schematic into Proteus, since it can simulate digital electronics really well.More details: https://github.com/martinpiper/BombJack/blob/master/README.mdWork in progress. Donating for the download will help me know which project is popular.Now renamed to "MegaWang 2000 Turbo Edition"https://twitter.com/MartinPiper/status/1448298427142402051

Cartridge board for ATARI 65XE/130XE/800XE/800XL 8-bit computers based on SST39SF040 CMOS multi-purpose Flash memory chip.The project does not use programmable logic chips such as GAL-chips.Only conventional logic chips are used, such as 74LS00N, 74LS74N and 74LS374N.This is a S/XEGS type cartridge that allows you to store and run dozens of games.The ROM files for the cartridge are created from the XEX files using the CreaXin1 utility, and then merged using the XEGS Merger to combine four files into one, forming a total of 512 kb of ROM memory.In the process of manufacturing a cartridge, microchips of Russian production can be used, such as ЭКР1533ИР23, К555ТМ2, К555ЛА3 etc.The cartridge body consists of two 3D-printed parts. The parts connect to each other without the use of screws or glue.The following DIP chips are required to build a cartridge:- SST39SF040 DIP32 (1pcs)- 74LS374N (or ЭКР1533ИЗ23) DIP20 (1pcs)- 74LS74N (or К555ТМ2) DIP14 (1pcs)- 74LS00N (or К555ЛА3) DIP14 (1pcs)And the following SMD 1206 parts are required to build a cartridge:- 100 nF capacitors (3 pcs)- 6.8 uF capacitor (1 pcs)- 11 kOhm resistors (6 pcs)- 3.3 kOhm resistor (1 pcs)Optional: Round Hole IC Socket Connector DIP32 (1pcs) for SST39SF040.And you need the ability to program the SST39SF040 Flash ROM, of course. Some sort of programmer like TL866II, or something else.To make a cartridge body, you need the ability to print models on a 3D printer. The model of the cartridge case and its cover is attached.

LittleSixteen is an Open Hardware remake of the Commodore 16 home computer, featuring many improvements over the original design.In V3 we started making improvements to the board:Switched to external power regulation, using the C64 connector and power supply: drastically reduces the heat inside the case, which is one of the main CPU/TED failure causes.Added current-limiting resistors on all ports exposing power pins: this will avoid short-circuiting the power supply, whatever you do on the external connectors.Added internal Joystick port buffers: this is basically like having two OpenC16JoyAdapters built into the machine, preventing the TED pins to be directly exposed on the joystick ports, which is another common cause of TED failures. It also gives the ports a fixed ground, allowing the use of "advanced" joysticks with autofire functionalities for instance, which require power from the machine.Joystick ports now use DB-9 (more properly: DE-9) connectors, just like any other machine of the era: you can now use your favourite C64/Amiga joystick on your C16.Similarly, the Datassette port was changed to the C64-style edge connector. An adapter to keep connecting the 1531 Datassette is trivial to make.Moved to the C64 power switch, since this can still be found on the market and is functionally equivalent.The CPU can now either be an original 7501/8501 or even a 6510, thanks to Andrew Challis's adapter being integrated on the board.In a similar fashion, the board can either directly accept an original MOS 251641 PLA or Dani?l Mantione's GAL16V8-based reimplementation.The design flaw that prevented the usage of cartridge-based RAM expansions was fixed: you can now plug in an OpenC16RamExpansion without the internal RAM fighting with it.Actually that might not even be necessary, as the board now directly supports either 16 or 64 kB of internal RAM.Since the RF modulator is basically useless these days, a replacement circuit was integrated on the board, providing either Luma+Chroma (say S-Video) or Composite Video.Added the possibility of combining the KERNAL and BASIC in a single all-in-one ROM: this allows replacing the original power-hungry chips with a single W27C512, which can also incorporate the Plus/4 function ROMs.ESD protection was improved on all ports.For more information, please check out the GitHub Project Page and the Development Blog.

Hey, Guys what's up?So this is PALPi which is a Raspberry Pi Zero W Based Handheld Retro Game Console that can run pretty much every retro game, from SNES to PS1.The brain of this project is the RECALBOX OS, an Opensource Game Console OS based on Retro Arch.Raspberry Pi Zero W is being used here with a custom PCB that has SMD Buttons on the front side and a battery on the back.This is currently the Fifth Iteration of the PALPi Game Console System.Its previous version was great but it had a battery issue, there wasn't much space inside the 3D Printed body and by increasing the thickness we could accommodate more cells but it would also increase its size.This version is also thick as it consists of two boards stacked together, we can add cells and everything later in a single board, this needs further refinement in this case but for now, it's working and the SMD Buttons feel a lot better than previously used tactile buttons.Material Requiredfollowing are the stuff used in this built-Custom PCB (which was provided by PCBWAY)IP5306 IC10uf 1206 Package Capacitor x82R 1206 Package x11K 0603 Package x210uH Inductor x1SMD Button four pin x 10SMD Button two pin x 3Indicator LEDs x4Type C USB Port x1Dual 18650 cell SMD HolderLi-ion Cells 3.7V 2600mah x2Female Header pins Con40 SMD VersionRaspberry Pi Zero4-inch PAL Display (salvaged from CAR MONITOR)3D Printed parts3D DesignThis Version is a special one, instead of 3D Printing the whole body, PCBs have been used for the overall construction.Front Panel Has SMD Buttons on TOP Side and Raspberry Pi on BOTTOM Side, Screen is also attached to the front Panel through two screen holders from the BOTTOM side of the board.It also holds two 3D Printed Hand Grips that increase its size and enhance the holding experience significantly.As for the Power, there's a second PCB dedicated to Cells and their charge management circuitry.The Battery Holder PCB is connected to the Front Panel through three 25mm Long PCB Standoffs.I used fusion360 to make this design, there are a total of four parts that we need to 3D Print which are the Controller Grip which consists of left and right pairs, the second part is the screen holder we need to print 2 units.As for print settings, I have used a 0.4mm Nozzle at 0.2mm layer height and 25% infill.SchematicThis Project utilizes two separate boards so there are a total of two schematics used in this project."Front Panel PCB" as its name suggests is the front part of the console, It holds the screen in its place and has 13 SMD Buttons.It also contains the Raspberry Pi Header Pin socket which is mounted on the bottom side of the board."Battery Holder PCB" is the second board that holds the main power source of this whole device, two Li-ion cells.IP5306 setup is used, for charging, there's a USB Type C Port and also one for discharging.PCB DesignAfter getting the rough Idea of the shape for both the Front and back PCB, I designed two separate boards, Front Panel and Battery Holder PCB.The Front Panel PCB contains mainly the screen and buttons, it has mounting holes for adding the Battery Holder PCB and Screen holder.The Battery Holder PCB was simple as well, it's an IP5306 Based board that controls Li-ion Charge and discharge cycle as well as gives stable 5V output for Raspberry Pi and screen to power.Both PCBs are made in such a way that they can be connected by three PCB Standoffs making the PCBs the main body so we don't have to use any sort of 3D Printed cover for this version.PCBWAYAfter completing both designs, I exported their Gerber data and sent it to PCBWAY for samples.A White solder mask and Black silkscreen were used for this project.I received PCBs in a week and the PCBs were nice as expected.I like the quality of the white solder mask, it was a tough sample to manufacture as the silkscreen that I have laid out on this board was not completely symmetrical and I also added a rectangular void in the middle region which was not like normal PCB layout but PCBWAY did an excellent job of manufacturing this PCB with no error whatsoever.check out PCBWay service for getting great PCB service at less cost.Solderpaste Dispensing ProcessNow the first step is to add solder paste to each component pad one by one.To Apply solder paste, I'm using a Solderpaste Dispensing Needle with a Wide syringe, and the solder paste I'm using is a regular solder paste consisting of 63% Tin and 37% Lead.We first applied solder paste to the Battery board and then did the same for the front PCB.Pick and Place ProcessAfter applying Solderpaste we move on to the next step which is to add componenets to their assigned location.I used an ESD Tweezer to place all the components on both the Front and Battery PCB.Hotplate Reflow ProcessAfter the "Pick & Place Process", I carefully lifted the whole circuit board and placed it on my DIY SMT Hotplate.the hotplate heats the PCB from below up to the solder paste melting temp, as soon as the PCB reaches that temp, the solder paste melts and all the components get soldered to their pads, we lift the PCB and then place it on a much cooler surface for a little bit, to cool down the heat of PCB.Adding SMD Rpi GPIO Header and CON2Next, we add the 40 Pin Female Header Pin on the Front Board's bottom layer using a soldering iron, this will take a while as we have to manually solder each pin to its SMD Pad.After adding Header Pin, we add CON2 JST Connector to the 5V and GND pin of the board, we later connect a JST Wire Harness to this CON2 for powering the RPI with Battery Board.SMD Li-ion cell HolderNext, on the Battery Holder PCB, we add Li-ion Cell 18650 SMD Holder in its place by using a regular Soldering Iron.Battery Board TestAfter adding the SMD Cell Holder, we add two 3.7V 2900mAh Li-ion cells in the Cell Holder, making sure to place them in the right polarity.Next, we press the Main ON OFF Button and measure the voltage at Output Terminals which should be more than 5V.Adding Screen with Front PCBWe now add the PAL Screen on the Front Panel by using two 3D Printed Screen holders and a couple of screws.After this, we connect the Screen's VCC to 5V of the Front Panel board, GND to GND, and PAL port to PAL port connector given on the left side of the board.Adding Side Holder/Grip with Front PCBNext, we add two Hand Grips to the Front Panel, these grips are 3D Printed and are mounted by two M2 screws each.Raspberry Pi Zero Merge with Front PCBIt's time to place the Raspberry Pi Zero in its Header socket.We first solder a wire to the PAL port nearby the Raspberry Pi zero area.Next, we secure Raspberry Pi in its place and add solder wire to the PAL port of the Raspberry Pi so we can attach the wire easily to it.Front PCB and Battery Holder PCB MergerWe now start the final assembly by first adding Three PCB Standoffs to the Battery Holder PCB.Next, we place the Battery Holder PCB on the Bottom side of the Front Panel and use three M3 Screws to connect both PCBs.Connecting Battery Board with Front Panel through JST wire harnessAt last, we add a JST wire harness to the Positive and Negative port of the Battery Holder PCB so we can connect this wire harness with the CON2 JST connector on the Front Panel.RESULTHere's the result, a handheld console that is powerful enough to run a bucket load of old retro games like Super Mario, Pokemon games, Contra, etc.But before doing that, we first need to set up the RECALBOX OS.Setting up Recalbox OSI used RECALBOX OS to run this setup.Why Recalbox OS, why not Retro Pi or another OS?well, the answer here is simple, recalbox is an easy-to-use OS that comes with a lot of Free games pre-installed.Also, it's small and can run on low-spec raspberry pi systems.like in my case, I'm using a Raspberry Pi Zero W which has 512MB ram.it's not exactly a powerhouse but it can handle a few retro games without breaking a sweat.Installing it is also very easyDownload the Raspberry Pi imager.Select the right OS for your device, which would be RecalBoxselect your system which is Rpi zeroRaspberry pi imager will do your work of downloading and installing the RecalBox on the memory card.After installing the RecalBox os, you need to plug your Raspberry pi setup with a Keyboard as the first boot always requires a keyboard.After plugging the setup into an HDMI monitor and booting it, the RecalBox works like a normal emulator.Editing Config File- GPIO Enable and PAL DisplayThis console has GPIO Buttons and PAL Display that we need to configure through two different files.Before SSH into the PI, we open the network settings in the Raspberry Pi and connect the recalbox to a local network for the internet. we add SSID and Password for the network and then wait for the Raspberry Pi to get connected, once it gets connected we can then copy the IP address of the Pi as we will be needing it in the next step.Open Win SCP on your computer, and enter the raspberry pi IP Address on it, the user name will be root, and the password for the pi is recalboxroot.go to recalbox>share>system>recalbox.confFor Enabling GPIO Buttons, we only need to change two things in the below section.set controller.gpio.enabled = 1 (It was 0 before) and change controller.gpio.args.map=1, 2 to controller.gpio.args.map=1 (2 is second player controlls)We change the default setting with the above settings and then reboot the whole setup, this will enable the GPIO Buttons.For the PAL Display, we go to boot>config.txt and change a few things in the config file.We Remove # from sdtv_mode and add sdtv_aspect=1, also, we add # in front of HDMI lines.Adding GamesRecalbox comes with many old games pre-installed but what if we want to run a personal favorite game which in my case was Pokemon Emerald and Super Mario World?we first need to download the custom ROM of any game you want to play on this game console. For example, I downloaded pokemon emerald. then we first need to connect the Recalbox to our WIFI router.We open WinSCP and add our Recalbox IP Address on it along with the user name- root, and the password for the pi is recalboxroot.go to this menu recalbox>share>rom, it contains all the emulator's folder which contains games ROM, I wanted to add pokemon Emeral in it which runs on Gameboy advance so I had to copy-paste its ROM file into the GBA folder.now reboot your raspberry pi setup and open the GBA Emulator menu, and you will see the newly added game.Similarly, we can add any ROM to the Pi, just download the ROM and then drop it into the right emulator folder.ConclusionHere's the result, a working classic game emulation device that is capable enough to run a few golden titles. Raspbeery Pi Zero isn't a powerhouse and it's limited by the 512MB ram which isn't fast enough for this kind of workload.Next, I want to try Compute Module for this task and make a decent controller from it but because of the current Raspberry Pi Shortage and price hike, I'm not sure if that will be possible any time sooner.Well, this is it for today folks, if you have any trouble regarding this project then leave a comment or DM me.Special Thanks to PCBWAY for supporting this project.Check out PCBWAY for great PCB service for a relatively lower cost.Thanks again and peace out.

Along 3 years I have been trying several leg mechanism, at first I decided to do a simple desing with tibial motor where placed on femur joint.This design had several problems, like it wasn't very robust and the most importat is that having the motor (with big mass) that far from the rotating axis, caused that in some movements it generate unwanted dynamics to the robot body, making controlability worse.New version have both motors of femur/tibial limb at coxa frame, this ends with a very simple setup and at the same time, the heaviest masses of the mechanism are centered to the rotating axis of coxa limb, so even though the leg do fast movements, inertias won't be strong enough to affect the hole robot mass, achieving more agility.Inverse Kinematics of the mechanismAfter building it I notice that this mechanism was very special for another reason, at the domain the leg normally moves, it acts as a diferential mecanism, this means that torque is almost all the time shared between both motor of the longer limbs. That was an improvent since with the old mechanism tibial motor had to hold most of the weight and it was more forced than the one for femur.To visualize this, for the same movement, we can see how tibial motor must travel more arc of angel that the one on the new version.In order to solve this mechanism, just some trigonometry is needed. Combining both cosine and sine laws, we can obtain desired angle (the one between femur and tibia) with respect to the angle the motor must achieve.Observing these equations, with can notice that this angle (the one between femur and tibia) depends on both servos angles, which means both motors are contributing to the movement of the tibia.Calibration of servosAnother useful thing to do if we want to control servo precisely is to print a calibration tool for our set up. As shown in the image below, in order to know where real angles are located, angle protactor is placer just in the origin of the rotating joint, and choosing 2 know angles we can match PWM signal to the real angles we want to manipulate simply doing a lineal relation between angles and PWM pulse length.Then a simple program in the serial console can be wrtten to let the user move the motor to the desired angle. This way the calibration process is only about placing motor at certain position and everything is done and we won't need to manually introduce random values that can be a very tedious task.With this I have achieved very good calibrations on motors, which cause the robot to be very simetrial making the hole system more predictable. Also the calibration procedure now is very easy to do, as all calculations are done automatically. Check Section 1 for the example code for calibration.More about this can be seen in the video below, where all the building process is shown as well as the new leg in action.SECTION 1:In the example code below, you can see how calibration protocol works, it is just a function called calibrationSecuence() which do all the work until calibration is finished. So you only need to call it one time to enter calibration loop, for example by sending a 'c' character thought the serial console.Also some useful function are used, like moving motor directly with analogWrite functions which all the calculations involved, this is a good point since no interrupts are used.This code also have the feature to calibrate the potentiometer coming from each motor.#define MAX_PULSE 2500 #define MIN_PULSE 560 /*---------------SERVO PIN DEFINITION------------------------*/ int m1 = 6;//FR int m2 = 5; int m3 = 4; int m4 = 28;//FL int m5 = 29; int m6 = 36; int m7 = 3;//BR int m8 = 2; int m9 = 1; int m10 = 7;//BL int m11 = 24; int m12 = 25; int m13 = 0;//BODY /*----------------- CALIBRATION PARAMETERS OF EACH SERVO -----------------*/ double lowLim[13] = {50, 30, 30, 50, 30, 30, 50, 30, 30, 50, 30, 30, 70}; double highLim[13] = {130, 150, 150, 130, 150, 150, 130, 150, 150, 130, 150, 150, 110}; double a[13] = { -1.08333, -1.06667, -1.07778, //FR -1.03333, 0.97778, 1.01111, //FL 1.03333, 1.05556, 1.07778, //BR 1.07500, -1.07778, -1.00000, //BL 1.06250 }; double b[13] = {179.0, 192.0, 194.5, //FR 193.0, 5.5, -7.5, //FL 7.0, -17.0, -16.0, //BR -13.5, 191.5, 157.0, //BL -0.875 }; double ae[13] = {0.20292, 0.20317, 0.19904 , 0.21256, -0.22492, -0.21321, -0.21047, -0.20355, -0.20095, -0.20265, 0.19904, 0.20337, -0.20226 }; double be[13] = { -18.59717, -5.70512, -2.51697, -5.75856, 197.29411, 202.72169, 185.96931, 204.11902, 199.38663, 197.89534, -5.33768, -32.23424, 187.48058 }; /*--------Corresponding angles you want to meassure at in your system-----------*/ double x1[13] = {120, 135, 90, 60, 135 , 90, 120, 135, 90, 60, 135, 90, 110}; //this will be the first angle you will meassure double x2[13] = {60, 90, 135, 120, 90, 135, 60, 90, 135, 120, 90, 135, 70};//this will be the second angle you will meassure for calibration /*--------You can define a motor tag for each servo--------*/ String motorTag[13] = {"FR coxa", "FR femur", "FR tibia", "FL coxa", "FL femur", "FL tibia", "BR coxa", "BR femur", "BR tibia", "BL coxa", "BL femur", "BL tibia", "Body angle" }; double ang1[13] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; double ang2[13] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; float xi[500]; float yi[500]; float fineAngle; float fineL; float fineH; int motorPin; int motor = 0; float calibrationAngle; float res = 1.0; float ares = 0.5; float bres = 1.0; float cres = 4.0; float rawAngle; float orawAngle; char cm; char answer; bool interp = false; bool question = true; bool swing = false; int i; double eang; int freq = 100; // PWM frecuency can be choosen here. void connectServos() { analogWriteFrequency(m1, freq); //FR coxa digitalWrite(m1, LOW); pinMode(m1, OUTPUT); analogWriteFrequency(m2, freq); //femur digitalWrite(m2, LOW); pinMode(m2, OUTPUT); analogWriteFrequency(m3, freq); //tibia digitalWrite(m3, LOW); pinMode(m3, OUTPUT); analogWriteFrequency(m4, freq); //FL coxa digitalWrite(m4, LOW); pinMode(m4, OUTPUT); analogWriteFrequency(m5, freq); //femur digitalWrite(m5, LOW); pinMode(m5, OUTPUT); analogWriteFrequency(m6, freq); //tibia digitalWrite(m6, LOW); pinMode(m6, OUTPUT); analogWriteFrequency(m7, freq); //FR coxa digitalWrite(m7, LOW); pinMode(m7, OUTPUT); analogWriteFrequency(m8, freq); //femur digitalWrite(m8, LOW); pinMode(m8, OUTPUT); analogWriteFrequency(m9, freq); //tibia digitalWrite(m9, LOW); pinMode(m9, OUTPUT); analogWriteFrequency(m10, freq); //FR coxa digitalWrite(m10, LOW); pinMode(m10, OUTPUT); analogWriteFrequency(m11, freq); //femur digitalWrite(m11, LOW); pinMode(m11, OUTPUT); analogWriteFrequency(m12, freq); //tibia digitalWrite(m12, LOW); pinMode(m12, OUTPUT); analogWriteFrequency(m13, freq); //body digitalWrite(m13, LOW); pinMode(m13, OUTPUT); } void servoWrite(int pin , double angle) { float T = 1000000.0f / freq; float usec = float(MAX_PULSE - MIN_PULSE) * (angle / 180.0) + (float)MIN_PULSE; uint32_t duty = int(usec / T * 4096.0f); analogWrite(pin , duty); } double checkLimits(double angle , double lowLim , double highLim) { if ( angle >= highLim ) { angle = highLim; } if ( angle <= lowLim ) { angle = lowLim; } return angle; } int motorInfo(int i) { enc1 , enc2 , enc3 , enc4 , enc5 , enc6 , enc7 , enc8 , enc9 , enc10 , enc11 , enc12 , enc13 = readEncoders(); if (i == 0) { rawAngle = enc1; motorPin = m1; } else if (i == 1) { rawAngle = enc2; motorPin = m2; } else if (i == 2) { rawAngle = enc3; motorPin = m3; } else if (i == 3) { rawAngle = enc4; motorPin = m4; } else if (i == 4) { rawAngle = enc5; motorPin = m5; } else if (i == 5) { rawAngle = enc6; motorPin = m6; } else if (i == 6) { rawAngle = enc7; motorPin = m7; } else if (i == 7) { rawAngle = enc8; motorPin = m8; } else if (i == 8) { rawAngle = enc9; motorPin = m9; } else if (i == 9) { rawAngle = enc10; motorPin = m10; } else if (i == 10) { rawAngle = enc11; motorPin = m11; } else if (i == 11) { rawAngle = enc12; motorPin = m12; } else if (i == 12) { rawAngle = enc13; motorPin = m13; } return rawAngle , motorPin; } void moveServos(double angleBody , struct vector anglesServoFR , struct vector anglesServoFL , struct vector anglesServoBR , struct vector anglesServoBL) { //FR anglesServoFR.tetta = checkLimits(anglesServoFR.tetta , lowLim[0] , highLim[0]); fineAngle = a[0] * anglesServoFR.tetta + b[0]; servoWrite(m1 , fineAngle); anglesServoFR.alpha = checkLimits(anglesServoFR.alpha , lowLim[1] , highLim[1]); fineAngle = a[1] * anglesServoFR.alpha + b[1]; servoWrite(m2 , fineAngle); anglesServoFR.gamma = checkLimits(anglesServoFR.gamma , lowLim[2] , highLim[2]); fineAngle = a[2] * anglesServoFR.gamma + b[2]; servoWrite(m3 , fineAngle); //FL anglesServoFL.tetta = checkLimits(anglesServoFL.tetta , lowLim[3] , highLim[3]); fineAngle = a[3] * anglesServoFL.tetta + b[3]; servoWrite(m4 , fineAngle); anglesServoFL.alpha = checkLimits(anglesServoFL.alpha , lowLim[4] , highLim[4]); fineAngle = a[4] * anglesServoFL.alpha + b[4]; servoWrite(m5 , fineAngle); anglesServoFL.gamma = checkLimits(anglesServoFL.gamma , lowLim[5] , highLim[5]); fineAngle = a[5] * anglesServoFL.gamma + b[5]; servoWrite(m6 , fineAngle); //BR anglesServoBR.tetta = checkLimits(anglesServoBR.tetta , lowLim[6] , highLim[6]); fineAngle = a[6] * anglesServoBR.tetta + b[6]; servoWrite(m7 , fineAngle); anglesServoBR.alpha = checkLimits(anglesServoBR.alpha , lowLim[7] , highLim[7]); fineAngle = a[7] * anglesServoBR.alpha + b[7]; servoWrite(m8 , fineAngle); anglesServoBR.gamma = checkLimits(anglesServoBR.gamma , lowLim[8] , highLim[8]); fineAngle = a[8] * anglesServoBR.gamma + b[8]; servoWrite(m9 , fineAngle); //BL anglesServoBL.tetta = checkLimits(anglesServoBL.tetta , lowLim[9] , highLim[9]); fineAngle = a[9] * anglesServoBL.tetta + b[9]; servoWrite(m10 , fineAngle); anglesServoBL.alpha = checkLimits(anglesServoBL.alpha , lowLim[10] , highLim[10]); fineAngle = a[10] * anglesServoBL.alpha + b[10]; servoWrite(m11 , fineAngle); anglesServoBL.gamma = checkLimits(anglesServoBL.gamma , lowLim[11] , highLim[11]); fineAngle = a[11] * anglesServoBL.gamma + b[11]; servoWrite(m12 , fineAngle); //BODY angleBody = checkLimits(angleBody , lowLim[12] , highLim[12]); fineAngle = a[12] * angleBody + b[12]; servoWrite(m13 , fineAngle); } double readEncoderAngles() { enc1 , enc2 , enc3 , enc4 , enc5 , enc6 , enc7 , enc8 , enc9 , enc10 , enc11 , enc12 , enc13 = readEncoders(); eang1 = ae[0] * enc1 + be[0]; eang2 = ae[1] * enc2 + be[1]; eang3 = ae[2] * enc3 + be[2]; eang4 = ae[3] * enc4 + be[3]; eang5 = ae[4] * enc5 + be[4]; eang6 = ae[5] * enc6 + be[5]; eang7 = ae[6] * enc7 + be[6]; eang8 = ae[7] * enc8 + be[7]; eang9 = ae[8] * enc9 + be[8]; eang10 = ae[9] * enc10 + be[9]; eang11 = ae[10] * enc11 + be[10]; eang12 = ae[11] * enc12 + be[11]; eang13 = ae[12] * enc13 + be[12]; return eang1 , eang2 , eang3 , eang4 , eang5 , eang6 , eang7 , eang8 , eang9 , eang10 , eang11 , eang12 , eang13; } void calibrationSecuence( ) { //set servos at their middle position at firstt for (int i = 0; i <= 12; i++) { rawAngle , motorPin = motorInfo(i); servoWrite(motorPin , 90); } // sensorOffset0 = calibrateContacts(); Serial.println(" "); Serial.println("_________________________________SERVO CALIBRATION ROUTINE_________________________________"); Serial.println("___________________________________________________________________________________________"); Serial.println("(*) Don't send several caracter at the same time."); delay(500); Serial.println(" "); Serial.println("Keyboard: 'x'-> EXIT CALIBRATION. 'c'-> ENTER CALIBRATION."); Serial.println(" 'i'-> PRINT INFORMATION. "); Serial.println(" "); Serial.println(" 'n'-> CHANGE MOTOR (+). 'b' -> CHANGE MOTOR (-)."); Serial.println(" 'm'-> START CALIBRATION."); Serial.println(" 'q'-> STOP CALIBRATION."); Serial.println(" "); Serial.println(" 'r'-> CHANGE RESOLUTION."); Serial.println(" 'p'-> ADD ANGLE. 'o'-> SUBTRACT ANGLE. "); Serial.println(" 's'-> SAVE ANGLE."); delay(500); Serial.println(" "); Serial.println("---------------------------------------------------------------------------------------------------"); Serial.print("SELECTED MOTOR: "); Serial.print(motorTag[motor]); Serial.print(". SELECTED RESOLUTION: "); Serial.println(res); while (CAL == true) { if (Serial.available() > 0) { cm = Serial.read(); if (cm == 'x') { Serial.println("Closing CALIBRATION program..."); CAL = false; secuence = false; startDisplay(PAGE); angleBody = 90; anglesIKFR.tetta = 0.0; anglesIKFR.alpha = -45.0; anglesIKFR.gamma = 90.0; anglesIKFL.tetta = 0.0; anglesIKFL.alpha = -45.0; anglesIKFL.gamma = 90.0; anglesIKBR.tetta = 0.0; anglesIKBR.alpha = 45.0; anglesIKBR.gamma = -90.0; anglesIKBL.tetta = 0.0; anglesIKBL.alpha = 45.0; anglesIKBL.gamma = -90.0; } else if (cm == 'i') { // + Serial.println(" "); Serial.println("---------------------------------------------------------------------------------------------------"); Serial.println("---------------------------------------------------------------------------------------------------"); Serial.println("(*) Don't send several caracter at the same time."); delay(500); Serial.println(" "); Serial.println("Keyboard: 'x'-> EXIT CALIBRATION. 'c'-> ENTER CALIBRATION."); Serial.println(" 'i'-> PRINT INFORMATION. "); Serial.println(" "); Serial.println(" 'n'-> CHANGE MOTOR (+). 'b' -> CHANGE MOTOR (-)."); Serial.println(" 'm'-> START CALIBRATION."); Serial.println(" 'q'-> STOP CALIBRATION."); Serial.println(" "); Serial.println(" 'r'-> CHANGE RESOLUTION."); Serial.println(" 'p'-> ADD ANGLE. 'o'-> SUBTRACT ANGLE. 's'-> SAVE ANGLE."); Serial.println(" "); delay(500); Serial.println(" "); Serial.println("---------------------------------------------------------------------------------------------------"); Serial.println(" "); Serial.print("SELECTED MOTOR: "); Serial.print(motorTag[motor]); Serial.print(". SELECTED RESOLUTION: "); Serial.println(res); Serial.println("Actual parameters of the motor: "); Serial.print("High limit: "); Serial.print(highLim[motor]); Serial.print(" Low limit: "); Serial.print(lowLim[motor]); Serial.print(" Angle 1: "); Serial.print(ang1[motor]); Serial.print(" Angle 2: "); Serial.println(ang2[motor]); Serial.println("---------------------------------------------------------------------------------------------------"); } else if (cm == 'm') { // + secuence = true; } else if (cm == 's') { // + } else if (cm == 'n') { // + motor++; if (motor >= 13) { motor = 0; } Serial.print("SELECTED MOTOR: "); Serial.println(motorTag[motor]); } else if (cm == 'b') { // + motor--; if (motor < 0) { motor = 13 - 1; } Serial.print("SELECTED MOTOR: "); Serial.println(motorTag[motor]); } else if (cm == 'r') { // + if (res == ares) { res = bres; } else if (res == bres) { res = cres; } else if (res == cres) { res = ares; } Serial.print("SELECTED RESOLUTION: "); Serial.println(res); } } if (secuence == true) { Serial.print("Starting secuence for motor: "); Serial.println(motorTag[motor]); for (int i = 0; i <= 30; i++) { delay(20); Serial.print("."); } Serial.println("."); while (question == true) { unsigned long currentMicros = micros(); if (currentMicros - previousMicros >= 100000) { previousMicros = currentMicros; if (Serial.available() > 0) { answer = Serial.read(); if (answer == 'y') { question = false; interp = true; secuence = true; } else if (answer == 'n') { question = false; interp = false; secuence = true; } else { Serial.println("Please, select Yes(y) or No(n)."); } } } } answer = 't'; question = true; if (interp == false) { Serial.println("___"); Serial.println(" | Place motor at 1ts position and save angle"); Serial.println(" | This position can be the higher one"); rawAngle , motorPin = motorInfo(motor); calibrationAngle = 90; //start calibration at aproximate middle position of the servo. while (secuence == true) { /* find first calibration angle */ if (Serial.available() > 0) { cm = Serial.read(); if (cm == 'p') { // + Serial.print(" | +"); Serial.print(res); Serial.print(" : "); calibrationAngle = calibrationAngle + res; servoWrite(motorPin , calibrationAngle); Serial.println(calibrationAngle); } else if (cm == 'o') { // - Serial.print(" | -"); Serial.print(res); Serial.print(" : "); calibrationAngle = calibrationAngle - res; servoWrite(motorPin , calibrationAngle); Serial.println(calibrationAngle); } else if (cm == 'r') { // + if (res == ares) { res = bres; } else if (res == bres) { res = cres; } else if (res == cres) { res = ares; } Serial.print("SELECTED RESOLUTION: "); Serial.println(res); } else if (cm == 'q') { // quit secuence secuence = false; Serial.println(" | Calibration interrupted!!"); } else if (cm == 's') { // save angle ang1[motor] = calibrationAngle; secuence = false; Serial.print(" | Angle saved at "); Serial.println(calibrationAngle); } } } if (cm == 'q') { Serial.println(" |"); } else { secuence = true; Serial.println("___"); Serial.println(" | Place motor at 2nd position and save angle"); Serial.println(" | This position can be the lower one"); } while (secuence == true) { /* find second calibration angle */ if (Serial.available() > 0) { cm = Serial.read(); if (cm == 'p') { // + Serial.print(" | +"); Serial.print(res); Serial.print(" : "); calibrationAngle = calibrationAngle + res; servoWrite(motorPin , calibrationAngle); Serial.println(calibrationAngle); } else if (cm == 'o') { // - Serial.print(" | -"); Serial.print(res); Serial.print(" : "); calibrationAngle = calibrationAngle - res; servoWrite(motorPin , calibrationAngle); Serial.println(calibrationAngle); } else if (cm == 'r') { // + if (res == ares) { res = bres; } else if (res == bres) { res = cres; } else if (res == cres) { res = ares; } Serial.print("SELECTED RESOLUTION: "); Serial.println(res); } else if (cm == 'q') { // quit secuence secuence = false; Serial.println(" | Calibration interrupted!!"); } else if (cm == 's') { // save angle ang2[motor] = calibrationAngle; secuence = false; Serial.print(" | Angle saved at "); Serial.println(calibrationAngle); } } } /*--------------------start calibration calculations------------------*/ if (cm == 'q') { Serial.println("___|"); Serial.println("Calibration finished unespected."); Serial.println(" Select another motor."); Serial.print("SELECTED MOTOR: "); Serial.print(motorTag[motor]); Serial.print(". SELECTED RESOLUTION: "); Serial.println(res); } else { Serial.println("___"); Serial.println(" |___"); Serial.print( " | | Interpolating for motor: "); Serial.println(motorTag[motor]); secuence = true; //real angle is calculated interpolating both angles to a linear relation. a[motor] = (ang2[motor] - ang1[motor]) / (x2[motor] - x1[motor]); b[motor] = ang1[motor] - x1[motor] * (ang2[motor] - ang1[motor]) / (x2[motor] - x1[motor]); Serial.println(" | |"); } interp = true; } /*---------------------------make swing movement to interpolate motor encoder-----*/ if (interp == true and secuence == true) { delay(200); double x; int k = 0; int stp = 180; swing = true; i = 0; orawAngle , motorPin = motorInfo(motor); previousMicros = 0; while (swing == true) { // FIRST unsigned long currentMicros = micros(); if (currentMicros - previousMicros >= 10000) { // save the last time you blinked the LED previousMicros = currentMicros; x = x2[motor]; calibrationAngle = a[motor] * x + b[motor]; servoWrite(motorPin , calibrationAngle); rawAngle , motorPin = motorInfo(motor); if ((i % 3) == 0) { yi[k+1] = x; xi[k] = rawAngle; Serial.print(" | | Real ang: "); Serial.print(x); Serial.print(" -> Servo ang: "); Serial.print(calibrationAngle); Serial.print(" Enc: "); Serial.println(rawAngle); k++; } if (i >= stp) { swing = false; } i++; } } swing = true; i = 0; while (swing == true) { // moving unsigned long currentMicros = micros(); if (currentMicros - previousMicros >= 10000) { // save the last time you blinked the LED previousMicros = currentMicros; x = x2[motor] + float(i) * (x1[motor] - x2[motor]) / stp; calibrationAngle = a[motor] * x + b[motor]; servoWrite(motorPin , calibrationAngle); rawAngle , motorPin = motorInfo(motor); if ((i % 6) == 0) { yi[k+1] = x; xi[k] = rawAngle; Serial.print(" | | Real ang: "); Serial.print(x); Serial.print(" -> Servo ang: "); Serial.print(calibrationAngle); Serial.print(" Enc: "); Serial.println(rawAngle); k++; } if (i >= stp) { swing = false; } i++; } } swing = true; i = 0; while (swing == true) { // SECOND unsigned long currentMicros = micros(); if (currentMicros - previousMicros >= 10000) { // save the last time you blinked the LED previousMicros = currentMicros; x = x1[motor]; calibrationAngle = a[motor] * x + b[motor]; servoWrite(motorPin , calibrationAngle); rawAngle , motorPin = motorInfo(motor); if ((i % 3) == 0) { yi[k+1] = x; xi[k] = rawAngle; Serial.print(" | | Real ang: "); Serial.print(x); Serial.print(" -> Servo ang: "); Serial.print(calibrationAngle); Serial.print(" Enc: "); Serial.println(rawAngle); k++; } if (i >= stp) { swing = false; } i++; } } swing = true; i = 0; while (swing == true) { // moving unsigned long currentMicros = micros(); if (currentMicros - previousMicros >= 10000) { // save the last time you blinked the LED previousMicros = currentMicros; x = x1[motor] + float(i) * (x2[motor] - x1[motor]) / stp; calibrationAngle = a[motor] * x + b[motor]; servoWrite(motorPin , calibrationAngle); rawAngle , motorPin = motorInfo(motor); if ((i % 6) == 0) { yi[k+1] = x; xi[k] = rawAngle; Serial.print(" | | Real ang: "); Serial.print(x); Serial.print(" -> Servo ang: "); Serial.print(calibrationAngle); Serial.print(" Enc: "); Serial.println(rawAngle); k++; } if (i >= stp) { swing = false; } i++; } } swing = true; i = 0; while (swing == true) { // FIRST unsigned long currentMicros = micros(); if (currentMicros - previousMicros >= 10000) { // save the last time you blinked the LED previousMicros = currentMicros; x = x2[motor]; calibrationAngle = a[motor] * x + b[motor]; servoWrite(motorPin , calibrationAngle); rawAngle , motorPin = motorInfo(motor); if ((i % 3) == 0) { yi[k+1] = x; xi[k] = rawAngle; Serial.print(" | | Real ang: "); Serial.print(x); Serial.print(" -> Servo ang: "); Serial.print(calibrationAngle); Serial.print(" Enc: "); Serial.println(rawAngle); k++; } if (i >= stp) { swing = false; } i++; } } swing = true; i = 0; while (swing == true) { // moving unsigned long currentMicros = micros(); if (currentMicros - previousMicros >= 10000) { // save the last time you blinked the LED previousMicros = currentMicros; x = x2[motor] + float(i) * (x1[motor] - x2[motor]) / stp; calibrationAngle = a[motor] * x + b[motor]; servoWrite(motorPin , calibrationAngle); rawAngle , motorPin = motorInfo(motor); if ((i % 6) == 0) { yi[k+1] = x; xi[k] = rawAngle; Serial.print(" | | Real ang: "); Serial.print(x); Serial.print(" -> Servo ang: "); Serial.print(calibrationAngle); Serial.print(" Enc: "); Serial.println(rawAngle); k++; } if (i >= stp) { swing = false; } i++; } } swing = true; i = 0; while (swing == true) { // SECOND unsigned long currentMicros = micros(); if (currentMicros - previousMicros >= 10000) { // save the last time you blinked the LED previousMicros = currentMicros; x = x1[motor]; calibrationAngle = a[motor] * x + b[motor]; servoWrite(motorPin , calibrationAngle); rawAngle , motorPin = motorInfo(motor); if ((i % 3) == 0) { yi[k+1] = x; xi[k] = rawAngle; Serial.print(" | | Real ang: "); Serial.print(x); Serial.print(" -> Servo ang: "); Serial.print(calibrationAngle); Serial.print(" Enc: "); Serial.println(rawAngle); k++; } if (i >= stp) { swing = false; } i++; } } Serial.println(" | | Interpolation finished!"); /*-------Calculate linear interpolation of the encoder from 60 meassures done in swing------*/ double sx = 0; double sy = 0; double sx2 = 0; double sy2 = 0; double sxy = 0; double xmean = 0; double ymean = 0; int n = 300; for (int i = 0 ; i < n ; i++) { sx += xi[i+10]; sy += yi[i+10]; sx2 += xi[i+10] * xi[i+10]; sy2 += yi[i+10] * yi[i+10]; sxy += xi[i+10] * yi[i+10]; } ae[motor] = (n * sxy - sx * sy) / (n * sx2 - sx * sx); //sxy / sx2; // be[motor] = (sy - ae[motor] * sx) / n; //ymean - ae[motor] * xmean; Serial.println(" | | Moving back to ZERO position."); // turn the motor back to middle position swing = true; i = 0; while (swing == true) { unsigned long currentMicros = micros(); if (currentMicros - previousMicros >= 10000) { // save the last time you blinked the LED previousMicros = currentMicros; x = x1[motor] + float(i) * (90 - x1[motor]) / 60; calibrationAngle = a[motor] * x + b[motor]; servoWrite(motorPin , calibrationAngle); rawAngle , motorPin = motorInfo(motor); eang = ae[motor] * rawAngle + be[motor]; if ((i % 4) == 0) { Serial.print(" | | Servo ang: "); Serial.print(calibrationAngle); Serial.print(" -> Real ang: "); Serial.print(x); Serial.print(" -> Encoder ang: "); Serial.println(eang); } if (i >= 60) { swing = false; } i++; } } Serial.println("___|___|"); Serial.println(" | "); Serial.println("___"); Serial.println(" | Calibration finished satisfactory. Results data:"); Serial.print(" | HIGH lim: "); Serial.print(highLim[motor]); Serial.print(" LOW lim: "); Serial.println(lowLim[motor]); Serial.print(" | angle 1: "); Serial.print(ang1[motor]); Serial.print(" angle 2 "); Serial.println(ang2[motor]); Serial.print(" | Regression Motor a: "); Serial.print(a[motor], 5); Serial.print(" b: "); Serial.println(b[motor], 5); Serial.print(" | Regression Encoder a: "); Serial.print(ae[motor], 5); Serial.print(" b: "); Serial.println(be[motor], 5); Serial.println(" |"); Serial.println(" | ______________________________________________________________"); Serial.println(" | | |"); Serial.println(" | | This code won't be able to save the updated parameters |"); Serial.println(" | | once the robot is shutted down. |"); Serial.println(" | | |"); Serial.println(" | | Please, write down the results |"); Serial.println(" | | and save them in the definition of each variable. |"); Serial.println(" | |_____________________________________________________________|"); Serial.println(" |"); Serial.println("___|"); Serial.println(" Select another motor."); Serial.print("SELECTED MOTOR: "); Serial.print(motorTag[motor]); Serial.print(". SELECTED RESOLUTION: "); Serial.println(res); } interp = false; secuence = false; } } SAFE = false; Serial.println("Calibration killed"); } // END OF CALIBRATION

ESP32-S in Arduino Form FactorThe ESP32-S is, at least in my opinion, one of the most versatile microcontrollers available to the Maker at this moment. It ticks almost all of my boxes for features required in a microcontroller, with a lot of gpio’s, WiFi, and Bluetooth, as well as a lot of storage space for code. I do however have an issue with it, which I usually get around by designing a custom circuit board with a specific purpose. This is great for a project, but as most projects do not start on a custom-built circuit board, I am usually required to use a breadboard module. This is where my problems start. These modules are cumbersome to fit on a breadboard, to say the least, taking up a lot of space, and leaving very little space to connect to its pins with anything else.Some of these modules do not even fit on the breadboard, making it necessary to hang one side off the breadboard or use two breadboards with a gap in the middle. I am quite sure many people can relate to this problem. My second issue is that when you have done your breadboarding, and want to go to a permanent project, which does not always need a dedicated PCB, you are now required to either live with things on a breadboard, scary to say the least or have a “spider” with many modules and wires, in a box or partly on protoboard etc…My Solution, the ESP32-S DEV Board, in Arduino Uno form factorMy solutionWhile not the most elegant, personally I really like the size, and layout of the humble Arduino Uno, with its standardised pinouts, and a large number of addon shields available for the platform. This made me think, sure, there are already ESP32-based boards in this form factor available commercially, but why not make my own instead, as well as a few of my most used modules in a standardised shield form, to make my life just that little bit easier?The picture above shows my attempt, with most of the GPIO broken out onto female header pins (except for the 6 gpio that are connected to the internal flash chip on the module).The Blank PCB ( front )PCB- BackThe PCB explained…Power:The board can be powered in two ways, either via the VIN pin ( at an optimal 7.0v DC – the LDO regulator can handle up to 15v, but I personally find that to stress it a bit hard ), which will use the onboard LDO voltage regulator to provide the needed 3.3v or from an external 3.3v PSU, which can provide a bit more current if needed…There are also plenty of 3.3v and ground connections on the two 20-way headers to connect to other sensors. Strapping PinsAll the required strapping pins are pulled up or pulled down, as per the datasheet, to 3.3v or ground respectively. GPIO PinsAll GPIO pins are clearly labelled on the silkscreen to make it easier to use.I did however not stick to the Arduino labelling convention, as I don’t always use the Arduino IDE, and the actual GPIO numbers are in my view, more useful then. Flashing code to the boardIt will be quite obvious that I did not include any USB-to-serial converter on the board, the reason for this being that, in my opinion, 1) it wastes space on the board2) it is not actually necessary, as we can upload with an external uart adapter, or use OTA ( which I actually do most of the time )3) In an actual project, that USB port is going to attract problems, especially if you give it to someone else to use…A simple Arduino OTA sketch is available in the examples section of the Arduino IDE. It is easy to use and modify and does not need a lot to make it useable with your own sketch… Antenna CutoutAs recommended by the manufacturer , I have chosen to place the chip inside a cutout on the top of the PCB, with no tracks nearby.Figure 17: Keepout Zone for ESP32 Module’s Antenna on the Base BoardAlthough this is not the ideal “best position”, I found that this position worked well with previous designs, and have thus kept it at that.General commentsAs this board is mainly designed for prototype development, I did not bother with dedicated power connectors etc. I did however add proper wide tracks for all the power connections, an on-PCB-heatsink for the voltage regulator, as well as proper ground planes on both sides of the PCB, connected together with via-stitching where needed. It is also very important to note that this is a 3.3v device. If you need to use sensors or peripherals that operate at other voltages, you will have to use external level converters. Some assembly picturesAfter Solderpaste applicationBefore ReflowAfter ReflowAfter final assemblySchematic

Analog audio amplifiers are very powerful enough to make a high noise with stable quality factor. I have designed a lot of IC based audio amplifier boards previous year. And today I am designing an OLD-GOLD amplifier using 1980’s STK4141 IC. This amplifier has a different sound environment which match to the theme of old era. A little noise with dual speakers gives the feeling of old HI-FI speaker system. This is the most popular IC of that time used in most of car stereo system and has a compact size.I am using PCBWAY prototyping service, PCBway is the one of the leading PCB manufacturer company in China for more than 15 years of experience. Get the top-quality product in reasonable prices, quote now and know more about the services.Ratings and features:Recommended speaker: 8 ohmsWide power supply range: 12v to 39volts (Dual supply)Stereo channel (25+25 watts)Thermal protection and mute optionsThis IC has dual channel stereo output and a very wide input range, works very well on 8ohms load speaker. The maximum power delivery is 25 watts per channel. This IC is developed by Sanyo, Tokyo. The recommended supply voltage is 26volt, standard 24-0-24 @3amp is enough to get the full output.Components required:STK4141 audio amplifier56k, 2.2k, 1k, 560R, 100R and 4.7R resistors220uf, 100uf, 47uf and 1uf electrolytic capacitors100nf, 470pf ceramic capacitorsCentre tapped transformerFiltered power supplyCustom PCB from PCBWAYCircuit diagram:The datasheet circuit is the practical one, but there is a mistake in the polarity of the capacitor. The datasheet is very old and circuit values are not visible enough. But it is recommended to connect high capacitance filters in the power supply lines.There are two power operational amplifiers inside the single package of STK4141 ic which is used separately to give an output of 25+25 watts. The basic principle remains the same we are using non inverting configurations with a closed loop gain of 100. Some other circuitry is also required for proper action and to set the biasing conditions.Transformer and power supply:A dual channel power supply which can output -24,0, +24 is required, I have built one previously using rectifier and filters. Which work fine with center tapped transformer and has protection features also. See dual channel filtered power supply from here.PCB and designs:I designed my files according to the updated schematics and turn it into PCB using Altium designer. You can download the Gerber files from here if you want to go with the same designs.I used blue color, hasl finish and 1.6mm thickness of fr4 material specs to manufacture these boards from PCBWAY. PCBWAY is providing prototyping service in just $5 for 10 pcs of 2-layer boards. You can also check PCBA, 3D printing, Stencil service and CNC from the official PCBWAY.com. Register now using this link and get new user free PCB coupons for the first order.Soldering and mounting components:First solder all the resistors then go with the capcaitors. Solder the joints properly when working with audio applications because any dry joint my cause humming issues. After soldering all the components go for the IC STK4141. And remove the access soldering residue using alcohol.Mounting the heatsink:STK comes with an aluminum back which acts like a heatsink but for heavy load it is not enough. That’s why a bigger aluminum piece is needed for heat dissipation. Add a little bit of heatsink compound in between the IC and heatsink and then tight it using the screws. Now you can run the amplifier on 100% potential and no need of any type of active cooling is needed anymore.Connections:There are 3 terminals are given for the input, output and power. Power connections are simple just connect a DC filtered power supply of dual channel. VCC to +24, VEE to -24 and GND to centre zero reference. Input can be supplied using any Bluetooth or Aux cable directly from the phone. Connect speakers on the output terminals. GND remains common everywhere so two wire are connected to GND and other to the SPK terminals.Working of amplifier:As I said earlier it gives a feeling of old music era, I don’t now but the IC itself made the effect which gives relaxation. If you are fond of listening old music then this might be an amplifier for you. There is slight high treble and normal bass effects when using normally without any preamplifier circuits. This amplifier is not made for the heavy bass output, just connect 2 stereo speakers and listen. You can see the bass output and stereo speakers output in the video given above.