블로그 이미지
개발자로서 현장에서 일하면서 새로 접하는 기술들이나 알게된 정보 등을 정리하기 위한 블로그입니다. 운 좋게 미국에서 큰 회사들의 프로젝트에서 컬설턴트로 일하고 있어서 새로운 기술들을 접할 기회가 많이 있습니다. 미국의 IT 프로젝트에서 사용되는 툴들에 대해 많은 분들과 정보를 공유하고 싶습니다.
솔웅

최근에 받은 트랙백

글 보관함

calendar

    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 31    


Here I am going to develop an Alexa skill for my own, customized based on 3 articles below.  


1. Fact Skill Tutorial

2. Fact Skill Blog

3. Section 2 of Alexa - A Free Introduction in Cloud Guru


Alexa will answer about the place(s) where I lived.


You can get the source codes of Alexa - A Free Introduction here.

https://github.com/ACloudGuru/alexacourse


I am going to modify index.js file of 1_spaceGeek.


* Modify var FACTS


* Modify AMAZON.HelpIntent


* Modify handleNewFactRequest() function


* zip the AlexaSkill.js and index.js as placeLived.zip



We are now starting to develop 'Amazon Skill' in earnest.

Amazon Skill development can be divided into two parts: skill service and skill interface.







* Skill Service



first access to aws.amazon.com to develop Skill Service.




1. Create a Role


IAM -> Roles -> Create New Role 



Select AWS Lambda.

Select AWSLambdaBasicExecutionRole and Click on Next Step button.




Enter any name for the Role and Click on Create Role button.




Now you have created a new role.




Now I am going to create a Lambda function.


Click on the cube image on top left to go to landing page of AWS services. and Click on Lambda -> Create function button.



Click on Author from scratch button.




Select Alexa Skills Kit for the Lambda



Click on Next button.



Enter Name and Description. And then select Upload a .ZIP file from Code entry type dropdown menu.




Upload the placeLived.zip file.

Next step is Select Choose an existing role from Role dropdown menu.

And select the created Role (placeLivedRole) from Existing role dropdown menu.



And then Click on Next button -> Create function button.



I've created a Lambda function for my skill.


Now it's done for Skill Service development.

I am going to develop the Skill Interface part.

The ARN information will be using when develop the Skill Interface.





* Skill Interface


To develop Skill Interface, Go to developer.amazon.com.


Go to ALEXA tab and Select Get Started button in Alexa Skills Kit.




Click on Add a New Skill button.





Enter Name and Invocation and Click on Next button.




Copy and paste this code to Intent Schema.

(This code is in IntentSchema.json of the source files.)


{

  "intents": [

    {

      "intent": "GetNewFactIntent"

    },

    {

      "intent": "AMAZON.HelpIntent"

    },

    {

      "intent": "AMAZON.StopIntent"

    },

    {

      "intent": "AMAZON.CancelIntent"

    }

  ]

 }


Enter Sample Utterances




Click on Save button. - It will build this skill.

Click on Next button once it is built.


Now I need to copy ARN from aws.amazon.com and paste it in to Global Fields in developer.amazon.com.

So I can make a connection between Skill Service and Skill Interface of mine.


Select AWS Lamda ARN -> North America and paste it into North America text field.



Click on Save and Next button.


Now it is completed.


To test, enter any utterance and click on Ask Places Lived button.













저작자 표시 비영리 동일 조건 변경 허락
신고

[Memo] PaaS, SFDC, DM/IoT/IIoT etc.

2017.08.10 09:39 | Posted by 솔웅


PaaS 


Platform as a service

From Wikipedia, the free encyclopedia


Platform as a service (PaaS) or application platform as a service (aPaaS) is a category of cloud computing services that provides a platform allowing customers to develop, run, and manage applications without the complexity of building and maintaining the infrastructure typically associated with developing and launching an app.[1][2][3] PaaS can be delivered in two ways: as a public cloud service from a provider, where the consumer controls software deployment with minimal configuration options, and the provider provides the networks, serversstorageoperating system (OS), 'middleware' (e.g. Java runtime, .NET runtime, integration, etc.), database and other services to host the consumer's application; or as a private service (software or appliance) inside the firewall, or as software deployed on a public infrastructure as a service.[4][5]







플랫폼 애즈 어 서비스

[Platform as a Service ]




인터넷으로 컴퓨터 응용 프로그램(애플리케이션) 설계 · 개발 · 배포 등에 필요한 하드웨어(HW)와 소프트웨어(SW)를 제공하는 체계를 일컫는다. ‘클라우드웨어(Cloudware)’로 부르기도 한다. 여럿이 한곳에 머무르지 않더라도 인터넷을 매개로 삼아 애플리케이션을 함께 개발할 수 있는 게 특징이다. 더 많은 프로그램을 쉽게 개발할 수 있게 ‘애플리케이션 프로그램 인터페이스(API : Application Program Interface)’를 개방 · 제공하는 것도 ‘파스’의 한 형태다. 실제로 구글과 SK플래닛 같은 인터넷콘텐츠제공사업자의 API 개방이 잇따랐다. 이처럼 특정 사업자의 파스를 쓰면 해당 업체의 서비스 체계와 개발 언어에 종속될 수도 있고, 개발한 애플리케이션을 다른 사업자의 서비스를 통해 제공하기도 어렵다.

[네이버 지식백과] 플랫폼 애즈 어 서비스 [Platform as a Service] (ICT 시사용어 300, 2013.02.05, 한국정보통신기술협회)










SFDC 

salesforce.com

From Wikipedia, the free encyclopedia


salesforce.com, inc. (styled in its logo as salesƒorce; abbreviated usually as SF or SFDC) is an American cloud computing company headquartered in San FranciscoCalifornia. Though its revenue comes from a customer relationship management (CRM) product, Salesforce also capitalizes on commercial applications of social networking through acquisition. As of early 2016, it is one of the most highly valued American cloud computing companies with a market capitalization above $61 billion.[3]

Its common stock is listed on the New York Stock Exchange with the symbol CRM and is a constituent of the S&P 500 Index.








두산백과

세일스포스

[Salesforce ]


1999년 미국의 소프트웨어 및 하드웨어 제공 업체인 오라클의 임원 출신인 마크 베니오프(Marc Benioff)가 소프트웨어 개발 전문가들과 함께 서비스 특성화 소프트웨어 전문 업체로 설립했다. 설립 직후 고객관계관리에 사용하는 온라인 영업 관리 자동화 솔루션을 런칭하고, 일본의 선브릿지(SunBridge)와 가부시키 카이샤 세일스포스(Kabushiki KaishaSalesforce.com)를 선보였다. 2001년, 영업, 마케팅, 고객관리를 통합한 온라인 어플리케이션을 판매하기 시작했고, 이듬해에는 이를 기업 전용, 오프라인 전용 및 온라인 기업 전용으로 나누어서 출시했다. 



2003년에 미국의 분석 및 프로세싱 소프트웨어 회사인 TIBCO와 전략적 파트너십을 맺고 사용료를 내게 하는 통합 소프트웨어를 제공했다. 2005년에는 모바일 솔루션을 제공하기 위해 일본의 통신 제공 업체인 KDDI와 제휴를 맺었고, 무선 어플리케이션을 별도로 보유했던 센디아(Sendia)를 인수했다. 이후 2007년에는 미국의 컴퓨터 소프트웨어 업체인 어도비와 함께 통합 비즈니스 솔루션인 어도브 플렉스 툴킷 포 아펙스(Adobe Flex Toolkitfor Apex)를 선보이는 한편, 구글과 함께 영업 및 마케팅을 통합하는 어플리케이션을 런칭했다.



영업 관리부터 다양한 물건들을 인터넷으로 연결하여 서비스를 제공하는 사물인터넷 통합 서비스까지 차세대 엔터프라이즈 어플리케이션(next generation of enterprise application)을 제공하며, 한국, 중국 등 아시아에도 진출했으나 주로 미국과 유럽을 기반으로 판매를 하고 있다. 기업정보 제공 업체인 마켓라인(MarketLine)의 보고서에 따르면, 2015년을 기준으로 CRM 솔루션 업계에서 19%의 시장 점유율을 차지하여 업계 1위가 되었고, 10개의 소프트웨어 제공 업체 중 수익이 가장 높았다.



미국의 신용평가기관인 스탠더드 앤드 푸어(Standard & Poor)사가 발표하는 주가지수인 S&P 500에 등재되는 한편, 2016년 미국의 경제전문지 포춘(Fortune)이 선정하는 500대 기업에 선정되었다. 첨단 서비스를 제공하는 업체로 꾸준하게 R&D 투자를 하며, 2015년 사물인터넷 클라우드 서비스, 2016년 4월 페이스북과 함께 메신저 형태의 소프트웨어 등 새로운 형태의 서비스를 개시하고 있다.

[네이버 지식백과] 세일스포스 [Salesforce] (두산백과)








DM/IoT/IIoT



Gradle Vs. Maven







저작자 표시 비영리 동일 조건 변경 허락
신고

'IoT > The Nolja' 카테고리의 다른 글

[Memo] PaaS, SFDC, DM/IoT/IIoT etc.  (0) 2017.08.10


Create ARN (Amazon Resource Name)


aws.amazon.com -> Go to Lambda service -> Create a Lambda function -> Select the Region as N. Virginia






Coding a code in Code tab

Configure Programming Language, Role etc. in Configuration tab

Set Alexa Skills Kit in Triggers tab





The ARN on top right of the screen will be used to configure the Alexa Skill in developer.amazon.com





developer.amazon.com - ALEXA - Alexa Skills Kit




Add a New Skill Button




Complete all steps in left menu pannel


1. Skill Information

2. Interaction Model (Builder BETA)

3. Configuration

4. Test

5. Publishing Information

6. Privacy & Compliance





1. Skill Information 

  : Enter Name and Invocation Name

2. Interaction Model 

  : Set Customer Intents - Sample Utterances

  : Build the App (Save and Build)

3. Configuration

  : Service Endpoint Type - AWS Lambda ARN, Select a geographical region

  : Copy ARN from asw.amazon.com and paste it to the text field under North America in the Configuration page

4. Test

  : Alexa Start Session

  : Type command in Enter Utterance text field and Click on the Button

  : Click on Listen button




  


  

You can test it at https://echosim.io.

get more sample skills from github.com/alexa

저작자 표시 비영리 동일 조건 변경 허락
신고

[Echo Show] Build Skills for Echo Show

2017.08.08 06:03 | Posted by 솔웅


Build Skills for Echo Show



With Echo Show, graphical elements complement the voice interaction on the device itself. Thus, a custom skill used with Echo Show can include an interactive touch display in its response, in addition to standard voice interaction. For example, a recipe skill can display images of the ingredients and the preparation process at the appropriate points in the skill interaction. A city guide skill can display pictures or videos of requested attractions, or take the user on a guided tour.



Echo Show를 사용하면 음성 상호작용에 graphical한 요소까지 디바이스에서 표현할 수 있습니다. 그러므로 Echo Show의 커스텀 Skill을 사용하면 표준인 음성 상호작용에 더해 터치 디스플레이와의 상호작용을 할 수 있습니다. 예를 들어 recipe skill에 재료와 준비과정 등을 적정한 때에 이미지로 표시할 수 있습니다. 또한 city guide skill에서는 가 볼만 한 곳에 대한 사진이나 비디오를 표현해서 사용자에게 투어 가이드를 할 수 있습니다.





Echo Show

Although the display component may enhance the user experience considerably, voice continues to be the primary interaction method with Alexa.


display component가 더 풍부한 user experience를 제공하지만 Alexa에서는 음성이 계속 주요 상호작용 방법입니다.


Cards, which provide additional information for the user beyond the Alexa voice response, are supported in the Alexa app, but the app requires the user to separately view the card in the Alexa app on their phone or computer. Thus, cards, while useful, are not meant to be part of the main workflow of the skill. With Echo Show, the screen displays may be a significant aspect of the skill’s main workflow.


Alexa 음성 response를 넘어 사용자에게 추가적인 정보를 제공하는 Card들이 알렉스 앱에서 제공되고 있습니다. 이 카드들은 사용자들의 전화기나 컴퓨터에 있는 Alexa 앱에서 별도로 보여줄수 있기 때문에 그러한 앱이 필요하게 됩니다. 그렇기 때문에 이 card들은 유용함에도 불구하고 skill의 핵심 workflow 중 하나는 아닙니다. 하지만 Echo Show에서는 스크린 디스플레이가 이러한 카드들이 Skill에 주요 workflow에 속할 수 있도록 합니다.


Designing an Alexa skill for Echo Show allows integration of voice, touch, text, images, and video.


Echo Show에서 일렉사 Skill 디자인은 음성, 터치, 텍스트, 이미지 그리고 비디오를 사용할수 있도록 합니다.

좀 더 자세한 방법은 아래 글들을 참조하세요.



You can use the Node.js SDK and the Java SDK to facilitate the creation of Alexa skills.


Node.js SDK와 Java SDK를 사용하여 Alexa 기술을 쉽게 만들 수 있습니다.


Display and Interaction Features on Echo Show


Skill developers can take advantage of the following features for display and navigation.


Skill 개발자들은 디스플레이와 네비게이션과 관련해 다음의 기능들을 사용해 개발을 할 수 있습니다.


Graphical Features

Echo Show supports screen displays with the following graphical features.


Echo Show는 스크린 디스플레이에서 아래의 graphical한 기능들을 제공합니다.


  • List templates - display content as horizontal or vertical lists with predefined formats

  • Body templates - display content which can include text and images with predefined formats

  • Images - used in list templates or body templates

  • AudioPlayer - appears when the skill plays audio

  • Video - appears when the skill plays video

  • Touch selection events - List items and action links may be activated by touch if the skill is coded to support that


An Echo Show device provides all of the functionality of Amazon Echo devices, as well as an interactive screen and video playback capability. See the Echo Show specifications. The screen resolution for Echo Show is 1024x600 pixels.


Echo Show에서는 아마존 에코 기기들의 모든 기능들에다가 스크린을 통한 상호작용과 비디오 플레이 기능들까지 제공됩니다. 자세한 내용은  Echo Show specifications를 보세요. Echo Show의 화면 해상도는 1024x600 pixel입니다.


Alexa skills continue to support cards, whether the device with Alexa has a screen or not. If a skill is programmed so that a card appears in the Alexa app, and the skill has not been programmed to use a screen template, then that card will appear on the screen of the Echo Show device. If the skill has no card or template display, then the skill name and the skill icon appear on the screen, with the hint text “When you’re ready to quit, try “Alexa, exit’”.


Alexa Skill에서는 디바이스가 스크린을 가지고 있든 없든 카드기능이 제공 됩니다. 프로그램이 돼 있다면 Alexa 앱에 카드가 나타날 겁니다. Skill이 프로그램 돼 있다면 Alexa 앱에 나올 것이고 프로그램이 스크린 템플랫을 사용하도록 프로그램 돼 있지 않다면 Echo Show 디바이스의 스크린에 카드가 나타날 겁니다. 만약 Skill에 카드가 없거나 탬플렛 디스플레이가 없다면 스크린에 Skill 이름이나 Skill 아이콘이 “When you’re ready to quit, try “Alexa, exit’”라는 메세지와 함께 나타날 겁니다. 


Types of Interactions With Alexa Custom Skills


Custom skills designed for Alexa must take the following interactions into account.


Alexa에 디자인 돼 있는 커스텀 Skill은 account에 다음과 같은 상호작용을 가져야 합니다.


  • Voice interactions. Voice remains the primary means of interacting with Alexa, even if you have an Echo Show device. If your skill requires a screen to be used effectively, such as a photo-browsing skill, create a workflow that informs customers who are not using Echo Show that the skill requires Echo Show. An Echo Show user can control screen display by speaking the following actions.


    Voice interactions : 음성은 Echo Show를 가지고 있어도 Alexa에서는 가장 핵심적인 상호작용 수단입니다. 만약 photo-browsing skill같은 스크린이 필요한 Skill이라면 Echo Show를 이용하는 사용자들에게 알려주기 위한 workflow를 생성합니다. Echo Show 사용자는 다음과 같은 액션들을 음성을 이용해 스크린에 표시되도록 콘트롤 할 수 있습니다.


    • Scroll up/down/left/right

    • Page up/down

    • Next/previous



  • Alexa app interactions. A custom skill may cause a card with more information to be displayed in the Alexa app. If the custom skill is used with an Echo Show device, this card also appears on the screen if the response does not also include a display template. Thus, a skill that includes no display templates will show all of its cards on Echo Show. If a response includes both a card and a display template, the display template appears on Echo Show. This display template remains on the screen until the next response that includes a card or display template is sent.


    Alexa app interactions. 커스텀 Skill에서는 Alexa 앱에 좀 더 많은 정보를 표시하기 위한 카드를 사용할 수 있습니다. 만약 이 커스텀 Skill이 Echo Show에서 사용된다면 이 카드도 스크린에 나타날 겁니다. 만약 response에 디스플레이 탬플릿이 포함하지 않으면요.

    그러므로 디스플레이 탬플릿이 포함되지 않은 Skill은 자신이 가지고 있는 모든 카드를 Echo Show에서 표시할 겁니다. 만약 response가 카드와 디스플레이 탬플릿 모두를 가지고 있다면 Echo Show에는 그 디스플레이 탬플릿이 나타날 겁니다. 이 디스플레이 탬플릿은 카드나 디스플레이 탬플릿이 전달된 다음 response 까지 스크린에 남아 있을 겁니다.


  • Screen display interactions. If the custom skill uses display templates, and the correct interaction triggers a display template, then the corresponding text and images are displayed on Echo Show.


    Screen display interactions. 만약 커스텀 Skill이 디스플레이 탬플릿을 사용하고 제대로 이 디스플레이 탬플릿을 사용하도록 상호작용이 일어나면 해당 텍스트와 이미지들이 Echo Show에 표시됩니다.


  • Screen touch interactions. When a customer touches an item on screen that has been encoded with a select intent, that will trigger a specific action that has been programmed in the skill, such as displaying a recipe that corresponds to the selected item.


    Screen touch interactions. 사용자가 스크린의 아이템을 터치하면 그리고 그 Skill에 select intent으로 코딩이 되어 있다면 그 터치는 프로그램 되어 있는 특정 액션을 트리거링 합니다. 예를 들어 선택된 아이템에 해당하는 요리법을 보여준다던지 하는 서비스가 가능합니다. 


Audio, Display, and Video Capability for Devices With Alexa


Devices with Alexa support the AudioPlayer interface to play audio files. Long-form audio is not currently supported for Echo Show.


Alexa가 있는 디바이스들은 오디오 파일을 플레이 할 수 있는 AudioPlayer interface 를 제공합니다. Echo Show에서는 Long-form audio는 아직 지원되지 않습니다.


Echo Show also supports the Display interface to display content on the device screen, and the VideoApp interface to play video files on the screen.


Echo Show에서는 또한 디바이스 스크린에 내용을 표시하기 위한 Display interface와 VideoApp interface 를 지원해 화면에 비디오 파일을 상영하도록 해 줍니다. 



How and When to Use Display Templates to Render Screen Displays


When you develop a custom skill, you determine the form of the response that your skill will send to Alexa. This response may be voice-only, or it may also include a card or screen display. The display template you want to use, if any, is included in the JSON-formatted response, just as speech output and cards can be included in the response. If both a display template and a card are included in the response, the display template is rendered to the screen. If only a card is included, then the card is rendered to the screen. If neither a card or template is specified, then the default body template (BodyTemplate5) is rendered to the screen, which is typically the name of the skill and the skill icon. Display templates are not rendered in the Alexa companion app.


커스텀 Skill을 개발할 때 여러분의 Skill이 Alexa에 보낼 response의 form을 정해야 합니다. 이 response는 음성만 있을 수 있고 카드나 스크린 표시 등이 포함돼 있을 수 있습니다. 여러분이 사용하고자 하는 디스플레이 탬플릿은 JSON-formatted response에 포함되게 됩니다. 음성이 나오는것과 마찬가지로 response안에 카드들도 포함될 수 있습니다. 디스플레이 탬플릿과 카드 둘 다 response에 포함돼 있다면 화면에는 디스플레이 탬플릿이 표시됩니다. 만약 카드만 있다면 이 카드가 화면에 표시될 겁니다. 둘 다 없으면 default body template (BodyTemplate5)이 화면에 표시 될 겁니다. 주로 그 Skill에 이름과 그 Skill의 아이콘이죠. 디스플레이 탬플릿은 Alexa 앱에는 표시되지 않습니다.


In general, you, as the skill developer, want a visually uncluttered experience for the skill user, with display templates effectively displayed when they enhance the user experience. Typically, you should only return display templates when responding with information that the user has requested. Other responses, such as questions to ask the user for more information, do not typically include display templates.


일반적으로 Skill 개발자들은 사용자들에게 시각적인 것을 전달하기 원합니다. 디스플레이 탬플릿을 사용하면 이 기능을 효율적으로 사용자들에게 제공할 수 있습니다. 특히 사용자가 요청하면 디스플레이 팀플릿만을 리턴해야 될 때도 있고 사용자에게 추가적으로 질문을 할 때 같은 경우는 디스플레이 탬플릿이 포함될 필요가 없을 때도 있습니다.


See Best Practices for Card Design.


Create a Multi-Mode Interaction Model for Your Alexa Skill


The VUI (Voice User Interface), combined with the GUI (Graphical User Interface) and touch elements of Echo Show, provide a unique user experience. When you design your skill, consider how all of these elements will work together for the users of your skill.


The VUI (Voice User Interface)는 Echo Show의 GUI (Graphical User Interface)와 터치 요소를 결합해서 서비스를 제공합니다. Skill을 디자인 할 때 이러한 요소들이 어떻게 사용자를 위해서 서비스 되어야 하는 지를 고려해야 합니다.


The flow of the skill becomes significant when considering what the effect of such commands as “Up” mean. For example, in a recipe skill, would the user go back a previous step in a recipe, or to a previous recipe? Similarly, if the user says “Up” in a fact skill, what should the behavior be, if any? As the skill developer, you must specify this behavior in the service code for the skill. Plan how you want the user to interact with your skill.


Skill의 흐름은 “Up” 같은 요청이 어떤 효과를 내야 하는지를 고려할 때 유의미하게 서비스를 제공할 수 있습니다. 예를 들어 recipe skill에서 사용자가 요리법의 이 전 단계를 가려고 하는지 혹은 아예 이전의 요리법으로 가야 하는지 등이죠. 마찬가지로 fact skill에서 사용자가 “Up”이라고 말하면 여기에 대한 behavior는 어떻게 해야 할 까요? Skill 개발자로는 그 behavior를 서비스 코드에 정해서 넣어야만 합니다. 여러분에 Skill에서 어떻게 사용자와 상호작용을 해야 할지 잘 디자인 하세요.


Consider How Your Skill Works Across Devices


If you design your skill for a particular device, such as Echo Show, remember that the user may choose to enable this skill on other Alexa devices as well. So determine if you want your users to have access to these features in a way that does not use the screen and touch features, or if you want to inform the user that the skill, or certain features of it, is supported only on Echo Show. For example, the VideoApp interface, which allows videos in a skill, is supported on Echo Show, but it is not supported on devices without a screen such as Amazon Echo.


특정 디바이스에 대해 Skill을 디자인 한다면 -예를 들어 Echo Show 같은- 사용자느 다른 Alexa 디바이스들에서도 이 Skill을 사용하려고 할 것이라는 것을 염두에 두세요. 그러니까 스크린을 갖지 않는 다른 디바이스들에서도 이 기능들에 사용자에게 접근할 수 있도록 할 것인지에 대해서 미리 정해야 합니다. 그렇지 않고 Echo Show에서만 이 Skill을 제공하고자 한다면 사용자에게 그 Skill에 대한 혹은 그 Skill의 특정 기능에 대한 정보를 주어야 하구요. 예를 들어 Skill에서 비디오를 사용할 수 있도록 해 주는 VideoApp interface같은 경우에는 Echo Show에서는 지원이 되지만 아마존 에코같은 스크린이 없는 디바이스들에서는 지원이 되지 않습니다.

Upgrade an existing skill for Echo Show


You may have already created a certified skill that works with Alexa-enabled devices without screens. You can modify this skill to add additional functionality to take advantage of the display templates and touch features.


여러분 중에 스크린이 없는 Alexa를 사용할 수 있는 디바이스에서 작동하는 Skill을 이미 개발한 분들도 있을 수도 있습니다. 이 Skill을 디스플레이 탬플릿과 터치 기능을 이용하도록하는 추가적인 기능들을 넣을 수도 있습니다.


To upgrade your skill for Echo Show, follow these steps.


Echo Show를 위해 여러분의 Skill을 업그레이드 하려면 아래와 같이 하세요.


  • Rethink the workflow of the skill. When a customer interacts with your skill on Echo Show, the experience will be different. Determine how your skill work work on both Echo Show, and other devices with Alexa that do not have screens.


    Skill의 workflow를 다시 생각합니다. Echo Show에서 여러분의 Skill이 사용자와 상호작용을 할 때 그 진행상황을 분명히 다를 겁니다. 여러분의 Skill이 Echo Show와 스크린이 없는 Alexa가 가능한 디바이스에서 어떻게 작동을 할 지에 대해 먼저 정하세요.


  • Enable the Display.RenderTemplate interface as described in Display Interface Reference.


    Display Interface Reference에 설명된 것 처럼 RenderTemplate interface 를 가능하도록 합니다. 


  • Modify the code of the skill service to reflect the new workflow you have designed, as well as preserve the experience for users who do not have Echo Show.


    여러분이 디자인한 새로운 workflow를 반영하도록 Skill 서비스의 코드를 수정합니다. Echo Show를 사용하지 않는 사용자들을 위해 기존의 기능들은 유지해야겠지요.


  • Test the skill with its new features.


    추가된 새 기능들을 테스트 해 봅니다.


  • Publish the changes.


    그리고 업데이트된 Skill을 Publish 합니다.



저작자 표시 비영리 동일 조건 변경 허락
신고

[AWS IoT] Getting Started with AWS IoT

2017.08.03 20:05 | Posted by 솔웅




There are several ways to get started with AWS IoT depending on your use case and how you want to integrate the service into your use case. The AWS Management Console provides a web-based interface for accessing and managing all your AWS IoT resources. Programmatic access to AWS IoT is enabled by the AWS CLI and AWS SDK.



AWS IoT를 시작하는 방법은 여러가지가 있을 수 있습니다. 여러분의 필요성과 그 필요를 충족하기 위해 서비스와 어떻게 융합할 것인지 등에 따라 나눌 수 있습니다. AWS Management Console은 여러분의 모든 AWS IoT resources들에 접근하고 관리하기 위한 web-based interface를 제공합니다. AWS IoT에 프로그램으로 접근하려면 AWS CLI 와 AWS SDK 를 사용해서 개발 할 수 있습니다.



To connect your hardware device, sensor, mobile app or a thing use the AWS IoT Device SDK. Choose from one of the AWS starter kits pre-packaged to connect to AWS IoT. In addition, AWS IoT is supported by a wide range of third party tools and gateways.



여러분의 하드웨어 디바이스, 센서, 모바일 앱 이나 기타 다른 사물들에 연결하려면 AWS IoT Device SDK를 사용하세요.
AWS starter kits 세트를 사용해서 AWS IoT에 연결할 수 있습니다. 또한 AWS IoT는 광범위한 3rd party 도구와 게이트웨이들의 지원을 받습니다.



Get started with AWS IoT




Get started with devices





The AWS Management Console is a web-based interface for accessing and managing your AWS IoT resources. You can easily and securely create a thing, associate certificate, publish messages and define actions using the AWS Management Console.



AWS Management Console은 여러분의 AWS IoT resources들에 접근하고 관리하기 위한 web-based interface입니다.
여러분은  AWS Management Console을 사용해서 쉽고 안전하게 사물, associate certificate, publish messages 등을 생성하고 액션들을 정의할 수 있습니다.



Get started with AWS IoT in the console



Experiment with AWS IoT





The AWS SDK helps take the complexity out of coding by providing APIs for many AWS services including AWS IoT. All AWS SDKs are enabled for AWS IoT. The single, downloadable package includes the code library, code samples, and documentation.



AWS SDK는 AWS IoT를 포함한 많은 AWS services들에 대한 APIs를 제공함으로서 복잡하지 않게 코딩을 하도록 도와줍니다. 모든 AWS SDK들은 AWS IoT에서도 사용할 수 있습니다. 코드 라이브러리, 코드 샘플들 그리고 문서들을 포함한 단일 패키지를 다운로드 할 수 있습니다.




The AWS IoT Device SDK helps you to easily and quickly connect your hardware device or your mobile device to AWS IoT. It offers enhanced features so that you can seamlessly interact with the device gateway and the device shadow that will enable you to quick start your development. The Device SDK supports a variety types of devices, from basic to industrial hardware devices. Learn more about the AWS IoT Device SDKs.


AWS IoT Device SDK는 여러분의 하드웨어 디바이스나 모바일 디바이스를 AWS IoT에 쉽고 빠르게 연결할 수 있도록 도와줍니다.
또한 향상된 기능들을 제공함으로서 디바이스 게이트와 디바이스 쉐도우와 끊임없이 상호작용할 수 있도록 해 여러분의 신속한 개발을 도와 줄 겁니다. 이 Device SDK는 다양한 타입의 디바이스들을 지원합니다. 기본적인 것에서부터 산업용 하드웨어 디바이스 까지요. AWS IoT Device SDK에 대해 좀 더 배워 보세요.




AWS IoT Starter Kits


The AWS IoT Starter Kits enable you to move quickly from idea to prototype. These physical kits are designed to help accelerate cloud-powered prototype development of connected devices and connect securely to AWS IoT. The kits include development microcontroller development boards, sensors and actuators, the AWS IoT Device SDK, and a simple getting started guide so that you can easily find the best fit for your products. You can purchase the kits from Amazon.com. If you already have the hardware board, you can download the SDK and samples to get started in minutes. Visit the APN partner portal to learn more about partners who provide AWS IoT Starter Kits.



AWS IoT Starter Kit들은 구상에서 프로토타입(시제품) 까지 이르는 길을 앞당기도록 도와 줍니다. 이 physical kit들은 연결된 디바이스들과 이들이 AWS IoT에 안전하게 연결되도록 하는 cloud-powered prototype 개발을 빨리 할 수 있도록 도와 주도록 디자인 돼 있습니다. 이 키트들은 development microcontroller development boards, 센서 그리고 actuators 등을 포함하고 있습니다. 또한 AWS IoT Device SDK와 간단한 안내서를 가지고 있어 여러분이 쉽게 제품에 가장 알맞는 구성들을 찾을 수 있도록 도와줍니다. 이 키트들은 아마존 닷 컴에서 구입할 수 있습니다. 이미 하드웨어 보드가 있다면 SDK를 다운로드 해 몇분안에 작업을 시작하실 수 있습니다. APN partner portal에 방문해서 AWS IoT Starter Kit들을 제공하는 파트너들에 대해 좀 더 배워 보세요.





The Digi ConnectCore 6UL SBC Pro development kit delivers the ultimate connected off-the-shelf NXP i.MX6UL Single Board Computer, Pico-ITX form factor, pre-certified 802.11a/b/g/n/ac Wi-Fi, Bluetooth® 4.2, including Bluetooth Low Energy, and out-of-box cellular integration options.
 

Buy Now

Get Started

Partner Website



The Digi ConnectCore® 6UL Starter Kit is a Linux development kit for the Digi ConnectCore 6UL SOM with Wi-Fi and Bluetooth 4.2 connectivity. The kit includes the compact ConnectCore 6UL SBC Express with on-board antenna, Grove connectors, and a Pi HAT compatible breakout connector.


Buy Now

Get Started

Partner Website





The Digi ConnectCore 6 SBC development kit delivers an industrial multi-core SBC platform with scalable NXP i.MX6 performance, pre-certified Bluetooth 4.0 and Wi-Fi integration, Digi XBee and cellular connectivity options, Gigabit Ethernet support, multi display/camera and audio support, external storage, and expansion connectors.


Buy Now

Get Started

Partner Website




This kit includes Broadcom BCM4343W (Wi-Fi, BLE) and few sensors packaged by Avnet runs Broadcom WICED SDK


Buy Now

Get Started

Partner Website



This kit includes Marvell MW302 and runs Marvell EZ-Connect SDK, ported from AWS IoT Device SDK


Buy Now

Get Started

Partner Website



This kit includes MediaTek Linkit One (Wi-Fi, GPS, BLE, GPRS) and Grove Sensors and Actuators and runs AWS IoT Device SDK with mBed TLS


Buy Now

Get Started

Partner Website


This kit includes Renesas RX63N RDK and runs AWS IoT Device SDK on Micrium OS


Buy Now

Get Started

Partner Website



This kit includes Qualcomm Snapdragon 410c (Wi-Fi, GPS, BLE) packaged by Arrow and runs AWS IoT Device SDK (C and Node.js)


Buy Now

Get Started

Partner Website



This kit includes Intel Edison with Arduino Breakout Board and Grove sensors and actuators and runs AWS IoT Device SDK (C and Node.js)


Buy Now

Get Started

Partner Website


This kit includes BeagleBone Green and Grove sensors and actuators and runs AWS IoT Device SDK (C and Node.js)


Buy Now

Get Started

Partner Website



This kit includes a Microchip PIC32 microcontroller, LAN8740A Ethernet Phy, MPLAB Harmony Integrated Software Framework, FreeRTOS, is extendable thought the mikroBUS header and runs AWS IoT Device SDK


Buy Now

Get Started

Partner Website





This kit includes Arduino Yun compatible board and Grove sensors and actuators and runs AWS IoT Device SDK for Arduino


Buy Now

Get Started

Partner Website





This kit includes TI Launchpad CC3200 and runs TI-RTOS


Buy Now

Get Started

Partner Website






The Wisplet S2W IoT Kit includes a ready-to-operate out-of-the-box Wi-Fi module together with a sensor module.


Buy Now

Get Started

Partner Website





The AT&T IoT Kit includes an AT&T Global SIM, LTE modem, and access to AWS IoT.


Buy Now

Get Started

Partner Website




저작자 표시 비영리 동일 조건 변경 허락
신고

[Arduino] 3rd project. 4X4X4 LED Light Cube

2017.06.05 10:22 | Posted by 솔웅


I've purchased 4X4X4 LED Light Cube kit from Aliexpress. ($3.79)

4X4X4 Blue LED Light Cube Kit 3D LED DIY Kit Electronic Suite for Arduino







You can get the instruction from here. but There is not enough information to complete the set.

Fortunately, got perfect info from this blog.

https://emalliab.wordpress.com/2015/07/24/icstation-4x4x4-led-cube-shield-for-arduino-hardware-build/

 https://emalliab.wordpress.com/2015/07/24/icstation-4x4x4-led-cube-shield-for-arduino-software/


So I've followed it and could complete the set like this.




This is the blog (2nd one) explained about the source code.


icStation 4x4x4 LED Cube Shield for Arduino – Software



July 24, 2015 at 10:31 pm (computers) ()


As described in my previous post, I now have a working (I’ve run the demo code!) icStation 4x4x4 LED cube shield connected up to an Arduino Uno.  Unfortunately as I started to dig around in the sample library, I just couldn’t quite work out how it was meant to address each plane of the cube.  Eventually I decided it wasn’t possible, due to a number of bugs in the code.


이전 게시물에서 설명한 것처럼, icStation 4x4x4 LED cube shield를 Arduino Uno에 연결하는 작업을 하고 있습니다. 불행하게도 샘플 라이브러리를 파고들 수록 큐브의 각 면을 지정하는 방법에 대해 이해하기가 더 어려워 졌습니다. 결국 해당 샘플 코드에 버그가 많아 제대로작동할 수 없다는 결론에 이르렀습니다.


The demo code worked as the code just showed the same pattern on each of the four planes.  This is largely because the initialisation routines set the four Ardunio data pins to low, and then never did anything else with them!  There is some mention of pins 16 and 17, but no mention of pins 18 and 19, and actually in the main display routines, there is nothing done to actually set any of these pins once initialisation is complete.  So at this point I decided to read a bit more about the 74HC595 and just go it alone.  Attached is the result.  Feel free to use as you see fit.


그 데모 코드는 4개의 면 각각이 동일한 패턴으로 보여지도록 작동하고 있습니다. 초기화 루틴이 4 개의 Ardunio 데이터 핀을 로우로 설정 한 후 그것을 아무곳에서도 사용하지 않습니다. 핀 16과 핀 17에 대해서는 언급이 있지만, 핀 18과 19에 대한 언급이 없습니다, 메인 디스플레이 루틴에서, 초기화가 완료되면 실제로 이러한 핀들을 설정하는 일은 없습니다. 그래서 이 시점에서 필자는 74HC595에 대해 좀 더 읽고 혼자서 결정했습니다. 첨부 된 결과입니다. 이것을 토대로 당신이 적합하다고 생각하는대로 자유롭게 사용하십시오.


Basic initialisation


The two shift registers seem fairly simple to setup.  The Arduino needs some control pins setting up as outputs alongside the four digital outs used for the LEDs.  The initialisation is quite straight forward as follows:


두 개의 시프트 레지스터는 설정하는 것이 매우 간단합니다. Arduino는 LED에 사용되는 4 개의 디지털 출력과 함께 출력으로 설정되는 일부 제어 핀을 필요로합니다. 초기화는 다음과 같이 매우 간단합니다.


#include <Arduino.h>

int HC595_clockPin=0;   // SH_CP of 74HC595 
int HC595_latchPin=1;   // ST_CP of 74HC595 
int HC595_dataPin=3;    // DS of 74HC595 
int HC595_enablePin=2;  // Not OE of 74HC595
int LED_Pin16= 4;
int LED_Pin17= 5;
int LED_Pin18= 6;
int LED_Pin19= 7;

void setup() {
  // put your setup code here, to run once:
  pinMode( HC595_latchPin,  OUTPUT );
  pinMode( HC595_clockPin,  OUTPUT );
  pinMode( HC595_dataPin,   OUTPUT );
  pinMode( HC595_enablePin, OUTPUT );
  
  pinMode( LED_Pin16, OUTPUT );
  pinMode( LED_Pin17, OUTPUT );
  pinMode( LED_Pin18, OUTPUT );
  pinMode( LED_Pin19, OUTPUT );
  
  digitalWrite(LED_Pin16,HIGH);
  digitalWrite(LED_Pin17,HIGH);
  digitalWrite(LED_Pin18,HIGH);
  digitalWrite(LED_Pin19,HIGH);
//  digitalWrite(HC595_enablePin, LOW);  // Enable Not OE (negative logic)
}


I never did quite work out if I needed to do anything with the enable pin, but as it is active low, I assumed that by not doing anything, everything would be enabled by default anyway.

enable pin과 관련해서는 아무것도 하지 않았습니다. active 상태 값이 low 이기 때문입니다. 이렇게 아무것도 정의하지 않으면 디폴트로  enable이 될 것으로 생각 됩니다.


In terms of actually writing a value to the 74HC595, again that is fairly straight forward.

74HC595에 적용된 값들은 그냥 보시는 대로 입니다. 



/*
  Protocol for sending the data to the hc595 is as follows:
   (see: http://www.arduino.cc/en/Tutorial/ShiftOut)
   
   "when the clock pin goes from low to high, the shift register
    reads the state of the data pin ... when the latch pin goes
    from low to high the sent data gets moved from the shift
    registers ... to the output pins"
   
   As we have two HC595s chained together, we use a 16 bit input value
*/
void write_74HC595 (unsigned int hc595value) { 
   digitalWrite(HC595_latchPin, LOW);   // ensures LEDs don't light whilst changing values
   
   // Shift each 8 bit value in sequence - the two chained HC595s automatically grab
   // the right bits - the first 8 to the first chip, second 8 to the second chip
   shiftOut(HC595_dataPin, HC595_clockPin, LSBFIRST, hc595value);  
   shiftOut(HC595_dataPin, HC595_clockPin, LSBFIRST, (hc595value >> 8));
   
   digitalWrite(HC595_latchPin, HIGH);  // data transferred from shift register to outputs when latch goes LOW->HIGH
}


So 16 bits of the hc595value variable are sent in two 8-bit chunks over the serial port to the shift registers and with the appropriate signalling via the latch pin, that is basically that.  This sets the outputs of the 74HC595 to high, but in order to make the LEDs come on, the Arduino data pins corresponding to the horizontal planes must be set low.  If a different pattern is required for each plane, then some kind of simple ‘scanning’ is required as illustrated below.



따라서 hc595value 변수의 16 비트는 두 개의 8 비트 chunk로 직렬 포트를 통해 shift register로 전송 되며 이것은 latch pin을 통해 적절한 신호로 전송됩니다. 이것은 74HC595의 출력을 high로 설정하지만 LED를 켜기 위해 수평면에 해당하는 Arduino 데이터 핀을 low로 설정 해야합니다. 각 평면에 다른 패턴이 필요한 경우 아래에 설명 된 것처럼 일종의 간단한 '스캐닝'이 필요합니다.



int LED_Plane[] = {LED_Pin16, LED_Pin17, LED_Pin18, LED_Pin19};

/*
  Inputs: Array of 4 integers - one for each plane
*/
void display (unsigned int *pPattern)
{
  int i;
  for (i=0; i<4; i++)
  {
    int j;
    for (j=0; j<1000; j++)
    {
      // Slow this down so that there is time for the LEDS to light
      // Experimentation shows that 200+ gives brighter LEDs
      // NB: Do it this way so an empty loop isn't optimised out
      if (j==0)
      {
        digitalWrite(LED_Plane[0], HIGH);
        digitalWrite(LED_Plane[1], HIGH);
        digitalWrite(LED_Plane[2], HIGH);
        digitalWrite(LED_Plane[3], HIGH);
        write_74HC595 (pPattern[i]);
        digitalWrite(LED_Plane[i], LOW);
      }
    }
  }
}


I guess the only thing to really note here is that without the loop involving j then the ‘scanning’ was happening too fast to allow the LEDs to have any significant brightness at all.  I initially had a simple for (j=0; j<1000; j++) {}; statement at the end, but this seemed to be optimised out – at least it didn’t seem to have the delay effect I wanted, so instead I made the code only act on one pass through the loop.


여기서 정말로 주목할 것은, j를 포함하는 루프가 없으면 '스캐닝'이 너무 빠르게 진행 되어 LED가 충분히 밝게 되지 않는 다는 겁니다. 나는 처음에는  간단한 for 문을 (j = 0; j <1000; j ++) {}; 를 끝에 사용했습니다.  이것이 최적화 된 것처럼 보였지만 내가 원한 delay 효과를 보여주지는 못했습니다. 그래서 그렇게 하는 대신에 loop를 통과하는 것을 한번만 실행되도록 코딩했습니다. 



So, with these basics, it is now possible to get a 64 bit pattern, in the form of four 16 bit values, each representing one plane of 16 LEDs, onto the cube.


이렇게 함으로서 64 bit pattern이 가능해 졌습니다. 4개의 16 비트 값 형태로 각각이 큐브의 16 LEDs 의 한 평면을 나타내게 됩니다.



I have the full demo code file below – it isn’t massively pretty, and its not cpp (sorry – I’ve always been more of a C person I’m afraid, and my C is a little rusty), but it works for me.  Your proverbial mileage, as they say, may vary.


아래에 전체 코드가 있습니다. 코드가 깔끔하지 않고 cpp 로 돼 있지 않습니다. (나는 C 언어에 대해 그렇게 능숙하지가 못해서요.) 아무튼 이 소스코드는 잘 작동합니다. 



Kevin




#include <Arduino.h>

int HC595_clockPin=0;   // SH_CP of 74HC595 
int HC595_latchPin=1;   // ST_CP of 74HC595 
int HC595_dataPin=3;    // DS of 74HC595 
int HC595_enablePin=2;  // Not OE of 74HC595
int LED_Pin16= 4;
int LED_Pin17= 5;
int LED_Pin18= 6;
int LED_Pin19= 7;
int LED_Plane[] = {LED_Pin16, LED_Pin17, LED_Pin18, LED_Pin19};

// Each line (8 bytes) is an entire cube, with two consecutive bytes per plane of LEDS,
// and 16 LEDS per plane. LEDs are encoded in the following order:
//    Lowest plane byte 1, lowest plane byte 2, second lowerst plane 1, then 2,
//    second from top plane 1, then 2, highest plane 1, highest plane 2.
//
//    Each plane is encoded looking at the Arduino oriented with the USB/power
//    designated by 'south' by started 'north west' as follows:
//        D0    D1    D2    D3
//        D4    D5    D6    D7
//        D8    D9    D10   D11
//        D12   D13   D14   D15
//
//        D16   D17   D18   D19
//          (USB)      (Power)
//    With D16 being the lowest plane, through to D19 being the highest plane
//    Of course, if you wire the planes up differently, that is up to you!
//
//    Each two bytes of the pattern are therefore:
//        B00000000, B00000000 -> D0-7, D8-15
//    with D0 = msb of the first value, D7 being the lsb of the first value,
//    and  D8 = msb of the second value, D15 being the lsb of the second value.
//
//    So the entire pattern is:
//    B10010000,B00001001,B00000000,B00000000,B00000000,B00000000,B10010000,B00001001,
//     |      |  |     ||                                          |      |  |     ||
//     |      |  |     |\ D15 bottom plane                         |      |  |     |\ D15 top plane
//     |      |  |     \ D14 bottom plane                          |      |  |     \ D14 top plane
//     |      |  \ D8 bottom plane                                 |      |  \ D8 top plane
//     |      \ D7 bottom plane                                    |      \ D7 top plane
//     \ D0 bottom plane                                           \ D0 top plane
//
// Comment following in or out to switch patterns in or out
#define SWAP   1
#define SNAKE  1
#define BURST  1
#define SPIRAL 1
#define ALT    1
unsigned char pattern[] = {
#ifdef SWAP
  B10010000,B00001001,B00000000,B00000000,B00000000,B00000000,B10010000,B00001001,
  B00000000,B00000000,B10010000,B00001001,B10010000,B00001001,B00000000,B00000000,
  B00000000,B00000000,B01100000,B00000110,B01100000,B00000110,B00000000,B00000000,
  B01100000,B00000110,B00000000,B00000000,B00000000,B00000000,B01100000,B00000110,
  B00001001,B10010000,B00000000,B00000000,B00000000,B00000000,B00001001,B10010000,
  B00000000,B00000000,B00001001,B10010000,B00001001,B10010000,B00000000,B00000000,
  B00000000,B00000000,B00000110,B01100000,B00000110,B01100000,B00000000,B00000000,
  B00000110,B01100000,B00000000,B00000000,B00000000,B00000000,B00000110,B01100000,
#endif
#ifdef SNAKE
  B11001100,B00000000,B11001100,B00000000,B00000000,B00000000,B00000000,B00000000,
  B00000000,B00000000,B11001100,B00000000,B11001100,B00000000,B00000000,B00000000,
  B00000000,B00000000,B00000000,B00000000,B11001100,B00000000,B11001100,B00000000,
  B00000000,B00000000,B00000000,B00000000,B00001100,B11000000,B00001100,B11000000,
  B00000000,B00000000,B00000000,B00000000,B00000000,B11001100,B00000000,B11001100,
  B00000000,B00000000,B00000000,B00000000,B00000000,B01100110,B00000000,B01100110,
  B00000000,B00000000,B00000000,B00000000,B00000000,B00110011,B00000000,B00110011,
  B00000000,B00000000,B00000000,B00110011,B00000000,B00110011,B00000000,B00000000,
  B00000000,B00110011,B00000000,B00110011,B00000000,B00000000,B00000000,B00000000,
  B00000011,B00110000,B00000011,B00110000,B00000000,B00000000,B00000000,B00000000,
  B00110011,B00000000,B00110011,B00000000,B00000000,B00000000,B00000000,B00000000,
  B01100110,B00000000,B01100110,B00000000,B00000000,B00000000,B00000000,B00000000,
#endif
#ifdef BURST
  B00000000,B00000000,B00000110,B01100000,B00000110,B01100000,B00000000,B00000000,
  B00000110,B01100000,B01101001,B10010110,B01101001,B10010110,B00000110,B01100000,
  B01101001,B10010110,B10010000,B00001001,B10010000,B00001001,B01101001,B10010110,
  B10010000,B00001001,B00000000,B00000000,B00000000,B00000000,B10010000,B00001001,
  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
#endif
#ifdef SPIRAL
  B11001100,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
  B01100110,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
  B00110011,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
  B00000011,B00110000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
  B00000000,B00110011,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
  B00000000,B01100110,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
  B00000000,B11001100,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
  B00001100,B11000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
  B11001100,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
  B00000000,B00000000,B11001100,B00000000,B00000000,B00000000,B00000000,B00000000,
  B00000000,B00000000,B01100110,B00000000,B00000000,B00000000,B00000000,B00000000,
  B00000000,B00000000,B00110011,B00000000,B00000000,B00000000,B00000000,B00000000,
  B00000000,B00000000,B00000011,B00110000,B00000000,B00000000,B00000000,B00000000,
  B00000000,B00000000,B00000000,B00110011,B00000000,B00000000,B00000000,B00000000,
  B00000000,B00000000,B00000000,B01100110,B00000000,B00000000,B00000000,B00000000,
  B00000000,B00000000,B00000000,B11001100,B00000000,B00000000,B00000000,B00000000,
  B00000000,B00000000,B00001100,B11000000,B00000000,B00000000,B00000000,B00000000,
  B00000000,B00000000,B11001100,B00000000,B00000000,B00000000,B00000000,B00000000,
  B00000000,B00000000,B00000000,B00000000,B11001100,B00000000,B00000000,B00000000,
  B00000000,B00000000,B00000000,B00000000,B01100110,B00000000,B00000000,B00000000,
  B00000000,B00000000,B00000000,B00000000,B00110011,B00000000,B00000000,B00000000,
  B00000000,B00000000,B00000000,B00000000,B00000011,B00110000,B00000000,B00000000,
  B00000000,B00000000,B00000000,B00000000,B00000000,B00110011,B00000000,B00000000,
  B00000000,B00000000,B00000000,B00000000,B00000000,B01100110,B00000000,B00000000,
  B00000000,B00000000,B00000000,B00000000,B00000000,B11001100,B00000000,B00000000,
  B00000000,B00000000,B00000000,B00000000,B00001100,B11000000,B00000000,B00000000,
  B00000000,B00000000,B00000000,B00000000,B11001100,B00000000,B00000000,B00000000,
  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B11001100,B00000000,
  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B01100110,B00000000,
  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00110011,B00000000,
  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000011,B00110000,
  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00110011,
  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B01100110,
  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B11001100,
  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00001100,B11000000,
  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B11001100,B00000000,
#endif
#ifdef ALT
  B11111001,B10011111,B10010000,B00001001,B10010000,B00001001,B11111001,B10011111,
  B00000110,B01100000,B01101001,B10010110,B01101001,B10010110,B00000110,B01100000,
  B00000000,B00000000,B00000110,B01100000,B00000110,B01100000,B00000000,B00000000,
  B00000110,B01100000,B01101001,B10010110,B01101001,B10010110,B00000110,B01100000,
#endif
};
int patternNumber=0;
int numPatterns=sizeof(pattern)/8;
int tickCount=0;
int tickCountMax=50;      // How many times to loop before changing the pattern
unsigned int currentPattern[4];

void setup() {
  // put your setup code here, to run once:
  pinMode( HC595_latchPin,  OUTPUT );
  pinMode( HC595_clockPin,  OUTPUT );
  pinMode( HC595_dataPin,   OUTPUT );
  pinMode( HC595_enablePin, OUTPUT );
  
  pinMode( LED_Pin16, OUTPUT );
  pinMode( LED_Pin17, OUTPUT );
  pinMode( LED_Pin18, OUTPUT );
  pinMode( LED_Pin19, OUTPUT );
  
  digitalWrite(LED_Pin16,HIGH);
  digitalWrite(LED_Pin17,HIGH);
  digitalWrite(LED_Pin18,HIGH);
  digitalWrite(LED_Pin19,HIGH);
//  digitalWrite(HC595_enablePin, LOW);  // Enable Not OE (negative logic)

  patternNumber=0;
  tickCount = tickCountMax;
}

/*
  Protocol for sending the data to the hc595 is as follows:
   (see: http://www.arduino.cc/en/Tutorial/ShiftOut)
   
   "when the clock pin goes from low to high, the shift register
    reads the state of the data pin ... when the latch pin goes
    from low to high the sent data gets moved from the shift
    registers ... to the output pins"
   
   As we have two HC595s chained together, we use a 16 bit input value
*/
void write_74HC595 (unsigned int hc595value) { 
   digitalWrite(HC595_latchPin, LOW);   // ensures LEDs don't light whilst changing values
//   digitalWrite(HC595_enablePin, HIGH); // OE is negative logic
   
   // Shift each 8 bit value in sequence - the two chained HC595s automatically grab
   // the right bits - the first 8 to the first chip, second 8 to the second chip
   shiftOut(HC595_dataPin, HC595_clockPin, LSBFIRST, hc595value);  
   shiftOut(HC595_dataPin, HC595_clockPin, LSBFIRST, (hc595value >> 8));
   
   digitalWrite(HC595_latchPin, HIGH);  // data transferred from shift register to outputs when latch goes LOW->HIGH
//   digitalWrite(HC595_enablePin, LOW);  // re-enable (negative logic again)
}

/*
  Inputs: Array of 4 integers - one for each plane
*/
void display (unsigned int *pPattern)
{
  int i;
  for (i=0; i<4; i++)
  {
    int j;
    for (j=0; j<1000; j++)
    {
      // Slow this down so that there is time for the LEDS to light
      // Experimentation shows that 200+ gives brighter LEDs
      // NB: Do it this way so an empty loop isn't optimised out
      if (j==0)
      {
        digitalWrite(LED_Plane[0], HIGH);
        digitalWrite(LED_Plane[1], HIGH);
        digitalWrite(LED_Plane[2], HIGH);
        digitalWrite(LED_Plane[3], HIGH);
        write_74HC595 (pPattern[i]);
        digitalWrite(LED_Plane[i], LOW);
      }
    }
  }
}

void displayPattern ()
{
  int i;
  // only update it every tick otherwise just display as is
  tickCount--;
  if (tickCount <= 0)
  {
    tickCount = tickCountMax;
    for (i=0; i<4; i++)
    {
      currentPattern[i] = pattern[i*2 + patternNumber*8] * 256 + pattern[i*2 + 1 + patternNumber*8];
    }
    patternNumber++;
    if (patternNumber >= numPatterns)
    {
      patternNumber = 0;
    }
  }
  display(&currentPattern[0]);
}

void loop() {
  // put your main code here, to run repeatedly:
  displayPattern();
}



저작자 표시 비영리 동일 조건 변경 허락
신고


The Hamcrest Tutorial



Introduction

Hamcrest is a framework for writing matcher objects allowing 'match' rules to be defined declaratively. There are a number of situations where matchers are invaluble, such as UI validation, or data filtering, but it is in the area of writing flexible tests that matchers are most commonly used. This tutorial shows you how to use Hamcrest for unit testing.


Hamcrest는 'match'rule을 선언적으로 정의 해 matcher objects를 작성하기위한 framework입니다. UI 유효성 UI validation 또는 데이터 필터링과 같이 matchers가 사용할 수 없는 상황도 많이 있지만 matcher가 가장 일반적으로 사용되는 곳은 flexible tests를 작성하는 영역에 있습니다. 이 tutorial에서는 unit testing를 위해 Hamcrest를 사용하는 방법을 보여줍니다.


When writing tests it is sometimes difficult to get the balance right between overspecifying the test (and making it brittle to changes), and not specifying enough (making the test less valuable since it continues to pass even when the thing being tested is broken). Having a tool that allows you to pick out precisely the aspect under test and describe the values it should have, to a controlled level of precision, helps greatly in writing tests that are "just right". Such tests fail when the behaviour of the aspect under test deviates from the expected behaviour, yet continue to pass when minor, unrelated changes to the behaviour are made.


테스트를 작성할 때 테스트를 지나치게 자세하게 지정하는 것 (그리고 수정이 어렵게 하는 것)과 충분한 테스트를 하지 않는 것 사이의 균형을 잡기가 어렵기 때문에 (이럴 경우 테스트 대상에 문제가 생긴 경우에도 테스트가 pass 될 수 있어 해당 테스트가 유효하지 않게 됩니다.) 테스트 할 aspect를 정확하게 선택할 수 있도록 하고, 가져야 할 값을 describe 해서 정밀하게 제여할 수 있도록 하는 도구를 사용하면 "just right" 테스트를 작성하는 데 크게 도움이됩니다. 이러한 테스트는 테스트중인 aspect의 동작이 예상되는 벗어나는 경우 fail 하고 , minor 한 변화나 테스트 범위에서 벗어난 변경이 있는 경우 pass 해야 합니다.



My first Hamcrest test

We'll start by writing a very simple JUnit 3 test, but instead of using JUnit's assertEquals methods, we use Hamcrest's assertThatconstruct and the standard set of matchers, both of which we statically import:


아래 간단한 JUnit 3 test를 작성할 겁니다. JUnit의 assertEquals methods를 사용하는 대신에 Hamcrest의 assertThat construct와 matchers의 표준 세트를 사용할 겁니다. 이 둘은 정적으로 import 합니다.



``` import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.*;


import junit.framework.TestCase;


public class BiscuitTest extends TestCase { public void testEquals() { Biscuit theBiscuit = new Biscuit("Ginger"); Biscuit myBiscuit = new Biscuit("Ginger"); assertThat(theBiscuit, equalTo(myBiscuit)); } } ```



The assertThat method is a stylized sentence for making a test assertion. In this example, the subject of the assertion is the object biscuit that is the first method parameter. The second method parameter is a matcher for Biscuit objects, here a matcher that checks one object is equal to another using the Object equals method. The test passes since the Biscuit class defines an equals method.


assertThat method는 test assertion을 만들기 위한 양식화 된 문장입니다. 이 예에서는 assertion의 subject는 첫 번째 method 매개 변수 인 object biscuit입니다. 두 번째 method 매개 변수는 Biscuit objects에 대한 matcher입니다. 여기에서 한 object를 검사하는 matcher는 Object equals method를 사용하는것과 같습니다. 이 테스트는 Biscuit 클래스가 equals method를 정의하기 때문에 pass 하게 됩니다.



If you have more than one assertion in your test you can include an identifier for the tested value in the assertion:


하나 이상의 assertion이 있는 경우 테스트 된 값에 대한 identifier를 assertion에 포함 할 수 있습니다.


assertThat("chocolate chips", theBiscuit.getChocolateChipCount(), equalTo(10)); assertThat("hazelnuts", theBiscuit.getHazelnutCount(), equalTo(3));



Other test frameworks



Hamcrest has been designed from the outset to integrate with different unit testing frameworks. For example, Hamcrest can be used with JUnit 3 and 4 and TestNG. (For details have a look at the examples that come with the full Hamcrest distribution.) It is easy enough to migrate to using Hamcrest-style assertions in an existing test suite, since other assertion styles can co-exist with Hamcrest's.


Hamcrest는 처음부터 다른 unit testing framework와 통합되도록 설계되었습니다. 예를 들어, Hamcrest는 JUnit 3과 4 및 TestNG와 함께 사용할 수 있습니다. (자세한 내용은 전체 Hamcrest distribution과 함께 제공되는 예제를 참조하십시오.) 다른 assertion 스타일이 Hamcrest와 같이 사용될 수 있기 때문에 기존 test suite에서 Hamcrest-style assertions를 사용하는 것으로 마이그레이션하는 것은 쉽습니다.


Hamcrest can also be used with mock objects frameworks by using adaptors to bridge from the mock objects framework's concept of a matcher to a Hamcrest matcher. For example, JMock 1's constraints are Hamcrest's matchers. Hamcrest provides a JMock 1 adaptor to allow you to use Hamcrest matchers in your JMock 1 tests. JMock 2 doesn't need such an adaptor layer since it is designed to use Hamcrest as its matching library. Hamcrest also provides adaptors for EasyMock 2. Again, see the Hamcrest examples for more details.


Hamcrest는 또한 mock objects framework와 같이 사용 될 수 있습니다. 그러려면 mock objects framework의 matcher와 Hamcrest의 matcher 에 대한 concept을 연결해 주도록 adaptors를 사용하면 됩니다. 예를 들어, JMock 1의 constraints는 Hamcrest의 matchers입니다. Hamcrest는 JMock 1 테스트에서 Hamcrest matchers를 사용할 수 있도록 JMock 1 어댑터를 제공합니다. JMock 2는 Hamcrest를 매칭 라이브러리로 사용하기 때문에 그러한 adaptor layer가 필요하지 않습니다. Hamcrest는 EasyMock 2 용 어댑터도 제공합니다. 자세한 내용은 Hamcrest 예제를 참조하십시오.



A tour of common matchers



Hamcrest comes with a library of useful matchers. Here are some of the most important ones.


Hamcrest는 유용한 matchers 라이브러리를 제공합니다. 그 중에 중요한 것들 입니다.



    Core
    • anything - always matches, useful if you don't care what the object under test is
    • describedAs - decorator to adding custom failure description
    • is - decorator to improve readability - see "Sugar", below

  • Logical
    • allOf - matches if all matchers match, short circuits (like Java &&)
    • anyOf - matches if any matchers match, short circuits (like Java ||)
    • not - matches if the wrapped matcher doesn't match and vice versa

  • Object
    • equalTo - test object equality using Object.equals
    • hasToString - test Object.toString
    • instanceOfisCompatibleType - test type
    • notNullValuenullValue - test for null
    • sameInstance - test object identity

  • Beans
    • hasProperty - test JavaBeans properties

  • Collections
    • array - test an array's elements against an array of matchers
    • hasEntryhasKeyhasValue - test a map contains an entry, key or value
    • hasItemhasItems - test a collection contains elements
    • hasItemInArray - test an array contains an element

  • Number
    • closeTo - test floating point values are close to a given value
    • greaterThangreaterThanOrEqualTolessThanlessThanOrEqualTo - test ordering

  • Text
    • equalToIgnoringCase - test string equality ignoring case
    • equalToIgnoringWhiteSpace - test string equality ignoring differences in runs of whitespace
    • containsStringendsWithstartsWith - test string matching



Sugar


Hamcrest strives to make your tests as readable as possible. For example, the is matcher is a wrapper that doesn't add any extra behavior to the underlying matcher. The following assertions are all equivalent:


Hamcrest는 여러분이 최대한 readable한 테스트를 만들 수 있도록 노력합니다. 예를 들어, is matcher는 기본이되는 matcher에 추가의 동작을 추가하지 않는 wrapper 입니다. (어떤 동작을 하지는 않고 단지 가독성 -readable- 을 제공하기 위한 것).

아래 assertion 들은 다 똑 같습니다.



assertThat(theBiscuit, equalTo(myBiscuit)); assertThat(theBiscuit, is(equalTo(myBiscuit))); assertThat(theBiscuit, is(myBiscuit));


The last form is allowed since is(T value) is overloaded to return is(equalTo(value)).


마지막 form은 is(T value)가 is(equalTo (value))를 return하도록 overload 되어 있기 때문에 가능합니다.



Writing custom matchers



Hamcrest comes bundled with lots of useful matchers, but you'll probably find that you need to create your own from time to time to fit your testing needs. This commonly occurs when you find a fragment of code that tests the same set of properties over and over again (and in different tests), and you want to bundle the fragment into a single assertion. By writing your own matcher you'll eliminate code duplication and make your tests more readable!


Hamcrest는 많은 유용한 matchers와 함께 번들로 제공되지만, 테스트 요구에 맞추기 위해 수시로 자신 만의 템플릿을 만들어야 할 필요가있을 것입니다. 이것은 일반적으로  동일한 properties set을 반복적으로 테스트 하는 (다른 테스트 들에서도) code의 fragment를 발견 했을 때 그리고 이 fragment를 단일 assertion으로 묶으려는 경우에 해당 될 겁니다. 자신 만의 matcher를 작성함으로써 코드 중복을 제거하고 테스트의 가독성을 훨씬 높일 수 있습니다!



Let's write our own matcher for testing if a double value has the value NaN (not a number). This is the test we want to write:


double 값의 값이 NaN (숫자가 아님) 인 경우를 테스트하기 위해 자체 matcher를 작성해 보겠습니다. 아래 그 예제가 있습니다.



public void testSquareRootOfMinusOneIsNotANumber() { assertThat(Math.sqrt(-1), is(notANumber())); }


And here's the implementation:


``` package org.hamcrest.examples.tutorial;

import org.hamcrest.Description; import org.hamcrest.Factory; import org.hamcrest.Matcher; import org.hamcrest.TypeSafeMatcher;

public class IsNotANumber extends TypeSafeMatcher {

@Override public boolean matchesSafely(Double number) { return number.isNaN(); }

public void describeTo(Description description) { description.appendText("not a number"); }

@Factory public static Matcher notANumber() { return new IsNotANumber(); }

} ```



The assertThat method is a generic method which takes a Matcher parameterized by the type of the subject of the assertion. We are asserting things about Double values, so we know that we need a Matcher<Double>. For our Matcher implementation it is most convenient to subclass TypeSafeMatcher, which does the cast to a Double for us. We need only implement the matchesSafely method - which simply checks to see if the Double is NaN - and the describeTo method - which is used to produce a failure message when a test fails. Here's an example of how the failure message looks:


assertThat method는, assertion의 subject의 type에 의해 파라미터 화 된 Matcher를 취하는 generic method입니다. 우리는 Double 값에 대해 asserting하고 있으므로 Matcher <Double>이 필요하다는 것을 알고 있습니다. 이 Matcher를 구현하는데 있어 TypeSafeMatcher를 서브 클래스로 implement 하는 것이 가장 좋습니다. TypeSafeMatcher는 Double로 형변환을 하게 됩니다. matchesSafely method와 describeTo method만 implement 하면 됩니다. matchesSafely method는 단순히 Double이 NaN인지 확인하고 describeTo method 테스트가 fail 할 경우 오류 메시지를 생성하는 데 사용됩니다. 다음은 failure message가 표시되는 예입니다.



assertThat(1.0, is(notANumber()));


fails with the message


java.lang.AssertionError: Expected: is not a number got : <1.0>



The third method in our matcher is a convenience factory method. We statically import this method to use the matcher in our test:


우리의 matcher에서 세 번째 method는 편리한 factory method 입니다. test에서 matcher를 사용하기 위해 이 method를 정적(statically)으로 가져옵니다.


``` import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.*;

import static org.hamcrest.examples.tutorial.IsNotANumber.notANumber;

import junit.framework.TestCase;

public class NumberTest extends TestCase {

public void testSquareRootOfMinusOneIsNotANumber() { assertThat(Math.sqrt(-1), is(notANumber())); } } ```



Even though the notANumber method creates a new matcher each time it is called, you should not assume this is the only usage pattern for your matcher. Therefore you should make sure your matcher is stateless, so a single instance can be reused between matches.


비록 notANumber method가 호출 될 때마다 new matcher를 생성하지만, 이것이 matcher의 유일한 사용 patter 이라고 예단 해서는 안됩니다. 여러분은 이 matcher가 stateless 임을 유념해야 합니다. single instance 가 matcher들 사이에서 재사용 될 수 있습니다.



Sugar generation



If you produce more than a few custom matchers it becomes annoying to have to import them all individually. It would be nice to be able to group them together in a single class, so they can be imported using a single static import much like the Hamcrest library matchers. Hamcrest helps out here by providing a way to do this by using a generator.


여러가지 custom matchers를 만들었다면 이들을 각각 import 하는 일이 성가실 겁니다. 하나의 클래스에서 이들을 그룹화 하면 좋겠죠. 그렇게 하면 Hamcrest 라이브러리 matchers와 같이 single static import를 사용하여 한꺼번에 import 할 수 있을 겁니다. Hamcrest는 generator를 사용하여 이를 수행 할 수있는 방법을 제공합니다.


First, create an XML configuration file listing all the Matcher classes that should be searched for factory methods annotated with the org.hamcrest.Factory annotation. For example:


먼저, 모든 Matcher classes을 리스팅 한 XML configuration file을 생성합니다. 이것은 org.hamcrest.Factory annotation과 함께 factory methods annotated를 하기 위해 검색 될 겁니다. 예 :


```

```


Second, run the org.hamcrest.generator.config.XmlConfigurator command-line tool that comes with Hamcrest. This tool takes the XML configuration file and generates a single Java class that includes all the factory methods specified by the XML file. Running it with no arguments will display a usage message. Here's the output for the example.


둘째, Hamcrest와 함께 제공되는 org.hamcrest.generator.config.XmlConfigurator command-line tool를 실행하십시오. 이 도구는 XML 구성 파일을 사용하여 XML 파일에 지정된 모든 팩토리 method를 포함하는 단일 Java 클래스를 생성합니다. 인수없이 실행하면 사용법 메시지가 표시됩니다. 이 예제의 결과는 다음과 같습니다.



``` // Generated source. package org.hamcrest.examples.tutorial;

public class Matchers {

public static org.hamcrest.Matcher is(T param1) { return org.hamcrest.core.Is.is(param1); }

public static org.hamcrest.Matcher is(java.lang.Class param1) { return org.hamcrest.core.Is.is(param1); }

public static org.hamcrest.Matcher is(org.hamcrest.Matcher param1) { return org.hamcrest.core.Is.is(param1); }

public static org.hamcrest.Matcher notANumber() { return org.hamcrest.examples.tutorial.IsNotANumber.notANumber(); }

} ```



Finally, we can update our test to use the new Matchers class.


마지막으로 new Matchers class를 사용하도록 아래처럼 업데이트 합니다.



``` import static org.hamcrest.MatcherAssert.assertThat;

import static org.hamcrest.examples.tutorial.Matchers.*;

import junit.framework.TestCase;

public class CustomSugarNumberTest extends TestCase {

public void testSquareRootOfMinusOneIsNotANumber() { assertThat(Math.sqrt(-1), is(notANumber())); } } ```



Notice we are now using the Hamcrest library is matcher imported from our own custom Matchers class.


Notice 우리는 custom Matchers class 에서 importe된 matcher 인 Hamcrest library를 사용하게 됩니다.



Where next?

See FurtherResources.

--Tom White

저작자 표시 비영리 동일 조건 변경 허락
신고


Asynchronous Testing with Protractor’s ControlFlow


Protractor is an end-to-end testing framework for AngularJS applications that uses a real browser, just as a real user would. It is built on top of NodeJS and WebDriverJS and taps into the internals of Angular to know when Angular is done processing and updating bindings.



Protractor는 real user would와 마찬가지로 실제 브라우저를 사용하는 AngularJS 응용 프로그램의 end-to-end testing framework입니다. NodeJS 및 WebDriverJS 위에 구축되며 Angular의 내부를 tap해서 Angular가 바인딩 처리 및 업데이트를 완료 한 시점을 알 수 있습니다.


The joy of Protractorand WebDriverJS is that we can write our tests in a synchronous style, and still have the added benefits of asynchronous code. 


Protractor와 WebDriverJS의 강점은 동기식 스타일로 테스트를 작성할 수 있으며 비동기 코드의 부가적인 이점을 여전히 가지고 있다는 것입니다.

We are currently using Protractor for testing a Rails and Angular application that we’re developing here in the Detroit office. We were faced with a problem: “How do we write our own functions which are asynchronous but appear in the same synchronous style that Protractor tests are written in?” This is especially handy for performing REST requests for seeding data into the test database using something like the rails Hangar gem. 


우리는 현재 디트로이트 사무실에서 개발중인 Rails 및 Angular 응용 프로그램을 테스트하기 위해 Protractor를 사용하고 있습니다. "비동기식이지만 Protractor로 작성된 동기식으로 보이는 함수는 어떻게 작성합니까"  이것은 rails Hangar gem 같은 것을 사용해서 테스트 데이터베이스에 데이터를 넣기 위한 REST requests를 수행 할 때 특히 유용합니다. 


The ControlFlow


This required diving into the internals of how Protractor and WebDriverJS handle asynchrony. WebDriverJS uses an object called theControlFlow, which coordinates the scheduling and execution of commands operating on a queue. 


Any time an asynchronous command is invoked, it’s put in the queue where it will wait for all previous commands to complete prior to execution. The ControlFlow allows us to write code like this:


Protractor와 WebDriverJS가 어떻게 비동기를 처리하는지에 대해 좀 더 깊이 들어가겠습니다. WebDriverJS는 theControlFlow라는 객체를 사용합니다. 이 객체는 queue에서 작동하는 명령의 일정과 실행을 조정합니다.


비동기 명령이 호출 될 때마다 queue에 저장되어 실행 되기 전 모든 이전 명령들이 완료 될 때까지 대기합니다. ControlFlow를 사용하면 다음과 같은 코드를 작성할 수 있습니다.


driver.get(“http://www.google.com”);
driver.findElement(webdriver.By.name('q')).sendKeys('webdriver');
driver.findElement(webdriver.By.name('btnG')).click();
driver.getTitle().then(function(title) {
  console.log(title);
});


That really performs in a synchronous manner such as this:

이것은 아래와 같이 동기화 방식으로 처리 됩니다.


driver.get(“http://www.google.com”).
    then(function() {
      return driver.findElement(webdriver.By.name('q'));
    }).
    then(function(q) {
      return q.sendKeys('webdriver');
    }).
    then(function() {
      return driver.findElement(webdriver.By.name('btnG'));
    }).
    then(function(btnG) {
      return btnG.click();
    }).
    then(function() {
      return driver.getTitle();
    }).
    then(function(title) {
      console.log(title);
    });


Behind the scenes of WebDriver, each call that interacts with the browser, such as get()findElement()sendKeys(), and click(), is being scheduled and pushed onto the WebDriver ControlFlow, allowing us to not have to worry about using .then() on the resulting promises (unless we specifically want the result returned by the call). 

WebDriver의 이면에서 get (), findElement (), sendKeys () 및 click ()과 같이 브라우저와 상호 작용하는 각 호출이 예약되고 WebDriver ControlFlow에 푸시되므로 resulting promises 에 대해 걱정할 필요가 없습니다 (호출에 의해 반환 된 결과가 특별히 필요하지 않는 한)


Using the WebDriverJS Promises



The ControlFlow queues functions based on promises. The following code exhibits how to take a callback based function and wrap it into WebDriver’s Promise API. We will be using the Restler NodeJS library.


ControlFlow 대기열 기능은 promises를 기반으로합니다. 아래 코드는 callback 기반 함수를 WebDriver의 Promise API로 래핑하는 방법을 보여줍니다. 우리는 Restler NodeJS 라이브러리를 사용할 것입니다.

To create a WebDriver/Protractor deferred using their promise API:

promise API를 사용하여 지연된 WebDriver / Protractor를 만들려면 :


deferred = protractor.promise.defer()


Then fullfill or reject the promise based on Restler’s events and return the deferred promise:


restler.postJson(url, requestData, options).once('success', function() {
  return deferred.fulfill();
}).once('error', function() {
  return deferred.reject();
}).once('fail', function() {
  return deferred.reject();
});
 
deferred.promise;


Pushing the Promise Onto the ControlFlow



To solve our problem of invoking a synchronous REST request, we have to interact with WebDriver’s ControlFlow. 

To get the instance of the ControlFlow that is shared with protractor:


synchronous REST request를 invoking하는 문제를 해결하려면 WebDriver의 ControlFlow와 상호 작용해야합니다.

Protractor와 공유되는 ControlFlow의 인스턴스를 얻으려면 :


var flow = browser.controlFlow()


Then we can use the ControlFlow’s execute() function, assuming we created a based on the above code that wraps restler’s callbacks and returns a WebDriverJS promise:


그런 다음 Restler의 콜백을 래핑하고 WebDriverJS 약속을 반환하는 위 코드를 기반으로 ControlFlow의 execute () 함수를 사용할 수 있다고 가정합니다.


flow.execute(restFunction)


Chaining Promises and Getting Results



The good news is that ControlFlow’s execute() function returns a new promise that will be fulfilled when our original promise is executed by the scheduler. We can use use the all() function, which returns a new promise once all of the control flow’s promises are fulfilled:

좋은 소식은 ControlFlow의 execute () 함수가 새 promise를 반환한다는 겁니다. 이렇게 함으로서 원래 약속이 스케줄러에 의해 실행될 때 수행 될 이 조건이 충족되게 됩니다. 모든 control flow의 promises가 충족 됐을 때 new promise 가 반환되는 all () 함수를 사용할 수 있습니다.


var allPromise = protractor.promise.all(flow.execute(restFunction1), flow.execute(restFunction2))



When allPromise is fulfilled, it will return an array of the results of all the promises passed to all() as arguments. 

allPromise가 수행되면 all ()에 전달 된 모든 promises의 결과 배열을 인수로 반환합니다.


Ideally the implementation of your helper functions would abstract the intermediary promises that are being passed to the ControlFlow and purely operate based upon the promises returned from the ControlFlow’s execute function.

이상적으로 helper 함수의 구현은 ControlFlow로 전달되는 intermediary promises을 abstract화하고 ControlFlow의 실행 함수에서 반환 된 promises를 기반으로 작동합니다.


저작자 표시 비영리 동일 조건 변경 허락
신고


Simple version of LED Light stand base for 3D crystal laser cube



I have Taj Mahal 3D crystal laser Cube.

You can get it from ebay also.





I found there are many stand bases for these kind of 3D crystal cube and it makes gorgeous view of it. like below.



So I've decided to develop it using Arduino.


The result is this.





This is the Source code.


/*

  For LED Light stand for 3D Crystal laser cube


  version : 0.4


  created 03 May 2017


  by Douglas Changsoo Park

*/


// Define Pins

#define RED1 3

#define GREEN1 4

#define BLUE1 5

#define RED2 6

#define GREEN2 7

#define BLUE2 8

#define delayTime 100


// define variables

int redValue1;

int greenValue1;

int blueValue1;

int redValue2;

int greenValue2;

int blueValue2;


void setup() {

  pinMode(RED1, OUTPUT);

  pinMode(GREEN1, OUTPUT);

  pinMode(BLUE1, OUTPUT);

  digitalWrite(RED1, HIGH);

  digitalWrite(GREEN1, HIGH);

  digitalWrite(BLUE1, HIGH);


  pinMode(RED2, OUTPUT);

  pinMode(GREEN2, OUTPUT);

  pinMode(BLUE2, OUTPUT);

  digitalWrite(RED2, HIGH);

  digitalWrite(GREEN2, HIGH);

  digitalWrite(BLUE2, HIGH);


  redValue1 = random(1, 255);

  greenValue1  = random(1, 255);

  blueValue1  = random(1, 255);

  redValue2 = random(1, 255);

  greenValue2  = random(1, 255);

  blueValue2  = random(1, 255);

}


void loop() {

  LEDLights(redValue1, greenValue1, blueValue1, redValue2, greenValue2, blueValue2);

  delay(delayTime * 4);

}


void LEDLights(int red1, int green1, int blue1, int red2, int green2, int blue2) {


  redValue1 = red1;

  greenValue1 = green1;

  blueValue1 = blue1;

  redValue2 = red2;

  greenValue2 = green2;

  blueValue2 = blue2;


  int redResult1 = randomValue(redValue1);

  int greenResult1 = randomValue(greenValue1);

  int blueResult1 = randomValue(blueValue1);


  int redResult2 = randomValue(redValue2);

  int greenResult2 = randomValue(greenValue2);

  int blueResult2 = randomValue(blueValue2);


  for (int i = 0; i < 25; i += 1) {

    analogWrite(RED1, redValue1 + redResult1);

    analogWrite(GREEN1, greenValue1 + greenResult1);

    analogWrite(BLUE1, blueValue1 + blueResult1);

    analogWrite(RED2, redValue2 + redResult2);

    analogWrite(GREEN2, greenValue2 + greenResult2);

    analogWrite(BLUE2, blueValue2 + blueResult2);


    redValue1 = redValue1 + redResult1;

    greenValue1 = greenValue1 + greenResult1;

    blueValue1 = blueValue1 + blueResult1;

    redValue2 = redValue2 + redResult2;

    greenValue2 = greenValue2 + greenResult2;

    blueValue2 = blueValue2 + blueResult2;


    delay(delayTime);

  }

}


int randomValue(int value) {

  int result;

  int minN;

  int maxN;


  int interval = random(1, 5);


  if (interval == 1) {

    minN = 26;

    maxN = 229;

  } else if (interval == 2) {

    minN = 51;

    maxN = 204;

  } else if (interval == 3) {

    minN = 76;

    maxN = 179;

  } else if (interval == 4) {

    minN = 101;

    maxN = 154;

  } else {

    minN = 126;

    maxN = 129;

  }


  if (value < minN) {

    result = interval;

  } else if (value > maxN) {

    result = -interval;

  } else {

    int randomVal = random(0, 1);

    if (randomVal == 0) {

      result = interval;

    } else {

      result = -interval;

    }

  }


  return result;

}




I wanted to make a combination and change of a more varied and softer color using random() in randomValue() function.


LEDLights() function will turn on and change the LED Light with the return value of the randomValue() function.


The loop() function will call the LED LIghts() function repeatedly every given time.


The components will be configured as below.





I've used Arduino Nano, 12V battery pack with 8 AAA batteries, 1 car charger adapter, small bread board and 2 RGB LEDs.


all parts are what I already have. 


It will cost about $ 15 for a new purchase.



Link to my project in hackster.


https://www.hackster.io/solkit/portable-led-light-stand-for-3d-crystal-laser-cube-5d8bd1







저작자 표시 비영리 동일 조건 변경 허락
신고


I don't like you

Practice scripting for the project 'I like you'


Source Code


/*

  For I don't like you. (practice project for the project 'I like you')


  version : 0.1


  created 07 May 2017


  by Douglas Changsoo Park

*/


#include <Servo.h>

#include <NewPing.h>


#define TRIGGER_PIN  12  // Arduino pin tied to trigger pin on the ultrasonic sensor.

#define ECHO_PIN     11  // Arduino pin tied to echo pin on the ultrasonic sensor.

#define MAX_DISTANCE 200 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.


NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance.

Servo myservo;//create servo object to control a servo


int distance;


void setup() {

  myservo.attach(9);//attachs the servo on pin 9 to servo object

  myservo.write(0);//back to 0 degrees 

  delay(1000);//wait for a second


  Serial.begin(9600); // Open serial monitor at 115200 baud to see ping results.

}


void loop() {

  delay(500);  // 

  unsigned int uS = sonar.ping(); // Send ping, get ping time in microseconds (uS).

  Serial.print("Ping: ");

  Serial.print(uS / US_ROUNDTRIP_CM); // Convert ping time to distance and print result (0 = outside set distance range, no ping echo)

  Serial.println("cm");

 

  distance = uS / US_ROUNDTRIP_CM;


  delay(500);

  // Servo motor moves when the distance is less than 5cm

  if (distance < 5 && distance != 0) {

    Serial.println("distance : ");

    Serial.println(distance); 

    myservo.write(90);//goes to 45 degrees 

    delay(500);

    myservo.write(-90);//goes to 45 degrees

    delay(500);

  }


}


==> Servo motor will move 90 degree and -90 degree when ultrasonic sensor detects object (person) in 5 cm.
Ultrasonic sonic sensor is going to be a pet's head so it looks like the pet is shaking his head because he doesn't like the person.

==> This is practice project of the project "I like you"
with the project, As you move, the pet will keep looking at you.
So the project name is "I like you" 

==> to do that I am planning to use 2 (or 3) ultrasonic sensor.

Anyway for the practice project "I don't like you", Arduino components should be configured as follows.



It will print the distance in 'cm' if it is run.




저작자 표시 비영리 동일 조건 변경 허락
신고

티스토리 툴바