Due to the Covid-19 pandemic, the importance of social distance, which should be at least 1.5-2 meters, has increased. While this increase caused many new rules, it also brought some obligations.It is obvious that one of the most important of these obligations is the limit of the maximum number of people that can exist indoors.In an interior; for example, a cafe, a bakery, a grocery store, or a public toilet, etc. It is necessary to monitor the number of people inside and the distance of this number to the limit.piCounter is a device that will provide exactly this tracking and carry out the necessary pre-planned instructions.The piCounter will process the signals it receives from the ultrasonic sensors on it, count the people entering and leaving, and will give a warning when the limit is approached by showing the current number inside. When the limit is reached or no one is inside, it will do its part by carrying out the necessary pre-planned instructions (such as sounding an alarm when the limit is reached, activating the security system when no one is inside, and turning off the lights, etc.).piCounter can be easily transported and installed with the advantage of having an internal battery. The internal 18650 battery can be charged via the power panel, output can be obtained if desired. This battery is rechargeable, can be used as a power source. It can give linear 5V 1A output.piCounter is a customizable device. You can change the limit according to the place where you will install, and the direction of the entrance according to the door you will install from the set mode. When we set the distance to the door of the sensors with the potentiometer on the front panel can make a more accurate count.Range Adjustment Video: There are three push buttons used to adjust the person limit that can be indoor and also to adjust the entrance direction. When the left button is pressed once it will enable the set mode for the limit, each press on the middle button will decrease the limit and each press on the right button will increase the limit. The second press for the left button will enable the set mode for the direction of the entrance. The middle button will set the direction from the left to right and the right button will set the direction from the right to left. The third press on the left button will disable the setting mode.Limit and Entrance Direction Adjustment Video: With the potentiometer on the other side of the box, the brightness of the screen can be adjusted, the piCounter can be reset, or it can be turned off and on completely.Left Panel :It starts to flash when 2 people are left to the limit assigned by the led on it. When the limit is reached and the limit is exceeded, the LED lights continuously.Video Showing the Limit Working Principle:Code:I preferred object-oriented programming to work somewhat modularly and wrote the range finder and lcd classes to be reusable.import time from machine import Pin, ADC, PWM from range_finder import RangeFinder from gpio_lcd import GpioLcd class VisitorCounter(): def __init__(self): self.potValue = 0 self.counter = 0 self.first = 0 self.second = 0 self.prior = 0 self.limit = 2 self.time1 = 0 self.distance1 = 0 self.time2 = 0 self.distance2 = 0 self.limitRange = 0 self.doorRange = 0 self.pot = ADC(26) # the middle pin on the Potentiometer self.lcd = GpioLcd(rs_pin=Pin(7), enable_pin=Pin(9), d4_pin=Pin(10), d5_pin=Pin(11), d6_pin=Pin(12), d7_pin=Pin(13), num_lines=2, num_columns=16) self.led = Pin(25, Pin.OUT) self.warningLed = Pin(0, Pin.OUT) self.rangeFinderObject = RangeFinder(echo_pin=15, trigger_pin=14) self.rangeFinderObject2 = RangeFinder(echo_pin=21, trigger_pin=20) def setup(self): self.lcd.clear() self.lcd.move_to(0,0) self.lcd.putstr("Limit : " + str(self.limit)) time.sleep(2) self.lcd.clear() #time.sleep(0.01) self.lcd.move_to(0,0) # default cursor position is (0,0) self.lcd.putstr("Existing: " + str(self.counter)) self.setButton = Pin(16, Pin.IN, Pin.PULL_DOWN) self.decButton = Pin(17, Pin.IN, Pin.PULL_DOWN) self.incButton = Pin(18, Pin.IN, Pin.PULL_DOWN) """ Maps two ranges together """ def range_mapper(self,x, in_min, in_max, out_min, out_max): return int((x-in_min) * (out_max-out_min) / (in_max - in_min) + out_min) def run(self): while True: print("tt") if self.limit - self.counter <= 2 and self.limit - self.counter >0 and self.limit - self.counter != 0: self.warningLed.on() time.sleep(0.1) self.warningLed.off() time.sleep(0.1) elif self.limit - self.counter <= 0: self.warningLed.on() else: self.warningLed.off() if self.setButton.value(): time.sleep(0.2) print("111") self.lcd.clear() self.lcd.putstr("Current Limit : " + str(self.limit)) while True: if self.incButton.value(): time.sleep(0.2) print("222") self.limit += 1 self.lcd.clear() self.lcd.putstr("Current Limit : " + str(self.limit)) elif self.decButton.value(): time.sleep(0.2) print("333") self.limit -= 1 self.lcd.clear() self.lcd.putstr("Current Limit : " + str(self.limit)) elif self.setButton.value(): time.sleep(0.2) self.lcd.clear() self.lcd.putstr("Set direction mode. (Right/Left)") while True: if self.incButton.value(): time.sleep(0.2) self.rangeFinderObject2 = RangeFinder(echo_pin=15, trigger_pin=14) self.rangeFinderObject = RangeFinder(echo_pin=21, trigger_pin=20) self.lcd.clear() self.lcd.putstr("Right to left.") elif self.decButton.value(): time.sleep(0.2) self.rangeFinderObject = RangeFinder(echo_pin=15, trigger_pin=14) self.rangeFinderObject2 = RangeFinder(echo_pin=21, trigger_pin=20) self.lcd.clear() self.lcd.putstr("Left to right.") if self.setButton.value(): time.sleep(0.2) break #self.lcd.clear() print("set") break time.sleep(0.2) potValue = self.pot.read_u16() distanceLimit = self.range_mapper(potValue,600, 65535,0,330) self.doorRange = distanceLimit self.lcd.clear() self.lcd.move_to(0,0) # default cursor position is (0,0) self.lcd.putstr("Existing: " + str(self.counter)) self.lcd.move_to(0,1) self.lcd.putstr("Range: " + str(distanceLimit) + " cm") if(self.counter < 0): #reset self.counter = 0 self.first = 0 self.second = 0 self.prior = 0 # next 3 lines are equal to setup() method self.lcd.clear() #time.sleep(0.01) self.lcd.move_to(0,0) self.lcd.putstr("Existing: " + str(self.counter)) if(self.counter >= 3): self.led.on() else: self.led.off() print(self.counter) print(self.first," ",self.second," ",self.prior) self.distance1 = round(self.rangeFinderObject.find(),1) # distance calculated in cm print(self.distance1) if (self.distance1 < self.doorRange and self.distance1 != 0 and self.first == 0): # first sensor detected self.first = 1 if(self.prior == 0): self.prior = 1 print("first active") elif (self.distance1 > self.doorRange): self.first = 0 if(self.prior == 2 and self.first == 1 and self.second == 0): print("exit") self.counter -= 1 self.prior = 0 if self.counter < 0: self.counter = 0 # next 3 lines are equal to setup() method self.lcd.clear() #time.sleep(0.01) self.lcd.move_to(0,0) self.lcd.putstr("Existing: " + str(self.counter)) time.sleep(0.1) self.distance2 = round(self.rangeFinderObject2.find(),1) print(self.distance2) if(self.distance2 < self.doorRange and self.distance2 != 0 and self.second == 0): self.second = 1 print("second active") if(self.prior == 0 and self.first == 0): self.prior = 2 elif (self.distance2 > self.doorRange): self.second = 0 if(self.prior == 1 and self.first == 0 and self.second == 1): self.counter += 1 self.prior = 0 # next 3 lines are equal to setup() method self.lcd.clear() #time.sleep(0.01) self.lcd.move_to(0,0) self.lcd.putstr("Existing: " + str(self.counter)) print("entry") visitorCounter = VisitorCounter() visitorCounter.setup() visitorCounter.run() Libraries and classes required for this code to work:You can also download these codes from the bottom of the page.range_finder.pyfrom time import sleep_us, ticks_us from machine import Pin, ADC, PWM import time class RangeFinder(): duration = 0 distance = 0 def __init__(self, echo_pin, trigger_pin): self.__echo_pin = Pin(echo_pin, Pin.IN) self.__trigger_pin = Pin(trigger_pin, Pin.OUT) def find(self): self.__trigger_pin.low() sleep_us(2) self.__trigger_pin.high() sleep_us(5) self.__trigger_pin.low() signal_on = 0 signal_off = 0 while self.__echo_pin.value() == 0: signal_off = ticks_us() while self.__echo_pin.value() == 1: signal_on = ticks_us() elapsed_time = signal_on - signal_off self.duration = elapsed_time self.distance = (elapsed_time * 0.343) / 2 return self.distance / 10 gpio_lcd.py"""Implements a HD44780 character LCD connected via ESP32 GPIO pins.""" from lcd_api import LcdApi from machine import Pin from utime import sleep_ms, sleep_us class GpioLcd(LcdApi): """Implements a HD44780 character LCD connected via ESP32 GPIO pins.""" def __init__(self, rs_pin, enable_pin, d0_pin=None, d1_pin=None, d2_pin=None, d3_pin=None, d4_pin=None, d5_pin=None, d6_pin=None, d7_pin=None, rw_pin=None, backlight_pin=None, num_lines=2, num_columns=16): """Constructs the GpioLcd object. All of the arguments must be machine.Pin objects which describe which pin the given line from the LCD is connected to. When used in 4-bit mode, only D4, D5, D6, and D7 are physically connected to the LCD panel. This function allows you call it like GpioLcd(rs, enable, D4, D5, D6, D7) and it will interpret that as if you had actually called: GpioLcd(rs, enable, d4=D4, d5=D5, d6=D6, d7=D7) The enable 8-bit mode, you need pass d0 through d7. The rw pin isn't used by this library, but if you specify it, then it will be set low. """ self.rs_pin = rs_pin self.enable_pin = enable_pin self.rw_pin = rw_pin self.backlight_pin = backlight_pin self._4bit = True if d4_pin and d5_pin and d6_pin and d7_pin: self.d0_pin = d0_pin self.d1_pin = d1_pin self.d2_pin = d2_pin self.d3_pin = d3_pin self.d4_pin = d4_pin self.d5_pin = d5_pin self.d6_pin = d6_pin self.d7_pin = d7_pin if self.d0_pin and self.d1_pin and self.d2_pin and self.d3_pin: self._4bit = False else: # This is really 4-bit mode, and the 4 data pins were just # passed as the first 4 arguments, so we switch things around. self.d0_pin = None self.d1_pin = None self.d2_pin = None self.d3_pin = None self.d4_pin = d0_pin self.d5_pin = d1_pin self.d6_pin = d2_pin self.d7_pin = d3_pin self.rs_pin.init(Pin.OUT) self.rs_pin.value(0) if self.rw_pin: self.rw_pin.init(Pin.OUT) self.rw_pin.value(0) self.enable_pin.init(Pin.OUT) self.enable_pin.value(0) self.d4_pin.init(Pin.OUT) self.d5_pin.init(Pin.OUT) self.d6_pin.init(Pin.OUT) self.d7_pin.init(Pin.OUT) self.d4_pin.value(0) self.d5_pin.value(0) self.d6_pin.value(0) self.d7_pin.value(0) if not self._4bit: self.d0_pin.init(Pin.OUT) self.d1_pin.init(Pin.OUT) self.d2_pin.init(Pin.OUT) self.d3_pin.init(Pin.OUT) self.d0_pin.value(0) self.d1_pin.value(0) self.d2_pin.value(0) self.d3_pin.value(0) if self.backlight_pin is not None: self.backlight_pin.init(Pin.OUT) self.backlight_pin.value(0) # See about splitting this into begin sleep_ms(20) # Allow LCD time to powerup # Send reset 3 times self.hal_write_init_nibble(self.LCD_FUNCTION_RESET) sleep_ms(5) # need to delay at least 4.1 msec self.hal_write_init_nibble(self.LCD_FUNCTION_RESET) sleep_ms(1) self.hal_write_init_nibble(self.LCD_FUNCTION_RESET) sleep_ms(1) cmd = self.LCD_FUNCTION if not self._4bit: cmd |= self.LCD_FUNCTION_8BIT self.hal_write_init_nibble(cmd) sleep_ms(1) LcdApi.__init__(self, num_lines, num_columns) if num_lines > 1: cmd |= self.LCD_FUNCTION_2LINES self.hal_write_command(cmd) def hal_pulse_enable(self): """Pulse the enable line high, and then low again.""" self.enable_pin.value(0) sleep_us(1) self.enable_pin.value(1) sleep_us(1) # Enable pulse needs to be > 450 nsec self.enable_pin.value(0) sleep_us(100) # Commands need > 37us to settle def hal_write_init_nibble(self, nibble): """Writes an initialization nibble to the LCD. This particular function is only used during initialization. """ self.hal_write_4bits(nibble >> 4) def hal_backlight_on(self): """Allows the hal layer to turn the backlight on.""" if self.backlight_pin: self.backlight_pin.value(1) def hal_backlight_off(self): """Allows the hal layer to turn the backlight off.""" if self.backlight_pin: self.backlight_pin.value(0) def hal_write_command(self, cmd): """Writes a command to the LCD. Data is latched on the falling edge of E. """ self.rs_pin.value(0) self.hal_write_8bits(cmd) if cmd <= 3: # The home and clear commands require a worst # case delay of 4.1 msec sleep_ms(5) def hal_write_data(self, data): """Write data to the LCD.""" self.rs_pin.value(1) self.hal_write_8bits(data) def hal_write_8bits(self, value): """Writes 8 bits of data to the LCD.""" if self.rw_pin: self.rw_pin.value(0) if self._4bit: self.hal_write_4bits(value >> 4) self.hal_write_4bits(value) else: self.d3_pin.value(value & 0x08) self.d2_pin.value(value & 0x04) self.d1_pin.value(value & 0x02) self.d0_pin.value(value & 0x01) self.hal_write_4bits(value >> 4) def hal_write_4bits(self, nibble): """Writes 4 bits of data to the LCD.""" self.d7_pin.value(nibble & 0x08) self.d6_pin.value(nibble & 0x04) self.d5_pin.value(nibble & 0x02) self.d4_pin.value(nibble & 0x01) self.hal_pulse_enable() return self.distance / 10 lcd_api.py"""Provides an API for talking to HD44780 compatible character LCDs.""" import time class LcdApi: """Implements the API for talking with HD44780 compatible character LCDs. This class only knows what commands to send to the LCD, and not how to get them to the LCD. It is expected that a derived class will implement the hal_xxx functions. """ # The following constant names were lifted from the avrlib lcd.h # header file, however, I changed the definitions from bit numbers # to bit masks. # # HD44780 LCD controller command set LCD_CLR = 0x01 # DB0: clear display LCD_HOME = 0x02 # DB1: return to home position LCD_ENTRY_MODE = 0x04 # DB2: set entry mode LCD_ENTRY_INC = 0x02 # --DB1: increment LCD_ENTRY_SHIFT = 0x01 # --DB0: shift LCD_ON_CTRL = 0x08 # DB3: turn lcd/cursor on LCD_ON_DISPLAY = 0x04 # --DB2: turn display on LCD_ON_CURSOR = 0x02 # --DB1: turn cursor on LCD_ON_BLINK = 0x01 # --DB0: blinking cursor LCD_MOVE = 0x10 # DB4: move cursor/display LCD_MOVE_DISP = 0x08 # --DB3: move display (0-> move cursor) LCD_MOVE_RIGHT = 0x04 # --DB2: move right (0-> left) LCD_FUNCTION = 0x20 # DB5: function set LCD_FUNCTION_8BIT = 0x10 # --DB4: set 8BIT mode (0->4BIT mode) LCD_FUNCTION_2LINES = 0x08 # --DB3: two lines (0->one line) LCD_FUNCTION_10DOTS = 0x04 # --DB2: 5x10 font (0->5x7 font) LCD_FUNCTION_RESET = 0x30 # See "Initializing by Instruction" section LCD_CGRAM = 0x40 # DB6: set CG RAM address LCD_DDRAM = 0x80 # DB7: set DD RAM address LCD_RS_CMD = 0 LCD_RS_DATA = 1 LCD_RW_WRITE = 0 LCD_RW_READ = 1 def __init__(self, num_lines, num_columns): self.num_lines = num_lines if self.num_lines > 4: self.num_lines = 4 self.num_columns = num_columns if self.num_columns > 40: self.num_columns = 40 self.cursor_x = 0 self.cursor_y = 0 self.implied_newline = False self.backlight = True self.display_off() self.backlight_on() self.clear() self.hal_write_command(self.LCD_ENTRY_MODE | self.LCD_ENTRY_INC) self.hide_cursor() self.display_on() def clear(self): """Clears the LCD display and moves the cursor to the top left corner. """ self.hal_write_command(self.LCD_CLR) self.hal_write_command(self.LCD_HOME) self.cursor_x = 0 self.cursor_y = 0 def show_cursor(self): """Causes the cursor to be made visible.""" self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY | self.LCD_ON_CURSOR) def hide_cursor(self): """Causes the cursor to be hidden.""" self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY) def blink_cursor_on(self): """Turns on the cursor, and makes it blink.""" self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY | self.LCD_ON_CURSOR | self.LCD_ON_BLINK) def blink_cursor_off(self): """Turns on the cursor, and makes it no blink (i.e. be solid).""" self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY | self.LCD_ON_CURSOR) def display_on(self): """Turns on (i.e. unblanks) the LCD.""" self.hal_write_command(self.LCD_ON_CTRL | self.LCD_ON_DISPLAY) def display_off(self): """Turns off (i.e. blanks) the LCD.""" self.hal_write_command(self.LCD_ON_CTRL) def backlight_on(self): """Turns the backlight on. This isn't really an LCD command, but some modules have backlight controls, so this allows the hal to pass through the command. """ self.backlight = True self.hal_backlight_on() def backlight_off(self): """Turns the backlight off. This isn't really an LCD command, but some modules have backlight controls, so this allows the hal to pass through the command. """ self.backlight = False self.hal_backlight_off() def move_to(self, cursor_x, cursor_y): """Moves the cursor position to the indicated position. The cursor position is zero based (i.e. cursor_x == 0 indicates first column). """ self.cursor_x = cursor_x self.cursor_y = cursor_y addr = cursor_x & 0x3f if cursor_y & 1: addr += 0x40 # Lines 1 & 3 add 0x40 if cursor_y & 2: # Lines 2 & 3 add number of columns addr += self.num_columns self.hal_write_command(self.LCD_DDRAM | addr) def putchar(self, char): """Writes the indicated character to the LCD at the current cursor position, and advances the cursor by one position. """ if char == '\n': if self.implied_newline: # self.implied_newline means we advanced due to a wraparound, # so if we get a newline right after that we ignore it. pass else: self.cursor_x = self.num_columns else: self.hal_write_data(ord(char)) self.cursor_x += 1 if self.cursor_x >= self.num_columns: self.cursor_x = 0 self.cursor_y += 1 self.implied_newline = (char != '\n') if self.cursor_y >= self.num_lines: self.cursor_y = 0 self.move_to(self.cursor_x, self.cursor_y) def putstr(self, string): """Write the indicated string to the LCD at the current cursor position and advances the cursor position appropriately. """ for char in string: self.putchar(char) def custom_char(self, location, charmap): """Write a character to one of the 8 CGRAM locations, available as chr(0) through chr(7). """ location &= 0x7 self.hal_write_command(self.LCD_CGRAM | (location << 3)) self.hal_sleep_us(40) for i in range(8): self.hal_write_data(charmap[i]) self.hal_sleep_us(40) self.move_to(self.cursor_x, self.cursor_y) def hal_backlight_on(self): """Allows the hal layer to turn the backlight on. If desired, a derived HAL class will implement this function. """ pass def hal_backlight_off(self): """Allows the hal layer to turn the backlight off. If desired, a derived HAL class will implement this function. """ pass def hal_write_command(self, cmd): """Write a command to the LCD. It is expected that a derived HAL class will implement this function. """ raise NotImplementedError def hal_write_data(self, data): """Write data to the LCD. It is expected that a derived HAL class will implement this function. """ raise NotImplementedError def hal_sleep_us(self, usecs): """Sleep for some time (given in microseconds).""" time.sleep_us(usecs) A piece of code where you can make sample applications for the LCD screen.from machine import Pin from gpio_lcd import GpioLcd # Create the LCD object lcd = GpioLcd(rs_pin=Pin(8), enable_pin=Pin(9), d4_pin=Pin(10), d5_pin=Pin(11), d6_pin=Pin(12), d7_pin=Pin(13), num_lines=2, num_columns=16) # #The following line of codes should be tested using the REPL # # #1. To print a string to the lcd, you can use lcd.putstr('Hello world!') # #2. Now, to clear the display. # lcd.clear() # #3. and to exactly position the cursor location # lcd.move_to(1,1) # # If you do not set the cursor position, # # the character will be displayed in the # # default cursor position starting from # # 0, x and 0, y location which is the top left-hand side. # # There are other useful functions we can use in using the lcd. # #4. Show the cursor # lcd.show_cursor() # #5. Hide the cursor # lcd.hide_cursor() # #6. Turn ON blinking cursor # lcd.blink_cursor_on() # #7. Turn OFF blinking cursor # lcd.blink_cursor_off() # #8. Disable display # lcd.display_off() # this will only hide the characters # #9. Enable display # lcd.display_on() # #10. Turn backlight OFF # lcd.backlight_off() # #11. Turn backlight ON # lcd.backlight_on() # # 12. Print a single character # lcd.putchar('x') # but this will only print 1 character # #13. Display a custom characters # happy_face = bytearray([0x00,0x0A,0x00,0x04,0x00,0x11,0x0E,0x00]) # lcd.custom_char(0, happy_face) # lcd.putchar(chr(0)) Future Works:The data can be transferred to a smartphone or any other device through a wireless protocol. That will allow people to monitor from another place and will maintain the portability of the device.The set mode code can be added to adjust the distance from the limit variable which is 2 now.If you like this project that I have done to be less affected by the covid-19 pandemic, I would be very grateful if you do not forget to vote and like.Thank you for reading my article and reviewing my project.Stay in touch with electronics.e-mail : agoktugaydin.ece@gmail.commedium blog : https://agoktugaydin.medium.com/youtube : https://www.youtube.com/channel/UCGHJt1cBOxA5xkZSUaCg2vA

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-CODEfrom 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):