* 워크숍 8일차 전체 동영상

 

 

* 스케쥴

 

 

* 누비슨 클라우드 관련 이슈

- 'The connection to the cloud server was lost' : 네트워크가 불안정할 때 발생 -> 재부팅 혹은 다른 네트워크 사용하기

 

- 모바일앱 프로퍼티가 나오지 않는 문제 : 재부팅 혹은 다른 컴퓨터에서 시도하기

 

- [공지] 오늘 저녁 6시 누비슨 대표님의 A/S가 예정되어 있습니다.

 

 

* Television - Smart Surveillance Camera with Telegram

- 발표자료 : [링크]

- 완성 소스 : git://git.tizen.org/apps/native/smart-surveillance-camera (브랜치 : television)

- 실습 소스 : git://git.tizen.org/apps/native/smart-surveillance-camera (브랜치 : television_dev)

- RPI에 추가 설치용 패키지

iotjs-1.0.0-99.armv7l.rpm.zip
0.32MB

- Camera State Diagram

 

- Camera APIs

 

 

- mmfw_camcorder_camera0.ini 초기파일

; < Camera/Camcorder Configure Control INI file >
;
; - Header List -
; 1.  Camera
; 2.  Strobe
; 3.  Effect
; 4.  Photograph
; 5.  Capture
; 6.  Detect
;
; - Note -
; If you want to add a new header,
; add a new enum value to "enum ConfigureCategoryControl"
; and new default table for it in mm_camcorder_configure.c/.h
;

[Camera]
; Input index - real setting value
;;; 0:PRIMARY_CAMERA, 1:SECONDARY_CAMERA
; Input index - MSL value(convert array index)
;;; -1:NONE, 0:CAMERA0, 1:CAMERA1
InputIndex = 0,-255 || 0
DeviceName = USB_CAMERA
PreviewResolution = 320,240 | 640,480 || 320,240
CaptureResolution = 320,240 | 640,480 || 640,480
VideoResolution = 320,240 | 640,480 || 640,480
FPS0 = 0,15,30 || 15
FPS1 = 0,15,30 || 15
; PictureForamt - MSL value
;;; 0:NV12, 1:NV12T, 2:NV16, 3:NV21, 4:YUYV, 5:UYVY, 6:422P, 7:I420, 8:YV12, 9:RGB565, 10:RGB888, 11:RGBA, 12:ARGB, 13:ENCODED, 14:INTERLEAVED_JPEG_UYVY, 15:ENCODED_H264
PictureFormat = 7 || 7
Overlay = 0,1 || 1
; Recommend display rotation
;;; 0:NONE, 1:90, 2:180, 3:270
RecommendDisplayRotation = 0
; Recommend preview format for capture
;;; 0:NV12, 1:NV12T, 2:NV16, 3:NV21, 4:YUYV, 5:UYVY, 6:422P, 7:I420, 8:YV12, 9:RGB565, 10:RGB888, 11:RGBA, 12:ARGB, 13:ENCODED, 14:INTERLEAVED_JPEG_UYVY, 15:ENCODED_H264
RecommendPreviewFormatCapture = 7
; Recommend preview format for record
;;; 0:NV12, 1:NV12T, 2:NV16, 3:NV21, 4:YUYV, 5:UYVY, 6:422P, 7:I420, 8:YV12, 9:RGB565, 10:RGB888, 11:RGBA, 12:ARGB, 13:ENCODED, 14:INTERLEAVED_JPEG_UYVY, 15:ENCODED_H264
RecommendPreviewFormatRecord = 7
; Recommend preview resolution
;;; 0: NORMAL ratio(4:3), 1: WIDE ratio(16:9), 2: SQUARE ratio(1:1)
RecommendPreviewResolution = 320,240 | 320,240 | 320,240 || 320,240
; Camera facing direction
;;; 0:REAR, 1:FRONT
FacingDirection = 0
FrameStabilityCount = 1


[Strobe]
;StrobeControl - Not support
;StrobeCapabilities - Not support
; Strobe mode - real setting value
;;; N/A
; Strobe mode - MSL value(convert array index)
;;; 0:OFF, 1:ON, 2:AUTO, 3:REDEYE_REDUCTION, 4:SLOW_SYNC, 5:FRONT_CURTAIN, 6:REAR_CURTAIN, 7:PERMANENT
StrobeMode = 0,-255,-255,-255,-255,-255,-255,-255 || 0
;StrobeStatus - Not support
;StrobeEV - Not support


[Effect]
Brightness = 0,8 || 4
;Contrast = 1,7 || 4
;Saturation = 0,4 || 2
;Sharpness = 0,4 || 2

; White balance - real setting value
;;; 0:AUTO, 1:DAYLIGHT, 2:CLOUDY, 3:TUNGSTEN, 4:FLUORESCENT
; White balance - MSL value(convert array index)
;;; 0:NONE, 1:AUTO, 2:DAYLIGHT, 3:CLOUDY, 4:FLUORESCENT, 5:INCANDESCENT, 6:SHADE, 7:HORIZON, 8:FLASH, 9:CUSTOM
WhiteBalance = -255,0,-255,-255,-255,-255,-255,-255,-255,-255 || 0

; Color tone - real setting value
;;; 1:NONE, 2:MONO, 3:SEPIA, 4:AQUA, 5:ANTIQUE, 6:NEGATIVE, 7:SHARPEN, 8:SKETCH, 9:WASHED, 10:VINTAGE_WARM
;;; 11:VINTAGE_COLD, 12:SOLARIZE, 13:POSTERIZE, 14:POINT_BLUE, 15:POINT_RED_YELLOW, 16:POINT_COLOR_3, 17:POINT_GREEN, 18:POINT_RED, 19:POINT_YELLOW, 20:CARTOONIZE
; Color tone - MSL value(convert array index)
;;; 0:NONE, 1:MONO, 2:SEPIA, 3:NEGATIVE, 4:BLUE, 5:GREEN, 6:AQUA, 7:VIOLET, 8:ORANGE, 9:GRAY, 10:RED,
;;; 11:ANTIQUE, 12:WARM, 13:PINK, 14:YELLOW, 15:PURPLE, 16:EMBOSS, 17:OUTLINE, 18:SOLARIZATION, 19:SKETCH, 20:WASHED,
;;; 21:VINTAGE_WARM, 22:VINTAGE_COLD, 23:POSTERIZATION, 24:CARTOON, 25:SELECTIVE_RED, 26:SELECTIVE_GREEN, 27:SELECTIVE_BLUE, 28:SELECTIVE_YELLOW, 29:SELECTIVE_RED_YELLOW
ColorTone = 1,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255 || 1
; Flip - real setting value
;;; 0:NONE, 1:VERTICAL, 2:HORIZONTAL
; Flip - MSL value(convert array index)
;;; 0:HORIZONTAL, 1:VERTICAL, 2:NONE
;Flip = 2,1,0 || 0

; Wide Dynamic Range - real setting value
;;; 0:OFF, 1:ON
; Wide Dynamic Range - MSL value(convert array index)
;;; 0:OFF, 1:ON, 2:AUTO
WDR = 0,-255,-255 || 0

; Part color mode - real setting value
;;; 0:OFF, 1:SWAP, 2:ACCENT
; Part color mode - MSL value(convert array index)
;;; 0:OFF, 1:SWAP, 2:ACCENT
;PartColorMode = 0,1,2 || 0

; Part color - real setting value
;;; 0:VIOLET, 1:PURPLE, 2:MAGENTA_1, 3:MAGENTA_2, 4:RED_1, 5:RED_2, 6:BROWN, 7:YELLOW, 8:GREEN_1, 9:GREEN_2, 10:GREEN_3,
;;; 11:GREEN_4, 12:COBALT, 13:CYAN, 14:BLUE_1, 15:BLUE_2, 16:GRAY
; Part color - MSL value(convert array index)
;;; 0:VIOLET, 1:PURPLE, 2:MAGENTA_1, 3:MAGENTA_2, 4:RED_1, 5:RED_2, 6:BROWN, 7:YELLOW, 8:GREEN_1, 9:GREEN_2, 10:GREEN_3,
;;; 11:GREEN_4, 12:COBALT_BLUE, 13:CYAN, 14:BLUE_1, 15:BLUE_2, 16:GRAY
;PartColor = 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 || 0


[Photograph]
;LensInit = 0,1 || 0
;DigitalZoom = 0,10 || 0
;OpticalZoom = 0,0 || 0

; Focus mode - real setting value
;;; 0:AUTO, 1:MANUAL, 2:PAN, 3:TOUCH_AUTO, 4:CONTINUOUS
; Focus mode - MSL value(convert array index)
;;; 0:NONE, 1:PAN, 2:AUTO, 3:MANUAL, 4:TOUCH_AUTO, 5:CONTINUOUS
FocusMode = 0,-255,-255,-255,-255,-255 || 0

; Auto focus type - real setting value
;;; 0:NORMAL, 1:MACRO, 2:FULL
; Auto focus - MSL value(convert array index)
;;; 0:NONE, 1:NORMAL, 2:MACRO, 3:FULL
AFType = 0,-255,-255,-255 || 0

; Auto exposure type - real setting value
;;; 0:BASE, 1:MATRIX, 2:CENTER, 3:SPOT, 4:MAX
; Auto exposure mode - MSL value(convert array index)
;;; 0,OFF 1,ALL 2,CENTER1  3,CENTER2 4,CENTER3 5,SPOT1 6,SPOT2 7,CUSTOM1 8,CUSTOM2
AEType = -255,0,-255,-255,-255,-255,-255,-255,-255 || 0

;ExposureValue - Not support
;FNumber - Not support
;ShutterSpeed - Not support

; ISO - real setting value
;;; 0:AUTO, 1:50, 2:100, 3:200, 4:400, 5:800, 6:1600
; ISO - MSL value(convert array index)
;;; 0:AUTO, 1:50, 2:100, 3:200, 4:400, 5:800, 6:1600, 7:3200
ISO = 0,-255,-255,-255,-255,-255,-255,-255 || 0

; Program mode - real setting value
;;; 1:NONE, 2:PORTRAIT, 3:NIGHTSHOT, 4:BACK_LIGHT, 5:LANDSCAPE, 6:SPORTS, 7:PARTY_INDOOR, 8:BEACH_SNOW, 9:SUNSET, 10:DUSK_DAWN,
;;; 11:FALL_COLOR, 12:FIREWORKS, 13:TEXT, 14:CANDLE_LIGHT
; Program mode - MSL value(convert array index)
;;; 0:NORMAL, 1:PORTRAIT, 2:LANDSCAPE, 3:SPORTS, 4:PARTY_N_INDOOR, 5:BEACH_N_INDOOR, 6:SUNSET, 7:DUSK_N_DAWN, 8:FALL_COLOR, 9:NIGHT_SCENE,
;;; 10:FIREWORK, 11:TEXT, 12:SHOW_WINDOW, 13:CANDLE_LIGHT, 14:BACKLIGHT
ProgramMode = 0,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255,-255 || 0

; Anti-handshake - real setting value
;;; 0:OFF, 1:ON
; Anti-handshake - MSL value(convert array index)
;;; 0:OFF, 1:ON, 2:AUTO, 3:MOVIE_ON
AntiHandshake = 0,-255,-255,-255 || 0

; Video-stabilization - real setting value
;;; 0:OFF, 1:ON
; Video-stabilization - MSL value(convert array index)
;;; 0:OFF, 1:ON
VideoStabilization = 0 || 0

; Face zoom mode
;;; 0:OFF, 1:ON
FaceZoomMode = 0 || 0
; Face zoom level
FaceZoomLevel = 0,0 || 0

; PTZ(Pan Tilt Zoom) type
;;; 0:Mechanical, 1:Electronic
;PtzType = 0,1 || 1

; Pan range for mechanical movement
;PanMecha = -10,10

; Pan range for electronic movement
;PanElec = -10,10

; Tilt range for mechanical movement
;TiltMecha = -10,10

; Tilt range for electronic movement
;TiltElec = -10,10


[Capture]
; Output mode
;;; No need to convert
;;; 0:NV12, 1:NV12T, 2:NV16, 3:NV21, 4:YUYV, 5:UYVY, 6:422P, 7:I420, 8:YV12, 9:RGB565, 10:RGB888, 11:RGBA, 12:ARGB, 13:ENCODED, 14:INTERLEAVED_JPEG_UYVY
OutputMode = 7,13 || 13
JpegQuality = 0,100 || 90
MultishotNumber = 1,1 || 1
SensorEncodedCapture = 0
; Support HDR
;;; 0: OFF, 1: ON, 2: ON and Original
SupportHDR = 0,-255,-255 || 0
FrameStabilityCount = 2


[Detect]
; Detect mode
;;; 0:OFF, 1:ON
DetectMode = 0,-255 || 0
;DetectNumber - Not support
;DetectFocusSelect - Not support
;DetectSelectNumber - Not support
;DetectStatus - Not support

 

* 워크숍 7일차 전체 동영상

 

 

* 실습 준비 : 조도센서로 조도 측정하기 [링크]

 

 

* 스케쥴

 

 

* 타이젠 스튜디오에 로그가 나오지 않는 문제 : [링크]

 

 

* SDTA7D SPI 업데이트 하기 : [링크]

 

 

* 누비슨 관련 공지사항

- 계정 : [슬랙채널]

- 관련내용 : [소스가 포함된 링크]

 

 

* thingpark Cloud with Tizen

- 발표자료

Thingspark IoT Cloud 연동-20190907.pdf
2.25MB

- 소스 : [링크]

 

 

 

 

 

* 타이젠 스튜디오 설치 중 문제점 발견시

- C:\Users\{user}\AppData\Local\.package-manager\install-log

  위의 위치에서 로그를 추출해주세요.

 

* 타이젠 스튜디오에서 인증서 생성 중 문제점 발견시

- C:\Users\{user}\SamsungCertificate

위의 위치에 저장된 정보를 추출해주세요.

 

* 타이젠 스튜디오 사용 중 문제점 발견시

- {tizen-studio-data}\{tool}\logs\

  위의 위치에서 로그를 추출해주세요.

 

* 타이젠 스튜디오에서 로그가 나오지 않는 문제

- 라즈베리파이에서 아래 명령어를 실행해주세요.

# dlogutil -c

 

* 워크숍 6일차 전체 동영상

 

 

* 스케쥴

 

 

* Nubison Cloud with Tizen

- 소스 : [링크]

- 발표자료

심플랫폼_해커톤 발표자료.pdf
3.98MB

 

 

 

 

 

 

 

 

* 누비슨 관련 공지사항

- 계정 : [슬랙채널]

- 소스 : [링크]

- 대상자 : [브라우저 혹은 모바일] 센싱 데이터 확인 및 액츄에이터 제어

- 클라우드 메뉴

 

- 프로젝트의 유닛 : 사용 API, 유닛 번호(':'으로 구분)

 

- 클라우드 드라이버 만들기 : RPI에서 보내는 데이터를 어떻게 파싱할 것인가?

- 드라이버 동기화

 

- 데이터뷰

 

- 모니터링 시스템

 

- 모바일 앱

 

- 라이브러리 : libnubioniotif.a(왜 소스가 없는가? (자산/보안)

 

- 콜백 함수 : Nubison -> RPI3

#define IF_QUERY_CALLBACK_FN void (*query_nubicb)(char *, char *,char *)		// 조회
#define IF_INVOKE_CALLBACK_FN void (*invoke_nubicb)(char *, char *,char *)		// 설정
#define IF_SETTING_CALLBACK_FN void (*setting_nubicb)(char *, char *,char *)		// 제어
#define IF_CHECK_CALLBACK_FN void (*check_nubicb)(char *, char *,char *)
#define IF_AUTHO_CALLBACK_FN void (*auth_nubicb)(int )

 

- 다중 데이터 보내기 : RPI3 -> Nubison

	// sendData를 String 자료형 변수로 저장하여 보내주세요.
	char tmp[BUFSIZE] = {0, };
	sprintf(tmp, "%d:%d", led0, led1);

	// 클라우드에서 조회 요청이 왔을때 관련된내용을 담아서 전달 함
	// 관련해서 정확히 DB에 Unit 별로 들어 게 하는 것은 클라우드 서버에서 Driver로 셋팅함
	cloudif->SendtoCloud(tmp, TYPE_STRING, api, uniqkey);

 

- 노티 함수 : RPI3 -> Nubison

void NotitoCloud(char *sdata, char *type, char* uniqKey,int min_term);

 

 

* 누비슨 클라우드 관련 이슈

- 'The connection to the cloud server was lost' : 네트워크가 불안정할 때 발생 -> 재부팅 혹은 다른 네트워크 사용하기

 

- 모바일앱 프로퍼티가 나오지 않는 문제 : 재부팅 혹은 다른 컴퓨터에서 시도하기

 

 

올해도 어김없이 Samsung Developer Conference가 샌프란시스코에서 열립니다.

 

일정 : '19. 10. 29(화) ~ 30(수)

장소 : 샌프란시스코 산 호세 컨벤션 센터

홈피 : https://www.samsungdeveloperconference.com/

 

 

타이젠 개발자들을 위해 반액 할인이 적용되는 개발자 프로모션 코드를 공유합니다.

필요하신 분은 1) 댓글 혹은 2) 메일로 메일주소를 남겨주세요.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

[여기]에서도 보실 수 있습니다.

 

 

* 워크숍 5일차 전체 동영상

5일차에는 내부 사정상 동영상을 제공하지 않습니다.

 

 

* 스케쥴

 

 

* GPIO 강의 [링크]

- 소스코드 다운로드 : git clone -b basic-interrupted https://git.tizen.org/cgit/apps/native/st-things-light   

  (각각의 실습 후에 application을 종료하거나 삭제해주세요.)

 

 

* I2C 강의 [링크]

- 소스코드 다운로드 : git clone -b illuminance https://git.tizen.org/cgit/apps/native/rcc illuminance

  (각각의 실습 후에 application을 종료하거나 삭제해주세요.)

 

 

* SPI 강의 [링크]

- 소스코드 다운로드 : git clone https://github.com/jay4peace/tizeniot_pio_spi.git   

  (각각의 실습 후에 application을 종료하거나 삭제해주세요.)

 

 

* 실습 강의 영상

 

 

* 유용한 커멘드

※ 라즈베리파이 시리얼 터미널이나 SDB shell에서 실행하는 명령어입니다.

- 설치된 application 패키지 확인

pkgcmd -l -t tpk

 

- 설치된 application 패키지 삭제 

pkgcmd -u -n {pkg_id} 

 

- 설치된 application 실행

app_launcher -s {app_id} 

 

실행 중인 application 확인 

app_launcher -S 

 

- 실행 중인 application 종료 

app_launcher -t {app_id} 

 

- 라즈베리파이 리부팅

reboot

 

 

* 타이젠 스튜디오에 로그가 안나오는 문제 임시로 해결하는 방법

- 라즈베리파이 터미널에서 dlogutil -c 실행

 

 

* SmartThings with Tizen

- Overview

 

- Smartthings 개발자 가이드 : [링크]

 

- Smartthings 개발자 워크스페이스 : [링크]


 

 

 

 

 

 

G Camp 홍보 이미지

 

 

* 1일차 동영상

 

 

* 기존의 '플랫폼 + 제어컨트롤러' 예시

- 자율주행 자동차 : https://comma.ai, 안드로이드 + MCU with 블루투스

사이트 설명 중

 

- 케이블 테스트 머신 : 코드주 제품, 제어부, 통신부 분리

- 초고온 측정 시스템 : 코드주 제품, 안드로이드 + MCU with BUS(?), https://youtu.be/ZlssLOXRJXM

- 스마트 에어모니터 : 코드주 제품, 안드로이드 + MCU with USB

 

 

* Mbed OS(= Arduino) 

- https://mbed.com 

 

Home | Mbed

The Arm® Mbed™ IoT Device Platform provides the operating system, cloud services, tools and developer ecosystem to make the creation and deployment of commercial, standards-based IoT solutions possible at scale.

www.mbed.com

- RTOS 지원

- OS 수준으로 File System 등 지원

- Mbed TLS로 보안 지원

 

* Mbed Web Compiler

https://os.mbed.com/ 가입

 

 

* Mbed CLI : https://os.mbed.com/docs/mbed-os/v5.13/tools/installation-and-setup.html

- 파이썬 버전 충돌로 인해 환경설정이 중첩되는 문제 발생

- 기본 소스

 

 

* NUCLEO-F429ZI

 

 

* Mbed OS Architecture

 

 

* API :  https://os.mbed.com/docs/mbed-os/v5.13/apis/index.html

 

Full API list - APIs | Mbed OS 5 Documentation

This site uses cookies to store information on your computer. By continuing to use our site, you consent to our cookies. If you are not happy with the use of these cookies, please review our Cookie Policy to learn how they can be disabled. By disabling coo

os.mbed.com

 

 

* YouTube : Mbed Office Hour

 

 

* L9110s : 바퀴 2개 자동차

 

* 2일차 동영상

 

 

* 첫번째 연습 : Mbed <-> Tizen I2C로 연동하기

- Mbed I2C Slave 소스

mbed.c
0.00MB

#include <mbed.h>

#if !DEVICE_I2CSLAVE
  #error [NOT_SUPPORTED] I2C Slave is not supported
#endif

I2CSlave slave(PB_9, PB_8);

int main() {
   char buf[10] = {0,};
   char rbuf[2] = {0,};
   char msg[] = "Slave!";
   char k = 0;
   
   //wait_us(50); // to mbed devices
   wait_us(500); // to RPI3

   printf("mbed-os-example\n\r");

   slave.frequency(100000);//100Khz
   slave.address(0xA0);

   while (1) {
       int i = slave.receive(); // blocking
       switch (i) {
           case I2CSlave::ReadAddressed:
               slave.write(buf, 2); // Includes null char
               buf[0] = k++;
               buf[1] = k++;
               
               if (buf[0] == 0xFF)
                    buf[0] = 0x0;
               if (buf[1] == 0xFF)
                    buf[1] = 0x0;

               break;
           case I2CSlave::WriteGeneral:
               //slave.read(buf, 10);
               //printf("Read G: %s\n", buf);
               break;
           case I2CSlave::WriteAddressed:
               slave.read(rbuf, 1);
               //printf("Read A: %s\n", buf);
               break;
       }
   }
}

 

 

- Tizen I2C Master 소스

  소스 다운로드 : git clone https://git.tizen.org/cgit/apps/native/rcc illuminance -b illuminance 

  위의 소스에서 'resource_illuminance_sensor.c'만 바꿔주세요.

tizen.c
0.00MB

/*
 * Copyright (c) 2018 Samsung Electronics Co., Ltd.
 *
 * Contact: Jin Yoon <jinny.yoon@samsung.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an AS IS BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdlib.h>
#include <unistd.h>
#include <peripheral_io.h>
#include <sys/time.h>

#include "log.h"
#include "resource_internal.h"

#define I2C_PIN_MAX 28
/* I2C */
#define GY30_ADDR (0xA0>>1) /* MBED Addr */

#define GY30_CONT_HIGH_RES_MODE 0x10 /* Start measurement at 11x resolution. Measurement time is approx 120mx */
#define GY30_CONSTANT_NUM (1.2)

static struct {
	int opened;
	peripheral_i2c_h sensor_h;
} resource_sensor_s;

void resource_close_illuminance_sensor(void)
{
	if (!resource_sensor_s.opened)
		return;

	_I("Illuminance Sensor is finishing...");
	peripheral_i2c_close(resource_sensor_s.sensor_h);
	resource_sensor_s.opened = 0;
}

int resource_read_illuminance_sensor(int i2c_bus, uint32_t *out_value)
{
	int ret = PERIPHERAL_ERROR_NONE;
	static int write = 0;
	static int count = 0;
	unsigned char buf[10] = { 0, };
	unsigned char cbuf[10] = { 0, };

	if (!resource_sensor_s.opened) {
		ret = peripheral_i2c_open(i2c_bus, GY30_ADDR, &resource_sensor_s.sensor_h);
		if (ret != PERIPHERAL_ERROR_NONE) {
			_E("i2c open error : %s", get_error_message(ret));
			return -1;
		}
		resource_sensor_s.opened = 1;
		write = 0;
	}

	cbuf[0] = 0x10;

	if (!write) {
		ret = peripheral_i2c_write(resource_sensor_s.sensor_h, buf, 1);
		if (ret != PERIPHERAL_ERROR_NONE) {
			_E("i2c write error : %s", get_error_message(ret));
			return -1;
		}
		write = 1;
	}

	ret = peripheral_i2c_read(resource_sensor_s.sensor_h, buf, 2);
	if (ret != PERIPHERAL_ERROR_NONE) {
		_E("i2c read error : %s", get_error_message(ret));
		return -1;
	}

	_D("READ : 0x%2X 0x%2X, count : %d", buf[0], buf[1], count++);

	*out_value = (buf[0] << 8 | buf[1]) / GY30_CONSTANT_NUM; // Just Sum High 8bit and Low 8bit

	return 0;
}

 

 

 

* 두번째 연습 : Mbed <-> Tizen I2C + GPIO로 연동하기

- Mbed 소스

mbed.c
0.00MB

#include "mbed.h"

#if !DEVICE_I2CSLAVE
  #error [NOT_SUPPORTED] I2C Slave is not supported
#endif

I2CSlave slave(PB_9, PB_8);
DigitalOut led1(LED1);
InterruptIn mybutton(USER_BUTTON);
DigitalOut _check(PC_6);

void pressed()
{
//    printf("button pressed event!!\r\n");
    _check = 0;
    led1 = !led1;
}


int main() {
   char buf[3];
   char msg[] = "Slave!";

   buf[0] = 0x1A;
   buf[1] = 0xFF;
   
   //wait_us(50);  //to mbed devices
   wait_us(500);   //to RaspberryPi
   
//   printf("hello world\r\n");
   
   slave.frequency(400000);
   slave.address(0xA0);
   _check = 1;
   
   mybutton.fall(&pressed);
   
   while (1) {
//       wait(1.0f);            
              
       int i = slave.receive();
       switch (i) {
           case I2CSlave::ReadAddressed:
               _check = 1; 
//               slave.write(msg, strlen(msg) + 1); // Includes null char
               slave.write(buf, 2);
 //              printf("Write A: %s\r\n",msg);
               _check = 1;
               break;
           case I2CSlave::WriteGeneral:
               slave.read(buf, 10);
//               printf("Read G: %s\n", buf);
               break;
           case I2CSlave::WriteAddressed:
               slave.read(buf, 2);
//               printf("Read A: %s\n", buf);
               _check = 1;
               break;
       }
//       for(int i = 0; i < 10; i++) buf[i] = 0;    // Clear buffer

   }
}

 

- 타이젠 소스

  git clone https://git.tizen.org/cgit/apps/native/st-things-light -b basic-interrupted st-things-light-basic-interrupted

tizen-mbed-final.zip
0.75MB

  1. 장병남 2019.08.28 17:38 신고

    MbedOS I2CSlave의 경우 Sync 방식으로 동작되기 때문에 ASync 방식으로 동작시키려면
    RTOS Thread를 이용해야 합니다. 예제는 Main Thread와 Slave Thread 두개로 분리해서
    간단하게 만들었습니다.
    여기에 글을 남기면 강의에 참석하신 분들이
    참고하실수 있으실것 같아서 댓글로 남깁니다.

    #include "mbed.h"

    I2CSlave slave(PB_9, PB_8);
    DigitalOut led1(LED1);
    DigitalOut led2(LED2);

    char buf[2];
    char rbuf[2];

    void start_slave(){
    slave.address(0xA0);

    while(1) {
    int i = slave.receive();
    switch (i) {
    case I2CSlave::ReadAddressed:
    slave.write(buf, 2);
    break;
    case I2CSlave::WriteGeneral:
    // printf("Read G: %s\n", buf);
    break;
    case I2CSlave::WriteAddressed:
    slave.read(rbuf, 1);
    break;
    }
    led2=!led2;
    }
    }

    int main() {
    Thread slave_thread(osPriorityLow); //very important
    slave_thread.start(&start_slave);

    while(1){
    //Main Thread Job(1)
    //Your Code Here
    printf("hello world\r\n";);
    wait(1.0f);
    led1=!led1;
    }
    }

 

 

* 스케쥴

 

 

* LiDAR & 미세먼지 센서 동영상

 

 

* 사례 공유 : LiDAR 센서

- 발표자 : 타이젠 스페셜리스트 방진석 연구원

- RPI3 Model B+ 보드 기반

- LiDAR 센서 발표자료

tizen 교육-gcamp-lidar.pdf
2.23MB

 

- LiDAR 센서 소스코드

LiDAR_Distance_I2C.zip
0.15MB

- LiDAR 센서 핀맵

발표자료 중

 

 

- LiDAR 읽고 쓰기 위한 비트 전달

발표자료 중

 

 

 

- OLED 핀맵

발표자료 중

 

 

- OLED 주소

발표자료 중

 

 

- OLED 비트 단위 전달

발표자료 중

 

 

- OLED Page당 8비트

발표자료 중

 

 

 

* 사례공유 : 미세먼지 센서

- 발표자 : 타이젠 스페셜리스트 방진석 연구원

- SDTA7D 보드 기반

- 미세먼지 센서 발표자료

tizen sdta7d uart 예제.pdf
0.69MB

 

- 미세먼지 센서 소스코드

DUST_UART.zip
0.21MB

 

- UART RX 테스트 프로그램 : 시리얼 포트, TCP/IP, UDP/IP 터미널 프로그램 (시리얼 통신 프로그램)

 

- SDTA7D와 먼지센서를 연결하기

발표자료 중

 

 

- UART 핸들 열기

발표자료 중

 

- 먼지센서 출력 데이터

발표자료 중

 

 

* 사례 공유 : 서보모터 

- 동영상

 

- 발표자 : 다인시스 안효복 대표

- SDTA7D 보드 기반

- 참고자료

DSA5101_Tizen_DeviceDriver-r10.zip
8.37MB

 

 

- 블루투스 아키텍처

발표자료 중

 

 

- 와이파이 아키텍처

발표자료 중

 

 

- 문자 디바이스 드라이버 등록 함수 예시

발표자료 중

 

 

- I2C Peripheral Bus

발표자료 중

 

 

- PWM

발표자료 중

 

 

- Servo Motor 연결하기

발표자료 중

 

 

 

 

* 공지사항 & 스케쥴 & 타이젠스튜디오 피드백  동영상

 

 

* 공지사항

- 타이젠 스페셜리스트 선정 : https://developer.tizen.org/blog/tizen-specialist-program

 

- 후보 저장소 : RCC

  git clone ssh://[YOUR_ID]@review.tizen.org:29418/apps/native/rcc

 

 

* 스케쥴

- 타이젠 스튜디오 설치&실행 문제 점검 : 타이젠 스튜디오팀 최종우 연구원, 유지호 연구원

- 타이젠 앱 메인루프 강의 : 타이젠팀 박춘언 연구원

- GPIO 이론 & 실습 : 타이젠팀 손보연 연구원

- I2C 이론 & 실습 : 타이젠팀 윤진 연구원

- SPI 이론 & 실습 : 타이젠팀 박정훈 연구원

 

 

* 타이젠 스튜디오 설치&실행 문제 점검

- 지난 시간에 발견된 문제들

  1) 타이젠 스튜디오 설치 후 '시작' 메뉴에 아이콘이 추가되지 않는 문제

  2) 타이젠 스튜디오 대신 이클립스를 실행해야 하는 문제

  3) 신규 인증서(개발자&배포자)를 생성할 수 없는 문제

  4) 앱 설치시 개발자/배포자 인증서의 비밀번호를 요구하는 문제

      {tizen_studio_path}\tools\certificate-encryptor\wincrypt 존재 여부 확인 필요

  5) 타이젠 스튜디오에 라즈베리파이의 로그가 나오지 않는 문제

 

타이젠 스튜디오 설치 중 문제점 발견시

  C:\Users\{user}\AppData\Local\.package-manager\install-log

  위의 위치에서 로그를 추출해주세요.

 

타이젠 스튜디오에서 인증서 생성 중 문제점 발견시

  C:\Users\{user}\SamsungCertificate

 위의 위치에 저장된 정보를 추출해주세요.

 

타이젠 스튜디오 사용 중 문제점 발견시

  {tizen-studio-data}\{tool}\logs\

  위의 위치에서 로그를 추출해주세요.

 

 

* 타이젠 메인루프 강의

- 동영상

 

- 발표자료

Tizen Main-Loop 이해.pdf
0.44MB

 

- 메인루프 진행 추상화 : 이벤트 대기 -> 이벤트 처리 -> UI 객체 업데이트 -> 화면 갱신

- Event-Driven

- Tizen App Life-Cycle & Main-Loop

발표자료 중

- Ecore Main Loop

발표자료 중

- Ecore Job

발표자료 중

- Ecore Thread

발표자료 중

 

- Ecore FD Handler

 

 

* GPIO & I2C & SPI 동영상

 

 

GPIO 이론 & 실습 

- 참고자료 : http://tizenschool.org/tutorial/154

- Motion Sensor Trigger Mode

발표자료 중

 

 

 

 

I2C 이론 & 실습 

- 참고자료 : http://tizenschool.org/tutorial/153

- I2C 인터페이스 다이어그램

발표자료 중

- 데이터 쓰기

발표자료 중

 

- 데이터 읽기

발표자료 중

 

 

* SPI 이론 & 실습 

- 참고자료 : http://tizenschool.org/tutorial/152

- 아날로그-디지털 변환 : 수학적 적분

발표자료 중

 

- SPI 인터페이스 다이어그램

발표자료 중

 

- Master <-> Slave 데이터 교환

발표자료 중

 

- MCP3008 비트 단위 교환

 

 

* 워크숍 2일차 전체 동영상 : 4시간 분량

 

- Arm M시리즈

  마이컴 == 마이크로 컨트롤러 == MCU(Micro Controller Unit)

  마이컴 = 마이크로 프로세서 + 입출력 제어 모듈 + 램 + 저장장치

  메모리 : MMU나 MPU 없이 직접 접근

  OS : FreeRTOS가 올라가는 수준

  보드 : 아두이노 혹은 오렌지보드

 

- Arm R시리즈 

  메모리 : 100~200MB 램, MPU(Memory Protection Unit)로 CPU에 내장된 메모리를 관리.

    (메모리를 파티셔닝하여 구획별로 관리하지만, 가상 메모리가 없기에 프로그램에서 직접 물리주소 관리.)

  OS : Real Time OS

  

- Arm A시리즈

  AP : Application Processor

  메모리 : MMU(Memory Management Unit)로 MPU의 모든 기능 + Virtual Memory

    1) Memory fragmentation 활용 가능

    2) 메모리 최대 크기보다 큰 앱 로딩 가능

    (참고 : https://jhkim3624.tistory.com/m/75)

 

- 퓨징 :  eMMC와 같은 플래시 메모리에 0 혹은 1을 새기는 행위.

  (참고 : https://kldp.org/node/101280)

 

- Boot  Mode Selection : Serial로 부팅하거나 외부 메모리로 부팅 가능

 

- J7 Peripheral : 타이젠에 맞게 포팅된 핀

 

- NXP : SDTA7D에서 사용하는 칩인 i.MX7의 메이커

  (참고 : https://www.nxp.com/)

 

- Nexell : Anchor 시리즈에서 사용하는 칩인 NXP3225의 메이커 

  (참고 : http://www.nexell.co.kr/)  

 

- USB Type C : 전원, USB SDB 디버그, USB Mass Storage

 

- USB OTG : Console. 115200, 8 Bits, No parity

 

- Linux GPIO Number = (GPIO_BANK - 1) * 32 + GPIO_BIT

 

- U Boot : Universal Boot. 

  CPU, Memory, Peripherals, Console 등 하드웨어 장치를 초기화하기 위한 임베디드용 부트로더(BIOS와 유사)

  OS가 부팅된 이후에는 더 이상 사용되지 않는다

 

- imx_usb_loader : USB Serial을 통해 부트로드를 보드의 SRAM으로 다운로드해주는 도구

 

- SPL : i.MX7을 위한 가장 기본적인 초기화 작업용

 

- 부팅 중에 램디스크를 사용하는 이유? https://developer.ibm.com/articles/l-initrd/

사이트 캡처

 

- DFU(Device Firmware Upgrade Utilities) : http://dfu-util.sourceforge.net/

 

- lsblk : lists information about all or the specified block devices.

  The lsblk command reads the sysfs filesystem to gather information. 

  (참고 : http://manpages.ubuntu.com/manpages/trusty/man8/lsblk.8.html)

 

- extlinux : EXTLINUX is a Syslinux variant which boots from a Linux filesystem.

  (참고 : https://wiki.syslinux.org/wiki/index.php?title=EXTLINUX)

 

- Trap : https://stackoverflow.com/questions/3149175/what-is-the-difference-between-trap-and-interrupt

 

발표자료 중
발표자료 중

 

- 플랫폼 디바이스는 언제 쓰이는지? 디바이스 트리 & 디바이스 드라이버와 함께 엮어 설명해주세요.

 

 

* 일정

 

* SDTA7D 보드 소개

- 발표자 : 시그마델타 테그놀로지 윤지원 대표

  (공식 사이트 : https://www.sigma-delta.tech)

- 발표자료 : 용량이 커서 두 개의 파일로 분할압축하였습니다.

[SDT] Seoul Hardware Hackathon.vol1.egg
10.00MB
[SDT] Seoul Hardware Hackathon.vol2.egg
9.15MB

 

발표자료 중

 

- 보드 이름 : SDTA7D(Sigma Delta Technologies Arm Coretex-A7 Dual)

- 보드 구매처 : http://www.devicemart.co.kr/goods/view?no=12220510

- 보드 외형

- 보드 사양

  ① CPU - i.MX7D

      High-performance Arm® Cortex®-A7 dual core

      Real-time processing Arm® Cortex®-M4 sub core (Free RTOS용)

  ② Memory

      512MB DDR3L (1600Mbps)

      8GB eMMC (5.0) flash memory

  ③ Low Power Consumption PMIC - PF3000

      1V35, 1V5, 1V8, 3V3 output

      Coin cell charger : RTC를 위한 코인 배터리를 충전하기 위한 목적으로 사용

      OTP memory : One Time Programmable Memory로 Ethernet의 MAC Addr.를 저장하기 위한 목적으로 사용

  ④ Secure Element (SE)

      For Key & Certification

      Includes every Secure Information

  ⑤ OS Support

      Arm Mbed Linux OS

      Tizen Platform 

  ⑥ Serial Peripherals

      UART, SPI, I2C, PWM, ADC, GPIO

      Dual CAN

      RGMII for 1Gbps Ethernet

      USB Host, USB OTG

      PCIe, SD I/O

      MIPI CSI for camera

      MIPI DSI for display

 

- 보드 외형

  USB Host & USB OTG 차이 : https://www.quora.com/What-is-the-difference-between-USB-host-VS-USB-OTG

 

- 보드 핀맵 : 확대해서 보세요.

  상단과 중단에 CSPI3_SLCK / CSPI3_MOSI / CSPI3_MISO 핀이 두 개씩 존재 : Mikroe 보드(https://www.mikroe.com/weather-click)를 지원하려는 목적

 

- 핀 번호 :   Tizen Port Map에 명시된 숫자를 사용하면 됩니다.

 

 

 

* 타이젠 드라이버 포팅하기

- 강의 : 다인시스 안효복 대표

- 강의자료

DSA5101_Tizen_DeviceDriver.pdf
9.27MB

 

 

* SDTA7D 보드에 타이젠 이미지를 플래싱하기

- 참고자료 : 

User Guide - Tizen on SDTA7D.pdf
0.43MB

 

- [이미 만들어진 이미지 사용하기] SDTA7D용 이미지 파일용 저장소 : 여기

  부트 이미지 : 다운로드

  플랫폼 이미지 : 다운로드

 

SigmaDeltaTechnologiesInc/sdta7d-images

Tizen sdta7d image repository. Contribute to SigmaDeltaTechnologiesInc/sdta7d-images development by creating an account on GitHub.

github.com

 

 

- [이미지 직접 만들기] 주요 소스 : github에서 클론하기

  U Boot : https://github.com/SigmaDeltaTechnologiesInc/u-boot.git

  Kernel : https://github.com/SigmaDeltaTechnologiesInc/linux-stable.git

  Building Block : https://github.com/SigmaDeltaTechnologiesInc/building-blocks.git

  Peripheral Bus : https://github.com/SigmaDeltaTechnologiesInc/peripheral-bus.git

  Peripheral I/O : https://github.com/SigmaDeltaTechnologiesInc/peripheral-io.git

  Systemd : https://github.com/SigmaDeltaTechnologiesInc/systemd.git

  SmartThings Plugin : https://github.com/SigmaDeltaTechnologiesInc/smartthing-plugin.git

  WiFi : https://github.com/SigmaDeltaTechnologiesInc/wlandrv-plugin-tizen-ap6335.git

  Bluetooth : https://github.com/SigmaDeltaTechnologiesInc/bluetooth-firmware-bcm.git

 

- [이미지 직접 만들기] gbs 빌드를 위한 설정 파일 : .gbsSdta7d.conf

GBS빌드.zip
0.00MB

 

- [이미지 직접 만들기] gbs로 위의 소스들을 빌드하기

$ sudo gbs -c ~/.gbsSdta7d.conf build -A armv7l --include-all

 

- [이미지 직접 만들기] 킥스타터 다운로드 : 타이젠 이미지 생성 과정에서 운영체제가 필요로 하는 질문을 자동으로 응답하게 해주는 파일

  tizen-unified_iot-boot-armv7l-sdta7d.ks : [다운로드]

...더보기

# -*-mic2-options-*- -A armv7l -f loop --pack-to=@NAME@.tar.gz -*-mic2-options-*- 

 
# Do not Edit! Generated by: 
kickstarter.py 
 

lang en_US.UTF-8 
keyboard us 
timezone --utc America/Los_Angeles 
part /lib/modules --fstype="ext4" --size=50 --ondisk=mmcblk0 --active --label modules --fsoptions=defaults,noatime 


rootpw tizen  
xconfig --startxonboot 
bootloader  --timeout=3  --append="rw vga=current splash rootwait rootfstype=ext4"   --ptable=gpt --menus="install:Wipe and Install:systemd.unit=system-installer.service:test" 

desktop --autologinuser=guest   
user --name guest  --groups audio,video --password 'tizen' 

repo --name=local --baseurl=file:///home/segaon/GBS-ARTIK-ROOT/tizen_artik5/local/repos/tizen_artik5/armv7l/ --priority=1 

repo --name=unified-standard --baseurl=http://download.tizen.org/releases/milestone/tizen/unified/tizen-unified_20181024.1/repos/standard/packages/ --ssl_verify=no 

%packages 

# @ IoT Boot sdta7d 
sdta7d-linux-kernel 
sdta7d-linux-kernel-modules 
u-boot-sdta7d 
# Others 




%end 


%attachment 
/boot/u-boot/SPL 
/boot/u-boot/u-boot.img 
/boot/zImage 
/boot/sdta7d.dtb 
%end 

%post 

%end 

%post --nochroot 

%end 

%runscript 

%end

 

  tizen-unified_iot-headless-2parts-armv7l-sdta7d.ks : [다운로드]

...더보기

# -*-mic2-options-*- -A armv7l -f loop --pack-to=@NAME@.tar.gz -*-mic2-options-*- 

 
# Do not Edit! Generated by: 
kickstarter.py 
 

lang C 
keyboard us 
timezone --utc America/Los_Angeles 
part / --size=1000 --ondisk mmcblk0p --fstype=ext4 --label=rootfs --extoptions="-J size=16" 
part /opt/ --size=512 --ondisk mmcblk0p --fstype=ext4 --label=system-data --extoptions="-m 0" 
part /mnt/initrd --size=7 --ondisk mmcblk0p --fstype=ext4 --label=ramdisk --extoptions="-b 1024" 
part /mnt/initrd-recovery --size=12 --ondisk mmcblk0p --fstype=ext4 --label=ramdisk-recovery --extoptions="-b 1024 -O ^has_journal" 


rootpw tizen  
xconfig --startxonboot 
bootloader  --timeout=3  --append="rw vga=current splash rootwait rootfstype=ext4"   --ptable=gpt --menus="install:Wipe and Install:systemd.unit=system-installer.service:test" 

desktop --autologinuser=guest   
user --name guest  --groups audio,video --password 'tizen' 


repo --name=local --baseurl=file:///home/segaon/GBS-ARTIK-ROOT/tizen_artik5/local/repos/tizen_artik5/armv7l/ --priority=1 

repo --name=unified-standard --baseurl=http://download.tizen.org/releases/milestone/tizen/unified/tizen-unified_20181024.1/repos/standard/packages/ --ssl_verify=no 
repo --name=base-standard --baseurl=http://download.tizen.org/releases/milestone/tizen/base/tizen-base_20180928.1/repos/standard/packages/ --ssl_verify=no 

%packages 

# @ IoT Headless Base 
building-blocks-root-Preset_iot_core 
building-blocks-sub1-domain_Feature-Recovery 
building-blocks-sub1-domain_Feature-Smartthings_App 
dbus-tools 
system-plugin-feature-namespace 
system-plugin-feature-session-bind 
# @ IoT Adaptation Sdta7d Headless 
building-blocks-sub1-Preset_boards-SDTA7D 
building-blocks-sub1-Preset_partition-2parts_ramdisk 
building-blocks-sub1-domain_Feature-Resource_manager_Headless 
building-blocks-sub1-domain_Feature-Upgrade 
building-blocks-sub2-Preset_boards-SDTA7D-Audio 
building-blocks-sub2-Preset_boards-SDTA7D-BLE 
building-blocks-sub2-Preset_boards-SDTA7D-Bluetooth 
#building-blocks-sub2-Preset_boards-SDTA7D-Display_Headless 
building-blocks-sub2-Preset_boards-SDTA7D-Wifi 
building-blocks-sub2-domain_API-AppFramework-TPK_Installation 
building-blocks-sub2-domain_API-Base-Utils 
building-blocks-sub2-domain_API-Multimedia-Player 
building-blocks-sub2-domain_API-Network-Bluetooth_Media_Audio 
building-blocks-sub2-domain_API-Network-Curl 
capi-network-wifi-manager-tool 
system-plugin-config-env-headless 
# Others 
wlandrv-plugin-tizen-ap6335 
smartthing-plugin 

%end 



%post 
#!/bin/sh 
echo "#################### generic-adaptation.post ####################" 

# fix TIVI-2291 
sed -ri "s/(^blacklist i8042.*$)/#fix from base-general.post \1/" /etc/modprobe.d/blacklist.conf 


#!/bin/sh 
echo "#################### generic-base.post ####################" 

test ! -e /opt/var && mkdir -p /opt/var 
test -d /var && cp -arf /var/* /opt/var/ 
rm -rf /var 
ln -snf opt/var /var 

test ! -e /opt/usr/home && mkdir -p /opt/usr/home 
test -d /home && cp -arf /home/* /opt/usr/home/ 
rm -rf /home 
ln -snf opt/usr/home /home 

build_ts=$(date -u +%s) 
build_date=$(date -u --date @$build_ts +%Y%m%d_%H%M%S) 
build_time=$(date -u --date @$build_ts +%H:%M:%S) 

sed -ri \ 
-e 's|@BUILD_ID[@]|tizen-unified_20181024.1|g' \ 
-e "s|@BUILD_DATE[@]|$build_date|g" \ 
-e "s|@BUILD_TIME[@]|$build_time|g" \ 
-e "s|@BUILD_TS[@]|$build_ts|g" \ 
/etc/tizen-build.conf 

# setup systemd default target for user session 
cat <<'EOF' >>/usr/lib/systemd/user/default.target 
[Unit] 
Description=User session default target 
EOF 
mkdir -p /usr/lib/systemd/user/default.target.wants 

# sdx: fix smack labels on /var/log 
chsmack -a '*' /var/log 

# create appfw dirs inside homes 
function generic_base_user_exists() { 
user=$1 
getent passwd | grep -q ^${user}: 
} 

function generic_base_user_home() { 
user=$1 
getent passwd | grep ^${user}: | cut -f6 -d':' 
} 

function generic_base_fix_user_homedir() { 
user=$1 
generic_base_user_exists $user || return 1 

homedir=$(generic_base_user_home $user) 
mkdir -p $homedir/apps_rw 
for appdir in desktop manifest dbspace; do 
mkdir -p $homedir/.applications/$appdir 
done 
find $homedir -type d -exec chsmack -a User {} \; 
chown -R $user:users $homedir 
return 0 
} 

# fix TC-320 for SDK 
. /etc/tizen-build.conf 
[ "${TZ_BUILD_WITH_EMULATOR}" == "1" ] && generic_base_fix_user_homedir developer 

# Add info.ini for system-info CAPI (TC-2047) 
/etc/make_info_file.sh 

#!/bin/sh 
echo "#################### generic-users.post ####################" 

if ! generic_base_user_exists owner; then 
        # By default GUM will create users in /opt/etc/passwd, which is 
        # additional users database suitable for end-user created accounts. 
        # However, the 'owner' user is shipped by Tizen system itself and 
        # it's its default user.  Consequently, it should always be available 
        # and thus, it should be added to /etc/passwd. 
        conf=/etc/gumd/gumd.conf 
        origf=${conf}.orig 
        mv -v $conf $origf 
        sed -e 's,^\(PASSWD_FILE\).*,\1=/etc/passwd,' -e 's,^\(SHADOW_FILE\).*,\1=/etc/shadow,' <$origf >$conf 
        gum-utils --offline --add-user --username=owner --usertype=admin --usecret=tizen 
        mv -v $origf $conf 
fi 



#!/bin/sh 

echo "############### iot-headless-base.post ################" 

######### Execute pkg_initdb if there is no pkgmgr-tool pacakge 
rpm -qa | grep pkgmgr-tool 
if [ $? != 0 ] 
then 
pkg_initdb --ro 
fi 


#!/bin/sh 
echo "#################### generic-wayland.post ####################" 


#!/bin/sh 
echo "#################### generic-middleware.post ####################" 


#!/bin/sh 
echo "#################### generic-applications.post ####################" 


#!/bin/sh 
echo "#################### generic-bluetooth.post ####################" 


#!/bin/sh 
echo "#################### generic-multimedia.post ####################" 


#!/bin/sh 
echo "#################### generic-desktop-applications.post ####################" 

# depends on generic-base functions 
function generic_desktop_applications_fix_userhome() { 
user=$1 

generic_base_user_exists $user || return 1 
homedir=$(generic_base_user_home $user) 

echo "Fix app_info.db of $user" 
chown -R $user:users $homedir/.applications/dbspace/ 
} 

# fix TC-320 for SDK 
. /etc/tizen-build.conf 
# Disable to run below line because this results in always failure, so it can be regarded as useless. 
#[ "${TZ_BUILD_WITH_EMULATOR}" == "1" ] && generic_desktop_applications_fix_userhome developer 


#!/bin/sh 
echo "#################### generic-crosswalk.post ####################" 


#!/bin/sh 
echo "############### common-crosswalk.post ################" 

# start wrt widgets preinstall 
rpm -qa | grep wrt-widget 
if [ $? = 0 ] 
then 
prepare_widgets.sh 
fi 


#!/bin/sh 
echo "############### common-license.post ################" 

LICENSE_DIR=/usr/share/licenses 
LICENSE_FILE=/usr/share/license.html 
MD5_TEMP_FILE=/usr/share/temp_license_md5 

if [[ -f $LICENSE_FILE ]]; then 
rm -f $LICENSE_FILE 
fi 

if [[ -f $MD5_TEMP_FILE ]]; then 
rm -f $MD5_TEMP_FILE 
fi 


cd $LICENSE_DIR 
LICENSE_LIST=`ls */*` 

for INPUT in $LICENSE_LIST; do 
if [[ -f $INPUT ]]; then 
PKG_NAME=`echo $INPUT|cut -d'/' -f1` 
echo `md5sum $INPUT` $PKG_NAME >> $MD5_TEMP_FILE 
fi 
done 

MD5_LIST=`cat $MD5_TEMP_FILE|awk '{print $1}'|sort -u` 

echo "" >> $LICENSE_FILE

 

echo "" >> $LICENSE_FILE 
echo "" >> $LICENSE_FILE 
echo "" >> $LICENSE_FILE

 

echo "" >> $LICENSE_FILE 
echo "" >> $LICENSE_FILE 
echo "" >> $LICENSE_FILE

 

echo "" >> $LICENSE_FILE 

rm -rf $LICENSE_DIR/* $MD5_TEMP_FILE 

#!/bin/sh 
echo "#################### generic-dbus-policychecker.post ####################" 
for f in /etc/dbus-1/system.d/*.conf; do 
echo 
echo "$0: Checking D-Bus policy file: $f" 
dbus-policychecker "$f" 
done 

#!/bin/sh 
echo "#################### generic-security.post ####################" 

if [ -e /usr/share/security-config/set_capability ]; then 
echo 'Give capabilities to daemons via set_capability from security-config package' 
/usr/share/security-config/set_capability 
fi 
if [ -e /opt/share/security-config/test/image_test.sh ]; then 
echo 'Run security-test' 
/opt/share/security-config/test/image_test.sh 
fi  

#!/bin/sh 
echo "############### common-cleanup-directory.post ################" 

# remove manuals, docs and headers 
rm -rf /usr/include 
rm -rf /usr/share/man 
rm -rf /usr/share/doc 


%end 

%post --nochroot 
####################### buildname.nochroot ####################### 
if [ -n "$IMG_NAME" ]; then 
echo "BUILD_ID=$IMG_NAME" >> $INSTALL_ROOT/etc/tizen-release 
echo "BUILD_ID=$IMG_NAME" >> $INSTALL_ROOT/etc/os-release 
echo "$IMG_NAME tizen-unified_20181024.1" >>$INSTALL_ROOT/etc/tizen-snapshot 
fi 

echo "############### backup-data.nochroot ################" 

date +'[%m/%d %H:%M:%S %Z] backup-data.nochroot nochroot post script - start' 

if [ -e $INSTALL_ROOT/usr/bin/build-backup-data.sh ]; then 
    $INSTALL_ROOT/usr/bin/build-backup-data.sh 
fi 

date +'[%m/%d %H:%M:%S %Z] backup-data.nochroot nochroot post script - end' 


%end 

%runscript 

%end

 

- [이미지 직접 만들기] MIC로 이미지를 생성하기

$ sudo mic cr loop tizen-unified_iot-boot-armv7l-sdta7d.ks --pack-to=tizen-unified_iot-boot-armv7lsdta7d.
tar.gz --logfile=mic_build.log -A armv7l
$ sudo mic cr loop tizen-unified_iot-headless-2parts-armv7l-sdta7d.ks --pack-to=tizen-unified_iotheadless-
2parts-armv7l-sdta7d.tar.gz --logfile=mic_build.log -A armv7l

  결과물 : tizen-unified_iot-boot-armv7l-sdta7d.tar.gz, tizen-unified_iot-headless-2parts-armv7l-sdta7d.tar.gz

 

- [SRAM에 부트로더 올리기] imx_usb_loader 준비하기 : SRAM에 i.MX 보드용 이미지 설치툴

$ cd ~/tools
$ git clone https://github.com/boundarydevices/imx_usb_loader
$ cd ~/tools/imx_usb_loader/
$ make

 

- [SRAM에 부트로더 올리기] USB로 부트로더를 로드하기 위해 DAP Station 점퍼를 설정하기

 

- [SRAM에 부트로더 올리기] SDTA7D 보드의 전원을 켜고, USB 상태 확인

$ lsusb | grep Freescale
Bus 00x Device 00y: ID 15a2:0076 Freescale Semiconductor, Inc

 

- [SRAM에 부트로더 올리기] 타이젠 이미지 압축 풀기

$ cd ~/Tizen-sdta7d/mic-output

$ tar zxvf tizen-unified_iot-boot-armv7l-sdta7d.tar.gz
modules.img
u-boot.img
SPL
sdta7d.dtb
zImage

$ tar zxvf tizen-unified_iot-headless-2parts-armv7l-sdta7d.tar.gz
system-data.img
rootfs.img
ramdisk.img
ramdisk-recovery.img

 

- [SRAM에 부트로더 올리기] SDTA7D 보드에 SPL 로드하기

$ sudo ~/tools/imx_usb_loader/imx_usb SPL

 

- [SRAM에 부트로더 올리기] SDTA7D 보드에 U Boot 로드하기

$ sudo ~/tools/imx_usb_loader/imx_usb u-boot.img

 

- [eMMC에 부트로더 올리기] U Boot의 환경변수 초기화하기

(U-Boot)
=> env default -f -a
=> saveenv

 

- [eMMC에 부트로더 올리기] U Boot에서 7개의 파티션을 지정하기

(U-Boot)
=> mmc partconf 0 0 7 0

배포자료 중

 

- [eMMC에 부트로더 올리기] DFU(Device Firmware Upgrade)를 이용하여 eMMC로 SPL & U-Boot를 퓨징하기

  http://dfu-util.sourceforge.net/

(U-Boot)
=> dfu 0 mmc 0

 

(Host)
$ cd ~/tizen-imx7/u-boot
$ sudo dfu-util -D SPL -a spl
$ sudo dfu-util -R -D u-boot.img -a u-boot

 

- [eMMC에 부트로더 올리기] eMMC로 부트하도록 점퍼 설정하기

 

- [eMMC에 부트로더 올리기] Reset

 

- [eMMC에 부트로더 올리기] USB 대용량 저장장치 모드 활성화하기

(U-Boot)
=> ums 0 mmc 0

 

- [eMMC에 부트로더 올리기] eMMC 파티션 만들기

(Host)
$ sudo ./mkpart.sh ${DISK}

mkpart.s_
0.00MB

 

- [eMMC에 부트로더 올리기] 호스트에서 보드의 USB 대용량 저장장치를 확인하기

$ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sdb 8:16 1 3.6G 0 disk
sdb4 8:20 1 1K 0 part
sdb2 8:18 1 128M 0 part
sdb5 8:21 1 1G 0 part
sdb3 8:19 1 2G 0 part
sdb1 8:17 1 32M 0 part
sdb6 8:22 1 410M 0 part
sda 8:0 0 160.1G 0 disk
sda2 8:2 0 4.5G 0 part
sda1 8:1 0 155.6G 0 part /

 

- [eMMC에 부트로더 올리기] 커널을 위한 환경변수 설정하기

$ export kernel_version=4.20.6-0-sdta7d
$ export DISK=/dev/sdc

 

- [eMMC에 부트로더 올리기] 부트 파티션을 마운트하기

$ sudo mount ${DISK}1 /media/hbahn/boot/

 

- [eMMC에 부트로더 올리기] extlinux.conf 설정하기

$ sudo mkdir -p /media/hbahn/boot/extlinux/
$ sudo sh -c “echo ‘label Linux ${kernel_version}’ > /media/hbahn/boot/extlinux/extlinux.conf”
$ sudo sh -c “echo ‘ kernel /boot/vmlinuz-${kernel_version}’ >> /media/hbahn/boot/extlinux/extlinux.conf”
$ sudo sh -c “echo ‘ append root=/dev/ram rw’ >> /media/hbahn/boot/extlinux/extlinux.conf”
$ sudo sh -c “echo ‘ fdtdir /boot/dtbs/${kernel_version}/’ >> /media/hbahn/boot/extlinux/extlinux.conf”
$ sudo sh -c “echo ‘ initrd /boot/ramdisk.img’ >> /media/hbahn/boot/extlinux/extlinux.conf”

 

- [eMMC에 부트로더 올리기] 커널이미지 복사하기

$ sudo mkdir -p /media/hbahn/boot/boot
$ sudo cp -v zImage /media/hbahn/boot/boot/vmlinuz-${kernel_version}

 

- [eMMC에 부트로더 올리기] 커널 디바이스 트리 바이너리 복사하기

$ sudo mkdir -p /media/hbahn/boot/boot/dtbs/${kernel_version}/
$ sudo cp sdta7d.dtb /media/hbahn/boot/boot/dtbs/${kernel_version}/

 

- [eMMC에 부트로더 올리기] 커널 모듈 복사하기

$ sudo dd if=modules.img of=${DISK}2 bs=1M

 

- [eMMC에 부트로더 올리기] 타이젠 플랫폼 이미지 복사하기

$ sudo dd if=rootfs.img of=${DISK}3 bs=1M
$ sudo dd if=system-data.img of=${DISK}5 bs=1M

 

- [eMMC에 부트로더 올리기] 램디스크 이미지 복사하기

$ sudo cp ramdisk.img /media/hbahn/boot/boot

 

 

* 해커톤 참가자들에게 배포된 이미지 중 SPI 부분만 갱신하기

- 신규 부트 바이너리 : tizen-unified_iot-boot-armv7l-sdta7d.tar.gz

- 신규 부트 바이너리의 압축을 풀면 아래와 같은 파일을 나옴.

$ tar zxvf tizen-unified_iot-boot-armv7l-sdta7d.tar.gz
modules.img 
u-boot.img 
SPL 
sdta7d.dtb 
zImage 

 

- 위에서 sdta7d.dtb와 zImage만 업데이트 해기

1. u-boot에서 USB mass storage utility 실행

=> ums 0 mmc 0

 

2. Host Linux에서 신규 boot image 복사

(1) 환경 설정

$ export kernel_version=4.20.6-0-sdta7d     
$ export DISK=/dev/sdc 

 

(2) 타깃보드 마운트(아래는 개인 환경에 따라 설정해주세요)                  

$ sudo mount ${DISK}1 /media/hbahn/boot/

 

(3) Copy Kernel Image

$ sudo cp -v zImage /media/hbahn/boot/boot/vmlinuz-${kernel_version} 

 

(4) Copy Kernel Device Tree Binaries

$ sudo cp sdta7d.dtb /media/hbahn/boot/boot/dtbs/${kernel_version}/

 

 

 

업데이트 : '19. 8. 18, 워크숍 동영상 & 앱 개발 관련 동영상 추가

 

 

 

0. 워크숍 1일차 전체 동영상 : 4시간 분량

- G Camp 측에서 강의 전체를 인코딩해주셨습니다. 자신에게 필요한 부분만 들으세요.

 

0. 사전 준비

* 총정리 게시물 주소(본 게시물) : https://bit.ly/2MmsVii

* 슬랙 채널 : (해커톤 참가자 전용 초대장) https://join.slack.com/t/tizen-iot/shared_invite/enQtNzIzMTQzMTQzNTA1LTU2N2JmODhlMTNkYzcwOGQ4NDRiOTUzZTlmN2NlODYxOTJmYTM5MGFiNDNlY2I5MzU4ZGIzOTQ0NDU2YTdkNDY

* 타이젠 스튜디오 설치하기 : 1~4페이지 참고, http://tizenschool.org/tutorial/149/contents/1

 

1. 해커톤 소개

* 주제 : 사람들의 간절한 문제를 해결하는 탑 메이커

* 구현기술 : 타이젠을 기본으로 하는 솔루션 구축

* 일정 : 1박 2일, 9. 21(토) ~ 22(일)

  - 1일차(토)

    13:00 ~ 18:00 모두 발언, 해커톤 진행(기술지원 ~ 21:00)

  -  2일차(일)

    11:00 ~ 12:00 제출 완료

    13:00 ~ 18:00 발표

 

* 보드 : ① RPI 3 Model B+ 혹은 ② SDTA7D

* 부속기기 : 센서, LED, 카메라 등 

* 평가배점 : 100점 = 심사위원 평가 60점 + 동료 평가 40점

* 심사위원 : 5명(타이젠팀 3명, IT전문가 2명)

* 심사위원 평가기준

    

  - 발표시간 : 팀당 각 10분 이내(3분 발표, 7분 질의응답)

  - 최종결과물 시연영상 : 휴대폰 촬영 영상 / 제시된 양식으로 제출

  - 전체 프로젝트 코드리뷰 : github에 업로드 필수, 코드작성자 기록 필수, 타이젠 스튜디오로 빌드 필수

  - 단, 사업아이템인 경우에는 비공개 요청을 별도로 하여야 함.

 

* 동료평가 기준

  - 당일 참가자에 스티커를 부여하여 각 팀의 시작품 중 우수시작품에 스티커 부착하기

  - 점수 산식 : (그 팀이 받은 스티커수/벽면 부착된 스티커 총수) x 40점

 

* 혜택

 

* 타이젠 스페셜리스트 선정 : https://developer.tizen.org/blog/tizen-specialist-program

  - 코드 리뷰를 통해 우수한 개발자는 타이젠 스페셜리스트로 선정함.

 

2. 워크숍 일정

 

3. 시료 배포

- 플라스틱 케이스

- SDTA7D / WiFi 안테나 / 전원케이블

- RPI3 B+ / 마이크로 SD 카드 / 카드리더기 / 5V 2A MicroUSB 어댑터 / FTDI USB-TTL

- 5mm LED / HC-SR501 인체감지센서 /  GY-303 조도센서 / SG90 서보모터 / 사운드센서

- 빵판 / MCP3008 / 220옴 저항 / 전선(MM, MF, FF)

- SPC-A1200B

 

4. 참가팀 소개 : 총 16개팀

- IHU

- 패트와 매트

- I.o.T ( Initialize on Tizen)

개인팀 x 2

InAirPeople 

용규 

Hell Maker

- 가디언즈

- 아이터틀

Red Light

- 엄유상

- 왔다 슈트 

디하시스 

- 나우 유 씨 미(Now U C Me) 

KMC 외 한명 

- System Consultant Group

※ 개인 두 분이 원하시면 두 분 위주의 팀 구성 or 타 팀 배정

 팀에게 지원되는 지원금은 9. 22(일)까지 팀장이 사용하고, 이후 증빙자료를 제출하고 비용처리 예정

    다만, 조건부 통과팀의 경우, 팀원 충당 후에 경비를 사용 가능

 팀간 결합시 기존 팀에 지급되던 비용은 그대로 지급

    즉, 팀간 결합을 통해 단일팀 구성을 하는 경우 60만원까지 사용가능

 팀을 구성하지 못한 개인은 해커톤에 참가 불가

 프로젝트 주제는 해커톤 전날까지 변경 가능

 

5. 타이젠 스튜디오 설치 및 라즈베리파이 환경설정

* Tizen & Tizen IoT 소개 : http://tizenschool.org/tutorial/150/contents/4

* 발표자료 목차

I. Tizen

 

II. Tizen IoT

 

III. Tizen Specialist

 

VI. 관련 사이트

1. 타이젠 개발자 사이트 (http://developer.tizen.org)

- Tizen API Guide를 포함한 타이젠 관련 모든 정보가 있음. 

- Headless API Guide : https://developer.tizen.org/dev-guide/tizen-iot-headless/5.0/

- Headed API Guide : https://developer.tizen.org/dev-guide/tizen-iot-headed/5.0/

 

2. Tizen School (http://tizenschool.org)

- Tizen 입문자를 위한 사이트로 단계별로 쉽게 따라할 수 있는 핵심 강좌 수록

 

3. CraftRoom (http://craftroom.tizen.org)

- Tizen IoT에 특화된 다양한 강좌 수록 및 원하는 IoT Image 생성 가능

 

4. Topmaker (https://www.topmaker.kr/tag/tizen)

- Tizen IoT 개발 관련 다양한 동영상 컨텐츠 수록

 

5. 삼성 개발자 사이트 (http://developer.samsung.com)

- Tizen이 탑재된 Samsung Device에 관한 개발정보 수록

 

* Tizen IoT 개발 환경 구축(Windows) : http://tizenschool.org/tutorial/149/contents/1

* 발표자료 목차

I. Overview

 

II. Tizen IoT 개발환경 구축

1. Java SE Development Kit (JDK) 설치

2. Tizen Studio 설치

3. Tizen IoT Package 설치

4. Tizen Certificate(인증서) 생성

 

III. RPI3+ 개발환경 구축

1. IoT Image 제작

2. 시리얼 통신 연결

3. 네트워크 설정

4. SDB 환경 변수 설정

5. SDB 연결

 

IV. Hello World

1. 프로젝트 생성

2. 프로젝트 수정 및 실행

3. 프로젝트 실행 결과 확인

 

6. 타이젠 앱 개발 기본

* 발표 자료 : https://craftroom.tizen.org/hackathon-kick-off-a-tizen-project/

* 소스코드 : 

rcc.zip
0.62MB

* 발표자료 목차

 

* 메인루프 설명 동영상

- 본 동영상은 UI앱을 대상으로 설명하였지만, UI가 없는 앱(서비스앱)에서도 일부 유효한 내용이 있습니다.

- 영상 재해석 : 몇 가지 부분을 아래처럼 이해하시면 보다 수월할 겁니다.

  앞면 : 앱이 foreground로 나온 상태

  뒷면 : 앱이 background에 들어간 상태

  app_resume_cb & app_pause_cb : 화면이 있는 UI앱에서만 필요. 화면이 없는 서비스앱에서는 불필요.

 

* 메인루프에 대한 심화 자료 : https://www.topmaker.kr/215

 

[EFL] ecore main loop의 이해

[전 삼성전자] 서주영님의 블로그에서 가져온 글입니다. 좀 오래된 글이지만, 도움이 되실 것 같아, 올립니다. ※ 이벤트 → 상황(event), 콜백 → 대응함수(call back) 등으로 수정하여 사용 http://eglo..

www.topmaker.kr

<첨언>

- EFL(Enlightenment Foundation Libraries)은 공개 소프트웨어이다.

  https://www.enlightenment.org

- IoT Headless 환경에서는 ecore_main_loop_begin()과 ecore_main_loop_quit()를 사용한다.

  (elm_run()과 elm_exit()는 사용하지 않는다)

- 타이젠의 UI앱 & 서비스앱은 ecore_main_loop를 기본 메인루프로 사용하고 있다.

- 메인루프는 대기(Idle) 상태와 이벤트처리 상태로 나뉜다.

- Idle 상태는 idle enter / idle / idle exit 세 단계로 나뉜다.

- Idle enter에서 화면을 그리거나 갱신하는 렌더링 루틴을 수행한다. 단, 그릴 것이 없으면 렌더링 루틴을 수행하지 않는다.

- Idle 상태로 진입하기 위해 select() 함수를 이용한다.

   int select(int nfds, fd_set *readfds, fd_set *writefds,
                        fd_set *exceptfds, struct timeval *timeout);

- IF SETS : Idle -> Fd handling -> Sig to event -> Event handling -> Timing handling -> Sig to Event

 

- 주제 : 타이젠에 대한 간략 소개
- 시간 : '19. 8. 5(월)
- 장소 : G Camp
- 발표자 : 삼성전자 손기성 수석연구원님

※ 본 동영상은 타이젠 팀의 기술지원을 받아 제작되었습니다.  
※ 본 동영상은 (주) 심플랫폼의 의견을 담고 있습니다. 타이젠 팀의 공식적인 의견은 아닙니다.

- 주제 : 타이젠 플랫폼과 누비슨 서비스를 연동하기
- 영상제작 : #누비슨
- 제작지원 : #지캠프, #메이커스페이스, #중소벤처기업부, #한국창업진흥원, #서울시, #서울산업진흥원, #금천구, #한국산업단지공단
- 기술지원 : #Tizen, #타이젠

 


 

Tizen IoT with Nubison Cloud

The Nubison IoT cloud is a cloud-based IoT platform that provides smart solutions and intelligent services by connecting various things easily, as well as collecting and analyzing IoT data in real time.

Real-time data monitoring and controlling between Tizen service app and Nubison cloud is empowered through Nubison plugin.

The following diagram shows the interface between Tizen IoT device and Nubison cloud through Nubison plugin:

Figure: Architecture

 

The Nubison plugin can be installed on Tizen IoT devices compatible with as follow:

  • Platform : Tizen 5.0 IoT Headed & Headless and later
  • SDK : Tizen Studio 3.0 and later

For more information about Nubison IoT cloud service, see the following references:

Start now by importing Nubison's template in the Tizen Studio!

 


 

1-1. Tizen 알아보기 #1

1-2. Tizen 알아보기 #2

1-3. Nubison Cloud 알아보기

1-4. Tizen 기기와 Nubison Cloud를 연동하기

2-2. Tizen x Nubison : GPIO 실습 #2

2-3. Tizen x Nubison : GPIO 실습 #3

2-4. Tizen x Nubison : GPIO 실습 #4

※ 정정 : peripheral_gpio_set_direction()는 GPIO로 연결된 센서로부터 값을 '읽어올지' 아니면 센서에 값을 '쓸지'를 설정하는 함수입니다.

 

2-5. Tizen x Nubison : GPIO 실습 #5

3-1. Tizen x Nubison : I2C 실습 #1

3-2. Tizen x Nubison : I2C 실습 #2

3-3. Tizen x Nubison : I2C 실습 #3

3-4. Tizen x Nubison : I2C 실습 #4

4-1. Tizen x Nubison : SPI 실습 #1

4-2. Tizen x Nubison : SPI 실습 #2

4-3. Tizen x Nubison : SPI 실습 #3

4-4. Tizen x Nubison : SPI 실습 #4

4-5. Tizen x Nubison : SPI 실습 #5

5-1. Tizen x Nubison : IoT 데이터 분석 #1

5-2. Tizen x Nubison : IoT 데이터 분석 #2

5-3. Tizen x Nubison : IoT 데이터 분석 #3

5-4. Tizen x Nubison : IoT 데이터 분석 #4

5-5. Tizen x Nubison : IoT 데이터 분석 #5

 

 

보드 환경설정 : 디바이스 / 이미지

- 타이젠스튜디오 with 라즈베리파이 : https://craftroom.tizen.org/diy-iot-%ED%8A%9C%ED%86%A0%EB%A6%AC%EC%96%BC-1-%EA%B0%9C%EB%B0%9C%ED%99%98%EA%B2%BD-%EC%84%A4%EC%A0%95%ED%95%98%EA%B8%B0/

- 이미지 생성하기 : https://craftroom.tizen.org/how-to-create-your-own-customized-platform-image/

- 이미지 설치하기 : https://craftroom.tizen.org/how-to-install-tizen-platform-image-on-eagleye-530s-board/

- WiFi 설정 : https://craftroom.tizen.org/tizeniot_wifi_setuptizen_studio_wireless_connect/

 

서비스앱

- 서비스앱 모델 : https://developer.tizen.org/development/guides/native-application/application-management/applications/service-application

- 네이티브 API : https://developer.tizen.org/development/api-references/native-application

 

프레임워크 + 앱개발 : 기본 입출력 프로토콜

- PIO API : https://developer.tizen.org/development/iot-extension-sdk/api-guides/tizen-peripheral-io-native-api

- GPIO : https://craftroom.tizen.org/smartmotionlight/

- I2C&PWM : https://craftroom.tizen.org/illuminance_to_servo/

- SPI : https://craftroom.tizen.org/co2/

- 라즈베리파이 + 아두이노 : https://craftroom.tizen.org/diy-iot-%ED%8A%9C%ED%86%A0%EB%A6%AC%EC%96%BC-5-%EC%95%84%EB%91%90%EC%9D%B4%EB%85%B8-%EC%97%B0%EA%B3%84%ED%95%98%EA%B8%B0/

 

* 프레임워크 + 앱개발 : 멀티미디어

- 카메라 기본 : https://developer.tizen.org/development/guides/native-application/media-and-camera/camera

- 카메라 프로젝트 : https://craftroom.tizen.org/simple-iot-camera/

 

* 프레임워크 + 앱개발 : AI를 위한 앱개발

- Image detection + Recognition : https://developer.tizen.org/development/guides/native-application/media-and-camera/visual-detection-and-recognition

- Vision : https://craftroom.tizen.org/%EC%95%84%ED%8B%B1%EC%9C%BC%EB%A1%9C-smart-surveillance-camera-%EB%A7%8C%EB%93%A4%EA%B8%B0/

- Alexa : https://craftroom.tizen.org/iotdev-withalexa/

 

*서비스:스마트싱스(버전 업데이트 필요, 아래 코드는 현재 사용 불가합니다)

- 스마트싱스 기본 : https://developer.tizen.org/development/iot-extension-sdk/api-guides/things-sdk-api

- 스마트싱스 사용하기 : https://craftroom.tizen.org/how-to-use-smartthings/

- 스마트싱스 + GPIO : https://craftroom.tizen.org/smart-motion-light-smartthings-for-tizen-5-0/

- 스마트싱스 프로젝트 생성 : https://craftroom.tizen.org/diy_iot_tutorial2/

- 자동화 : https://craftroom.tizen.org/diy-iot-%ED%8A%9C%ED%86%A0%EB%A6%AC%EC%96%BC-6-%EC%9E%90%EB%8F%99%ED%99%94-%EA%B7%9C%EC%B9%99-%EB%A7%8C%EB%93%A4%EA%B8%B0/

 

* 서비스 클라우드 누비슨 

- 누비슨 사이트 : https://nubisoniot.com/

- 깃허브 : https://github.com/nubisoniot/NI

 

타이젠 메이킹 프로젝트 예시

- 아마존 대시 버튼 : https://craftroom.tizen.org/%EC%BB%A4%EC%8A%A4%ED%85%80-%EC%95%84%EB%A7%88%EC%A1%B4-%EB%8C%80%EC%8B%9C-%EB%B2%84%ED%8A%BC-%EC%A0%9C%EC%9E%91%ED%95%98%EA%B8%B0/

- 콘센트 : https://craftroom.tizen.org/diy-iot-%EC%BD%98%EC%84%BC%ED%8A%B8-%EC%A0%9C%EC%9E%91%ED%95%98%EA%B8%B0/

- 스위치 : https://craftroom.tizen.org/diy-iot-%EC%82%AC%EB%A1%80-iot-%EC%8A%A4%EC%9C%84%EC%B9%98%EB%A1%9C-%EC%A0%84%EB%93%B1-%EC%A0%9C%EC%96%B4%ED%95%98%EA%B8%B0/

 

기타

- 포팅 가이드 https://wiki.tizen.org/Tizen_3.0_Porting_Guide

 

* Unified Model Config : System Information을 저장하는 곳

- 저장소 : git clone ssh://[your_id]@review.tizen.org:29418/platform/adaptation/unified-model-config

- 예시 : Tizen 5.5 IoT RPI3 대상

...더보기

tizen.org/system/model_name" type="string">rpi3 
tizen.org/system/platform.name" type="string">Tizen 
tizen.org/feature/platform.version" type="string">5.5 
tizen.org/system/platform.processor" type="string">BCM2837 
tizen.org/system/platform.communication_processor" type="string">none 
tizen.org/system/manufacturer" type="string">Tizen 
tizen.org/feature/accessibility.grayscale" type="bool">false 
tizen.org/feature/accessibility.negative" type="bool">false 
tizen.org/feature/account" type="bool">false 
tizen.org/feature/account.sync" type="bool">false 
tizen.org/feature/app_history" type="bool">false 
tizen.org/feature/battery" type="bool">false 
tizen.org/feature/calendar" type="bool">true 
tizen.org/feature/camera" type="bool">false 
tizen.org/feature/camera.back" type="bool">false 
tizen.org/feature/camera.back.flash" type="bool">false 
tizen.org/feature/camera.front" type="bool">false 
tizen.org/feature/camera.front.flash" type="bool">false 
tizen.org/feature/consumer_ir" type="bool">false 
tizen.org/feature/container" type="bool">false 
tizen.org/feature/contextual_trigger" type="bool">false 
tizen.org/feature/database.encryption" type="bool">false 
tizen.org/feature/datasync" type="bool">false 
tizen.org/feature/display.state" type="bool">true 
tizen.org/feature/download" type="bool">true 
tizen.org/feature/feedback.vibration" type="bool">false 
tizen.org/feature/fmradio" type="bool">false 
tizen.org/feature/graphics.acceleration" type="bool">true 
tizen.org/feature/humanactivitymonitor" type="bool">false 
tizen.org/feature/input.keyboard" type="bool">false 
tizen.org/feature/input.keyboard.layout" type="string">none 
tizen.org/feature/input.rotating_bezel" type="bool">false 
tizen.org/feature/iot.ocf" type="bool">true 
tizen.org/feature/led" type="bool">false 
tizen.org/feature/location" type="bool">false 
tizen.org/feature/location.batch" type="bool">false 
tizen.org/feature/location.fused" type="bool">false 
tizen.org/feature/location.gps" type="bool">false 
tizen.org/feature/location.gps.satellite" type="bool">false 
tizen.org/feature/location.wps" type="bool">false 
tizen.org/feature/location.geofence" type="bool">false 
tizen.org/feature/maps" type="bool">true 
tizen.org/feature/media.audio_recording" type="bool">true 
tizen.org/feature/media.video_recording" type="bool">false 
tizen.org/feature/microphone" type="bool">true 
tizen.org/feature/minicontrol" type="bool">false 
tizen.org/feature/multi_assistant" type="bool">true 
tizen.org/feature/multi_point_touch.pinch_zoom" type="bool">false 
tizen.org/feature/multi_point_touch.point_count" type="int">0 
tizen.org/feature/multimedia.transcoder" type="bool">false 
tizen.org/feature/multimedia.custom_audio_effect" type="bool">true 
tizen.org/feature/multimedia.raw_video" type="bool">true 
tizen.org/feature/multimedia.player.stream_info" type="bool">true 
tizen.org/feature/multimedia.media_codec" type="bool">true 
tizen.org/feature/multimedia.player.spherical_video" type="bool">false 
tizen.org/feature/content.scanning.others" type="bool">true 
tizen.org/feature/content.filter.pinyin" type="bool">true 
tizen.org/feature/network.internet" type="bool">true 
tizen.org/feature/network.ethernet" type="bool">true 
tizen.org/feature/network.bluetooth" type="bool">true 
tizen.org/feature/network.bluetooth.audio.call" type="bool">false 
tizen.org/feature/network.bluetooth.audio.media" type="bool">true 
tizen.org/feature/network.bluetooth.audio.controller" type="bool">false 
tizen.org/feature/network.bluetooth.health" type="bool">false 
tizen.org/feature/network.bluetooth.hid" type="bool">true 
tizen.org/feature/network.bluetooth.hid_device" type="bool">false 
tizen.org/feature/network.bluetooth.le" type="bool">true 
tizen.org/feature/network.bluetooth.le.ipsp" type="bool">false 
tizen.org/feature/network.bluetooth.le.gatt.server" type="bool">true 
tizen.org/feature/network.bluetooth.le.gatt.client" type="bool">true 
tizen.org/feature/network.bluetooth.opp" type="bool">false 
tizen.org/feature/network.bluetooth.oob" type="bool">true 
tizen.org/feature/network.bluetooth.phonebook.client" type="bool">false 
tizen.org/feature/network.bluetooth.le.5_0" type="bool">false 
tizen.org/feature/network.mtp" type="bool">true 
tizen.org/feature/network.nfc" type="bool">false 
tizen.org/feature/network.nfc.card_emulation" type="bool">false 
tizen.org/feature/network.nfc.reserved_push" type="bool">false 
tizen.org/feature/network.push" type="bool">true 
tizen.org/feature/network.secure_element" type="bool">false 
tizen.org/feature/network.secure_element.ese" type="bool">false 
tizen.org/feature/network.secure_element.uicc" type="bool">false 
tizen.org/feature/network.telephony" type="bool">false 
tizen.org/feature/network.telephony.sms.cbs" type="bool">false 
tizen.org/feature/network.telephony.sms" type="bool">false 
tizen.org/feature/network.telephony.mms" type="bool">false 
tizen.org/feature/network.telephony.service.cdma" type="bool">false 
tizen.org/feature/network.telephony.service.edge" type="bool">false 
tizen.org/feature/network.telephony.service.gprs" type="bool">false 
tizen.org/feature/network.telephony.service.gsm" type="bool">false 
tizen.org/feature/network.telephony.service.hsdpa" type="bool">false 
tizen.org/feature/network.telephony.service.hspa" type="bool">false 
tizen.org/feature/network.telephony.service.hsupa" type="bool">false 
tizen.org/feature/network.telephony.service.lte" type="bool">false 
tizen.org/feature/network.telephony.service.umts" type="bool">false 
tizen.org/feature/network.tethering" type="bool">true 
tizen.org/feature/network.tethering.bluetooth" type="bool">false 
tizen.org/feature/network.tethering.usb" type="bool">true 
tizen.org/feature/network.tethering.wifi" type="bool">true 
tizen.org/feature/network.vpn" type="bool">false 
tizen.org/feature/network.wifi" type="bool">true 
tizen.org/feature/network.wifi.direct" type="bool">true 
tizen.org/feature/network.wifi.direct.display" type="bool">true 
tizen.org/feature/network.wifi.direct.service_discovery" type="bool">false 
tizen.org/feature/network.wifi.softap" type="bool">true 
tizen.org/feature/network.wifi.tdls" type="bool">false 
tizen.org/feature/network.traffic_control" type="bool">true 
tizen.org/feature/network.inm" type="bool">true 
tizen.org/feature/nlp" type="bool">false 
tizen.org/feature/opengles" type="bool">true 
tizen.org/feature/opengles.texture_format.3dc" type="bool">false 
tizen.org/feature/opengles.texture_format.atc" type="bool">false 
tizen.org/feature/opengles.texture_format.etc" type="bool">true 
tizen.org/feature/opengles.texture_format.ptc" type="bool">false 
tizen.org/feature/opengles.texture_format.pvrtc" type="bool">false 
tizen.org/feature/opengles.texture_format.utc" type="bool">false 
tizen.org/feature/opengles.version.1_1" type="bool">true 
tizen.org/feature/opengles.version.2_0" type="bool">true 
tizen.org/feature/peripheral_io.gpio" type="bool">true 
tizen.org/feature/peripheral_io.i2c" type="bool">true 
tizen.org/feature/peripheral_io.pwm" type="bool">false 
tizen.org/feature/peripheral_io.spi" type="bool">true 
tizen.org/feature/peripheral_io.uart" type="bool">true 
tizen.org/feature/platform.core.cpu.arch" type="string">armv8 
tizen.org/feature/platform.core.cpu.arch.armv6" type="bool">false 
tizen.org/feature/platform.core.cpu.arch.armv7" type="bool">false 
tizen.org/feature/platform.core.cpu.arch.armv8" type="bool">true 
tizen.org/feature/platform.core.cpu.arch.x86" type="bool">false 
tizen.org/feature/platform.core.fpu.arch.sse2" type="bool">false 
tizen.org/feature/platform.core.fpu.arch.sse3" type="bool">false 
tizen.org/feature/platform.core.fpu.arch.ssse3" type="bool">false 
tizen.org/feature/platform.core.fpu.arch.vfpv2" type="bool">false 
tizen.org/feature/platform.core.fpu.arch.vfpv3" type="bool">true 
tizen.org/feature/platform.core.fpu.arch.vfpv4" type="bool">false 
tizen.org/feature/platform.native.api.version" type="string">5.5 
tizen.org/feature/platform.native.osp_compatible" type="bool">false 
tizen.org/feature/platform.web.api.version" type="string">5.5 
tizen.org/feature/profile" type="string">common 
tizen.org/feature/screen.auto_rotation" type="bool">true 
tizen.org/feature/screen.bpp" type="int">32 
tizen.org/feature/screen.coordinate_system.size.large" type="bool">false 
tizen.org/feature/screen.coordinate_system.size.normal" type="bool">true 
tizen.org/feature/screen.dpi" type="int">316 
tizen.org/feature/screen.height" type="int">720 
tizen.org/feature/screen.output.hdmi" type="bool">true 
tizen.org/feature/screen.output.rca" type="bool">false 
tizen.org/feature/screen.size.all" type="bool">true 
tizen.org/feature/screen.size.large" type="bool">false 
tizen.org/feature/screen.size.normal" type="bool">true 
tizen.org/feature/screen.size.normal.240.400" type="bool">false 
tizen.org/feature/screen.size.normal.320.320" type="bool">false 
tizen.org/feature/screen.size.normal.320.480" type="bool">false 
tizen.org/feature/screen.size.normal.360.480" type="bool">false 
tizen.org/feature/screen.size.normal.480.800" type="bool">false 
tizen.org/feature/screen.size.normal.540.960" type="bool">false 
tizen.org/feature/screen.size.normal.600.1024" type="bool">false 
tizen.org/feature/screen.size.normal.720.1280" type="bool">true 
tizen.org/feature/screen.size.normal.1080.1920" type="bool">false 
tizen.org/feature/screen.shape.circle" type="bool">false 
tizen.org/feature/screen.shape.rectangle" type="bool">true 
tizen.org/feature/screen.width" type="int">1280 
tizen.org/feature/security.tee" type="bool">true 
tizen.org/feature/sensor.accelerometer" type="bool">false 
tizen.org/feature/sensor.accelerometer.wakeup" type="bool">false 
tizen.org/feature/sensor.activity_recognition" type="bool">false 
tizen.org/feature/sensor.barometer" type="bool">false 
tizen.org/feature/sensor.barometer.wakeup" type="bool">false 
tizen.org/feature/sensor.bio" type="bool">false 
tizen.org/feature/sensor.geomagnetic_rotation_vector" type="bool">false 
tizen.org/feature/sensor.gesture_recognition" type="bool">false 
tizen.org/feature/sensor.gravity" type="bool">false 
tizen.org/feature/sensor.gyroscope" type="bool">false 
tizen.org/feature/sensor.gyroscope.uncalibrated" type="bool">false 
tizen.org/feature/sensor.gyroscope.wakeup" type="bool">false 
tizen.org/feature/sensor.gyroscope_rotation_vector" type="bool">false 
tizen.org/feature/sensor.heart_rate_monitor" type="bool">false 
tizen.org/feature/sensor.heart_rate_monitor.led_green" type="bool">false 
tizen.org/feature/sensor.heart_rate_monitor.led_ir" type="bool">false 
tizen.org/feature/sensor.heart_rate_monitor.led_red" type="bool">false 
tizen.org/feature/sensor.humidity" type="bool">false 
tizen.org/feature/sensor.linear_acceleration" type="bool">false 
tizen.org/feature/sensor.magnetometer" type="bool">false 
tizen.org/feature/sensor.magnetometer.uncalibrated" type="bool">false 
tizen.org/feature/sensor.magnetometer.wakeup" type="bool">false 
tizen.org/feature/sensor.pedometer" type="bool">false 
tizen.org/feature/sensor.photometer" type="bool">false 
tizen.org/feature/sensor.photometer.wakeup" type="bool">false 
tizen.org/feature/sensor.proximity" type="bool">false 
tizen.org/feature/sensor.proximity.wakeup" type="bool">false 
tizen.org/feature/sensor.rotation_vector" type="bool">false 
tizen.org/feature/sensor.significant_motion" type="bool">false 
tizen.org/feature/sensor.sleep_monitor" type="bool">false 
tizen.org/feature/sensor.stress_monitor" type="bool">false 
tizen.org/feature/sensor.temperature" type="bool">false 
tizen.org/feature/sensor.tiltmeter" type="bool">false 
tizen.org/feature/sensor.tiltmeter.wakeup" type="bool">false 
tizen.org/feature/sensor.ultraviolet" type="bool">false 
tizen.org/feature/sensor.wrist_up" type="bool">false 
tizen.org/feature/shell.appwidget" type="bool">true 
tizen.org/feature/shortcut" type="bool">false 
tizen.org/feature/sip.voip" type="bool">false 
tizen.org/feature/speech.recognition" type="bool">false 
tizen.org/feature/speech.synthesis" type="bool">true 
tizen.org/feature/speech.control" type="bool">true 
tizen.org/feature/storage.external" type="bool">true 
tizen.org/feature/systemsetting" type="bool">false 
tizen.org/feature/systemsetting.home_screen" type="bool">false 
tizen.org/feature/systemsetting.lock_screen" type="bool">false 
tizen.org/feature/systemsetting.incoming_call" type="bool">false 
tizen.org/feature/systemsetting.notification_email" type="bool">false 
tizen.org/feature/systemsetting.font" type="bool">false 
tizen.org/feature/thermistor.ap" type="bool">true 
tizen.org/feature/thermistor.cp" type="bool">false 
tizen.org/feature/thermistor.battery" type="bool">false 
tizen.org/feature/tv.audio" type="bool">false 
tizen.org/feature/tv.display" type="bool">false 
tizen.org/feature/tv.inputdevice" type="bool">false 
tizen.org/feature/tv.pip" type="bool">false 
tizen.org/feature/tv.tuner" type="bool">false 
tizen.org/feature/tv.information" type="bool">false 
tizen.org/feature/usb.accessory" type="bool">false 
tizen.org/feature/usb.host" type="bool">true 
tizen.org/feature/vision.barcode_detection" type="bool">true 
tizen.org/feature/vision.barcode_generation" type="bool">true 
tizen.org/feature/vision.face_recognition" type="bool">true 
tizen.org/feature/vision.image_recognition" type="bool">true 
tizen.org/feature/vision.qrcode_generation" type="bool">false 
tizen.org/feature/vision.qrcode_recognition" type="bool">false 
tizen.org/feature/watch_app" type="bool">false 
tizen.org/feature/web.ime" type="bool">false 
tizen.org/feature/web.service" type="bool">false 
tizen.org/system/sound.media.volume.resolution.max" type="int">15 
tizen.org/system/sound.notification.volume.resolution.max" type="int">15 
tizen.org/system/sound.ringtone.volume.resolution.max" type="int">15 
tizen.org/system/sound.system.volume.resolution.max" type="int">15 
tizen.org/system/input.key.volume" type="bool">false 
tizen.org/system/input.key.menu" type="bool">false 
tizen.org/system/input.key.back" type="bool">false 
tizen.org/feature/fido.uaf" type="bool">true 
tizen.org/feature/oauth2" type="bool">true 
tizen.org/feature/security.privacy_privilege" type="bool">false 
tizen.org/feature/security.device_certificate" type="bool">false 

 

 

 

* Building Block : System Information 덮어쓰기

- 주의 : 여기서 지정한 값은 unified-model-config에서 지정한 값을 덮어쓴다.

- 저장소 : git clone ssh://[your_id]@review.tizen.org:29418/tools/building-blocks

- 예시 : platform-preset-boards-rpi3.inc

...더보기

%tizen_feature tizen.org/system/platform.processor BCM2837 
%tizen_feature tizen.org/system/platform.communication_processor none 
%tizen_feature tizen.org/feature/platform.core.cpu.arch armv8 
%tizen_feature tizen.org/feature/platform.core.cpu.arch.armv7 false 
%tizen_feature tizen.org/feature/platform.core.cpu.arch.armv8 true 
%tizen_feature tizen.org/feature/platform.core.cpu.frequency 1200 
%tizen_feature tizen.org/feature/platform.core.fpu.arch vfpv4 
%tizen_feature tizen.org/feature/platform.core.fpu.arch.vfpv3 false 
%tizen_feature tizen.org/feature/platform.core.fpu.arch.vfpv4 true 
%tizen_feature tizen.org/feature/profile common 
%tizen_feature tizen.org/feature/location.batch false 
%tizen_feature tizen.org/feature/network.ethernet true 
%tizen_feature tizen.org/feature/network.wifi.tdls false 
%tizen_feature tizen.org/feature/screen.auto_rotation false 
%tizen_feature tizen.org/feature/screen.height 1920 
%tizen_feature tizen.org/feature/screen.output.hdmi true 
%tizen_feature tizen.org/feature/screen.output.rca false 
%tizen_feature tizen.org/feature/screen.shape.circle false 
%tizen_feature tizen.org/feature/screen.shape.rectangle true 
%tizen_feature tizen.org/feature/screen.size.normal.1080.1920 true 
%tizen_feature tizen.org/feature/screen.width 1080 
%tizen_feature tizen.org/feature/sensor.accelerometer false 
%tizen_feature tizen.org/feature/sensor.gravity false 
%tizen_feature tizen.org/feature/sensor.linear_acceleration false 
%tizen_feature tizen.org/feature/sensor.proximity false 
%tizen_feature tizen.org/feature/sensor.temperature fasle 
%tizen_feature tizen.org/feature/storage.external true 
%tizen_feature tizen.org/feature/peripheral_io.gpio true 
%tizen_feature tizen.org/feature/peripheral_io.i2c true 
%tizen_feature tizen.org/feature/peripheral_io.pwm false 
%tizen_feature tizen.org/feature/peripheral_io.spi true 
%tizen_feature tizen.org/feature/peripheral_io.uart true 
%tizen_feature tizen.org/feature/accessibility.grayscale false 
%tizen_feature tizen.org/feature/accessibility.negativee false 
%tizen_feature tizen.org/system/model_name rpi3 

*** %tizen_feature is from 'sed'. 
%define tizen_feature() sed -i 's#\\\(\\\"%{1}\\\".\\\+>\\\).\\\+\\\(\\\)#\\\1%{2}\\\2#' %{_sysconfdir}/config/model-config.xml;

 

* System Information 적용하기  

// Managed DB from the installed file. 
# mount -o remount rw / 
  
// /etc/config/model-config.xml 수정하기
# rm /etc/system_info_db 
# system_info_init_db 
# chsmack -a "_" /etc/system_info_db 

 

 

* Craftroom side
- Upload your packages(unified-model-config, building-block) into Craftroom.
- Make an image.

수정내역 : '19. 8. 16(금) 내용 추가

 

'19년 8~9월, 타이젠 워크숍 및 해커톤을 개최할 예정입니다.

 

* 해커톤
- 주제 : 사람들의 간절한 문제를 해결하는 탑 메이커
- 모집기간 : ‘19. 7. 16(화) ~ 8. 16(금)
- 하드웨어 해커톤 일정 : 1박 2일, 9. 21(토) ~ 22(일)
- 참가규모 : 30팀 이내(120명 내외, 팀 당 4명 내외 구성)
- 참가요건 : H/W개발자, S/W개발자 각 1명 이상(필수)으로 구성된 4인 내외의 팀
   ※ 가능 : SW 개발자 1명 + HW개발자 1명 + 기획자
   ※ 불가능 : 기획자 2명 + 디자이너 2명
- 필수기술 : 타이젠
   ※ 타이젠은 음성이나 비전 등 고성능을 요구하는 제품에 적합한 OS.
- 지원내용
   ① 1개 팀당 개발지원금 30만원 제공
      (사후 증빙서류 제출후 입금해줌. 신용카드 매출전표 & 증빙사진이 필요함. 
   ② 토일 개발 워크숍 [4주 내외, 동영상강의 별도 제공]
   ③ 별도 주중 워크숍 [7월~8월사이 별도의 특별 워크숍도 진행예정, 고급과정 중심]

 

* 사전 기술워크숍(해커톤 참여자 대상, 외부참여 일부허용)

 

* 시상혜택

지원 내용

시상 내역

비 고

최우수상

상금 2,000천원 (1)

하드웨어 스타트업 엑셀러레이팅 프로그램 T-Stars 참가기회부여

기술창업비자 필수점수 부여 (법무부)

- 3D모델링, CNC/3D 프린팅 등 시작품 제작지원

서울시 창업허브 입주신청시 가점부여

심사위원

(60%)

동료 평가

(40%)

우수상

상금 1,000천원 (각 1팀, 총 2팀)

기술창업비자 필수점수 부여 (법무부)

- 3D모델링, CNC/3D 프린팅 등 시작품 제작지원

서울시 창업허브 입주신청시 가점부여

심사위원

(60%)

동료 평가

(40%)

장려상

상금 500천원 (각 1팀, 총 2팀)

- 3D모델링, CNC/3D 프린팅 등 시작품 제작지원

서울시 창업허브 입주신청시 가점부여

심사위원

(60%)

동료 평가

(40%)

우수 리더상

∘ 2

삼성 갤럭시 워치 각 1

 

동료 평가

(100%)

기타 사항

※ 외국인 개발자 특전 사항 (최우수상우수상 수상시)

기술창업비자 필수점수 부여 (법무부)

 

 

자세한 내용을 확인하고 싶으시거나 해커톤 참가 신청을 하시려면,
여기를 참고해주세요~

 

(2019) '사람들의 간절한 문제를 해결하는 탑 메이커'를 주제로한 서울 하드웨어 해커톤 | Seoul Hardware Hackathon, Top Maker

(2019) '사람들의 간절한 문제를 해결하는 탑 메이커'를 주제로한 서울 하드웨어 해커톤 | Seoul Hardware Hackathon, Top Maker ※ 서울 하드웨어 해커톤은 개발자간 네트워킹을 중요시합니다. 서로 많이들 알아..

www.topmaker.kr

 

추가 : 신청이 마감되었습니다.

* 본 게시물은 '19. 7. 29(월)에 추가로 수정되었습니다.

 

G Camp에서 타이젠 워크숍이 개최될 예정입니다.
타이젠 스페셜리스트이신 방진석님의 강의를 들으실 수 있습니다.

* 1차 워크숍
- 일정 : '19. 7. 29(월) ~ 31(수)
- 장소 : 서울시 금천구 디지털로 9길 90 까르뜨니트 물류창고
- 신청하기 : (마감) https://www.g.camp/910

1차 워크숍에서는 예정에 없던 타이젠팀 강석현님의 발표도 있었습니다.

발표자 : 강석현님

강석현님은 20분 남짓한 시간 동안 타이젠의 지난 몇 년간의 흐름을 짚어주셨습니다.

 

발표자 방진석님

그리고 방진석님께서 전체적으로 강의를 이끌어 나가셨는데,

이번이 공식적인 발표 데뷰전이신데도 불구하고 침착하게 잘하시더군요.

 

다행스럽게도,

1차 워크숍의 인기가 좋아서 동일한 내용의 워크숍이 하나 더 개설되었다고 합니다.

 

* 2차 워크숍
일정 : '19. 8. 5(월) ~ 7(수)
장소 : 서울시 금천구 디지털로 9길 90 까르뜨니트 물류창고
- 신청하기 : https://www.topmaker.kr/186

(이하 게시 내용)


 

 

 

□ 개요
 ○ 개최 배경
  - 리눅스기반 고성능 하드웨어의 제조 요청이 증가하고 있으나, 이와관련된 교육기회는 적으며, 라즈베리파이 기반으로 제공되는 경우는 적용은 매우 쉬우나, 실제 상용으로서의 한계를 가지고 있음
  - Tizen은 이미 많은 하드웨어에 실제 적용되어, 오류코드가 지속적으로 수정되고 있으며, 보안적으로 우수함
  - 다양한 API를 제공하여 쉽게 하드웨어 적용이 가능함
  - 이에 리눅스 기반 타이젠 플랫폼을 이용한 디바이스 제작으로  여러 기업 및 하드웨어 스타트업이 활용 할 수 있는 기회 제공

 ○  강의 : 타이젠 스페셜리스트 방진석 (https://developer.tizen.org/blog/tizen-specialist-program)

 ○ 기대효과
- 전년도 교육(https://topmaker.tistory.com/tag/TIZEN2018)과 변화된 내용 전달 
- Tizen IoT Platform을 이용한 간단한 전자 부품 및 Seneor 실습을 통한 Tizen IoT Project 이해 
- Tizen IoT Platform을 이용한 Lidar Sensor 제작 경험 공유 

□ 세부 내용 

 ○ 모집인원 : 20 명 (선착순) 다만, 전자 부품 및 C언어에 대한 이해를 중급이상으로 가지고 있어야 합니다. 

 ○ 일정

 [1일차] 

Tizen IoT Platform 소개 및 Tizen Studio 설치, 구조알기 Tizen 소개와 설치, 구조 알기 작년도 동영상 교육 내용 활용 (동영상 교육 재활용) - 현 시점의 달라진 내용 전달 - Craftroom workspace를 이용한 image 제작 소개 (해당 web page 에서 설명) - Tizen IoT Platform Memory Card 에 Image Fusing 하기 (해당 web page 에서 설명) - Tizen Studio 설치 설명 (해당 web page 에서 설명) - Tizen Project 구조 동작 방식 (작년도 동영상 교육 내용 으로 전달) - WiFi 설정 및 연결 - SDB 사용과 연결하기 - GPIO 사용을 위한 API 설명 - LED 제어 하기(실습)

 [2일차] 

Tizen IoT Platform을 이용한 전자 부품 및 Sensor 실습 - 버튼 입력 받기(실습) - 모션 센서 (실습) - I2C Bus 사용을 위한 API 설명 - illuminance Sensor (실습) - OLED 출력 하기

 [3일차] 

Tizen IoT Platform을 활용한 Digital 거리계 만들기 - Lidar Sensor 알아보기 - Hardware 배선((실습) - Tizen Project(distance) 설명 - Tizen Project를 활용한 Lidar Sensor 개발 경험 및 개발 멘토링

  ○ 준비물 ( 메이커스페이스에서 구매 준비합니다)

구분

품명

규격

수량

비고

개인

노트북

INTEL I5 이상 권장

1

 교육중에 Mac 셋팅을 지원하지는 않아요. 

재료

목록

Embedded board

Raspberry Pi 3 B

1

 

Lidar Sensor

Lidar Lite V3

1

 

OLED

0.96인치 OLED 디스플레이

모듈 - I2C

1

 

디지털 조도 센서

BH-1750 IIC bus

1

 

8-Channel 10bit

ADC SPI Interface

MCP3008

1

 

 

Motion Sensor

HC-SR501

1

 

 

 

 

 

 

USB to TTL Convert

PL2303

1

 

Bread Board

Half Size Breadboard

1

 

Raspberry Pi power

DC5V / MAX 2.5A

1

 

Electrolytic Capacitors

470 uF/ 16V

1

 

Yellow LED

5 pi, 5mm

1

 

Green LED

5 pi, 5mm

1

 

Resistance

2.7Kohm 1/4W

2

 

Resistance

330ohm 1/4W

2

 

※ 교육 참여자는 개인 노트북 및 USB 지참하여야 합니다. 
※ 교육에 사용되는 노트북 OS 는 Windows10 를 사용 합니다. Linux OS 및 Mac OS는 지원 하지 않습니다.
※ 교육 참여자는 전자 부품 및 C 언어에 대한 이해도가 중급이상이어야 합니다. 
※ 이 교육은 전자부품 및 센서 모듈을 중점 적으로 설명할 예정으로 Tizen에 연관된 클라우드는 다루지 않습니다. 

□ 참가신청
 ○ 천만원 가까이 비용이 투입되는 워크숍으로 불참시 반드시 통보요망, 미 통보시 향후 워크숍 참여불가
 ○ 참가비는 2만원을 받을 예정이며, 이는 최종일에 상호 네트워킹의 음료 구매시 실비로 사용할 예정입니다. 영수증은 제공되지 않으며, 영수증이 필요하신 분은 당일 근처 편의점에서 음료를 구매해서 가져오시면 됩니다. 

SDTA7D 보드 <사진=서울산업진흥원(SBA) 제공>

지난해 11월 아틱 브랜드가 종료된 이후,
지난 반년간 타이젠 플랫폼이 탑재된 보드를 개발하였습니다.

후원 : 서울산업진흥원 G Camp
제작 : Sigma Delta Technologies
기술지원 : 삼성전자
보드명 :  SDTA7D, Sigma Delta Technologies Arm cortex 7 Dual

조만간 인터넷으로도 구매할 수 있을 예정입니다.
구매가능하게 되면 이 게시물에 관련 정보를 추가하겠습니다.

관련기사 : http://www.etnews.com/20190722000115

 

서울시-SBA 메이커스랩 G·CAMP, 사물인터넷용 리눅스 보드 출시

[전자신문인터넷 박동선기자] 서울산업진흥원(대표 장영승, 이하 SBA)이 상용 하드웨어 보드 공급을 토대로 사물인터넷(IoT) 산업 활성화를 촉진한다. 최근 SBA 측은 산하 메이커스페이스 랩 G·CAMP(지&midd

www.etnews.com

 



안녕하세요, 타이젠 개발자 윤진입니다.


전자신문을 비롯하여 몇 개의 언론사에서 타이젠 기반 IoT 개발 워크숍에 대한 기사를 다뤘습니다..

근데 전자신문이 내용을 제일 잘 이해하고 썼네요.


전자신문 : http://www.etnews.com/20180727000135

한국경제 : http://news.hankyung.com/article/201807275359a





해커톤에서 사용된 자료를 공유합니다.

- 이은영님, '타이젠 IoT 환경설정',  Tizen_IoT_Environment.pdf

- 한준규님, '타이젠 앱 개발 기초',  Tizen_IoT_App_Basic_Development.pdf

- 손보연님, 'GPIO', https://craftroom.tizen.org/smart-motion-light-smartthings/

- 윤진, 'I2C & PWM', https://craftroom.tizen.org/illuminance_to_servo/

- 박정훈님, 'SPI', https://craftroom.tizen.org/co2/

- 정성문님, 박지원님, 자료는 따로 공유하지 않습니다.




* 본 게시물은 '19. 7. 29(월)에 추가로 수정되었습니다.

  Tizen IoT Preview는 Tizen 4.0에서 베타 버전으로 한시적으로 지원되었습니다.

  Tizen 5.0에서는 더 이상 사용할 수 없습니다.





출처 : https://developer.tizen.org/development/iot-preview/iot-apis


IoT APIs

 

The Tizen IoT API provides a common set of interfaces allowing you to build compelling IoT device applications which achieve native performance. The characteristics include:

  • Common set API, which means that the Tizen IoT API is based on the Tizen 4.0 common profile. The API supports the common set of mobile, wearable, and TV profiles and allows you to make IoT applications, such as network audio applications.
  • Available platform binaries, which allow you to efficiently create an IoT application. Tizen Common Headed binaries for Raspberry Pi 3 and ARTIK 530 have passed the API test verification, which means that you can create IoT applications with a productive quality.

In Preview 1, the Tizen IoT API releases only the native "C" API. Other convenient language types for the API are to be considered in the future.

The following table lists the IoT-specific Tizen platform API group.


Things SDK API

Developing "Things" which are market-ready (with cloud support) has been a challenge for most of the companies and individual developers. The SmartThings™ Things SDK API helps you to create new IoT devices easily. The version number of the first release is 0.9, which is the preview version.

The 2 core components for creating a new device are:

  • SmartThings™ Things JSON Configuration file (device_definition.json)

    For more information on the configuration file details, see Device Definition.

  • Application logic and user interaction

    For more information on using the SmartThings™ Things SDK API, see API Usage.

Figure: Creating a new device

Creating a new device

The SmartThings™ (ST) Things SDK provides you an easy and configurable option to build and deploy your own devices quickly:

  • The ST Things SDK provides JSON-based things definition, which:
    • Defines device and platform information.
    • Defines resources that the thing is supporting.
    • Defines an easy-setup configuration.
  • The ST Things SDK provides spec-agnostic APIs, which:
    • Hide the interface and resource type details in a request data.
    • Divide a collection resource request into single resource requests.
    • Provide the "property_key" in case of the GET request.

The SmartThings™ Things SDK API provides the following benefits for you:

  • Supporting pin-based and UserConfirm(Certificate)-based OTM in EasySetup.
  • Providing a JSON-based device/resource definition method in a single file:
    • Includes Single resource and Collection resource support.
  • Resources that are defined in a JSON file/string are made internally.
  • Easy APIs to handle requests and responses:
    • Supports request methods: GET and POST.
    • You only need to make a representation (bundle of property values) for a response.
    • You do not need to handle interfaces, as they are handled internally.
    • The request to a collection resource is divided into individual requests to single resources.
  • Cloud setup (Sign-up/Sign-in/Sign-out/Resource publish to cloud) is handled internally.
  • Following operations are handled internally:
    • To respond to an Access Point List (APList) request from a client.
    • To start and stop softAP.
    • To connect to a target WiFi AP (Enroller).
    • To make the whole response data according to the interfaces (such as oic.if.baselineoic.if.b, and oic.if.ll).


API Usage

The following figure illustrates the SmartThings™ Things API life-cycle.

 

 

Figure: SmartThings™ Things API life-cycle

SmartThings Things API life-cycle

Initializing Stack and Callbacks

Once the device configuration JSON file is ready, you can specify the read-only and read-write paths in the st_things_set_configuration_prefix_path() function (optional), and specify the file in the st_things_initialize() function:

bool easysetup_complete = false;
st_things_set_configuration_prefix_path("/ropath/XXX/res", "/rwpath/XXX/data"); /* Optional */
st_things_initialize("sample_device.json", &easysetup_complete);

/* User input can be handled graphically or using CLI */
/* You need to decide that */
if (!easysetup_complete) {
    int cmd = 0;
    printf("[%s]Start Easysetup ? (1:yes, other:no): ", TAG);
    scanf("%d", &cmd);
    if (1 != cmd) {
        st_things_deinitialize();

        return 0;
    }
}

/* Register Callbacks */
st_things_register_request_cb(handle_get_request, handle_set_request);
st_things_register_reset_cb(handle_reset_request, handle_reset_result);
st_things_register_user_confirm_cb(handle_ownership_transfer_request);
st_things_register_things_status_change_cb(handle_things_status_change);

st_things_start();
printf("ST Things Stack started\n");

handle_main_loop();

st_things_stop();
printf("ST Things Stack Stopped\n");
st_things_deinitialize();
printf("ST Things Stack deinitialized\n");

You must define the highlighted code in the above example. The st_XXX() functions come from the ST Things SDK API. For more information, see the API Documentation.

Getting and Setting Request Handling Callbacks

Assume that the following resources and resource types are defined in the sample_device.json file:

Example: Resources and resource types

"resources": {
   "single": [
      {
         "uri": "/switch",
         "types": [
            "oic.r.switch.binary"
         ],
         "interfaces": [
            "oic.if.a",
            "oic.if.baseline"
         ],
         "policy": 3
      },
      {
         "uri": "/audio",
         "types": [
            "oic.r.audio"
         ],
         "interfaces": [
            "oic.if.a",
            "oic.if.baseline"
         ],
         "policy": 3
      }
   ]
}
"resourceTypes": [
   {
      "type": "oic.r.switch.binary",
      "properties": [
         {
            "key": "value",
         "type": 0,
            "mandatory": true,
            "rw": 3
         }
      ]
   },
   {
      "type": "oic.r.audio",
      "properties": [
         {
            "key": "volume",
            "type": 1,
            "mandatory": true,
            "rw": 3
         },
         {
            "key": "mute",
            "type": 0,
            "mandatory": true,
            "rw": 3
         }
      ]
   }
]

The 2 defined resources are:

  • Switch (URI = "/switch")
  • Audio (URI = "/audio")

The following example illustrates the get and set request handlers:

static const char* RES_SWITCH = "/switch";
static const char* RES_AUDIO = "/audio";

bool
handle_get_request(st_things_get_request_message_s* req_msg, st_things_representation_s* resp_rep)
{
    printf("[%s]Received a GET request on %s\n", TAG, req_msg->resource_uri);
    bool ret = false;
    if (0 == strcmp(req_msg->resource_uri, RES_SWITCH)) {
        ret = handle_get_request_on_switch(req_msg, resp_rep);
    } else if (0 == strcmp(req_msg->resource_uri, RES_AUDIO)) {
        ret = handle_get_request_on_audio(req_msg, resp_rep);
    } else {
        printf("[%s]Not supported uri.\n", TAG);
    }

    return ret;
}

bool
handle_set_request(st_things_set_request_message_s* req_msg, st_things_representation_s* resp_rep)
{
    printf("[%s]Received a SET request on %s\n", TAG, req_msg->resource_uri);
    bool ret = false;

    if (0 == strcmp(req_msg->resource_uri, RES_SWITCH)) {
        ret = handle_set_request_on_switch(req_msg, resp_rep);
    } else if (0 == strcmp(req_msg->resource_uri, RES_AUDIO)) {
        ret = handle_set_request_on_audio(req_msg, resp_rep);
    } else {
        printf("[%s]Not supported uri.\n", TAG);
    }

    return ret;
}

The key difference is the req_msg->resource_uri value passed in the callbacks to distinguish the 2 resources. Since the resource URI is unique in the device definition, each resource can be handled separately.

The following examples illustrate the get and set request handling callbacks for a single and multiple properties:

  • For a single property, you must extract the desired property from the request message and update the device property database locally. Once you have updated the device property, you must update the response representation about the updated property which is sent to the client:
    #define TAG "DEVELOPER_DEVICE"
    
    static const char* PROPERTY_VALUE = "value";
    bool g_switch_value = false;
    
    bool
    handle_get_request_on_switch(st_things_get_request_message_s* req_msg, st_things_representation_s* resp_rep)
    {
        printf("[%s]IN-handle_get_request_on_switch() called..\n", TAG);
        printf("[%s]current switch value: %d\n", TAG, g_switch_value);
    
        resp_rep->set_bool_value(resp_rep, PROPERTY_VALUE, g_switch_value);
    
        printf("[%s]OUT-handle_get_request_on_switch() called..\n", TAG);
    
        return true;
    }
    
    bool
    handle_set_request_on_switch(st_things_set_request_message_s* req_msg, st_things_representation_s* resp_rep)
    {
        printf("[%s]IN-handle_set_request_on_switch() called..\n", TAG);
        printf("[%s]current switch value: %d\n", TAG, g_switch_value);
    
        bool desired_value = false;
        req_msg->rep->get_bool_value(req_msg->rep, PROPERTY_VALUE, &desired_value);
    
        printf("[%s]desired switch value: %d\n", TAG, desired_value);
        g_switch_value = desired_value;
        printf("[%s]changed switch value: %d\n", TAG, g_switch_value);
    
        resp_rep->set_bool_value(resp_rep, PROPERTY_VALUE, g_switch_value);
    
        printf("[%s]OUT-handle_set_request_on_switch() called..\n", TAG);
    
        return true;
    }
  • For multiple properties, the process is the same, except that you need to handle multiple properties at the same time:
    #define TAG "DEVELOPER_DEVICE"
    static const char* PROPERTY_VOLUME = "volume";
    static const char* PROPERTY_MUTE = "mute";
    int64_t g_audio_volume = 0;
    bool g_audio_mute = false;
    
    bool
    handle_get_request_on_audio(st_things_get_request_message_s* req_msg, st_things_representation_s* resp_rep)
    {
        printf("[%s]IN-handle_get_request_on_audio() called..\n", TAG);
        printf("[%s]current audio volume: %"PRId64".\n", TAG, g_audio_volume);
        printf("[%s]current audio mute: %d.\n", TAG, g_audio_mute);
    
        resp_rep->set_int_value(resp_rep, PROPERTY_VOLUME, g_audio_volume);
        resp_rep->set_bool_value(resp_rep, PROPERTY_MUTE, g_audio_mute);
        printf("[%s]OUT-handle_get_request_on_audio() called..\n", TAG);
    
        return true;
    }
    
    bool
    handle_set_request_on_audio(st_things_set_request_message_s* req_msg, st_things_representation_s* resp_rep)
    {
        printf("[%s]IN-handle_set_request_on_audio() called..\n", TAG);
        printf("[%s]current audio volume: %"PRId64".\n", TAG, g_audio_volume);
        printf("[%s]current audio mute: %d\n", TAG, g_audio_mute);
    
        int64_t desired_volume = 0;
        bool desired_mute = false;
        req_msg->rep->get_int_value(req_msg->rep, PROPERTY_VOLUME, &desired_volume);
        req_msg->rep->get_bool_value(req_msg->rep, PROPERTY_MUTE, &desired_mute);
    
        printf("[%s]desired audio volume: %"PRId64".\n", TAG, desired_volume);
        printf("[%s]desired audio mute: %d.\n", TAG, desired_mute);
    
        g_audio_volume = desired_volume;
        g_audio_mute = desired_mute;
    
        printf("[%s]changed audio volume: %"PRId64".\n", TAG, g_audio_volume);
        printf("[%s]changed audio mute: %d.\n", TAG, g_audio_mute);
    
        resp_rep->set_int_value(resp_rep, PROPERTY_VOLUME, g_audio_volume);
        resp_rep->set_bool_value(resp_rep, PROPERTY_MUTE, g_audio_mute);
    
        printf("[%s]OUT-handle_set_request_on_audio() called..\n", TAG);
    
        return true;
    }

Notifying Observers

The following example illustrates how you can notify observers:

#define TAG "DEVELOPER_DEVICE"
static const char* RES_SWITCH = "/switch";
static const char* RES_AUDIO = "/audio";
static const char* PROPERTY_VALUE = "value";
bool g_switch_value = false;

bool
notify_observers(const char *resource_uri)
{
    printf("[%s] Notify all observers for resource = %s\n", TAG, resource_uri);
    bool ret = false;
    if (0 == strcmp(resource_uri, RES_SWITCH)) {
        ret = st_things_notify_observers(resource_uri);
    } else if (0 == strcmp(resource_uri, RES_AUDIO)) {
        ret = st_things_notify_observers(resource_uri);
    } else {
        printf("[%s]Not supported uri.\n", TAG);
    }

    return ret;
}

bool
handle_set_request_on_switch(st_things_set_request_message_s* req_msg, st_things_representation_s* resp_rep)
{
    printf("[%s]IN-handle_set_request_on_switch() called.\n", TAG);
    printf("[%s]current switch value: %d\n", TAG, g_switch_value);
    bool is_value_changed = false;
    bool desired_value = false;
    req_msg->rep->get_bool_value(req_msg->rep, PROPERTY_VALUE, &desired_value);

    printf("[%s]desired switch value: %d\n", TAG, desired_value);
    if (g_switch_value = desired_value) {
        g_switch_value = desired_value;
        is_value_changed = true;
    }
    resp_rep->set_bool_value(resp_rep, PROPERTY_VALUE, g_switch_value);

    if (is_value_changed) {
        notify_observers(req_msg->resource_uri);
    }
    printf("[%s]OUT-handle_set_request_on_switch() called..\n", TAG);

    return true;
}

IoTivity Information

The following table lists the resource types supported by IoTivity.

Table: IoTivity resource types

Resource type nameResource type value
Deviceoic.wk.d
Platformoic.wk.p
Discoveryoic.wk.res
Presenceoic.wk.ad
Collectionoic.wk.col

The following table shows the IoTivity interfaces that specify how the device returns its response. These interfaces can be used by the IoTivity client (such as Samsung Connect) to retrieve information from the server (device).

Table: IoTivity interfaces for responses

NameInterfaceDescription
Baselineoic.if.baselineIncludes all information about the resource, including metadata and collection information. This is the default interface type.
Linked Listoic.if.llIncludes only the collection information about the resource. This is the default interface type for /oic/res.
Batchoic.if.bAllows for the aggregation of interaction with all resources. Each resource is interacted with separately, but their responses are aggregated.

The following table lists other interface types that are related to permissions. These interfaces are relevant for retrieve and update requests.

Table: IoTivity interfaces for permissions

NameInterfaceDescription
Readoic.if.rAllows values to be read.
Read Writeoic.if.rwAllows values to be read and written.
Actuatoroic.if.aAllows creating, updating, and retrieving actuator values.
Sensoroic.if.sAllows sensor values to be read.



Tizen Peripheral I/O Native API

Tizen IoT provides the Peripheral I/O APIs for IoT devices to control peripherals, such as sensors and actuators, using industry-standard protocols and interfaces:

  • GPIO (General-Purpose Input/Output)
  • PWM (Pulse-Width Modulation)
  • SPI (Serial Peripheral Interface)
  • I2C (Inter-Integrated Circuit)
  • UART (Universal Asynchronous Receiver-Transmitter)

Since each peripheral supports different interfaces and protocols, you must check from the peripheral's specifications whether a specific protocol is supported. Peripheral I/O APIs are categorized based on the protocol.

Figure: Peripherals connected to an IoT device

Peripherals connected to an IoT device

Supported Protocols

The following table lists the supported protocols for the Tizen IoT hardware targets.

Table: Protocols supported by the Tizen IoT hardware targets

ProtocolARTIK 530Raspberry Pi 3
GPIOYesYes
PWMYesNo
SPIYesYes
I2CYesYes
UARTYesYes

The following figures illustrate the pinout information for the Tizen IoT hardware targets.

Figure: ARTIK 530 pinout

ARTIK 530 pinout

Figure: Raspberry Pi 3 pinout

Raspberry Pi 3 pinout

Prerequisites

  1. To use the Peripheral I/O API, the application has to request permission by adding the following platform privilege to the tizen-manifest.xml file:
    <privileges>
       <privilege>http://tizen.org/privilege/peripheralio</privilege>
    </privileges>

    To obtain authorization to use platform-level privileges, the application must be signed with a platform-level distributor certificate. Create a certificate profile for signing the application:

    1. To open the Certificate Manager, in the Tizen Studio menu, go to Tools > Certificate Manager.

      Certificate Manager

    2. To add a new certificate profile for signing your application, click + in the Certificate Manager and enter a profile name.

      Add a new profile

    3. Select Create a new author certificate and click Next.

      Create an author certificate

    4. Enter the key file name, author name, password, and password again. If you want to provide more information for the certificate, enter the details after unfolding the More details section.

      Add author certificate details

    5. Select Use the default Tizen distributor certificate and the Platform privilege level, and click Finish.

      The new platform-level certificate is created and shown in the Certificate Manager.

      Select privilege level

      View new certificate

  2. To use the functions and data types of the Peripheral I/O API, include the <peripheral_io.h> header file in your application:
    #include <peripheral_io.h>


GPIO

GPIO (General-Purpose Input/Output) is a programmable interface for reading the state of binary input peripherals, such as a switch, and controlling the state of binary output peripherals, such as a LED.

GPIO sets a direction for the data transfer. It can also detect an interrupt signaled by a level transition: either a falling edge (high to low) or a rising edge (low to high). To detect the interrupt signal you want, set the appropriate edge mode.

GPIO offers the following edge modes:

  • Rising mode detects data changes from low to high.
  • Falling mode detects data changes from high to low.

Figure: GPIO edge modes

GPIO edge modes

Opening and Closing a Handle

To open and close a handle:

  1. To open a GPIO handle, use the peripheral_gpio_open() function:
    int pin = 26; /* ARTIK 530 : GPIO8, Raspberry Pi 3 : GPIO26 */
    peripheral_gpio_h gpio_h;
    peripheral_gpio_open(pin, &gpio_h);

    The pin parameter required for this function must be set according to the following tables.

    Table: ARTIK 530

    Pin namePin (parameter 1)Pin namePin (parameter 1)
    GPIO0128GPIO1129
    GPIO2130GPIO346
    GPIO414GPIO541
    GPIO625GPIO70
    GPIO826GPIO927

    Table: Raspberry Pi 3

    Pin namePin (parameter 1)Pin namePin (parameter 1)
    GPIO44GPIO55
    GPIO66GPIO1212
    GPIO1313GPIO1616
    GPIO1717GPIO1818
    GPIO1919GPIO2020
    GPIO2121GPIO2222
    GPIO2323GPIO2424
    GPIO2525GPIO2626
    GPIO2727--
    NoteFor more information on the pin names and locations, see Supported Protocols.
  2. To close a GPIO handle that is no longer used, use the peripheral_gpio_close() function:
    peripheral_gpio_close(gpio_h);

Setting the Data Direction

To set the data transfer direction, use the peripheral_gpio_set_direction() function with 1 of the following direction types:

  • PERIPHERAL_GPIO_DIRECTION_IN: Input mode to receive data from a binary output peripheral.
  • PERIPHERAL_GPIO_DIRECTION_OUT_INITIALLY_HIGH: Output mode to send data to a binary output peripheral. This value initializes the output peripheral state as high.
  • PERIPHERAL_GPIO_DIRECTION_OUT_INITIALLY_LOW: Output mode to send data to a binary output peripheral. This value initializes the output peripheral state as low.
peripheral_gpio_set_direction(gpio_h, PERIPHERAL_GPIO_DIRECTION_OUT_INITIALLY_LOW);
NoteTo set the data direction to PERIPHERAL_GPIO_DIRECTION_OUT_INITIALLY_HIGH or PERIPHERAL_GPIO_DIRECTION_OUT_INITIALLY_LOW, the edge mode must be set to PERIPHERAL_GPIO_EDGE_NONE.

Setting the Edge Mode

To set the edge mode, use the peripheral_gpio_set_edge_mode() function with 1 of the following edge mode types:

  • PERIPHERAL_GPIO_EDGE_NONE: No edge mode.
  • PERIPHERAL_GPIO_EDGE_RISING: Interrupted at a rising edge (low to high).
  • PERIPHERAL_GPIO_EDGE_FALLING: Interrupted at a falling edge (high to low).
  • PERIPHERAL_GPIO_EDGE_BOTH: Interrupted at both rising and falling edges.
peripheral_gpio_set_edge_mode(gpio_h, PERIPHERAL_GPIO_EDGE_RISING);
NoteTo set the edge mode to PERIPHERAL_GPIO_EDGE_RISINGPERIPHERAL_GPIO_EDGE_FALLING, or PERIPHERAL_GPIO_EDGE_BOTH, the data direction must be set to the PERIPHERAL_GPIO_DIRECTION_IN.

Setting the Interrupted Callback

The interrupted callback is called when the GPIO state changes, based on the selected edge mode.

The interrupted callback is unset when the peripheral_gpio_unset_interrupted_cb() function is called or when the callback receives an error value other than PERIPHERAL_ERROR_NONE.

To implement the interrupted callback:

  1. Define the interrupted callback content.
    static void
    interrupted_cb(peripheral_gpio_h gpio_h, peripheral_error_e error, void *user_data)
    {
        /* Code you want to run when the interrupt occurs */
    }
  2. Set the callback with the peripheral_gpio_set_interrupted_cb() function:
    peripheral_gpio_set_interrupted_cb(gpio_h, interrupted_cb, NULL);
  3. When no longer needed, unset the interrupt callback with the peripheral_gpio_unset_interrupted_cb()function:
    peripheral_gpio_unset_interrupted_cb(gpio_h);

Reading and Writing Binary Data

To read and write binary data:

  • To read binary data from a peripheral, use the peripheral_gpio_read() function:
    uint32_t value;
    peripheral_gpio_read(gpio_h, &value);
  • To write binary data to a peripheral, use the peripheral_gpio_write() function:
    uint32_t value = 1;
    peripheral_gpio_write(gpio_h, value);
NoteTo write binary data, the data direction must be set to PERIPHERAL_GPIO_DIRECTION_OUT_INITIALLY_HIGHor PERIPHERAL_GPIO_DIRECTION_OUT_INITIALLY_LOW.


PWM

PWM (Pulse-Width Modulation) is a programmable interface that allows you to, for example, control motor speed or change light brightness.

Peripherals that support PWM are controlled by the current strength. To modulate the current, the voltage needs to be modulated. The voltage is proportional to the intensity of the current.

To modulate the voltage, you must set the duty cycle and polarity:

  • The period is a constant interval at which the pulse repeats.
  • The duty cycle is the constant time within 1 period in which a signal is active.
  • A "polarity high" signal starts high for the duration of the duty cycle and goes low for the remainder of the period. Conversely, a "polarity low" signal starts low for the duration of the duty cycle and goes high for the remainder of the period.
  • The pulse repeats if repetition has been enabled.

Figure: Duty cycle

Duty cycle

For example, if the period is 10,000,000 nanoseconds and the polarity high duty cycle is 7,000,000 nanoseconds, the average voltage is at 70%.

Figure: Average voltage per duty cycle

Average voltage per duty cycle

Opening and Closing a Handle

To open and close a handle:

  1. To open a PWM handle, use the peripheral_pwm_open() function:
    int chip = 0;
    int pin = 2;
    peripheral_pwm_h pwm_h;
    peripheral_pwm_open(chip, pin, &pwm_h);

    The chip and pin parameters required for this function must be set according to the following table.

    Table: ARTIK 530

    Pin nameChip (parameter 1)Pin (parameter 2)
    PWM002
    NoteFor more information on the pin names and locations, see Supported Protocols.
  2. To close a PWM handle that is no longer used, use the peripheral_pwm_close() function:
    peripheral_pwm_close(pwm_h);

Setting the Period

To set the period, use the peripheral_pwm_set_period() function.

The following example sets the period to 20 milliseconds. The unit is nanoseconds.

Uint32_t period = 20000000;
peripheral_pwm_set_period(pwm_h, period);

Setting the Duty Cycle

To set the duty cycle, use the peripheral_pwm_set_duty_cycle() function.

The following example sets the duty cycle to 2 milliseconds. The unit is nanoseconds.

uint32_t duty_cycle = 2000000;
peripheral_pwm_set_duty_cycle(pwm_h, duty_cycle);

Setting the Polarity

To set the polarity, use the peripheral_gpio_set_polarity() function with 1 of the following polarity types:

  • PERIPHERAL_PWM_POLARITY_ACTIVE_HIGH: Polarity is high.
  • PERIPHERAL_PWM_POLARITY_ACTIVE_LOW: Polarity is low.
peripheral_pwm_set_polarity(pwm_h, PERIPHERAL_PWM_POLARITY_ACTIVE_HIGH);

Enabling Repetition

To enable repetition, use the peripheral_pwm_set_enabled() function:

bool enable = true;
peripheral_pwm_set_enabled(pwm_h, enable);


SPI

SPI (Serial Peripheral Interface) is a programmable interface for transferring data quickly to peripherals that require high performance.

The SPI protocol is a serial communication method that controls the clock signal as master and other peripherals connected to SPI as slaves. This protocol is used by peripherals, such as heart-beat pulse sensors and graphic displays, that require fast data transfer.

Figure: SPI interface diagram

SPI interface diagram

The SPI is a communication method between 1 master and multiple slave devices. In the above figure:

  • CLK (SCLK or SCK) is a simple synchronization signal and a communication clock.
  • The data flows from the master to the slave in the MOSI (Master Out Slave In) line, and from the slave to the master in the MISO (Master In Slave Out) line. Full duplex data communication is possible with 2 lines (MOSI and MISO).
  • CS (Chip Select) is a signal for selecting a slave device.

SPI supports half duplex read/write and full duplex transfer.

To use SPI, you must set the following:

  • SPI mode

    Figure: SPI modes

    SPI modes

    Each of the 4 available SPI modes defines a specific combination of clock polarity (CPOL) and clock phase (CPHA).

    Table: SPI modes

    SPI mode

    Polarity

    (CPOL)

    Phase

    (CPHA)

    Description
    SPI MODE 000CLK (Clock) is first low and data is sampled on the rising edge of each clock pulse.
    SPI MODE 101CLK is first low and data is sampled on the falling edge of each clock pulse.
    SPI MODE 210CLK is first high and data is sampled on the falling edge of each clock pulse.
    SPI MODE 311CLK is first high and data is sampled on the rising edge of each clock pulse.
  • Bit order

    The bit order refers to the sequential order in which bytes are arranged into larger numerical values. MSB indicates that the most significant bit is transmitted first. LSB indicates that the least significant bit is transmitted first.

  • Bit per word

    The bit per word refers to the number of bits to be transmitted at a time when data is exchanged with a connected slave. Normally, it is set to 8 bits per word.

  • Frequency

    The frequency refers to the clock signal in Hz. Since the frequencies are different for each slave device, the applicable value must be checked from the peripheral's specification.

Opening and Closing a Handle

To open and close a handle:

  1. To open a SPI handle, use the peripheral_spi_open() function:
    int bus = 2;
    int chip_select = 0;
    peripheral_spi_h spi_h;
    peripheral_spi_open(bus, chip_select, &spi_h);

    The bus and chip_select parameters required for this function must be set according to the following tables.

    Table: ARTIK 530

    Pin nameBus (parameter 1)Chip Select (parameter 2)
    SPI0_MOSISPI0_MISOSPI0_CLKSPI0_CS20

    Table: Raspberry Pi 3

    Pin nameBus (parameter 1)Chip Select (parameter 2)
    SPI0_MOSISPI0_MISOSPI0_CLKSPI0_CS000
    SPI0_MOSISPI0_MISOSPI0_CLKSPI0_CS101
    NoteFor more information on the pin names and locations, see Supported Protocols.
  2. To close a SPI handle that is no longer used, use the peripheral_spi_close() function:
    peripheral_spi_close(spi_h);

Setting the SPI Mode

To set the SPI mode, use the peripheral_spi_set_mode() function with 1 of the following mode types:

  • PERIPHERAL_SPI_MODE_0: CLK is active high and sampled at the rising edge.
  • PERIPHERAL_SPI_MODE_1: CLK is active high and sampled at the falling edge.
  • PERIPHERAL_SPI_MODE_2: CLK is active low and sampled at the rising edge.
  • PERIPHERAL_SPI_MODE_3: CLK is active low and sampled at the falling edge.
peripheral_spi_set_mode(spi_h, PERIPHERAL_SPI_MODE_1);

Setting the Bit Order

To set the bit order, use the peripheral_spi_set_bit_order() function with 1 of the following bit order types:

  • PERIPHERAL_SPI_BIT_ORDER_MSB: Use the most significant bit first.
  • PERIPHERAL_SPI_BIT_ORDER_LSB: Use the least significant bit first.
peripheral_spi_set_bit_order(spi_h, PERIPHERAL_SPI_BIT_ORDER_MSB);
NoteThe ARTIK 530 and Raspberry Pi 3 boards do not support the LSB bit order.

Setting the Bits per Word

To set the bits per word, use the peripheral_spi_set_bits_per_word() function:

uint8_t bits_per_word = 8;
peripheral_spi_set_bits_per_word(spi_h, bits_per_word);

Setting the Frequency

To set the frequency, use the peripheral_spi_set_frequency() function.

The frequency unit is Hz.

uint32_t frequency = 1024;
peripheral_spi_set_frequency(spi_h, frequency);

Reading, Writing, and Transferring Data

To read, write, and transfer data:

  • To read data from a slave device, use the peripheral_spi_read() function:
    uint8_t data;
    uint32_t length = 1;
    peripheral_spi_read(spi_h, &data, length);
  • To write data to a slave device, use the peripheral_spi_write() function:
    uint8_t data = 0x80;
    uint32_t length = 1;
    peripheral_spi_read(spi_h, &data, length);
  • To exchange bytes data with a slave device, use the peripheral_spi_transfer() function:
    uint8_t tx_data[2] = {0x80, 0x01};
    uint8_t rx_data[2];
    uint32_t length = 2;
    peripheral_spi_transfer(spi_h, tx_data, rx_data, length);


I²C

I2C (Inter-Integrated Circuit) is a programmable interface that allows you to communicate with I2C peripherals.

I2C is a synchronous serial interface that uses a clock signal to synchronize data transfers between master and slave device:

  • Master device generates the clock and initiates communication with slaves.
  • Slave device receives the clock and responds when addressed by the master.

Figure: I2C interface diagram

I2C interface diagram

To allow the I2C master to connect to 128 I2C slave devices, an I2C slave device provides a 7-bit address. Since most slave addresses are determined by the manufacturer, refer to the specification to find the slave device address.

Using the I2C bus, the master controls signal lines called SCL (Shared CLock) and SDA (Shared DAta) to read or write data to or from the device. SCL is a clock line for communication synchronization, and SDA is a data line. The master outputs the clock for synchronization with the SCL, and the slave outputs or receives data through the SDA according to the clock output to the SCL.

If the SDA line is used alone, only half duplex communication is possible because data is sent only to 1 line.

Opening and Closing a Handle

To open and close a handle:

  1. To open an I2C handle, use the peripheral_i2c_open() function:
    int bus = 1;
    int address = ...;   /* See the specification */
    peripheral_i2c_h i2c_h;
    peripheral_i2c_open(bus, address, &i2c_h);

    The bus parameter required for this function must be set according to the following table.

    Table: ARTIK 530 / Raspberry Pi 3

    Pin nameBus number (parameter 1)
    I2C1_SDAI2C1_SCL1
    NoteFor more information on the pin names and locations, see Supported Protocols.

    The address parameter must be set based on the peripheral specification.

  • To close an I2C handle that is no longer used, use the peripheral_i2c_close() function:
    peripheral_i2c_close(i2c_h);

Reading and Writing Data

To read and write data:

  • To write bytes to a slave device, use the peripheral_i2c_write() function:
    uint8_t data[2] = {0x06, 0x01};
    uint32_t length = 2;
    peripheral_i2c_write(i2c_h, data, length);
  • To read bytes from a slave device, use the peripheral_i2c_read() function:
    uint8_t data[2];
    uint32_t length = 2;
    peripheral_i2c_read(i2c_h, data, length);

Reading and Writing Register Data

To read and write register data:

  • To write single byte data to a slave device register, use the peripheral_i2c_write_register_byte() function:
    uint8_t data = 0x06;
    uint8_t register_address = ...;  /* See the specification */
    peripheral_i2c_write_register_byte(i2c_h, register_address, data);
  • To read single byte data from a slave device register, use the peripheral_i2c_read_register_byte() function:
    uint8_t data ;
    uint8_t register_address = ...;  /* See the specification */
    peripheral_i2c_read_register_byte(i2c_h, register_address, &data);
  • To write word data to a slave device register, use the peripheral_i2c_write_register_word() function:
    uint16_t data = 0xffff;
    uint8_t register_address = ...;  /* See the specification */
    peripheral_i2c_write_register_word(i2c_h, register_address, data);
  • To read word data from a slave device register, use the peripheral_i2c_read_register_word() function:
    uint16_t data ;
    uint8_t register_address = ...;  /* See the specification */
    peripheral_i2c_read_register_word(i2c_h, register_address, &data);


UART

UART (Universal Asynchronous Receiver-Transmitter) is a programmable interface that allows you to communicate 1:1 with a UART peripheral.

Figure: UART interface diagram

UART interface diagram

UART is an interface for exchanging data with peripherals. It is an asynchronous method that transmits data without a clock line, and consists of only 2 data lines: transmit (Tx) and receive (Rx). UART performs 1:1 communication.

Figure: UART data frame

UART data frame

The UART data frame consists of start (1 bit), data (5~8 bit), parity (1 bit) and stop (1 bit):

  • Start bit

    Indicates the start of the communication before sending data and holds it for a bit time length.

  • Data

    Transmits 5 to 8 bits of data.

  • Parity bit

    Generates and transmits a parity value for error verification, and determines a receiving side error. The following options are available: NoneEven, and Odd parity. Selecting None removes this bit.

  • Stop bit

    Indicates the termination of the communication and holds 1 or 2 bits.

  • Baud rate

    Asynchronous transmission/receiving speeds must be matched to the peripheral. For this purpose, the number of signals transmitted per second can be synchronized with a peripheral. It is called the Baud.

If a device supports a 5-wire UART port, hardware flow control can be used to increase the reliability of the data transmission. Software flow control can also be used to increase reliability.

Opening and Closing a Handle

To open and close a handle:

  1. To open a UART handle, use the peripheral_uart_open() function:
    int port = 4; /* ARTIK 530 : UART0 */
    peripheral_uart_h uart_h;
    peripheral_uart_open(port, &uart_h);

    The port parameter required for this function must be set according to the following tables.

    Table: ARTIK 530

    Pin namePort (parameter 1)
    UART0_RXUART0_TX4

    Table: Raspberry Pi 3

    Pin namePort (parameter 1)
    UART0_RXUART0_TX0
    NoteFor more information on the pin names and locations, see Supported Protocols.
  2. To close a UART handle that is no longer used, use the peripheral_uart_close() function:
    peripheral_uart_close(uart_h);

Setting the Baud Rate

To set the baud rate, use the peripheral_uart_set_baud_rate() function with a baud rate value:

  • PERIPHERAL_UART_BAUD_RATE_0 ~ PERIPHERAL_UART_BAUD_RATE_230400
peripheral_uart_set_baud_rate(uart_h, PERIPHERAL_UART_BAUD_RATE_9600);

Setting the Byte Size

To set the byte size, use the peripheral_uart_set_byte_size() function with 1 of the following byte size types:

  • PERIPHERAL_UART_BYTE_SIZE_5BIT: Byte size is 5 bits.
  • PERIPHERAL_UART_BYTE_SIZE_6BIT: Byte size is 6 bits.
  • PERIPHERAL_UART_BYTE_SIZE_7BIT: Byte size is 7 bits.
  • PERIPHERAL_UART_BYTE_SIZE_8BIT: Byte size is 8 bits.
peripheral_uart_set_byte_size(uart_h, PERIPHERAL_UART_BYTE_SIZE_7);

Setting the Parity Bit

To set the parity bit, use the peripheral_uart_set_parity() function with 1 of the following parity types:

  • PERIPHERAL_UART_PARITY_NONE: No parity bit.
  • PERIPHERAL_UART_PARITY_EVEN: Parity bit is even.
  • PERIPHERAL_UART_PARITY_ODD: Parity bit is odd.
peripheral_uart_set_parity(uart_h, PERIPHERAL_UART_PARITY_EVEN);

Setting the Stop Bits

To set the stop bits, use the peripheral_uart_set_stop_bits() function with 1 of the following stop bit types:

  • PERIPHERAL_UART_STOP_BITS_1BIT: 1 bit is used for stop bits.
  • PERIPHERAL_UART_STOP_BITS_2BIT: 2 bit is used for stop bits.
peripheral_uart_set_stop_bits(uart_h, PERIPHERAL_UART_STOP_BITS_2BIT);

Setting the Flow Control

To set the hardware and software flow control, use the peripheral_uart_set_flow_control() function with 1 of the following flow control types:

  • PERIPHERAL_UART_SOFTWARE_FLOW_CONTROL_NONE: No software flow control.
  • PERIPHERAL_UART_SOFTWARE_FLOW_CONTROL_XONXOFF: Software flow control uses XONXOFF.
  • PERIPHERAL_UART_HARDWARE_FLOW_CONTROL_NONE: No hardware flow control.
  • PERIPHERAL_UART_HARDWARE_FLOW_CONTROL_AUTO_RTSCTS: Hardware flow control uses RTSCTS.
peripheral_uart_set_flow_control(uart_h, PERIPHERAL_UART_SOFTWARE_FLOW_CONTROL_XONXOFF, PERIPHERAL_UART_HARDWARE_FLOW_CONTROL_AUTO_RTSCTS);

Reading and Writing Data

To read and write data:

  • To write data to a slave device, use the peripheral_uart_write() function:
    uint8_t data[2] = {0x06, 0x01};
    uint32_t length = 2;
    peripheral_uart_write(uart_h, data, length);
  • To read data from a slave device, use the peripheral_uart_read() function:
    uint8_t data[2];
    uint32_t length = 2;
    peripheral_uart_read(uart_h, data, length);



안녕하세요, 타이젠 개발자 윤진입니다.


Tizen Studio 2.0 설치경로에 빈칸이 있으면,

Remote Device Manager에서 디바이스가 제대로 안붙는 문제가 있습니다.



Remote Device Manager


Tools > Device Manager > Remote Device Manager

위의 메뉴에서 스캔버튼을 눌러서 검색된 Remote Device의 상태를 off > on으로 변경해도

선택한 Remote Device가 Tizen Studio에 연결되지 않습니다.


위의 문제는 Tizen Studio 설치경로에 빈칸이 있을때 발생하고,

Remote Deivice Manager가 내부적으로 sdb.exe 커맨드를 실행할 때,

공백처리를 하고 있지 않아서 발생한 문제라고 합니다.


Tizen Studio 1.3에는 지원되었었지만,

2.0에서는 공백 처리 부분이 누락되었다고 합니다.

차기 Hotfix 버전에는 이 부분이 수정될 것으로 보입니다.


설치에 불편을 드려 죄송합니다.

  1. 안녕하세요 2018.02.13 22:56

    티스토리 가입하고 싶은데 괜찮으시면 초대장 보내주실수 있나요? 부탁드립니다. 감사합니다.

  2. 안녕하세요 2018.02.13 22:56

    티스토리 가입하고 싶은데 괜찮으시면 초대장 보내주실수 있나요? 부탁드립니다. 감사합니다.


안녕하세요,

타이젠 개발자 윤진입니다.


Tizen Studio 1.3 → 2.0 업그레이드 후,

Connection Explorer View가 깨지는 문제가 발생할 수 있습니다.


타이젠 스튜디오 런칭 직후,

오른편에 위치한 Connection explorer 영역을 보시면 아래와 같은 에러문구가 나옵니다.

"Could not create the view: org.tizen.common.connection.explorer.ConnectionExplorer"


이 문제는 Connection Explorer가 Device Manager로 변경되며 발생한 문제로 두가지 해결책이 있습니다.


해결책 #1

아래 그림처럼 Window > Perspective > Reset Perspective를 선택해주세요.





해결책 #2

타이젠 스튜디오 2.0을 설치한 이후에,

> eclipse.exe -clean -clearPersistedState

위의 명령어를 수행해주신 이후에 타이젠 스튜디오 2.0을 다시 실행해주세요.


본 포스트에 대한 기본내용은 타이젠 SDK팀에서 제공해주셨습니다.



안녕하세요, 타이젠 개발자 윤진입니다.


얼마 전에 출시된 타이젠 스튜디오 2.0을 설치하여 실행할때,

아래 사진처럼 "Decoration Calculation" 에러가 나실 때 해결방법입니다.



Tizen Studio > Window > Preferences > General > Appearance > Label Decorations

위의 메뉴에 진입하여,

"Javascript Function Override Indicator" 항목의 체크를 해제해주면 됩니다.



위의 에러는 이클립스 관련 에러로서 아래 스택오버플로우에서 보고된 내용입니다.

https://stackoverflow.com/questions/27373824/eclipse-an-internal-error-occurred-during-decoration-calculation-java-lang


본 포스트에 대한 기본내용은 타이젠 SDK팀에서 제공해주셨습니다.



안녕하세요, 타이젠 개발자 윤진입니다.


과학기술정보통신부가 주관하고-

정보통신산업진흥원(National IT Industry Promotion Agency) 등이 주관하는 공개SW 커뮤니티데이 행사에 Tizen IoT도 참여하게 되었습니다.

이 행사는 국내 공개SW 커뮤니티, 개발자, SW기업, 대학 등이 참여하여 기술을 교류하고 협력의 장을 만든다는 취지를 갖고 있는 만큼 이번 기회에 일반 개발자들과도 폭넓게 소통하고자 합니다.


이제 막 생긴 행사라서 온라인에 관련 정보를 찾기가 쉽진 않지만-

1회는 올해 9월 22일(금)에 선릉역 근방에서 '클라우드'라는 주제로 열렸고,

2~3회는 지난 10월말에 양재역 근방에서 '빅데이터'를 주제로 열렸으며,

4회는 11월 30일(목)에 명지대에서 '사물인터넷'이란 주제로 열릴 예정입니다.


일시 : '17년 11월 30일(목) 14:00 ~ 18:00

장소 : 명지대학교 자연캠퍼스 창조관

참가자 : 36명


아무래도 명지대학교 캠퍼스 내에서 진행되는 행사이니 만큼,

서울 시내에서 진행한 지난 행사보다 접근성이 많이 떨어집니다.


참가신청은 온오프믹스에서 진행되고 있습니다.

튜토리얼 세션의 경우,

참가자수가 36명으로 제한되어 있기 때문에 금방 마감됩니다.

(이번에는 장소가 장소이니 만큼 금방 마감되지 않을 수도 있겠네요)

참가신청 : https://onoffmix.com/event/119307


행사에 참석하게 되면 아는 척 해주세요~ :)




+ 11. 30(목)

튜토리얼 수업이 진행된 강의실



공개SW와 함께하는 사물인터넷 포스터



행사장에서 참석자에게 배포한 강의자료와 소스코드입니다.

차후에 행사동영상도 올릴테니,

D2C(Device-to-cloud) 방식으로 IoT 환경을 구축하고 싶으신 분은 참고하세요.

tizentalks_1130.zip










안녕하세요, 타이젠 개발자 윤진입니다.


'17년 세번째 DevLab x TizenTalks를 11월 21일(화) 우면동 삼성전자 연구소에서 진행할 예정입니다.

참가신청은 http://www.codeground.org/devlab에 오픈되었는데,

이번에도 소규모로 진행할 예정이라 오픈 직후 바로 마감되었습니다.

관심을 가져주신 많은 분께 감사드립니다.


참여하지 못하신 분들을 위해,

- 차후에도 이와 유사한 주제로 행사를 계속 하려 하고,

- 이번 행사의 세션발표는 모두 촬영하여 유투브에 올리려고 합니다.


DevLab 신청마감


주제는 '타이젠을 활용하여 IoT 쉽게 만들기'로 지난 8월에 진행된 DevLab과 동일한 주제입니다.

그렇지만, 3개월 동안 크고 작은 변화가 있었습니다.

가장 큰 변화는 Device-to-Device 방식에서 Device-to-Cloud 방식으로 연결방법과 대상을 바꾼 점입니다.

그에 따라 발표자료, API Set, Template을 일부 변경하거나 새로 추가하였습니다. 




- 우리는 왜 Tizen IoT를 선택해야 하는가?

- Tizen IoT를 시작하기 위한 환경 설정하기 :  Tizen.IoTivity.Init.pdf

- Thing에 연결된 센서로부터 센서값 읽어오기 :  Tizen.IoTivity.Sensing.pdf

- IoT 세계에서 클라우드와 소통하기 :  Tizen.IoTivity.connectivity.pdf

스케쥴표의 마지막 세션인 'IoT 세계에서 클라우드와 소통하기'가 이번 D2C 트랙에서 새롭게 선보이는 내용입니다.

얼마전 중앙대 강의에서 박정훈 연구원님이 중앙대생들에게 첫 선을 보이기도 하였습니다.


다른 부분도 타이젠이 버전업그레이드하는 흐름에 발맞춰 세부항목이 갱신되고 있습니다.

Tizen Studio 2.0이 최근 출시되었기 때문에 환경설정에 해당 내용이 반영되었습니다.

이 부분은 이근선 연구원님과 이은영 연구원님이 애써주셨습니다.


발표자도 조금씩 변경되었는데 이 부분은 블로그 방문객 분들은 별로 관심없겠죠?

내부적으로 롤을 조금씩 바꿔가면서 진행하고 있기 때문에 발표자도 조금씩 바뀌고 앞으로도 바뀔 예정입니다.


참가신청자들에게 사전에 환경설정 가이드가 이미 배포되었습니다.

새로 나온 Tizen Studio 2.0을 위해 새로 만든 가이드입니다. :)

Tizen을활용하여IoT쉽게만들기_가이드_2.0.pdf


이제 행사가 다음주로 다가왔습니다.

새로운 소식이 있으면 이 곳에 포스트하도록 하겠습니다.



+ 11월 21일(화)

오늘 행사가 큰 탈없이 잘 마무리되었습니다.

발표자 및 튜터분들께 감사의 인사를 전합니다.


최초 신청자 36명 중 33명이 참석하셨다고 합니다.

무언가 의미있는 시간이셨길 빕니다.


행사장 분위기가 담긴 사진 몇 장을 투척합니다.


환경설정 세션진행



동영상은 유투브에 업로드 예정!



센서로부터 검출한 데이터를 서버로 보내는데 성공!



+ 11. 26(일), 당일날 발표동영상이 올라왔습니다.

- 박영주 연구원님, 모두발언



- 윤진 연구원, "왜 타이젠 IoT인가?"



- 이근선 연구원님, "Tizen IoT를 시작하기 위한 환경 설정하기"



- 이은영 연구원님, "Things에 연결된 센서로부터 센서값 읽어오기"



- 박정훈 연구원님, "IoT 세계에서 클라우드와 소통하기"






안녕하세요, 타이젠 개발자 윤진입니다.


지난 월요일(11. 6)&금요일(11. 10)에 중앙대학교에서 Tizen IoT를 주제로 강의가 있었습니다.

Tizen 플랫폼 차원에서 대학교와 연계하게 비정기적으로 행사를 진행하고 있는데,

이번에는 중앙대와 호흡을 맞추게 되었고 3주간 총 9시간 동안 Tizen을 주제로 학생들을 만나고 있습니다.

그 중에 IoT에는 3시간이 주어져서 월요일/금요일 두 번에 걸친 강의안을 준비하였습니다.


졸업 후 겸사겸사 모교는 방문하긴 했지만,

타대학에 강의하러 가는 것은 이번이 처음인지라 강의안부터 신경이 쓰였습니다.



중앙대학교 캠퍼스



Tizen IoT 강의는 실습을 병행하고 있기 때문에,

- 발표자료 뿐만 아니라,

- 인원수 만큼의 디바이스도 준비하고,

- 템플릿 코드도 Step 별로 git repo.에 push하고,

- 실습 중 IoT 결과 확인을 위한 웹서버도 설치하였습니다.

- 강의실의 인터넷환경이 실습결과를 좌우하기 때문에 사전에 네트워크 상태도 파악했죠.


개발자의 본업인 개발을 하며-

부가적으로 강의+실습을 준비해야 하기 때문에 여러 연구원들이 자기 시간을 쪼개어 일을 분담하여 진행하였습니다.

(박정훈 연구원님, 이근선 연구원님, 이은영 연구원님이 고생이 많으셨습니다)


특히, 이번 강의는 기존에 시도하였던 Device-to-Device 방식의 주제에서 방향을 살짝 틀어,

Device-to-Cloud로 진행되는 첫번째 강의라서 준비해야할 것이 있었습니다.

새로운 D2C를 위한 API Set부터 개발해야 했는데,

기존 API Set과 어떤 식으로 어우러지게 만드느냐가 제법 흥미로운 토론거리였습니다.


https://review.tizen.org/gerrit/#/c/159095/

위의 커밋에서 논의의 1차 결과물을 엿보실 수 있습니다.



  extern int connectivity_set_protocol(connectivity_protocol_e protocol_type);
  extern int connectivity_attributes_add_bool(connectivity_resource_s *resource_info, const char *key, bool value);
  extern int connectivity_attributes_add_int(connectivity_resource_s *resource_info, const char *key, int value);
  extern int connectivity_attributes_add_double(connectivity_resource_s *resource_info, const char *key, double value);
  extern int connectivity_attributes_add_string(connectivity_resource_s *resource_info, const char *key, const char *value);
  extern int connectivity_attributes_notify_all(connectivity_resource_s *resource_info);


위와 같은 형태의 connectivity API가 추가되었습니다.

API에 대한 주석도 다른 커밋에 작업되어 있습니다.


준비는 열심히 했지만,

타행사와는 다르게 이번 강의는 참여자가 자발적으로 신청하여 참여하는 행사가 아니라 신경이 쓰였습니다.

전공수업만으로도 충분히 버거운 학생들에게 새로운 분야와 기술을 공유하는 것은... 쉽지 않네요.



강의가 진행된 208동 전경


오전 11시 강의시간보다 일찍 도착하여 준비하였습니다.

이근선 연구원님이 카메라를 설치하여 촬영을 하였으니 머잖아 유투브에 동영상이 올라오겠네요.



강의 시작 10분 전, '강의자료를 다운로드해주세요!'



강의 시작 10분 전, 실습을 준비하는 학생들-


월요일 수업에는,

- Tizen IoT에 대한 간단한 설명 :  Tizen.IoT#0(중앙대).pdf

- 환경설정과 센서사용하기 :  Tizen.IoT#1(중앙대).pdf


금요일 수업에는,

박정훈 연구원님이 Connectivity에 대해 강의하셨습니다.

Tizen.IoT#2(중앙대).pdf


중앙대 수업에는 대략 36명 정도의 학생이 참여하였고,

최종적으로 센싱한 데이터를 웹서버에 전달하는데 성공한 학생은 3명이라고 합니다. :)


수업을 진행하며 동영상을 촬영하였고,

중앙대 컴공과 조교님께 동영상을 올리겠노라 선언을 하고 왔습니다만,

아직 작업이 마무리되지 않아서 차일피일 미루고 있습니다.

작업이 마무리되는대로 본 포스트에 추가로 올리겠습니다.



+ 11. 26(일), 드디어 동영상이 업로드 되었습니다.

월요일에 "Tizen IoT를 위한 환경설정과 센서 사용하기"라는 주제로 발표한 내용입니다.

1시간 30여분 동안 환경설정과 센서부분을 발표하였습니다.

아무래도 시간이 촉박하다보니 아쉬움이 많이 남습니다.



금요일에는 "Tizen IoT Connectivity"를 주제로 박정훈 연구원님이 발표하였습니다.

동영상 42분을 보면 14번 센서에서 데이터를 보내는 것이 성공적으로 캘리포니아 웹서버에 안착된 것을 볼 수 있습니다.

손기성 수석연구원님께서도 동영상에 간혹 등장하시네요.

항상 여러가지로 신세지고 있는데 동영상으로 뵈니 더 반갑네요.





안녕하세요, 타이젠 개발자 윤진입니다.


제 3회 삼성 오픈소스 컨퍼런스가 오는 10월 25일(수)~26일(목) 이틀간 개최됩니다.

올해는 예년보다 빨리 개최된다는 소문이 있었지만 결국 10월로 확정되었습니다.




'삼성 오픈소스 컨퍼런스'라는 행사명만 보면,

오로지 '삼성'이 적극적으로 관여하고 있는 오픈소스 프로젝트만을 다룰 것 같지만 전혀 그렇지 않습니다.

국내외 각종 오픈소스 프로젝트에서 다루는 핫한 기술을 포괄적으로 다루고 있습니다.

행사 주최측에서 다양한 주제를 아우르기 위해 상당히 심혈을 기울이고 있습니다.



삼성 개발자 컨퍼런스에는 오픈소스 타이젠 플랫폼이 빠질 수 없겠죠.

거기에 덧붙여 AI, Security, Smart Machine 등 다양한 주제를 다루고 있습니다.


요즘 참여하고 있는 프로젝트의 주제는,

- Tizen Platform

- IoTivity

- Big Data

위의 3가지로 요약할 수 있는데요,

이번 SOSCON에 위의 3가지를 버무려서 흥미로운 Hands-on Lab을 열게 되었습니다.




현재는 컨퍼러스 참가 신청만 받고 있습니다만,

조만간 Hands-on Lab 참가등록도 받을 예정입니다.


Hands-on Lab은 둘째날 오전 11시부터 오후 5시 15분까지 진행될 예정이고,

Tizen IoTivity를 키워드로 삼아 여러가지 흥미로운 과정을 꾸리게 될 겁니다.


추가적으로 내용이 공개되면 이 포스팅에 계속 업데이트하겠습니다.




+ 9월 28일(목)

오후 2시에 Hands-on Lab 참가신청 사이트가 오픈되었습니다.




Hands-on Lab의 두번째 주제를 보시면,

"DEVLAB 2 + IoT Chagllenge"라고 되어 있는데요.


오전/오후에는 DEVLAB으로 실습세션을 진행하고,

저녁에는 2시간 동안 코딩 컨테스트를 진행하고자 합니다.


모든 컨테스트가 그렇듯,

몇가지 원칙을 세워놓고 준비하고 있습니다.


컨테스트 전 과정은 '공정'하게,

실습에 성실하게 참여한 사람이면 시간 내에 컨테스트의 문제를 완수할 수 있게,

그리고 순위는 모두가 납득할 수 있는 결과를 바탕으로 매겨지게 하려고 합니다.


부가로 이왕이면 '재미있는' 문제를 준비하기 위해 팀원들과 함께 만발의 노력을 기울이고 있습니다.

기대해주세요~!




+ 9월 30일(토)



Hands-on Lab 참가신청까지 마감되었네요.

실습트랙은 참가자수가 몇십명 정도라서 오픈시작과 동시에 마감되는 경우가 많습니다.

참가자수를 늘리면 좋겠지만,

공간/실습장비/튜터가 한정되어 있다보니 인원을 한 명 더 늘리는 것도 쉽지 않네요.


등록에 성공하시는 분들은-

먼 걸음 해주시는 만큼 뭔가 얻어가는게 있으셨으면 좋겠습니다.



 + 10월 25일(수) D-1

참가자들은 타이젠 스튜디오와 필수 유틸리티를 설치해오셔야 합니다.

타이젠 스튜디오는 여기 주소에서 다운로드 받으실 수 있습니다.

필수 유틸리티 설치는 이 파일( DEVLAB2_Tizen을활용하여IoT쉽게만들기_가이드.pdf)을 참조해주세요.


아침에 출근하여 소스콘 전시공간을 구경하며 촬영하였습니다.

유광 흰색 패넬에 푸른색 '소스콘' 글자가 잘 어울리네요.

발표자료를 준비하며 파워포인트 템플릿을 보니 짙은 회색 바탕에 푸른색 '소스콘' 글자도 꽤나 잘 어울려 보였습니다.



전시 부스 공간