blink_tm 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b4e90e73c0c9d495bf37a16e6020498d5880ef79dd2ad36aaa054fd344580e5c
+  data.tar.gz: 02a83b060adb7e15c3e06cc6fe266aa699740b494d0a4f87296aa329741aa12a
+SHA512:
+  metadata.gz: 40d53fe4c787ad0995525d6531688ef5d83f9049107fca15936826ebde78515cf29c15bd567ad9c19a8bebc6acca9ce38419a874349063e76c93349739c62ea4
+  data.tar.gz: f6483431ae948c6eda5a59ca449e086b7a3fb4c8fee9766039bbb1d8c200ddd62994cb00387a78229e32726dbe90881ea57912e01bd31af8534b575541aba4dc

data/exe/blink-tm

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require 'blink_tm'
+
+# Find Device running Blink Taskmanager
+dev = nil
+retry_count = 0
+
+while(!dev)
+	dev = BlinkTM.find_device
+
+	if dev
+		puts "#{BlinkTM::BOLD}#{BlinkTM::GREEN}:: Device discovered successfully. Path: #{dev}#{BlinkTM::RESET}"
+	else
+		puts "#{BlinkTM::BOLD}#{BlinkTM::RED}:: No device found. Retrying #{retry_count += 1}#{BlinkTM::RESET}"
+		sleep 0.5
+	end
+end
+
+BlinkTM.start(dev)

data/ext/baudrate/baudrate.c

@@ -0,0 +1,99 @@
+#include <stdio.h>
+#include <fcntl.h>
+#include <termios.h>
+#include "ruby.h"
+
+VALUE setBaudRate(volatile VALUE obj, volatile VALUE dev, volatile VALUE speed) {
+	char *device = StringValuePtr(dev) ;
+	unsigned int spd = NUM2UINT(speed) ;
+
+	int serial_port = open(device, O_RDWR) ;
+	struct termios tty ;
+
+	char status = tcgetattr(serial_port, &tty) ;
+
+	/*
+		Serial Monitor sets these flags:
+
+		speed 57600 baud; line = 0;
+		min = 0; time = 0;
+		-brkint -icrnl -imaxbel
+		-opost
+		-isig -icanon -iexten -echo -echoe -echok -echoctl -echoke
+	*/
+
+	if(status != 0) return Qnil ;
+
+	tty.c_cflag &= ~CSIZE ;
+	tty.c_cflag |= CS8 ;
+	tty.c_cflag |= CREAD | CLOCAL ;
+	tty.c_oflag &= ~OPOST ;
+
+	tty.c_lflag &= ~ECHO ;
+	tty.c_lflag &= ~ECHOCTL ;
+	tty.c_lflag &= ~ECHOK ;
+	tty.c_lflag &= ~ECHOE ;
+	tty.c_lflag &= ~ECHOKE ;
+	tty.c_lflag &= ~ISIG ;
+	tty.c_lflag &= ~ICRNL ;
+	tty.c_lflag &= ~IEXTEN ;
+	tty.c_lflag &= ~ICANON ;
+
+	tty.c_cc[VTIME] = 0 ;
+	tty.c_cc[VMIN] = 0 ;
+
+	cfsetispeed(&tty, spd) ;
+	cfsetospeed(&tty, spd) ;
+	status = tcsetattr(serial_port, TCSANOW, &tty) ;
+
+	if (status == 0) return Qtrue ;
+
+	return Qfalse ;
+}
+
+VALUE getBaudRate(volatile VALUE obj, volatile VALUE dev) {
+	char *device = StringValuePtr(dev) ;
+
+	int serial_port = open(device, O_RDWR) ;
+	struct termios tty ;
+
+	char status = tcgetattr(serial_port, &tty) ;
+
+	if(status == 0) {
+		unsigned int in = cfgetispeed(&tty) ;
+		unsigned int out = cfgetospeed(&tty) ;
+
+		return rb_ary_new_from_args(2,
+			UINT2NUM(in), UINT2NUM(out)
+		) ;
+	}
+
+	return rb_ary_new() ;
+}
+
+void Init_baudrate() {
+	VALUE blinktm = rb_define_module("BlinkTM") ;
+	rb_define_const(blinktm, "B0", INT2FIX(B0)) ;
+	rb_define_const(blinktm, "B50", INT2FIX(B50)) ;
+	rb_define_const(blinktm, "B75", INT2FIX(B75)) ;
+	rb_define_const(blinktm, "B110", INT2FIX(B110)) ;
+	rb_define_const(blinktm, "B134", INT2FIX(B134)) ;
+	rb_define_const(blinktm, "B150", INT2FIX(B150)) ;
+	rb_define_const(blinktm, "B200", INT2FIX(B200)) ;
+	rb_define_const(blinktm, "B300", INT2FIX(B300)) ;
+	rb_define_const(blinktm, "B600", INT2FIX(B600)) ;
+	rb_define_const(blinktm, "B1200", INT2FIX(B1200)) ;
+	rb_define_const(blinktm, "B1800", INT2FIX(B1800)) ;
+	rb_define_const(blinktm, "B2400", INT2FIX(B2400)) ;
+	rb_define_const(blinktm, "B4800", INT2FIX(B4800)) ;
+	rb_define_const(blinktm, "B9600", INT2FIX(B9600)) ;
+	rb_define_const(blinktm, "B19200", INT2FIX(B19200)) ;
+	rb_define_const(blinktm, "B38400", INT2FIX(B38400)) ;
+	rb_define_const(blinktm, "B57600", INT2FIX(B57600)) ;
+	rb_define_const(blinktm, "B115200", INT2FIX(B115200)) ;
+
+	rb_define_module_function(blinktm, "set_baudrate", setBaudRate, 2) ;
+
+	rb_define_module_function(blinktm, "get_baudrate", getBaudRate, 1) ;
+	rb_define_module_function(blinktm, "baudrate", getBaudRate, 1) ;
+}

data/ext/baudrate/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile 'blink_tm/baudrate'

data/lib/blink_tm.rb

@@ -0,0 +1,33 @@
+# Frozen_String_Literal: true
+require 'blink_tm/baudrate'
+
+module BlinkTM
+	# Important Constants
+	BAUDRATE = BlinkTM::B57600
+	SCANID = 'BTM'
+	POLLING = 0.375
+
+	# Refresh should always get subtracted with 0.05
+	REFRESH = 0.5 - 0.05
+
+	# Errors
+	NoDeviceError = Class.new(StandardError)
+	DeviceNotReady = Class.new(StandardError)
+
+	# Units
+	TB = 10 ** 12
+	GB = 10 ** 9
+	MB = 10 ** 6
+	KB = 10 ** 3
+
+	# ANSI Sequences
+	RED = "\e[38;2;225;79;67m"
+	BLUE = "\e[38;2;45;125;255m"
+	GREEN = "\e[38;2;40;175;95m"
+	ORANGE = "\e[38;2;245;155;20m"
+	BOLD = "\e[1m"
+	RESET = "\e[0m"
+end
+
+require 'blink_tm/version'
+require 'blink_tm/blink_tm'

data/lib/blink_tm/blink_tm.rb

@@ -0,0 +1,223 @@
+
+#!/usr/bin/ruby -w
+# Frozen_String_Literal: true
+
+require 'fcntl'
+require 'linux_stat'
+
+module BlinkTM
+	# Detect device
+	def find_device
+		dev = nil
+
+		Dir.glob('/sys/bus/usb/devices/*').each { |x|
+			v = File.join(x, 'idVendor')
+			vendor = IO.read(v).strip if File.readable?(v)
+
+			p = File.join(x, 'idProduct')
+			product = IO.read(p).strip if File.readable?(p)
+
+			if vendor == '1a86' && product == '7523'
+				puts "#{BOLD}#{GREEN}:: #{Time.now.strftime('%H:%M:%S.%2N')}: A potential device discovered: #{vendor}:#{product}#{RESET}"
+
+				Dir.glob('/dev/ttyUSB[0-9]*').each { |x|
+					if File.writable?(x)
+						puts "#{BlinkTM::BOLD}#{BlinkTM::BLUE}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Changing baudrate to 57600...#{BlinkTM::RESET}"
+
+						if BlinkTM.set_baudrate(x, BlinkTM::BAUDRATE)
+							puts "#{BlinkTM::BOLD}#{BlinkTM::GREEN}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Successfully Changed baudrate to 57600...#{BlinkTM::RESET}"
+						else
+							puts "#{BlinkTM::BOLD}#{BlinkTM::RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Cannot change the baudrate#{BlinkTM::RESET}"
+						end
+					else
+						"#{BOLD}#{RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: No permission granted to change Baudrate#{RESET}"
+					end
+
+					if File.readable?(x)
+						begin
+							if File.open(x).readpartial(30).to_s.scrub.include?("BTM")
+								puts "#{BOLD}#{ORANGE}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Multiple Blink Task "\
+								"Manager Hardware Found! "\
+								"Selecting: #{vendor}:#{product}#{RESET}" if dev
+
+								dev = x
+							end
+						rescue EOFError
+							sleep 0.125
+							retry
+						end
+					end
+				}
+			end
+		}
+
+		dev
+	end
+
+	# Convert Numeric bytes to the format that blink-taskmanager can read
+	def convert_bytes(n)
+		if n >= TB
+			"%06.2f".%(n.fdiv(TB)).split(?.).join + ?4
+		elsif n >= GB
+			"%06.2f".%(n.fdiv(GB)).split(?.).join + ?3
+		elsif n >= MB
+			"%06.2f".%(n.fdiv(MB)).split(?.).join + ?2
+		elsif n >= KB
+			"%06.2f".%(n.fdiv(KB)).split(?.).join + ?1
+		else
+			"%06.2f".%(n).split(?.).join + ?0
+		end
+	end
+
+	# Convert percentages to the format that blink-taskmanager can read
+	def convert_percent(n)
+		"%06.2f".%(n).split('.').join
+	end
+
+	def start(device)
+		return false unless device
+
+		cpu_u = mem_u = swap_u = iostat = net_u = net_d = 0
+		io_r = io_w = 0
+
+		Thread.new {
+			cpu_u = LS::CPU.total_usage(POLLING).to_f while true
+		}
+
+		Thread.new {
+			while true
+				netstat = LS::Net::current_usage(POLLING)
+				net_u = netstat[:transmitted].to_i
+				net_d = netstat[:received].to_i
+			end
+		}
+
+		Thread.new {
+			while true
+				io_stat1 = iostat()
+				sleep POLLING
+				io_stat2 = iostat()
+
+				io_r = POLLING * io_stat2[0].-(io_stat1[0])
+				io_w = POLLING * io_stat2[1].-(io_stat1[1])
+			end
+		}
+
+		begin
+			raise NoDeviceError unless device
+
+			in_sync = false
+			fd = IO.sysopen(device, Fcntl::O_RDWR | Fcntl::O_EXCL)
+			file = IO.open(fd)
+
+			until in_sync
+				# Clear out any extra zombie bits
+				file.syswrite(?~)
+				# Start the device
+				file.syswrite(?#)
+				file.flush
+
+				sleep 0.125
+
+				begin
+					if file.readpartial(8000).include?(?~)
+						in_sync = true
+						break
+					end
+				rescue EOFError
+					sleep 0.05
+					retry
+				end
+
+				sleep 0.05
+			end
+
+			puts "#{BlinkTM::BOLD}#{BlinkTM::GREEN}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Device ready!#{BlinkTM::RESET}"
+
+			while true
+				# cpu(01234) memUsed(999993) swapUsed(999992) io_active(0)
+				# netUpload(999991) netDownload(999990)
+				# disktotal(999990) diskused(999990)
+
+				memstat = LS::Memory.stat
+				mem_u = memstat[:used].to_i.*(1024).*(100).fdiv(memstat[:total].to_i * 1024).round
+
+				swapstat = LS::Swap.stat
+				swap_u = swapstat[:used].to_i.*(1024).*(100).fdiv(swapstat[:total].to_i * 1024).round
+
+				# Output has to be exactly this long. If not, blink-taskmanager shows invalid result.
+				# No string is split inside blink-task manager, it just depends on the string length.
+				#
+				# cpu(100) memUsed(100) swapUsed(100)
+				# netDownload(9991) netUpload(9991)
+				# ioWrite(9991) ioRead(9991)
+
+				# Debugging string
+				# str = "#{"%03d" % cpu_u} #{"%03d" % mem_u} #{"%03d" % swap_u} "\
+				# "#{convert_bytes(net_u)} #{convert_bytes(net_d)} "\
+				# "#{convert_bytes(io_r)} #{convert_bytes(io_w)}"
+
+				str = "#{"%03d" % cpu_u}#{"%03d" % mem_u}#{"%03d" % swap_u}"\
+				"#{convert_bytes(net_u)}#{convert_bytes(net_d)}"\
+				"#{convert_bytes(io_r)}#{convert_bytes(io_w)}"
+
+				# Rescuing from suspend
+				file.syswrite('#')
+
+				file.syswrite('!')
+				file.flush
+				sleep 0.025
+
+				file.syswrite(str)
+				file.flush
+				sleep 0.025
+
+				file.syswrite('~')
+				file.flush
+
+				sleep REFRESH
+			end
+		rescue Interrupt, SystemExit, SignalException
+			file &.close
+			exit 0
+		rescue Errno::ENOENT, BlinkTM::NoDeviceError
+			file &.close
+			device = find_device
+
+			unless device
+				puts "#{BlinkTM::BOLD}#{BlinkTM::RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Error establishing connection. Don't worry if this is a valid device. Retrying...#{BlinkTM::RESET}"
+				sleep 0.1
+			end
+
+			retry
+		rescue BlinkTM::DeviceNotReady
+			file &.close
+			sleep 0.1
+			retry
+		rescue Exception
+			puts $!.full_message
+			file &.close
+			sleep 0.1
+			retry
+		end
+	end
+
+	def iostat
+		@@root_partition ||= IO.foreach('/proc/mounts').detect {
+			|x| x.split[1] == ?/
+		}.to_s.split[0].to_s.split(?/).to_a[-1]
+
+		@@sector_size = LS::FS.stat(?/)[:block_size]
+
+		io_stat = IO.foreach('/proc/diskstats'.freeze).find { |x|
+			x.split[2] == @@root_partition
+		} &.split.to_a
+
+		_io_r = io_stat[5].to_f.*(@@sector_size).round
+		_io_w = io_stat[9].to_f.*(@@sector_size).round
+
+		[_io_r, _io_w]
+	end
+
+	extend(self)
+end

data/lib/blink_tm/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BlinkTM
+	VERSION = "0.1.1"
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: blink_tm
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Sourav Goswami
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: linux_stat
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+description: A controller for Arduino OLED System Monitor, Blink Task Manager
+email:
+- souravgoswami@protonmail.com
+executables:
+- blink-tm
+extensions:
+- ext/baudrate/extconf.rb
+extra_rdoc_files: []
+files:
+- exe/blink-tm
+- ext/baudrate/baudrate.c
+- ext/baudrate/extconf.rb
+- lib/blink_tm.rb
+- lib/blink_tm/blink_tm.rb
+- lib/blink_tm/version.rb
+homepage: https://github.com/souravgoswami/blink-tm
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
+summary: A controller for Arduino OLED System Monitor, Blink Task Manager
+test_files: []