Python - 流行の科学技術を勝手に追いかけるブログ人工知能仮想現実ブロックチェーン

機械学習：pandas_datareaderで株価を取得してpandasで統計処理してmatplotlibで可視化する

pandas_datareaderで株価を取得してpandasで統計処理してmatplotlibで可視化してみます。

次回は、sklearnで株価を予測してみますので、当該記事でpandas_datareaderの使い方を覚えてしまいましょう。

# 使用するモジュール群をインポート

# 使用するモジュール群をインポート
import datetime
import matplotlib.pyplot as plt
import numpy as np
import pandas_datareader
import sklearn
import sklearn.linear_model
import sklearn.model_selection

# 使用するモジュール群をインポート

import datetime

import matplotlib.pyplot as plt

import numpy as np

import pandas_datareader

import sklearn

import sklearn.linear_model

import sklearn.model_selection

# データウェアハウスからAPIを利用してデータを引っ張ってくる

# データウェアハウス
df_nvda = pandas_datareader.data.DataReader("NVDA","yahoo","2014-11-01")
df_aapl = pandas_datareader.data.DataReader("AAPL","yahoo","2014-11-01")
df_fb = pandas_datareader.data.DataReader("FB","yahoo","2014-11-01")
df_gold = pandas_datareader.data.DataReader("GLD","yahoo","2014-11-01")

# データウェアハウス

df_nvda = pandas_datareader.data.DataReader("NVDA","yahoo","2014-11-01")

df_aapl = pandas_datareader.data.DataReader("AAPL","yahoo","2014-11-01")

df_fb = pandas_datareader.data.DataReader("FB","yahoo","2014-11-01")

df_gold = pandas_datareader.data.DataReader("GLD","yahoo","2014-11-01")

#終値のチャートを可視化

#終値のチャートを可視化
df_nvda["Close"].plot(figsize=(16,5),color="green")
df_fb["Close"].plot(figsize=(16,5),color="blue")
df_gold["Close"].plot(figsize=(16,5),color="orange")

# figを保存
plt.savefig("chart_001.png")
plt.show()

#終値のチャートを可視化

df_nvda["Close"].plot(figsize=(16,5),color="green")

df_fb["Close"].plot(figsize=(16,5),color="blue")

df_gold["Close"].plot(figsize=(16,5),color="orange")

# figを保存

plt.savefig("chart_001.png")

plt.show()

# 統計処理：単純移動平均

# 統計処理

# 過去14日単純移動平均のcolumnを作成する
df_nvda["SMA"] = df_nvda["Close"].rolling(window=14).mean()

#終値と過去14日単純移動平均を比較したグラフを作成する
df_nvda["Close"].plot(figsize=(15,6), color="red")
df_nvda["SMA"].plot(figsize=(15,6), color="green")
plt.show()

# 過去14日単純移動平均が追加されたデータフレームを確認
df_nvda

# 統計処理

# 過去14日単純移動平均のcolumnを作成する

df_nvda["SMA"] = df_nvda["Close"].rolling(window=14).mean()

#終値と過去14日単純移動平均を比較したグラフを作成する

df_nvda["Close"].plot(figsize=(15,6), color="red")

df_nvda["SMA"].plot(figsize=(15,6), color="green")

plt.show()

# 過去14日単純移動平均が追加されたデータフレームを確認

df_nvda

#統計処理：変動率

# 始値に対する当日の変動率 % のcolumnを新規追加
df_nvda["change"] = ((df_nvda["Close"]-df_nvda["Open"])/df_nvda["Open"])*100
df_aapl["change"] = ((df_aapl["Close"]-df_aapl["Open"])/df_aapl["Open"])*100
df_fb["change"] = ((df_fb["Close"]-df_fb["Open"])/df_fb["Open"])*100
df_gold["change"] = ((df_gold["Close"]-df_gold["Open"])/df_gold["Open"])*100

# 直近１００日間の変動率 %　を可視化 
df_nvda["change"].tail(100).plot(figsize=(15,6), color="green")
df_aapl["change"].tail(100).plot(figsize=(15,6), color="red")
df_fb["change"].tail(100) .plot(figsize=(15,6), color="blue")
df_gold["change"].tail(100) .plot(figsize=(15,6), color="gold")

# 保存
plt.savefig("chart_variable.png")
plt.show()

# 始値に対する当日の変動率 % のcolumnを新規追加

df_nvda["change"] = ((df_nvda["Close"]-df_nvda["Open"])/df_nvda["Open"])*100

df_aapl["change"] = ((df_aapl["Close"]-df_aapl["Open"])/df_aapl["Open"])*100

df_fb["change"] = ((df_fb["Close"]-df_fb["Open"])/df_fb["Open"])*100

df_gold["change"] = ((df_gold["Close"]-df_gold["Open"])/df_gold["Open"])*100

# 直近１００日間の変動率 %　を可視化

df_nvda["change"].tail(100).plot(figsize=(15,6), color="green")

df_aapl["change"].tail(100).plot(figsize=(15,6), color="red")

df_fb["change"].tail(100) .plot(figsize=(15,6), color="blue")

df_gold["change"].tail(100) .plot(figsize=(15,6), color="gold")

# 保存

plt.savefig("chart_variable.png")

plt.show()

では、次回はこれをsklearnで機械学習して未来を予測してみます。

Python:csv,DataFrame,Matplotlibの操作例

データ処理のコード例です。

有限要素法解析のポストプロセッサJ-visionから吐き出される応力データを評価使用とすると、自分でデータをこねくり回す必要があります。エクセルではやってられないのでpythonで自動化しました。

私の使い方は、csvからデータフレームとして取り込む＞不要なデータを削除してデータフレームを整形する。＞欲しいデータになるように演算する＞結果を可視化する。という流れが多いです。

一度作ったら、クラス化しておけば後々改造するのが楽ちんになりますので、積極的にやっています。

やっていきましょう。モジュール群をインポートします。

#python3
"""
当該プログラムはLS-Dyna ポストプロセッサ J-Visionによる第１主応力、ミーゼス相当応力などのcsv出力データを取り込み
時系列最大値（場所は問わず）のグラフを出力するスクリプトです。Keita_Nakamori

"""
%matplotlib inline
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.ticker as tick # 目盛り操作
import matplotlib.patches as patches # グラフ内へ図形を追加

#python3

"""

当該プログラムはLS-Dyna ポストプロセッサ J-Visionによる第１主応力、ミーゼス相当応力などのcsv出力データを取り込み

時系列最大値（場所は問わず）のグラフを出力するスクリプトです。Keita_Nakamori

"""

%matplotlib inline

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import matplotlib.ticker as tick # 目盛り操作

import matplotlib.patches as patches # グラフ内へ図形を追加

クラスとメソドです。
csvファイルを読み込んでDataFrameを作成。整理します。

class jvision():
    def __init__(self):
        pass
    
    def show_graph(self,file_addr, save=True):
        """csvデータを読み込んで　データフレームとして整形し　グラフを出力する
        
        args:
            file_addr : csvファイルのアドレス.拡張子
            save      : 出力したグラフを file_addr.png　としてカレントディレクトリに保存する
        
        return : なし
        
        attribute :
            self.df            :整形したデータフレーム
            self.array_max     : 選択した全要素のうち、最大の応力を時系列に並べたリストを表示
            self.max           : 全時刻　選択した全要素の応力の最大値を算出
            self.array_impulse : 選択した全要素の応力の総和を時系列に並べたリスト
            self.impulse       : 全時刻　選択した全要素の力積の総和
                 
        
        """
        # ======== データの整形========
        
        #csvデータの１行目に空白があるのでデータフレームを作成する際に予め定義してエラーを回避する
        col_names = [ 'c{0:02d}'.format(i) for i in range(1000) ]

        #csvデータの１，２行目に日本語があるのでエンコーディングをshift-jisとしてエラーを回避する
        encoding="shift-jis"

        #データフレームを作成する
        df=pd.read_csv(file_addr,names=col_names, encoding="shift-jis")

        #不要なcolumnを削除する
        del df["c00"]

        #不要なindexを削除する
        df = df.drop(range(2))

        #timeをindexとして定義し、不要となったc0を削除する
        time = np.array(df["c01"])
        df.index = time
        del df["c01"]

        # データフレーム内の NAN を含むcolumを削除 .dropna
        df.shape              #削除前のシェイプ(102, 999)
        df = df.dropna(axis=1, how ="all")
        df = df.astype(float) #データフレームのあ中はすべて文字列になっているので数値化する
        df.shape              #削除後のシェイプ(102, 321)
        
        # ======== データの解析========
        
        # 各時刻ごとの最大値を算出
        df_max = df.max(axis=1) # kgf/mm2
        df_max =df_max *9.8     # MPa
        
        #全時刻の最大値を算出
        print(" Max stress in the data : {:.3f} MPa".format(df_max.max(axis=0)))  # MPa
        
        # Figureを設定        #最大値を算出
        df_max = df.max(axis=1) # kgf/mm2
        df_max =df_max *9.8  # MPa
        array_max =np.array(df_max) #np.arrayとして抽出
        fig = plt.figure(figsize=(10, 5))

        # グラフ描画領域を追加
        ax = fig.add_subplot(111)

        # Axesのタイトルを設定
        ax.set_title(file_addr, fontsize = 20)
        
        # 時間timeを表すdf.indexは文字列なのでfloatに変換する
        li=[]
        for i in df.index: 
            li.append(float(i))
        time = li
        
        # 全時刻　選択した全要素の力積の総和
        array_impulse = df.sum(axis=1)*(li[1]-li[0]) # 時系列の力積リスト
        impulse = array_impulse.sum(axis=0)          # 力積の最大値
        
        
        
        #アトリビュートを生成する
        self.df   = df
        self.time = time
        self.array_max = array_max
        self.max = df_max.max(axis=0)
        self.array_impulse = array_impulse
        self.impulse =impulse
        
        # ======== データの可視化========
        
        # データをプロット
        ax.plot(time, array_max,label="stress",color="red",marker="",linestyle="solid" ,linewidth=2 )
        ax.legend(fontsize=20,loc=1)
        plt.xlabel("time / sec",fontsize=20)
        plt.ylabel("Stress / MPa",fontsize=20)
        plt.tick_params(labelsize = 18)
        
        
        # x軸の目盛設定
        #ax.set_xticks( np.arange(0, 0.0010, 0.0002) )
        
        # y軸の目盛設定
        #ax.set_yticks(np.arange(0,1000,10))
        
        #ax.tick_params(direction = "inout", length = 5, colors = "black")
        
        #plt.gca().xaxis.set_minor_locator(tick.MultipleLocator(5))
        #plt.gca().yaxis.set_minor_locator(tick.MultipleLocator(0.1))
        
        
        # グリッド表示をONにする
        plt.grid(which='minor')
        ax.grid(True)
        
        #x,yのリミット範囲を定義する
        ax.set_xlim(0,0.001)
        ax.set_ylim(0,10000)
        
        #保存と表示
        if save==True:
            plt.savefig(file_addr+".png")

        return

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

class jvision():

def __init__(self):

pass

def show_graph(self,file_addr, save=True):

"""csvデータを読み込んで　データフレームとして整形し　グラフを出力する

args:

file_addr : csvファイルのアドレス.拡張子

save : 出力したグラフを file_addr.png　としてカレントディレクトリに保存する

return : なし

attribute :

self.df :整形したデータフレーム

self.array_max : 選択した全要素のうち、最大の応力を時系列に並べたリストを表示

self.max : 全時刻　選択した全要素の応力の最大値を算出

self.array_impulse : 選択した全要素の応力の総和を時系列に並べたリスト

self.impulse : 全時刻　選択した全要素の力積の総和

"""

# ======== データの整形========

#csvデータの１行目に空白があるのでデータフレームを作成する際に予め定義してエラーを回避する

col_names = [ 'c{0:02d}'.format(i) for i in range(1000) ]

#csvデータの１，２行目に日本語があるのでエンコーディングをshift-jisとしてエラーを回避する

encoding="shift-jis"

#データフレームを作成する

df=pd.read_csv(file_addr,names=col_names, encoding="shift-jis")

#不要なcolumnを削除する

del df["c00"]

#不要なindexを削除する

df = df.drop(range(2))

#timeをindexとして定義し、不要となったc0を削除する

time = np.array(df["c01"])

df.index = time

del df["c01"]

# データフレーム内の NAN を含むcolumを削除 .dropna

df.shape #削除前のシェイプ(102, 999)

df = df.dropna(axis=1, how ="all")

df = df.astype(float) #データフレームのあ中はすべて文字列になっているので数値化する

df.shape #削除後のシェイプ(102, 321)

# ======== データの解析========

# 各時刻ごとの最大値を算出

df_max = df.max(axis=1) # kgf/mm2

df_max =df_max *9.8 # MPa

#全時刻の最大値を算出

print(" Max stress in the data : {:.3f} MPa".format(df_max.max(axis=0))) # MPa

# Figureを設定 #最大値を算出

df_max = df.max(axis=1) # kgf/mm2

df_max =df_max *9.8 # MPa

array_max =np.array(df_max) #np.arrayとして抽出

fig = plt.figure(figsize=(10, 5))

# グラフ描画領域を追加

ax = fig.add_subplot(111)

# Axesのタイトルを設定

ax.set_title(file_addr, fontsize = 20)

# 時間timeを表すdf.indexは文字列なのでfloatに変換する

li=[]

for i in df.index:

li.append(float(i))

time = li

# 全時刻　選択した全要素の力積の総和

array_impulse = df.sum(axis=1)*(li[1]-li[0]) # 時系列の力積リスト

impulse = array_impulse.sum(axis=0) # 力積の最大値

#アトリビュートを生成する

self.df = df

self.time = time

self.array_max = array_max

self.max = df_max.max(axis=0)

self.array_impulse = array_impulse

self.impulse =impulse

# ======== データの可視化========

# データをプロット

ax.plot(time, array_max,label="stress",color="red",marker="",linestyle="solid" ,linewidth=2 )

ax.legend(fontsize=20,loc=1)

plt.xlabel("time / sec",fontsize=20)

plt.ylabel("Stress / MPa",fontsize=20)

plt.tick_params(labelsize = 18)

# x軸の目盛設定

#ax.set_xticks( np.arange(0, 0.0010, 0.0002) )

# y軸の目盛設定

#ax.set_yticks(np.arange(0,1000,10))

#ax.tick_params(direction = "inout", length = 5, colors = "black")

#plt.gca().xaxis.set_minor_locator(tick.MultipleLocator(5))

#plt.gca().yaxis.set_minor_locator(tick.MultipleLocator(0.1))

# グリッド表示をONにする

plt.grid(which='minor')

ax.grid(True)

#x,yのリミット範囲を定義する

ax.set_xlim(0,0.001)

ax.set_ylim(0,10000)

#保存と表示

if save==True:

plt.savefig(file_addr+".png")

return

クラスのインスタンスを作成して、メソドを実行します。

# インスタンスの作成
data = jvision()

# 読み込むファイルのアドレスを定義する
file_addr_li =[]

file_addr_li.append("case1_n0_principal_stress.csv")
file_addr_li.append("case1_n1_principal_stress.csv")
file_addr_li.append("case1_n2_principal_stress.csv")
file_addr_li.append("case2_n0_principal_stress.csv")
file_addr_li.append("case2_n1_principal_stress.csv")
file_addr_li.append("case2_n2_principal_stress.csv")
file_addr_li.append("case3_n0_principal_stress.csv")
file_addr_li.append("case3_n1_principal_stress.csv")
file_addr_li.append("case3_n2_principal_stress.csv")



# グラフ作成・保存・アトリビュートのメソド jvision.make_graph()を実行する

stress_dict={}
impulse_dict ={}

for file_addr in file_addr_li:
    data.show_graph(file_addr,save=True)
    
    # 応力の最大値をディクショナリで取得
    stress_dict[file_addr] = data.max # MPa
    
    # 力積の総和をディクショナリで取得
    impulse_dict[file_addr] = data.impulse # MPa・s

# インスタンスの作成

data = jvision()

# 読み込むファイルのアドレスを定義する

file_addr_li =[]

file_addr_li.append("case1_n0_principal_stress.csv")

file_addr_li.append("case1_n1_principal_stress.csv")

file_addr_li.append("case1_n2_principal_stress.csv")

file_addr_li.append("case2_n0_principal_stress.csv")

file_addr_li.append("case2_n1_principal_stress.csv")

file_addr_li.append("case2_n2_principal_stress.csv")

file_addr_li.append("case3_n0_principal_stress.csv")

file_addr_li.append("case3_n1_principal_stress.csv")

file_addr_li.append("case3_n2_principal_stress.csv")

# グラフ作成・保存・アトリビュートのメソド jvision.make_graph()を実行する

stress_dict={}

impulse_dict ={}

for file_addr in file_addr_li:

data.show_graph(file_addr,save=True)

# 応力の最大値をディクショナリで取得

stress_dict[file_addr] = data.max # MPa

# 力積の総和をディクショナリで取得

impulse_dict[file_addr] = data.impulse # MPa・s

結果整理１

#del stress_dict["case3_n0_principal_stress.csv"]
y=stress_dict.values()
x=range(len(y))
plt.bar(x,y)
plt.show()

#del stress_dict["case3_n0_principal_stress.csv"]

y=stress_dict.values()

x=range(len(y))

plt.bar(x,y)

plt.show()

結果整理２

#del impulse_dict["case3_n0_principal_stress.csv"]
y=impulse_dict.values()
x=range(len(y))
plt.bar(x,y)
plt.show()

#del impulse_dict["case3_n0_principal_stress.csv"]

y=impulse_dict.values()

x=range(len(y))

plt.bar(x,y)

plt.show()

以上、参考まで。

Python:マルチスレッド　threading モジュール

どーもこんにちはKeita_Nakamori(´・ω・`)です。

最近はIoT関係で遊んでいるのですが、１つのラズパイで、複数のセンサーを扱うにはどうすればいいか考えていました。

普通のシングルスレッドで実行すると、PLCでいうところのスキャンタイムに依存することになります。

あるセンサーは高速でパルスをカウントしなければならない一方で、別のセンサーは、１秒周期でいいよとか、サンプリングタイムが全然違う場合はどうすればいいのか。

解決策として、マルチスレッドというものがあります。

それぞれのセンサーでサンプリングする関数を作って、それぞれを別々のスレッドとしてオブジェクト化して、メインスレッド内で実行するというやり方です。そうすると、それぞれのスレッドが互いに干渉することなく、あたかも２つのプログラムが同時に動いているような挙動を示します。

今回は、IOTというより、Pythonの基本なので、カテゴリーはPythonにしました。

では、やってみましょう。

まずは普通の関数を実行

まず最初に　time_count()という関数を作って実行してみましょう。

１秒ごとに現在時間を出力しているだけのスクリプトです。

Pythonではthreadingモジュールから利用することができます。

import datetime
import time

def time_count():
    print("time count start")
    cnt=0
    while True:
        now = datetime.datetime.now()
        print(now)
        cnt+=1
        time.sleep(1)
        if cnt > 10:
            print(" time is dead")
            break
    print("finished")

time_count()

import datetime

import time

def time_count():

print("time count start")

cnt=0

while True:

now = datetime.datetime.now()

print(now)

cnt+=1

time.sleep(1)

if cnt > 10:

print(" time is dead")

break

print("finished")

time_count()

結果：どうでしょう、これは普通ですよね。

time count start
2019-06-03 22:16:48.919908
2019-06-03 22:16:49.919994
2019-06-03 22:16:50.920481
2019-06-03 22:16:51.920590
2019-06-03 22:16:52.920871
2019-06-03 22:16:53.921354
2019-06-03 22:16:54.922110
2019-06-03 22:16:55.922260
2019-06-03 22:16:56.922273
2019-06-03 22:16:57.922571
2019-06-03 22:16:58.923210
time is dead
finished

time count start

2019-06-03 22:16:48.919908

2019-06-03 22:16:49.919994

2019-06-03 22:16:50.920481

2019-06-03 22:16:51.920590

2019-06-03 22:16:52.920871

2019-06-03 22:16:53.921354

2019-06-03 22:16:54.922110

2019-06-03 22:16:55.922260

2019-06-03 22:16:56.922273

2019-06-03 22:16:57.922571

2019-06-03 22:16:58.923210

time is dead

finished

次は、これをスレッド化して実行してみましょう。

import datetime
import time

def time_count():
    print("time count start")
    cnt=0
    while True:
        now = datetime.datetime.now()
        print(now)
        cnt+=1
        time.sleep(1)
        if cnt > 10:
            print("time is dead")
            break
    print("finished")
    
thread_001 = threading.Thread(target=time_count)
thread_001.start()

import datetime

import time

def time_count():

print("time count start")

cnt=0

while True:

now = datetime.datetime.now()

print(now)

cnt+=1

time.sleep(1)

if cnt > 10:

print("time is dead")

break

print("finished")

thread_001 = threading.Thread(target=time_count)

thread_001.start()

最後の２行で、関数をスレッドとしてオブジェクト化し、スタートさせています。

動作は、全く一緒です。

そして、次はマルチスレッドを試してみましょう。

今度は２つのスレッドを同時に動かしてみます。

import threading
import datetime
import time

def time_count():
    print("time count start")
    cnt=0
    while True:
        now = datetime.datetime.now()
        print(now)
        cnt+=1
        time.sleep(1)
        if cnt > 10:
            print("time is over")
            break
    print("time count is done")

def time_alert():
    print("ready to alert")
    time.sleep(5)
    print("get up now!!")
    print("end of alert")
    
thread_001 = threading.Thread(target=time_count)
thread_002 = threading.Thread(target=time_alert)
 
thread_001.start()
thread_002.start()
print("here is script end")

import threading

import datetime

import time

def time_count():

print("time count start")

cnt=0

while True:

now = datetime.datetime.now()

print(now)

cnt+=1

time.sleep(1)

if cnt > 10:

print("time is over")

break

print("time count is done")

def time_alert():

print("ready to alert")

time.sleep(5)

print("get up now!!")

print("end of alert")

thread_001 = threading.Thread(target=time_count)

thread_002 = threading.Thread(target=time_alert)

thread_001.start()

thread_002.start()

print("here is script end")

結果：さあどうでしょうか。

thread_001とthread_002をスタートして、最後に”here is script end”をするスクリプトです。

thread_001が始まった直後にthread_002もスタートしていますので、スクリプト通り、thread_001による時間カウントが５秒のところで”get up now!!”というthread_002の出力が確認できます。

さらに、スクリプトの最後の”here is script end１”はthread_002がスタートされた直後に終了しています。

メインスレッドが最後までいっても、thread_001、thread_002が終わっていなければ、プログラムは終わりません。このように、実は３つのスレッドが同時に走っているわけです。

time count start
2019-06-03 22:22:18.637921
ready to alert
here is script end
2019-06-03 22:22:19.638316
2019-06-03 22:22:20.639319
2019-06-03 22:22:21.640172
2019-06-03 22:22:22.641065
get up now!!
end of alert
2019-06-03 22:22:23.641760
2019-06-03 22:22:24.642122
2019-06-03 22:22:25.642486
2019-06-03 22:22:26.642826
2019-06-03 22:22:27.643360
2019-06-03 22:22:28.644210
time is over
time count is done

time count start

2019-06-03 22:22:18.637921

ready to alert

here is script end

2019-06-03 22:22:19.638316

2019-06-03 22:22:20.639319

2019-06-03 22:22:21.640172

2019-06-03 22:22:22.641065

get up now!!

end of alert

2019-06-03 22:22:23.641760

2019-06-03 22:22:24.642122

2019-06-03 22:22:25.642486

2019-06-03 22:22:26.642826

2019-06-03 22:22:27.643360

2019-06-03 22:22:28.644210

time is over

time count is done

最後に

関数をメソド化して使ってみましょう。

# 最後に　関数をメソド化してみる
import threading
import datetime
import time

class time_ruler():
    
    def time_count(self):
        print("time count start")
        cnt=0
        while True:
            now = datetime.datetime.now()
            print(now)
            cnt+=1
            time.sleep(1)
            if cnt > 10:
                print("time is over")
                break
        print("time count is done")

    def time_alert(self):
        print("ready to alert")
        time.sleep(5)
        print("get up now!!")
        print("end of alert")

# インスタンス作成
time_master = time_ruler()

# メソドをスレッドにする。
thread_001 = threading.Thread(target=time_master.time_count)
thread_002 = threading.Thread(target=time_master.time_alert)

# スレッドをスタート
thread_001.start()
thread_002.start()
print("script is over")

# 最後に　関数をメソド化してみる

import threading

import datetime

import time

class time_ruler():

def time_count(self):

print("time count start")

cnt=0

while True:

now = datetime.datetime.now()

print(now)

cnt+=1

time.sleep(1)

if cnt > 10:

print("time is over")

break

print("time count is done")

def time_alert(self):

print("ready to alert")

time.sleep(5)

print("get up now!!")

print("end of alert")

# インスタンス作成

time_master = time_ruler()

# メソドをスレッドにする。

thread_001 = threading.Thread(target=time_master.time_count)

thread_002 = threading.Thread(target=time_master.time_alert)

# スレッドをスタート

thread_001.start()

thread_002.start()

print("script is over")

動作は一緒です。以上です。

IOT:ラズベリーパイ　パーティクルセンサー

どーもご無沙汰しております、Keita_Nakamori(´・ω・`)です。

先日、パーティクルセンサーが届きましたので、使ってみようと思います。

Particle Sensor　Model PPD42NS

ヒーターで空気を温めて上昇気流を作り、光学式センサーを通過させることによって、粒子数をカウントするとのことです。なので、向きが大事です。

スペック

スペック的にPM2.5なんてのも取れそうです。

安定するまでに１分間必要と書いてあるので、スクリプトの中で”現在立ち上げ中です。”とか”カウントダウン”とかを入れてあげると良いと思います。

検出可能な粒子サイズ： 1μm (minimum.)
検出濃度範囲： 0~28,000 pcs/L (0~8,000pcs/0.01 CF=283mL)
供給電圧： DC5V ±10% (CN1コネクタ:ピン1=GND , ピン3=+5V)
作動温度範囲： 0~45°C
作動湿度範囲：相対湿度95% 以下 (結露なきこと)
電力消費： 90mA
周囲温度： -30~60°C
安定するまでの立上時間：１分
電源ONから安定に必要な時間：１分
寸法： 59(W) × 45(H) × 22(D) [mm]
出力方式：負論理、デジタル出力　←　ここは後で解説します。
Hi : 4.0V以上 Low : 0.7V以下

コネクタ

右から　黒　赤　黄　のケーブルがついた脱着可能なコネクタがついていました

しかし、これ、ブレッドボードに刺さるわけでも、ブレッドボード用のケーブルがささるわけでもないので、取っ払ってしまいました。

コネクタケーブルを引き抜くと、ちょうどラズパイのGPIOと同じサイズのピンが出てきますので黒　赤　黄の３本のメス型ケーブルに差し替えました。

説明書によると　右から

CN : S5B-EH(JST)
1 : COMMON(GND)
2 : OUTPUT(P2)
3 : INPUT(5VDC 90mA)
4 : OUTPUT(P1)
5 : INPUT(T1)･･･FOR THRESHOLD FOR [P2]

となっていますので、使用するのは、黒：GND　赤：５V　黄：出力P1　の３つになります。

ラズパイ側のGPIO

事前に必要な知識として、ラズパイGPIOピンの指定方法には２種類の表現があります。

１．BOARD番号で指定する場合

PythonではGPIO.setmode(GPIO.BOARD)と書きます。

ラズパイのボード（基盤）の配置順に番号が振られていて、たとえばpin=40とした場合はGPIO21のことを指します

２．BCM番号で指定する場合

こちらはGPIO.setmode(GPIO.BCM)と書きます。
GPIO21を指定したいときは、そのままpin=21と書きます。

こちらのほうがわかりやすいので私はこちらを使っています。どっちでもOKです。

出力データと処理の話

出力はパルスで出力されます。
低パルスの状態が３０秒間に占める割合（LPO：Low Plulse Occupancy time)を粒子数として換算するようです。

「1μm以上の粒子が283mLの中に何個入っているか」と「低パルス占有率」の関係を測定したサンプルデータです。（メーカーHPより）

スクリプト

では、センサーから出力されたLowパルスの占有率を算出しましょう。

まずは、うまく行かなかった例です。

# モジュールをインポート
import RPi.GPIO as GPIO
import time

# 微小なLowパルス時間をカウントする
def time_low(pin):
    """
    args:
        pin  :pulse input pin number

    variables:
        t_start:開始時間
        t_end  :終了時間
    
    returns:Lowパルスの微小時間
        t_end - t_start: (終了時間 - 開始時間)
                
    """

    # 変数の初期化（現在時刻）
    t_start = time.time()
    
    # 変数の初期化
    t_end = time.time()
    
    # GPIOに入力されるパルスがLowの時間
    while GPIO.input(pin) == False:
        t_end = time.time()

    return (t_end - t_start)

# Lowパルス占有率を計算する
def lpo(pin):
    # 初期の時間の定義
    t0 = time.time()
    
    # low時間の初期化
    t_low = 0
    
    # サンプリング時間＝３０sec （スペックより）
    ts = 30

    # ループします。
    while(True):
        # LOW状態の微小時間dt_lowを求める関数:time_low()
        dt_low = time_low(pin)
        
        # low時間に追加する
        t_low = t_low + dt_low

        # (現在時間-初期時間)　が　サンプリング時間を超えたらブレイク
        if ((time.time() - t0) > ts):
            
            # LOWパルス占有率
            low_ratio = t_low/ts

            print("Low Pulse Time [sec]:".format(low_ratio))
            print(ratio, " [%]")
            break



# GPIO.BCMの表現でピン番号を指定する
GPIO.setmode(GPIO.BCM)

# センサーからのパルスが入力されるピンを指定する
pulse_pin = 21

# TRIG_PINを出力, ECHO_PINを入力
GPIO.setup(pulse_pin,GPIO.IN)

# 実行直後に予定な警告が出ないようにする。
GPIO.setwarnings(False)

#とりあえず３回出力してみる
for i in [1,2,3]:
    # Lowパルス占有率算出関数:lpo
    lpo(pulse_pin)

# 使用しているピン設定をクリアにする
GPIO.cleanup()

# モジュールをインポート

import RPi.GPIO as GPIO

import time

# 微小なLowパルス時間をカウントする

def time_low(pin):

"""

args:

pin :pulse input pin number

variables:

t_start:開始時間

t_end :終了時間

returns:Lowパルスの微小時間

t_end - t_start: (終了時間 - 開始時間)

"""

# 変数の初期化（現在時刻）

t_start = time.time()

# 変数の初期化

t_end = time.time()

# GPIOに入力されるパルスがLowの時間

while GPIO.input(pin) == False:

t_end = time.time()

return (t_end - t_start)

# Lowパルス占有率を計算する

def lpo(pin):

# 初期の時間の定義

t0 = time.time()

# low時間の初期化

t_low = 0

# サンプリング時間＝３０sec （スペックより）

ts = 30

# ループします。

while(True):

# LOW状態の微小時間dt_lowを求める関数:time_low()

dt_low = time_low(pin)

# low時間に追加する

t_low = t_low + dt_low

# (現在時間-初期時間)　が　サンプリング時間を超えたらブレイク

if ((time.time() - t0) > ts):

# LOWパルス占有率

low_ratio = t_low/ts

print("Low Pulse Time [sec]:".format(low_ratio))

print(ratio, " [%]")

break

# GPIO.BCMの表現でピン番号を指定する

GPIO.setmode(GPIO.BCM)

# センサーからのパルスが入力されるピンを指定する

pulse_pin = 21

# TRIG_PINを出力, ECHO_PINを入力

GPIO.setup(pulse_pin,GPIO.IN)

# 実行直後に予定な警告が出ないようにする。

GPIO.setwarnings(False)

#とりあえず３回出力してみる

for i in [1,2,3]:

# Lowパルス占有率算出関数:lpo

lpo(pulse_pin)

# 使用しているピン設定をクリアにする

GPIO.cleanup()

改良

動かないので、改良ついでにクラス化してみました。

なおかつ３０秒ごとに出力される粒子濃度のデータをconsentration.txtに随時書き出すようにしました。

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import RPi.GPIO as GPIO
import time
import datetime
       
class particle_counter():

    def __init__(self):
        pass

    def set_pin_number(self, PIN=21):
        self.PIN = PIN
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(self.PIN, GPIO.IN)
        GPIO.setwarnings(False)
                
    def particle_count(self, count_times=10):
        self.count_times = count_times

        #print('Counting Now')
        print(' datetime.datetime.now() : Pulse Low Occupancy')

        for i in range(self.count_times):
            print('Revolution : ',i)
            self.lpo()

    def lpo(self):
        #print('lpo method excuting')
        t_start = time.time()
        t_low = 0
        t_interval = 30 # [sec] by instruction

        while(True):

            # LOW状態の微小時間dt_lowを求める関数:time_low()
            dt_low = self.time_low()
            
            # low時間に追加する
            t_low += dt_low
            t_current = time.time() - t_start

        
        
                  
            # (現在時間-初期時間)　が　サンプリング時間を超えたらブレイク
            if (t_current > t_interval):
                
                # LOWパルス占有率
                #print('(self.t_current,self.t_low)aaaaa: ', (t_current, t_low))
                self.low_occupancy = t_low / t_current
                print(' {} ====> {:.3g}'.format(datetime.datetime.now(),self.low_occupancy))
                f = open('consentration.txt','a')
                data=str(datetime.datetime.now())+","+str(self.low_occupancy)
                f.write(data+"\n")
                f.close()

                break
        

 
    # 微小なLowパルス時間をカウントする
    def time_low(self):
        """
        args:
            pin  :pulse input pin number
     
        variables:
            t_start:開始時間
            t_end  :終了時間
        
        returns:Lowパルスの微小時間
            t_end - t_start: (終了時間 - 開始時間)
                    
        """
     
        # 変数の初期化（現在時刻）

        t_start = time.time()
        t_end = time.time()

        if GPIO.input(self.PIN) == 1:
            return 0.0
        
        # GPIOに入力されるパルスがLowの時間
        while GPIO.input(self.PIN) == 0:
            t_end = time.time()

        return (t_end - t_start)

# Excute to moniter
if __name__ == '__main__':

    # Make instance
    device001 = particle_counter()

    # Set signal pin
    device001.set_pin_number(PIN=21)

    # Excute
    device001.particle_count(count_times=1000000)

    # Finish
    GPIO.cleanup()
    print('==== Done ====')

100

101

102

103

104

105

106

#!/usr/bin/env python

# -*- coding: utf-8 -*-

import RPi.GPIO as GPIO

import time

import datetime

class particle_counter():

def __init__(self):

pass

def set_pin_number(self, PIN=21):

self.PIN = PIN

GPIO.setmode(GPIO.BCM)

GPIO.setup(self.PIN, GPIO.IN)

GPIO.setwarnings(False)

def particle_count(self, count_times=10):

self.count_times = count_times

#print('Counting Now')

print(' datetime.datetime.now() : Pulse Low Occupancy')

for i in range(self.count_times):

print('Revolution : ',i)

self.lpo()

def lpo(self):

#print('lpo method excuting')

t_start = time.time()

t_low = 0

t_interval = 30 # [sec] by instruction

while(True):

# LOW状態の微小時間dt_lowを求める関数:time_low()

dt_low = self.time_low()

# low時間に追加する

t_low += dt_low

t_current = time.time() - t_start

# (現在時間-初期時間)　が　サンプリング時間を超えたらブレイク

if (t_current > t_interval):

# LOWパルス占有率

#print('(self.t_current,self.t_low)aaaaa: ', (t_current, t_low))

self.low_occupancy = t_low / t_current

print(' {} ====> {:.3g}'.format(datetime.datetime.now(),self.low_occupancy))

f = open('consentration.txt','a')

data=str(datetime.datetime.now())+","+str(self.low_occupancy)

f.write(data+"\n")

f.close()

break

# 微小なLowパルス時間をカウントする

def time_low(self):

"""

args:

pin :pulse input pin number

variables:

t_start:開始時間

t_end :終了時間

returns:Lowパルスの微小時間

t_end - t_start: (終了時間 - 開始時間)

"""

# 変数の初期化（現在時刻）

t_start = time.time()

t_end = time.time()

if GPIO.input(self.PIN) == 1:

return 0.0

# GPIOに入力されるパルスがLowの時間

while GPIO.input(self.PIN) == 0:

t_end = time.time()

return (t_end - t_start)

# Excute to moniter

if __name__ == '__main__':

# Make instance

device001 = particle_counter()

# Set signal pin

device001.set_pin_number(PIN=21)

# Excute

device001.particle_count(count_times=1000000)

# Finish

GPIO.cleanup()

print('==== Done ====')

出力：consentration.txt

中身は下記のような感じです。

2019-05-30 19:16:40.318976,0.07213182909293626
2019-05-30 19:17:10.434010,0.0951778309901365
2019-05-30 19:17:40.536987,0.07830632987722516
2019-05-30 19:18:10.660109,0.05319190541036891
2019-05-30 19:18:40.774304,0.030014825256954498
2019-05-30 19:19:10.876265,0.01660005851583172
2019-05-30 19:19:40.980323,0.019892370764988204
2019-05-30 19:20:11.065823,0.012348209387846658
2019-05-30 19:20:41.148922,0.01847427585179943
2019-05-30 19:21:11.243032,0.010773055171737232

2019-05-30 19:16:40.318976,0.07213182909293626

2019-05-30 19:17:10.434010,0.0951778309901365

2019-05-30 19:17:40.536987,0.07830632987722516

2019-05-30 19:18:10.660109,0.05319190541036891

2019-05-30 19:18:40.774304,0.030014825256954498

2019-05-30 19:19:10.876265,0.01660005851583172

2019-05-30 19:19:40.980323,0.019892370764988204

2019-05-30 19:20:11.065823,0.012348209387846658

2019-05-30 19:20:41.148922,0.01847427585179943

2019-05-30 19:21:11.243032,0.010773055171737232

データ処理

データを処理するためにpandasで読み込んで、整えましょう。

文字パターン抽出 ” .str.extract() ” で文字列を　年月日　時間　濃度　に切り分けます。

import numpy as np
import pandas as pd


with open("consentration.txt",encoding='utf-8') as f:
    f_list=f.readlines() # read as list

series = pd.Series(f_list)
df = series.str.extract('(.+) (.+),(.+)\n',expand=True,)
df.columns=['ymd','hms ms','consentration']
df

import numpy as np

import pandas as pd

with open("consentration.txt",encoding='utf-8') as f:

f_list=f.readlines() # read as list

series = pd.Series(f_list)

df = series.str.extract('(.+) (.+),(.+)\n',expand=True,)

df.columns=['ymd','hms ms','consentration']

すると、こんな感じで切れました

	ymd	hms ms	consentration
0	2019-05-30	19:16:40.318976	0.07213182909293626
1	2019-05-30	19:17:10.434010	0.0951778309901365
2	2019-05-30	19:17:40.536987	0.07830632987722516
3	2019-05-30	19:18:10.660109	0.05319190541036891
4	2019-05-30	19:18:40.774304	0.030014825256954498
5	2019-05-30	19:19:10.876265	0.01660005851583172
6	2019-05-30	19:19:40.980323	0.019892370764988204

可視化

ざっくりとグラフを書いてみます。

%matplotlib inline
import matplotlib.pyplot as plt

x=np.array(df['ymd']+df['hms ms'])
y=np.array(df['consentration'])

plt.plot(x,y)
plt.show()

%matplotlib inline

import matplotlib.pyplot as plt

x=np.array(df['ymd']+df['hms ms'])

y=np.array(df['consentration'])

plt.plot(x,y)

plt.show()

なんじゃこりゃ(*´﹃｀*)

でもとりあえず、なんかおかしいことは分かりました。なんで階段状なんだろう。

もっと研究が必要ですね。

IOT:ラズベリーパイでサーボドライバPCA9685を使ってみる

Keita_Nakamoriです。

前回はサーボモータSG92Rをラズパイに直結して動かしてみました。

今回はサーボモータを１６個同時に動かすことができるサーボドライバPCA9685を使って、SG90とSG92Rを同時に動かしてみようと思います。

動画

基本スペック

I2C周波数範囲：24-1526Hz
動作電圧：2.3-5.5V
入出力の許容電圧：5.5V
最大62個のPCA9685が接続できます￥。よって992個のサーボモータを同時に動かせます。

余談：I2Cはアイスクウエアシーと呼ぶそうです。

ピン

左端のピン

は、上から

GND：ラズパイGIPIOのグランドに接続する
DE：？？？　どこにも繋げない
SCL:シリアル通信のクロック　ラズパイGIPIOのSCL1に繋ぐ
SDA：シリアル通信のデータラズパイGPIOのSDA1に繋ぐ
VCC：プラス電圧　ラズパイGPIOの+5Vに繋ぐ
V+：？？？　どこにも繋げない

下端のピン

はサーボモータを接続します、左から0～１５番が振られてあり合計１６個のサーボモータと接続できます。

上から、

PWM：サーボモータのPWM＝オレンジ
V+：サーボモータの赤
GND：サーボモータの茶

上端のコネクタ

は、電源供給です。

左はV+:ラズパイの5Vに繋ぎます
右はGND：ラズパイのGNDに繋ぎます
今回はラズパイのGPIOに繋ぎましたが、１６個サーボモータを繋げるときは、別途電源を取らなくてはならないと思います。

制御の話

PCA9685はPWMで動きます。
パルス幅によってサーボモータの回転角が0～180degが決定されます。
- 例えば 0.5ms幅のとき0deg、1.5ms幅のとき90deg、2.5ms幅のとき180degになったりします。（周波数で変更できます。周波数が高いほうが高速で制御できます。）
アナログサーボの周波数範囲は３０～６０Hzのものがほとんどです。
例えば、周波数f=60Hzのとき周期はT=1/f=17ms　です。（早い方がいいので60Hzで考えましょう。）
周期Tの分解能は12bitなので、周期Tを2＾12＝４０９６分割できます。１分割分を１ステップと呼ぶことにしましょう。
周期17msを4096分割できるので、１ステップあたり0.004150390625ms　になります。
パルス幅を0.5msにしたければ、ステップは0.5/(17/4096)=120.47058823529412ステップになります。
サーボモータ角度をodegにしたいときは0.5msですから、120ステップをONして、残りの(4096-120)をOFFにすれば良いのです。

サーボ回転角度[deg]	ONの時間 [ms]	ステップ数
0	0.5	120
60	1.0	240
90	1.5	361
120	2.0	481
180	2.5	602

サーボ回転角度を0degから180degにするためには、(602-120)=482ステップになります。
1degあたりのステップ数は　482ステップ/180deg　=　2.7 (step/deg)
なので任意のサーボ回転角度θでステップ数Nsを表現すると、Ns=120+2.7θ ということになります。

モジュール　Adafruit_PCA9685

pip3 install Adafruit_PCA9685　したところ拒否されました。

pipのバージョンを上げて再チャレンジします。

pip3 install –upgrade pip3 と書いたところ pip3でなくてpipで書けみたいなことを言われました。

pip install –upgrade pip　と書いたところ許可がないといっております。

なので、スーパーDOしてみます。

sudo pip install –upgrade pip　これでOKでした

Successfully uninstalled pip-19.0.3
Successfully installed pip-19.1.1

そして再度チャレンジ

pip3 install Adafruit_PCA9685　　[Errno 13] 許可がありません

なるほど読めました。やはり須藤ですね。

sudo pip3 install Adafruit_PCA9685

Successfully installed Adafruit-GPIO-1.0.3 Adafruit-PCA9685-1.0.1 adafruit-pureio-0.2.3

これでやっとAdafruit_PCA9685モジュールがインストールできました。

pip freezeすると

Adafruit-GPIO==1.0.3
Adafruit-PCA9685==1.0.1
Adafruit-PureIO==0.2.3

が入っていました。注意点として、importするときはAdafruitの後ろにはハイフンではなくアンダースコアになります。

スクリプト

import Adafruit_PCA9685
import time

# pwm制御のためのインスタンスを作成する
pwm = Adafruit_PCA9685.PCA9685()

# 周波数は60Hzにする
pwm.set_pwm_freq(60)

# サーボコントロール
cnt =1 
while True:
    print("revolution : ",cnt)
    # サーボNO.0
    pwm.set_pwm(0, 0, 120)
    time.sleep(0.3)
    
    pwm.set_pwm(0, 0, 602)
    time.sleep(0.3)
    
    # サーボNO.1
    pwm.set_pwm(1, 0, 240)
    time.sleep(0.05)
    
    pwm.set_pwm(1, 0, 481)
    time.sleep(0.05)

    pwm.set_pwm(1, 0, 240)
    time.sleep(0.05)
    
    pwm.set_pwm(1, 0, 481)
    time.sleep(0.05)

    cnt += 1

import Adafruit_PCA9685

import time

# pwm制御のためのインスタンスを作成する

pwm = Adafruit_PCA9685.PCA9685()

# 周波数は60Hzにする

pwm.set_pwm_freq(60)

# サーボコントロール

cnt =1

while True:

print("revolution : ",cnt)

# サーボNO.0

pwm.set_pwm(0, 0, 120)

time.sleep(0.3)

pwm.set_pwm(0, 0, 602)

time.sleep(0.3)

# サーボNO.1

pwm.set_pwm(1, 0, 240)

time.sleep(0.05)

pwm.set_pwm(1, 0, 481)

time.sleep(0.05)

pwm.set_pwm(1, 0, 240)

time.sleep(0.05)

pwm.set_pwm(1, 0, 481)

time.sleep(0.05)

cnt += 1

余談

ラズパイの操作はWindowsマシンからrealVNC Viewerでリモートしているのですが、ラズパイ側のidleに書いたスクリプトをcnt+c しても　Windows側にcnt+v　できません。

コツがありまして、ラズパイ側のText Editorに一旦貼り付けた後に、それをcnt+cしてから、Windows側にcnt+v　すると、しっかりと貼り付けられます。

どうぞお試しあれ。

IOT:ラズベリーパイでサーボモータSG92Rを動かす

どーもこんにちはKeita_Nakamori(´・ω・`)です。

今日は、GPIOでサーボモータを動かして見ようと思います。

デバイス

サーボモータ：SG92R

配線

サーボの茶をGND（グランド）
サーボの赤を電源+5V
サーボのオレンジは制御パルス用なので、今回はGPIO18に接続しました。

ラズパイの電源は5Vバッテリー2.1Aです。

※サーボの挙動がガクガクしています。電源のせいかも・・・

テストスクリプト

# python3
import RPi.GPIO as GPIO # 慣例で省略する
import time             #time.sleep()用

def pulse(angle):
    """
    pulse(): 角度をサーボ制御パルスに変換する
    args:
        angle: 角度をdegで入力する 0〜180 deg
        
        0deg = 2.5 %
        180deg =12 %        
    """
    delta_x=180
    delta_y=12-2.5
    return delta_y/delta_x*angle+2.5

# これからは役割ピン番号で指定する BCB = BroadCoM のこと
GPIO.setmode(GPIO.BCM)

# " GPIO18 " をサーボ制御信号の出力ピンとして設定する
gp_num_control = 18
GPIO.setup(gp_num_control, GPIO.OUT)

# 今回は使用しないが外部からの入力信号をする場合
gp_num_input = 2 
GPIO.setup(gp_num_input,GPIO.IN)

#今回は使用しないがピン信号をON/OFFする場合
gp_num_onoff = 5
#GPIO.output(gp_num_onoff,GPIO.HIGH) # ONの場合
#GPIO.output(gp_num_onoff,GPIO.LOW) # OFFの場合

# サーボモータのインスタンスを作成する
# PWM制御をする。引数はピン番号と周波数

# SG92R:PWM周波数 = 50Hz = 20ms , 制御パルス:0.5ms〜2.4ms, (=2.5%〜12%)
servo_001 = GPIO.PWM(gp_num_control, 50)

# サーボ制御パルス出力開始。引数はデューティーサイクル0-100%
servo_001.start(0) 

time.sleep(0.0)

for ang in range(180):
    servo_001.ChangeDutyCycle(pulse(ang))
    print(ang)
    time.sleep(0.1)

servo_001.stop()
GPIO.cleanup()

# python3

import RPi.GPIO as GPIO # 慣例で省略する

import time #time.sleep()用

def pulse(angle):

"""

pulse(): 角度をサーボ制御パルスに変換する

args:

angle: 角度をdegで入力する 0〜180 deg

0deg = 2.5 %

180deg =12 %

"""

delta_x=180

delta_y=12-2.5

return delta_y/delta_x*angle+2.5

# これからは役割ピン番号で指定する BCB = BroadCoM のこと

GPIO.setmode(GPIO.BCM)

# " GPIO18 " をサーボ制御信号の出力ピンとして設定する

gp_num_control = 18

GPIO.setup(gp_num_control, GPIO.OUT)

# 今回は使用しないが外部からの入力信号をする場合

gp_num_input = 2

GPIO.setup(gp_num_input,GPIO.IN)

#今回は使用しないがピン信号をON/OFFする場合

gp_num_onoff = 5

#GPIO.output(gp_num_onoff,GPIO.HIGH) # ONの場合

#GPIO.output(gp_num_onoff,GPIO.LOW) # OFFの場合

# サーボモータのインスタンスを作成する

# PWM制御をする。引数はピン番号と周波数

# SG92R:PWM周波数 = 50Hz = 20ms , 制御パルス:0.5ms〜2.4ms, (=2.5%〜12%)

servo_001 = GPIO.PWM(gp_num_control, 50)

# サーボ制御パルス出力開始。引数はデューティーサイクル0-100%

servo_001.start(0)

time.sleep(0.0)

for ang in range(180):

servo_001.ChangeDutyCycle(pulse(ang))

print(ang)

time.sleep(0.1)

servo_001.stop()

GPIO.cleanup()

IOT:ラズベリーパイにVNC接続してOpenCVで顔認識する

どーもこんにちは(´・ω・`)です。

前回、ラズベリーパイにVNC接続してOpenCVでカメラの起動に成功しました。

今回は更に、そのOpenCVで顔認識も追加していこうと思います。

bcm2835-v4l2　の自動化

前回ハマりました、bcm2835-v4l2　についてですが、やはりシャットダウンすると、無効になってしまい、OpenCVが機能しませんでした。

今回は、まず起動したときに自動的にbcm2835-v4l2　が実行される方法からやっていきます。

/etc/modules を開くと

# /etc/modules: kernel modules to load at boot time.
#
# This file contains the names of kernel modules that should be loaded
# at boot time, one per line. Lines beginning with “#” are ignored.

i2c-dev

と書いてありますが、これは”ブートするときにロードするためのカーネルモジュール群”　を書いておく場所になっています。Windowsでいうとスタートアップです。

ここにbcm2835-v4l2をいれればOKなのですが、このファイルは書き込み禁止なので、予め解除しておきます。

ファイル書き込み禁止を解除する

パーミッションを確認します。

pi@pi:/etc $ ls -l modules

-rw-r–r– 1 root root 203 3月 23 20:29 modules

スーパーユーザーsudoとしてチェンジモードchmodして、パーミッションを777にします。

pi@pi:/etc $ sudo chmod 777 modules

で、変更が成功したか確認すると
pi@pi:/etc $ ls -l modules

-rwxrwxrwx 1 root root 203 3月 23 20:29 modules

フルアクセスに変更されました。

その上で、チェンジディレクトリcd /etc/でvimでmodulesを開きます。

pi@pi:/etc $ vim modules

i2c-devの下にbcm2835-v4l2を追加して保存しましょう。

# /etc/modules: kernel modules to load at boot time.
#
# This file contains the names of kernel modules that should be loaded
# at boot time, one per line. Lines beginning with “#” are ignored.

i2c-dev
bcm2835-v4l2

キャットで確認すれば

pi@pi:/etc $ cat modules

しっかりとbcm2835-v4l2が追加されているのがわかると思います。

本題：Opencvで顔認識をやってみる

基本的には、前回のコードに学習済みハールカスケードと顔認識した顔に四角い図形でマーキングをするスクリプトを追加するだけです。

まずhaarcascade_frontalface_alt2.xmlは/usr/local/share/OpenCV/haarcascades/　の中に入っているので、作業ディレクトリであるhome/pi/の中へコピーを作っておきます。

import numpy as np
import cv2

if __name__ == '__main__':
    # グローバル変数を定義
    ESC_KEY = 27     # Escキー
    INTERVAL= 33     # インターバル
    FRAME_RATE = 30  # フレームレートfps
    
    # ウィンドウ名称を定義
    ORIGINAL_WINDOW_NAME = "original"
    GRAY_SCALE_WINDOW_NAME = "gray_scale"

    DEVICE_ID = 0

    # 学習済みの分類器を定義
    cascade = cv2.CascadeClassifier("haarcascade_frontalface_alt2.xml")

    # カメラ映像を取得
    cap = cv2.VideoCapture(DEVICE_ID)

    # 初期フレームを読み込む
    end_flag, frame = cap.read()
    height, width, channels = frame.shape

    # ウィンドウの準備
    cv2.namedWindow(ORIGINAL_WINDOW_NAME)
    cv2.namedWindow(GRAY_SCALE_WINDOW_NAME)

    # 画像処理
    while end_flag == True:

        # 画像の取得と顔の検出
        img = frame
        img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        face_list = cascade.detectMultiScale(img_gray, minSize=(100, 100))

        # 検出した顔に四角いマーキングを付ける
        for (x, y, w, h) in face_list:
            color = (100, 100, 225) # GBR
            line_width = 3
            cv2.rectangle(img_gray, (x, y), (x+w, y+h), color, thickness = line_width)

        # フレームを表示
        cv2.imshow(ORIGINAL_WINDOW_NAME, frame)
        cv2.imshow(GRAY_SCALE_WINDOW_NAME, img_gray)

        # Escキーで終了
        key = cv2.waitKey(INTERVAL)
        if key == ESC_KEY:
            break

        # 次のフレーム読み込み
        end_flag, frame = cap.read()

    # 終了処理
    cv2.destroyAllWindows()
    cap.release()

import numpy as np

import cv2

if __name__ == '__main__':

# グローバル変数を定義

ESC_KEY = 27 # Escキー

INTERVAL= 33 # インターバル

FRAME_RATE = 30 # フレームレートfps

# ウィンドウ名称を定義

ORIGINAL_WINDOW_NAME = "original"

GRAY_SCALE_WINDOW_NAME = "gray_scale"

DEVICE_ID = 0

# 学習済みの分類器を定義

cascade = cv2.CascadeClassifier("haarcascade_frontalface_alt2.xml")

# カメラ映像を取得

cap = cv2.VideoCapture(DEVICE_ID)

# 初期フレームを読み込む

end_flag, frame = cap.read()

height, width, channels = frame.shape

# ウィンドウの準備

cv2.namedWindow(ORIGINAL_WINDOW_NAME)

cv2.namedWindow(GRAY_SCALE_WINDOW_NAME)

# 画像処理

while end_flag == True:

# 画像の取得と顔の検出

img = frame

img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

face_list = cascade.detectMultiScale(img_gray, minSize=(100, 100))

# 検出した顔に四角いマーキングを付ける

for (x, y, w, h) in face_list:

color = (100, 100, 225) # GBR

line_width = 3

cv2.rectangle(img_gray, (x, y), (x+w, y+h), color, thickness = line_width)

# フレームを表示

cv2.imshow(ORIGINAL_WINDOW_NAME, frame)

cv2.imshow(GRAY_SCALE_WINDOW_NAME, img_gray)

# Escキーで終了

key = cv2.waitKey(INTERVAL)

if key == ESC_KEY:

break

# 次のフレーム読み込み

end_flag, frame = cap.read()

# 終了処理

cv2.destroyAllWindows()

cap.release()

以上、簡単ですね。

IOT:ラズベリーパイにVNC接続してOpenCVで cv2.VideoCapture(0)してみる

どーもこんにちはKeita_Nakamori(´・ω・`)です。

今日は、WindowsマシンからラズベリーパイにVNC接続してOpenCVで cv2.VideoCapture(0)に挑戦します。

まずはrealVNC viewerを起動してIPアドレスを打ってVNC接続します。

1回つなげたことのあるIPアドレスは保存され、アイコンみたいに表示されるので２回目からはアイコンをクリックするだけの簡単操作でした。

落とし穴

早速ハマりました。cap=cv2.VideoCapture(0)してもcapにはなにもデータが入ってきません。ふぁ～(*´Д｀)

ret, img = cap.read() しても、当然imgはNoneです。

なぜだ！

思い出しました

そう、かつてハマりまくった、あのときを・・・

ラズパイ専用カメラをしようしているので、一般的なwebカメラとして認識できるように下記のコードを実行することが必要でした。

注意点としては最後の部分は　「ぶい　よん　える　に」　です。

「ぶい　よん　いち　に」　だと思って奮闘してしまいました。

sudo modprobe bcm2835-v4l2

ということで、shellでsudo modprobe bcm2835-v4l2と打ってカメラを認識させます。

テストコードを実行すると・・・

はい、隣の部屋のソファーが写っています。

弱点

ラズパイはwifi接続、Windowsマシンは有線ですが、VNC解像度をミディアムにしても、カメラのキャプチャー映像はガックガク！！です。

低解像度だと色がキッタナイ！

どうにもなりません。

念の為、試運転のコードを貼っておきます。

# -*- coding: utf-8 -*-
import numpy as np
import cv2

cap = cv2.VideoCapture(0)

while(True):
    # Capture frame-by-frame
    ret, frame = cap.read()

    # Our operations on the frame come here
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Display the resulting frame
    cv2.imshow('frame',frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()

# -*- coding: utf-8 -*-

import numpy as np

import cv2

cap = cv2.VideoCapture(0)

while(True):

# Capture frame-by-frame

ret, frame = cap.read()

# Our operations on the frame come here

gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

# Display the resulting frame

cv2.imshow('frame',frame)

if cv2.waitKey(1) & 0xFF == ord('q'):

break

# When everything done, release the capture

cap.release()

cv2.destroyAllWindows()

IOT:Python socketモジュールで通信してみる

どーも　こんちには　Keita_Nakamori (´・ω・`) です

今日は、socketモジュールを使ってみます。

前回、少しsocketモジュールについて基本的な操作をやりましたが、実際に運用するとなると不備が多いので、そこを修正していきます。

IT用語　（予備知識）

ポート

ネットワーク内の端末間でデータをやり取りする港（port）です。

ポート番号

ポートの番号です。TPCでデータをやり取りするとき、データは１プロセスとか１スレッドというプログラムの塊を対象とします。そのプロセスにはポート番号が割り当てられそこを通ってデータをやり取りします。

IPアドレスが住所なら、ポート番号はマンションの部屋番号みたいなものです。

よく使う番号をピックアップしてみます。

TCP 20 : FTP (データ)
TCP 22 : SSH
TCP 25 : SMTP
TCP 80 : HTTP
TCP 443 : HTTPS

ポート番号の種類

ポート番号は0から65535まで存在します。その中でも３つの種類に分けれれます。

ウェルノウンポート番号　0~1023

よく知られているポート番号という名前の通り、TPC/IP通信において主要なサービスがすでに使用しているポート番号です。ユーザーがここをいじってしまうと不具合が生じるので触らないでおきましょう。

レジスタードポート番号　1024~49151

特定のアプリケーションなどが使用することになっている番号です。IANAという団体が管理しているので、使うときは申請しなくてはいけません。

その他のポート番号　49152~65535

ユーザが自由に使って良いポート番号です。しかし、やたらと開放してはいけません。必要なものだけ開けましょう。

スクリプト

続きはあとで書きます。

IOT:python LINE Notify にメッセージを送る

どーも　こんちには　Keita_Nakamori (´・ω・`) です

PythonからLINE Notifyにメッセージを送るということをやってみようと思います。後々IOTの一環で、設備などの状態を監視し、故障予測の通知をしていくためにやってみました。

LINE notifyのAPI ドキュメント

LINE notifyのAPI ドキュメントをみるとやり方が書いてありますので、その通り進めました。通常のLINEアカウントがあればOKです。

予めトークンを取得しておいてください。

スクリプト

下記コードの<ここにアクセストークンを入れる>へ代入してください。<　>は要りません。Bearerとの間にはスペースを一つ入れてください。

messageをmassageとミスタイプして焦らないでください。（わたしです）

import requests

# 条件 : パラメータmassage を型strで1000文字以内
payload = {'message': 'エヴァ初号機のLCC圧力が生存限界を超えています！直ちにエントリープラグを強制射出してください!100'}
request_headers = {'Authorization': 'Bearer <ここにアクセストークンを入れる>'}

# 通知系 API のエンドポイントのホスト名は notify-api.line.me
r = requests.post('https://notify-api.line.me/api/notify', headers=request_headers, data=payload)

print(r.json())

import requests

# 条件 : パラメータmassage を型strで1000文字以内

payload = {'message': 'エヴァ初号機のLCC圧力が生存限界を超えています！直ちにエントリープラグを強制射出してください!100'}

request_headers = {'Authorization': 'Bearer <ここにアクセストークンを入れる>'}

# 通知系 API のエンドポイントのホスト名は notify-api.line.me

r = requests.post('https://notify-api.line.me/api/notify', headers=request_headers, data=payload)

print(r.json())

実行すると下記のように自分のラインへアラートが来ます。

2024年4月
月	火	水	木	金	土	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30

クラスとメソドです。 csvファイルを読み込んでDataFrameを作成。整理します。

クラスのインスタンスを作成して、メソドを実行します。

結果整理１

結果整理２

まずは普通の関数を実行

次は、これをスレッド化して実行してみましょう。

そして、次はマルチスレッドを試してみましょう。

最後に

Particle Sensor Model PPD42NS

スペック

コネクタ

ラズパイ側のGPIO

１．BOARD番号で指定する場合

出力データと処理の話

スクリプト

改良

動画

基本スペック

ピン

左端のピン

下端のピン

上端のコネクタ

制御の話

モジュール Adafruit_PCA9685

スクリプト

余談

デバイス

配線

テストスクリプト

bcm2835-v4l2 の自動化

ファイル書き込み禁止を解除する

本題：Opencvで顔認識をやってみる

落とし穴

思い出しました

弱点

念の為、試運転のコードを貼っておきます。

IT用語 （予備知識）

ポート

ポート番号

ポート番号の種類

ウェルノウンポート番号 0~1023

レジスタードポート番号 1024~49151

その他のポート番号 49152~65535

スクリプト

LINE notifyのAPI ドキュメント

スクリプト

実行結果

クラスとメソドです。
csvファイルを読み込んでDataFrameを作成。整理します。

Particle Sensor　Model PPD42NS

モジュール　Adafruit_PCA9685

bcm2835-v4l2　の自動化

IT用語　（予備知識）

ウェルノウンポート番号　0~1023

レジスタードポート番号　1024~49151

その他のポート番号　49152~65535