yujin-shim.log

OpenAI GYM으로 강화학습 시작하기(1)

Mon, 22 Apr 2024 13:12:12 GMT

로보틱스에 대한 열정으로 차근차근 나아가보려고 한다!

그 첫걸음으로 강화학습에 대해 알아가보고자 한다. 그 이유는 최근 관심을 가지게 된 뛰어난 성능을 보이는 DreamWaQ가 Deep reinforcement learning을 통해 만들어졌기 때문이다.

DreamWaQ 논문 링크

왕초보로서 강화학습에 첫단계부터 나아가고자 한다.

강화학습

강화학습에서는 에이전트가 주변 환경을 observe하고 Policy에 따라 행동을 하게 되며 그 결과로 보상(+/-)을 받는다. (+)의 보상이 최대가 되도록 학습한다.

OpenAI GYM 환경 만들기

virtualenv 설치하고 환경 활성화하기 자신이 원하는 폴더를 만들어 그 안에서 환경을 활성화 그 후 OpenAI GYM을 만들어주면 된다

  sudo apt install python3-virtualenv
  virtualenv env
  source env/bin/activate
  pip install gym==0.23.1 ```

그 후 Python 파일에 아래 코드를 넣어주면 된다

import gym
env = gym.make('CartPole-v1')
for i_episode in range(20):
    observation = env.reset()
    for t in range(100):
        env.render()
        print(observation)
        action = env.action_space.sample()
        observation, reward, done, info = env.step(action)
        if done:
            print("Episode finished after {} timesteps".format(t+1))
            break
env.close()```

진행하면서 이 링크를 참고했다// OpenAI gym Cartpole

이 python 파일을 실행하면 이렇게 막대를 쓰러뜨리지 않기 위한 스텝을 진행하게 된다.

실행해보고 나면 마지막에 얼마나 많은 스텝을 진행했는지 알 수 있는데 내가 실행한 파일에서는 46 step밖에 진행하지 못했다.

그렇다면 계속되는 시리즈동안 신경망으로 더 좋은 정책(Policy)을 만들 수 있는지 알아가보자

프로그래머스 게임 맵 최단거리(전역변수와 지역변수)

Fri, 04 Aug 2023 08:26:29 GMT

그동안 풀었던 최단거리 문제 = BFS를 이용한 문제로 접근하여 풀었다.

오늘 글에서 다루고 싶은 내용은 문제풀이가 아니다. 벨로그를 조금 더 troubleshooting에 초점을 맞춰서 작성해보려고 한다. 내가 적은 velog를 다시 읽어보니 뭔가 나의 실력을 쌓을 때 도움이 되는 방향인 것 같지 않았다. 백준이나 프로그래머스 문제를 풀면서 만나는 다양한 문제들이 왜 나타났는지, 그리고 어떻게 해결했는지를 중점적으로 적고자 한다.

문제 자체는 전역변수& 지역변수와 관련은 없다. 문제를 만나고 나는 익숙하게 큐를 이용한 BFS 형태로 문제를 풀었다. 그런데, 결과를 제출하고보니 효율성 부분에서 통과하지 못한 것이다.

처음에는 if문을 분리하지 않아서 그런가 했다. 수정해도 효율성 통과를 하지 못했으므로 아니다.

그동안 백지 상태에서 코드를 다 적어야하는 백준과 달리 프로그래머스는 기본적인 틀이 제공되어있다.

그래서 내가 아무런 의심이나 생각없이 main문 안에서 변수들을 선언한 것이다. 여기에서 효율성 통과를 하지 못한 이유가 나온다.

왤까?

그전에 한번 공부를 했었던 내용인데 코드를 짜다보니 간과한 부분이다.

프로그램의 메모리 공간

프로그램이 운영체제로부터 할당받는 대표적인 메모리공간이 있다.

코드 (code) 영역
데이터 (data) 영역
힙 (heap) 영역
스택 (stack) 영역

자료출처: 코딩 시그널

내가 main문 안에서 변수를 선언하였으니 이는 지역변수로 선언한 것이다. 이렇게 되면 컴파일 시간에 영향을 미치게 된다.

전역변수는 DATA 영여긍로 훨씬 low memory로 선언할 수 있다. 그래서 내가 변수들을 전역변수로 (main 함수 밖으로) 선언하고 나니 효율성 테스트를 통과한 것이다.

코딩을 하다보면 이런 부분을 놓칠 수도 있다는 생각이 들며 약간의 위기감을 느꼈다...ㅎㅎ 왜냐하면 테스트케이스에서는 에러 없이 잘 작동했기 때문이다.

방심하지 말고 변수를 적는 위치도 신중하게 설정하자 ^^

전체 코드

#include
#include 
using namespace std;

int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int count[101][101];
bool visited[101][101];
queue> q;

int solution(vector> maps)
{
    int answer = 0;
    int n = maps.size();
    int m = maps[0].size();

    q.push({0,0});
    visited[0][0] = true;
    count[0][0] = 1;

    while(!q.empty())
    {
        int x = q.front().first;
        int y = q.front(). second;
        q.pop();

        for(int step = 0; step<4; step++)
        {
            int x_step = x + dx[step];
            int y_step = y + dy[step];

            if (x_step < 0 || y_step < 0 || x_step >= n || y_step >=m) continue;
            if (visited[x_step][y_step]) continue;
            if (maps[x_step][y_step] != 1) continue;


            visited[x_step][y_step] = true;
            q.push({x_step, y_step});
            count[x_step][y_step] = count[x][y] + 1;
        }
    }

    answer = count[n-1][m-1];
    if(!answer)
        answer = -1;
    return answer;
}

백준 2178 미로 탐색

Thu, 13 Jul 2023 10:21:40 GMT

문제 링크: 미로 탐색

문제

N×M크기의 배열로 표현되는 미로가 있다.

1 0 1 1 1 1 1 0 1 0 1 0 1 0 1 0 1 1 1 1 1 0 1 1

미로에서 1은 이동할 수 있는 칸을 나타내고, 0은 이동할 수 없는 칸을 나타낸다. 이러한 미로가 주어졌을 때, (1, 1)에서 출발하여 (N, M)의 위치로 이동할 때 지나야 하는 최소의 칸 수를 구하는 프로그램을 작성하시오. 한 칸에서 다른 칸으로 이동할 때, 서로 인접한 칸으로만 이동할 수 있다.

위의 예에서는 15칸을 지나야 (N, M)의 위치로 이동할 수 있다. 칸을 셀 때에는 시작 위치와 도착 위치도 포함한다.

입력

첫째 줄에 두 정수 N, M(2 ≤ N, M ≤ 100)이 주어진다. 다음 N개의 줄에는 M개의 정수로 미로가 주어진다. 각각의 수들은 붙어서 입력으로 주어진다.

출력

첫째 줄에 지나야 하는 최소의 칸 수를 출력한다. 항상 도착위치로 이동할 수 있는 경우만 입력으로 주어진다.

문제 풀이 과정

많이 풀어본 유형의 문제이기 때문에 푸는 과정에서 크게 어려움은 없었다. 이런 유형의 문제의 경우 자연스럽게 BFS의 활용이 떠올라야 한다. DFS로도 풀 수는 있지만 출구를 찾을 때까지 완전 탐색의 방식이기 때문에 시간 복잡도가 높아진다. 넓게 갈 수 있는 step을 map 상에서 더해가면서 이 칸까지는 7step, 저 칸까지는 9step 이런식으로 숫자를 늘려가면서 모든 1이 있는 칸까지 이동한데 필요한 step 수를 적고 마지막에 출구 칸만 출력하면 된다.

코드를 보면 설명이 더 쉽다.

code(1) - input 받기

어쩌면 input을 받는 부분에서 흠칫했다 ㅎㅎ 1011011101 이런 값들이 다 붙어서 들어오기 때문이다. 이렇게 다 붙어서 들어오니 난 string으로 받아서 하나씩 분리, int로 바꿔서 matrix에 넣어줬다.


void input()
{
    cin >> n >> m;
    for (int i = 0; i < n; i++)
    {
        string temp;
        cin >> temp;
        for (int j = 0; j < m; j++)
        {
            map[i][j] = temp[j] - '0';
        }

    }
}

code(2) - BFS

codingtest 시리즈에서 앞에 풀었던 bfs와 다른 방식이 있다면 상하좌우로 이동하면서 그 map의 값이 0 이상인 경우(이동 가능한 경우) queue에 넣고 지금까지 이동해온 칸 수를 더해주었다.



void bfs()
{
    // start point = 0,0
    visited[0][0] = true;
    q.push({ 0,0 });

    while (!q.empty())
    {
        int x = q.front().first;
        int y = q.front().second;
        q.pop();

        for (int d = 0; d < 4; d++)
        {
            int x_step = x + dx[d];
            int y_step = y + dy[d];    
            if (!visited[x_step][y_step] and map[x_step][y_step] > 0 and x_step >= 0 and y_step >= 0 and x_step < n and y_step < m)
            {
                // not visited, map value is 1 and not out range of map
                visited[x_step][y_step] = true;
                q.push({ x_step, y_step });
                map[x_step][y_step] = map[x][y] + 1;
            }
        }
    }
}

전체 코드

#include 
#include 

using namespace std;

//initialization
int n, m;
int map[101][101];
int visited[101][101];
queue > q;
int dx[4] = { -1, 0, 1, 0 };
int dy[4] = { 0, -1, 0, 1 };

void input()
{
    cin >> n >> m;
    for (int i = 0; i < n; i++)
    {
        string temp;
        cin >> temp;
        for (int j = 0; j < m; j++)
        {
            map[i][j] = temp[j] - '0';
        }

    }
}

void bfs()
{
    // start point = 0,0
    visited[0][0] = true;
    q.push({ 0,0 });

    while (!q.empty())
    {
        int x = q.front().first;
        int y = q.front().second;
        q.pop();

        for (int d = 0; d < 4; d++)
        {
            int x_step = x + dx[d];
            int y_step = y + dy[d];    
            if (!visited[x_step][y_step] and map[x_step][y_step] > 0 and x_step >= 0 and y_step >= 0 and x_step < n and y_step < m)
            {
                // not visited, map value is 1 and not out range of map
                visited[x_step][y_step] = true;
                q.push({ x_step, y_step });
                map[x_step][y_step] = map[x][y] + 1;
            }
        }
    }
}
int main()
{
    input();
    bfs();
    cout << map[n-1][m-1];
    return 0;
}

백준 1260 DFS와 BFS

Wed, 12 Jul 2023 09:47:17 GMT

코테 문제를 풀면서 내가 실수를 하는 부분은 크게 2가지다.

변수 크기 잘못 설정

for loop 변수 이름 (중첩 for loop을 다 i로 한다던지...) 혹은 범위 잘못 설정

문제 링크: DFS와 BFS

문제

그래프를 DFS로 탐색한 결과와 BFS로 탐색한 결과를 출력하는 프로그램을 작성하시오. 단, 방문할 수 있는 정점이 여러 개인 경우에는 정점 번호가 작은 것을 먼저 방문하고, 더 이상 방문할 수 있는 점이 없는 경우 종료한다. 정점 번호는 1번부터 N번까지이다.

. .

문제 풀이 과정

일단 오랜만에 다시 코테 문제들을 푸는 과정이라 쉬운 문제부터 차근차근 푸는 중이다.

DFS (깊이 우선 탐색)

재귀함수나 스택을 이용한다.

BFS (너비 우선 탐색)

큐를 이용한다.

이 부분은 코드를 통해 더 자세하게 설명해보겠다.

. .

code(1) - input 받기

input을 받는 부분에서 놓쳐서는 안되는 부분이 있다. 보통 문제에 내가 bold 처리해둔 것을 잘 보면 코딩에 챙겨야 할 부분들이 명시되어 있다.

방문할 정점이 여러개인 경우에는 정점번호가 작은 것부터 방문하라고 되어있으므로 노드별로 연결된 노드를 push_back으로 넣어준 후 sort를 통해 정렬을 해주어야 한다.

또한 이 정렬을 할 때 노드별로 하나씩 진행하는데 여기서 주의할 부분은 for loop의 idx가 곧 노드의 번호라는 점이다. 따라서 1부터 시작해야 한다.

아래 코드를 진행하고 나면 아래와 같이 graph에 저장된다고 생각하면 된다.

예제 1번을 기준으로 graph[1] = {2, 3, 4} graph[2] = {1, 4} graph[3] = {1, 4} graph[4] = {1, 2, 3}


void input()
{
    cin >> n >> m >> start_point;
    for (int i = 1; i <= m; i++)
    {
        cin >> a >> b;
        graph[a].push_back(b);
        graph[b].push_back(a);
    }
    for (int i = 1; i <= n; i++)
    {
        sort(graph[i].begin(), graph[i].end());

    }
}

. .

code(2) - DFS

DFS는 깊이 우선 탐색으로 기준 노드에서 탐색할 수 있는 가장 깊은 노드까지 갔다가 돌아와 탐색하는 방식이다. 스택이나 재귀함수를 이용해 구현할 수 있다.

나는 재귀함수로 구현하였다.

일단 작동 방식을 설명하자면 예제 1을 기준으로

1번이 start이므로

1번 노드 방문처리
1번 노드 출력
1번 노드와 연결된 노드 차례대로 방문 (위 input 함수에서 오름차순으로 정렬)
방문 안한 경우 재귀함수(방문처리, 출력, 연결된 노드 차례대로 방문)

이런 방식으로 진행된다. 따라서 1 → 2 → 4 → 3

< 그래프 형태 > graph[1] = {2, 3, 4} graph[2] = {1, 4} graph[3] = {1, 4} graph[4] = {1, 2, 3}

dfs(1) -> dfs(2) -> dfs (4) -> dfs(3) 재귀함수의 흐름을 나타내자면 이런 형태 인 것이다.

dfs(2)에서 dfs(4)로 넘어가는 이유는 1은 이미 방문하여 방문처리 되었기 때문이다.


void dfs(int start)
{
    visited[start] = true;
    cout << start << ' ';
    for (int i = 0; i < (int)graph[start].size(); i++)
    {
        int y = graph[start][i];
        if (!visited[y])
            dfs(y);
    }

}

. .

code(3) - BFS

BFS는 큐를 사용한다. 방문하고자 하는 노드와 연결된 노드 중에서 방문하지 않은 노드를 모두 큐에 넣고 큐에서 하나씩 꺼내어 연결된 노드를 찾는 방식이다.

예시 1을 기준으로 설명해보자면

< 그래프 형태 > graph[1] = {2, 3, 4} graph[2] = {1, 4} graph[3] = {1, 4} graph[4] = {1, 2, 3}

1번 노드 방문
queue에 1번 노드와 연결된 노드 중 방문하지 않은 노드 넣고 방문처리하기 q = {2, 3, 4}
queue에서 앞에서부터 빼면서 출력, 또 연결된 노드 중 방문하지 않은 노드 큐에 넣기 (예시1에서는 없음)


void bfs(int start)
{
    visited_b[start] = true;
    q.push(start);
    while (!q.empty())
    {
        int x = q.front();
        q.pop();
        cout << x << ' ';
        for (int i = 0; i < (int)graph[x].size(); i++)
        {
            int y = graph[x][i];
            if (!visited_b[y])
            {
                visited_b[y] = true;
                q.push(y);
            }
        }
    }

}

전체 코드(cpp)


#include 
#include 
#include 
#include 
using namespace std;

//initialization
int n;
int m;
int a, b;
int start_point;
vector graph[1001];
bool visited[1001];
bool visited_b[1001];
queue q;

void input()
{
    cin >> n >> m >> start_point;
    for (int i = 1; i <= m; i++)
    {
        cin >> a >> b;
        graph[a].push_back(b);
        graph[b].push_back(a);
    }
    for (int i = 1; i <= n; i++)
    {
        sort(graph[i].begin(), graph[i].end());

    }
}

void dfs(int start)
{
    visited[start] = true;
    cout << start << ' ';
    for (int i = 0; i < (int)graph[start].size(); i++)
    {
        int y = graph[start][i];
        if (!visited[y])
            dfs(y);
    }

}

void bfs(int start)
{
    visited_b[start] = true;
    q.push(start);
    while (!q.empty())
    {
        int x = q.front();
        q.pop();
        cout << x << ' ';
        for (int i = 0; i < (int)graph[x].size(); i++)
        {
            int y = graph[x][i];
            if (!visited_b[y])
            {
                visited_b[y] = true;
                q.push(y);
            }
        }
    }

}

int main()
{
    input();
    dfs(start_point);
    cout << endl;
    bfs(start_point);
    return 0;
}

. . . .

전체코드 (python)

코테를 준비하다보니 python으로도 문제를 풀어보고있다.

from sys import stdin
from collections import deque
# func
def dfs(start):
    visited[start] = True
    print(start, end=" ")
    for alpha in graph[start]:
        if not visited[alpha]:
            dfs(alpha)

def bfs(start):
    visited2[start] = True
    q = deque([start])
    while q:
        alpha = q.popleft()
        print(alpha, end=" ")
        for i in graph[alpha]:
            if not visited2[i]:
                visited2[i] = True
                q.append(i)


# input
node, line, stp = map(int, stdin.readline().split())
graph = [[] for _ in range(node+1)]
visited = [False] * (node+2)
visited2 = [False] * (node+2)

for _ in range(line):
    x,y = map(int,stdin.readline().split())
    graph[x].append(y)
    graph[y].append(x)

for i in graph:
    i.sort()

dfs(stp)
print()
bfs(stp)

백준 2775 부녀회장이 될테야

Wed, 12 Jul 2023 09:21:35 GMT

문제 링크: 부녀회장이 될테야

주희의 반상회 주최를 도와봅시다... DP를 완벽히 이해하고자 DP 문제를 연속으로 풀어보았다.

문제

평소 반상회에 참석하는 것을 좋아하는 주희는 이번 기회에 부녀회장이 되고 싶어 각 층의 사람들을 불러 모아 반상회를 주최하려고 한다.

이 아파트에 거주를 하려면 조건이 있는데, “a층의 b호에 살려면 자신의 아래(a-1)층의 1호부터 b호까지 사람들의 수의 합만큼 사람들을 데려와 살아야 한다” 는 계약 조항을 꼭 지키고 들어와야 한다.

아파트에 비어있는 집은 없고 모든 거주민들이 이 계약 조건을 지키고 왔다고 가정했을 때, 주어지는 양의 정수 k와 n에 대해 k층에 n호에는 몇 명이 살고 있는지 출력하라. 단, 아파트에는 0층부터 있고 각층에는 1호부터 있으며, 0층의 i호에는 i명이 산다.

입력

첫 번째 줄에 Test case의 수 T가 주어진다. 그리고 각각의 케이스마다 입력으로 첫 번째 줄에 정수 k, 두 번째 줄에 정수 n이 주어진다

출력

각각의 Test case에 대해서 해당 집에 거주민 수를 출력하라.

문제풀이 과정

Dynamic programming 문제이므로 dp 식에서 규칙을 찾는 게 중요하다.

DP 규칙 찾기

일단 0층 i호에는 i명이 산다고 했으므로 0층 1호는 1명, 0층 2호는 2명 이런식이다

따라서 아래표에서 0층은 생략하겠다.

floor	room	people	DP 식
1	1	1	dp[1][1] = 1
1	2	3	dp[1][2] = dp[1][1] + dp[0][2]
1	3	6	dp[1][3] = dp[1][2] + dp[0][3]
.	.	.	...
2	1	1	dp[2][1] = 1
2	2	4	dp[2][2] = dp[2][1] + dp[1][2]

이쯤 적다보면 규칙이 눈에 보이기 시작한다. 일단 모든 층의 1호는 1명이고, (0층 1호의 명수가 1명이므로)

DP 식 : dp[i][j] = dp[i][j-1] + dp[i-1][j]

전체 코드


#include 

using namespace std;

int input_f;
int input_r;
int input_floor[10000];
int input_room[10000];
int testcase;
int dp[15][15];

int count(int floor, int room)
{
    for (int f = 1; f <= floor; f++)
    {
        for (int r = 2; r <= room; r++)
        {
            dp[f][r] = dp[f][r - 1] + dp[f - 1][r];
        }
    }
    return 0;
}

int main()
{
    // initialization
    for (int i = 1; i <= 14; i++)
    {
        // floor 0 - room 1~14
        dp[0][i] = i;
        dp[i][1] = 1;
    }

    cin >> testcase;

    for (int t = 0; t < testcase; t++)
    {
        cin >> input_f >> input_r;
        input_floor[t] = input_f;
        input_room[t] = input_r;
    }
    for (int t = 0; t < testcase; t++)
    {
        count(input_floor[t], input_room[t]);
        cout << dp[input_floor[t]][input_room[t]] << endl;
    }
    return 0;
}

백준 1463 1로 만들기

Wed, 12 Jul 2023 05:48:24 GMT

문제 링크: 1로 만들기

문제 풀이 과정

Dynamic Programming 문제이다. DP를 공부하며 참고한 링크 : Dynamic Programming

이 문제를 풀면서 고민을 정말 많이했다. DP 문제를 많이 안 풀어봐서 DP를 공부하면서 풀 겸 결국 검색해서 풀이를 보았다. 참고한 문제풀이

DP 규칙 찾기

일단 전체적으로 한번씩 적으며 dp식이 어떻게 반복되는가를 찾았다.

idx = input	calculation	dp 식
1	0	dp[1] = 0
2	2 → 1	dp[2] = 1
3	3 → 1	dp[3] = 1
4	4 → 2 → 1	dp[4] = 1+dp[i/2]
5	5 → 4 → 2 → 1	dp[5] = 1+dp[i-1]
6	6 → 3 → 1 or 6 → 2 → 1	dp[6] = 1+dp[i/3] or dp[6] = 1+dp[i/2]
7	7 → 6 → 3 → 1	dp[7] = 1+dp[i]
8	8 → 4 → 2 → 1	dp[8] = 1+dp[i/2]
9	9 → 3 → 1	dp[9] = 1+dp[i/3]
10	10 → 9 → 3 → 1	dp[10] = 1+dp[i-1]
11	11 → 10 → 9 → 3 → 1	dp[11] = 1+dp[i-1]

반드시 dp[i] = 1+dp[i-1] 은 성립한다.

이렇게 다 적고보면 규칙이 전체적으로 보인다.

2로도 3으로도 안나눠지는 값
2로도 3으로도 나눠지는 값
2로 나눠지는 값
3으로 나눠지는 값

. .

2로도 3으로도 안나눠지는 값

위 표에서는 5, 7, 11이 될 수 있겠다. 이런 경우는 무조건 1을 뺀 후 이전 dp값을 사용하는 경우 뿐이기 때문에 dp[i] = 1+dp[i-1]

2로도 3으로도 나눠지는 값

6, 12와 같은 값! 이런 경우 2개의 경우의 수 중에 연산의 개수가 작은 것을 선택한다. ** min(d[i] = 1+dp[i/2], dp[i] = 1+dp[i/3]) **

2로 나눠지는 값

4, 8, 10 이런 경우는 이전 값을 사용하는 dp 식과 i/2 dp식을 이용하는 것 중 작은 것을 선택 ** min(dp[i] = 1+dp[i-1], dp[i] = 1+dp[i/2])**

3으로 나눠지는 값

9와 같은 값

** min(dp[i] = 1+dp[i-1], dp[i] = 1+dp[i/3])**

전체코드

#include 

using namespace std;

// variable
int dp[1000001];
int input;

int main()
{
    cin >> input;
    dp[1] = 0;
    dp[2] = 1;
    dp[3] = 1;
    dp[4] = 2;

    for (int i = 5; i <= input; i++)
    {
        if (i % 2 != 0 && i % 3 != 0)
        {
            dp[i] = 1 + dp[i - 1];
        }
        else if (i % 2 == 0 && i % 3 == 0)
        {
            dp[i] = min(1 + dp[i / 2], 1 + dp[i / 3]);
        }
        else if (i % 2 == 0)
        {
            dp[i] = min(1 + dp[i / 2], 1 + dp[i - 1]);
        }
        else if (i % 3 == 0)
        {
            dp[i] = min(1 + dp[i / 3], 1 + dp[i - 1]);
        }

    }

    cout << dp[input];
    return 0;
}

백준 2309 일곱 난쟁이

Wed, 05 Jul 2023 11:38:51 GMT

문제 링크 : 일곱 난쟁이

문제

왕비를 피해 일곱 난쟁이들과 함께 평화롭게 생활하고 있던 백설공주에게 위기가 찾아왔다. 일과를 마치고 돌아온 난쟁이가 일곱 명이 아닌 아홉 명 이었던 것이다.

아홉 명의 난쟁이는 모두 자신이 "백설 공주와 일곱 난쟁이"의 주인공이라고 주장했다. 뛰어난 수학적 직관력을 가지고 있던 백설공주는, 다행스럽게도 일곱 난쟁이의 키의 합이 100이 됨을 기억해 냈다.

아홉 난쟁이의 키가 주어졌을 때, 백설공주를 도와 일곱 난쟁이를 찾는 프로그램을 작성하시오.

입력

아홉 개의 줄에 걸쳐 난쟁이들의 키가 주어진다. 주어지는 키는 100을 넘지 않는 자연수이며, 아홉 난쟁이의 키는 모두 다르며, 가능한 정답이 여러 가지인 경우에는 아무거나 출력한다.

출력

일곱 난쟁이의 키를 오름차순으로 출력한다. 일곱 난쟁이를 찾을 수 없는 경우는 없다.

문제 풀이 과정

눈 여겨봐야 할 내용들을 bold 처리 해두었다. 문제를 보면 다행히 input이 모두 다르고, 아무거나 출력하므로 중복처리나 조건처리가 필요하지 않으므로 비교적 쉬운 문제이다! :)

코드의 구조를 뜯어보면 다음과 같다.

전체 코드는 맨 아래 나와있다. 👍

input 받아 정렬하기

나는 vector를 사용하기로 했다.

 for (int i =0; i> temp;
        h.push_back(temp);
    }

 sort(h.begin(), h.end());

합쳐서 100이 되는 7명 찾기

거꾸로 생각하면 전체 합친 키에서 빼서 100이 되는 2명을 찾으면 된다.

이런식으로 전체 개수 (tot) 이 주어지고 그 중에 n개 찾기와 같은 문제는 (tot-n) 을 생각해보면 빨리 문제를 해결할 수 있다.

중간에 주석처리한 cout 부분을 주석 해제하고 출력해보면 전체 키를 합한 값에서 뺀 2명의 조합과 뺀 값도 확인해 볼 수 있다.

출력단을 따로 뺄 수도 있지만 문제에서 주어진 것에서 정답이 여러개면 아무거나 출력하는 것이 조건이길래 그냥 발견하는대로 출력하고 종료되도록 만들었다.

따라서 if 문에서 (전체 키의 합) - (2명 난쟁이의 키의 합)이 100이면 그 두명을 제외하고 vector를 출력하도록 되어있다.

여기서 주의해야할 부분은 내가 i < j 가 되도록 했기 때문에 뒤에 있는 index 값인 j를 먼저 제거해주어야 한다.

그렇지 않고 i 부터 제거하면 index가 앞으로 채워지면서 j의 index가 가르키는 값이 달라지기 때문이다.

(j+1을 해도된다, 항상 2명이기 때문에)

    ans = accumulate(h.begin(), h.end(), 0);

    // subtract 2 numbers untill the ans gets 100
    for (int i =0; i




전체 코드

#include 
#include 
#include 
#include 

using namespace std;
vector h;
int dwarf = 9;
int ans;

int main()
{
    for (int i =0; i> temp;
        h.push_back(temp);
    }

    sort(h.begin(), h.end());

    // add all the heights
    ans = accumulate(h.begin(), h.end(), 0);

    // subtract 2 numbers untill the ans gets 100
    for (int i =0; i 

끝!



[cpp] Code Note
Wed, 05 Jul 2023 10:43:04 GMT
예전에 코딩테스트를 준비하면서 
인상적인 함수나 몰랐던 방법들을 볼 때마다 notion에 적어두곤 했는데, 
이제 TIL를 velog로 옮기면서 조금씩 옮기고 있다. 
(notion에서 내보내기 > markdown 으로 하면 velog에 아주 잘 호환된다.)
Code Note

💡 To master Python & C++




Tips
for 문에서 len(list)같이 계산이 필요한 것들 loop에 넣으면 시간 복잡도 급 상승, for loop전에 변수로 선언해주고 변수만 넣어주기
vector에서는 마지막요소idx로 -1 안됨! v.back() 이용~



Char to int
노트
char c = '1';
int n = c - '0';
// n = 1


이진수
1의 갯수 세기
int n = 10;
int x = __builtin_popcount(n);

//gcc 컴파일러 내장함수 - unsigned int를 받아서 1인 bit의 개수를 리턴
// unsigned int = 32bit -> 시간복잡도 O(32)


priority queue
조건에 맞춰 정렬하고 싶을 때 - 삼성코테예제 중 BFS 쓸때 유용~
// 값을 priority queue에 넣어주면 struct에 선언된 기준대로 정렬해줌!!
#include 

struct standard {
    int x,y,x_cnt, y_cnt;
    bool operator <(const standard& i const{
        if(x == i.x)
        {
            if(y == i.y)
            {
                    return x_cnt > i.x_cnt // x값도 y값도 같은 경우, x_cnt가 작은 순서대로 정렬
            } else return y > i.y // 들어온 값들의 x값이 같은 겅우, y가 작은 순서대로 정렬
        }
        else return x < i.x // x가 클수록 앞으로 정렬
    }
};

int main()
{
    priority_queue qp;
    pq.push({1,2,3,4});
    int x_first = pq.top().x;
}


Tuple
Tuple(3개의 요소 한번에 넣고 싶을때) - 2개는 pair
#include 
#include 
vector > v;

v.push_back({1,2,3});
a = get<0>(v.front());
b = get<1>(v.front());
c = get<2>(v.front());


Sort
Sort
#include 
#include 
vector  v;

// Vector
// 오름차순
sort(v.begin(), v.end());

// 내림차순
sort(v.begin(),v.end(), greater<>());
sort(v.rbegin(),v.rend());

// Array
sort(arr,arr+5);
# 오름차순
list.sort()

# 내림차순
list.sort(reverse = True)
Vector
Basic functions
#include 
vector  v;  // 1d vector
vector > v2; // 2d vector

v.push_back(a); // add a to end of vector
v.emplace_back(a);
v.pop_back(); // delete last element
v.size(); // size of the vector v
v.begin(); // address of first element
v.end(); // address of last element

Vector
min, max, idx
#include 
vector  v;

int min = *min_element(v.begin(),v.end());
int max = *max_element(v.begin(),v.end());

int max_idx = max_element(v.begin(),v.end()) - v.begin();
int min_idx = min_element(v.begin(),v.end()) - v.begin();

//그냥 값을 넣어서 구할수도 있다.
int min = min(v[0],v[1]); // 이렇게 !
Vector
Count (개수세기)
#include 
#include 
vector  v;

// 2가 몇개 있는지 찾고싶을 때
int target = 2; 
int c = count(v.begin(),v.end(),target);

// 2 이하가 몇개인지 찾고싶을 때
int cc = count_if(v.begin(),v.end(), [](int elem){return elem <= 2;});

or
bool cnt (int x)
{
    return (x <= 2); // 진짜 숫자 상수 밖에 안됨, vector[i] 도 넣어봤는데 안됨. 아마 int main 안에서 선언되는게 아니라 그런듯
}
int cc = count_if(v.begin(),v.end(), cnt);

Vector
Vector 값 모두 출력하기
for (auto loop:v)
{
        cout << loop << " ";
}

Vector
특정값 idx 찾기
#include 

auto idx = find(v.begin(), v.end(), target);
cout << idx - v.begin()+1; // idx 출력
cout << *idx; // vector의 idx값

// 있으면 
if (idx != v.end())
{
    cout << "Element found : " << *idx;
}
else
{
    cout << "Element Not found";
}

Vector
n번째 idx값 출력하기
vector  :: iterator idx = v.begin() + n + 1;
cout << *idx;
Vector
2차원 벡터 입력받기
int n, m; // row, col
vector > v2;

for (int i = 0; i> temp;
                v2[i].push_back(temp);
        }
}

input.txt
Input.txt로 불러오기
리소스파일 폴더에 input.txt 만들어두고

#define LOCAL
#define _CRT_SECURE_NO_DEPRECATE

#include 

int main()
{
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
#endif
}


Vector
String 일부만 추출하기
// substr(start, length)
v.substr(0,v[0].size());



Set (중복x)
Set
#include 
set  s1;

s1.insert(10);
// 중복 x, 자동 오름차순 정렬
# list to set
# 중복 제거

ls = [1,2,3,4,5,5,5]
ss = set(ls)
Unordered_set
-장점: insert, find, erase =O(1)
-주의: 내부에 랜덤하게 저장됨
순서를 고려하는 경우, 사용 X

시간복잡도가 낮은 이유: 해시함수
입력된 값으로부터 값을 저장할 array의 idx값을 계산 → 값으로부터 idx값을 알 수 있으므로 탐색X

unordered_set find
#include 

unordered_set  mm;

if (mm.find(10) != mm.end()){
    // 10 mm안에 있음}

mm.find(x) == mm.end() 가 true면 없는거 (끝까지 탐색했는데 없어서 end idx와 같아지면)


문자열(공백찾기)
isspace
//isspace : 공백이 아니면 0 반환

if (isspace(str) != 0) // 공백일 때
if (isspace(str) == 0) // 공백 아닐 때


문자열
문자열 합치기(list → word)
...
str_list = ['a','b','c','d']
''.join(str_list)

# result = 'abcd'
문자열(대문자, 소문자)
tolower, toupper
#include 
string str = "HOHO";
for (char& ch:str)
{
        ch = tolower(ch);
}
//-------------------------
string word = "HELLO";
transform(word.begin(), word.end(), word.begin(), ::tolower);
cout<

str = "hoho"
str.upper()
str.lower()

문자열(String to int)
stoi
#include 

// string to int
string s = "12345";
int ss = stoi(s);

// int to string
to_string(ss)
s = "12345"
ss = int(s)

Vector Remove / erase
Vector에서 특정값 지우기
#include 
#include 

target = 10;
v.erase(remove(v.begin(),v.end(),target));
target = 10
list.remove(target)

Vector
Vector 2개 이어붙이기
// vector x 뒤에 y 붙이기

x.insert(x.end(),y.begin(),y.end());
ans = x + y

Vector sum
Vector / list 값 모두 더하기
#include 

ans = accumulate(v.begin(), v.end(),0); // 0+요소값 전부
ans = sum(ls)




[Simulation][Project] 카페 서빙 로봇 
Wed, 05 Jul 2023 09:49:48 GMT

코드 및 설명 참고: Github
그동안 진행했던 simulation 강의를 바탕으로 project를 진행중이다 :) 
1차 demo는 완성된 상태이며 navigation 성능을 개선하기 위해 노력 중이다.
더 자세한 설명과 완성된 코드는 계속해서 update 될 예정이다.
팀 mate : 정빈, 찬영, 건우, 유진 :)



와이파이 비밀번호 찾기
Mon, 03 Jul 2023 05:22:42 GMT
window에서 cmd라고 검색 후 관리자 권한으로 실행로 열기

netsh wlan show profile "wifiname" key=clear
이렇게 해서 나오는
보안설정의 키 콘텐츠가 비밀번호이다.



[Simulation] 오픈소스 기반 시뮬레이션 패키지 활용
Mon, 03 Jul 2023 05:19:55 GMT

혹시 이 simulation을 따라하는 사람이 있다면...
심화과정으로 갈수록 virtual machine은 정신건강에 좋지 않다. (저도 알고싶진 않았어요)
듀얼부팅을 하거나 리눅스용 노트북을 장만하는 것을 추천한다.
나는 로봇에 관한 것들을 계속 할 것이기 때문에 리눅용 노트북을 하나 마련했다 💻
새 노트북에서 gazebo를 돌리니 아주 천국이다 :)

개요

summit XL
PR2
Jackal
Turtlebot3


sim_ws/src/ 안에 chapter10 파일 넣어주기
hidden folders 중에서 .gazebo/models 에 extra_models 안에 있는 모든 파일  붙여넣기

chapter10에 대한 dependency 설치
cd sim_ws
rosdep install -i --from-path src/chapter10 --rosdistro noetic -y --os=ubuntu:focal
catkin_make

roslaunch turtlebot3_gazebo turtlebot3_world.launch
roslaunch turtlebot3_navigation turtlebot3_navigation.launch
roscd turtlebot3_navigation/rviz/
rviz -d turtlebot3_nav.rviz
초기위치가 안 맞을 경우 2D Pose Estimate를 이용해 맞춰주면 된다.
roslaunch turtlebot3_teleop turtlebot3_teleop_key.launch
or
rosrun teleop_twist_keyboard teleop_twist_keyboard.py
launch 파일이 안되는 경우, rosrun으로 실행하면 키보드로 map 안에서 주행이 가능하다.
관성값을 잘 설정해준 관계로 벽에 부딪혀도 매우 잘 일어나는 것을 확인할 수 있다.
끝
.
.
목적지 경유 (waypoint)
2D pose estimate로 map에 직접 찍어주기
turtlebot의 경우, 한번에 한 위치로만 이동할 수 있음.
여러 포인트를 이동하기 위해서는 어떻게 해야할까?_?
roslaunch turtlebot3_gazebo turtlebot3_world.launch
roslaunch turtlebot3_navigation turtlebot3_navigation.launch
roscd turtlebot3_navigation/rviz
rviz -d turtlebot3_nav.rviz
roslaunch follow_waypoints follow_waypoints.launch
follow_waypoints.launch 파일을 열고나면 /initialpose를 받기를 기다린다는 내용이 terminal에 출력된다.

rviz 상에서 2D pose estimate를 찍어주면 /initialpose가 출력되므로 2D pose estimate 버튼을 이용해 여기저기 점을 찍어주면 terminal 상에서 계속
Received new waypoint라는 메세지가 나올 것이다.
rostopic pub /start_journey std_msgs/Empty -1
위 명령어를 쳐주면 찍어준 포인트들로 이동하는 것을 확인할 수 있다.
원하는 경유지를 하나씩 2D pose estimate로 찍어줄 수 있어서 편하지만 
costmap이 계속 남아있게되는데 이는 2D pose estimate로 지정해주는 /initialpose를 
amcl 노드도 받아 초기 위치를 localization하기 때문이다.
그래서 위치를 찍어줄 때마다 로봇의 초기 위치도 같이 이동하고 다니게 되면서 잔상이 남는다.

따라서 코드를 통해 waypoint를 깔끔하게 설정해보자
Code로 waypoint 찍어보기
smach (state machine)

로봇을 여러 state로 만들고 그 state를 전환을 지정해주어 시스템 또는 로봇의 동작을 모델링하는 소프트웨어 모듈
센서데이터, 사용자 명령, 또는 내부 이벤트와 같은 input에 대해 응답하고 현재상태에 따라 작업을 수행하도록 설계되어 있다.

로봇 팔을 제어할 때, 물체 감지 / 사용자 명령을 기반으로 동작 등 상태를 전환할 때 state machine을 사용할 수 있다.

state 만들기

class Foo(smach.State):
    def _init_(self, outcomes=[‘outcome1’, ‘outcome2’]):

    def execute(self, userdata):
        if xxx:
            return ‘outcome1’
        else:    
            return ‘outcome2’

State Machine에 state 추가하기
state machine : 여러 state를 보관하는 컨테이너
State machine is also state so you can add the states machine to another state machine

sm = smach.StateMachine(outcomes=[‘outcome4’, ‘outcome5’])
with sm:
    smach.StateMachine.add(‘FOO’, Foo(), transitions={‘outcome1’ : ‘BAR’, ‘outcome2’ : ‘outcome4’})
    smach.StateMachine.add(‘BAR’, Bar(), transitions={‘outcome2’ : ‘FOO’})
위 코드를 그림으로 나타내면 아래와 같다.
FOO일 때는 결과 값이 outcome1이면 BAR로 가고 outcome2 면 FOO로 간다

이것을 바탕으로 waypoint를 경유 하는 코드를 작성 해 보자.
mkdir ~/sim_ws/src/chapter10/turtlebot3/t3_course/scripts
code ~/sim_ws/src/chapter10/turtlebot3/t3_course/scripts/custom_follow_waypoints.py

#!/usr/bin/env python3

import threading
import rospy
import actionlib

from smach import State, StateMachine
from move_base_msgs.msg import MoveBaseAction, MoveBaseGoal

waypoints = []
class FollowPath(State):
    def __init__(self):
        State __init__(self, outcomes=[‘success’], input_keys=[‘waypoints’])
       self.frame_id = rospy.get_param(‘~goal_frame_id’, ‘map’)

code ~/sim_ws/src/chapter10/turtlebot3/t3_course/launch/start_follow_waypoints.launch 
< start_follow_waypoints.launch >

    
    

    
        
        
    

또한 rviz 상에서 2D pose estimate로 waypoint를 설정할 경우, 
amcl노드도 동일하게 영향을 받기 때문에 코드로 직접 waypoint publish 해주도록 하겠다.
rostopic info /initialpose를 해보면 msg type이
geometry_msgs/PosewithCovarianceStamped 이므로 이 type으로 publish 해주면 된다.

rviz상에서 좌표를 보기 어려울 때는 rostopic echo /clicked_point를 해주고
rviz ui에 있는 Publish Point로 찍어주면 msg가 출력된다.


#!/usr/bin/env python3

import rospy
import time
import tf.transformations

from std_msgs.msg import Empty
from geometry_msgs.msg import PoseWithCovarianceStamped

# wp_id : (x, y)
wp_list = {1 : (0.427, -1.795),
           2 : (0.444, 1.784),
           3 : (-1.833, -0.021)}

"""
user:~$ rosmsg show geometry_msgs/PoseWithCovarianceStamped
std_msgs/Header header
  uint32 seq
  time stamp
  string frame_id
geometry_msgs/PoseWithCovariance pose
  geometry_msgs/Pose pose
    geometry_msgs/Point position
      float64 x
      float64 y
      float64 z
    geometry_msgs/Quaternion orientation
      float64 x
      float64 y
      float64 z
      float64 w
  float64[36] covariance
"""

def talker():
    pub_wp = rospy.Publisher('my_t3_waypoints', PoseWithCovarianceStamped, queue_size=1)
    pub_path_ready = rospy.Publisher('path_ready', Empty, queue_size=1)

    rospy.init_node('waypoint_publisher', anonymous=True)
    rate = rospy.Rate(10) # hz

    my_wp = PoseWithCovarianceStamped()
    my_wp.header.stamp = rospy.Time.now()
    my_wp.header.frame_id = 'map'

    init_x = -1.81
    init_y = -0.46
    init_roll = 0.0
    init_pitch = 0.0
    init_yaw = 0.7071

    quaternion = tf.transformations.quaternion_from_euler(init_roll, init_pitch, init_yaw)
    # transfromation from roll, pitch, yaw to x y z w

    my_wp.pose.pose.orientation.x = quaternion[0]
    my_wp.pose.pose.orientation.y = quaternion[1]
    my_wp.pose.pose.orientation.z = quaternion[2]
    my_wp.pose.pose.orientation.w = quaternion[3]

    for i in range(len(wp_list)):
        rospy.loginfo("Waypoint" + str(i))
        # my_wp.pose.pose.position.x = float(i)*0.3 + init_x
        # my_wp.pose.pose.position.y = float(i)*0.3 + init_y
        my_wp.pose.pose.position.x = wp_list[i+1][0]
        my_wp.pose.pose.position.y = wp_list[i+1][1]

        while not rospy.is_shutdown():
            connections = pub_wp.get_num_connections()
            if connections > 0:
                pub_wp.publish(my_wp)
                break
            rospy.loginfo("Wait for 'my_t3_waypoints' topic")
            rate.sleep()

        rospy.loginfo("Published waypoint number " + str(i))
        time.sleep(2)

    start_command = Empty()

    while not rospy.is_shutdown():
        connections = pub_path_ready.get_num_connections()
        if connections > 0:
            pub_path_ready.publish(start_command)
            rospy.loginfo("Sent waypoint list execution command")
            break
        rospy.loginfo("Waiting for 'path_ready' topic")
        rate.sleep()

if __name__=='__main__':
    try:
        talker()
    except rospy.ROSInterruptException:
        pass
실행해보자 
roslaunch turtlebot3_gazebo turtlebot3_world.launch
roslaunch turtlebot3_navigation turtlebot3_navigation.launch
roscd turtlebot3_navigation/rviz/
rviz -d turtlebot3_nav.rviz
roslaunch t3_course start_follow_waypoint.launch
rosrun t3_course waypoint_publisher.py
이처럼 잘 이동하는 것을 볼 수 있다. (내 rviz가 지저분한 것은 초기위치 설정을 찾느라 좀 헤맸기 때문이다 ㅎ)
state machine은 꽤나 복잡해보이지만
다양한 종류의 동작을 하는 로봇을 설계할 때는 state machine을 쓰는 것이 유리하다.
각 동작의 결과에 따른 다음 동작을 설정하거나 각각 state일 때 수정할 부분을 찾기도 편하기 때문
재미있다!! 😎️ 😎️ 😎️ 👍
.
.
Line follower
Opencv는 ros library는 아니지만 cv-bridge를 이용해서 통합할 수 있음
이 라이브러리를 이용해서 rosmsg-imagetype 간의 변환이 편하므로 다양하게 이용할 수 있다.
Line 따라 이동하도록 하기

ROS 이미지를 가져와서 OpenCV 형식으로 변환
OpenCV 라이브러리를 사용하여 이미지를 처리하여 작업에 필요한 데이터를 얻음
얻은 데이터를 기반으로 노란색 선을 따라 로봇을 이동

간단하게 cv bridge를 알아보자

message type을 알고 싶을 때는 둘 중 하나를 해주면 된다.


rosmsg show sensor_msgs/Image
google에 sensor_msgs/Image를 검색하면 된다.

/t3_course/scripts/example_cv_bridge.py 를 만들어 주자

#!/usr/bin/env python3

import rospy
import cv2
from cv_bridge import CvBridge, CvBridgeError
from sensor_msgs.msg import Image


class LineFollower(object):

    def __init__(self):
        self.bridge_object = CvBridge()
        self.image_sub = rospy.Subscriber("/camera/rgb/image_raw",Image,self.camera_callback)

    def camera_callback(self,data):
        try:
            # We select bgr8 because its the OpneCV encoding by default
            cv_image = self.bridge_object.imgmsg_to_cv2(data, desired_encoding="bgr8")
        except CvBridgeError as e:
            print(e)

        cv2.imshow("Image window", cv_image)
        cv2.waitKey(1)


def main():
    line_follower_object = LineFollower()
    rospy.init_node('line_following_node', anonymous=True)
    try:
        rospy.spin()
    except KeyboardInterrupt:
        print("Shutting down")
    cv2.destroyAllWindows()

if __name__ == '__main__':
    main()
실행시켜보자!
roslaunch t3_course follow_line.launch
rosrun t3_course example_cv_bridge.py
실행해보면 robot이 보는 image가 나오게 된다.
Line을 따라 이동하도록 코드를 만들어보자
파일 2개를 만들어줄 것이다.
로봇을 움직이기 위한 파일과
/turtlebot3/t3_course/scripts/move_robot.py
노란선을 검출하고 따라가도록 하는 파일
/turtlebot/t3_course/scripts/follow_line_step_hsv.py

#!/usr/bin/env python3
import rospy
from geometry_msgs.msg import Twist

class MoveRobot(object):
    def __init__(self):
        self.cmd_vel_pub = rospy.Publisher('cmd_vel', Twist, queue_size=10)
        self.last_cmd_vel = Twist()

        self.pub_rate = rospy.Rate(10)

        self.shutdown_detected = False

    def move_robot(self, cmd_vel_msg):
        self.cmd_vel_pub.publish(cmd_vel_msg)

    def stop_robot(self):
        cmd_vel = Twist()
        cmd_vel.angular.z = 0.0
        self.move_robot(cmd_vel_msg=cmd_vel)
        self.shutdown_detected = True

def main():
    rospy.init_node('move_robot_node', anonymous=True)

    move_robot_obj = MoveRobot()
    cmd_vel = Twist()

    # Make it start turning
    cmd_vel.angular.z = 0.15

    rate = rospy.Rate(5)

    ctrl_c = False

    def shutdownhook():
        # works better than the rospy.is_shut_down()
        move_robot_obj.stop_robot()
        rospy.loginfo("shutdown time!")
        ctrl_c = True

    rospy.on_shutdown(shutdownhook)

    while not ctrl_c:
        move_robot_obj.move_robot(cmd_vel_msg=cmd_vel)
        rate.sleep()

if __name__=='__main__':
    main()



python code를 만들고나면 항상 terminal에서 chmod +x * 해주는 것을 잊지말자
결과
노란선을 잘 따라가는 귀여운 turtlebot을 볼 수 있다. ㅎㅎ

.
Blob tracking

비디오 sequance의 객체를 감지하고 추적하는데 사용되는 기술
blob = 색 / intensity 이런 속성을 공유하는 연결된 그룹을 의미한다.
위치 크기 모양 등이 추출되어 사용가능하다

.
.
Object Detection
.
.
Object Recognition



[Simulation] Path planning
Thu, 29 Jun 2023 14:54:15 GMT

ROS에서 경로계획이 어떻게 작동하는지 알아보자

Rviz에서 path planning 시각화 하기
Rviz Display

Map display (for costmap)
Path display (plans)
2D Nav Goal

roslaunch husky_navigation_launch main.launch
roslaunch husky_navigation move_base_demo.launch
rviz
rviz를 켰으면 아래 적힌 내용들을 설정해주자 
.
add > map
add > robotmodel
add > laserscan > size > 0.1
add > map > topic > /move_base/gloabal_costmap/costmap > remane > global costmap > color scheme > costmap
add > map > topic > /move_base/local_costmap/costmap > rename > local costmap > color scheme > costmap
add > by topic > /move_base > /global_plan > path > rename > global planner
add > by topic > /move_base > /local_plan > path (topic: /move_base/DWAPlannerROS/local_plan) > rename > local planner
add > by topic > /global_costmap > /footprint > polygon > rename > global polygon -> 충돌 영역 표시
add > by topic > /local_costmap > /footprint > polygon > rename > local polygon -> 충돌 영역 표시
add > by_topic > /particlecloud > poseArray > rename > AMCL particles
add > by_topic > /move_base_simple > /goal > pose > rename > goal pose

참고로 이미있는 것과 속성이 같다면 duplicate해서 topic만 바꿔주면 된다.

2D Nav Goal로 갈 곳을 지정해주면
    빨간색 선 : global plan
    초록색 선 : local plan 
을 확인해 볼 수 있다.
보기 편하도록 색을 바꿔주면 좋다
이렇게 설정한 rviz를 아래 directory에 navigation.rviz로 저장해주도록 하자
~/sim_ws/src/husky/husky_navigation/rviz
.
.
오픈소스 path planning 패키지
Move_base 노드

navigation stack에 주요 노드
목적: 로봇을 현재 위치에서 목표 위치까지 이동 (SimpleActionServer 이용)
목적지에 대한 Msg Type : geometry_msgs/PoseStamped
Published Topic : move_base/goal


rostopic echo /move_base/goal
rviz 상에서 2D NAV GOAL을 찍어준 후 메세지를 출력해보면 goal 정보가 출력되는 것을 확인할 수 있다.
이처럼 rviz의 UI 상에서 2D nav goal로 목표 지점을 찍어줄 때마다 move_base가 /move_base/goal을 publish하는 것이다.
goal:
    target_pose:
        header:
            seq:
            stamp:
                secs:
                nsecs:
            frame_id : 
        pose :
              position:
                x:
                y:
                z:
            orientation:
                x:
                y:
                z:
                w:

move_base 노드의 topics

/move_base/goal (move_base_msgs/MoveBaseActionGoal)

/move_base/cancel (actionlib_msgs/GoalID)

/move_base/feedback (move_base_msgs/MoveBaseActionFeedback)

현재 map상에서 robot의 위치 업데이트, goal로 잘 이동하는지 확인하기 위함


/move_base/status (actionlib_msgs/GoalStatusArray)

현재 상태가 나온다 (goal로 이동중: status:1, 도착하면 goal reached 나옴)


/move_base/result (move_base_msgs/MoveBaseActionResult)

목적지에 도달하고 나면 topic 생성 (goal reached)



꼭 rviz 상에서 goal을 2d nav goal로 정해주지않아도 터미널 상에서 message를 publish해서 지정해줄 수 있다.
rostopic까지 적어준 후 tab을 치면 자동적으로 구조가 나온다.
(terminal이므로 커서가 좌우로만 움직인다..)
rostopic pub /move_base/goal move_base_msgs/MoveBaseActionGoal

.
.
실습
목표

move_base 노드의 액션서버로 메세지 전송을 위한 액션 클라이언트 만들기 (send_goal_client.py)

mission

액선 클라이언트를 사용하여 로봇을 map 의 세 가지 다른 목적지로 이동
로봇이 3개의 목적지에 도달하면 루프를 다시 생성
(로봇이 3개의 목적지로 계속 반복해서 이동하도록 함)

천천히 코드를 발전시키면서 movebase를 이해해보자
mission - goal 위치 지정, 상태 출력
 - version1
#! /usr/bin/env python3

import rospy
import time
import actionlib

from move_base_msgs.msg import MoveBaseGoal, MoveBaseAction, MoveBaseResult, MoveBaseFeedback

def feedback_callback(msg):
    rospy.loginfo("[Feedback] Going to Goal Pose...")

rospy.init_node('move_base_action_client')
client = actionlib.SimpleActionClient('move_base',MoveBaseAction)
client.wait_for_server()

goal = MoveBaseGoal()
goal.target_pose.header.frame_id = 'map'
goal.target_pose.pose.position.x = 2.0
goal.target_pose.pose.position.y = 2.0
goal.target_pose.pose.position.z = 0.0

goal.target_pose.pose.orientation.x = 0.0
goal.target_pose.pose.orientation.y = 0.0
goal.target_pose.pose.orientation.z = 0.0
goal.target_pose.pose.orientation.w = 1.0


client.send_goal(goal = goal, feedback_cb = feedback_callback)
client.wait_for_result()

rospy.loginfo("[Result] State: %d" %(client.get_state()))
결과

.
.
Global planner & Global costmap
.
.
Local planner & Local costmap
.
.
Common Costmap Parameters



[Simulation] Robot Localization
Wed, 28 Jun 2023 16:16:08 GMT
Rviz에서 Localization 시각화하기
Rviz Display

map display
laserscan display
PoseArray display

실습
Husky 다운로드 & 설치
~/src 에 다운받은 husky 파일을 넣고
아래 명령어로 의존성 설치를 해준다.
ros와 ubuntu 버전에 맞게 설치해주면 된다.
rosdep install -i --from-path src/husky --rosdistro melodic -y --os=ubuntu:bionic

sudo apt install ros-melodic-ur-description
sudo apt install ros-melodic-lms1xx
catkin_make
husky launch 해보기
roslaunch husky_navigation_launch main.launch
roslaunch husky_navigation_launch keyboard_teleop.launch


gazebo상에서 실외 네비게이션도 시뮬레이션 가능함 (가짜 topic - 경도 위도 값으로 가능)
오호 다음에 한번 해보고 싶당😲

localization 해보기
roslaunch husky_navigation_launch main.launch
roslaunch husky_navigation amcl_demo.launch
rviz
rviz > add > Map > topic > /map
rviz > add > Laserscan
rviz > add > RobotModel
rviz > add > PoseArray

roslaunch husky_navigation_launch keyboard_teleop.launch
로봇을 점점 움직일수록 화살표들 (불확실성) 이 로봇 쪽으로 모이는 것을 확인할 수 있다.
.
.
Localization 다루기
Monte Carlo Localization (MCL)
로봇은 다음에 어디로 이동할지 무작위로 추정 = particle
Lidar와 같은 sensor 값을 바탕으로 가능성이 낮은 영역을 배제하면서 particle은 가장 로봇이 있을만한 위치로 수렴하게 된다.
로봇이 움직일수록 화살표가 로봇쪽으로 모였던 이유는
움직이면서 sensor를 통해 더 많은 값을 얻을 수 있으므로 위치파악이 더 정확해진 것이다.
AMCL (Adaptive Monte Carlo Localization) package

Launch 파일로 amcl 노드 켜주기

roslaunch husky_navigation amcl_demo.launch

2D pose estimate를 통해 초기 로봇 위치 설정

로봇을 움직이기 및 시각화



Subscribing Topic: /scan, /map, /tf
Publishing Topic: /amcl_pose, /particlecloud

mkdir ~/sim_ws/src/husky/husky_launch/scripts 
code ~/sim_ws/src/husky/husky_launch/scripts/get_pose_service.py

#! /usr/bin/env python3

import rospy
from std_srvs.srv import Empty, EmptyResponse # Import the service message python classes generated from Empty.srv.
from geometry_msgs.msg import PoseWithCovarianceStamped, Pose

robot_pose = Pose()

def service_callback(request):
    rospy.loginfo("Robot Pose: " + str(robot_pose))

    return EmptyResponse() # the service Response class, in this case EmptyResponse


def sub_callback(msg):
    global robot_pose
    robot_pose = msg.pose.pose

rospy.init_node('get_pose_service')
my_service = rospy.Service('get_pose_service', Empty, service_callback) # create the Service called get_pose_service with the defined callback
sub_pose = rospy.Subscriber('amcl_pose', PoseWithCovarianceStamped, sub_callback)

rospy.spin() # mantain the service open.
rosrun husky_launch get_pose_service.py
rqt or rosservice call /get_pose_service "{}"
rqt > plugins > service > service caller > /get_pose_service 선택 후 call
rqt 상에서도 가능하고 terminal에서 명령어를 쳐도 가능하다. 
map상에서 로봇의 좌표가 terminal 상에서 출력되는 것을 이야기한다.
Transforms
Localization을 위한 하드웨어 요구사항

Good Laser data (/scan)
Good odometry data (/odom/filtered)
Good Map data (/map)

Localization을 위해 꼭 필요한 변환관계

base_laser => odom
이 변환관계를 AMCL이 계산, 이를 통과하는 경로가 있어야 함


base_laser => base_link
LaserScan frame에 대한 로봇 base의 고정된 TF 관계가 필요



.
.
오픈소스 Localization 패키지

더 자세한 정보는 링크 참고 : amcl ros

amcl 노드의 일반 parameter

odom_model_type (default: "diff")
사용할 주행거리 측정 모델 설정
"diff", "omni", "diff-corrected", "omni-corrected"


odom_frame_id (default: "odom")
odometry 시스템에 연결된 프레임의 이름


base_frame_id (default: "base_link")
로봇의 base와 연결된 프레임의 이름


global_frame_id (default: "map")
localization 시스템에 의해 publising되는 기준좌표 프레임


use_map_topic (default: false)
노드가 topic에서 지도 데이터를 가져올지 아니면 서비스 호출에서 가져올지를 결정



.
.
amcl 노드의 filter 관련 파라미터

min_particles (default: 100)
필터에 허용되는 최소 입자수 | CPU 사용량에 영향을 미침


max_particles (default: 5000)
필터에 허용되는 최대 파티클 수 | CPU 사용량에 영향을 미침


kid_err (default: 0.01)
실제 분포와 추정 분포 사이에 허용되는 최대오차


update_min_d (default: 0.2)
update_min_a (default: pi/6.0)
resample_interval (default: 2)

실습
mission

min_particle 및 max_particle를 각각 1과 5로 설정하고 결과 확인
laser_max_range를 1로 변경하고 결과 확인
모든 파라미터 변경은 yaml 파일에서 하도록 함 (amcl_params.yaml)
(launch 파일도 새로 만들기 - my_amcl.launch)

code /home/yujin/sim_ws/src/husky/husky_launch/my_amcl.launch



    
    

    

    
    
        
        
    

    
    
code ~/sim_ws/src/husky/husky/husky_navigation/config/amcl_params.yaml

use_map_topic: true
odom_model_type: diff
odom_frame_id: odom

gui_publish_rate: 10.0
min_particles: 500
max_particles: 2000
kld_err: 0.05
update_min_d: 0.25
update_min_a: 0.2
resample_interval: 1
transform_tolerance: 1.0

laser_max_beams: 60
laser_max_range: 1.0
laser_z_hit: 0.5
laser_z_short: 0.05
laser_z_max: 0.05
laser_z_rand: 0.5
roslaunch husky_navigation_launch main.launch
roslaunch husky_launch my_amcl.launch
나는 이렇게 해도 particle이 보이지 않았다... 아직 해결하지 못함
amcl 노드 관련 service

/global_localization (std_srvs/Empty)
모든 파티클이 map 의 빈 공간에 무작위로 분산되는 global localization을 시작


/static_map (nav_msgs/GetMap)
Laser 기반 위치 추정에 사용되는 map을 가져옴



로봇의 위치를 알려줄 수 없을 때 (2D pose estimate로 지정 불가)
global_localization을 통해서 할 수 있다.
실습

목표 : /global_localization 서비슬르 호출하는 노드 만들기

Mission

AMCL의 파티클 초기 위치를 랜덤하게 설정하기 위해 /global_localization 서비스를 사용
파일 안에 서비스 클라이언트를 위한 코드 작성
이 클라이언트를 통해 파티클을 분산

code ~/sim_ws/src/husky/husky_launch/scripts/init_particles_caller.py

#! /usr/bin/env python3

import rospy
from std_srvs.srv import Empty, EmptyRequest
import sys

rospy.init_node("init_particles_caller")
rospy.wait_for_service('/global_localization')

disperse_particles_service = rospy.ServiceProxy('/global_localization', Empty)
msg = EmptyRequest()
result = disperse_particles_service(msg)

rospy.loginfo(result)
rosrun husky_launch init_particles_caller.py

흩어진 불확실성 particle들이 로봇을 움직여주면 robot의 위치로 모두 모이는 것을 확인할 수 있다.
map과 scan 데이터가 어느정도 matching되면 로봇의 위치를 잘 추정했다고 생각하는 방식이다.
문제는 만약 환경이 우리가 사용하는 환경처럼 직사각형 모양이라면 위아래가 뒤집혀도
map과 scan 데이터가 matching 되므로 로봇의 위치를 잘 추정했다고 생각할 수 있다는 것이다.
따라서 환경의 특징이 매우 뚜렷하다면 global localization을 사용하기 좋지만 
그렇지 않다면 위치 추정에 실패할수도 있음을 기억해두어야 한다.
.
.
과제 - Localization
목표

로봇이 모르는, 알 수 없는 환경에서 위치를 추정한다고 가정
위치에 대한 공분상(불확실성, covariance) 값이 일정 수준으로 떨어지도록 로봇을 정사각형 형태로 이동시키기

Mission

Square_move.py 파일 생성
Particle을 맵 전체에 분산시키는 서비스 호출
로봇은 정사각형 형태로 이동을 수행
주행 중 공분산(covariance)이 0.65 미만이면 로봇이 올바르게 위치를 파악했다는 뜻이므로 프로그램 종료
공분산이 0.65보다 클 경우, 파티클 분산, 이동수행, 공분산 확인 과정을 계속 반복
프로그램 종료 전에, 최종 파티클 필터의 공분산을 터미널에 출력


hint


amcl과 관련된 서비스를 호출하려면 amcl 노드가 실행중이어야 함
파티클의 공분산은 /amcl_pose 토픽을 통해 확인할 수 있음
파티클 공분산은 행렬형태로 publish
  (첫번째 값은 x의 공분산, 8번째 값은 y의 공분산, 마지막 값은 z의 공분산




[Simulation] SLAM
Wed, 28 Jun 2023 04:15:05 GMT
Rviz에서 Mapping 과정 시각화
Rviz Display

Map display
LaserScan display
RobotModel display

Rviz 구성하기
지난번 처럼 rviz_launcher에 있는 launch 파일로 열었지만 
이번에는 직접 rviz를 꾸며보자
roslaunch turtlebot_navigation_gazebo main.launch
roslaunch turtlebot_navigation_gazebo gmapping_demo.launch
rviz

빈 rviz 창에서 add를 눌러 LaserScan을 추가해준 후
topic에서 kobuki/laser/scan으로 설정해준다.
size > 0.05 (=5cm)

Global option > Fixed frame > map

add > RobotModel

add > map > topic > /map


roslaunch turtlebot_teleop keyboard_teleop.launch
로봇을 움직이며 mapping을 하면 된다.
Rviz configuration 저장하기

File > Save Config As > Save

view_mapping.launch에서 저장한 .rviz파일을 실행할 수 있음
teleop_keyboard로 mapping을 하고나면
map을 저장해야 한다.
.
.
Map 다루기

오픈소스 기반 SLAM 패키지 : gmapping


(자료출처; programmers)
rviz는 topic을 시각화하는 tool이므로 nav_msgs/OccupancyGrid를 시각화한다.

오픈소스 기반 Map 관리 패키지 : map_server

2가지 노드를 제공 (map_saver & map_server)

map_saver 노드

현재 얻은 지도를 저장할 수 있다
(확장자 .pgm & .yaml 파일이 저장된다)



.
키보드로 mapping을 모두 한 이후에 아래 명령어로 mapping한 map을 저장해주자
-f 뒤에 적는 것이 파일명이 된다.
roscd turtlebot_navigation_gazebo/maps
rosrun map_server map_saver -f my_map



image : grid map pgm 파일이름 지정
resolution : map의 해상도를 pixel 당 m 단위로 지정 (e.g. 0.05m x 0.05m = 1 pixel)
origin : 전역 좌표계에서 지도 원점을 지정 - 2D (x, y, rotate)
negate : map 반전 여부 결정 (boolean), 빈칸 - 점유된 칸 반전 -> 장애물 map을 만들 때 유용 
occupied_thresh : occupied 되었는지 결정하는 threshold, 이 값보다 크거나 같은 값은 점유된 것으로 간주
free_thresh : map에서 cell이 사용가능한지 결정하는 threshold, 이 값보다 작거나 같은 값은 모두 비어있는 것으로 간주





pixel의 점유 / 빈칸 여부를 색으로 표시
ros_msgs로 map의 정보가 전달될 때는 0~100까지의 정수를 이용하는데
0 = 빈칸
100 = 장애물 (occupied)
-1 = unknown



map_server 노드 - 다른 노드가 지도를 요청하면 지도 제공
map_server 노드가 제공하는 service * static_map(nav_msgs/GetMap)

map_server 노드가 제공하는 latched topic = 토픽의 마지막 msg가 저장됨
map_metadata(nav_msgs/MapMetaData) - .yaml파일에 있는 정보들
map (nav_msgs/OccupancyGrid) - -1,0,100으로 그린 map







아래 명령어로 지도의 정보를 또ㅍ다른 노드 (e.g move_base) 에게 제공할 수 있다.
(파일이 저장된 경로에서는 경로 지정없이 파일 이름만으로 가능)
rosrun map_server map_server map_file.yaml
rqt
rqt를 열어보면 /map 과 /map_metadata가 topic으로 publishing되는 것을 확인할 수 있다.
rviz를 켜고 map을 add 한 후 rosrun으로 map을 켜주면 rviz에 map이 나타난다.
실습
mission
map_server 노드를 rosrun이 아닌 launch 파일로 실행하기

arg 태그를 활용해 .yaml 파일도 받을 수 있도록 만들기

code ~/sim_ws/src/programmers_turtlebot/turtlebot_navigation_gazebo/launch/map_server.launch


    

    
roscore
rviz
roslaunch turtlebot_navigation_gazebo map_server.launch
.
/static_map service를 처리할 수 있는 service client node (call_map_service.py) 작성하기

지도 데이터를 가져오기 위해 /static_map 서비스를 호출
결과로 터미널에 지도의 크기와 해상도를 인쇄

mkdir ~/sim_ws/src/programmers_turtlebot/turtlebot_navigation_gazebo/script
code ~/sim_ws/src/programmers_turtlebot/turtlebot_navigation_gazebo/script/call_map_service.py

#! /usr/bin/env python3

import rospy
from nav_msgs.srv import GetMap, GetMapRequest
import sys 

rospy.init_node('service_client') # Initialise a ROS node with the name service_client
rospy.wait_for_service('static_map') # Wait for the service /static_map to be running
rospy.loginfo("init complete")

get_map_service = rospy.ServiceProxy('static_map', GetMap) # Create the connection to the service
get_map = GetMapRequest() # Create an object of type GetMapRequest

result = get_map_service(get_map) # Call the service
print(result) # Print the result given by the service called
chmod +x call_map_service.py
roscore
roslaunch turtlebot_navigation_gazebo map_server.launch
rosrun turtlebot_navigation_gazebo call_map_service.py
(rviz)

terminal에서 map이 출력된 것을 확인할 수 있다.
static map - 호출했을 때의 상태를 유지 (환경이 변화해도 반영되지 않음, 2D map이므로 높이 정보 없음 - 드론에는 적용 불가)

.
.
Transforms
좋은 mapping을 위한 다양한 조건들
2D Lidar SLAM을 위한 하드웨어 요구사항

Good Laser Data
Good Odometry Data

Odometry : 원점으로부터 로봇이 얼마나 이동했는가를 나타내는 값
Transforms
.
    - 한 프레임에 표현된 데이터를 다른 프레임으로 변환하는 방법
    - Laser 정보를 이용해 map을 구성하기 위해서는 Laser의 위치와 방향을 로봇에게 알려줘야함 = transform
    - Position, Orientation 정보를 포함
예를 들어 lidar가 30cm 앞에 장애물이 있다고 인지했다면 로봇의 중심으로부터의 거리는 또 다를 것이다.
그래서 lidar frame에서 robot frame으로 변환이 필요하다.
Mapping을 위해 꼭 필요한 변환 관계

laser_link -> base_link
일반적으로 고정된 값
robot_state_publisher or static_transfrom_publisher 노드에 의해 주기적으로 broadcast




base_link -> odom (기준위치로부터 로봇이 얼마나 움직였는가)
Odometry 시스템에 의해 제공 (wheel odometry, visual odometry)



.
.
tf 시각화하기
roslaunch turtlebot_navigation_gazebo main.launch
rqt
rqt에서
plugins > visualization > tf tree
변환관계를 확인할 수 있음!
TF Broadcast - TF 관계 설정하는 방법

static_transform_pulbisher
x, y, z: 프레임간의 거리 오프셋
yaw, pitch, roll (rad): 프레임 간의 회전 오프셋
frame_id, child_frame : 각각의 frame ID
period_in_ms : TF를 퍼블리싱할 주기



방법1
rosrun tf static_transform_publisher x y z yaw pitch roll frame_id child_frame_id period_in_ms
방법2

    
    
실습
mission

static_transform_publisher 노드를 시작하기 위한 launch 파일 만들기(pub_static.launch)
로봇 최상단에 button을 부착한다고 가정, button과 로봇의 base_link 사이의 TF publishing
TF 시각화를 통해 프레임 그래프를 다시 생성하고 새 Transform이 게시되는지 확인code ~/sim_ws/src/programmers_turtlebot/turtlebot_navigation_gazebo/launch/pub_static.launch



    
    
roslaunch turtlebot_navigation_gazebo main.launch
rviz
roslaunch turtlebot_navigation_gazebo pub_static.launch
rqt
button 노드가 추가되었다.
rviz 상에서 RobotModel과 TF 를 추가하여 만든 tf를 확인할 수 있다.


모든 로봇을 설계할 때 이런 식으로 하나씩 다 tf를 정의해야하는 걸까??
  -> 아니다. 로봇 모델의 정의를 하는 URDF에서 TF를 정의한다. 가끔 하나씩 추가를 해줘야할 떄 사용하기에 유용하다.

.
.
오픈소스 SLAM 패키지
gmapping의 일반 파라미터

roslaunch, yaml 파일에서 별도로 설정할 수 있음

base_frame (default: "base_link")

모바일 베이스의 기준 프레임 - 모바일 베이스, 로봇의 기준점을 의미    


map_frame (default: "map")

지도의 기준이 될 프레임의 이름 - map을 기준으로 baseframe이 어디있는지 알기 위해


odom_frame (default: "odom")

Odometry 시스템에 연결된 프레임의 이름 - map -> odom -> base


map_update_interval(default: 5.0)

지도를 업데이트할 때까지 대기할 시간을 설정 



gmapping의 laser 관련 파라미터

maxRange (float)
Laser의 최대 범위를 설정
이 값은 실제 센서의 최대 범위보다 약간 높은 값으로 설정


maxUrange (default: 80.0m)
Laser의 최대 사용 가능 범위를 설정
Laser의 beam이 이 값으로 잘림


minimumScore (default: 0.0)
Laser의 센서 값이 양호하다고 간주하는 최소 점수를 설정



gmapping의 Map 관련 파라미터

xmin (default: -100.0)
initial map size


ymin (default: -100.0)
initial map size


xmax (default: 100.0)
initial map size


ymax (default: 100.0)
initial map size


delta (default: 0.05)
sets the resolution of the map



gmapping의 기타 파라미터

linearUpdate (default:1.0)
laser 센서 값을 처리하기 위해, 로봇이 이동해야 하는 선형 거리
최소한 1m는 이동해야 map이 업데이트 된다


angularUpdate (default: 0.5)
laser 센서값을 처리하기 위해, 로봇이 이동해야 하는 각도
최소한 0.5rad는 회전을 해야 map이 업데이트 된다



YAML 파일을 이용한 파라미터 load
launch 파일에서의 yaml 파일 업로드
yaml 파일 내부구조
name_of_parameter: value_of_parameter
실습
mission

map_update_interval을 15로 바꾸고 map update 주기 확인

키보드로 로봇을 움직여 보면서 update주기가 바뀌었는지 확인


maxUrange를 2로 바꾸고 mapping 영역 확인

map이 없데이트되는 범위가 확 줄어든다.




xmin, ymin를 -100d으로 xmax, ymax를 100으로 설정하고 초기 map이 어떻게 보이는지 확인

scan할 수 있는 범위가 매우 넓어짐 (로봇이 움직이면 더 확장됨)




모든 파라미터 변겅은 yaml파일에서 하도록 함 (gmapping_params.yaml)

.
code ~/srm_ws/src/programmers_turtlebot/turtlebot_navigation_gazebo/param/gmapping_params.yaml
programmers_turtlebot/turtlebot_navigation/launch/includes/gmapping/gmapping.launch.xml 파일을 참고해서 yaml 파일의 양식에 맞게 작성해주면 된다.

base_frame: base_footprint
odom_frame: odom
map_update_interval: 5.0
maxUrange: 6.0
maxRange: 8.0

minimumScore: 200

linearUpdate: 0.5
angularUpdate: 0.436
temporalUpdate: -1.0
resampleThreshold: 0.5
particles: 80
xmin: -1.0
ymin: -1.0
xmax: 1.0
ymax: 1.0

delta: 0.05
llsamplerange: 0.01
llsamplestep: 0.01
lasamplerange: 0.005
lasamplestep: 0.005
이제 이 파라미터들을 읽어올 launch 파일을 만들어보자
code ~/sim_ws/src/programmers_turtlebot/turtlebot_navigation_gazebo/launch/my_gmapping.launch


    

    
        

        
    
일단 launch 파일을 잘 설정했는지 확인하기 위해 실행해본 후 
.yaml 파일의 파라미터를 바꿔보면 된다.
(yaml 파일에서 파라미터를 바꿀 때마다 launch 다시 해야함)
roslaunch turtlebot_navigation_gazebo main.launch
roslaunch turtlebot_navigation_gazebo my_gmapping.launch
roslaunch turtlebot_rviz_launchers my_gmapping.launch
.
.
기타 Tip
Map을 수동으로 조작하기

직접 포토샵을 이용해서 지울 수 있다. - gimp

Logging된 데이터를 이용해 Map 생성하기

매번 mapping을 할 수 없으니까 bag 파일로 저장해서 slam 만 추후에 진행하는 방식


bag file 만들기
LaserScan topic과 TF 정보를 recording 하기



robag record -O mylaserdata /laser_topic /tf_topic
2.bag file을 재생하고 map 생성하기
rosbag play bag_file_name
실습
키보드로 로봇을 움직이며 그동안의 bag file 을 저장
roslaunch turtlebot_navigation_gazebo main.launch
roslaunch turtlebot_teleop keyboard_teleop.launch
rosbag record -O mylaser /kobuki/laser/scan /tf /tf_static
모두 종료 후 저장된 bag 파일로 mapping
roslaunch turtlebot_navigation_gazebo my_gmapping.launch
roslaunch turtlebot_rviz_launchers view_mapping.launch
rosbag info mylaser.bag (잘 저장되었나 확인)
rosbag play mylaser.bag
rviz상에서 map이 점점 그려지는 것을 확인할 수 있다.
.
.
과제 - Map 만들기
목표

corridor.world 환경의 Map 구성하기
또는 4강 과제에서 만들었던 나만의 world를 load해서 map 구성하기
  (.pgm & .yaml 파일 제출)

Mission
기존 실행했던 main.launch 파일을 수정해 다른 world load
나는 corridor_main.launch 라는 이름으로 파일을 만들어주었다.
나머지는 main.launch 파일과 모두 동일하고 world 파일만 corridor로 바꾸어주면 된다.


   
  

   
     
     
     

  
  
  
  
  

  
    
    
    
    
    
    
  

  
    
    
    
  

  
    
  

  
  

.
.
slam_gmapping 노드를 실행시키고 mapping 수행하기
roslaunch turtlebot_navigation_gazebo corridor_main.launch
roslaunch turtlebot_navigation_gazebo gmapping_demo.launch
roslaunch turtlebot_rviz_launchers view_mapping.launch
roslaunch turtlebot_teleop keyboard_teleop.launch
위 launch 파일들을 모두 실행하고 키보드로 world를 돌아다니며 mapping을 해주면 된다.

mapping 결과 저장하기
rosrun map_server map_saver -f corridor_map_yj
이 명령어를 실행하고 나면 .pgm파일과 .yaml 파일로 map이 저장된다.



image: corridor_map_yj.pgm
resolution: 0.050000
origin: [-12.200000, -13.800000, 0.000000]
negate: 0
occupied_thresh: 0.65
free_thresh: 0.196


[Simulation] Navigation
Mon, 26 Jun 2023 14:37:31 GMT
심화편 소개
시뮬레이션에 활용될 로봇들

kobuki = turtlebot
Husky
Summit XL

목적

ROS 기반의 Navigation Stack 학습
Navigation Stack으로 프로젝트 진행

필요한 파일 다운로드 받기
~/sim_ws/src에 programmers_turtlebot 파일 다운로드 받기
아래 명령어로 dependency 설치 후 build 해주기
ubuntu 20.04의 code name = focal
ubuntu 18.04의 code name = bionic
자신의 ubuntu 버전에 맞게 code name을 바꿔서 아래내용을 terminal에 쳐주자
rosdep install --from-paths src --ignore-src -r -y --os=ubuntu:bionic
catkin_make
roslaunch turtlebot_navigation_gazebo main.launch
.
.
자율주행에 필요한 요소

ROS기반의 Navigation stack을 구성해서 로봇이 특정 환경을 자율적으로 탐색하도록 만들기 위해서는


Mapping (로봇이 움직이며 lidar와 같은 센서로 주변환경을 지도로 얻는 과정)roslaunch turtlebot_navigation_gazebo main.launch
roslaunch turtlebot_navigation_gazebo gmapping_demo.launch
roslaunch turtlebot_teleop keyboard_teleop.launch
roslaunch turtlebot_rviz_launchers view_mapping.launch

keyboard로 로봇을 움직이며 환경을 mapping 해보면 된다.
.
.

Localization (지도 속에서 내가 어느 위치에 있는지, 어느 방향을 향하고 있는지 알아야 함)

roslaunch turtlebot_navigation_gazebo main.launch
roslaunch turtlebot_navigation_gazebo amcl_demo.launch
roslaunch turtlebot_rviz_launchers view_localization.launch
roslaunch turtlebot_teleop keyboard_teleop.launch
녹색화살표 = localization 추정치
로봇을 움직이다 보면 laser scan (red)와 map이 어느정도 일치하는 것을 확인할 수 있다.

Path planning (경로 계획)

rviz 상에서

2D Pose Estimate : 로봇의 위치와 방향을 지정해줄 수 있음
2D Nav Goal : 로봇의 목표위치 지정 (로봇을 목표위치로 보내줄 수 있음)

roslaunch turtlebot_navigation_gazebo main.launch
roslaunch turtlebot_navigation_gazebo move_base_demo.launch
roslaunch turtlebot_rviz_launchers view_planning.launch

Obstacle Avoidanceroslaunch turtlebot_navigation_gazebo main.launch
roslaunch turtlebot_navigation_gazebo move_base_demo.launch
roslaunch turtlebot_rviz_launchers view_navigation.launch



민트색 cost map과 로봇 주위에 local cost map이 생성된 것을 확인할 수 있다.
cd ~/turtlebot_navigation/urdf
rosrun gazebo_ros spawn_model -file object.urdf -urdf -x 0 -y 0 -z 1 -model my_object
장애물을 spawn하고 로봇을 근처로 이동해보면 장애물을 감지하는 것을 확인할 수 있다
rviz상에서 장애물을 넘어가도록 2D Nav Goal을 설정해주면 장애물을 피해서 가는 것을 확인할 수 있다.
갑자기 object를 앞에 두어도 로봇이 잘 피해가는 것을 확인할 수 있다.


> 소소한 TIP
roslaunch를 실행하다보면 계속 다른 terminal을 켜야하는 경우가 생긴다.
이때는 terminator를 이용하면 편하다 
>> sudo apt-get install terminator
ctrl + shift + O (가로분할) or 한영키 옆 menu + O
ctrl + shift + E (세로분할) or 한영키 옆 menu + E
.
.

# Navigation Stack

- 사용하려는 로봇을 올바르게 구성하고 정의하는 것이 중요
- 로봇의 구성 및 정의 : URDF 파일

## 하드웨어 요구사항

- kinematics
    - Differential drive
    - Holonomic Drive (Omnidirectional Drive)
    - Skid steer Drive
    - Ackermann Drive
- Velocity control
    - x, y (linear)
    - z (angualr)
- Sensor
    - LiDAR, Camera ...
- Mobile Robot Shape
    - square, circular ...

[Navigation Stack Setup](http://wiki.ros.org/navigation/Tutorials/RobotSetup)


## 실습

### 목표
- Navigation Stack 구성 요소를 시뮬레이션 환경에서 확인해보기

### Mission
- Kobuki와 Navigation 관련 Launch file 실행
- Navigation stack에 필요한 Topic 체크
roslaunch turtlebot_navigation_gazebo main.launch
roslaunch turtlebot_navigation_gazebo move_base_demo.launch
rqt_graph
rostopic list
rosmsg show nav_msgs/Odometry

### move_base 노드
- move_base 노드와 연결되는 패키지들
 > global-planner
 local planner
 rotate-recovery
 clear-costmap-recovery
 costmap-2D

- move_base 노드와 연결되는 외부 패키지들
> map-server
AMCL
gmapping, slam-karto 등


{-ing}[Simulation][Project][Gazebo] 시뮬레이션 기초 전부 활용해보자! 프로젝트
Sun, 25 Jun 2023 11:45:50 GMT

지금까지 배운 simulation 기초를 모두 활용해볼 프로젝트가 과제로 나왔다!
simulation을 배우는 건 처음인데 너무너무 재미있다. 잘 배워서 나중에 다양한 로봇과 환경에서 활용해보고 싶다.
무엇보다 너무 좋은 강의해주시는 신승렬강사님 너무 감사합니다! ><


과제를 수행한 것이라 모든 내용은 내가 직접 했다 😊
나는 프로그래머스 Planning & Control 1기 과정을 진행중이다 ㅎㅎ
내가 프로젝트를 수행하면서 과정을 기록한 내용이기 때문에 뒤로 갈수록 코드에 변화가 생겼다.
이걸보고 비슷하게 진행해보고 싶은 사람은 나의 github에 올라와있는 코드(=최종본)를 보는 것이 이해하는데 더 편할 것 같다.

프로젝트 - 시뮬레이터 기초편 전체 활용
개발 환경 준비하기
새 ROS 패키지 만들기

프로젝트와 관련한 모든 것을 수행할 mid_project라는 새 패키지 생성
지금까지 작성했던 dependency들을 잘 활용할 것

그동안 배운 simulation 기초를 모두 활용해보는 과제이므로
지금까지 이용한, 그리고 지금 프로젝트에 필요한 dependency를 모두 추가해서 package를 만들었다.
.
.
cd ~/sim_ws/src
catkin_create_pkg mid_project rospy roscpp urdf xacro gazebo gazebo_ros gazebo_plugins
.
.
새로운 world 만들기
Launch 파일과 world 파일 만들기
(가이드)
~/sim_ws/src/mid_project/launch/gazebo.launch
~/sim_ws/src/mid_project/launch/spawn.launch
~/sim_ws/src/mid_project/models/custom_mid_obj
    (이 directory에 model.config와 model.sdf 포함)
일단 나는 헷갈릴까봐 모든 폴더를 다 만들어 두었다.
mkdir -p ~/sim_ws/src/mid_project/launch
mkdir -p ~/sim_ws/src/mid_project/models/custom_mid_obj
mkdir -p ~/sim_ws/src/mid_project/worlds
mkdir -p ~/sim_ws/src/mid_project/
World 만들기 (walls.world)
code ~/sim_ws/src/mid_project/worlds/walls.world
code ~/sim_ws/src/mid_project/launch/gazebo.launch
Gazebo에서 기본으로 제공하는 shape들을 활용해 custom_mid_obj 만들기
강의에서 주어진 모델은 이렇게 생겼다. 
기본으로 제공되는 box와 cylinder를 이용해서 shape을 만들어 주었다.

만드는 파일 : model.sdf & model.config

만들고 나서 /.gazebo/models에 폴더 자체를 추가해주는 것 잊지 말자~


** 나중에 로봇이 라이더로 돌아다닐 예정이므로 collision 설정도 해주어야 한다!
.
.
[Error] : [parser.cc:759] XML Attribute[length] in element[cylinder] not defined in SDF, ignoring.
.sdf 파일에서 cylinder 태그를 아래와 같이 radius와 length를 적어서 만들어졌었는데 내가 원하는대로 반지름이나 길이가 반영이 안되서 터미널을 보니 에러가 나고 있었다.


[Solution] 아래처럼 태그로 달아주면 해결~





.
.
.sdf 파일에서 정해주는 model name이 앞으로 world에서 include 할 때 적는 이름이니까 잘 설정해두자 :)



    
        0 0 0.5 0 0 0
        false
        
            
                1.0
                
                    0.083
                    0.0
                    0.0
                    0.083
                    0.0
                    0.083
                
            

            
            
                1.55 1 0 0 0 0.523
                
                    
                        0.3 2 0.5
                    
                
            

            
                1 0 0 0 0 0
                
                    
                        2 0.3 0.5
                    
                
            

            
                0.55 1 0 0 0 1.0472
                
                    
                        2 0.3 0.5
                    
                
            


            
                0 0 0 0 0 0
                
                    
                        0.25
                        1
                    
                
            


            
                2 0 0 0 0 0
                
                    
                        0.25
                        1
                    
                
            


            
                1 2 0 0 0 0
                
                    
                        0.25
                        1
                    
                
            


            
            
                1.55 1 0 0 0 0.523
                
                    
                        0.3 2 0.5
                    
                
            
            
                    1 0 0 0 0 0
                    
                        
                            2 0.3 0.5
                        
                    
            

            
                0.55 1 0 0 0 1.0472
                
                    
                        2 0.3 0.5
                    
                
            

            
                0 0 0 0 0 0
                
                    
                        0.25
                        1
                    
                
            
             
                2 0 0 0 0 0
                
                    
                        0.25
                        1
                                   
                
            
             
                1 2 0 0 0 0
                
                    
                        0.25
                        1
                                   
                
            
        
    





    Custom Model
    1.0
    model.sdf

    
        yujin
        aaaa@gmail.com
    

    
        custom object
    
.
.
.
Gazebo Model Library에서 제공하는 "grey_wall"을 활용해 벽 세우기 (20mx20m의 정사각형)
 에 population으로 벽을 만들어주었다.
벽이 규격대로 사각형이 딱 맞게 나타나는 것이 아니라서 
일단 위치를 맞춘 후에 보면서 약간의 미세 조정이 필요하다. (약간 오래 걸림)
(그래서 20x20이지만 xy의 좌표가 10,-10만 있는 것은 아님)
가능하면 Gazebo ui 상에서 벽을 배치한 후 .world파일로 저장하는 것이 편할 것 같다.
(나는 virtual machine을 쓰고 있어서 그런지 world를 저장하면 자꾸 UI가 멈춰서..... population으로 만들어줬다.)



    

        
        
            model://sun
        

        
        
            model://ground_plane
        

        
        
            
                
                    true
                    model://grey_wall
                
            
            3 10 0.3 0 0 0
            
                20 20 0.01
            
            3
            
                linear-x
            
        

        
        
            
                
                    true
                    model://grey_wall
                
            
            2.8 -10.6 0.3 0 0 0
            
                20 20 0.01
            
            3
            
                linear-x
            
        

        
        
            
                
                    true
                    model://grey_wall
                    0 0 0 0 0 1.57
                
            
            10 3 0.3 0 0 0
            
                20 20 0.01
            
            3
            
                linear-y
            
        

        
        
            
                
                    true
                    model://grey_wall
                    0 0 0 0 0 1.57
                
            
            -11 3 0.3 0 0 0
            
                20 20 0.01
            
            3
            
                linear-y
            
        

    

.
.
벽 내부에 생성한 custom_mid_obj 4개를 10mx10m의 영역에 균일하게 배치(정적 장애물 4개)
population에서 distribution tag는 Population of model를 참고해 uniform으로 설정했다.
아래 코드를 위에서 작성한 walls.world에 넣어주면 된다.
<+walls.world>
        
        
            
                
                    true
                    model://custom_mid_obj
                
            
            -1 -1 0 0 0 0
            
                10 10 0.01
            
            4
            
                uniform
            
        
/
성공!

collision 설정도 잘 된 것을 확인했다.

.
.
.
.
.
Model Plugin 작성하기
관련 파일 준비하기

Plugin 파일 만들기~/sim_ws/src/mid_project/src/moving_plugin.cc
새 Plugin을 컴파일할 수 있도록 CMakeList.txt 파일 수정

Plugin 작성하기
고정해놨던 custom object 외에 동적 장애물 만들기 (동적 장애물 4개)
moving_plugin.cc 작성

plugin을 만들어서 모델을 world에 올렸더니 이렇게 신나게 날아다니고 있었다.
의도한 바는 바닥에 붙어서 얌전히 움직이는 것이었는데.. 해결방법은 아직 찾는중이다. 🤣


.
.
.
.
로봇 가져오기
관련 file 준비하기

urdf 디렉터리와 파일 만들기~/sim_ws/src/mid_project/urdf/robot.xacro
~/sim_ws/src/mid_project/urdf/robot.gazebo

Robot 구성하기

로봇은 4개의 wheel을 보유
이전 강의에서 만들었던 로봇보다 작아야함 (장에물 회피에 용이)
skid steering drive를 활용하여 로봇을 제어하고 odometry 데이터를 읽음
장애물을 피하기 위해 laser scan을 배치
부드러운 움직임을 위해 마찰 계수 조절하기

간단한 장애물 회피 알고리즘 구현하기
obstacle_aviodance.py 작성하기

아래 쪽의 sample_script를 개선한 프로그램 작성하기
로봇이 장애물에 접근하는 경우, 후진을 해야할 수 있음
알고리즘은 laser scan topic을 읽어 callback 함수에서 범위별 측정한 평균값을 지정
로봇을 충분한 여유 공간이 있을 때마다 전진하고, 장애물에 가까워지며 왼쪽으로 방향을 전환하면서 이동

결과확인
export GAZEBO_MODEL_PATH=~/sim_ws/src/mid_project/models:$GAZEBO_MODEL_PATH
roslaunch mid_project gazebo.launch
roslaunch mid_project spawn.launch
rosrun mid_project obstacle_aviodance.py


[Visual Studio Code] 파일 확장자 인식 설정 방법 
Fri, 23 Jun 2023 11:47:04 GMT
simulation 코딩을 하다보면 .world 파일 같은 확장자를 가진 파일이 xml 인식이 안되는 경우가 있다.
이런 경우는 다 같은 색으로 보여 불편할 수 있으므로 vsc상에서 설정해줄 수 있다.
먼저 visual studio code에서 좌측 하단에 있는 설정 모양을 눌러 setting으로 들어가거나
단축키 :** ctrl+, **로 들어갈 수도 있다.
setting 창이 켜지면 "file association"이라고 검색해 "Add Item"을 해주면 된다.

나는 .world 파일을 xml로 인식하도록 설정해주었다.
그러면 이후부터 .world 파일을 만들면 자동으로 xml로 인식하게 된다.



[Simulation] Gazebo Plugin
Fri, 23 Jun 2023 07:53:36 GMT
Gazebo Plugin이란?🤷‍♀️

Gazebo plugins give your URDF models greater functionality and can tie in ROS messages and service calls for sensor output and motor input. 


Gazebo API는 물체를 움직이거나 센서 데이터를 받아오거나 등등의 다양한 기능을 제공하는데 이때 plugin은 이 API에 접근이 가능하도록 해준다.
Plugin은 C++ library로 

Plugin 개발 환경 준비

C++로 만들어짐

Plugin 만들기
cd ~/sim_ws/src
catkin_create_pkg writing_plugins gazebo gazebo_ros gazebo_plugins roscpp
code ~/sim_ws/src/writing_plugins/src/my_gazebo_plugin.cc

.cc 파일이 처음인 분도 있을 것이다.
  오래된 code base나 embedded system programming에서 사용되는 확장자로 
  c with classes의 약어이고 대부분 cpp compiler에서 작동한다.
  gazebo는 plugin을 만들 때 .cc 파일을 활용한다.


#include 
#include 
#include 
namespace gazebo{
        class MyGazeboPlugin : public WorldPlugin {
            public:
            MyGazeboPlugin() : WorldPlugin() {
                std::cout << "Plugin constructor method!" << std::endl;
            }

            public:
            void Load(physics::WorldPtr _world, sdf::ElementPtr _sdf) {
                std::cout << "Everything is awesome!" << std::endl;
            }
        };

        // register plugin - why no semicolon..?
        GZ_REGISTER_WORLD_PLUGIN(MyGazeboPlugin)
}
GZ_REGISTER_WORLD_PLUGIN : gazebo에 plugin을 등록하는데 사용되는 매크로 호출이다.
.
 도 수정해줘야한다.
cmake_minimum_required(VERSION 3.0.2)
project(writing_plugins)

find_package(gazebo REQUIRED)

find_package(catkin REQUIRED COMPONENTS
  gazebo_plugins
  gazebo_ros
  roscpp
)

catkin_package()

include_directories(
    # include
  ${catkin_INCLUDE_DIRS}
)

include_directories(${GAZEBO_INCLUDE_DIRS})
link_directories(${GAZEBO_LIBRARY_DIRS})
list(APPEND CMAKE_CXX_FLAGS "${GAZEBO_CXX_FLAGS}")

add_library(my_gazebo_plugin SHARED src/my_gazebo_plugin.cc)
target_link_libraries(my_gazebo_plugin ${GAZEBO_LIBRARIES})
.

find_package : 우리가 사용할 package의 필요한 dependency를 찾고 구성해주는 역할
(패키지 의존성(Package Dependencies)이란 한 패키지가 정상적으로 동작하기 위해서 다른 패키지나 라이브러리 패키지)
catkin_package : package.xml을 바탕으로 cmake에 지시를 줌
include_directories / link_directoies : directory나 link library를 프로젝트에 추가해줌
add_library : 라이브러리를 추가해주고
target_link_libraries : 라이브러리를 연결해주는 역할

이제 build를 해준다. 빌드가 되고나면 이제 plugin을 사용할 준비가 되었다는 뜻이다.
나는 catkin_make를 이용해서 계속 package를 빌드해왔다.
정확히는 alias를 정의해서 'cd ~/sim_ws && catkin_make' 이렇게 한번에 해주고 있다.
문득 catkin build랑 catkin_make는 뭐가 다른지 궁금해서 정리해뒀으니 궁금한 사람은 읽어보자 👍
*한번 catkin_make로 빌드하고 나면 catkin build로 빌드가 안됨
cd ~/sim_ws
catkin build
.

[궁금증] catkin_make vs catkin build ?


catkin build를 사용하면 전체적인 build configuration이 훨씬 견고해지고 
isolated package는 병렬로 빌드되므로 훨씬 빠르다.




catkin build는 아무 directory에서나 가능하지만 catkin_make는 top level directory에서만 가능하다.
single package만 build할수도 있다. - catkin build (package_name)
catkin build는 catkin clean, install, list ... 등등의 다양한 subcommands도 제공한다.

.
.
Plugin 경로설정

Gazebo plugin 환경변수를 선언해주자.
이렇게 하면 새로 생성한 plugin을 gazebo에게 알려줄 수 있다.

simulation을 실행할 때마다 terminal에서 선언해주면 된다.
.
참고로 띄어쓰기를 하면 안된다 ㅎㅎ
export GAZEBO_PLUGIN_PATH=${GAZEBO_PLUGIN_PATH}:~/sim_ws/devel/lib
.
실행을 위한 파일 생성
launch & world 파일 만들기

우리가 만든 package안에 launch & world 폴더와 파일을 만들어주자mkdir -p ~/sim_ws/src/writing_plugins/launch
code ~/sim_ws/src/writing_plugins/launch/gazebo.launch
mkdir -p ~/sim_ws/src/writing_plugins/worlds
code ~/sim_ws/src/writing_plugins/launch/gazebo.world

[궁금증] mkdir -p는?
mkdir 뒤에 옵션으로 붙는 -p는 상위폴더도 함께 생성하라는 의미이다.
그 외에도 -v는 생성하고 생성된 경로를 메세지 출력 등의 옵션이 있습니다.
.



.


    
        
        
        
        
        
        
    



    
        
    

.world 파일이 visual studio code에서 xml로 인식이 잘 안된다면 
아래 링크를 참고해 vsc상에서 설정해주자
vsc 파일 확장자 설정하기

결과확인
roslaunch writing_plugins gazebo.launch
실행시키고 나면 위에서 가 실행되어 아래내용이 print된다.

Plugin constructor method!
Everything is awesome!


.
.
World Plugin
Plugin으로 gazebo상에 model 넣기
위에서 만든 my_gazebo_plugin.cc에서 Load 함수 부분만 변경해주면 되지만
나는 더 정확히 이해하기 위해 
다른 이름 my_gazebo_plugin_world.cc 를 만들어주었다.
.cc 파일 만들기

#include 
#include 
#include 
namespace gazebo{
    class MyGazeboPlugin : public WorldPlugin {
        public:
        MyGazeboPlugin() : WorldPlugin() {
            std::cout << "Plugin constructor method!" << std::endl;
        }

        public:
        void Load(physics::WorldPtr _world, sdf::ElementPtr _sdf){
            //set a node
            transport::NodePtr node(new transport::Node());
            node->Init(_world->Name());

            //set publisher
            transport::PublisherPtr publisher=node->Advertise("~/factory");

            //create msg obj
            msgs::Factory msg;

            //model to use
            msg.set_sdf_filename("model://jersey_barrier");

            //send the message
            publisher->Publish(msg);
        }
    };
    GZ_REGISTER_WORLD_PLUGIN(MyGazeboPlugin)
}
.
.
.
CMakeList.txt 수정하기
이미 위에서 CMakeList.txt를 수정했기 때문에 1줄만 추가해주면 된다.
add_library(my_gazebo_plugin_world SHARED src/my_gazebo_plugin_world.cc)
그 다음 build를 해주면 .so 파일이 생성된 걸 확인할 수 있다.

.
world 파일 만들기
code ~/sim_ws/src/writing_plugins/worlds/gazebo_world.world



    
        
    
Launch 파일 만들기
code ~/sim_ws/src/writing_plugins/launch/gazebo_world.launch


    
        
        
        
        
        
        
    

.
.
결과
launch 파일을 실행하면 
gazebo에 jersey_barrier가 생긴 것을 볼 수 있다.

Plugin을 이용해 모델을 특정위치에 배치하기

world_plugin.cc 파일 생성하고, CMakeList.txt에 필요한 코드 추가하기
gazebo.world도 이에 맞게 수정하기
Plugin을 통해 모델을 특정 위치에 배치하기

힌트
msgs::Set(msg.mutable_pose(),
    ignition::math::Pose3d(
        ignition::math::Vector3d(5,5,0),
        ignition::math::Quaterniond(0,0,0))
);
.

#include 
#include 
#include 
namespace gazebo{
    class MyGazeboPlugin : public WorldPlugin {
        public:
        MyGazeboPlugin() : WorldPlugin() {
            std::cout << "Plugin constructor method!" << std::endl;
        }

        public:
        void Load(physics::WorldPtr _world, sdf::ElementPtr _sdf){
            //set a node
            transport::NodePtr node(new transport::Node());
            node->Init(_world->Name());

            //set publisher
            transport::PublisherPtr publisher=node->Advertise("~/factory");

            //create msg obj
            msgs::Factory msg;

            //model to use
            msg.set_sdf_filename("model://jersey_barrier");

            msgs::Set(msg.mutable_pose(),
                ignition::math::Pose3d(
                    ignition::math::Vector3d(5,5,0),
                    ignition::math::Quaterniond(0,0,0))
            );
            //send the message
            publisher->Publish(msg);
        }
    };
    GZ_REGISTER_WORLD_PLUGIN(MyGazeboPlugin)
}
결과

(5,5) 위치에 잘 놓여있는 것을 확인할 수 있다~


.
.
Model Plugin
모델 움직이기

world plugin과 다른 class를 상속해주면 model plugin을 만들 수 있다.

code ~/sim_ws/src/writing_plugins/worlds/model.world
code ~/sim_ws/src/writing_plugins/src/my_model_plugin.cc
code ~/sim_ws/src/writing_plugins/launch/model.launch
모델을 움직이는 plugin.cc 만들기

#include 
#include 
#include 
#include 
#include 

namespace gazebo {
    class MyModelPlugin : public ModelPlugin {
        public:
        void Load(physics::ModelPtr _parent, sdf::ElementPtr) {
            // Store the pointer to the model
            this->model = _parent;

            // Listen to the update event. This event is broadcast every simulation iteration.
            this->updateConnection = event::Events::ConnectWorldUpdateBegin(
                std::bind(&MyModelPlugin::OnUpdate, this));
        }

        // Called by the world update start event
        public:
        void OnUpdate() {
            // Apply a small linear velocity to the model.
            if (this->counter < 10000) {
                this->model->SetLinearVel(ignition::math::Vector3d(0, 0, 0.4));
            }

            this->counter++;
        }

        // Pointer to the model
        private:
        physics::ModelPtr model;

        private:
        int counter;

        // Pointer to the update event connection
        private:
        event::ConnectionPtr updateConnection;
    };

    // Register this plugin with the simulator
    GZ_REGISTER_MODEL_PLUGIN(MyModelPlugin)
} // namespace gazebo
OnUpdate : 반복 주기에 의한 callback 함수
모델이 위쪽으로 움직이게 되는 이유는 setLinearVel에서 Z 축 방향으로 0.4만큼의 velocity를 계속 인가하고 있기 때문, 관련링크 : setLinearVel

API에 대한 내용은 홈페이지를 참고하자 : Gazebo:Model class

.
.
CMakeList.txt 수정하기
 파일에서 아래 내용을 수정해준 후 빌드를 해주면 된다.
add_library(my_model_plugin SHARED src/my_model_plugin.cc)
target_link_libraries(my_model_plugin ${GAZEBO_LIBRARIES})
.world 파일 만들기
model plugin의 경우, world 파일에서 불러와줘야 하므로
 파일에서 model 태그 안에 내용을 수정해줘야 한다.


    
        
        
            model://ground_plane
        

        
            model://sun
        

        
            0 0 0.5 0 0 0
            
                
                    
                        
                    
                

                
                    
                        
                    
                
            

            
            
        

    
launch 파일도 생성해준다 ( 앞에서 많이 했으니 생략하겠다. )
결과
정육면체가 위로 올라가는 것을 확인할 수 있다.

.
.
모델을 움직이게 하는 Plugin

목표 : 모델을 움직이게 하는 Plugin (a_model_plugin.cc)

Mission

모델이 반복하며 정사각형 패턴으로 움직이도록 프로그래밍
OnUpdate() callback 함수를 다시 활용


Load() 매서드 안에 hint 코드를 활용하기 (반복횟수 "iterations"와 선형속도 "linear_vel"을 파라미터로 활용)

설정한 파라미터는 model.world에서 설정할 수 있다!



this -> iterations = 10 * 1000;
if (_sdf->HasElement("iterations")){
    this->iterations=_sdf->Get("iterations");
}


    0.2
    15000
.
.
.cc 파일 만들기
포인터가 많이나와서 .. 포인터를 열심히 공부해야겠다 생각했다..

#include 
#include 
#include 
#include 
#include 
#include 

namespace gazebo {
    class AModelPlugin : public ModelPlugin {
        public:
        void Load(physics::ModelPtr _parent, sdf::ElementPtr _sdf) {
            //store the pointer to the model
            this->model = _parent;

            this -> iterations = 10 * 1000;
            if (_sdf->HasElement("iterations")){
                this->iterations=_sdf->Get("iterations");
            }

            this -> linear_vel = 0.0;
            if (_sdf->HasElement("linear_vel")){
                this->linear_vel=_sdf->Get("linear_vel");
            }


            this->updateConnection = event::Events::ConnectWorldUpdateBegin(
                std::bind(&AModelPlugin::OnUpdate, this)
            );

        }

        // Called by the world update start event
        public:
        void OnUpdate() {
            // apply a small linear velocity to the model

            if(this->counter < this->iterations)
            {
                this->model->SetLinearVel(ignition::math::Vector3d(this->linear_vel,0,0));
            }
            else if(this->counter < 2 * this->iterations)
            {
                this->model->SetLinearVel(ignition::math::Vector3d(0,this->linear_vel,0));
            } 
            else if(this->counter < 3 * this->iterations)
            {
                this->model->SetLinearVel(ignition::math::Vector3d(-this->linear_vel,0,0));
            }
             else if(this->counter < 4 * this->iterations)
            {
                this->model->SetLinearVel(ignition::math::Vector3d(0,-this->linear_vel,0));
            }
            else
            {
                this->counter = 0;
            }
            this->counter++;
        }

        private:
        physics::ModelPtr model;

        private:
        int counter;
        double linear_vel;
        int iterations;

        // Pointer to the update event connection
        private:
        event::ConnectionPtr updateConnection;
    };

    // register this plugin with the simulation
    GZ_REGISTER_MODEL_PLUGIN(AModelPlugin)
}
CMakeList.txt 수정하기
아래 내용을 추가해주고~
add_library(a_model_plugin SHARED src/a_model_plugin.cc)
target_link_libraries(a_model_plugin ${GAZEBO_LIBRARIES})
.world 만들기


    
        
        
            model://ground_plane
        

        
            model://sun
        

        
            1 1 0 0 0 0
            false
            
                model://suv
            

            
            
                5.0
                5000
            
        

    
launch 파일은 어렵지 않으니 생략하겠다...
결과
사각형패턴으로 움직이는 것을 확인할 수 있다.

마치며
정말 분량이 많아서 오래걸리고 힘들었지만.....
그래도 ... 반복해서 하다보니 plugin을 만드는 flow를 이해하는데 도움이 되었다!!
c++ 공부에 더 매진해야겠다.
난 이제 지쳤어요 땡벌땡벌




[Simulation] 나의 world에서 키보드로 로봇 움직이기
Thu, 22 Jun 2023 11:58:43 GMT
목표

나만의 World 만들기
다양한 모델과 population을 이용하기
world를 열기 위한 launch 파일 작성하고 실행시키기
로봇 spawn하여 teleop_twist_keyboard로 주행해보기

.
.
step1. 나만의 world 만들기

나의 world concept: 학교!


.
.
<.world 파일>


    

        
        
            model://sun
        

        
        
            model://ground_plane
        

        
            model://school
            true
            -20 -10 0.3 0 0 3.14 
        
        
            model://playground
            true
            10 10 0.3 0 0 3.14 
        


        
        
            
                
                    true
                    model://pine_tree
                
            
            0 19 0.3 0 0 0
            
                40 40 0.01
            
            20
            
                linear-x
            
        

        
        
            
                
                    true
                    model://pine_tree
                
            
            10 5 0.3 0 0 0
            
                10 20 0.01
            
            10
            
                linear-x
            
        

        
        
            
                
                    true
                    model://pine_tree
                    0 0 0 0 0 1.57
                
            
            19 10 0.3 0 0 0
            
                10 10 0.01
            
            10
            
                linear-y
            
        

        
        
            
                
                false
                model://person_walking
                
            
            0 0 0.2 0 0 0
            
                30 30 0.01
            
            5
            
                random
            
        

            
        
            
                
                true
                model://oak_tree
                
            
            0 0 0.2 0 0 0
            
                60 60 0.01
            
            5
            
                random
            
        
    
.
.
step2. Robot spawn
roslaunch robot_description spawn.launch
로봇 배치! - 이건 그전 포스팅 로봇만들기 편 참고
step3. Robot keyboard control

방법은..
rosrun teleop_twist_keyboard teleop_twist_keyboard.py

package가 없다는 에러가 난다면 설치가 안되어서 그럴 수 있으므로
terminal에서 설치를 해주면 된다.
이때 자신의 ros version에 맞게 melodic을 바꿔줘야한다.
melodic이면 아래처럼 적고 noetic이면 ros-noetic-teleop-twist-keyboard 이런식으로

sudo apt-get install ros-melodic-teleop-twist-keyboard
이제 키보드를 눌러 만든 world에서 자유롭게 이동하는 로봇을 구경하면 된다!
.
.



[Simulation] World & 모델 만들기
Thu, 22 Jun 2023 09:29:30 GMT
World 만들기
패키지 생성
cd ~/sim_ws/src
catkin_create_pkg studying_gazebo rospy urdf
cd ~/sim_ws
catkin build
gazebo (안되면 roslaunch robot_description empty_world.launch)
GUI 상에서 insert하는 방법

UI 상에서 Map을 만드는 것이 가장 쉽다.
Insert 탭에서 다양한 것들을 추가할 수 있다.
save를 통해 world를 저장할 수 있다.

.world 파일에 직접 추가하는 방법
.world 파일에 직접 추가하는 방법도 있다.
code /usr/share/gazebo-9/worlds/empty.world
gazebo 버전이 달라 위처럼 쳐서 안될 수도 있다.
그럴때는 empty_world.launch 파일을 켜서 insert 탭에 들어가면 경로를 확인해볼 수 있다.
(* insert 탭에 경로는 사전 설정되어있음)

.
.
 파일에 직접 추가하기


  
    
    
      model://sun
    
    
    
      model://ground_plane
    

    
    
        -6.0 -1.0 0 0 -0 0 
        model://ambulance
    

    
        -5.5 -5.5 0 0 -0 0 
        model://construction_barrel
    
  


아래서 한 git clone을 안했다면 모델이 없어서 실행이 안될 수 있음.

.
.
.

Gazebo 빨리 끄는 법 😊

cd
gedit ~/.bashrc
(.bashrc 파일이 열리면 맨 아래 alias를 추가해주자)
alias killgzb='killall -9 gazebo & killall -9 gzserver & killall -9 gzclient'
이후 부터는 terminal에 killgzb만 치면 빠르게 gazebo를 종료할 수 있다.


/
Gazebo Models
Gazebo Models Database
모델 데이터베이스 Github : github.com/osrf/gazebo_models
cd 
cd ./download
git clone http://github.com/osrf/gazebo_models
다운로드 폴더에 위 git를 clone한 후 /.gazebo/models 폴더에 model 파일들을 옮겨준다.
(+ 를 누르면 히든 폴더들을 볼 수 있다.)
(+ models 폴더가 없다면 당황하지 말고 그냥 만들면 된다. mkdir models)
.
.
Models directory 구조

model.config (this file includes name, version, description, dependency ...)

model.sdf (this file includes structure, physical informations ...)

pose ( X Y Z R P Y) : world에 배치될 때 위치
static (true or false) : true면 외부의 힘에 의해 움직이지 않음
link
inertial : 질량과 관성 행렬 정의 -> 이를 이용해 object의 물리적반응 계산
collision : 물리엔진이 외부와의 충돌을 계산할 때 고려하는 치수


visual : 시뮬레이션에서 볼 수 있는 모양을 정의(대체로 collision과 동일)





.
.
.
.
빈 world 만들기
mkdir ~/sim_ws/src/studying_gazebo/launch/
mkdir ~/sim_ws/src/studying_gazebo/worlds/
touch ~/sim_ws/src/studying_gazebo/launch/empty_world.launch
code ~/sim_ws/src/studying_gazebo/launch/empty_world.launch
 파일

    
        
        
        
        
        
    

.
.
.
나만의 모델 만들기


간단한 tutorial이므로 material이나 texture는 사용하지 않겠습니당
박스 모델을 만들어 봅시다🔰

cd ~/sim_ws/src/studying_gazebo
mkdir -p models/box_model
cd models/box_model
touch model.config
touch model.sdf




    Box Model
    1.0
    model.sdf

    
        yujin
        aaa@gmail.com
    

    
        A simple box model
    



    
        0 0 0.5 0 0 0
        false
        
            
                1.0
                
                    0.083
                    0.0
                    0.0
                    0.083
                    0.0
                    0.083
                
            
            
                
                    
                        1 1 1
                    
                
            
            
                
                    
                        1 1 1
                    
                
            
        
    

위와 같이 모델을 만들었다면 Gazebo에서 불러올 수 있도록 경로 설정을 해줘야 한다.
Gazebo insert 탭에 들어가서 add path에 우리가 만든 폴더를 추가해주면 된다.

roslaunch robot_description empty_world.launch

Mission(1)
위에서 만든 box model을 수정하여
visual은 설정되어 있지만 collision은 막혀있는 모델 만들기
2개의 visual 태그 사용
collision을 설정하지 않으면 물리엔진상의 계산을 받지 않게 된다.
정확히 뭐가 달라지는 건지 직접 해보자!
model.sdf파일에 collision을 설정하지 않은 원통을 하나 만들어 박스위에 둬보자보자



    
        0 0 0.5 0 0 0
        false
        
            
                1.0
                
                    0.083
                    0.0
                    0.0
                    0.083
                    0.0
                    0.083
                
            
            
                
                    
                        1 1 1
                    
                
            
            
                
                    
                        1 1 1
                    
                
            
            
                0 0 1 0 0 0
                
                    
                
            
        
    
Gazebo UI 상에서 view >> collision을 선택하면 collision 영역이 주황색으로 나타난다.
cylinder는 collision을 설정하지 않았으므로 주황색 영역이 없다.

visual2 인 cylinder는 collision을 설정해주지 않았다. 
따라서 보이는 영상처럼
충돌의 상황에서 계산에 사용될 요소를 설정해주지 않은 것이므로 cylinder는 관통하고 box에서는 collision이 일어나는 것을 확인할 수 있다.


.
.
.
Digital Elevation Models
지표면을 그래픽으로 표현한 모델 - 카메라나 라이다 정보로 생성할 수 있음
DEM world 만들기
touch ~/sim_ws/src/studying_gazebo/worlds/dem.world
cd ~/sim_ws/src/studying_gazebo/worlds
wget http://github.com/osrf/gazebo_tutorials/raw/master/dem/files/mtsthelens_before.zip
unzip mtsthelens_before.zip
rm mtsthelens_before.zip



    
        
        
            model://sun
        

        
        true
        
            
            
                
                /home/yujin/sim_ws/src/studying_gazebo/worlds/30.1.1.1282760.dem
                75 75 25
                0 0 0
                
            
            

            
            
                
                
                    file://media/materials/textures/dirt_diffusespecular.png
                    file://media/materials/textures/flat_normal.png
                    1
                
                
                    file://media/materials/textures/grass_diffusespecular.png
                    file://media/materials/textures/flat_normal.png
                    1
                
                
                    file://media/materials/textures/fungus_diffusespecular.png
                    file://media/materials/textures/flat_normal.png
                    1
                
                
                    2
                    5
                
                
                    4
                    5
                
                /home/shin/sim_ws/src/studying_gazebo/worlds/30.1.1.1282760.dem
                75 75 25
                0 0 0
                
            
            

        
        

    


    
        
        
        
        
        
        
    
.
.
.
Model population
-> object를 무작위로 / 지정된 패턴으로 배치할 수 있다. (하나씩 배치할 필요 없음)
.
Population 기본 구문
 - population 이름 설정
    
         - 다른 리소스나 파일 include
        
    
     - 시뮬레이션에서 object 초기 위치 
     - object가 배치될 영역 설정 (box or cylinder)
     - object를 몇개 둘지
     - 배치방법 결정
    distribution : random, uniform, grid, linear-x, linear-y, linear-z
        
    
.
world를 만들어주자
touch ~/sim_ws/src/studying_gazebo/worlds/population.world
touch ~/sim_ws/src/studying_gazebo/launch/population.launch



    

        
        
        model://sun
        

        
        
        model://ground_plane
        

        
        
            
                
                false
                model://jersey_barrier
                
            
            0 0 0.3 0 0 0
            
                12 12 0.01
            
            3
            
                linear-x
            
        

        
        
            
                
                false
                model://bookshelf
                
            
            0 8 0.3 0 0 0
            
                6 6 0.01
            
            4
            
                linear-y
            
        

    
.

population 태그를 보면 bookshelf에서 model_count가 4, distribution이 linear-y이다.
선형 y축으로 bookshelf가 4개 생성된다는 뜻이다.
.
distribution : random, uniform, grid, linear-x, linear-y, linear-z
.
.



    
        
        
        
        
        
        
    
.
.

launch 파일을 실행하면 아래와 같이
y축으로 정렬된 bookshelf와 x축으로 정렬된 barrier가 나온다.


.
.
.
Mission(3)

40m X 40m의 벽으로 둘러싸기
벽돌안에 constriction_barrel 모델을 무작위로 배치
construction_barrel의 배치는 30mx30m 공간으로 제한




    

        
        
            model://sun
        

        
        
            model://ground_plane
        

        
        
            
                
                    true
                    model://jersey_barrier
                
            
            0 19 0.3 0 0 0
            
                40 40 0.01
            
            10
            
                linear-x
            
        

        
        
            
                
                    true
                    model://jersey_barrier
                
            
            0 -21.5 0.3 0 0 0
            
                40 40 0.01
            
            10
            
                linear-x
            
        

        
        
            
                
                    true
                    model://jersey_barrier
                    0 0 0 0 0 1.57
                
            
            19 0 0.3 0 0 0
            
                40 40 0.01
            
            10
            
                linear-y
            
        

        
        
            
                
                    true
                    model://jersey_barrier
                    0 0 0 0 0 1.57
                
            
            -21.5 0 0.3 0 0 0
            
                40 40 0.01
            
            10
            
                linear-y
            
        


        
        
            
                
                false
                model://construction_barrel
                
            
            0 0 0.2 0 0 0
            
                30 30 0.01
            
            100
            
                random
            
        

    

미션 결과이다!