INTRODUCTIONSince I was six, I thought it would be cool to make my own web caster. Not knowing much then, I thought I could have an explosive shoot out fishing line with a suction cup on the end and it could do the trick. 3D printers were just getting somewhat affordable and we didn't have one at the time. So, the project idea was shelved. Since then, my Dad and I have become Makers. It gave me a thought, what if in the Spider-Verse there was another character - say, 14 years old, only child, grew up with old motors and mechanical parts in the basement and electronics tools. He's accumulated two 3D printers and a welder. At 9, he started a Maker channel (Raising Awesome). His dad impulse bought a sewing machine on Prime Day, and THEN, at 14, he was bitten by the radioactive Maker bug...well arachnid. He was a Maker first - then got his Spidey powers. What would that character be like?So, we dreamed up a Webslinger Gauntlet and Spidey-Sense Visual AI Circuit.PROJECT DESIGNWebslingerThe webslinger gauntlet houses a 16gram CO2 cartridge to use a burst of pressure to shoot out a hook that is tethered with Kevlar. No MCU is needed for this, just a valve like you find for inflating bike tires. It will has a motor in the gauntlet to retrack the Kevlar. Spider-SenseThe camera & proximity sensor was sewn into the back of the shirt. The Raspberry Pi A+ served as a brain for the full suit, controlling all sensors and cameras within the suit. Along with that, we used a Pi SenseHat with its built in RGB display to change logos like when the "Spidey Sense" is triggered. With the timing of this contest, I was able to score one last Halloween costume.You can find the model on our GitHub site: https://github.com/RaisingAwesome/Spider-man-Into-the-Maker-Verse/tree/master.This is the code to trigger the RGB and vibration:from sense_hat import SenseHat import time import RPi.GPIO as GPIO # GPIO Mode (BOARD / BCM) GPIO.setmode(GPIO.BCM) # set GPIO Pins GPIO_ECHO = 9 GPIO_TRIGGER = 10 GPIO_VIBRATE = 11 # set GPIO direction (IN / OUT) GPIO.setup(GPIO_TRIGGER, GPIO.OUT) GPIO.setup(GPIO_ECHO, GPIO.IN) GPIO.setup(GPIO_VIBRATE, GPIO.OUT) sense = SenseHat() g = (0, 255, 0) b = (0, 0, 255) y = (255, 255, 0) w = (255,255,255) r = (204, 0, 0) a1 = [ b, r, b, b, b, b, r, b, b, r, b, b, b, b, r, b, b, b, r, r, r, r, b, b, b, b, b, r, r, b, b, b, r, r, r, r, r, r, r, r, b, b, b, r, r, b, b, b, b, b, r, b, b, r, b, b, b, r, b, b, b, b, r, b ] a2 = [ b, b, r, b, b, r, b, b, b, r, b, b, b, b, r, b, b, b, r, r, r, r, b, b, r, b, b, r, r, b, b, r, b, r, r, r, r, r, r, b, r, b, b, r, r, b, b, r, b, b, r, b, b, r, b, b, b, b, r, b, b, r, b, b ] a3 = [ r, b, b, b, b, b, b, r, b, r, b, b, b, b, r, b, b, b, r, r, r, r, b, b, r, b, b, r, r, b, b, r, b, r, r, r, r, r, r, b, r, b, b, r, r, b, b, r, b, b, r, b, b, r, b, b, b, r, b, b, b, b, r, b ] def animate(): # dist is given in feet. # speed is calculated by a linear equation y=mx+b where b=0 and m=.1 sense.set_pixels(a1) time.sleep(.05*distance()) sense.set_pixels(a2) time.sleep(.05*distance()) sense.set_pixels(a1) time.sleep(.05*distance()) sense.set_pixels(a3) time.sleep(.05*distance()) def distance(): # Returns distance in feet StartTime = time.time() timeout = time.time() timedout = False # set Trigger to HIGH to get the system ready GPIO.output(GPIO_TRIGGER, True) # set Trigger after 0.00001 seconds (10us) to LOW to send out a ping from the sensor time.sleep(.00010) GPIO.output(GPIO_TRIGGER, False) # so we don't wait forever, set a timeout to break out if anything goes wrong. while GPIO.input(GPIO_ECHO) == 0: # if we don't get a response to let us know its about to ping, move on. # the sensor should trigger, do its thing, and start reporting back in milliseconds. StartTime = time.time() if (time.time()>timeout+.025): timedout=True break #print("Echo from low to high trap timed-out: ",timedout) timeout = StartTime StopTime=StartTime while GPIO.input(GPIO_ECHO) == 1: # if we don't get a bounce back on the sensor with the top of its range of detection, move on. # Ultrasonic travels at the speed of sound, so it should pong back at least this # fast for things within the top of its dectection range. timedout=False StopTime = time.time() if (time.time()>timeout+.025): timedout=True break #print("Echo from High back to Low timed-out: ",timedout) # record the time it ponged back to the sensor # time difference between start and arrival TimeElapsed = StopTime - StartTime # multiply with the sonic speed (34300 cm/s) # and divide by 2, because it has to get there over the distance and back again # then convert to feet by dividing all by 30.48 cm per foot distance = (TimeElapsed * 17150)/30.46 #print("Distance: ",distance) if (distance<.1): distance=5 distance=round(distance) if distance<5: vibrate() return distance def vibrate(): #if something is very close, vibrate the spidey-sense #code pending GPIO.output(GPIO_VIBRATE, True) time.sleep(.1) GPIO.output(GPIO_VIBRATE, False) # The next line will allow for this script to play stand alone, or you can # import the script into another script to use all its functions. if __name__ == '__main__': try: GPIO.output(GPIO_TRIGGER, False) GPIO.output(GPIO_VIBRATE, False) time.sleep(1) while True: animate() # The next line is an example from the SenseHat library imported: # sense.show_message("Sean Loves Brenda and Connor!!", text_colour=yellow, back_colour=blue, scroll_speed=.05) # Handle pressing CTRL + C to exit except KeyboardInterrupt: print("\n\nSpiderbrain execution stopped.\n") GPIO.cleanup() Visual AIIf you've seen Spider-man: Homecoming, you'd know about the all new Stark branded AI, Karen, that Peter uses in his mask to assist him in missions. Karen was designed to be able to highlight threats and alert Peter of his surroundings, along with controlling many of his suit functions. While making an AI chatbot that responds with a voice and sense of emotion may not be the easiest thing to accomplish for this competition, we did think ahead to include a way to create this artificial "Spidey-Sense." We decided now would be a good time to take advantage of the surge in popularity of the Microsoft Azure, and the Machine Vision API provided by Microsoft.We built a "see-in-the dark" solution with the Raspberry Pi Model A and a NoIR camera: The Microsoft Computer Vision cloud service is able to analyze things in an image which is taken by the Raspberry Pi camera (aka my Pi-der cam) that is mounted to a belt. To activate this super sixth sense, I have to be very still. Once the accelerometer of the Sense Hat stabilizes, the picture is taken automatically. Using my cell phone's personal hot spot, the Azure API analyzes the image and the Raspberry Pi's eSpeak package let's me know through an earpiece. This allows the suit to be able to tell if a car is close behind me, or maybe an evil villain.Python Visual AI for Microsoft Azure Machine Vision:import os import requests from picamera import PiCamera import time # If you are using a Jupyter notebook, uncomment the following line. # %matplotlib inline import matplotlib.pyplot as plt from PIL import Image from io import BytesIO camera = PiCamera() # Add your Computer Vision subscription key and endpoint to your environment variables. subscription_key = "YOUR KEY HERE!!!" endpoint = "https://westcentralus.api.cognitive.microsoft.com/" analyze_url = endpoint + "vision/v2.0/analyze" # Set image_path to the local path of an image that you want to analyze. image_path = "image.jpg" def spidersense(): camera.start_preview() time.sleep(3) camera.capture('/home/spiderman/SpiderBrain/image.jpg') camera.stop_preview() # Read the image into a byte array image_data = open(image_path, "rb").read() headers = {'Ocp-Apim-Subscription-Key': subscription_key, 'Content-Type': 'application/octet-stream'} params = {'visualFeatures': 'Categories,Description,Color'} response = requests.post( analyze_url, headers=headers, params=params, data=image_data) response.raise_for_status() # The 'analysis' object contains various fields that describe the image. The most # relevant caption for the image is obtained from the 'description' property. analysis = response.json() image_caption = analysis["description"]["captions"][0]["text"].capitalize() the_statement="espeak -s165 -p85 -ven+f3 \"Connor. I see " +\"" + image_caption +"\" --stdout | aplay 2>/dev/null" os.system(the_statement) #print(image_caption) spidersense() BUILD VIDEOTo see this all come together, here is our build video:

First of all, I'm a 15 years old student. And sometimes when you're working on a computer, you have to press some key combinations. Creating a new document for online school or opening the browser. Sometimes that can be quite annoying. So I thought, why not making a cost-effective Macro-Keyboard with a Raspberry Pi Pico and some satisfying CherryMX-Keyswitches - And that's what I did. It's 100mmx61mm PCB. It consists of 12 CherryMX-Keyswitches. I used green ones, but you can choose any type of CherryMX-Keyswitch. Every Button can be lit individually. So therefore you also need 12 3mm-LED's. I used green ones for the Razer- Look. But you can of course use any color. Next up you need 6 5mm-WS2812B with 6 0603 100nF-Capacitors. If you choose not to use RGB-LED's, you can also leave the WS2812B-LED's and the capacitors behind. As a Pullup-Resistor you'll also need 12 0603 Resistors. I used 1K. I also recommend to use a good USB-Connector. I used a USB-B-Female Connector for better stability. Because the Micro-USB-port on the RaspberryPi-Pico itself can be ripped off very easily (trust me ;). If you want to build one yourself, follow the following steps:Gather the PCBFirst you need to download the gerber-file given below. To support me, you can directly buy it over the "Add to cart"-Button. 10% will be distributed to me ;)Gather the componentsThese are the components needed for my build:12 x CherryMX-Keyswitches12 x 1K 0603 Resistors12 x 3mm TH-LED's 6 x WS2812B-LED's (5mm)6 x 100nF 0603 Capacitor1 x Encoder1 x USB-B-Female-Connector1 x Raspberry Pi PicoWiresSolder everything togetherNow it's soldering time! :)This soldering-project is very beginner-friendly and can be made by anyone!But before starting to solder: Please make sure to solder the middle 3 Buttons first before soldering the Pi Pico in place. Because you can't solder on the button, LED's and Resistors when the Pi Pico is already soldered on. And that's basically it. Now you just need to program the whole thing. You have 2 possibilities: CircuitPython and Arduino IDE. I prefer the Arduino IDE. But unfortunately there are not many libraries supported by the Pi Pico yet.Programming

Introduction:This project shows the implementation of contact-less temperature measurement with segment display.The sensor MLX90614 is interfaced with Raspberry Pi Pico using I2C communication. The segment display driver is also controlled overI2C commands. This entire setup is wired up on the breadboard.Raspberry Pi Pico:I have ordered a couple of boards and want to make some tutorials out of that. As 1st step i made getting start guide for Raspberry Pi Picoits documented here (https://www.hackster.io/ashokr/getting-start-with-raspberry-pi-pico-87e4f9)Thonny IDE:The coding is done using micropython, Thonny IDE is used for development. The IDE is too good for anyone to easily write-upcode for Raspberry Pi Pico.Working Demo:The working demo of this project is published on you-tube here

Here, We are going to make an Automatic Watering System using Raspberry Pi Pico, which waters the plant every 8 hours or depending on the soil moisture level. Let's see how I made it. Hardware Components 1. Raspberry Pi Pico x 1 - https://www.dfrobot.com/product-2187.html?tracking=qlFCvkDilNCTmTOSEGHNIxeqgaQGOp3SZCnaR13VZAG86M3mWPrLMfa9i9kvCzRL 2. Water pump x 1 - https://www.dfrobot.com/product-1710.html?tracking=qlFCvkDilNCTmTOSEGHNIxeqgaQGOp3SZCnaR13VZAG86M3mWPrLMfa9i9kvCzRL 3. Soil Moisture Sensor x 1 - https://www.dfrobot.com/product-599.html?tracking=qlFCvkDilNCTmTOSEGHNIxeqgaQGOp3SZCnaR13VZAG86M3mWPrLMfa9i9kvCzRL 4. RGB LED x 15. Breadboard x 16. Power bank x 1 Software Components 1. MicroPython2. Thonny IDESTEP 1 - Setting up Raspberry Pi Pico1. Download the micropython firmware from https://micropython.org/download/rp2-pico/ 2. On the Raspberry Pi Pico, Press the BOOTSEL button and hold it while you connect the other end of the micro USB cable to your computer. This puts your Raspberry Pi Pico into USB mass storage device mode. 3. Drag and drop the downloaded .uf2 firmwareNow the Raspberry Pi Pico is ready to be programmed. Open Thonny IDE, select the interpreter as MicroPython(Raspberry PI Pico).STEP 2 - ConnectionsYou can find the Pinout of the Raspberry Pi Pico below. Make the connections as shown below. We have an internal RTC to get the time. Here we connect Water Pump, Soil Moisture Sensor, RGB LED to the Raspberry Pi Pico. 5V Water Pump ->GPIO26Soil Moisture Sensor ->GPIO27LED_Pin1 -> GPIO14LED_Pin2 -> GPIO13LED_Pin3 -> GPIO12STEP 3 - FunctionalityFirst, we will interface with the internal RTC to get the current time. We will trigger the water pump every 8 hours. The Moisture level is also continuously monitored. If the soil moisture drops, then the water pump is activated for 5 to 10 seconds. In this way, the plant is supplied with sufficient water at regular intervals. Reading the Soil moisture sensor as a digital input. We toggle the LEDs and the water pump depending on the sensor value. STEP 4 - CodeYou can find the code on my GitHub repository. Link to the Project repo: https://github.com/Rahul24-06/Automatic-Plant-Watering-System-using-Raspberry-Pi-Pico-CODE from machine import Pin import time import utime red_led = Pin(14, Pin.OUT) #RED LED green_led = Pin(13, Pin.OUT) #GREEN LED sensor = Pin(27, Pin.IN, Pin.PULL_DOWN) pump = Pin(26, Pin.OUT) #pump print() print(" YYYY MM DD HH MM SS") dateTime = (input ("Enter current date & time: "))+' 0 0' synchronisedTime = utime.mktime(list(map(int, tuple(dateTime.split(' '))))) timeDelta = synchronisedTime - int(utime.time()) def timeNow(): return utime.localtime(utime.time() + timeDelta) def pump_on(): red_led.value(1) green_led.value(0) pump.value(0) time.sleep(10) print("Pump On - Watering the Plant") def pump_off(): red_led.value(0) green_led.value(1) pump.value(1) print("Plant is healthy.") while True: dateTime = timeNow() #print("{:02d}-{:02d}-{:04d} {:02d}:{:02d}:{:02d}".format(dateTime[2],dateTime[1],dateTime[0],dateTime[3],dateTime[4],dateTime[5])) utime.sleep(1) if (dateTime[3] == 8 and dateTime[3] == 16 and dateTime[3] == 0): if (dateTime[4] == 0 and dateTime[5] == 0): pump_on() else: pump_off() elif sensor.value(): pump_on() else: pump_off() STEP 5 - WorkingThis setup is placed on a pot and is powered using a power bank. One of the water tubes is connected between the water pump and a water bottle, and the other tube from the water pump is connected to the soil.We finally did this project successfully. If you faced any issues in building this project, feel free to ask me. Please do suggest new projects that you want me to do next. Give a thumbs up if it really helped you and do follow my channel for interesting projects. :) Share this video if you like. Blog - https://rahulthelonelyprogrammer.blogspot.com/ Github - https://github.com/Rahul24-06/Happy to have you subscribed: https://www.youtube.com/c/rahulkhanna24june?sub_confirmation=1 Thanks for reading!

My goal was to use the CircuitPython Gamepad libraries, in conjunction with a Raspberry Pico, and allow you to use your NES controllers with your computer, or a Raspberry Pi (imagine playing NES games on your RetroPie setup using an original controller!)The code and build is pretty straight forward, and you could easily 3d print a case for this and make it a permanent adapter. Here's the video that guides you through the process! https://www.youtube.com/watch?v=Fipmq0VcJd4

I thought it would be fun to build a project around the hit arcade game, Space Invaders. I added a little more challenge to it by using a screen that only has 128x64 pixels, less than half the resolution of the original game. The final result is something that looks, sounds, and even feels like the original game, but a whole lot smaller.Full walkthru of code, and assembly instructions are provided on my YouTube channel, https://www.youtube.com/watch?v=O5S1LC5TFiM& .

Raspberry Pi 4 NAS out of an old power amplifierStory:I had played around with the NAS feature of my router in the past, but quickly reached its limits. Since then, I was looking for a NAS solution for my whole family. Best to build it myself. I already had a few Raspberry Pis at home and when the PI 4B came out, this was the perfect moment to get this project started.Around the same time, a power amp at my school broke. Since I am involved in sound engineering there, it was no problem to get hold of it. So, I had a case in which all components would fit.This project is divided into two parts.In part 1 we take care of the hardware, i.e. the cabling of the individual devices and especially also the installation in the power amp case.In part 2 we will install the operating system and set up the NAS.If you are only interested in the software part and setting up the NAS with Ubuntu Server, you can jump straight to the second part.Attention! Working on mains voltage is life threatening and should only be done by qualified personnel. Some steps shown here should only be done if you know exactly what you are doing. Furthermore, a multiple socket, as shown here, should never be used for permanent installations.Specs:Raspberry Pi 48 GB DDR3 SDRAMGigabit Ethernet4 TB RAID 1 StorageWhat you need:Note: For a pure Raspberry Pi 4 NAS without amp case, we only need those articles in bold.Raspberry Pi 4B (I recommend the 8GB RAM version, as it is not much more expensive compared to other NAS solutions)Power supply (PSU) for the Pi (5V, 3A, 45W, UBS-C, surge- and overload protection)Micro SD card (32GB)Active cooling case for the PiUSB 3 Hub (This turned out later)Active USB-SATA adapterHard drives (4TB WD red)Power supply for the case fans (24V, 4.5A)2 relay board (to switch the two case fans and the fan on the Raspberry Pi)Ethernet feedthrough (To connect an Ethernet cable to the case, as it would be with a real server)Ethernet patch cable (20cm)Switch (250V, 10A, for the Case)Fuse (4.5A)MC 7805 (Fixed voltage regulator)Capacitors (2200μF, 10 μF, 100nF – more details later)Diode (1N4001)Jumper cablesPart 1 - The enclosure (not important for the NAS itself)Mounting the devices:After opening the 19" case, and removing the actual PCB, I was also able to unscrew the front panel and get access to the fans. Of course, these had to be cleaned first. I decided to further disassemble the front panel and spray paint it completely black. In order for the paint to hold better, I had to sand it down a bit.Then I had to think about the actual allocation of the devices in the case. This was only possible to a limited extent before, because I didn’t have any specifications of the power supplies for the USB-SATA adapters. I had originally wanted to take a black multi-socket, but the plugs there were arranged at an 45° angle, so that the power supplies would then have been too high and would no longer have fit into the housing. Therefore, I had to search for a multi-socket with straight plugs.Now that I knew what should go where, I could start attaching the parts. The Ethernet feed through I could simply attach to the place of a previous speakOn port, for this I only had to drill two holes for the screws. For the relay, the 24 V power supply and the Raspberry Pi, I marked the holes and punched them so I could drill them with a 2.5 and 3mm drill bit. I was able to immediately screw the 24V power supply to the bottom of the case. But since the relay module was not insulated at the bottom side of the PCB, I had to mount it on spacers and attach a small plastic sheet.I had long been wondering how I would mount the Raspberry Pi. In the end, the best solution was to mark the four holes of the base plate, with a scriber on the bottom of the amp, and then screw the Raspberry Pi case to the power amp case with longer screws. Since the fans were clean again in the meantime, I could screw them into the case as well.In order not to damage the hard drives during assembling the NAS, I took two old ones to mark the proportions. Then the hard drives were fixed with metal brackets. To allow air to get under the hard drives and reduce vibrations at the same time, I packed rubber spacers between both, the metal brackets and the case bottom.After all the important components were fixed, I could start the wiring.AC wiring:I decided to use the screw terminals on the 24V power supply to be able to connect the multisocket there. So I had to remove the plug, and strip the three stranded wires. I crimped ferrules onto the stripped ends and then screwed them (L2, N2, PE2) to the AC input side of the terminal block on the 24V power supply.From the incoming mains cable, I was able to connect the neutral conductor (N1) directly to the power supply, using a wire end ferrule.The phase (L1), I first connected to a 4.5A fuse. In my case, I was able to insulate the solder joints of the fuse holder well with heat shrink tubing and electrical tape.Then L1 was looped to the switch (250V, 10 A). There I used insulated cable lugs to be able to plug and unplug the switch easily. Next, the phase was pulled back to the power supply. Since I have an illuminated switch, I also had to connect the neutral (N3) to the switch.Because only two cable ends fit on the terminal strip of the 24V PSU, this neutral conductor (N3) had to be connected with a terminal plug.I also screwed the protective conductor (PE2) of the multiple socket to the terminal strip of the power supply.In order to be able to connect the protective conductor of the mains cable and the power supply (PE3) and the incoming cable (PE1) with the housing, I have sanded down an unpainted area again and screwed both protective conductors using a toothed ring.After an isolation test, I was able to plug it in for the first test. Fortunately, nothing blew up in my face, nothing exploded, and everything behaved as it should.... except the switch… Wiring this power switch was a bit difficult, as it had an LED that was supposed to indicate if the switch was set to on or off.... but it was not quite clear in which positions what happened. So it took me a few tries before I knew the correct wiring, as the manufacturer did not include instructions.DC wiring:This seems complicated because there are many cables, but it is relatively simple.To reduce a few cables and to be able to connect the fans well, I soldered a board to which I can plug both fans on one side and the 24V is connected on the other side. GND goes directly to the power supply and +24V are switched via relay 1. As it turned out later, the fans vibrated very strongly at 24V. At 20V, however, they ran quietly. Therefore I soldered a 85 Ohm power resistor in front of each fan. From the fan of the Raspberry Pi you can also plug GND directly to a GPIO. I connected the +5V with a jumper cable to relay 2 and led it back again, so I didn't have to cut and solder a cable. This would make the fan more replaceable.To switch the relay, we need to connect +5V (VCC) and GND (GND) from the Raspberry Pi as power supply to the relay module. We also need GPIO 04 (IN1) and GPIO 17 (IN2) to switch the relays. The jumper has to be set between VCC and RVCC. Now the relay would theoretically already work, but the Raspi would not be galvanically separated from the relay module.To achieve this by using the optocouplers on the PCB, the jumper must be removed and a voltage of +5V must be connected to RVCC and GND.Since I don't have a 5V voltage source in the case, I built myself a voltage converter with a fixed voltage regulator with the following schematic:On the in pin of the MC7805 +24V are applied. Also an electrolytic capacitor is connected between +24V and GND. The middle pin (GND) is also connected to GND and the Out pin is connected to RVCC on the relay board. Between the out pin and GND an electrolytic capacitor with 10μF and a ceramic capacitor with 100nF are connected. To protect the MC7805 from a too high voltage at the out pin, a 1N4001 diode is connected between In and Out. The capacitors smooth the voltage. The GND of the circuit is connected to GND on the relay board.Because 19V drops at the fixed voltage regulator, it can get very hot. Therefore I took an old heat sink, which was previously installed in the power amp, and attached the MC7805 to it. I used a fixed voltage regulator instead of a DC/DC converter, because I had one at home. In addition, the 5V are only needed for the switching operations of the relay. Therefore the heat sink is theoretically not necessary. But since I might need the 5V output for other stuff and it does look good, I decided to use it.Now all that's left to do is plug in the power supplies, connect the hard drives to the Pi, and create a connection with the 20cm patch cable between the Pi and the Ethernet feedthrough.At this point it is important to add that it turned out later that you need an additional active USB hub between the Raspberry Pi and the active SATA USB adapters. When setting up the NAS, I struggled almost continuously with one of the disks being kicked out. sudo dmesg always returned errors that looked like this:over current change #54. There were other errors, but they were software related. After weeks of trying and researching I found someone with the same problem. His hard drives were also thrown out, although he also used active SATA USB adapters. Indeed. With an active USB hub I didn't get these error messages anymore. Interesting to know is that the active USB hub drew only 0.2A(DC) in IDLE and almost 1A(DC) in use. From this I conclude that the active adapters could not supply enough current. Now that the Raspberry Pi has been expanded with more USB3 ports, I'm also thinking of moving the operating system to an SSD, as these are more durable than SD cards.Of course, good cable management is important, so that cables do not unplug themselves and that it is easier to upgrade later.To stop dust that would be sucked in by the fans, I sandwiched a strip of filter floss for servers between the chassis and the fans.After flashing the Micro SD card (See Part 2) I was able to insert it into the Raspberry Pi and then attach the black painted front panel as well as the lid.About switching the fans: Since the fans do not support PWM out of the box, it would be an idea to control the fans with MosFets instead of just a relay, to control their speed proportional to the temperature.Also, mac587 had suggested on hackster, where I had presented the project a few months ago, to use an ATX power supply as power source. So you could save the voltage converter and run fans with only 12V.Now we continue in part 2, since we have already done everything that has to do with hardware.Part 2 - SoftwareInstall operating systemTo get the operating system onto the SD card, we use the Pi imager.There we select Choose OS -> Other general purpose OS -> Ubuntu -> Ubuntu Server 20.XX.x LTS (RPi 3/4/400).And then choose your SD card.Then press "Write" The process took me about 6 minutes.Get the IP of the RaspberryAfter the SD card is in the Pi and it is turned on, it should appear on your router's user interface after a few seconds.At my Fritz!Box you can find the IP under Home Tetworks -> Mesh -> Other connected or registered home network devices.There you should give the device a static IP, so that you don't have any problems later when mounting e.g. in fstab.Access the Pi via SSHTo get access to the Raspberry Pi via SSH, we open a terminal on the PC and type:ssh ubuntu@ubuntu or?ssh ubuntu@"IP_of_your_pi". the default password is ubuntu but the password should be urgently replaced with a strong password, otherwise an attacker will have access to all data stored on the NAS.After that you will be logged out and have to log in again with your new password.First steps on a new OSHints and tipsUse tab in terminal for auto-complete.Exit nano with Ctrl+x and confirm changes with y.Select a text section in nano: Alt+A+M and then move with the arrow keys. Ctrl+arrow key then selects the whole paragraph at once.Cut selected text in nano: Ctrl+KUpdate the Raspberry Pisudo apt-get update sudo at-get full-upgrade If errors occur here, just rebooting will help.Make SSH more secureNote: Since the NAS will only be accessible from the home network anyway, this is not absolutely necessary. This measure helps to make attacks on port 22 useless, but with a portscan you can also find out the actually used port. Therefore, a strong password is more important for every user. More help would be provided by fail2ban and access via certificate.For this we need to change the default SSH port and disable root login. This is done in the SSH configuration file under /etc/ssh/sshd_config:sudo nano /etc/ssh/sshd_config Here we have to remove the "#" in line #Port 22 and change "22" to any other port (e.g. 2846).Also, in the line #PermitRootLogin prohibit-password, the "#" should be removed and "prohibit-password" should be replaced by " no".This should look like this:Port 2846 #AddressFamily any #ListenAddress 0.0.0.0 #ListenAddress :: ? #HostKey /etc/ssh/ssh_host_rsa_key [...] ? # Authentication: ? #LoginGraceTime 2m PermitRootLogin no ?To make the changes take effect immediately, we restart ssh:sudo /etc/init.d/ssh restart Allow selected port in the firewallSince we changed the default port of SSH, sudo ufw allow OpenSSH won't work anymore. Therefore, we need to use the following command to allow the newly selected port:sudo ufw allow 1636 Now the port must be specified when logging in via SSH:ssh ubuntu@ubuntu -p 2846 Change hostnameSince I have installed several Ubuntu servers and want to recognize my NAS better in the home network afterwards, the hostname will be changed. Note: After that the RPi is no longer reachable via ssh under ssh ubuntu@ubuntu -p 2846 but under ssh ubuntu@rpi-nas -p 2846.With hostnamectl we can display the current hostname:$ hostnamectl Static hostname: ubuntu Icon name: computer Machine ID: e5e5d4e8666c456488d91bc2735712d0 Boot ID: 1fdeecd84e8f48c499c520978bc60358 Operating System: Ubuntu 20.04.2 LTS Kernel: Linux 5.4.0-1029-raspi Architecture: arm64 With the set-hostname option we can set a new hostname:sudo hostnamectl set-hostname rpi-nas Then we have to add the line 127.0.0.1 rpi-nas to the /etc/hosts file:sudo nano /etc/hosts It should then look something like this:127.0.0.1 rpi-nas # The following lines are desirable for IPv6 capable hosts ::1 ip6-localhost ip6-loopback fe00::0 ip6-localnet The last thing to do is to change a value in the cloud.cfg file:sudo nano /etc/cloud/cloud.cfg Search here for preserve_hostname: and change the value to trueTo make sure everything worked, we run hostnamectl again.$ hostnamectl Static hostname: rpi-nas Icon name: computer Machine ID: e5e5d4e8666c456488d91bc2735712d0 Boot ID: 1fdeecd84e8f48c499c520978bc60358 Operating System: Ubuntu 20.04.2 LTS Kernel: Linux 5.4.0-1029-raspi Architecture: arm64 Add non-root userThe last thing we do is to add a default, non-root user, which we will work with from now on.To do this:sudo adduser config Add the user to the sudo group:sudo usermod -a -G sudo config Now we switch to the new user and run a command that requires root right to make sure everything worked:sudo su - config sudo apt-get update Python scripts to cool the NASCooling the Raspberry PiFirst, you need to install some packages:sudo apt-get install python3-pip sudo pip3 install Rpi.GPIO pip3 install gpiozero pip3 install pigpio sudo apt-get install rpi.gpio-common sudo apt-get install python3-rpi.gpio Then the group gpio must be created, the current user (config) must be added and the group must get rights for the GPIOs:sudo groupadd gpio # Add the group sudo usermod -a -G gpio $USER # Add the current user to the new group sudo grep gpio /etc/group # Assure that everything is working sudo chown root:gpio /dev/gpiomem # Change the gpio owner to root sudo chmod g+rw /dev/gpiomem # Add read and write permissions Alternatively, the current user may also own gpiomem:sudo chown root:$USER /dev/gpiomem Now we create another folder where the python scripts will be placed, and also the python script itself. The code that needs to be inserted is found on GitHub:mkdir code cd code mkdir python cd python nano cooling_pi.py # now paste the code from GitHub sudo chmod u+x cooling_pi.py # Make the script executable To ensure that the Pi is reliably cooled after each reboot, we add the following line to the crontab. To log any errors that occur, we also create a log file:cd log/ touch cron_user.log crontab -e @reboot python3 /home/config/code/python/cooling_pi.py > /home/config/log/cron_user.log 2>&1 # Insert this line. Cooling the HDDsTo be able to read out the temperatures of the hard disks, hddtemp must be installed:sudo apt-get install hddtemp The following line can be used to read out the temperature for a hard disk:for i in /dev/sdX ; do sudo hddtemp sata:$i; done For the script we create a new folder for shell scripts in the directory./code. There we will create a script for each disk (code on GitHub) Since the readout requires root rights, but the python script is executed by a non-root user, the owner of the shell scripts must be changed to root, as well as the file rights must be adjusted.cd code/ mkdir shell cd shell/ nano sda_temp.sh # For HDD1 nano sdb_temp.sh # For HDD2 sudo chown root:root sda_temp.sh sdb_temp.sh # Change the owner sudo chmod 755 sda_temp.sh sdb_temp.sh # Assign the relevant file permissions sudo visudo # To avoid the need to enter a password, insert those two lines config ALL=(ALL) NOPASSWD: /home/config/code/shell/sda_temp.sh config ALL=(ALL) NOPASSWD: /home/config/code/shell/sdb_temp.sh Now we create the python script and add it to the crontab.cd code/python/ nano cooling_hdd.py # now paste the code from GitHub sudo chmod u+x cooling_hdd.py # Make the script executable crontab -e @reboot python3 /home/config/code/python/cooling_hdd.py > /home/config/log/cron_user.log 2>&1 # Insert this line. Create Software RaidNow it finally comes to create the raid using mdadm.First, let's display the available disks to check that everything is working fine.sudo lshw -short H/W path Device Class Description =============================================== system Raspberry Pi 4 Model B Rev 1.4 /0 bus Motherboard /0/1 processor cpu /0/2 processor cpu /0/3 processor cpu /0/4 processor cpu /0/5 memory 7811MiB System memory # 8 GB RAM /0/0 bridge Broadcom Inc. and subsidiaries /0/0/0 bus VL805 USB 3.0 Host Controller /0/0/0/0 usb1 bus xHCI Host Controller /0/0/0/0/1 bus USB2.0 Hub /0/0/0/1 usb2 bus xHCI Host Controller /0/0/0/1/1 storage ASM105x /0/0/0/1/2 storage ASM105x /0/6 scsi0 storage /0/6/0.0.0 /dev/sda disk 4TB ASM105x # HDD1 /0/6/0.0.0/1 /dev/sda1 volume 3726GiB EXT4 volume /0/7 scsi1 storage /0/7/0.0.0 /dev/sdb disk 4TB ASM105x # HDD2 /0/7/0.0.0/1 /dev/sdb1 volume 3726GiB EXT4 volume /1 wlan0 network Wireless interface /2 eth0 network Ethernet interface If the hard disks are not partitioned yet, we will do that first. Note that for disks larger than 2TB, GPT must be used instead of MBR as the partition table, since MBR can only handle partitions < 2TB and the disk will otherwise contain several small partitions instead of one large one.To create a partition using the entire hard disk, you can simply enter 0% 100%. Otherwise the start and end block must be specified.sudo parted /dev/sda mklabel gpt # Create partition table sudo parted -a optimal -- /dev/sda mkpart primary 0% 100% sudo parted /dev/sda set 1 raid on # Mark partition as RAID Of course must be repeated for the second drive (sdb).Now the RAID can be created. We create a RAID1, so the disks are mirrored.sudo mdadm --create /dev/md0 --auto md --level=1 --raid-devices=2 /dev/sda1 /dev/sdb1 The question "Continue creating array?" must be answered with "y".Now we create an ext4 partition on the raid array and mount it.sudo mkfs.ext4 /dev/md0 sudo mkdir /mnt/nas sudo nano /etc/fstab /dev/md0 /mnt/nas ext4 defaults 0 2 # Insert this line sudo mount -a The last thing to do is to update mdadm.conf and initramfs. The second one takes a while.sudo su -c "/usr/share/mdadm/mkconf > /etc/mdadm/mdadm.conf“ sudo update-initramfs -u -k all Whether everything went well can be checked with these two commands:cat /proc/mdstat Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10] md0 : active raid1 sdb[1] sda[0] 3906886464 blocks super 1.2 [2/2] [UU] [>....................] resync = 1.9% (75295680/3906886464) finish=3092.5min speed=20649K/sec bitmap: 30/30 pages [120KB], 65536KB chunk Here you can also see if a hard disk is failed or synchronized.sudo mdadm --detail /dev/md0 /dev/md0: Version : 1.2 Creation Time : Wed Feb 3 09:26:57 2021 Raid Level : raid1 Array Size : 3906886464 (3725.90 GiB 4000.65 GB) Used Dev Size : 3906886464 (3725.90 GiB 4000.65 GB) Raid Devices : 2 Total Devices : 2 Persistence : Superblock is persistent Intent Bitmap : Internal Update Time : Wed Feb 3 10:31:45 2021 State : clean, resyncing Active Devices : 2 Working Devices : 2 Failed Devices : 0 Spare Devices : 0 Consistency Policy : bitmap Resync Status : 1% complete Name : ubuntu:0 (local to host ubuntu) UUID : ab3d8d90:b05e8253:5f8e750d:7ae67fea Events : 1235 Number Major Minor RaidDevice State 0 8 0 0 active sync /dev/sda 1 8 16 1 active sync /dev/sdb Block UASIn the beginning, I often had problems with my hard drives being kicked out. On the one hand, this was due to the lack of a USB hub, but on the other hand, it was also due to UAS. That is why we will block it. In addition, we deactivate the sleep mode of the hard drives, so that they do not switch off at some point and are then no longer accessible.lsusb -t # check, if your adapter uses UAS: /: Bus 04.Port 1: Dev 1, Class=root_hub, Driver=xhci_hcd/4p, 5000M |__ Port 2: Dev 2, If 0, Class=Mass Storage, Driver=uas, 5000M # <- UAS sudo lsusb Bus 001 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub Bus 004 Device 002: ID 174c:55aa ASMedia Technology Inc. Name: ASM1051E SATA 6Gb/s bridge, ASM1053E SATA 6Gb/s bridge, ASM1153 SATA 3Gb/s bridge, ASM1153E SATA 6Gb/s bridge sudo nano /boot/firmware/cmdline.txt usb-storage.quirks=174c:55aa:u # Insert this line. sudo update-initramfs -u # Update initramfs so that the changes take effect. sudo hdparm -S0 /dev/sda #Disable sleep Setup SambaCreate userssudo apt-get install samba samba-common # install samba I have created a total of 7 users on my end. The distribution as follows: User1, User2, User3, User4 for all family members. In addition, I have set up a public share (family). This is where files and photos are stored to which everyone has access. Then there is a share User2Work. This share is for the business data of user 2, which is also mounted only on the business laptop.There is also the user nas. This is generally used for writing, because otherwise conflicts with user rights could arise, for example, if User1 wants to change a file created by User2.With the first command a normal Ubuntu user named User1 is created. However, since this user does not need a home directory, nor does he need to log in to the NAS via ssh as we do, we disable this with the options --no-create-home and --disabled-login. Also questions about residence, department, etc. can be skipped. The second command sets a (strong!) password for this user. Note that anyone who has this password can also have access to all files stored under this user.sudo adduser --no-create-home --disabled-login --shell /bin/false user1 sudo smbpasswd -a user1 These steps are now repeated for all 7 users.Create folders for the usersOf course, no folder is created for nas, since this user is only used for writing. Besides that, a separate folder is created for each of the other 6 users.In order for nas to be used for writing, this user must also be specified as the owner at the end.cd /mnt/nas/ sudo mkdir shares cd shares/ sudo mkdir {user1,user2,user2work,user3,user4,family} sudo chown -R nas: /mnt/nas/shares/ Set up sharesTo do this, we edit the smb.conf file.For the normal users, the example of user1 can be used. Make sure that everywhere user1 (also in the path to the folder) is aligned with the real name.The example from the family can be used for all public shares.Just add it at the end of the file.In addition, the line map to guest = bad user must be changed to map to guest = never, so that Windows10 users can also use the share without errors. Otherwise "network errors" might occur.sudo nano /etc/samba/smb.conf ? # user1 [user1] # The name of the share. comment = User1 # This comment appears e.g. in Explorer. path = /mnt/nas/shares/user # This is the folder for all files of User1. write list = user1 valid users = user1 force user = nas read only = no browsable = yes ? # family [family] comment = Family path = /mnt/nas/shares/family write list = user1,user2,user3,user4 # Enter all users who should have access here. valid users = family,user1,user2,user3,user4 # In addition, of course, family must be added here. force user = nas read only = no browsable = yes Note at this point: Whoever has the ubuntu or config passwords also has access to all files stored on the entire NAS.Last stepThe last thing to do is to restart Samba and allow it in the firewallsudo service smbd restart sudo allow smb on ufw Now the NAS is completely set up and working.It can now be mounted under Windows or Linux//192.168.178.54/user1/documents /home/user1/Documents cifs credentials=/home/user1/.credentials/smbcredentials,users,uid=1000,gid=1000,forceuid,forcegid 0 0 and used normally like a hard disk.Keep in mind, however, that a Raid1 storage is not a fully permanent backup solution and that regular backups must be made to different locations.

Hand Gesture Controller for RoboticThe hand gesture controller makes it possible to control applications using hand tilt angle values. Actually, the hand gesture controller uses an accelerometer, it is possible to use it wherever tilt is provided and control projects. For example, controlling with head movements other than hand movements. It also allows you to do this control wirelessly. Let's take a look at the video on how it works.How It Works?The Hand Gesture Controller includes an accelerometer and it detects the motion by comparing the acceleration on any axis with set thresholds.The accelerometer can measure the static acceleration of gravity in tilt-sensing projects. The hand gesture controller acts as a transmitter, so a receiver circuit is required.The hand gesture controller contains three main hardware:1) nRF24L01 Transceiver Module2) ADXL335 Accelerometer3) Arduino Pro Mini ATmega328 3.3V 8 MHz MicrocontrollerTransceiver - Accelerometer - MicrocontrollernRF24L01 Transceiver Module- The nRF24L01 + transceiver module allows two or more Arduino boards to communicate with each other wirelessly and remotely.- A transmitter and a receiver circuit are required to provide communication. - An address (array of bytes) is created for two nRF24L01 modules to communicate. It communicates over this address and transfers data. - A popular library called RF24 is used to interface with the nRF24L01 transceiver module. RF24 Arduino Library for nRF24L01+ Module - https://github.com/nRF24/RF24ADXL335 Accelerometer- At the heart of the Hand Gesture Controller is a low-power three-axis accelerometer ADXL335. - It can measure the static acceleration due to gravity in tilt-sensing applications.The program works as follows,- The X, Y and Z values provided by the ADXL335 sensor are read by the program and transmitted to the Receiver via the nRF24L01 module. - The receiver compares these values with the min and max threshold values defined in the program. - If the values satisfy the condition specified in the program, the function is executed.For example,- When the sensor outputs 1.65 (0g) volts on the x-axis (i.e. xAxis=511), the "stop" condition is executed and the DC motors remain in the "LOW" state.- When the sensor outputs 3.3 (+3g) volts on the x-axis (i.e. xAxis=1023), the "turn to one side" condition is executed and the DC motors go into the "HIGH" state.- When the sensor outputs 0 (0g) volts on the x-axis (i.e. xAxis=0), the "turn to other side" condition is executed and the DC motors go into the "HIGH" state.- For more detail about ADXL335 - https://www.analog.com/media/en/technical-documentation/data-sheets/ADXL335.pdfArduino Pro Mini - Arduino Pro Mini was developed for applications and installations where space is premium and projects are made as permanent set ups.- The Pro Mini does not have a built-in USB input, so a serial converter (FTDI) is used to upload the source code. It is an easy process.Prototype (Printed Circuit Board)A printed circuit board was designed to turn the project into a useful prototype. Printed circuit boards are plates with conductive paths on the surface for mounting electronic circuit components. PCB manufacturers provide service to turn your projects into professional prototypes.To get the PCBs, simply upload the shared "Gerber file" to PCBWay and create an order. High-quality PCBs will arrive in a few days depending on the shipping address.Required Components and SolderingThe hand gesture controller needs a few components. Easy solderable components. Place and solder components according to shared reference designator.- Self-locking On / Off Switch- 2P SMD Connector- 100uF / 10uF Capacitor- Resistor- Female Header- LED- 3.7v Lipo BatteryTransmitter Source CodeArduino Pro Mini 3.3V version is used in the project, so make sure to set the power jumper on the FTDI module to 3.3V! Upload the shared Transmitter source code using the FTDI module. Before the source code is uploaded, the board selection should be determined according to the Arduino Pro Mini version (3.3v) used.https://github.com/MertArduino/How-To-Make-DIY-Arduino-Gesture-Control-Robot-At-Home/blob/master/GestureTransmitterCode/GestureTransmitterCode.inoReceiver Circuit and Source CodeThe hand gesture controller acts as a transmitter, so a receiver circuit is required. You can get the necessary and source code for the Receiver (DC motor and Servo motor control) from the link.https://github.com/MertArduino/How-To-Make-DIY-Arduino-Gesture-Control-Robot-At-Home/blob/master/GestureReceiverCode/GestureReceiverCode.inoWhat About Everything Else?If you want to know more about Gesture Tank Control in the project:- Project Video https://youtu.be/64NS91KmK84- Source Code https://github.com/MertArduino/How-To-Make-DIY-Arduino-Gesture-Control-Robot-At-HomeIf you want to know more about Robotic Hand:- InMoov Open-Source 3D Parts and Assembly http://inmoov.fr/hand-and-forarm/

Marble RobotA 76-year-old grandfather who enjoys working with his own CNC machine. Maybe I'm the oldest participant!I have made many marble machines from before, but I decided to make them because there is no example of combination with an arm robot.Marble movement: Marbles carried to the slope stand roll on the slope,It is divided into 3 holes by the separator below.When a marble enters any of the holes, the photo sensor notifies the control unit of the hole number. Then the arm robot starts to move and picks up the marbles and carries them to the slope stand.Rather than explain in the text, if you look at the YouTube image, you'll be satisfied.Marble Robot Raspberry pi Pico Circuitby CNC-Paradise

This is my third attempt at making a LED cube.First version was your simple 4x4x4 LED cube, using the 5mm LED leads to connect them in a matrix. Powered by an barebone ATMega328P and Arduino software, there was a lot of wires, and code was really annoying to write. This project established my soldering skills, and passion for all things LED related.Fast forward, the second attempt introduced WS2182b LEDS, with PCBs as the layers and connecting columns. The baseboard was made on a veroboard, connected to a Arduino Nano. Although looking slick, baseboard being a veroboard didn't look that good. It was also pretty difficult to assemble; you had to hold the columns and layers together while soldering to connect them. WS2812b LEDs are great, as you only need 3 wires (power, gnd and signal) to daisy chain LEDs together, making the circuit fairly simple. The layers wind the signal in a snake pattern, meaning example code for WS2812B LED strips (which are really common) could be used without much effort.Finally the third version. It was envisioned that this would be a 10x10x10 cube (1000 LEDs). As such, the design was made using alternating brass (conductive) and polymide (non-conductive) 2mm-long hex standoffs to add more layers when necessary. Thickness was added to improve the durability of the layers. Only limiting factor is the power supply; we require 5V 5A per column of 10 layers. That's enough power to charge a decent sized laptop. Plus, each layer increases the overall cost.Project files are at the GitLab link. Software is not yet finished, still deciding what features to work on.License for hardware and software is MIT.

Welcome!This project which I call the C.C.H (Central Command Hub) is an Arduino & Raspberry Pi powered A.I System. It is private and completely customizable. This A.I can't listen in on your private conversations and sell your gossip to it's buyers on the dark web because it's completely offline. The only things that are connect to the internet this project are the Raspberry Pi (Wifi) and in a future update, a WIFI module to have the A.I turn things on remotely using IOT. Since these things don't have any onboard mic's, they can't listen in on you. Now you can speak easy knowing your A.I respects your privacy :)How Does the A.I system work?The A.I system works by using a Movi Shield which allows you to program your own custom commands and responses for those commands.What's the Raspberry Pi used for? The Raspberry Pi is currently being used as a convenient onboard computer and it's also used to play Sound FXs when the Arduino tells it to. In the future, I hope to have the Arduino tell the Raspberry Pi to open certain tabs such as YouTube, the news, ect.. I also hope to add a Vison system so it can recognize objects and people. Want to build your own?Just hop over to the tutorial I created here. Code and STLs can be found on my Thingiverse page.This A.I is still in it's beginning phase so there's a whole lot more updates to come. So stay tuned and feel free to improve upon it. Here's a demo of the Systems Check Subroutine (Which has since been updated):

Idea ??After working on various projects on different domains, I planned to make a fun project, and I decided to make a rock-paper-scissors game :)In this project, we will make an interactive game and play against the computer which is powered by AI to make decisions. AI uses the Camera connected to the Raspberry Pi to recognize what moves the user made with the hand, classify them into the best category(label) rock, paper, or scissors. Once the computer makes its move, the stepper motor connected to the Raspberry Pi points towards the direction based on its move.Rules which has to be considered for this game:Rock blunts the scissorPaper covers the rockScissors cut paperThe winner will be decided based on the above three conditions.Let's see a quick demo of the project here.Getting Started ??I've used a Raspberry Pi 3 Model B+ which has great enhancements and is More Powerful than the earlier Raspberry Pi 3 Model B.Raspberry Pi 3 B+ is integrated with the 1.4GHz 64-bit quad-core processor, dual-band wireless LAN, Bluetooth 4.2/BLE, faster Ethernet, and Power-over-Ethernet support (with separate PoE HAT).Specifications:Broadcom BCM2837B0, Cortex-A53 (ARMv8) 64-bit SoC @ 1.4GHz1GB LPDDR2 SDRAM2.4GHz and 5GHz IEEE 802.11.b/g/n/ac wireless LAN, Bluetooth 4.2, BLEGigabit Ethernet over USB 2.0 (maximum throughput of 300 Mbps)The extended 40-pin GPIO headerFull-size HDMI4 USB 2.0 portsCSI camera port for connecting a Raspberry Pi cameraDSI display port for connecting a Raspberry Pi touchscreen display4-pole stereo output and composite video portMicro SD port for loading your operating system and storing data5V/2.5A DC power inputPower-over-Ethernet (PoE) support (requires separate PoE HAT)We use an SG-90 servo motor, a high torque motor that can handle the load up to 2.5kg (1cm).A USB camera to make the game interactive with the image processingThese are the overall components used for this project.Some Jumper cables are used to wire the stepper motor and Raspberry Pi.Burn Raspbian to the SD card ??Raspbian is the Linux distribution of choice running on the Raspberry Pi. In this guide, we will be using the Lite version, but the Desktop version (which comes with a graphical environment) can be used as well.Download Etcher and install it.Connect an SD card reader with the SD card inside.Open Etcher and select from your hard drive the Raspberry Pi .img or .zip file you wish to write to the SD card.Select the SD card you wish to write your image to.Review your selections and click 'Flash!' to begin writing data to the SD card.Connect the device to your networkEnable SSH access by adding empty file ssh, again placed at the root of the boot volume on your SD card.Insert the SD card into the Raspberry Pi. It will boot in roughly 20 seconds. You should now have SSH access to your Raspberry Pi. By default, its hostname will be raspberrypi.local. On your computer, open a terminal window and type the following:ssh pi@raspberrypi.local The default password is raspberryHere I've used a separate monitor to interface with the Raspberry Pi.Collecting the Dataset ???The first step in this project is data collection. The System has to identify the hand gesture and recognize the action and make its move accordingly.We install several libraries to the Raspberry Pi using the pip install <package_name> command.sudo apt-get update && sudo apt-get upgrade sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev pip install opencv pip install numpy pip install scikit-learn pip install scikit-image pip install h5py pip install Keras pip install tensorflow pip install Werkzeug pip install Keras-Applications pip install Keras-Preprocessing pip install keras-squeezenet pip install astor pip install tensorboard pip install tensorflow-estimator pip install mock pip install grpcio pip install absl-py pip install gast pip install joblib pip install Markdown pip install protobuf pip install PyYAML pip install six If you face any issues with the OpenCVpackage, I strongly recommend installing these packages.sudo apt-get install libhdf5-dev sudo apt-get install libhdf5-serial-dev sudo apt-get install libatlas-base-dev sudo apt-get install libjasper-dev sudo apt-get install libqtgui4 sudo apt-get install libqt4-test We have installed all the required dependencies for this project. The Data-set is made by collections and arrangements of the images under the appropriate label.Here we create the data set images for the label rock, paper, and scissor using the following snippet.roi = frame[100:500, 100:500] save_path = os.path.join(img_class_path, '{}.jpg'.format(count + 1)) cv2.imwrite(save_path, roi) The image is captured for each label (rock, paper, scissor, and None).Capturing RockCapturing PaperDesigning a NN & Training the Model ????The Core of this project is an image classifier that classifies one of three categories. To make this Classifier, we use the pre-trained CNN (Convolutional Network) called SqueezeNet.Here we use Keras and TensorFlow to generate the SqueezeNet model which can identify the gesture. The images which we generated in the previous step are used to train the model. The model is trained using the Dataset generated for no of Epochs (Cycles) mentioned.The model is configured with the hyperparameters as shown below.model = Sequential([ SqueezeNet(input_shape=(227, 227, 3), include_top=False), Dropout(0.5), Convolution2D(NUM_CLASSES, (1, 1), padding='valid'), Activation('relu'), GlobalAveragePooling2D(), Activation('softmax') ]) While the model is training, you can find the loss and accuracy of the model for each Epoch, and the accuracy increases at some point in time after a few Epochs.Model TrainingIt roughly took 2 hours to generate the model with the highest accuracy after 10 epoch.If you face any memory allocation errors, do the following steps (Thanks to Adrian)To increase your swap space, open up /etc/dphys-swapfile and then edit the CONF_SWAPSIZE variable:# CONF_SWAPSIZE=100 CONF_SWAPSIZE=1024 Notice that I am increasing the swap from 100MB to 1024MB.From there, restart the swap service:$ sudo /etc/init.d/dphys-swapfile stop $ sudo /etc/init.d/dphys-swapfile start Note: Increasing swap size is a great way to burn out your memory card, so be sure to revert this change and restart the swap service when you’re done. You can read more about large sizes corrupting memory cards here.Testing the Model ?Once the model is generated, It produces the output file "rock-paper-scissors-model.h5". This file is used as the source to test whether the system can identify different hand gestures and able to differentiate the actions.The model is loaded in the python script as followsmodel = load_model("rock-paper-scissors-model.h5") The camera reads the test image and transform the required color model, and then resize the image to 227 x 227 pixel (Same size used for model generation). The images which were used for training the model can be used to test the generated model.img = cv2.imread(filepath) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img = cv2.resize(img, (227, 227)) Once the model is loaded and the image is acquired by the camera, the model predicts the captured image using the SqueezeNet model loaded, and makes the prediction for the user's movements.pred = model.predict(np.array([img])) move_code = np.argmax(pred[0]) move_name = mapper(move_code) print("Predicted: {}".format(move_name)) Run the test.py script to test the model with various test images.python3 test.py <testimage> Testing - PaperTesting - RockTesting - ScissorsNow the model is ready to detect and understand the hand gestures.Rock-Paper-Scissors gameThe Game uses a random number generation function to decide the computer's move. It follows the above-said rules to determine the winner. The game is designed with two modes: Normal Mode and Intelligent mode, where intelligent mode counterattack the user's movement, i.e Computer wins all the moves against the user.cap = cv2.VideoCapture(0) # To capture image from the Camera Now let's make the game in Normal mode where the system/ Raspberry Pi takes the picture of the hand and analyzes and identifies the hand gesture. Then using a random number generator, the computer move is played. The winner is chosen based on the rules and then displayed on the screen.Start the game using the following command.python3 play.py Computer GameServo Motor Integration ??At last, add the servo motor to this project. Servo motor is GPIO pin 17 of the Raspberry Pi, which has the PWM function to control the angle of rotation.The Servo Motor used in this project is SG-90. It can make rotations clockwise and anti-clockwise up to 180 °The Connections are given as follows.Servo Motor ---> Raspberry PiVcc ---> +5VGND ---> GNDSignal ---> GPIO17The libraries such as RPi.GPIO and time are used in this project.import RPi.GPIO as GPIO import time The GPIO pin is then configured to PWM using the following linesservoPIN = 17 GPIO.setmode(GPIO.BCM) GPIO.setup(servoPIN, GPIO.OUT) GPIO Pin 17 is configured to use as a PWM at the frequency of 50Hz. The Angle of the servo motor is achieved by setting the duty cycle (Ton & Toff) of the PWMduty = angle/18 + 2 GPIO.output(servoPIN, True) p.ChangeDutyCycle(duty) time.sleep(1) GPIO.output(servoPIN, False) p.ChangeDutyCycle(0) This will produce the desired step angle for every pulse, which would give the desired angle of rotation.Now I have taken the chart and sliced it into three sections, rock, paper, and scissors. The Servo motor is fixed to the center of the chart. The pointer/flap is connected to the shaft of the servo motor. This shaft points to the computer's move according to the logic computed in the script.Working of the Project ??And now, it's playtime. Let's see the working of the project.Working VideoIf you faced any issues in building this project, feel free to ask me. Please do suggest new projects that you want me to do next.Give a thumbs up if it really helped you and do follow my channel for interesting projects. :)Share this video if you like.Follow me onBlog - https://rahulthelonelyprogrammer.blogspot.in/Github - https://github.com/Rahul24-06Happy to have you subscribed: https://www.youtube.com/c/rahulkhanna24june?sub_confirmation=1Thanks for reading!