ice_tm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4b75ddb028fb7f91ece76d947e7baaf49ca49834e94fd8eb511dc8bc358d320f
+  data.tar.gz: 102c2e59d34635e2dcdd5518e5acda17cc33c16e26eec46dff5d7e09c924c411
+SHA512:
+  metadata.gz: 7ebe5c6589697b31a5bf8b7d158bc99220eb043807720223556e4236544f8d5ce52cdcd61756a619dab0f3daa9f921c8ff0cf4c984b3cc416d21edf3d6d610f7
+  data.tar.gz: 41e1f87dd7ed6259ef5fd58768bbfad923c42060d036c3f35f2bd1bc651ca906d3cf7a4c383b3f701883e3799fb5cf02c78ddca6de3698cb85134392c89221f3

data/exe/ice-tm

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

data/ext/baudrate/baudrate.c

@@ -0,0 +1,94 @@
+#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) ;
+
+	// IDE 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 ;
+	else 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 icetm = rb_define_module("IceTM") ;
+	rb_define_const(icetm, "B0", INT2FIX(B0)) ;
+	rb_define_const(icetm, "B50", INT2FIX(B50)) ;
+	rb_define_const(icetm, "B75", INT2FIX(B75)) ;
+	rb_define_const(icetm, "B110", INT2FIX(B110)) ;
+	rb_define_const(icetm, "B134", INT2FIX(B134)) ;
+	rb_define_const(icetm, "B150", INT2FIX(B150)) ;
+	rb_define_const(icetm, "B200", INT2FIX(B200)) ;
+	rb_define_const(icetm, "B300", INT2FIX(B300)) ;
+	rb_define_const(icetm, "B600", INT2FIX(B600)) ;
+	rb_define_const(icetm, "B1200", INT2FIX(B1200)) ;
+	rb_define_const(icetm, "B1800", INT2FIX(B1800)) ;
+	rb_define_const(icetm, "B2400", INT2FIX(B2400)) ;
+	rb_define_const(icetm, "B4800", INT2FIX(B4800)) ;
+	rb_define_const(icetm, "B9600", INT2FIX(B9600)) ;
+	rb_define_const(icetm, "B19200", INT2FIX(B19200)) ;
+	rb_define_const(icetm, "B38400", INT2FIX(B38400)) ;
+	rb_define_const(icetm, "B57600", INT2FIX(B57600)) ;
+	rb_define_const(icetm, "B115200", INT2FIX(B115200)) ;
+
+	rb_define_module_function(icetm, "set_baudrate", setBaudRate, 2) ;
+
+	rb_define_module_function(icetm, "get_baudrate", getBaudRate, 1) ;
+	rb_define_module_function(icetm, "baudrate", getBaudRate, 1) ;
+}

data/ext/baudrate/extconf.rb

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

data/lib/ice_tm.rb

@@ -0,0 +1,25 @@
+# Frozen_String_Literal: true
+require 'ice_tm/baudrate'
+
+module IceTM
+	# Errors
+	NoDeviceError = Class.new(StandardError)
+
+	# Other Important Constants
+	BAUDRATE = IceTM::B57600
+
+	TB = 10 ** 12
+	GB = 10 ** 9
+	MB = 10 ** 6
+	KB = 10 ** 3
+
+	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 'ice_tm/version'
+require 'ice_tm/ice_tm'

data/lib/ice_tm/ice_tm.rb

@@ -0,0 +1,208 @@
+
+#!/usr/bin/ruby -w
+# Frozen_String_Literal: true
+
+require 'fcntl'
+require 'linux_stat'
+
+module IceTM
+	# 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 "#{IceTM::BOLD}#{IceTM::BLUE}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Changing `baudrate` to 57600...#{IceTM::RESET}"
+						IceTM.set_baudrate(x, IceTM::BAUDRATE)
+					else
+						"#{BOLD}#{RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: No permission granted to change Baudrate#{RESET}"
+					end
+
+					if File.readable?(x)
+						1000.times {
+							if File.open(x).gets.to_s.scrub.strip.include?("IceTM")
+								puts "#{BOLD}#{ORANGE}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Multiple Ice Task "\
+								"Manager Hardware Found! "\
+								"Selecting: #{vendor}:#{product}#{RESET}" if dev
+
+								dev = x
+								break
+							end
+						}
+					end
+				}
+			end
+		}
+
+		dev
+	end
+
+	# Convert Numeric bytes to the format that ice-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 ice-taskmanager can read
+	def convert_percent(n)
+		"%06.2f".%(n).split('.').join
+	end
+
+	def start(device)
+		return false if(!device)
+
+		cpu_u = mem_u = swap_u = iostat = net_upload = net_download = 0
+
+		Thread.new {
+			while true
+				cpu_u = LS::CPU.total_usage(0.125).to_f
+			end
+		}
+
+		Thread.new {
+			while true
+				netstat = LS::Net::current_usage(0.1)
+				net_upload = netstat[:transmitted].to_i
+				net_download = netstat[:received].to_i
+			end
+		}
+
+		begin
+			in_sync = false
+			fd = IO.sysopen(device, Fcntl::O_RDWR | Fcntl::O_EXCL)
+			file = IO.open(fd)
+
+			until in_sync
+				file.syswrite(?! * 1000)
+				STDOUT.flush
+
+				begin
+					if file.readpartial(8000).include?(?~)
+						in_sync = true
+						break
+					end
+				rescue EOFError
+					retry
+				end
+			end
+
+			puts "#{IceTM::BOLD}#{IceTM::GREEN}:: #{Time.now.strftime('%H:%M:%S.%2N')}: Device ready!#{IceTM::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_t = convert_bytes(memstat[:total].to_i.*(1000))
+				mem_u = convert_bytes(memstat[:used].to_i.*(1000))
+				mem_percent = convert_percent(memstat[:used].to_i.*(100).fdiv(memstat[:total].to_i))
+
+				swapstat = LS::Swap.stat
+				swap_u = convert_bytes(swapstat[:used].to_i.*(1000))
+				swap_percent = convert_percent(swapstat[:used].to_i.*(100).fdiv(swapstat[:total].to_i))
+
+				diskstat = LS::Filesystem.stat
+				disk_total = convert_bytes(diskstat[:total])
+				disk_used = convert_bytes(diskstat[:used])
+				_diskavail = LS::Filesystem.available
+				disk_avail = convert_bytes(_diskavail)
+
+				disk_used_percent = convert_percent(diskstat[:used].*(100).fdiv(diskstat[:total]))
+				disk_avail_percent = convert_percent(_diskavail.*(100).fdiv(diskstat[:total]))
+
+				total_process = LS::Process.count
+				ps_r = LS::Process.running.count
+				ps_sl = LS::Process.sleeping.count
+				ps_i = LS::Process.idle.count
+				ps_t = LS::Process.stopped.count
+				ps_z = LS::Process.zombie.count
+
+				# Output has to be exactly this long. If not, ice-taskmanager shows invalid result.
+				# No string is split inside ice-task manager, it just depends on the string length.
+				#
+				# cpu(01234) memUsed(999993) swapUsed(999992) io_active(0)
+				# netUpload(999991) netDownload(999990)
+				# disktotal(999990) diskused(999990) diskAvail(999990) totalProcess(12345678)
+				# memPercent(01234) swapPercent(01234) diskPercent(01234) diskAvailPercent(01234)
+				# psR(65536) psS(65536) psI(65536) psT(65536) psZ(65536)
+
+				# Array for better debugging
+				# a = [
+				# 	convert_percent(cpu_u),
+				# 	mem_u, swap_u, iostat(),
+				# 	convert_bytes(net_upload), convert_bytes(net_download),
+				# 	disk_total, disk_used, disk_avail,
+				# 	"%08d" % total_process,
+				# 	mem_percent, swap_percent, disk_used_percent, disk_avail_percent,
+				# 	"%05d" % ps_r, "%05d" % ps_sl, "%05d" % ps_i, "%05d" % ps_t, "%05d" % ps_z
+				# ]
+
+				str = "#{convert_percent(cpu_u)}#{mem_u}#{swap_u}#{iostat()}"\
+				"#{convert_bytes(net_upload)}#{convert_bytes(net_download)}"\
+				"#{disk_total}#{disk_used}#{disk_avail}#{"%08d" % total_process}"\
+				"#{mem_percent}#{swap_percent}#{disk_used_percent}#{disk_avail_percent}"\
+				"#{"%05d" % ps_r}#{"%05d" % ps_sl}#{"%05d" % ps_i}#{"%05d" % ps_t}#{"%05d" % ps_z}"
+
+				file.syswrite('!')
+				STDOUT.flush
+				sleep 0.0125
+				file.syswrite(str)
+				STDOUT.flush
+				sleep 0.0125
+				file.syswrite('~')
+				STDOUT.flush
+
+				sleep 0.1
+			end
+		rescue Interrupt, SystemExit, SignalException
+			file &.close
+			exit 0
+		rescue Errno::ENOENT, IceTM::NoDeviceError
+			device = find_device
+
+			unless device
+				puts "#{IceTM::BOLD}#{IceTM::RED}:: #{Time.now.strftime('%H:%M:%S.%2N')}: No device found. Retrying#{IceTM::RESET}"
+				sleep 0.1
+			end
+
+			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]
+
+		iostat = IO.foreach('/proc/diskstats'.freeze).find { |x|
+			x.split[2] == @@root_partition
+		} &.split.to_a[11]
+	end
+
+	extend(self)
+end

data/lib/ice_tm/version.rb

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

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: ice_tm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sourav Goswami
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-04-23 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, ICE Task Manager
+email:
+- souravgoswami@protonmail.com
+executables:
+- ice-tm
+extensions:
+- ext/baudrate/extconf.rb
+extra_rdoc_files: []
+files:
+- exe/ice-tm
+- ext/baudrate/baudrate.c
+- ext/baudrate/extconf.rb
+- lib/ice_tm.rb
+- lib/ice_tm/ice_tm.rb
+- lib/ice_tm/version.rb
+homepage: https://github.com/souravgoswami/ice-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, ICE Task Manager
+test_files: []