2018年1月31日星期三

英特爾多接取邊緣運算(Multi-access Edge Computing，MEC) 解決方案

時間:2017-12-05 16:43來源:英特爾作者:英特爾點擊:167次

MEC商機
物聯網驅動的數十億連網裝置，加上資料龐大的新應用程式以及雲端服務，讓電信網路面臨前所未見的巨大資料量傳輸。若能在網路終端處理特定應用，將可提升網路效能並降低延遲，進而為電信商及OTT內容服務商創造新商機。

MEC解決方案
多接取邊緣運算（MEC）在無線接取網路（RAN）內，近距離地為行動用戶提供IT及雲端運算能力，能為應用開發商及內容供應商提供超低時延、高頻寬的服務環境，並能直接存取即時無線網路資訊（如用戶地點、基地台負載等），提供符合情境的相關應用服務，打造與眾不同的行動寬頻體驗；多接取邊緣運算（MEC）可縮短終端所需的反應時間，提升內容及服務的提供速度，並可根據無線及網路條件增進網路速度及電信服務效能，賦予行動用戶更豐富優質的體驗。

多接取邊緣運算（MEC）帶來全新的生態系和價值鏈，電信商可向獲得授權之第三方單位開放其無線接取網路（RAN）的終端，為行動用戶、企業用戶及特定垂直產業快速、有彈性地佈建創新應用及服務。無論是近距離、情境、快速回應時間及速度均能被轉化為電信商、網路設備商、及其他第三方單位可以活用的價值，讓他們在各自的商業模式內，發揮互補功能，從行動寬頻體驗中獲得商機。

MEC結合NFV
MEC原則之一，是盡可能再利用或活用現有網路功能虛擬化（Network Function Virtualization，NFV）之技術和概念，讓MEC系統成為既有NFV系統的延伸。

MEC重點總結
 提升無線接取網路（RAN）終端之運算能力
 打破接取(Access)與OTT內容服務商之間的壁壘
 為OTT內容服務開發人員提供標準API與「抽象基礎電信介面 (abstract underlying telco interfaces)」的平台
 為5G技術之發展支柱，符合低時延與高頻寬的需求

Intel積極投資於網路技術，從終端到雲端皆以5G為重點。

多項重要技術正在開發，如網路功能虛擬化（NFV）技術已在建置中，為5G逐步奠定基礎。一旦虛擬化完成，網路將快速改變，網路切片(network slicing)等技術也將得以支援各種服務及連線，實現更貼近需要的網路體驗。

英特爾參與多項標準制定，並與多家電信商及設備製造商合作，成立Intel® Network Builders此一網路生態合作的社群，當中包括設備供應商、軟體廠商、應用服務廠商等共超過200家企業一同打造未來的5G網路，並共同開發及測試如動態網路切片、多接取邊緣運算、毫米波及其他技術，共同推動5G及令人期待的各項服務。

不久的將來，包括2018年初的韓國平昌冬季奧運，以及2020年的東京夏季奧運，都將會是5G的展示場！

(責任編輯：helen)

什麼是邊緣計算（Edge computing）？邊緣計算的解釋和三種類型

．什麼是邊緣計算（Edge computing）？邊緣計算的解釋和三種類型

來源：万物云联网

邊緣計算(Edge computing )是一種在物理上，靠近數據生成的位置處理數據的方法，即事物和人所在的現場區域，如家庭和遠端辦公室內。

　　圖2、物聯網設備中通常集成具有一定計算能力的處理器

由於這些產生數據的事物和人通常不在雲端，因此我們需要通過許多形式的在物聯網(IoT)解決方案架構的邊緣處的計算來補充雲計算。

　　圖3、節點與雲之間有大量的數據需要傳遞

關於邊緣計算(Edge computing )的討論，通常會忽略有多少類型的「邊緣」計算，而本文我們將探討邊緣計算(Edge computing )的基本驅動因素，和許多類型的邊緣計算(Edge computing )。

由於邊緣計算(Edge computing )指的是接近於事物，數據和行動源頭處的計算，所以我們也可以把這種類型的數據處理，使用更通用的術語來表示：鄰近計算或者接近計算(Proximity Computing)。

鄰近計算(Proximity Computing)的經濟學因素

我們對周圍所發生的事件，需要即時地做出回應，以獲得良好的用戶體驗(如當需要「改變電視頻道」時)，或者避免災難(如當發生「煤氣洩漏」時)。

　　圖3、感知，處理和行動是物聯網的三類事件

由於有許多這些類發生的事件,因此我們需要將這類複雜的系統編排為感知，處理和行動(SPA、既Sense、Process， and Act (SPA))。 SPA的成本是本地與遠端處理成本，網路連接成本，以及遠端系統管理成本的函數。

就物聯網(IoT)設備的尺寸和功率來說，鄰近計算(Proximity Computing)平衡了回應事件的即時性，與回應事件的成本兩者之間的關係。數據傳遞的管理的法律限制，進一步推動了對鄰近計算(Proximity Computing)的需求。

多邊場景 - 接近計算(Proximity Computing)的類型

當涉及到最佳鄰近計算時，有很多類型的邊緣(edges )要考慮。梳理下來它們主要有三種類型：個人邊緣(Personal Edge)、業務邊緣(Business Edge)，以及雲邊緣(Cloudy Edge)。

這三種邊緣將SPA(Sensing-Processing-Acting)佈署到不同環境中，來處理一系列不同的問題，以實現最佳的自動回應，例如當您的個人汽車被盜時。

　　圖4、三種類型的邊緣

下面是每種邊緣及其發展的驅動因素。

1)個人邊緣(Personal Edge)

這個邊緣計算(Edge computing )圍繞著我們個人，有時就在我們的身邊，就在我們的家裡；它包括家庭機器人、智慧眼鏡、智慧藥片，以及您皮膚下的傳感器、手錶、家庭自動化系統，您的Amazon Echo(回聲)和智慧手機。

個人邊緣(Personal Edge)總體上是移動的。當我們在家庭和工作場所之間移動時，個人邊緣(Personal Edge)計算設備進出於商業邊緣(Business Edge)區。

　　圖5、個人邊緣

隨著智慧家庭設備，數位健康和其他個人設備的普及，我們將在未來5年裡，聽到更多關於個人邊緣(Personal Edge)計算的資訊。

2)業務邊緣(Business Edge)

這是最受關注的邊緣計算(Edge computing )類型。在業務邊緣(Business Edge)處連接的機器和人在這裡匯聚。業務邊緣(Business Edge)在我們鋪有地毯的辦公室中，也可以在無地毯的領域，甚至在我們工作和娛樂的開放的地方。

許多物聯網的討論似乎假設這是唯一的邊緣，同時每個物聯網的討論，都表達了這種邊緣計算(Edge computing )的好處。關鍵任務(Mission-critical)SPA(「感知，處理和行動」，「Sensing-Processing-Acting」))在這一領域尤其如工業物聯網(Industrial IoT)領域中集中發展的勢頭強勁。

　　圖6、業務邊緣

許多供應商正在提供這類應用的開發環境，以幫助客戶開發邊緣應用和分析。 Amazon Lambda Greengrass(https://aws.amazon.com/cn/lambda/)和Azure IoT Hub是此類軟體的示例。

【注1：Amazon Lambda Greengrass是Amazon的雲計算服務，通過 AWS Lambda，無需配置或管理伺服器即可運行代碼。您只需按消耗的計算時間付費 – 代碼未運行時不產生費用。借助 Lambda，您幾乎可以為任何類型的應用程序或後端服務運行代碼，而且全部無需管理。只需上傳您的代碼，Lambda 會處理運行和擴展高可用性代碼所需的一切工作。您可以將您的代碼設置為自動從其他 AWS 服務觸發，或者直接從任何 Web 或移動應用程序調用。】

【注2：Azure IoT Hub是微軟針對物聯網應用的雲計算，Azure IoT Hub意為物聯網中心，是為物聯網設備提供註冊、管理、溝通的雲服務。它是微軟Azure IoT Suite的重要組成部分，也是微軟物聯網戰略的重要基礎。微軟Azure IoT Hub可用於管理數十億物聯網設備，提供雲端與設備之間的雙向通信支持，每月可處理數以萬億計訊息，並簡化了與其他Azure服務之間的整合，包括Azure機器學習以及Azure流分析等。】

3)多雲邊緣(Cloudy Edge)

這是目前最少談論的一類邊緣計算(Edge computing)，但是它是最老的一類邊緣。多雲邊緣(Cloudy Edge)是服務提供商或企業網路邊緣的拓撲術語，其中業務首先從撥號調制解調器，進入到家庭或者遠程分支機構中的。

多雲邊緣(Cloudy Edge)，從前只是一個沒有任何計算能力的網路邊緣。它們被稱為PoP(存在的節點，points-of-presence)。

　　圖7、多雲邊緣(Cloudy Edge)

對應用性能和內容傳送的需求，需要在網路邊緣( network edge)中添加應用和數據處理能力。現代的邊緣數據中心(Edge Data Centers)能夠滿足這一需求。內容交付網路(CDN，Content Delivery Networks)就是在利用它們，以便我們能夠獲得更好的頁面和視訊加載效果。移動邊緣計算(Mobile Edge Computing)增強了這一邊緣的優勢，因為人們需要更好的移動應用程序(mobile app)的性能。

所以老PoP在內容和計算方面變得沒有前途。而SP邊緣( SP edge)，移動邊緣(mobile edge)和企業邊緣(enterprise edge)共同形成了雲端。這類邊緣仍然與確保應用程序性能和內容傳遞順暢等相關。

總結

有很多方法來描述什麼是物聯網(IoT)，這些描述都是對的，只不過有些描述要更全面一些。

在這裡我們提供對物聯網(IoT)的一個這樣的描述：IoT = 跨連接設備迷宮的分布式人工智慧和人類智慧。

　　圖8、邊緣計算正在改變整個物聯網(IoT)場景

像AWS Lambda和Greengrass這樣的邊緣計算(Edge computing )技術，正在幫助加速創建這種分布式人工智慧。如何在個人，業務和雲端邊緣中，創建分布式智慧，將取決於您的應用程序，成本和相關規定。我們將看到越來越多的邊緣計算(Edge computing )參考架構的發展，以支持物聯網(IoT)的新應用模式。

2017年2月26日星期日

[STM32F103 GPIO 定義說明]

void GPIO_Configuration(void)//初始化

{

GPIO_InitTypeDef GPIO_InitStructure; //定義了一個初始化的結構體變數，其中包括埠引腳，速度，模式，

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 ;

//GPIO_Pin_None; //無管腳被選中

//GPIO_Pin_0 - GPIO_Pin_15;//選中管腳 0-15

//GPIO_Pin_All; //選中全部管腳

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//推挽輸出

//GPIO_Mode_AIN; //模擬輸入

//GPIO_Mode_IN_FLOATING ;//浮空輸入

//GPIO_Mode_IPD; //下拉輸入

//GPIO_Mode_IPU; //上拉輸入

//GPIO_Mode_Out_OD; //開漏輸出

//GPIO_Mode_Out_PP; //推挽輸出

//GPIO_Mode_AF_OD; //複用開漏輸出

//GPIO_Mode_AF_PP; //複用推挽輸出

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;

//GPIO_Speed_10MHz; //最高輸出速率 10MHz

//GPIO_Speed_2MHz; //最高輸出速率 2 MHz

//GPIO_Speed_50MHz; //最高輸出速率 50MHz

GPIO_Init(GPIOD, &GPIO_InitStructure);

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

}

main()

{

ReadValue = GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_13);//讀取指定埠位

ReadValue = GPIO_ReadInputData(GPIOC); //讀取指定的 GPIO埠輸入

ReadValue = GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_7);//讀取指定埠管腳的輸出

ReadValue = GPIO_ReadOutputData(GPIOC); //讀取指定的 GPIO埠輸出

GPIO_SetBits(GPIOD,GPIO_Pin_2|GPIO_Pin_4); //設置指定數據埠位元

GPIO_ResetBits(GPIOD,GPIO_Pin_2); //清除指定資料埠位元

GPIO_WriteBit(GPIOD, GPIO_Pin_3, Bit_SET);//設置指定數據埠位元

GPIO_WriteBit(GPIOD, GPIO_Pin_3, Bit_RESET);//清除指定資料埠位元

GPIO_Write(GPIOD,0x0004);//指定GPIO口寫數據

}

2017年1月17日星期二

Linux CentOS7 64bit install docker Note

$sudo yum update

When Centos 6 ,5 befer then Centos7 version install

$sudo yum install -y http://mirrors.yun-idc.com/epel/6/i386/epel-release-6-8.noarch.rpm

$sudo yum install -y docker-io

Centos7 is ready install

$sudo yum install -y docker

# set docker power on auto startup server

$ sudo systemctl enable docker.service

# start run docker

$ sudo systemctl start docker

# test docker run

$ sudo docker run --rm hello-world

2017年1月8日星期日

Docker命令查詢

Docker 包括三個基本概念

映像檔（Image）
容器（Container）
倉庫（Repository）

Docker命令查詢

基本語法

docker [OPTIONS] COMMAND [arg...]

一般來說，Docker 命令可以用來管理 daemon，或者透過 CLI 命令管理映像檔和容器。可以透過 man docker 來查看這些命令。

選項

-D=true|false
    使用 debug 模式。預設為 false。

-H, --host=[unix:///var/run/docker.sock]: tcp://[host:port]來綁定或者 unix://[/path/to/socket] 來使用。
    在 daemon 模式下綁定的 socket，透過一個或多個 tcp://host:port, unix:///path/to/socket, fd://* or fd://socketfd 來指定。

--api-enable-cors=true|false
    在遠端 API 中啟用 CORS 頭。預設為 false。

-b=""
    將容器掛載到一個已存在的橋接器上。指定為 'none' 時則禁用容器的網路。

--bip=""
    讓動態建立的 docker0 採用指定的 CIDR 位址; 與 -b 選項互斥。

-d=true|false
    使用 daemon 模式。預設為 false。

--dns=""
    讓 Docker 使用指定的 DNS 伺服器。

-g=""
    指定 Docker 執行時的 root 路徑。預設為 /var/lib/docker。

--icc=true|false
    啟用容器間通信。預設為 true。

--ip=""
    綁定連接埠時候的預設 IP 位址。預設為 0.0.0.0。

--iptables=true|false
    禁止 Docker 新增 iptables 規則。預設為 true。

--mtu=VALUE
    指定容器網路的 mtu。預設為 1500。

-p=""
    指定 daemon 的 PID 檔案路徑。預設為 /var/run/docker.pid。

-s=""
    強制 Docker 執行時使用指定的儲存驅動。

-v=true|false
    輸出版本資訊並退出。預設值為 false。

--selinux-enabled=true|false
    啟用 SELinux 支援。預設值為 false。SELinux 目前不支援 BTRFS 儲存驅動。

命令

Docker 的命令可以採用 docker-CMD 或者 docker CMD 的方式執行。兩者一致。

docker-attach(1)
    依附到一個正在執行的容器中。

docker-build(1)
    從一個 Dockerfile 建立一個映像檔

docker-commit(1)
    從一個容器的修改中建立一個新的映像檔

docker-cp(1)
    從容器中複製檔案到宿主系統中

docker-diff(1)
    檢查一個容器檔案系統的修改

docker-events(1)
    從服務端取得實時的事件

docker-export(1)
    匯出容器內容為一個 tar 包

docker-history(1)
    顯示一個映像檔的歷史

docker-images(1)
    列出存在的映像檔

docker-import(1)
    匯入一個檔案（典型為 tar 包）路徑或目錄來建立一個映像檔

docker-info(1)
    顯示一些相關的系統資訊

docker-inspect(1)
    顯示一個容器的底層具體資訊。

docker-kill(1)
    關閉一個執行中的容器 (包括程式和所有資源)

docker-load(1)
    從一個 tar 包中載入一個映像檔

docker-login(1)
    註冊或登錄到一個 Docker 的倉庫伺服器

docker-logout(1)
    從 Docker 的倉庫伺服器登出

docker-logs(1)
    取得容器的 log 資訊

docker-pause(1)
    暫停一個容器中的所有程式

docker-port(1)
    查找一個 nat 到一個私有網口的公共口

docker-ps(1)
    列出容器

docker-pull(1)
    從一個Docker的倉庫伺服器下拉一個映像檔或倉庫

docker-push(1)
    將一個映像檔或者倉庫推送到一個 Docker 的註冊伺服器

docker-restart(1)
    重新啟動一個執行中的容器

docker-rm(1)
    刪除指定的數個容器

docker-rmi(1)
    刪除指定的數個映像檔

docker-run(1)
    建立一個新容器，並在其中執行指定命令

docker-save(1)
    保存一個映像檔為 tar 包檔案

docker-search(1)
    在 Docker index 中搜索一個映像檔

docker-start(1)
    啟動一個容器

docker-stop(1)
    終止一個執行中的容器

docker-tag(1)
    為一個映像檔打標籤

docker-top(1)
    查看一個容器中的正在執行的程式資訊

docker-unpause(1)
    將一個容器內所有的程式從暫停狀態中恢復

docker-version(1)
    輸出 Docker 的版本資訊

docker-wait(1)
    阻塞直到一個容器終止，然後輸出它的退出符

一張圖總結 Docker 的命令

Docker 簡介

Docker by LXC(Linux Containers)

Docker 理解為一種 Applice or Server 套件的 Sandbox , 每一個 Container 都安裝執行一種應用 , Contain 間可以建立溝通 , 其Containers 啟動和停止都很快對本機資源要求不高遠低於 VM ,實際應用實直接把Container 當成應用軟體執行也可以!

這樣帶來以下優勢

>>快速部屬和派送:

>>更高效率資源應用

>>用容易搬遷和擴展

>>用易更新

在 LXC 的基礎上 Docker 進行了進一步的封裝，讓使用者不需要去關心容器的管理，使得操作更為簡便。使用者操作 Docker 的容器就像操作一個快速輕量級的虛擬機一樣簡單。

下面的圖片比較了 Docker 和傳統虛擬化方式的不同之處，可見容器是在作業系統層面上實作虛擬化，直接使用本地主機的作業系統，而傳統方式則是在硬體層面實作。

2016年7月24日星期日

python sudoku plan # [sudoku_tablex1.py]

=======================================================
[sudoku_tablex1.py] --題庫(demo_1)Easy ,(demo_2)Normal,(demo_3)Hard

#============================
demo_1=[
[[7,0,1,0,2,0,0,0,0],#e001
[0,0,0,0,5,3,9,0,1],
[9,3,5,1,7,6,0,2,4],
[1,6,0,9,8,0,3,0,0],
[3,2,9,0,4,0,5,6,8],
[0,0,4,0,3,2,0,9,7],
[4,9,0,3,1,7,2,8,5],
[5,0,8,2,9,0,0,0,0],
[0,0,0,0,6,0,4,0,9] ],

[[0,0,5,0,9,0,7,0,4],#e002
[0,7,4,3,0,1,6,0,0],
[0,8,0,7,0,4,5,0,2],
[7,4,0,9,3,0,2,0,1],
[9,5,2,0,0,0,4,6,3],
[3,0,1,0,4,2,0,7,8],
[4,0,3,8,0,5,0,2,0],
[0,0,7,6,0,9,3,4,0],
[5,0,6,0,1,0,8,0,0] ],

[[6,0,0,2,9,0,0,0,1],#e003
[3,0,0,0,0,6,9,0,0],
[9,1,0,0,3,0,4,0,0],
[0,7,0,9,0,0,6,0,0],
[0,2,0,7,0,3,0,4,0],
[0,0,9,0,0,2,0,5,0],
[0,0,8,0,5,0,0,9,4],
[0,0,5,6,0,0,0,0,8],
[1,0,0,0,8,7,0,0,5] ],

[[0,4,0,0,0,0,7,0,1],#e004
[0,0,8,0,0,2,3,0,0],
[0,6,1,9,4,0,0,0,0],
[0,0,0,5,0,0,2,3,0],
[8,0,0,0,9,0,0,0,4],
[0,2,5,0,0,1,0,0,0],
[0,0,0,0,5,7,9,6,0],
[0,0,4,3,0,0,1,0,0],
[6,0,9,0,0,0,0,5,0] ],

[[1,0,5,0,0,0,0,0,0],#e005
[0,0,0,2,0,0,0,6,8],
[0,0,8,0,3,0,0,4,0],
[2,5,0,0,8,1,0,0,0],
[4,0,6,0,0,0,8,0,2],
[0,0,0,6,4,0,0,5,3],
[0,7,0,0,5,0,1,0,0],
[6,1,0,0,0,7,0,0,0],
[0,0,0,0,0,0,2,0,9] ],

[[0,3,0,0,0,0,1,0,0],#e006
[0,0,0,4,2,0,0,3,0],
[8,0,9,0,0,7,0,0,0],
[6,8,0,0,0,0,3,4,0],
[9,0,0,6,8,5,0,0,2],
[0,1,7,0,0,0,0,8,5],
[0,9,0,2,0,0,5,0,4],
[0,0,0,0,3,4,0,0,0],
[0,0,8,0,0,0,0,6,0] ],

[[0,4,0,0,2,0,9,0,7],#e007
[0,3,0,0,5,0,0,0,0],
[9,0,0,3,0,0,1,0,0],
[8,7,0,4,0,0,0,0,0],
[0,0,4,7,0,8,6,0,0],
[0,0,0,0,0,5,0,8,4],
[0,0,1,0,0,6,0,0,9],
[0,0,0,0,3,0,0,6,0],
[7,0,6,0,4,0,0,1,0] ],

[[0,2,0,0,6,0,4,0,1],#e008
[5,0,8,0,0,3,0,0,0],
[0,3,0,2,0,0,0,0,9],
[0,0,0,0,4,0,8,9,0],
[8,0,0,7,5,2,0,0,4],
[0,6,4,0,3,0,0,0,0],
[1,0,0,0,0,7,0,5,0],
[0,0,0,9,0,0,7,0,3],
[4,0,5,0,8,0,0,1,0] ],

[[2,0,0,6,0,7,0,0,8],#e009
[4,9,0,0,0,0,3,7,0],
[8,0,0,0,4,0,5,0,0],
[9,1,0,2,0,0,0,0,0],
[0,0,3,4,0,1,6,0,0],
[0,0,0,0,0,3,0,8,4],
[0,0,9,0,6,0,0,0,5],
[0,6,5,0,0,0,0,4,7],
[7,0,0,3,0,2,0,0,6] ],

[[0,0,0,0,0,0,0,0,0],#e010
[0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0] ]

]
#============================
demo_2=[
[[0,8,0,0,0,0,0,3,4],#n001
[0,0,1,0,9,3,0,0,0],
[0,3,0,0,0,0,1,5,0],
[4,0,0,2,0,0,5,0,0],
[1,0,0,7,0,4,0,0,2],
[0,0,8,0,0,5,0,0,6],
[0,1,4,0,0,0,0,9,0],
[0,0,0,3,4,0,6,0,0],
[5,2,0,0,0,0,0,4,0] ],

[[3,8,0,1,0,0,0,0,0],#n002
[0,0,1,0,0,0,6,0,4],
[0,4,0,9,3,0,0,0,0],
[7,0,0,0,0,0,0,6,1],
[0,2,0,5,0,4,0,9,0],
[8,5,0,0,0,0,0,0,7],
[0,0,0,0,6,3,0,2,0],
[5,0,7,0,0,0,3,0,0],
[0,0,0,0,0,9,0,1,6] ],

[[0,0,0,7,0,0,2,8,0],#n003
[0,2,0,0,0,6,5,0,0],
[5,7,0,0,0,0,0,0,4],
[3,0,0,0,8,4,0,1,0],
[7,0,0,0,0,0,0,0,3],
[0,4,0,3,2,0,0,0,8],
[8,0,0,0,0,0,0,4,1],
[0,0,9,8,0,0,0,7,0],
[0,3,4,0,0,9,0,0,0] ],

[[0,4,6,0,0,7,0,0,2],#n004
[0,0,0,0,0,9,5,0,4],
[8,7,0,0,3,0,0,0,0],
[0,5,2,7,0,0,0,0,0],
[0,0,8,0,6,0,9,0,0],
[0,0,0,0,0,8,2,6,0],
[0,0,0,0,2,0,0,5,1],
[3,0,4,1,0,0,0,0,0],
[5,0,0,9,0,0,6,4,0] ],

[[0,1,3,0,0,5,0,0,0],#n005
[0,0,2,0,0,3,0,9,0],
[9,0,0,0,0,0,4,0,8],
[0,3,0,1,0,6,0,0,2],
[5,0,0,0,3,0,0,0,9],
[7,0,0,2,0,9,0,6,0],
[1,0,4,0,0,0,0,0,5],
[0,9,0,5,0,0,6,0,0],
[0,0,0,8,0,0,1,2,0] ],

[[0,6,8,0,3,0,0,0,0],#n006
[0,0,0,0,0,0,9,0,1],
[0,0,0,7,0,6,3,0,2],
[0,0,0,0,4,7,0,1,0],
[5,4,0,0,0,0,0,9,6],
[0,3,0,2,6,0,0,0,0],
[8,0,6,5,0,4,0,0,0],
[9,0,3,0,0,0,0,0,0],
[0,0,0,0,9,0,1,5,0] ],

[[9,2,0,3,0,8,0,0,0],#n007
[0,0,0,0,6,0,0,0,8],
[0,8,3,7,0,0,0,0,0],
[6,0,1,0,0,0,5,0,0],
[0,4,0,5,0,3,0,9,0],
[0,0,7,0,0,0,8,0,3],
[0,0,0,0,0,6,2,5,0],
[4,0,0,0,8,0,0,0,0],
[0,0,0,4,0,1,0,8,6] ],

[[0,0,1,0,0,0,3,4,0],#n008
[0,4,0,0,8,0,0,0,9],
[5,0,0,3,0,7,0,0,0],
[4,0,6,2,0,0,0,0,0],
[0,9,0,5,0,6,0,7,0],
[0,0,0,0,0,1,6,0,5],
[0,0,0,7,0,5,0,0,8],
[2,0,0,0,1,0,0,9,0],
[0,8,3,0,0,0,7,0,0] ],

[[2,0,1,8,0,0,0,6,0],#n009
[0,0,0,9,0,0,0,2,4],
[4,0,0,0,1,0,0,0,0],
[0,0,2,1,5,0,9,0,0],
[0,8,0,0,3,0,0,1,0],
[0,0,9,0,6,7,5,0,0],
[0,0,0,0,9,0,0,0,7],
[9,3,0,0,0,6,0,0,0],
[0,5,0,0,0,1,8,0,9] ],

[[5,0,0,9,0,0,0,3,0],#n010
[0,0,0,0,7,4,6,0,0],
[1,0,6,0,0,0,0,4,0],
[0,0,0,0,0,1,3,7,0],
[0,0,8,6,9,7,1,0,0],
[0,7,1,3,0,0,0,0,0],
[0,9,0,0,0,0,5,0,8],
[0,0,4,8,1,0,0,0,0],
[0,1,0,0,0,2,0,0,9] ]
]
#============================
demo_3=[
[[0,0,8,0,0,0,0,5,1],#h001
[0,6,0,0,0,5,7,0,0],
[0,0,1,0,8,0,0,0,0],
[0,2,0,0,0,0,0,0,6],
[5,0,0,7,0,1,0,0,4],
[3,0,0,0,0,0,0,2,0],
[0,0,0,0,5,0,9,0,0],
[0,0,3,8,0,0,0,1,0],
[4,9,0,0,0,0,8,0,0] ],

[[0,0,4,8,0,0,0,1,0],#h002
[0,0,7,0,9,0,0,0,4],
[0,6,0,0,3,0,2,0,0],
[8,0,0,0,0,1,0,0,0],
[0,0,0,3,0,2,0,0,0],
[0,0,0,7,0,0,0,0,1],
[0,0,2,0,4,0,0,5,0],
[4,0,0,0,2,0,6,0,0],
[0,9,0,0,0,7,4,0,0] ],

[[0,0,8,0,3,0,0,6,0],#h003
[5,0,0,1,0,0,0,0,0],
[0,0,0,0,0,9,1,7,0],
[0,0,0,0,0,5,9,4,0],
[2,0,0,0,0,0,0,0,8],
[0,3,5,4,0,0,0,0,0],
[0,2,6,7,0,0,0,0,0],
[0,0,0,0,0,8,0,0,4],
[0,5,0,0,4,0,7,0,0] ],

[[0,0,1,0,0,0,0,0,8],#h004
[8,0,0,5,0,1,0,0,0],
[0,5,0,0,3,0,1,0,0],
[0,1,0,0,0,6,0,4,0],
[0,0,6,0,0,0,7,0,0],
[0,9,0,3,0,0,0,2,0],
[0,0,5,0,7,0,0,3,0],
[0,0,0,2,0,8,0,0,5],
[4,0,0,0,0,0,8,0,0] ],

[[1,0,0,0,7,0,0,9,0],#h005
[0,5,3,0,0,0,0,0,4],
[2,0,0,0,0,3,0,0,0],
[0,2,0,0,0,5,8,0,0],
[0,0,0,6,0,8,0,0,0],
[0,0,5,1,0,0,0,2,0],
[0,0,0,2,0,0,0,0,5],
[4,0,0,0,0,0,3,6,0],
[0,8,0,0,9,0,0,0,7] ],

[[0,0,5,0,0,9,0,2,0],#h006
[0,7,0,0,5,0,0,0,3],
[4,0,0,0,1,0,0,0,0],
[0,4,0,6,0,0,0,0,0],
[0,0,6,9,0,7,2,0,0],
[0,0,0,0,0,3,0,7,0],
[0,0,0,0,6,0,0,0,8],
[6,0,0,0,3,0,0,1,0],
[0,5,0,8,0,0,6,0,0] ],

[[0,0,0,0,0,3,9,0,8],#h007
[0,0,1,0,0,9,0,0,2],
[2,3,0,0,4,0,0,0,0],
[0,7,0,0,0,6,0,0,0],
[0,0,4,0,0,0,5,0,0],
[0,0,0,4,0,0,0,3,0],
[0,0,0,0,7,0,0,8,9],
[4,0,0,3,0,0,7,0,0],
[7,0,6,5,0,0,0,0,0] ],

[[2,0,0,9,6,0,0,1,0],#h008
[0,3,1,0,0,0,0,0,0],
[0,0,0,0,3,0,0,0,5],
[0,5,0,0,0,0,6,0,0],
[0,0,9,3,0,7,2,0,0],
[0,0,3,0,0,0,0,4,0],
[3,0,0,0,9,0,0,0,0],
[0,0,0,0,0,0,8,2,0],
[0,8,0,0,4,1,0,0,7] ],

[[8,0,0,0,0,7,0,0,9],#h009
[4,0,6,0,2,0,0,0,0],
[0,5,0,3,0,0,2,0,0],
[0,0,7,2,0,0,0,0,0],
[0,6,0,0,0,0,0,9,0],
[0,0,0,0,0,1,3,0,0],
[0,0,8,0,0,6,0,4,0],
[0,0,0,0,5,0,1,0,8],
[6,0,0,8,0,0,0,0,5] ],

[[0,0,0,0,6,0,0,3,0],#h010
[0,4,5,0,0,9,0,0,8],
[0,0,0,0,0,1,0,0,6],
[0,0,2,5,0,0,0,8,0],
[0,0,9,0,0,0,6,0,0],
[0,6,0,0,0,7,1,0,0],
[4,0,0,1,0,0,0,0,0],
[9,0,0,6,0,0,3,4,0],
[0,1,0,0,7,0,0,0,0] ]
]

=======================================================

python sudoku plan [sudoku_publib.py]

=======================================================
[sudoku_publib.py] --class Num and Class sudoku_data array
# coding=utf-8
#=== pyt268104 home work ===
# 20160627
#import math
#import numpy as np
#v1.1
class Num:
arealoop=[[1,3,1,3],[1,3,4,6],[1,3,7,9],
[4,6,1,3],[4,6,4,6],[4,6,7,9],
[7,9,1,3],[7,9,4,6],[7,9,7,9]
]
areacode=0
chkno=[]
no=0
pos=00
status = 0 #0:user edit ,1:is mask can no edit
chkfg=0

def __init__(self, pos, no, status):
self.pos=pos
self.no=no
self.status = status
self.chkfg=0
self.chkno=[1,2,3,4,5,6,7,8,9]

def setpos(self,pos):
px=eval(str(pos)[1])
py=eval(str(pos)[0])
if 1<= px <=9:
if 1<= py <=9:
#self.pos = pos
if 1<=py<=3:
if 1<=px<=3:
self.areacode=1
elif 4<=px<=6:
self.areacode=2
elif 7<=px<=9:
self.areacode=3

elif 4<=py<=6:
if 1<=px<=3:
self.areacode=4
elif 4<=px<=6:
self.areacode=5
elif 7<=px<=9:
self.areacode=6

elif 7<=py<=9:
if 1<=px<=3:
self.areacode=7
elif 4<=px<=6:
self.areacode=8
elif 7<=px<=9:
self.areacode=9

def maskno(self,no):
if self.status==1:#mask no
self.no=no

def setno(self,no):
if self.status==0:#user edit no
self.no = no

def scanchk(self,xx):
self.chkfg=0
fg1=0
fg2=0
fg3=0
fg1=self.area_scanchk(xx)
fg2=self.col_scanchk(xx)
fg3=self.row_scanchk(xx)
self.chkfg|=fg1 or fg2 or fg3
pass

def area_scanchk(self,xx):
fg=0
#py=int(self.pos/10)
#px=self.pos%10
self.setpos(self.pos)
xacode=self.areacode
y1,y2,x1,x2 = self.arealoop[self.areacode-1]
y,x = (y1-1),(x1-1)
for y in range(y1-1,y2):
for x in range(x1-1,x2):
tt=(y+1)*10+x+1
if tt!=self.pos:
nn = xx[y][x].no
if nn in self.chkno:
self.chkno.remove(nn)

if nn!=0:
if nn==self.no:
fg=1# fthe game check fail
return fg
pass

def col_scanchk(self,xx):#col y 列
fg=0
#px=eval(str(pos)[1])#row
py=eval(str(self.pos)[0])#col
y=py-1
for x in range(1-1,9):
tt=(y+1)*10+x+1
if tt!=self.pos:
nn = xx[y][x].no
if nn in self.chkno:
self.chkno.remove(nn)
if nn!=0:
if nn==self.no:
fg=1# fthe game check fail

return fg
pass

def row_scanchk(self,xx):#row x 行
fg=0
px=eval(str(self.pos)[1])#row
#py=eval(str(pos)[0])#col
x=px-1
#print("x=",x)
for y in range(1-1,9):
#print("y=",y)
tt=(y+1)*10+x+1
if tt!=self.pos:
nn = xx[y][x].no
if nn in self.chkno:
self.chkno.remove(nn)
if nn!=0:
if nn==self.no:
fg=1# fthe game check fail
return fg
pass

class sudoku_dataarray:
gname=""
sudokudat = []
chkfg=0
runfg=0
def __init__(self,name):
self.gname = name
self.sudokudat = [[0 for i in range(9)] for j in range(9)]
for i in range(9):
for j in range(9):
pos = (i+1)*10+(j+1)
self.sudokudat[i][j] = Num(pos,0,0)
self.chkfg=0
self.runfg=0
pass

def showsudoku(self):
#self.chkfg=0
#print()
print("="*15,"sudoku data","="*15)
for i in range(9):
for j in range(9):

if self.sudokudat[i][j].status==1:
print("($%1s)"%(self.sudokudat[i][j].no),end="")#mask
else:
print("[%2s]"%(self.sudokudat[i][j].no),end="")#free edit
#self.sudokudat[i][j].scanchk(self.sudokudat)
#self.chkfg+=self.sudokudat[i][j].chkfg

if j in (2,5):
print("||",end="")
print()
if i in (2,5):
print(("="*12)+"||"+("="*12)+"||"+("="*12))

print("="*42)
pass

def checksudoku(self):
self.chkfg=0
self.runfg=0
for i in range(9):
for j in range(9):
if self.sudokudat[i][j].status==0:
self.sudokudat[i][j].scanchk(self.sudokudat)
self.chkfg|=self.sudokudat[i][j].chkfg
if self.sudokudat[i][j].no==0:
self.runfg+=1

#return self.chkfg

def setsudoku_col(self,nn,ll):
tt=0
for j in range(9):
self.sudokudat[nn-1][j].no=ll[tt]
if ll[tt]!=0:
self.sudokudat[nn-1][j].status=1 # mask data
else:
self.sudokudat[nn-1][j].status=0 # user data
tt+=1
pass

def setsudoku_plan(self,tab):
tt=0
for i in range(9):
for j in range(9):
self.sudokudat[i][j].no = tab[i][j]
nn = tab[i][j]
if self.sudokudat[i][j].no!=0:
self.sudokudat[i][j].status=1 # mask data
else:
self.sudokudat[i][j].status=0 # user data
stt=self.sudokudat[i][j].status
self.sudokudat[i][j].chkno=[1,2,3,4,5,6,7,8,9]
pp = (i+1)*10+(j+1)
self.sudokudat[i][j].setpos(pp)

#xx = [[0 for i in range(9)] for j in range(9)]
#split the pos by col and row
#k1=eval(str(s)[0])
#k2=eval(str(s)[1])

=======================================================

python sudoku plan # [ pyt268104_sudoku.py] --main code

由三個檔案組成
=======================================================[ pyt268104_sudoku.py] --主程式
# coding=utf-8
#=== pyt268104 home work ===
# 20160627
#import math
#import numpy as np

#def fun(a1,a2):
# c = np.dot(a1,a2)
# return c
from class_hw import sudoku_tablex1
from class_hw import sudoku_publib

level = 1
gcode = 1
pysudokuver = '''
This is Sudoku Game
Desiger: Handel Liao pyt268104
Codeing by Python3.5
Ver : 1.2 20160725
'''
lev=["Easy","Normal","Hard"]
mtxt = '''
=== Easy Sudoku Game V1.2 pyt268104 Handel ===
*** System Command ***
[1]Level Select (L1:Easy,L2:Normal,L3:Hard)
[2]Game code by LEVEL(1..10)
[3]Show Game Buffer and Status
[4]select play Game
[?]List Menu
[H]Help info show
[Q]quit
*** Game Command ***
[N]Add a New Game
[D]Delete a Game
[L]Load Game Data[from level,gcode]
[P]Print Game data array
[K]key in a data to Game
[C]check the Game by Pass
'''

def getsudoku():
xx = [[0 for i in range(9)] for j in range(9)]
return xx

def showsudoku(xx):
print()
print("="*15,"sudoku data","="*15)
for i in range(9):
for j in range(9):
print("[%2s]"%(xx[i][j]),end="")
if j in (2,5):
print("||",end="")
print()
if i in (2,5):
print(("="*12)+"||"+("="*12)+"||"+("="*12))

def setsudoku_area(xx,nn,ll):
tt=0
for j in range(9):
xx[nn-1][j]=ll[tt]
tt+=1

def setsudoku_plan(xx,tab):
tt=0
for i in range(9):
xx[i]=tab[i]

def scanok(yy):#c1: area ,col,raw must be 1 scan
for i in range(9):
for j in range(9):
if yy.sudokudat[i][j].status == 0:
yy.sudokudat[i][j].scanchk(yy.sudokudat)

runok=0
runfail=0
for i in range(9):
for j in range(9):
ll=len(yy.sudokudat[i][j].chkno)
print("%d%d = %s # %d"%(i+1,j+1,yy.sudokudat[i][j].chkno,ll))
if yy.sudokudat[i][j].no==0:
if ll==1:
yy.sudokudat[i][j].no = yy.sudokudat[i][j].chkno[0]
else:
runok+=1

if ll==0:
runfail+=1

return runok,runfail

def scanok2(yy):#c2: area mabe only 1 scan
pass

def main():
game=[]
level = 1
gcode = 1
ss="demo"+",("+lev[level-1]+"_"+str(gcode)+")"
game.append(sudoku_publib.sudoku_dataarray(ss))
game[0].setsudoku_plan(sudoku_tablex1.demo_1[gcode])

level = 2
gcode = 1
ss="demo1"+",("+lev[level-1]+"_"+str(gcode)+")"
game.append(sudoku_publib.sudoku_dataarray(ss))
game[1].setsudoku_plan(sudoku_tablex1.demo_2[gcode])

level = 3
gcode = 1
ss="demo2"+",("+lev[level-1]+"_"+str(gcode)+")"
game.append(sudoku_publib.sudoku_dataarray(ss))
game[2].setsudoku_plan(sudoku_tablex1.demo_3[gcode])

level = 1
gcode = 1
playindex = 0
cmm ='?'
while 1:
if cmm =='?':
print(mtxt)
elif cmm =='h':
print(pysudokuver)
elif cmm == 'q':
print()
print("************************")
print("** Thank You By By **")
print("************************")
print()
break
elif cmm == 'n':#add a new Game
ss = input("input the gmae name:")
ss+=",("+lev[level-1]+"_"+str(gcode)+")"
game.append(sudoku_publib.sudoku_dataarray(ss))
tt=0
for i in game:
print("[%d]: %s "%(tt,i.gname))
tt+=1
print("Add ok !")
print()

elif cmm == 'd': #delete
print("==================")
tt=0
for i in game:
print("[%d]: %s "%(tt,i.gname))
tt+=1
nn = eval(input("input index by Delete:"))
if nn>len(game)-1:
print("Sorry ! index out of range ")
print()
else:
del game[nn]
tt=0
for i in game:
print("[%d]: %s "%(tt,i.gname))
tt+=1
if playindex>=len(game):
playindex=len(game)-1
print("delete ok !")
print()
elif cmm == 'l':#load data to array
if level==1:
game[playindex].setsudoku_plan(sudoku_tablex1.demo_1[gcode])
elif level==2:
game[playindex].setsudoku_plan(sudoku_tablex1.demo_2[gcode])
elif level==3:
game[playindex].setsudoku_plan(sudoku_tablex1.demo_3[gcode])

ss1 = game[playindex].gname
ss = ss1.split(",")[0]
ss += ",("+lev[level-1]+"_"+str(gcode)+")"
game[playindex].gname = ss
print("===%d is [ %s ] ==="%(playindex,game[playindex].gname))
game[playindex].showsudoku()

elif cmm == "p":#show data array
print()
print("===%d is [ %s ] ==="%(playindex,game[playindex].gname))
game[playindex].showsudoku()

elif cmm == "k":#keyin data to array
cl=2
while 1:
xin= input("input game pos(11..99),Num:")
ll=xin.split(",")
if len(ll)==2:
pos=eval(xin.split(",")[0])
nn =eval(xin.split(",")[1])
i = int(pos/10)
j = pos%10
game[playindex].sudokudat[i-1][j-1].setno(nn)
game[playindex].showsudoku()
else:
print("Err input stop keyin ...")
break

elif cmm =='1':
level = eval(input("(1:Easy,2:Normal,3:Hard)Input Level:"))
if 0 print("Level:%d , Gcode:%d "%(level,gcode))
else:
print("Error input level Out of range")

elif cmm =='2':
gcode = eval(input("input gcode:"))
if 0 print("Level:%d , Gcode:%d "%(level,gcode))
else:
print("Error input gcode Out of range")

elif cmm =='4':
tt=0
for i in game:
print("[%d]: %s "%(tt,i.gname))
tt+=1
xcm = input("input playindex:")
if xcm.isdigit():
nn = eval(xcm)
else:
print("Error input must is Number ... ")
nn = playindex

if nn < len(game):
playindex = nn
print("You select game [ %s ]"%(game[playindex].gname))
else:
print("Error input index Out of range")

elif cmm =='3':
print()
print("====Game buffer show list ==========")
print("Level:%d , Gcode:%d "%(level,gcode))
tt=0
for i in game:
print("[%d]: %s "%(tt,i.gname))
tt+=1

print("Game index = %d is run [ %s ]"%(playindex,game[playindex].gname))
print()

elif cmm == "c":#check game pass or fail
print()
print("===check the %d is [ %s ] ==="%(playindex,game[playindex].gname))
game[playindex].showsudoku()
game[playindex].checksudoku()

if game[playindex].runfg>0:
print("Some Number must to edit ...")
else:
if game[playindex].chkfg==0:
print("************************")
print("** This Game Pass ... **")
print("************************")
else:
print("This Game Fail !")
print("Try Again ...")

elif cmm == 'c1':
runck,runfail = scanok(game[playindex])
print("have %d will be edit %d is err ... "%(runck,runfail))

elif cmm == 'c2':
pass

cmm = input("Play (game[%d]-> %s) help(?)Input cmm="%(playindex,game[playindex].gname))

if __name__ == '__main__':
main()

=======================================================

訂閱：文章 (Atom)

廖德 Handel Working Spece

welcom ! Handel home

2018年1月31日星期三

英特爾多接取邊緣運算(Multi-access Edge Computing，MEC) 解決方案

英特爾多接取邊緣運算(Multi-access Edge Computing，MEC) 解決方案

什麼是邊緣計算（Edge computing）？邊緣計算的解釋和三種類型

．什麼是邊緣計算（Edge computing）？邊緣計算的解釋和三種類型

2017年2月26日星期日

[STM32F103 GPIO 定義說明]

2017年1月17日星期二

Linux CentOS7 64bit install docker Note

2017年1月8日星期日

Docker命令查詢

Docker命令查詢

基本語法

選項

命令

一張圖總結 Docker 的命令

Docker 簡介

2016年7月24日星期日

python sudoku plan # [sudoku_tablex1.py]

python sudoku plan [sudoku_publib.py]

python sudoku plan # [ pyt268104_sudoku.py] --main code

welcom ! Handel home

2018年1月31日 星期三

英特爾多接取邊緣運算(Multi-access Edge Computing，MEC) 解決方案

．什麼是邊緣計算（Edge computing）？ 邊緣計算的解釋和三種類型

2017年2月26日 星期日

2017年1月17日 星期二

2017年1月8日 星期日

Docker命令查詢

基本語法

選項

命令

一張圖總結 Docker 的命令

2016年7月24日 星期日

2018年1月31日星期三

．什麼是邊緣計算（Edge computing）？邊緣計算的解釋和三種類型

2017年2月26日星期日

2017年1月17日星期二

2017年1月8日星期日

2016年7月24日星期日