LazGem 0.0.4 → 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 985405454252520def5e31a7afae9187704aa1c4
+  data.tar.gz: 03699e93b777b3b52de11603b2fa40df4bce8c12
+SHA512:
+  metadata.gz: feae049a0705ecdac98751f784c75ef733b49d49b5ae3f2e2c180863ed028681b28711b9aa353411e2965bdf34a84f931c59e02b4328f2e23690b3a40b561445
+  data.tar.gz: 7fff6cd541ccb21472487dd82dd9c90db8c97469da5fd0e901b9fc2620e41b283a8321da52e178ed7df06b47198aedf3c9c0c40a072b3d6b33d9e7f30603c3fb

data/README.md

@@ -22,13 +22,17 @@ Or install it yourself as:
 
 ## Usage
 
-please try to execute sample program
+###please try to execute sample program
 tx:	sample\sample_tx.rb
+
 rx:	sample\sample_rx.rb
 
-document(Japanese only):
+
+###document(Japanese only):
+
   http://www.lapis-semi.com/lazurite-jp/contents/gateway/ruby/LazGem.html
 
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/LazGem/device.rb

@@ -3,8 +3,12 @@
 # Function:
 #   Lazurite Pi Gateway SubGHz library
 
-
-class LAZURITE_ERROR < StandardError; end
+#################################################################
+######
+######	Do not forget to change path of libraries
+######			require and insmod
+######
+################################################################
 class LazGem::Device
 	##
 	# func   : Read the data from the receiving pipe
@@ -15,44 +19,20 @@ class LazGem::Device
 	@@device_rd=nil
 	@@device_wr=nil
 
-# LAZURITE.open(ch=36,panid=0xabcd,pwr=20,rate=100),mode=2)
-# function
-#	open device deriver
-# parameter
-#	ch:		frequency 24-61. 36 is in default
-#	panid:	pan id
-#	pwr:		tx power
-#	rate:	bit rate  50 or 100
-#	pwr:		tx power  1 or 20
-#	mode:	must be 2
-# return
-#	none
-	def device_open(ch=36, panid=0xabcd, pwr=20, rate=100, mode=2)
-		if(ch < 24) || (ch > 61) then
-			puts "ch is invalid. it must be 24-61"
-			raise LAZURITE_ERROR
-			return
-		end
-		if(pwr != 1) && (pwr != 20) then
-			puts "pwr is invalid. it must be 1 or 20"
-			raise LAZURITE_ERROR
-			return
-		end
-		if(rate != 50) && (rate != 100) then
-			puts "rate is invalid. it must be 50 or 100"
-			raise LAZURITE_ERROR
-			return
-		end
-		cmd = "sudo insmod /home/pi/driver/LazDriver/DRV_802154.ko ch=" +ch.to_s+" panid=0x"+panid.to_s(16)+ " pwr="+pwr.to_s+" rate="+rate.to_s + " mode="+mode.to_s(16)
+	def init()
+		cmd = "sudo insmod /home/pi/driver/LazDriver/lazdriver.ko"
+		p cmd
 		result = system(cmd)
-		bp3596_dev = "/dev/bp3596"
+		lzgw_dev = "/dev/lzgw"
 		sleep(0.1)
-		result = system("sudo chmod 777 "+bp3596_dev)
+		result = system("sudo chmod 777 "+lzgw_dev)
 #		p result
 		sleep(0.1)
-		@@device_rd = open(bp3596_dev,"rb")
-		@@device_wr = open(bp3596_dev,"wb")
-		result = system("tail -n -2 /var/log/messages")
+		@@device_rd = open(lzgw_dev,"rb")
+		@@device_wr = open(lzgw_dev,"wb")
+		@@device_wr.sync = true
+		@@device_rd.sync = true
+		result = system("tail -n -4 /var/log/messages")
 		print("\n")
 #		p result
 		print("Success to load SubGHz module\n")
@@ -65,180 +45,147 @@ class LazGem::Device
 #	none
 # return
 #	none
-	def device_close()
-		@@device_rd.close
+	def remove()
+		begin
+			@@device_rd.close
+		rescue Exception => e
+			p e
+		end
+		begin
 		@@device_wr.close
+		rescue Exception => e
+			p e
+		end
 		@@devie_rd = nil
 		@@device_wr = nil
-		cmd = "sudo rmmod DRV_802154"
+		cmd = "sudo rmmod lazdriver"
 		system(cmd)
 		p cmd
 	end
 
-
-# LAZURITE.read()
-# function
-#	try to read data from SubGHz module
-# parameter
-#	none
-# return
-#	-1:			no data
-#	Hash[]:		receiving data
-#		key
-#		"command" => command	it should be fixed to 0x03
-#		"Time" => Time class of receiving time
-#		"usec" => integer type data of usec for receiving time
-#		"rxPanid" => unsigned long type data of panid for receiving
-#			if packet does not include panid, data is -1.
-#		"rxAddrType" => unsigned char type deta of address type
-#				0 = packet no rxAddr
-#				1 = rxAddr = 8 bit integer type
-#				2 = rxAddr = 16bit include rxAddr
-#				3 = rxAddr = 64bit rxAddr String type
-#		"rxAddr" => rx address. data type is determined by rxAddrType
-#		"txPanid" => long type data of panid for sending
-#			if packet does not include panid, data is -1.
-#		"txAddrType" => unsigned char type deta of address type
-#			same meaning of data as rxAddrType
-#		"txAddr" => tx Address. data type is determind by txAddrType
-#		"rssi" => RF power, when receiving
-#		"payload" => binary stream type of data. need to unpack for using as strings
-
 	def read()
-		# Data reception wait (timeout = 100ms)
-		ret = select([@@device_rd], nil, nil, 0.1)
-		# Reads the size of the received data
-		len = @@device_rd.read(2)
-		if ((len == "") || (len == nil)) then # read result is empty
-			return -1
-		end
-		size =  len.unpack("S*")[0]
-		# The received data is read
-		recv_buf = @@device_rd.read(size)
-		if ((recv_buf == "") || (recv_buf == nil)) then # read result is empty
-			return -1
+		size = 2
+		len = @@device_rd.read(size)
+    	if ((len == "") || (len == nil)) then # read result is empty
+      		return -1
+    	end
+    	size =  len.unpack("S*")[0]
+
+    	# The received data is read
+    	raw = @@device_rd.read(size)
+    	if ((raw == "") || (raw == nil)) then # read result is empty
+      		return -1
 		end
-		return recv_dec(recv_buf,size)
-	end
-
-	def recv_dec(raw,size)
-		# PANID
-		command =		raw[0..1].unpack("S*")[0]
-		tv_sec =		raw[2..5].unpack("L*")[0]
-		tv_usec =		raw[6..9].unpack("L*")[0]/1000
-		t = Time.at(tv_sec,tv_usec)
-		area =			raw[10..11].unpack("a2")[0]
-		ch =			raw[12..13].unpack("S*")[0]
-		rate =			raw[14..15].unpack("S*")[0]
-		pwr =			raw[16..17].unpack("S*")[0]
-		header =		raw[18..21].unpack("L*")[0]
-		rxPanid =		raw[22..25].unpack("L*")[0]
-		rxAddrType =	raw[26].unpack("C*")[0]
-		if rxAddrType == 0 then
-			rxAddr = -1
-		elsif rxAddrType == 1 then
-			rxAddr = raw[34].unpack("n*")[0]
-		elsif rxAddrType == 2 then
-			rxAddr =		raw[33..34].unpack("n*")[0]
-		elsif rxAddrType == 3 then
-			rxAddr =		raw[27..34].unpack("a8*")[0]
-		end
-		txPanid =		raw[35..38].unpack("L*")[0]
-		txAddrType =	raw[39].unpack("C*")[0]
-
-		if txAddrType == 0 then
-			txAddr = -1
-		elsif txAddrType == 1 then
-			txAddr = raw[47].unpack("n*")[0]
-		elsif txAddrType == 2 then
-			txAddr =		raw[46..47].unpack("n*")[0]
-		elsif txAddrType == 3 then
-			txAddr =		raw[40..47].unpack("a8*")[0]
-		end
-
-		rssi =			raw[48].unpack("C*")[0]
-		payload =		raw[49..size-1]
 		
-		out = Hash["Command" => command,
-					"Time" => t,
-					"usec" => tv_usec,
-					"Area" => area,
-					"ch" => ch,
-					"rate" => rate,
-					"pwr" => pwr,
-					"header" => header,
-					"rxPanid" => rxPanid,
-					"rxAddrType" => rxAddrType,
-					"rxAddr" => rxAddr,
-					"txPanid" => txPanid,
-					"txAddrType" => txAddrType,
-					"txAddr" => txAddr,
-					"rssi" => rssi,
-					"payload" => payload,
-					]
-	end
-
-# LAZURITE.write()
-# function
-#	sending data by SubGHz
-#	currently only one format is supported.
-# parameter
-#	HASH[]
-#		currently two parameter should be included.
-#		"rxAddr" => 	Integer type of rxAddress
-#		"payload" => 	binary array of sending data
-#		<option>
-#		"rxPanid" => rxPanid. If it is not included, rxPanid = 0xABCD
-# return
-#		none
-# Exception
-#		KeyError			: if hash data does not include rxAddr, this error is raisen.
-#		PAYLOAD_SIZE_OVER	: payload length is over
-	def write(packet)
-		begin
-			rxAddrType =packet.fetch("header")
-		rescue KeyError
-			header =0xa821
+		len = raw.length
+		header = raw.unpack("S*")[0]
+
+		rx_addr_type = (header>>14) & 0x03
+		frame_ver = (header >> 12) & 0x03
+		tx_addr_type = (header >> 10) & 0x03
+		ielist = (header >> 9) & 0x01
+		seq_comp = (header >> 8) & 0x01
+		panid_comp = (header >> 6) & 0x01
+		ack_req = (header >> 5) & 0x01
+		pending = (header >> 4) & 0x01
+		sec_enb = (header >> 3) & 0x01
+		frame_type = (header >> 0) & 0x07
+
+		offset = 2
+
+		if seq_comp == 0 then
+			seq = raw[offset..offset+1].unpack("C")[0]
+			offset = offset + 1
 		end
-		seq = 0
 
-		# panid
-		begin
-			rxPanid =packet.fetch("rxPanid")
-		rescue KeyError
-			rxPanid = 0xABCD
+		if rx_addr_type == 0 && tx_addr_type == 0 && panid_comp == 0 then
+			addr_type = 0
+			rx_panid = nil
+			tx_panid = nil
+		elsif rx_addr_type == 0 && tx_addr_type == 0 && panid_comp != 0 then
+			addr_type = 1
+			rx_panid = raw[offset..offset+2].unpack("S*")[0]
+			offset = offset + 2
+			tx_panid = nil
+		elsif rx_addr_type == 0 && tx_addr_type != 0 && panid_comp == 0 then
+			addr_type = 2
+			rx_panid = nil
+			tx_panid = raw[offset..offset+2].unpack("S*")[0]
+			offset = offset + 2
+		elsif rx_addr_type == 0 && tx_addr_type != 0 && panid_comp != 0 then
+			addr_type = 3
+			rx_panid = nil
+			tx_panid = nil
+		elsif rx_addr_type != 0 && tx_addr_type == 0 && panid_comp == 0 then
+			addr_type = 4
+			rx_panid = raw[offset..offset+2].unpack("S*")[0]
+			offset = offset + 2
+			tx_panid = nil
+		elsif rx_addr_type != 0 && tx_addr_type == 0 && panid_comp != 0 then
+			addr_type = 5
+			rx_panid = nil
+			tx_panid = nil
+		elsif rx_addr_type != 0 && tx_addr_type != 0 && panid_comp == 0 then
+			addr_type = 6
+			rx_panid = raw[offset..offset+2].unpack("S*")[0]
+			offset = offset + 2
+			tx_panid = nil
+		elsif rx_addr_type != 0 && tx_addr_type != 0 && panid_comp != 0 then
+			addr_type = 7
+			rx_panid = nil
+			tx_panid = nil
 		end
 
-		# rxAddr
-		rxAddr =packet.fetch("rxAddr")
-
-		# txAddr
-		txAddr = 0
-
-		#payload
-		payload =packet["payload"]
-		if payload.length > 235 then
-			puts "Payload size over. maximum length is less than 235"
-			raise LAZURITE_ERROR
-			return
+		if rx_addr_type == 1 then
+			rx_addr = raw[offset..offset+1].unpack("C")[0]
+			offset = offset+1
+		elsif rx_addr_type == 2 then
+			rx_addr = raw[offset..offset+2].unpack("S*")[0]
+			offset = offset+2
+		else
+			rx_addr = raw[offset..offset+8].unpack("H*")[0]
+			offset = offset+8
 		end
 
-		raw = [header,seq,rxPanid,rxAddr,txAddr,payload].pack("scsssa*")
-
-		ret = select(nil, [@@device_wr], nil, 0.1)
-		begin
-			len = @@device_wr.write(raw)
-		rescue
-			puts "Doesn't receive ACK"
-			raise LAZURITE_ERROR
+		if tx_addr_type == 1 then
+			tx_addr = raw[offset..offset+1].unpack("C")[0]
+			offset = offset+1
+		elsif tx_addr_type == 2 then
+			tx_addr = raw[offset..offset+2].unpack("S")[0]
+			offset = offset+2
+		else
+			tx_addr = raw[offset..offset+8].unpack("H*")[0]
+			offset = offset+8
 		end
-		return len
+
+		payload = raw[offset..len-1].unpack("Z*")[0]
+
+		rcv = Hash.new()
+
+		rcv["header"] = header
+		rcv["rx_addr_type"] = rx_addr_type
+		rcv["frame_ver"] = frame_ver
+		rcv["tx_addr_type"] = tx_addr_type
+		rcv["ielist"] = ielist
+		rcv["seq_comp"] = seq_comp
+		rcv["panid_comp"] = panid_comp
+		rcv["ack_req"] = ack_req
+		rcv["pending"] = pending
+		rcv["sec_enb"] = sec_enb
+		rcv["frame_type"] = frame_type
+		rcv["addr_type"] = addr_type
+		rcv["rx_panid"] = rx_panid
+		rcv["tx_panid"] = tx_panid
+		rcv["rx_addr"] = rx_addr
+		rcv["tx_addr"] = tx_addr
+		rcv["payload"] = payload
+			
+    	return rcv
 	end
-	def print_bin(data)
-		out = ""
-		for i in 0..data.length-1 do
-			print(data[i].unpack("H*")[0]," ")
-		end
-		print("\n")
+	def send(panid,addr,payload)
+		set_tx_panid(panid)
+		set_tx_addr0(addr)
+		@@device_wr.write(payload)
+		sleep 0.001
 	end
 end

data/lib/LazGem/ioctl.rb

@@ -0,0 +1,385 @@
+
+# -*- coding: utf-8; mode: ruby -*-
+#
+# Function:
+#   Lazurite Pi Gateway SubGHz library
+
+class LazGem::Device
+	IOCTL_CMD=			0x0000
+	IOCTL_SET_BEGIN=		IOCTL_CMD+0x11
+	IOCTL_SET_RXON=			IOCTL_CMD+0x13
+	IOCTL_SET_RXOFF=		IOCTL_CMD+0x15
+	IOCTL_SET_CLOSE=		IOCTL_CMD+0x17
+	IOCTL_GET_SEND_MODE=	 IOCTL_CMD+0x18
+	IOCTL_SET_SEND_MODE=	 IOCTL_CMD+0x19
+	IOCTL_PARAM=		0x1000
+	IOCTL_GET_CH=			IOCTL_PARAM+0x02
+	IOCTL_SET_CH=			IOCTL_PARAM+0x03
+	IOCTL_GET_PWR=			IOCTL_PARAM+0x04
+	IOCTL_SET_PWR=			IOCTL_PARAM+0x05
+	IOCTL_GET_BPS=			IOCTL_PARAM+0x06
+	IOCTL_SET_BPS=			IOCTL_PARAM+0x07
+	IOCTL_GET_MY_PANID=		IOCTL_PARAM+0x08
+	IOCTL_SET_MY_PANID=		IOCTL_PARAM+0x09
+	IOCTL_GET_TX_PANID=		IOCTL_PARAM+0x0a
+	IOCTL_SET_TX_PANID=		IOCTL_PARAM+0x0b
+	IOCTL_GET_MY_ADDR0=		IOCTL_PARAM+0x0c
+	IOCTL_SET_MY_ADDR0=		IOCTL_PARAM+0x0d
+	IOCTL_GET_MY_ADDR1=		IOCTL_PARAM+0x0e
+	IOCTL_SET_MY_ADDR1=		IOCTL_PARAM+0x0f
+	IOCTL_GET_MY_ADDR2=		IOCTL_PARAM+0x10
+	IOCTL_SET_MY_ADDR2=		IOCTL_PARAM+0x11
+	IOCTL_GET_MY_ADDR3=		IOCTL_PARAM+0x12
+	IOCTL_SET_MY_ADDR3=		IOCTL_PARAM+0x13
+	IOCTL_GET_TX_ADDR0=		IOCTL_PARAM+0x14
+	IOCTL_SET_TX_ADDR0=		IOCTL_PARAM+0x15
+	IOCTL_GET_TX_ADDR1=		IOCTL_PARAM+0x16
+	IOCTL_SET_TX_ADDR1=		IOCTL_PARAM+0x17
+	IOCTL_GET_TX_ADDR2=		IOCTL_PARAM+0x18
+	IOCTL_SET_TX_ADDR2=		IOCTL_PARAM+0x19
+	IOCTL_GET_TX_ADDR3=		IOCTL_PARAM+0x1a
+	IOCTL_SET_TX_ADDR3=		IOCTL_PARAM+0x1b
+	IOCTL_GET_ADDR_TYPE=	IOCTL_PARAM+0x1c
+	IOCTL_SET_ADDR_TYPE=	IOCTL_PARAM+0x1d
+	IOCTL_GET_ADDR_SIZE=	IOCTL_PARAM+0x1e
+	IOCTL_SET_ADDR_SIZE=	IOCTL_PARAM+0x1f
+	IOCTL_GET_DRV_MODE=		IOCTL_PARAM+0x20
+	IOCTL_SET_DRV_MODE=		IOCTL_PARAM+0x21
+	IOCTL_GET_SENSE_TIME=	IOCTL_PARAM+0x22
+	IOCTL_SET_SENSE_TIME=	IOCTL_PARAM+0x23
+	IOCTL_GET_TX_RETRY=		IOCTL_PARAM+0x24
+	IOCTL_SET_TX_RETRY=		IOCTL_PARAM+0x25
+	IOCTL_GET_TX_INTERVAL=	IOCTL_PARAM+0x26
+	IOCTL_SET_TX_INTERVAL=	IOCTL_PARAM+0x27
+	IOCTL_GET_CCA_WAIT=		IOCTL_PARAM+0x28
+	IOCTL_SET_CCA_WAIT=		IOCTL_PARAM+0x29
+	IOCTL_GET_RX_SEC0=		IOCTL_PARAM+0x2A
+	IOCTL_GET_RX_SEC1=		IOCTL_PARAM+0x2C
+	IOCTL_GET_RX_NSEC0=		IOCTL_PARAM+0x2E
+	IOCTL_GET_RX_NSEC1=		IOCTL_PARAM+0x30
+	IOCTL_GET_RX_RSSI=		IOCTL_PARAM+0x32
+	IOCTL_GET_TX_RSSI=		IOCTL_PARAM+0x34
+	IOCTL_RF=			0x2000
+	IOCTL_RF_READ=		IOCTL_RF+0x0000
+	IOCTL_RF_WRITE=		IOCTL_RF+0x8000
+	IOCTL_EEPROM=		0x3000
+	IOCTL_RX_LED=		0x4000
+	IOCTL_TX_LED=		0x4000
+
+###			API
+	def begin(ch,panid,bps,pwr)
+		set_ch(ch)
+		set_my_panid(panid)
+		set_bps(bps)
+		set_pwr(pwr)
+		return set_begin()
+	end
+	def getMyAddress()
+		return get_my_addr0()
+	end
+	def rxDisable()
+		rxon = 0;
+		ret = @@device_wr.ioctl(IOCTL_SET_RXOFF,rxon)
+		return ret
+	end
+	def rxEnable()
+		rxon = 1
+		ret = @@device_wr.ioctl(IOCTL_SET_RXON,rxon)
+		return ret
+	end
+	def close()
+		data = 0
+		ret = @@device_wr.ioctl(IOCTL_SET_CLOSE,data)
+		return ret
+	end
+	def getSendMode()
+		data = 0
+		ret = @@device_wr.ioctl(IOCTL_GET_SEND_MODE,data)
+		param = Hash.new()
+		param["addr_type"] = get_addr_type()
+		param["sense_time"] = get_sense_time()
+		param["tx_retry"] = get_tx_retry()
+		param["tx_interval"] = get_tx_interval()
+		param["cca_wait"] = get_cca_wait()
+		param["my_address"] = get_my_addr0()
+		return param
+	end
+	def setSendMode(param)
+		ret = @@device_wr.ioctl(IOCTL_GET_SEND_MODE,data)
+		begin
+			data = param.fetch("addr_type")
+			ret = @@device_wr.ioctl(IOCTL_SET_ADDR_TYPE,data)
+		rescue Exception
+		end
+		begin
+			data = param.fetch("sense_time")
+			ret = @@device_wr.ioctl(IOCTL_SET_SENSE_TIME,data)
+		rescue Exception
+		end
+		begin
+			data = param.fetch("tx_retry")
+			ret = @@device_wr.ioctl(IOCTL_SET_TX_RETRY,data)
+		rescue Exception
+		end
+		begin
+			data = param.fetch("tx_interval")
+			ret = @@device_wr.ioctl(IOCTL_SET_TX_INTERVAL,data)
+		rescue Exception
+		end
+		begin
+			data = param.fetch("cca_wait")
+			ret = @@device_wr.ioctl(IOCTL_SET_CCA_WAIT,data)
+		rescue Exception
+		end
+		begin
+			data = param.fetch("my_address")
+			ret = @@device_wr.ioctl(IOCTL_SET_MY_ADDRESS,data)
+		rescue Exception
+		end
+		ret = @@device_wr.ioctl(IOCTL_SET_SEND_MODE,data)
+		return ret
+	end
+
+###			Libraries
+	def set_begin()
+		data = 0;
+		ret = @@device_wr.ioctl(IOCTL_SET_BEGIN,data)
+		return ret
+	end
+	def get_ch()
+		ch = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_CH,ch)
+		return ret
+	end
+	def set_ch(ch)
+		ret = @@device_wr.ioctl(IOCTL_SET_CH,ch)
+	end
+	def get_pwr()
+		pwr = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_PWR,pwr)
+		return ret
+	end
+	def set_pwr(pwr)
+		ret = @@device_wr.ioctl(IOCTL_SET_PWR,pwr)
+		return ret
+	end
+	def get_bps()
+		bps = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_BPS,bps)
+		return ret
+	end
+	def set_bps(bps)
+		ret = @@device_wr.ioctl(IOCTL_SET_BPS,bps)
+		return ret
+	end
+	def get_my_panid()
+		panid = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_MY_PANID,panid)
+		return ret
+	end
+	def set_my_panid(panid)
+		ret = @@device_wr.ioctl(IOCTL_SET_MY_PANID,panid)
+		return ret
+	end
+	def get_tx_panid()
+		panid = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_TX_PANID,panid)
+		return ret
+	end
+	def set_tx_panid(panid)
+		ret = @@device_wr.ioctl(IOCTL_SET_TX_PANID,panid)
+		return ret
+	end
+	def get_my_addr0()
+		addr = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_MY_ADDR0,addr)
+		return ret
+	end
+	def set_my_addr0(addr)
+		ret = @@device_wr.ioctl(IOCTL_SET_MY_ADDR0,addr)
+		return ret
+	end
+	def get_my_addr1()
+		addr = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_MY_ADDR1,addr)
+		return ret
+	end
+	def set_my_addr1(addr)
+		ret = @@device_wr.ioctl(IOCTL_SET_MY_ADDR1,addr)
+		return ret
+	end
+	def get_my_addr2()
+		addr = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_MY_ADDR2,addr)
+		return ret
+	end
+	def set_my_addr2(addr)
+		ret = @@device_wr.ioctl(IOCTL_SET_MY_ADDR2,addr)
+		return ret
+	end
+	def get_my_addr3()
+		addr = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_MY_ADDR3,addr)
+		return ret
+	end
+	def set_my_addr3(addr)
+		ret = @@device_wr.ioctl(IOCTL_SET_MY_ADDR3,addr)
+		return ret
+	end
+	def get_tx_addr0()
+		addr = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_TX_ADDR0,addr)
+		return ret
+	end
+	def set_tx_addr0(addr)
+		ret = @@device_wr.ioctl(IOCTL_SET_TX_ADDR0,addr)
+		return ret
+	end
+	def get_tx_addr1()
+		addr = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_TX_ADDR1,addr)
+		return ret
+	end
+	def set_tx_addr1(addr)
+		ret = @@device_wr.ioctl(IOCTL_SET_TX_ADDR1,addr)
+		return ret
+	end
+	def get_tx_addr2()
+		addr = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_TX_ADDR2,addr)
+		return ret
+	end
+	def set_tx_addr2(addr)
+		ret = @@device_wr.ioctl(IOCTL_SET_TX_ADDR2,addr)
+		return ret
+	end
+	def get_tx_addr3()
+		addr = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_TX_ADDR3,addr)
+		return ret
+	end
+	def set_tx_addr3(addr)
+		ret = @@device_wr.ioctl(IOCTL_SET_TX_ADDR3,addr)
+		return ret
+	end
+	def get_addr_type()
+		type = 0
+		ret = @@device_wr.ioctl(IOCTL_GET_ADDR_TYPE,type)
+		return ret
+	end
+	def set_addr_type(type)
+		ret = @@device_wr.ioctl(IOCTL_SET_ADDR_TYPE,type)
+		return ret
+	end
+	def get_addr_size()
+		size = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_ADDR_SIZE,size)
+		return ret
+	end
+	def set_addr_size(size)
+		ret = @@device_wr.ioctl(IOCTL_SET_ADDR_SIZE,size)
+		return ret
+	end
+	def get_drv_mode()
+		mode = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_DRV_MODE,mode)
+		return ret
+	end
+	def set_drv_mode(mode)
+		ret = @@device_wr.ioctl(IOCTL_SET_DRV_MODE,mode)
+		return ret
+	end
+	def get_sense_time()
+		sense_time = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_SENSE_TIME,sense_time)
+		return ret
+	end
+	def set_sense_time(sense_time)
+		ret = @@device_wr.ioctl(IOCTL_SET_SENSE_TIME,sense_time)
+		return ret
+	end
+	def get_tx_retry()
+		tx_retry = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_TX_RETRY,tx_retry)
+		return ret
+	end
+	def set_tx_retry(tx_retry)
+		ret = @@device_wr.ioctl(IOCTL_SET_TX_RETRY,tx_retry)
+		return ret
+	end
+	def get_tx_interval()
+		tx_interval = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_TX_INTERVAL,tx_interval)
+		return ret
+	end
+	def set_tx_interval(tx_interval)
+		ret = @@device_wr.ioctl(IOCTL_SET_TX_INTERVAL,tx_interval)
+		return ret
+	end
+	def get_cca_wait()
+		cca_wait = 0;
+		ret = @@device_wr.ioctl(IOCTL_GET_CCA_WAIT,cca_wait)
+		return ret
+	end
+	def set_cca_wait(cca_wait)
+		ret = @@device_wr.ioctl(IOCTL_SET_CCA_WAIT,cca_wait)
+		return ret
+	end
+	def get_rx_time()
+		tmp = 0;
+		rx_sec = @@device_wr.ioctl(IOCTL_GET_RX_SEC1,tmp)
+		rx_sec = rx_sec * 65536 + @@device_wr.ioctl(IOCTL_GET_RX_SEC0,tmp)
+		rx_nsec = @@device_wr.ioctl(IOCTL_GET_RX_NSEC1,tmp)
+		rx_nsec = rx_nsec *65536 + @@device_wr.ioctl(IOCTL_GET_RX_NSEC0,tmp)
+		rx_time = Hash.new()
+		rx_time["sec"] = rx_sec
+		rx_time["nsec"] = rx_nsec
+		return rx_time
+	end
+	def get_rx_rssi()
+		tmp = 0;
+		rssi = @@device_wr.ioctl(IOCTL_GET_RX_RSSI,tmp)
+		return rssi
+	end
+	def get_tx_rssi()
+		tmp = 0;
+		rssi = @@device_wr.ioctl(IOCTL_GET_TX_RSSI,tmp)
+		return rssi
+	end
+
+	def rf_reg_read(addr)
+		data = 0;
+		if addr >= 0 || addr <= 0xff then
+			ret = @@device_wr.ioctl(IOCTL_RF_READ + addr,data)
+			return ret
+		end
+	end
+	def rf_reg_write(addr,data)
+		if addr >= 0 || ch <= 0xff || data >= 0 || data <= 0xff then
+			ret = @@device_wr.ioctl(IOCTL_RF_WRITE+addr ,data)
+			return ret
+		end
+	end
+
+	def eeprom_read(addr)
+		data = 0;
+		if addr >= 0 || addr <= 0x0fff then
+			ret = @@device_wr.ioctl(IOCTL_EEPROM + addr,data)
+			return ret
+		end
+	end
+
+	def rx_led(time)
+		if time >= 0 || time <= 0xffff then
+			ret = @@device_wr.ioctl(IOCTL_RX_LED,time)
+			return ret
+		end
+	end
+
+	def tx_led(time)
+		if time >= 0 || time <= 0xffff then
+			ret = @@device_wr.ioctl(IOCTL_TX_LED,time)
+			return ret
+		end
+	end
+end

data/lib/LazGem/version.rb

@@ -1,3 +1,3 @@
 module LazGem
-    VERSION = "0.0.4"
+    VERSION = "0.0.6"
 end

data/lib/LazGem.rb

@@ -2,4 +2,5 @@ module LazGem; end
 
 require_relative "LazGem/version"
 require_relative "LazGem/device"
+require_relative "LazGem/ioctl"
 

data/sample/sample_rx.rb

@@ -22,7 +22,10 @@ Signal.trap(:INT){
 #  rate:	bit rate  50 or 100
 #  pwr:		tx power  1 or 20
 #  mode:	must be 2
-laz.device_open()
+laz.init()
+laz.begin(36,0xABCD,100,20)
+print(sprintf("myAddress=0x%04x\n",laz.getMyAddress()))
+laz.rxEnable()
 
 # printing header of receiving log
 print(sprintf("time\t\t\t\trxPanid\trxAddr\ttxAddr\trssi\tpayload\n"))
@@ -35,17 +38,13 @@ while finish_flag == 0 do
 		next
 	end
 	# printing data
-	print(sprintf("%s.%06d\t0x%04X\t0x%04X\t0x%04X\t%03d\t%s",
-		rcv["Time"].strftime("%Y-%m-%d %H:%M:%S"),
-		rcv["usec"],
-		rcv["rxPanid"],
-		rcv["rxAddr"],
-		rcv["txAddr"],
-		rcv["rssi"],
-		rcv["payload"].unpack("a*")[0]))
+	p rcv
+	rx_time = laz.get_rx_time()
+	rssi = laz.get_rx_rssi()
+	print(sprintf("rx_time= %s\trx_nsec=%d\trssi=%d\n",Time.at(rx_time["sec"]),rx_time["nsec"],rssi));
 end
 
 # finishing process
-laz.device_close()
+laz.remove()
 
 

data/sample/sample_tx.rb

@@ -7,22 +7,48 @@ require 'LazGem'
 
 laz = LazGem::Device.new
 
+# Halt process when CTRL+C is pushed.
 finish_flag=0
 Signal.trap(:INT){
 	finish_flag=1
 }
-
-laz.device_open()
-
+# open device deriver
+# 
+# LAZURITE.open(ch=36,panid=0xabcd,pwr=20,rate=100),mode=2)
+# parameter
+#  ch:		frequency 24-61. 36 is in default
+#  panid:	pan id
+#  pwr:		tx power
+#  rate:	bit rate  50 or 100
+#  pwr:		tx power  1 or 20
+#  mode:	must be 2
+laz.init()
+print(sprintf("myAddress=0x%04x\n",laz.getMyAddress()))
+i = 0
+# main routine
 while finish_flag == 0 do
-	tx = Hash["rxAddr" => 0x902b]
-	tx["payload"] = "Welcome SubGHz\n"
 	begin
-		laz.write(tx)
-	rescue LAZURITE_ERROR
+	laz.begin(36,0xABCD,100,20)
+	rescue Exception => e
+		p "file io error!! reset driver"
+		laz.remove()
+		laz.init()
+	end
+	begin
+	payload =sprintf("hello pi gateway %d\n",i)
+	p payload
+	laz.send(0xabcd,0x5fba,payload)
+	p laz.get_tx_rssi()
+	laz.close()
+	rescue Exception => e
+	p e
+	sleep 1
 	end
+	sleep 1.000
+	i = i + 1
 end
 
-laz.device_close()
+# finishing process
+laz.remove()
 
 

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: LazGem
 version: !ruby/object:Gem::Version
-  version: 0.0.4
-  prerelease: 
+  version: 0.0.6
 platform: ruby
 authors:
 - NaotakaSaito
@@ -10,57 +9,51 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-17 00:00:00.000000000 Z
+date: 2016-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.11'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
-description: ! 'low power IoT device '
+description: 'low power IoT device '
 email:
 - saitou088@dsn.lapis-semi.com
 - saito253@dsn.lapis-semi.com
@@ -68,8 +61,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -80,6 +73,7 @@ files:
 - bin/setup
 - lib/LazGem.rb
 - lib/LazGem/device.rb
+- lib/LazGem/ioctl.rb
 - lib/LazGem/version.rb
 - release.log
 - sample/sample_rx.rb
@@ -87,26 +81,25 @@ files:
 homepage: https://github.com/LAPIS-Lazurite/LazGem
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Lazurite ruby gem
 test_files: []