2007 sienna engine oil change

http://www.ehow.com/how_8405861_change-toyota-sienna-engine-oil.html
http://www.fixrambler.com/art133.html

Instructions

1. • 1
     Open the Sienna's hood and open the oil filler cap on top of the engine.
   • 2
     Raise the front of the Sienna with a floor jack. Slide jack stands under the vehicle's subframe and lower the Toyota onto the jack stands. Remove the floor jack.
   • 
     
   • 3
     Crawl under the Sienna and locate the oil pan, which is the metal pan on the bottom of the engine. Set a drain pan under the drain plug in the oil pan. Loosen the drain plug, using the closed end of a combination wrench, and remove the drain plug by hand.
   • 4
     Remove the oil drain plug gasket and clean the drain plug, using a clean, lint-free cloth. Install a new gasket on the drain plug. Hand-tighten the drain plug into the oil pan once only slow drips of oil come from the pan. Tighten the drain plug to 30 foot-pounds, using a torque wrench and a six-point socket.
   • 5
     Locate the oil filter cap, which is the circular, metal cap on the passenger-side front of the engine. Set the drain pan under the oil filter cap and loosen it with a 64 mm oil filter cup and a ratchet. Allow the oil to drain from the oil filter housing, then remove the oil filter cap and oil filter.
   • 6
     Place the blade of a flat-head screwdriver under the rubber O-ring on the oil filter cap, and pry the O-ring from its groove in the cap. Remove the O-ring from the oil filter cap.
   • 7
     Install a new O-ring on the oil filter cap and roll it up the cap until it seats in the groove on the cap. Set a new oil filter in the oil filter cap.
   • 8
     Place a small amount of new engine oil on your finger and coat the O-ring on the oil filter cap with oil. Hand-tighten the oil filter cap onto the engine. Apply 18 foot-pounds of torque to the oil filter cap, using a 64 mm oil filter cup and a torque wrench.
   • 9
     Raise the Sienna off of the jack stands, using a floor jack, and remove the jack stands. Lower the van to the ground.
   • 10
     Insert a funnel into the oil filler hole and pour in 6.4 qts. of 5W-30 engine oil.
   • 11
     Allow the oil to settle for approximately 1 minute and remove the oil dipstick. Wipe the dipstick clean, using a clean, lint-free cloth and reinsert the dipstick. Remove the dipstick and check that the oil level is between the two dots on the bottom of the dipstick. Add engine oil as needed. Close the oil filler cap.
   • 12
     Start the engine and allow it to run for 2 to 3 minutes. Check and adjust the oil level according to the procedure in step 11. Close the Sienna's hood.
   • 13
     Insert a funnel in an empty oil bottle and fill this bottle with old oil from the drain pan. Close the bottle's cap when the bottle is full. Repeat this step until all of the oil is out of the drain pan.
   • 14
     Take the bottles of old oil and the filter to a local automotive oil recycling center. Many auto parts stores recycle old oil free of charge.

Read more: How to Change the 2007 Toyota Sienna Engine Oil | eHow.com http://www.ehow.com/how_8405861_change-toyota-sienna-engine-oil.html#ixzz20vpBOtW2

The 2007 Toyota Sienna uses a canister style oil filter. It is possible to get at the canister without lifting the front, although for extra room and maneuverability I jack up the front with a floor jack so the wheels are just barely off of the ground and I put two jack stands under the front for support. Here is where the canister is located: 

 

Remove the drain plug with a 14mm wrench. The plug washer is number 90430-12028. 

 

There is a smaller insert that you can remove. In my case, since I tighten the whole assembly from the insert, the whole filter comes off when I remove the insert. The best way is probably to just use a 65 mm cap wrench to remove the canister. There is a plastic fitting you can use to drain the oil from the canister via the whole beneath the insert. I find it works just as well to put a drain pan beneath the canister, take it off, and dump out the oil. 

 

Here is the inside of the canister: 

 

An oil change shop munged up the canister. Plus, they didn't replace the o-rings and oil leaked, which is why I'm back to changing my own oil again. 

 




My technique of tightening the filter made the insert difficult to get out. I had to put the canister in a vice. I didn't tighten the vice down, I just set it so it would catch the fins and used a 1/2 inch ratchet and 3/8 inch adapter to remove the insert: 

 

Here you can see the insert removed, as well as the small o-ring. The hole in the center is where you stick the plastic drain spout: 

 

The filter I'm using is a 04152-YZZA1; however, this filter has been superseded by part number 04152-YZZA5. Both the filters and the plug washer are available from your Toyota dealer, or online at Toyota Parts Center. Here is the filter label: 

 

Here is the new o-ring installed on the outside of the inner canister: 

 

It is kind of nice to only have to discard the paper element and install a fresh new one that is visible: 

 

sienna 2007 engine air filter change

The engine air filter in your 2006 Toyota Sienna cleans the air that enters your engine. You should change the filter on your Sienna at least once a year or every 20,000 miles, whichever comes first. If you drive in dusty or sandy conditions, you should change your filter more frequently. A dirty air filter will cause your Sienna to lose 1 - 3 mpg, depending on your driving, you can save 70 - 100 gallons of gas per year simply by changing your filter regularly. The video above, shows you where the engine air filter is located in your Sienna and how to change it!

In addition to improving the fuel economy of your Sienna, regularly replacing your air filter will put less strain on your engine. These filters are fairly inexpensive, so check out our parts page for great deals and coupons on a new one (tip: buy several, when you go to check the filter on your Sienna, you can easily swap it for a new one if it is dirty).


http://www.carcarekiosk.com/video/2006_Toyota_Sienna_LE_3.3L_V6/air_filter_engine/replace

1. Getting Started
2. Open the Hood
3. Remove the Filter
4. Replace the Filter
5. Additional Thoughts

도니의 인라인 기술해부-1에서 4까지

http://cafe.daum.net/kjdhwtl

서론 인라인 기술에 관련된 칼럼을 쓰는 것은 만 3년만입니다. 3년전에 파스칼의 더블푸쉬를 분석했던 것 이 후로 기술적인 부분에 대해서 칼럼은 잘 쓰지 않았습니다. 그것은 인라인을 알면 알수록 제 지식이 미천함을 깨닫게 되었기 때문일 것입니다. 그동안 기술에 대한 이해를 높이려 많은 시간을 노력했고 또 제가 이해한 내용을 보다 쉽고 정확하게 전달하고자 틈틈이 자료를 준비해왔습니다. 기본적인 원리에서 고급 기술까지 원포인트 형식으로 정리해보고자 합니다. 부족한 점이 있다면 여러분들과 함께 연구하고 보완하는 칼럼이 되고자 합니다. 1. 효율적인 푸쉬(1) - fall 아마추어 인라인 레이서들의 주 관심사는 어떻게 더 적은 체력으로 더 먼거리를(또는 더 빠르게) 갈 것인가 하는 효율에 대한 것이다. 이것은 마라톤과 로드런 위주로 발전한 인라인 문화의 영향일 것이다. 효율적인 푸쉬를 위해서는 중력을 최대한 이용해야하며 중력을 추진력으로 변환하는 동작이 '체중 떨어뜨리기'(fall)이다. (최근 한홍희님이 언급한 '넘어지기', 이왕중님이 오래전부터 설명하는 '쓰러지기'가 다 이 fall동작이다. 땅에 넘어지는 동작과 구분하기 위해 fall이란 용어를 그대로 사용하고자한다. 영어알레르기가 있는 분들의 양해를 바람.) 체중이 중력에 의해서 땅에 떨어지려는 힘이 fall동작에 의해서 횡방향의 힘을 만들어 낸다. 먼저 그림으로 중력이 어떻게 추진력으로 변환되는지 알아보자. 그림1.1. 푸쉬 = 중력에 의한 추진(fall) + 근력에 의한 추진(밀기)  [사진: 허유빈 데몬] 푸쉬동작은 중력에 의한 추진(fall)와 다리 근력에 의한 추진(밀기)로 이루어진다. 초급자일수록 다리 근력에 의지하여 추진력을 발생시키며, 상급자는 상황에 따라 두 가지 추진력의 비율을 자유롭게 조절할 수 있다. (초급자가 다리 근력에만 의지하는 이유가 체중이 추진력을 만들어내는 원리와 그 느낌을 이해하지 못하기 때문이고 그것을 쉽게 설명하려는 것이 본 글의 목적이다.) 본 글은 효율적인 푸쉬에 대한 내용이므로 근력을 최소한 사용하고 체중을 최대한 활용하는 쪽에 초점을 맞추고자 한다. fall 동작을 풀어 말하면 무게중심(COM:center of mass)을 축발(BOS:base of support)으로부터 횡방향으로 멀어지게 하여 중력에 의해 떨어뜨리는 것이다. 무게중심이 축발을 벗어날 수록 불안정해지고 넘어지기 직전에 위치에너지가 최대 운동에너지를 만들어낸다. 즉, 무게중심(골반)이 충분히 움직여야 큰 추진력을 얻을 수 있고, 이 것이 안될 때 '체중이동이 안된다'라고 말한다. 다음은 fall동작이 전혀없는 전형적인 초급자의 동작과 fall동작이 잘 보이도록 과장한 동작이다. 빨강, 파랑, 녹색 세개의 원은 양발과 무게중심의 위치를 의미한다.   그림1.2. (좌)fall이 전혀 안되는 푸쉬 (우) fall 동작 그림1.3. 두 발과 무게중심의 표시 방법  [사진: 정소영 데몬] 두가지 동작의 차이점은 축발을 먼저 내려놓고 푸쉬를 하는가 아니면 최대한 축발을 늦게 내려놓는 가이다. 축발을 땅에 늦게 내려놓을 수록 낙차가 커지고 큰 추진력을 얻게 된다. fall동작이 무엇인지 이해가 되었다면 다음 동영상을 통해 실제 주행에서의 fall을 이해할 수 있을 것이다. 다은은 에디 매츠거의 주행 영상에 fall 동작을 표시한 것이다. 그림1.4. 살로몬, 데스티네이션 스피드 中 '데스티네이션 스피드'에서 에디는 '이 자세는 장거리에 적합하고 특히 혼자 달리거나 선두에서 달릴때 최소한의 체력으로 스피드를 유지할 수 있다. 셋 다운을 늦게하고 체중이 떨어지는 힘을 푸쉬하는 발에 집중시켜야한다.'라고 설명한다. 다소 과장된 에디의 주행자세에서 fall동작을 쉽게 발견할 수 있다. 본 글에서는 적은 체력 소비하고 효율적으로 주행을 할 수 있는 fall 동작에 대해서 알아보았다. 이는 특히 레이싱 초급자들이 간과하는 부분이다. 다음에는 효율적인 푸쉬 두번째 팁으로 푸쉬 방향에 대해서 설명할 것이다. 효율적인 푸쉬(2) – 푸쉬의 방향 두 번째 주제로 푸쉬 방향을 선택한 이유는 푸쉬 방향이 오랜 동안 논란의 대상이 되었고 그 과정에서 고정관념이 형성되어 바람직하지 않은 영향도 미치고 있다고 생각하기 때문이다. 효율적인 푸쉬 방향은 분명 존재 할 것이다. 그러나, 이 방향(각도)는 단순히 다리의 움직임에 의한 것이 아니라 여러 동작들이 서로 영향을 미쳐 만들어낸 결과이며 속도에 따라 달라지며 스케이팅 스타일이나 신체조건에 따라서도 달라지게 된다. 따라서, 그 원리와 과정을 생략하고 단순히 푸쉬의 방향만을 따지는 것은 바람직하지 않다. 상급자들의 경우 푸쉬의 방향에 자체에 대해서 큰 의미를 두지 않는다. 충분한 가속을 얻을 수 있는지 여부가 중요한 것이며, 어떤 순간에 어느 방향으로 밀어야 하는지는 경험과 감각으로 판단하게 된다. 본 글에서는 그 동안 3시/9시 또는 45도라고 양분하여 생각하였던 고정관념이 비롯된 원인을 밝히고 이를 벗어나 새로운 시각에서 바라볼 수 있는 계기가 되고자 한다. 푸쉬 방향에 대한 고정관념 전통적인 푸쉬의 방향은 45도 뒤쪽으로 미는 것이다. 그러나, 이런 개념을 뒤바꿔놓은 것은 살로몬의 ‘데스티네이션 스피드’ 비디오이다. 뿐만 아니라 [Liz Miller의 칼럼]을 보면 횡방향 푸쉬를 위해 심지어 2시/10시 방향으로 밀라고 설명한다. 그런데, 필라 월드팀의 클리닉은 지난 몇 년간 45도 뒤쪽으로 미는 ‘전통적인 방식’을 가르치고 있다. 게다가 최근 필라팀의 성적이 최고이기 때문에 더 혼란스럽기만 하다.   그림2.1. 파워 박스, 그림2.2. 필라팀 클리닉(45도 방향 푸쉬) (※그림2.2는 알팩닷컴의 [필라팀 클리닉 후기]에서 발췌했음을 밝힙니다) 또, 일부는 '푸쉬를 하는 동안 전진하기 때문에 45도 방향 처럼 보이지만 선수입장에서는 3시/9시를 만들려고 해야한다'라고 설명하기도 한다. 과연 어떤 것이 바람직한 것인지 함께 해답을 찾아보도록 하자. 푸쉬 방향과 추진력의 상관관계 어렵지 않은 물리적인 해석을 통해 푸쉬 방향에 따른 추진력에 대하여 살펴 보도록 하자. 먼저 푸쉬의 방향을 정의해보자. 일반적으로 말하는 푸쉬의 방향은 시계방향과 각도 두 가지를 이용 한다. 이 중에서 각도로 나타낼 때 푸쉬의 방향은 진행방향의 수직방향을 기준으로 표현한다(대각선 뒤쪽으로 미는 경우가 45도). 또한 프레임의 방향은 진행방향을 기준으로 말하는 게 일반적이다. 이러한 관례를 바탕으로 푸쉬의 방향에 영향을 주는 요소인 다리의 각도와 프레임의 각도를 정의하였다(그림2.3). 그림2.3. 다리의 각도와 프레임의 각도 해석을 쉽게 하기 위해 스케이트의 성질에 대하여 살펴보자. 스케이트는 프레임방향에 수직방향으로 작용하는 힘의 성분만이 추진력에 영향을 준다. 그림2.4는 서로 다른 크기의 힘이 작용하지만 같은 크기의 힘만 전달되는 것을 설명하고있다. 따라서, 힘의 손실을 최소로 하기 위해서는 프레임의 수직방향에 가깝게 힘을 가해야 한다. 그림2.4. 스케이트의 성질 따라서, 그림2.3에서 정의한 다리의 각도와 프레임의 각도는 비슷할수록 힘 전달 측면에서 유리하다. 이러한 특성을 바탕으로 계산의 편리를 위해 프레임과 다리의 각도가 같다고 가정하고자 한다(실제 주행에서도 큰 차이를 발생하지 않는다). 또한, 푸쉬의 방향을 다리의 각도로 표현하려 한다. 푸쉬에 의한 추진력은 뒤쪽으로 밀수록 커지며 측면으로 밀수록 작아진다. 그렇다면 소위 백 푸쉬가 바람직한 것일까? 이것은 정지상태에서 푸쉬를 하는 경우이며 속도가 빨라질수록 뒤쪽으로 미는 힘은 상쇄되고 옆으로 미는 힘만이 추진력으로 작용한다. 예를 들어 시속 30km/h로 달리면서 뒤로 푸쉬하려하면 헛발질을 하게 되는 이유는 다리를 뒤로 움직이는 속도보다 몸을 기준으로 지면이 움직이고 있는 속도가 더 빠르기 때문이다. 따라서, 속도가 빨라질수록 옆쪽으로 미는 것이(다리의 각도가 작은 것이) 효율적이 된다. 설명의 편의를 위해 뒤로 미는 힘이 완전히 상쇄 되는 속도를 ‘임계속도’라고 부르도록 하겠다. (뒤로미는 힘이 완전히 상쇄된 후에도 옆으로 미는 힘에의한 가속이 가능하기 때문에 임계속도가 최대속도는 아니다) 그림2.5. 푸쉬방향에 따른 추진력과 속도에 의한 상쇄 다리를 움직일 수 있는 속도는 사람에 따라 다르기 때문에 정확히 시속 몇 킬로가 임계속도인지는 알 수 없다. 따라서,속도에서 최대 추진력을 발생하는 푸쉬의 방향은 그 순간의 주행 속도와 신체조건에 따라 달라진 다는 것이다. 속도의 변화(정지에서 임계속도까지)에 따라 최대 추진력을 발생시키는 푸쉬 방향의 변화는 다음과 같다. 속도가 빨라질 수록 효율적인 푸쉬각도가 작아지는 경향을 확인 할 수 있다. 또 지나치게 옆으로 미는 것 역시 효율적이지 않음을 알 수 있다. 그림2.6. 속도와 푸쉬 방향에 따른 추진력의 변화. 그림2.7. 최대 추진력을 발생시키는 푸쉬의 방향의 변화 위 결과에서는 정지상태에서 임계속도까지에 대해 효율적인 푸쉬 방향에 대하여 보여주고있다. 실제 주행시에는 이 임계속도보다 빠른 속도를 낼 수 있기 때문에 푸쉬각도는 더 작아질 것이다(그림2.7의 점선). 본 글에서는 이와 같이 속도에 따라 푸쉬의 각도가 작아지는 경향을 확인하는 데까지만 물리학적인 접근방법을 사용하고자 한다. 실제 주행의 푸쉬방향: 푸쉬 방향에 영향을 주는 또 다른 요인 서론에서 설명했듯이 푸쉬의 방향은 단순한 다리의 움직임이 아니라 여러 동작이 영향을 미쳐 만들어낸 결과이기 때문에 물리적으로 해석하는데는 한계를 갖고 있다. 실제 주행에서 푸쉬에 영향을 주는 다른 요인들을 살펴보자. 먼저 푸쉬를 시작해서 끝날 때까지 푸쉬의 방향은 변한다. 그림2.8은 지난 회에서 fall에 대해 멋진 시연을 해준 에디의 푸쉬 방향이다(동영상에서 추출한 결과). 0도에서 시작하여 25도까지 커졌다가 20도로 다시 줄어드는 것을 볼 수 있다. 마지막에 푸쉬각도가 다시 작아지는 것은 보다 긴 시간동안 푸쉬를 하기 위한 동작으로 ‘카빙(carving)’이라고 부르기도 한다. 그림2.8. 에디의 푸쉬 방향 다음으로 푸쉬가 끝나는 시점에서 반대쪽발을 내려놓는 셋다운 동작에 의한 영향도 생각할 수 있다. 상급자일수록 그리고 가속동작 일수록 셋다운 동작에 탄력을 주기 때문에 마지막 푸쉬각도가 커질 수 있다. 아래 파스칼의 셋다운 동작과 그 순간의 푸쉬에 대해 주의깊게 관찰해보기 바란다.(더블푸쉬 동작임을 고려하기 바람) 그림2.9. 파스칼의 주행 (살로몬, 데스티네이션 스피드 中) 파워 박스는 잘못된 이론인가? 실제 주행에서의 푸쉬 방향은 우리가 알고 있었던 파워박스이론과는 많이 다른 것을 알 수 있었다. 그렇다면 파워박스는 잘못된 이론인가? 이를 논하기 전에 먼저 파워박스가 무엇인지 확인해보자. 먼저 ‘데스티네이션 스피드’동영상에서 정의하는 파워박스의 의미는 다음과 같다. “The Power Box is a zone around the body in which the skates can affect the push with maximum power” 번역하면 “파워박스는 스케이트가 최대의 힘으로 푸쉬에 영향을 미치는 몸 주위의 영역”을 말하는 것이다. 또한 “과학적 실험결과 푸쉬 힘이 가장 큰 순간은 파워박스 가운데 부근에 위치하며 휠 전체로 땅을 잡고 있는 순간”이라고 설명한다. 그림2.10의 검은색 명암이 푸쉬 힘을 나타내며 그중 가장 어두운 부분이 최대가 되는 순간이다. 그림2.10. 파워 박스(흰색)와 푸쉬 힘(검은색 명암) (살로몬, 데스티네이션 스피드 中) 즉, 파워박스는 푸쉬의 방향을 설명하기 위한 것이 아니라 푸쉬의 힘이 최대가 되는 순간을 설명하기 위한 것이며 이 순간은 모든 휠에 최대의 힘이 가해지는 순간이다. 그리고, 이러한 원리를 바탕으로 제안하는 연습방법이 ‘옆으로 밀기(lateral push)’동작이다. 다시말해 모든 휠로 푸쉬하는 연습을 하는 것이다. 결론적으로 파워박스 이론은 잘못된 것이 아니라 파워박스를 설명하는 화면과 그에 이어지는 연습방법 때문에 잘못 이해하고 있었던 것이다. 연습용 자세과 실제 자세를 혼동하는 일은 비단 파워 박스의 경우만은 아니다. 월드팀이 강습하는 내용을 이렇게 잘못 받아들이는 예가 많이 있다. 또 한가지 예가 리커버리에 관한 것인데 이것은 다음 편에서 설명하려 한다. 맺음말 지금까지 효율적인 푸쉬에 대하여 알아보았다. 정리해보면 효율적인 푸쉬방향이란 정해져있는 각도가 아니라  휠 전체를 이용해서 푸쉬하기 위한 방향이다. 반대로 말하면 휠 전체를 이용해서 푸쉬할 때 자연스럽게 나타나는 각도이기도 하다. 따라서, 속도에 관계없이 휠 전체를 이용해서 푸쉬할 수 있는 능력이 중요하며, 이를 위한 훈련방볍이 옆으로 밀기(lateral push)인 것이다. 스스로 제대로 푸쉬를 하고 있는지를 알고 싶다면 푸쉬동작에서 '무릎이 완전히 펴진 순간에 휠 5개가 모두 지면에 닿아있는지'를 확인해 보기 바란다. 또, 아래 파스칼의 푸쉬동작을 이러한 관점에서 살펴보기 바란다. 그림2.11. 파스칼의 푸쉬 동작 (살로몬, 데스티네이션 스피드 中) 지난 시간에 설명한 fall동작이 다소 혼동의 여지가 있었던 같다. ‘무게중심을 떨어뜨리는 동작이 중요하다’고 설명한 것이 ‘상체움직임이 큰 것이 좋다’라는 해석이 가능했던 것이다. 많은 초급자들이 fall에 대한 느낌을 이해하지 못하기 때문에 이해를 돕기 위한 설명이며 과도한 상체움직임은 당연히 바람직 하지 못하다. 이번 글에서 설명하고자 했던 내용 역시 추진력을 최대로 발생시키는 느낌을 이해할 수 있도록 도움이 되고자 한 글이다. 각도에 대한 고정관념을 버리자는 의미가 '아무렇게나 되는대로 밀자'라는 의미는 아님을 강조하면서 글을 마무리하려 한다. 리커버리: 상급자가 되기 위한 관문 리커버리는 싱글푸쉬의 구분동작(푸쉬,리커버리,셋다운,글라이드) 중 가장 익히기 어려운 동작이다. 그래서 리커버리동작만 보면 한눈에 그사람의 수준을 알 수 있게된다. '체중(중력)을 이용한 푸쉬'(참고: [기술해부1])가 초급자와 중급자를 구분짓는다고도 볼 수 있으며 리커버리는 중급자가 상급자가 되기위해 넘어야할 높은 산이다. (상급자는 일정수준의 기록과 함께 정확한 기술을 구사할 수 있는 수준을 의미) 기술해부1편에서 살펴보았던 에디의 스케이팅에서부터 시작해보고자한다. 아래 동영상에서 에디는 체중과 중력을 최대한 이용하여 체력소모를 줄일 수 있는 자세를 보여준다. 그러나 이 자세는 장거리주행을 위한 효율측면에서 좋은 본보기이지만 최대속력면에서는 바람직하지 못한자세이다. 이 자세는 중상급의 동호인들의 모습과 유사하며 스피드를 지향하는 엘리트선수,월드팀선수들의 자세와는 차이를 갖고있다. 그렇기때문에 에디의 자세에서 설명을 시작하고자한다. (아래 동영상은 에디가 시범을 보이는 동작이며 실제 주행시 에디의 자세와 차이가 있습니다) 그림3.1. 에디의 장거리 주행자세 (살로몬, 데스티네이션 스피드 中) 리커버리의 세가지 모델 이해를 돕기위해 리커버리의 형태를 세가지 모델로 구분하고자 한다. 빨강,파랑,녹색의 세점은 각각 양쪽 발과 무게중심(배꼽)을 나타낸다. (참고: [기술해부1: 효율적인 푸쉬(1)]) 편의상 무게중심은 좌우로만 이동한다고 가정하겠다. 그림3.2. 리커버리 모델1 리커버리 모델1은 체중이동이 정확하게 일어나며(푸쉬가 끝나는 시점에서 셋다운된다), 푸쉬가 끝난 발(이하 회수발)이 체중을 지지하는 발(이하 축발)까지 회수되는 동작을 보여준다. 데몬선수들에게서 볼 수 있는 자세이며, 엘리트(월드팀)선수들이 팩을 만들어 달릴때 사용하는 자세이다. 일반적으로 동호인들은 이 모델을 머릿 속에 그리며 연습한다. 그림3.3. 리커버리 모델2 리커버리 모델2는 체중이동이 제대로 이뤄지지않는 경우이다. 회수발을 배꼽 아래까지 가져오지만 그 전에 체중이 이동되기때문에 결과적으로 회수발이 축발까지 오지않고 허우적대는 모습이 된다. 하지만, 본인은 배꼽아래까지 리커버리를 하고 있는 것을 느끼기때문에 자신의 자세가 잘못된 것을 알지 못한다. (나중에 자신의 사진이나 동영상을 보고 상상했던 모습과 크게 달라 좌절한다) 리커버리와 푸쉬의 동작이 정확히 구분되지 않는 것이 가장 큰 문제이다. 그림3.4. 리커버리 모델3 리커버리 모델3는 푸쉬하는 발에 분산된 체중까지 리커버리과정에서 축발에 실어주어 축발에 완전히 체중이 실리고 이 과정에서 발생한 탄력을 추진력에 더하는 것으로 고속주행의 기본이 되는 자세이다. 이 것은 아이스스케이팅에서 볼 수 있는 자세와 흡사하다. 아이스스케이팅은 이 좌우의 움직임(소위 롤링)이 인라인에 비해 더 크고 글라이딩 구간이 더 길다. 반면에 인라인은 상대적으로 짧은 푸쉬를 반복하게 되는데 인라인에 있어서도 이 롤링은 중요한 역할을 한다. 모델2는 반드시 고쳐야하는 자세이며, 모델1과 모델3는 상황에 따라 모두 사용할 수 있어야하는 자세이다. 장거리에서 체력소모를 줄이고자 하거나 팩을 이룰때는 모델1이 적합하고, 최대속도를 내기위해선 모델3가 필요하다. 모델1은 모델3이 축약된 형태로 생각할 수 있으며 정확한 동작을 익히기 위해선 모델3를 연습해야한다. 실제 주행에서의 리커버리 아래 동영상은 앞서 설명한 리커버리 모델3의 실제 모습이다. 이것은 데몬스트레이션을 위한 과장된 동작으로 좌우 움직임이 지나치게 심해보이고 속력도 느려보인다. 또한 실제 주행자세와는 많이 달라보인다. 그림3.5. 싱글푸쉬 시연 (필라 인터네셔널팀) 그러나 이는 실제 주행의 기본이 되는 자세이고 좋은 기록을 위해서는 필수적인 자세이다. 이렇게 중요한 자세를 실제 경기에서 볼 수 없는 이유는 무엇일까? 앞서 설명했 듯이 이 자세는 고속에 적합한 자세이다. 고속(스퍼트)에서는 리커버리의 타이밍을 최대한 땡겨서 같은 시간동안 많은 회수의 푸쉬를 하기 때문에 이러한 동작이 눈에 잘 드러나지 않는다. 즉, 마라톤 대회에서는 주로 모델1의 모습을 보게되고 모델3는 마지막 스퍼트나 중간중간의 브레이크어웨이에서 또 트랙대회중 직선구간에 잠깐 그것도 '빠른동작'으로만 나타나게된다. 이런 이유로 동호인들은 모델3에 대해 인식하지 못하고 또 연습의 필요성을 못느낀다. 실제로 모델1만 연습해도 아마추어대회의 중상위권에 들 수 있다. 다음에 해당하는 분들은 본 칼럼을 통해 모델3을 연습하기 바란다. 1. 부드럽고 안정적이고 우아한 자세로 타고 싶은 분 2. 마지막스퍼트에서 항상 밀린다고 생각하는 분 3. 남들하고 똑같이 푸쉬하는데 속도가 느린 분 리커버리의 원리 리커버리는 앞으로 전진하기위한 자연스러운 동작이다. 리커버리를 어렵게 생각하고 그 동작을 만들어내려고 하면 더 잘안된다. 오히려 회수하는 다리에 긴장을 풀고 정확한 체중이동에 신경쓰면 생각외로 훌륭한 리커버리동작이 나오게된다. 리커버리는 푸쉬한 발을 모아 다시 푸쉬하기 위한 동작인 동시에 근육에 피로를 푸는 '쉬는 동작'이다. 따라서 리커버리하는 동안 근육을 충분히 이완시키는 것이 중요하며 이를 위해서는 발끝이 땅을 향하게 하는 것이 도움이된다. 또한 앞바퀴가 땅에 닿지 않을 정도로만 다리를 들고있는 것이 좋다. 겉에서 보기에 아무리 비디오와 똑같이 다리가 움직인다고하더라도 근육의 피로를 감소시키지못한다면 잘못된 리커버리이다. 즉, 겉으로 드러나는 모습보다는 그 역할에 충실하는 것이 우선이다. D자모양이나 삼각형모양에 연연하지 말고 자신의 다리가 가장 편한 형태를 찾아보자. 초급자들이 착각하는 부분이 다리를 들어서 가져와야한다고 생각하는 것이다. 푸쉬한 발이 지면에서 떨어진뒤 체중을 축발에 고정시키고 푸쉬한 다리에 힘을 빼면 중력에 의해 회수발이 배꼽아래로 떨어지게 된다. 이때 사용되는 근육은 발이 땅에 닿지 않도록 살짝 들어주기 위한 정도 뿐이다. 그림3.6. 파스칼의 리커버리 시연 (사브살로몬팀 클리닉, 촬영: 박순백박사님) 그림3.6에서 파스칼이 보여주고 있는 동작이 바로 가장 자연스러운 형태의 리커버리이다. 체중을 고정한 채 다리에 힘을 빼고 툭 떨어뜨리는 모습을 발견할 수 있다. 어떤형태를 만들기위해 불필요한 근육을 사용하지 않는 것이 그 포인트이다. 그렇다면 우리가 알고 있는 D자 형태의 리커버리는 잘못된 것인가? 아래 파스칼의 주행장면을 보면 위 동영상과는 또 다른 모습을 보여준다. 얼핏보기에 회수발이 D자모양을 그리는 것으로 보인다. 이제 좀 이해했다 싶었는데 다시 머리가 아파오기 시작할 것이다. 그림3.7. 파스칼의 푸쉬 동작 (살로몬, 데스티네이션 스피드 中) 그림3.6은 앞서 설명했듯이 리커버리하는 동안 근육을 충분히 쉬게 하는 것을 강조하는 것이다. 즉, 위 동영상(그림3.7)에서도 리커버리하는 다리의 근육이 충분히 이완되어있다는 것이다. 겉으로 보이는 모습이 다른 이유는 우선 속도의 차이이다. 빠른 속도에서는 자연히 푸쉬가 뒤로 빠지게 된다. 또한 가속을 위해 셋다운시 축발에 체중을 실어 앞으로 치고 나가기 때문이다. (이 부분은 다음 편 '셋다운'에서 자세한 내용을 다루겠다) 고속에서는 리커버리의 타이밍을 땡기는 것이 중요하다고 설명하였다. 이를 위해서는 무릎을 당겨오거나 구부리는 추가적인 테크닉을 필요로 한다. 리커버리에 어느정도의 근력을 투자하고 그로인해 얼마나 더 빠른 속도를 얻는가는 선택의 문제(trade off)이다. 이를 위해 극단적인 두가지 경우를 모두 연습하는 것이 좋다. 리커버리의 연습방법 먼저 정확한 체중이동을 할 수 있도록 연습하는 것이 중요하다. 중심이동에 대한 연습방법은 '이은상 인라인 교실(http://www.inlineedu.com/index.php )'과 '신영식 인라인 클리닉( http://www.sis.ne.kr )'에 훌륭한 동영상 강좌가 많이 있으므로 참고하기 바란다. 리커버리를 연습하기 위해서는 많은 인내력이 필요하다. 평소의 속도대로 달리다 보면 어느새 다리에 힘이 들어가서 정확한 동작을 연습할 수 없기 때문에 느린속도에서 연습해야한다. 또 계속 낮은 자세를 유지해야하기 때문에 힘들고 재미없는 과정이다. 축발에 체중을 싣고 최대한 오래 동안 글라이딩하는 연습과 좌우로 크게 움직이면서 체중이동을 과장해서 하는 훈련을 하면 많은 도움을 얻을 수 있다. 흔히 실수하는 부분이 체중이 실려있는 다리(supporting leg)의 무릎을 너무 일찍 피는 것이다. 리커버리가 끝나기 전에 무릎을 펴버리면 전형적인 모델2의 모습이 된다. 글라이딩하는 동안 무릎을 더 구부리는 것도 체중이동을 돕고 추진력을 높이는 역할을 한다(실제 주행에서도 사용되는 테크닉이다). 또한, 리커버리 모델3를 연습하기 위해서는 중력에 의해 떨어진 회수발이 무게중심(또는 축발)과 따라가는 느낌을 느껴보도록하자. 그림3.8. 살로몬 이동준데몬의 연습장면(동영상을 보시려면 클릭하세요) 위의 살로몬 이동준데몬의 동영상처럼 좌우로 크게 움직이면서 리듬을 갖고 달리면서 머리속에 리커버리 모델3를 그리는 훈련을 반복하다보면 어느새 멋진 리커버리 동작이 몸에 베어있게 될 것이다. 푸쉬와 체중이동의 관계푸쉬와 체중이동은 많은 관련을 갖고 있다. 상급자들은 푸쉬가 곧 체중이동을 의미함을 잘 알고있을 것이다. 하지만, 기존의 이론과 강습은 눈에 보이는 푸쉬위주로 이루어져있는 경우가 많아, 초급자들은 체중이동에 대해 느끼고 실천하기까지 적지않은 시간이 걸린다. 그림4.1은 싱글푸쉬를 설명하기 위해 일반적으로 많이 사용되는 그림이다. 이 것만 보더라도 그동안의 자료들이 푸쉬위주로 설명되어있음을 알 수 있다. 그림4.1. 싱글푸쉬의 궤적 스스로 체중이동에 대해서 이해하고 있다고 생각하는 분들은 위 그림위에 무게중심이 이동하는 곡선을 그려보자. 대부분 고개를 갸우뚱하게 될 것이다. 그동안 우리는 발의 움직임에만 신경을 쓰면서 스케이팅을 했기 때문에 실제로 무게중심이 어떻게 이동되는지는 잘 모르고 있다. 또한, 위 그림에는 스케이트가 땅에 닿아있는 동안의 움직임만 나타나있기 때문에 리커버리하는 발이 어떻게 이동되는지도 알 수 없다. 체중이동과 리커버리 동작이 이해하기 어려운 이유는 그 실체를 정확히 보여주는 자료가 없기 때문은 아닐까? 위 그림은 이론상의 그림이며 실제 주행시 스케이트가 지면에 남기는 궤적과는 차이가 있다. 본 글에서는 실제 스케이팅의 궤적으로 부터 체중이동과 리커버리의 형태에 대해 알아보고자 한다. 실제 스케이팅의 궤적 그림4.3는 에디 매츠거(Eddy Matzger)의 동영상(그림4.2)로부터 추출한 스케이팅 궤적이다. 일반적으로 중,상급의 동호인들이 장거리를 달릴 때 볼 수 있는 자세이다. 그림4.3(좌)는 무게중심을 기준으로 양쪽 발의 상대적인 움직임을 나타낸 것이다. 앞서 살펴본 그림4.1 역시 상대적인 푸쉬 궤적을 나타내고 있는 것이다. 실제 도로상에 스케이트가 남기는 흔적은 그림4.3(우)에 해당한다. 녹색선으로 무게중심(배꼽위치 기준)의 이동을 함께 나타내었다. 그림4.2. 에디의 장거리 주행자세 (살로몬, 데스티네이션 스피드 中) 그림4.3. 에디의 스케이팅 궤적 그림4.1을 머리 속에 담고 연습하는 경우 문제점은 자로 잰 듯 똑바로 가야 맞는 자세라고 생각한다는 것이다. 그림4.3(우)의 경우 무게중심이 S형태로 좌우로 움직이는 것을 보여주고 있는데, 이와 같이 무게중심이 어느정도 좌우로 이동되는 것이 중요하다. 무게중심의 좌우이동이 전혀 없다는 것은 ‘체중을 이용한 추진’(fall)이 거의 일어나지 않는 다는 것이며, 좌우이동이 심한 것은 감속 동작이 된다. 체중이동의 형태를 살펴보면 양쪽 발이 셋다운 되는 시점을 부근에서 방향전황이 일어남을 알 수 있다. 또 글라이딩 궤적과 체중이동 과적이 거의 일치함을 알 수 있다. 다음으로 리커버리 동작을 살펴보면 푸쉬가 끝난 시점부터 자연스럽게 축발, 무게중심의 움직임을 따라 이동하여 무게중심 아래까지 이동하게 된다. 그림4.4. 전통적인 싱글푸쉬 그림4.5. 전통적인 싱글푸쉬의궤적 그림4.4는 엘리트 여자선수들에게서 쉽게 발견할 수 있는 전통적인 싱글푸쉬의 자세이다(실제 주행자세라기보다 저속의 시연용 자세임을 감안하기 바람) 또 그림4.5는 이 동영상에서 추출한 스케이팅 궤적이다. 무게중심을 기준으로 한 상대적인 발의 움직임(그림4.5(좌))는 크게 다르지 않지만, 실제 주행궤적(그림4.5(우))은 언뜻 보기에도 그림4.1과 크게 다른 것을 알 수 있다. 무게중심이 좌우로 이동되는 간격에 비해 그동안 전진하는 거리가 훨씬 길기 때문에(초당1회 푸쉬로 시속30km를 달릴 경우, 한번 푸쉬했을 때 주행하는 거리가 8m) 앞으로만 전진하는 것으로 보일 수도 있지만 이러한 무게중심 이동은 추진력에 중요한 역할을 한다. 적극적인 체중이동 이와 같이 체중이동이 실제주행에서 어떻게 이루어지는지를 정확히 이해하는 것은 연습에 큰 도움이 될 것이라 생각한다. 그림4.1의 형태를 억지로 만들어내는 스케이팅이 아니라 적극적으로 체중이동을 하고 이를 통해 발생하는 스케이팅의 리듬을 느끼며 달리는 것이 중요하다. 그림4.3(좌)와 그림4.5(좌)의 가장 큰 차이점은 리커버리의 형태이다. 그림4.5은 회수한 발이 셋다운하기 전에 중심선을 더 많이 넘어가는 것을 볼 수 있다. 이 것은 그림4.6와 같이 회수한 발 보다 무게중심을 더 빨리 떨어뜨리기(fall) 위한 동작이다. 에디 매츠거에 의해(&: 앰퍼센드)라고 알려진 이 자세는 체중이 가진 위치에너지를 더 큰 추진력으로 만들어낼 수 있게 한다. (이 자세를 앰퍼센드라고 부르는 이유는 &기호의 모양과 그림4.6을 비교해보면 알 수 있을 것이다) 그림4.6. 적극적인 중심이동 (앰퍼센드 자세) 스케이팅의 이론과 실제에 대한 고찰 그렇다면, 그 동안 실제 주행과 차이가 있는 스케이팅 궤적(그림4.1)이 정석으로 알려져 왔을까? 앞서 설명한 것처럼 그림4.1은 무게중심을 기준으로 한 상대적인 발의 움직임을 나타내는 것이다. 제3자의 관점에서 보이는 전체적인 움직임을 이해하는 것도 중요하지만, 스케이트를 신고 달리는 주인공의 관점에서는 상대적인 양쪽발의 움직임이 더 중요하고 관점에 따라 그림4.1이 맞다고 볼 수도 있다. 또한, 그림4.1이 푸쉬와 글라이드의 궤적만을 나타내고 리커버리를 표시안한 것에서도 중요한 의미를 발견할 수 있다. 리커버리는 앞으로 전진하기위한 자연스러운 동작이다. 리커버리의 형태를 정해두고 그 동작을 만들어내려고 하면 자연스러운 동작이 나오기 어렵다. 리커버리 동작은 오히려 회수하는 다리에 긴장을 풀고 정확한 체중이동에 신경을 쓰면 80%는 완성할 수 있는 동작이다. 하지만, 어떤 형태가 과연 자연스러운 것인지 또 바람직한 것인지는 알 필요가 있기 때문에 본 글에서는 선수들의 동영상을 바탕으로 리커버리의 궤적을 나타내보았다. 이러한 원리들을 이해하고 억지로 정해진 틀에 맞추는 형태를 벗어나 창의적인 스케이팅을 하길 바란다. 출처: KIC

Technique: Increase Your Pushing Power By Liz Miller

http://www.getrolling.com/orbit/10powertips.html

Tired of being left behind on uphills? Ready to adopt a smooth, elegant stroke that is both fast and powerful? If so, here's an opportunity to piece that dream stroke together one component at a time. Practice just one of these tips each time you skate this summer. I recommend you start with the first, which is the easiest. You'll experience impressive improvements from each tip, so just imagine the results when you can incorporate every part into every stroke!
Note: If poor balance prevents you from working on these tips, be sure to read Dan's article, Put a Little Balance in Your Life.

1. Get low -- Bend your support leg close to 90 degrees while your pushing leg is at work. That makes it possible to keep the wheels pushing across a longer distance, which adds power and speed. On the gliding foot, be sure to keep your nose, knee and toes lined up one over the other to maximize the push.
2. No toe-flicking -- For the entire length of each stroke, keep all 4 (or 5) wheels of the pushing skate in contact with the pavement, concentrating the most pressure on the heel wheel. If you lift the back wheels before the end of your stroke, you lose both power and friction.
3. Push to the side, not back -- A side-directed push results in forward momentum (Don't ask me how!) Tip #2 is easy if you do as speedskaters do and imagine you are pushing the right heel toward 2 o'clock and the left heel toward 10 o'clock. Yes, that's more forward than lateral, but the attempt is what results in 3 o'clock and 9 o'clock strokes. To me, it feels like I'm trying to paint a giant handlebar mustache with my heel wheels.
4. Polish your swizzles -- Swizzle practice (making figure eights with both skates in constant pavement contact) is one of the best ways to get used to pushing with the heels and pushing laterally. Be assertive: listen for a slight scrubbing sound from your heel wheels at that moment of greatest force when you steer your toes inward. Then sink to a 90-degree knee bend when both skates are under your hips to regroup for another forceful push. Enjoy the fitness benefits while you're at it!
5. Straighten your knee -- A stroke is incomplete if your knee is still bent when you lift it off the pavement for recovery. This could lose you several inches of contact with the pavement, which means lost power and efficiency.
6. Slow your stroke tempo -- If the previous tips haven't forced you into less strokes per minute, it's time to focus on longer strokes and glides. My favorite game for this is to skate behind somebody and try to match their speed with half the number of strokes. This practice makes a good test for what you've learned so far this summer!
7. Make Air D's -- To conserve energy, keep your wheels close to the pavement as you bring back (recover) your skate at the end of the stroke. While you trace a sideways D with your toe wheel, your knee follows the same path higher up. The knee comes in behind the support leg so close that you brush it as you move the skate ahead for the set-down.
8. Fine tune your set-down -- Put your skate back on the pavement slightly ahead of you, with the wheels parallel to the direction of travel, rather than angled which deflects your speed. Land on the "tops" or center edges, not on the inside wheel edges. Later, once your stroke is powerful enough, try landing that skate beyond your center line of travel and touching down on the outside edges. This is the classic component of the Stride 3 or "power stride" taught by IISA-certified instructors. Try learning it on just one side at first, skating along a long painted line to gauge your set-down placements.
9. Push with your hip -- By fully extending your pushing leg from both the hip and knee joints at the end of each stroke, you access power stored in some of your largest muscle groups. Just try unkinking at the hip when you finish each stroke.
10. Let gravity help -- You can use gravity to aid in stroke efficiency. At the end of each glide, when your body is aligned nose-knee-toes over the support leg, delay set-down of the recovered skate while you let your support leg begin the a new push. As your weight begins its shift toward the recovered skate, you feel a slight "fall" just before before it touches down to catch you. That falling feeling is your body using gravity to add more power to what your muscles give. You want each set down to make a loud "clomp" for this drill. Make sure you're still making lateral pushes throughout.

And here's my bonus Zen tip: On a long fitness or training skate when exhaustion begins to weaken your will and technique, "relax and allow" the discomfort without obsessing, which is sure to make you more miserable and less mobile. Instead, experience each stroke and each inhalation as a new one (be here now) knowing the pain will end in due time.

USA Swimming - The Best Backstroke

site:www.usaswimming.org backstroke picture

http://www.usaswimming.org/ViewNewsArticle.aspx?TabId=1&itemid=4039&mid=8712

BREASTSTROKE!

http://www.usaswimming.org/_Rainbow/Documents/d86ce91f-719f-4eef-bac1-a0d6e416c6c3/Teaching%20Breaststroke.pdf

google search
site:www.usaswimming.org breastroke picture

http://www.usaswimming.org/ViewNewsArticle.aspx?TabId=0&itemid=4246&mid=8712

자세가 무엇보다 중요하다

평영은 1회 긁기와 1회 킥 사이 반드시 차고 뻗기의 자세를 취하는 영법이다. 우선은 기본이 되는 차고 뻗기 자세를 다시 한 번 확실히 상기하자. 또한 양 팔다리는 좌우 대칭으로 움직이기 때문에 타이밍을 잡는 것이 중요하다.
차고 뻗기의 자세로 나아간다

평영의 기본 자세는 자유형과 같은 엎드려 뜨기에서 똑바로 팔다리를 편차고 뻗기이다. 차고 뻗기의 자세에서 시작해서 풀과 킥을 끝낸 순간에도 차고 뻗기의 자세가 되어야 한다. 즉, 1회의 긁기와 1회의 킥을 한 후는 반드시 이 차고 뻗기의 자세가 있게 된다. 여기에서 다시 한 번 차고 뻔기의 자세를 점검해 본다. 양팔을 귀에, 발쪽을 대퇴에 가볍게 붙이는 점을 주의해서 긴장하지 말고 앞으로 나아가면서 적합한 유선형을 만들자.
발바닥으로 많은 물을 잡는다.

평영은 발바닥으로 물을 잡아 킥하여 추진력을 얻게 된다. 이것은 규칙에도 '차기는 후방의 바깥쪽을 향해야 한다'고 정해져 있으므로 기억해 둔다. 킥 때는 항상 발바닥으로 물을 잡고 있지만 이 경우에는 장심(掌心)을 중심으로 해서 물을 끼우는 듯이 찬다. 무릎, 발목을 부드럽게 이용해서 킥 후 유선형을 바로 만들 수 있는 자세로 가다듬어서 마무리한다.
팔다리는 좌우대칭으로 움직인다 

평영은 진행 방향에 대해서 팔을 옆으로 벌이거나 다리를 끌어 당기는 움직임을 해서 자칫하면 진행을 방해할 수 있는 영법이다. 즉 킥, 긁기, 호흡과 타이밍을 잘 맞추지 않으면 안되는 것이다. 

또한 규칙에서 양 팔다리는 좌우 대칭의 움직임을 한다고 정해져 있으므로 그대로 주의해서 연습한다. 연습 방법으로는 손 긁기와 타이밍에 맞춰 킥을 해서 차고 뻗기 자세를 우선은 타이밍을 익힌다. 

무릎은 확실한 움직임으로 추진력을 얻는다.

발바닥을 의식하고 킥

평영에서는 킥이 중심 추진력이 된다. 양다리와 무릎을 구부리고 발뒤꿈치가 허리 가까이에 오도록 동시에 끌어당긴다. 발목을 일으켜서 발끝을 바깥쪽으로 향하고 발바닥이 확실히 물을 잡을 수 있도록 킥한다. 발뒤꿈치를 끌어당길 때는 무릎부터 끌지 않고 발목부터 허리에 접근시키 듯이 무릎을 구부린다. 이때 부채차기나 양다리를 상하로 움직이는 돌고래 차기는 금지되고 있기 때문에 주의한다. 

장심(掌心)으로 물을 후방 바깥쪽으로 민다

평영의 기본적인 킥을 확실히 익힌다. 차고 뻗기 자세에서 발바닥을 수면으로 향하도록 하고 다리를 약간 벌리면서 무릎을 구부리고 발뒤꿈치를 끌어당긴다. 양발목을 허리까지 끌어당긴 후 발목을 양다리를 약간 비스듬히 내리차는 듯하게 장심으로 물을 후방 바깥쪽으로 밀어내면서 킥하고, 다리를 충분히 편다.

다리를 너무 벌리지 않는다 

양발목을 허리로 끌어당길 때의 다리는 무릎과 무릎사이를 꼭 어깨 폭과 같은 정도로 벌리는 것이 가장 좋다. 그 이상 벌리면 넓적다리로 물을 앞으로 밀게 되어 저항받게 된다.

입체적으로 킥

평영의 킥은 입체적으로 찬다는 생각을 갖는 것이 중요하다. 발바닥으로 물을 뒤쪽으로 참과 동시에 양다리 사이에 물을 끼우듯이 하면서 효율적인 킥을 지향하자.

수중에서의 리커버리는 저항이 적도록 한다.

어깨 앞에서 긁는 것이 평영의 철칙

평영에서 팔의 움직임은 차고 뻗기의 상태에서 전방으로 펴진 자세에서 시작되어 좌우 바깥쪽으로 긁었다가 안쪽으로 향해서 긁어 모은다. 피니시부터 리커버리까지 수중에서 이루어지기 때문에 물의 저항을 받지 않도록 정확한 각도로 팔의 긁기가 요구된다. 또한 어깨앞에서만 긁는 점도 이 영법의 큰 특징이다. 풀로 얻은 속력은 떠어뜨리는 일 없이 원활한 긁기를 할 수 있도록 한다.

팔꿈치를 구부려서 풀

팔은 똑바로 전방으로 펴고 좌우로 물을 가르듯이 굵기 시작한다. 좌우로 벌린 팔이 약 90도가 되었을 때 풀꿈치를 구부리면서 물을 끌어당긴다. 어깨 옆에서 끌어당김을 동시에 옆구리를 조이고 양팔을 가믓 아래에 껴안듯이 해서 다음 스트로크를 위해 팔을 펴고 리커버리를 한다.

팔의 긁기는 역하트 형태를 그린다

평영에서의 스트로크는 양손으로 역하트를 그리는 듯한 형태라고 생각하자. 양팔을 편 상태에서 팔꿈치를 구부리고 손바닥을 안쪽으로 긁어 모으는 일련의 움직임은 정확히 역하트를 그리고 있다.

물을 누르고 마무리

손바닥이 좌우 바깥으로 향하고 있을 때 상체는 조금씩 물 위로 나온다. 그리고 마무리 때에 몸 전체가 떠서 속력이 가장 많이 난다. 이 속력을 떨어뜨리지 않고 상체를 물위로 내보내기 위해서는 마무리 때에 물을 누르는 듯한 긁기가 필요해진다.

손의 긁기와 킥은 같은 타이밍으로 물을 잡는다

유선형을 만들면서 헤엄친다

평영은 킥이나 긁기가 모두 수중에서 이루어지기 때문에 다른 영법에 비해 저항이 많은 수영이라고 말할 수 있다. 큰 추진력을 얻기 위해서는 이 저항을 최소로 만드는 킥과 긁기의 결합이 요구된다. 팔의 마무리 직전에 다리를 끌어당기고 팔을 앞쪽으로 펴는 리커버리 때에 다리를 차 낸다고 하는 기본적인 몸의 움직임을 숙달하자. 평영은 몸 전체가 퍼지거나 움츠러들거나 해서 나아가지만 타이밍이 나쁘면 자벌레와 같은 영법이 되어 버린다.

몸의 축에서 대칭으로 팔다리를 움직인다

자유형이나 배영의 킥과 손동작의 움직임은 좌우 모두 항상 정반대였지만 평영의 경우는 킥, 긁기 모두 몸의 축을 중심으로 해서 대칭의 움직임이 된다. 일상 생활에서는 걷을 때나 달릴 때나 좌우 대칭의 동작이 그다지 없기 때문에 다소 당황하게 될 것이다.

그러나 평영은 몸의 축을 중심으로 해서 좌우 대칭의 움직임을 한다는 의식을 가지면 킥이나 긁기의 타이밍을 맞추기 쉬워진다.

콤비네이션(Combinatiaon)을 익히자

1. 팔다리가 완전히 펴진 상태의 차고 뻗기의 자세이며 유선형을 유지하는 것이 중요하다.
2. 손바닥을 뒤집어서 물을 긁기를 시작함과 동시에 다리를 당기기 시작한다.
3. 양팔을 가슴 앞에서 껴안을 때에 발목을 충분히 끌어당긴다.
4. 발목의 끌어당김이 완전히 이루어지면 양팔을 전방으로 펴고 발바닥으로 물을 잡으면서 킥한다. 팔의 긁기에 맞춰서 다리의 타이밍을 계산하자.

스트로크의 후반에 입으로 단숨에 호흡한다

한 번 긁기, 한 번 호흡이 기본이다

한 번 긁기에 맞춰 한 번 호흡이 기본이다. 얼굴은 긁기의 타이밍에 맞춰 전방으로 올리기 때문에 자유형 때와 같은 어려움은 없지만 '음', '파', 라고 하는 호흡법은 같다. 긁기의 후반, 몸 전체가 떠서 속력이 가장 나고 있을 때에 호흡을 개시한다. 규칙상 자유형과 같이 어깨가 올라가든가, 또는 내려가든가 속도롤 유지하기 위해 얼굴을 올리지 않고 머리가 수면보다 아래에 가라앉은 채의 잠수영법은 하면 실격이 된다. 이와 같은 사항들은 참고로 침착하게 호흡하자.

호흡은 자연스럽게 한다

호흡을 위해서 상체를 수면에 올릴 때는 팔꿈치를 옆구리에 붙이고 손바닥은 가슴 부근에서 모아 물을 껴안듯이 푸시한다. 호흡을 위해서 얼굴을 올리는 것이 아니라 수영 중에 자연히 상체가 떠오르는 듯한 느낌이 되면 가장 좋다.

호흡의 타이밍을 잡는다

팔의 긁기에 맞춰 수면에서 얼굴을 올리고 호흡을 익히는 방법 중의 하나에 수중을 걸으면서 긁기를 하고 타이밍을 잡는 연습이 있다. 가슴 정도 깊이의 지점에 서서 어깨까지 물에 넣고 양팔을 앞쪽으로 펴서 수면에 얼굴을 닿게 하고 준비한다. 이 상태에서 양팔을 좌우로 벌리면서 물을 가라앉히고 긁기 후반에 얼굴을 올려 호흡한다. 충분히 얼굴을 물에 가라앉히고 긁기에 맞춰서 재빨리 호흡을 할 수 있도록 연습하자. 

접영 체크 포인트

http://www.marujong.net/?document_srl=1004 접영 체크 포인트 ▶킥 1. 장딴지가 수면에 나와 있지 않은가. 장딴지가 수면에 나오지 않도록 할 것. 양발의 동작은 크지만 모두 수면아래의 동작이 원칙이다. 2. 발목이 구부러져 있지 않은가. 발목을 뻗어서 발등으로 물을 치는 것은 자유형이나 배영이나 모두 같다. 발목이 구부러져 있으면 좋은 킥은 할 수 없다. ▶몸전체 3. 허리로 리듬을 제대로 맞추고 있는가. 초심자일 때부터 확실히 익혀둬야 할 것이 허리의 상하동작이다. 발을 차내릴 때 의식적으로 허리를 들어 그 반동으로 킥을 하도록 하자 4. 엉덩이가 수면 밖으로 나와 있는가. 허리가 상하로 잘 움직이고 있는가를 살피는 데는 엉덩이가 킥의 리듬에 맞추어서 수면에 얼굴을 내는지 어떤지를 확인하는 것이 손쉽다. ▶ 팔의 상태 5. 입수할 때 손은 똑바로 인가. 어깨넓이 이상으로, 입수 때의 손이 벌어지지 않도록 주의. 팔꿈치가 내려가면 잘 안되므로 자유형의 엘보우 엡을 하는 셈으로 노력하자. 6. 수중에서 팔꿈치를 구부리고 있는가. 수중에서 양손의 동작은 자유형의 스트로크와 같다. 입수하면 확실하게 팔꿈치를 구부려서 물을 푸시. 입수의 힘으로 아래를 향해 푸시하면 상체가 일어서 버리므로 주의하자. ▶ 얼굴 7. 목은 수면에서 나와 있는가. 호흡할 때에는 얼굴을 앞쪽으로 내민다. 그러나 목은 수면 아래에 남긴다.

자유형 체크 포인트

http://www.marujong.net/?document_srl=999

자유형 체크 포인트

▶킥

1. 물보라는 어떤가.
철썩철썩 요란한 물보라는 절대로 불가.
더욱 나쁜 것은 무릎과 발목의 힘이 빠지지 않아 푸드득푸드득 하고 정강이로 물을 차고 있는 것 같은 킥이다.

2. 무릎에 힘이 너무 들어가 있지 않은가.
무릎과 발목에 불필요한 힘이 들어가 있으면 물보라가 많은 서투른 킥이 되고 피로하기 쉬워 오래 계속할 수가 없다. 곧 킥이 무너져 버리는 사람은 무릎과 발목의 탄력에 유의하자.

3. 발 전체를 효율적으로 쓰고 있는가.
넓적다리로 친다.... 이것을 항상 잊지 않도록 한다.
발목을 확실히 뻗고 발등으로 물을 푸시하고 있는지 어떤지도 중요하다.
이것이 되어 있지 않은 것도 요란한 물보라의 원인이 된다.

▶몸 전체

4. 몸은 슈퍼맨인가.
구부정한 자세,묘하게 뒤로 젖힌 몸은 금기이다.
아무리 해도 몸이 바로 뻗지 않는 초심자는 다시 한 번 물장구에서 부터 연습을 반복하는 것이 좋다.

▶팔의 상태

5. 엘보우 업은 되어 있는가.
팔꿈치에서 나오고 있는가,수상에서는 팔꿈치가 가장 높은 위치에 있는가,손 끝이 유연하게 있는가가 포인트이다.
입수와 동시에 손이 바로 뻗는지 어떤지도 이것으로 결정된다.

6. 수중의 팔꿈치는 구부러져 있는가.
물방아나 외륜선과 같은 움직임으로는 추진력을 벌 수 없다는 것을 상기하기 바란다.
입수하면 팔꿈치를 구부리고 가장 힘을 발휘하기 쉬운 상태에서 물을 젓는다.

7. 손바닥은 둥글지 않은가.
손바닥을 의식적으로 둥글게 하면 손의 다른 부분에도 불필요한 힘이 들어가고 반대로 손가락이 벌어져 있으면 물을 잡을 수 없다.

▶눈

8. 눈은 뜨고 있는가.
기본중의 대기본이다. 본인은 눈을 뜨고 있다고 생각하지만 입수의 순간이나 얼굴이 수중에 있을 때에 감아버리는 경우가 있다. 풀의 코스 라인등 무언가를 보면서 헤엄치자.

▶호흡

9. 공기를 확 들이 마실 수 있는가.
곧 호흡이 곤란해지는 것은 모양만 되어있고 확실하게 숨을 들이 마시지 못한 증거.
"공기를 먹는다."즉, 단숨에 들이 마시자.

평영 체크 포인트

http://www.marujong.net/?document_srl=1001 평영 체크 포인트 ▶킥 1. 좌우의 손발은 대칭인가. 좌우의 손발이 대칭적으로 동작하지 않으면 평영은 성립되지 않는다. 특히 발의 흐트러짐에 주의하자. 2. 킥의 종료때는 똑바로 뻗어 있는가. 킥은 좌우로 크게 벌리지 말고 종료는 발바닥을 모으는 듯이 발끝을 가지런히 하는 것이 정답. 3. 가랑이는 벌리고 있지 않은가. 가장 중요한 체크포인트. 발을 끌어 당길 때 가로가 아니고,세로로 당기는 것에 신경을 집중하자. ▶ 몸전체 4. 허리는 가라앉지 않는가. 몸 전체가 뻗었을 때는 물론이지만 발을 끌어당겼을 때 허리의 가라 앉음에도 요주의. 피로해 지면 입영 비슷하게 된다. ▶ 팔 5. 어깨 앞에서 팔꿈치를 구부리고 있는가. 앞으로 뻗어서 물을 좌우로 젓기 시작한 손은 곧 팔꿈치를 구부려서 물을 껴안는 것 같은 스타일로 하는 것이 중요. 쓸데없이 뒤까지 손을 흘리지 말고 재빨리 팔꿈치를 구부려서 힘을 내는 것이다. 6. 수중에서도 팔꿈치는 가라앉아 있지 않은가. 자유형이 엘보우 업이면 평영은 스트로크의 어디에서 팔꿈치를 구부리기 시작하는 가가 결정수. 팔꿈치를 90。 정도로 구부리고 항상 유연한 힘을 낼 수 있는 상태로 해 둘 것. ▶ 호흡 7. 매회때마다 제대로 호흡을 할 수 있는가. 한번 스트로크에 한 번 숨쉬는 것을 1회씩 정확하게 호흡할 수 있도록 하기 바란다. 계기는 양손의 동작이다. ▶ 머리 8. 머리는 수몰되어 있지 않은가. 제대로 된 평영은 숨을 들이마실 때에만 얼굴을 내미는 것이 철칙이지만 (항상 얼굴을 들고 있으면 몸이 눕지 않는다.) 머리를 너무 가라앉혀 수면 아래에 숨어 버리면 실격이 된다

배영 체크 포인트

http://cafe.naver.com/totalimmersion.cafe


배영 체크 포인트 

▶킥

1. 발목은 뻗어 있는가.
발목이 제대로 뻗어 있지 않으면 물보라만 이는 킥이 된다.
유연한 발목과 탄력이 포인트이다.

2. 수면에 발이 나와 있지 않은가
발끝만이 조금 수면에 나와 있는 킥이 가장 좋다.
정강이나 무릎을 수면 밖으로 내미는 킥은 초급이전이다.

▶몸전체

3. 구부정한 자세로 되어 있지 않은가.
킥을 하고 있어도 허리가 가라앉아 버리는 상태는 좋지 않은 상태.
가라앉을 정도면 하나부터 다시 시작한다.

▶ 팔의 상태

4. 수중에서 손은 살아 있는가.
수중에서는 팔꿈치를 조금 구부리고,손바닥 전체로 물을 뒤쪽으로 푸시하는 느낌을 자기 것으로

하도록 한다.
팔꿈치보다 손목이 깊을 정도면 아직 미숙. 가장 힘이 나오는 포인트를 찾자.

5. 수면 위에서 팔은 뻗어 있는가.
공중의 팔을 쭉 뻗는다. 마치 선수선서하듯이 눈으로 체크하면서 스트로크를 하자.

6. 입수까지 팔꿈치는 똑 바른가.
초심자로서 외워두어야 할 최대의 포인트가 입수시에 팔꿈치의 뻗기이다.
선수선서에서 귀를 문지르고 입수까지 제대로 팔꿈치가 뻗어 있는가의 여하에 따라 수영이

결정된다.
몸이 뻗어 있지 않으면 팔꿈치도 뻗지 못한다.

▶ 얼굴

7. 턱은 당겨 있는가.
머리가 흔들흔들 움직이는 것도 초심자의 특징.
턱을 가볍게 당겨서 시선을 일정하게. 조금쯤 얼굴에 물을 뒤집어 써도 개의치 않는다.

▶ 호흡

8. 아무렇게나 호흡하고 있지 않은가.
크롤처럼 고생하지 않아도 되는 만큼 호흡도 아무렇게나 하기 쉽다.
팔을 들어올리는 것에 맞추어 숨을 들이 마신다라는 리듬을 확실히 하자.

ATI radeon 9200 graphic accelerator issue

I used VLC i had sound no audio.

This will work for all with catalyst on their computer

1) Right click on desktop and go on catalyst

2)Pick Advanced

3)Top left it says graphics click video on drop down menu

4) change home preset to anything but custom if you see a picture appear on top your video will work

The IEEE Verilog 1364-2001 Standard What's New, and Why You Need It

http://www.sutherland-hdl.com/papers/2000-HDLCon-paper_Verilog-2000.pdf


3.2 Scalable models—Verilog generate


Verilog-2001 adds  generate loops, which permit generating multiple instances of modules and primitives, as well as generating multiple occurrences of variables, nets, tasks, functions, continuous assignments, initial procedures, and always procedures. Generated declarations and instantiations can be conditionally created, using if–else decisions and case statements.

3.4 Indexed vector part selects

The Verilog-2001 standard adds a new syntax, called indexed part selects. With an indexed part select, a base expression, a width expression, and an offset direction are provided, in the form of:
[base_expr +: width_expr] //positive offset
[base_expr -: width_expr] //negative offset




3.5 Multidimensional arrays
The Verilog-1995 standard allows one-dimensional arrays of variables. Verilog-2001 extends this by permitting:
• Multi-dimensional arrays
• Arrays of both variable and net data types

Verilog-Mode Emacs

http://www.veripool.org/papers/verilog-mode_veritedium_snug.pdf


Reduce spins on fixing lint or compiler warnings
ƒ Reduce sensitivity problems
- If you forget (or don’t have) a linter, these are horrible to debug!
ƒ Make it easier to name signals consistently
through the hierarchy
- Reduce cut & paste errors on multiple instantiations.
- Make it more obvious what a signal does.
ƒ Reducing the number of lines is goodness alone.
- Less code to "look" at.
- Less time typing.


This expansion is best if in the editor
• You can “see” the expansion and edit as needed
ƒ There is a Verilog package for Emacs
• Written by Michael McNamara <mac@versity.com>
• Auto highlighting of keywords
• Standardized indentation
ƒ Expanded it to read & expand /*AUTOs*/
• Magic key sequence for expand/deexpand

C-c C-a  and C-c C-d

With this key sequence,
Verilog-Mode parses the verilog code, and
expands the text after any /*AUTO*/ comments.

verilog and systemverilog real port

Subject: Literal number gotchas

There are several gotchas associated with defining literal integer numbers
in Verilog and System Verilog. There are actually two different sets of
rules involving literal integers: one that defines the generation of an
integer number, and another for assigning the number.

Many engineers have only a vague understanding of these two sets of rules,
and often confuse them with each other. Here we'll discuss gotchas on the
generation a literal integer. Sec 4.4 discusses the issues regarding the
assignment of integers.

Review of literal integer syntax. Literal integers can be specified as a
simple decimal integer (e.g. 5) or as a based integer (e.g.'h5). A based
literal integer is specified using the following syntax:

's

Where:

- is optional. If given, it specifies the total number of bits
represented by the literal value. If not given, the default size is
32 bits (the Verilog standard says "at least" 32 bits, but all
implementations the authors are aware of use exactly 32 bits).
- s is optional. If given, it specifies that the literal integer should
be treated as a 2's complemented signed value. If not given, the
default is unsigned.
- is required, and specifies whether the value is in binary,
octal, decimal, or hex.
- is required, and specifies the literal integer value.


4.1 Signed versus unsigned literal integers

Gotcha: Some literal integers default to signed; other literal
integers default to unsigned.

A simple literal integer (e.g. 5) defaults to a signed value, and cannot be
specified as unsigned. A based literal integer (e.g. 'h5) defaults to an
unsigned value, unless explicitly specified as signed (e.g. 'sh5). The s
specifier was added as part of the Verilog-2001 standard to allow the
specification of sized, signed literal values.

The difference in the default signed-ness of a value can catch engineers by
surprise. Signed-ness of a value affects several types of operations.
Unexpected operation results will occur if an engineer forgets -- or is not
aware of -- the different default signed-ness of a simple literal integer
versus a based literal integer number.

Are the following two signed counter statements the same? (Of course
not, or we wouldn't have included this example in this paper!)

byte in; // signed 8-bit variables
int out1, out2; // signed 32-bit variables

initial begin
in = -5;
out1 = in + 1; // OK: -5 + 1 = -4 (literal 1 is signed)
out2 = in + 1'b1; // GOTCHA: -5 + 1'b1 = 252 (1'b1 is unsigned)
end

How to avoid this gotcha: The difference between adding 1 and 1'b1 is that
the literal integer 1 is a signed value, whereas the literal integer 1'b1
is an unsigned value. This difference affects how the ADD operation is
performed. Signed arithmetic is discussed in more detail in Sec 5.3.


4.2 Default base of literal integers

Gotcha: Literal integers have a default base that might not be
what is intended.

A simple literal integer (e.g. 5) defaults to a decimal base. To use a
binary, octal or hex value, a based-literal number must be specified
(e.g. 'h5). The base options are represented using b, o, d, or h for
binary, octal, decimal and hex, respectively. The base specifier can be
either lower case or upper case (i.e. 'h5 and 'H5 are the same).

The following example of a 4-to-1 MUX illustrates a common gotcha when an
engineer forgets -- or is not aware -- that a simple integer number is a
decimal value:

logic [1:0] select; // 2-bit vector

always_comb begin
case (select) // intent is for a 4-to-1 MUX behavior
00: y = a;
01: y = b;
10: y = c; // GOTCHA! This branch is never selected
11: y = d; // GOTCHA! This branch is never selected
endcase
end

This gotcha fits nicely with the well known joke that only engineers laugh
at: "There are 10 types of people in the world, those that know binary, and
those that don't". The example above may look reasonable, and it is
syntactically correct. But, since the default base of a simple integer is
decimal, the values "10" and "11" are ten and eleven, respectively. The
size of the values is not specified, and so defaults to 32-bits wide. The
2-bit select signal will be zero-extended to 32-bits wide, and then compared
to zero, one, ten and eleven. The only values of select that will ever
match are a and b, which extend to 32-bit 00...00 and 00...01, respectively.
The extended value of select will never match the decimal "10" and "11".
Therefore, the c and d inputs of the multiplexer will never be selected.
Since this is not a syntax error, the problem shows up in simulation as a
functional failure which can be difficult to detect and debug. GOTCHA.

How to avoid this gotcha: to detect this use the System Verilog unique
modifier to the case statement, as in:

unique case (select) // intent is for a 4-to-1 MUX behavior

The unique modifier reports an error if two or more case select items are
true at the same time, or if no case select items are true. The example
above becomes a simulation error, rather than a functional bug in the code.

Code coverage utilities and/or System Verilog functional coverage can also
be used to detect that some branches of the case statement are not being
executed. Also, some EDA tools, such as LEDA and DC, will warn about a
mismatch in the size of select and the literal integer values to which
it is compared.


4.3 Size mismatch in literal integers

Gotcha: Too small a size truncates most-significant bits; too large
a size left-extends with...something.

Size smaller than value gotcha. Verilog rules state that if your bit size
specified is fewer bits than the value, then, no matter what, the left-most
bits of the value are truncated. This can be a gotcha when the value is
signed, because the sign bit will be truncated as well.

This can significantly affect the result of signed operations! In the
following example, a negative 15 (8-bit F1 hex) is truncated to 2-bits
wide, becoming a positive 1.

-2'sd15; // 11110001 is truncated to 01

How to avoid this gotcha: Be sure that the bit size specified is at least as
wide as the size of the value, especially when using signed values. Some
tools, such as rule checking programs like LEDA, will detect a size versus
value mismatch. Unfortunately, these tools will also report size mismatches
when using unsigned values, where a mismatch may not be a problem, and may
even be useful.

Size greater than value gotcha. Verilog rules state that when your bit size
specified is more bits than the value, then the value will be expanded to
the size by left-extending the value. The fill value used to left extend is
based on the most significant specified bit of the value, as follows:

- If the most significant bit of the value is a 0 or a 1, then the value
is left-extended zeros.
- If the most significant bit is an X, then the value is left-extended Xs.
- If the most significant bit is a Z, then the value is left-extended Zs.

This left extension can be very useful. For example, it is not necessary to
specify the value of each and every bit of a vector to reset the vector to
zero or to set the vector to high impedance.

64'h0; // fills all 64 bits with 0
64'bZ; // fills all 64 bits with Z

A surprising gotcha can occur when the bit-size is larger than the value,
and the value is signed. The expansion rules above do not sign-extend a
signed value. Even if the number is specified to be signed, and the most
significant bit is a 1, the value will still be extended by 0's. Example:

logic [11:0] a, b, c;

initial begin
a = 12'h3c; // unsigned value 00111100 expands to 000000111100
b = 12'sh3c; // signed value 00111100 expands to 000000111100
c = 12'so74; // signed value 111100 expands to 000000111100
if (a == b) ...; // evaluates as true
if (a == c) ...; // evaluates as true
end

In this example, a hex 3c is an 8-bit value, which does not set its most-
significant bit. When the value is expanded to the 12-bit size, the
expansion zero-extends, regardless of whether the value is signed or
unsigned. This is as expected.

The octal value 73 is the same bit pattern as a hex 3c, but is a 6-bit
value with its most-significant bit set. But, the expansion to the 12 bit
size still zero-extends, rather than sign-extends. If sign extension was
expected, then GOTCHA!.

How to avoid this gotcha: The subtlety in the preceding example is that the
sign bit is not the most-significant bit of the value. It is the most-
significant bit of the specified size. Thus, to specify a negative value
in the examples above, the value must explicitly set bit 12 of the literal
integer.

12'h805 // expands to 100000000101, which is 2053 decimal
12'sh805 // expands to 100000000101, which is -2043 decimal
12'shFFB // expands to 111111111011, which is -5 decimal
-12'sh5 // expands to 111111111011, which is -5 decimal

Unspecified size. If the size of a literal integer is not specified, then
the bit size of the literal number defaults to 32 bits. This default size
can be a gotcha when the is not 32 bits, as discussed earlier.


4.4 Literal number size mismatch in assignments

Gotcha: A size mismatch in literal numbers follows different rules
than a size mismatch in assignment statements.

Once a literal integer has been created and expanded via the rules in
Sec 4.3, the operator rules are then applied.

Note: This is a discussion on assignment of literal value (e.g. a = 5;)
gotchas. Sec 5 discusses assignment rules and gotchas when there are
operators on the right-hand side of the assignment.

The assignment operation rules for assigning literal values are:

- When the left-hand side expression of an assignment statement is
fewer bits than the right-hand side literal value, then the most
significant bits of the right-hand side value are truncated.
- When the left-hand side expression of an assignment statement is
more bits than the right-hand side literal value, ...
- If the right-hand side literal value is unsigned, it will be
left-extended with zeros.
- If the right-hand side literal value is signed, it will be
left-extended using sign extension.
- Exceptions: If the right-hand side is an unsized high-impedance
literal value (e.g.: 'bz) or unsized unknown (e.g.: 'bx), the value
will left-extend with Z or X, respectively, regardless of whether
signed or unsigned.

These rules might seem, at first glance, to be the same rules discussed in
Sec 4.3, when a literal integer size does not match the literal integer
value. But there is a subtle, and important difference in the rules. The
difference is that literal value expansion does not sign-extend, but an
assignment statement does sign-extend.

And now the gotcha. Sign extension of the right-hand side only occurs if
the expression on the right-hand side is signed. The signed-ness of the
left-hand side expression does not affect whether or not sign extension
will occur. Consider:

logic [3:0] a; // unsigned 4-bit variables
logic signed [3:0] b; // signed 4-bit variables
logic [7:0] u; // unsigned 8-bit variables
logic signed [7:0] s; // signed 8-bit variables

u = 4'hC; // 1100 (right-hand side) is zero-extended to 00001100
s = 4'hC; // 1100 (right-hand side) is zero-extended to 00001100
// even though s is a signed variable; GOTCHA

u = 4'shC; // 1100 (right-hand side) is sign-extended to 11111100
// even though u is an unsigned variable; GOTCHA
s = 4'shC; // 1100 (right-hand side) is sign-extended to 11111100

a = 4'hC;
u = a; // 1100 (right-hand side) is zero-extended to 00001100
s = a; // 1100 (right-hand side) is zero-extended to 00001100
// even though s is a signed variable; GOTCHA

b = 4'hC;
u = b; // 1100 (right-hand side) is sign-extended to 11111100
// even though u is an unsigned variable; GOTCHA
s = b; // 1100 (right-hand side) is sign-extended to 11111100

These simple examples illustrate two types of gotchas:

- Assigning to a signed variable does not cause sign extension. Sign
extension only occurs if the right-hand side expression is signed.

- Assigning to an unsigned variable can have sign extension. Sign
extension occurs if the right-hand side expression is signed.

In other words, it is the right-hand side of an assignment that determines
if sign extension will occur. The signed-ness of the left-hand side has no
bearing on sign extension.

These same assignment expansion rules apply when operations are performed on
the right-hand side of an assignment. However, whether zero extension or
sign extension will occur also depends on the type of operation. These
operation rules are covered in Sec 5.3.


4.5 Literal number Z and X extension backward compatibility

Gotcha: Verilog-2001 Z and X extension is not backward compatible
with Verilog-1995.

Verilog-1995 had a gotcha when assigning an unsized high-impedance value
('bz) to a bus that is greater than 32 bits. The default size of an unsized
number is 32 bits. The literal number expansion rules state the Z value
will extend through those 32 bits (see Sec 4.3). But, the assignment
extension rules state that this 32-bit value then zero-extends to the size
of the left-hand side of the assignment (see Sec 4.4). Therefore, with
Verilog-1995, only the lower 32 bits would be set to high-impedance, and the
upper bits would be set to 0. To set the entire bus to high-impedance
requires explicitly specifying the number of high impedance bits. Example:

//Verilog-1995 style:
parameter WIDTH = 64;
reg [WIDTH-1:0] data;

data = 'bz; // fills with 64'h00000000zzzzzzzz
data = 64'bz; // fills with 64'hzzzzzzzzzzzzzzzz

The fill rules in Verilog-1995 make it difficult to write models that scale
to new vector sizes. Redefinable parameters can be used to scale vector
widths, but the Verilog source code must still be modified to alter the
literal value widths used in assignment statements. (And yes, believe it or
not, there are still some companies primarily using Verilog-1995.) The
example above applies equally to assigning X's to a vector.

How to avoid this gotcha: One solution came with Verilog-2001, which changed
the rule for assignment expansion of unsized Z and X literal integers. The
unsized value of Z or X will automatically expand to fill the full width of
the vector on the left-hand side of the assignment.

//Verilog-2001style:
parameter WIDTH = 64;
reg [WIDTH-1:0] data;

data = 'bz; // fills with 64'hzzzzzzzzzzzzzzzz

The Verilog-2001 enhancement allows writing code that scales when vector
sizes are redefined. But, this solution is also a gotcha, because it is not
backward compatible w/ Verilog-1995. If maintaining backward compatibility
with Verilog-1995 is a requirement, then always specify the exact size of
literal Z and X values.

The best way to avoid these Z and X fill gotchas is to take advantage of a
new System Verilog literal number, as described in Sec 4.6.


4.6 Filling vectors

Gotcha: Verilog does not have a literal value that fills all bits
of a vector with 1's.

In Verilog-2001, assigning 'bx, 'bz, or 0 will fill a vector of any size
with all bits set to X, Z or zero, respectively. However, assigning 'b1 is
not orthogonal. It does not fill a vector with all bits set to one.

//Verilog-2001 style:
parameter WIDTH = 64;
reg [WIDTH-1:0] data;

data = 'b0; // fills with 64'h0000000000000000
data = 'bz; // fills with 64'hzzzzzzzzzzzzzzzz
data = 'bx; // fills with 64'hxxxxxxxxxxxxxxxx
data = 'b1; // fills with 64'h0000000000000001 -- GOTCHA!

In order to assign a vector of any size with all bits set to one, designers
must learn clever coding tricks involving various Verilog operators. These
tricks are not discussed in this paper, because there is a better way to
avoid this gotcha...

How to avoid this gotcha: System Verilog defines a consistent syntax for
filling any size of variable with all 1s, all 0s, all Xs or all Zs.

//System Verilog style:
parameter WIDTH = 64;
reg [WIDTH-1:0] data;

data = '1; // fills with 64'hffffffffffffffff
data = '0; // fills with 64'h0000000000000000
data = 'z; // fills with 64'hzzzzzzzzzzzzzzzz
data = 'x; // fills with 64'hxxxxxxxxxxxxxxxx

The syntax for this is just a simple assigning '.


4.7 Passing real (floating point) numbers through ports

Gotcha: Verilog does not allow real numbers to be passed directly
through ports.

In Verilog, the outputs of a module can be either net or variable types, but
the signals receiving values from module instantiations are required to be
of type net. Verilog also requires that input ports of a module be net
types. Verilog variables include the real type, which is a double-precision
floating point value, but there is no counterpart to a real variable for the
net data types. If outputs of a module can be variable types, but the
receiving side must be a net type, how are real values passed through
module ports?

The gotcha is it's illegal in Verilog to pass real numbers through ports.
A secret that many engineers don't know, however, is that Verilog has a pair
of built-in system functions that can be used to convert real numbers to a
format that can be passed through ports. The numbers are then converted
back to real in the receiving module. These functions are $realtobits and
$bitstoreal.

module top;
wire [63:0] net_real; // only net types used in netlist
real_out ro (.net_real_out(net_real));
real_in ri (.net_real_in(net_real));
endmodule

module real_out(output wire [63:0] net_real_out); // output is net type
real r;
assign net_real_out = $realtobits(r); // must convert real to a
// bit-vector to pass through
// module output port
...
endmodule

module real_in(input wire [63:0] net_real_in); // input is net type
real r;
always @(net_real_in)
r = $bitstoreal(net_real_in); // must use bit-vector on input
// port, then convert to real
...
endmodule

How to avoid this gotcha: While Verilog does provide a solution for
passing real numbers through ports, the solution is not well known, and is
awkward to use. System Verilog provides a much more elegant way to avoid
this gotcha. In System Verilog, real types can be passed directly through
ports System Verilog also allows both the sending and receiving side of
ports to be real variables. The example above can be coded much more
simply in System Verilog.

module top;
real r; // variable types can be used in netlist
real_out ro (.r);
real_in ri (.r);
endmodule

module real_out(output real r); // output is real variable type
...
endmodule

module real_in(input real r); // input is real variable type
...
endmodule


4.8 Port connection rules

Gotcha: The size of a port and the size of the net or variable
connected to it can be different.

The Verilog standard states that module ports are treated as continuous
assign statements that continuously transfer values into, and out of,
modules. This is not a gotcha that one can avoid, but rather a rule that
helps explain some gotchas relating to port connections.

In Verilog, the receiving side of an input or inout port can only be a net
type. The transmitting side of an output port can be either a net or a
variable. When considering ports as continuous assignment statements, it
becomes easier to understand why the receiving sides of ports are required
to be net data type signals, and why the driver (or source) side of ports
could be either net or variable. The receiving side of a port is the same
as the left hand side of a continuous assign statement, and the driver or
source side of a port is the same as the right hand side of a continuous
assign statement. In other words, the left hand side/right hand side rules
for continuous assignments apply directly to port assignments.

With this in mind, consider the 4 scenarios regarding port size connections
(3 of which can be gotchas if not well understood):

- The port size and the signal driving the port are the same size
- The signal driving the port has more bits than the port (a gotcha)
- The signal driving the port has fewer bits than the port (a gotcha)
- An input port is unconnected; no signal driving the port (a gotcha)

Applying continuous assignment size rules to ports gives the following
effects for these 4 scenarios:

1. If the size of the port and the size of the signal driving the
port match, then the value passes through the port with no change.

2. If the signal driving the port has more bits than the port's
receiving signal, then the upper bits of the driving signal are
truncated, including any sign bit.

3. If the signal driving the port has fewer bits than the port's
receiving signal, then the upper bits are extended, following
Verilog's assignment rules:

- If the driving signal is unsigned, the upper bits are
zero-extended to the size of the receiving signal.
- If the driving signal is signed, then the upper bits will
be sign-extended.

4. If an input port is unconnected, the value for the receiving
signal of the port will be the default uninitialized value for its
given data type. For the wire net type, the uninitialized value
is Z. For tri0 and tri1 net types, the uninitialized values are
0 and 1, respectively, with a pull-up strength.

Most often, any mismatch in port connection sizes is a design error. But,
it is not a syntax error. In Verilog, an incorrect size declaration is very
easy design error to make, especially when the modules that make up a design
are written by several different engineers, (and possibly even come from
outside sources). A simple typo in a netlist, or an incorrect parameter
redefinition, can also lead to port size mismatches. Typographical errors
in a netlist can also result in ports of a module instance unintentionally
left unconnected.

Verilog's rules for port connection mismatches are well defined, but the
simulation results are a gotcha! Trying to trace back to why some bits
disappeared from a vector, or additional bits suddenly appeared, can be
difficult. And that assumes that verification detected that there is a
problem! The following example illustrates how values are extended or
truncated when passed through a port of a different size than the value.

module top;
wire [3:0] data = 4'b1111; // decimal 15
wire [7:0] address = 8'b11111111; // decimal 255

block1 b1 (.data(data), // 4-bit wire connected to 8-bit port
.address(address)); // 8-bit wire connected to 4-bit port
// third port left unconnected
endmodule: top

module block1 (input [7:0] data,
input [3:0] address,
input [3:0] byte_en);

initial
#1 $display(" data = %b \n address = %b \n byte_en = %b\n",
data, address, byte_en);
endmodule: block1

The output from this code is:

data = 00001111
address = 1111
byte_en = zzzz

The example above shows how confusing unconnected or partially connected
ports can be. The value of data has mysteriously changed, gaining an extra
four bits. The value of address changed from 255 to 15 (decimal), and
byte_en is high-impedance instead of a valid logic value.

Most simulators generate warnings when code like this is elaborated, but
such warnings are not required by the Verilog standard, and engineers are
notorious for ignoring these warnings.

System Verilog has a great solution to this: implicit port connections using
either . or .* module instantiations. When using the . or the
.* module instantiation syntax, the driver and receiver port signals are
required to be the same size. If, for some reason, a driver/receiver signal
pair size mismatch is desired, the port must be explicitly connected. This
makes it very obvious in the code that the mismatch was intended.

module top;
wire [7:0] data;
wire [7:0] address;

block1 b1 (.data, // implicit port connections
.address);
endmodule: top

module block1 (input [7:0] data,
input [3:0] address,
input [3:0] byte_en);
...
endmodule: block1

In this example, the size of the wire called data has been corrected to be
8-bits wide, which is the same as the size of the data port in block1. The
. shortcut will infer that the wire called data is connected to the
port called data. However, there is still a typo in the declaration of the
wire called address. Instead of a port connection mismatch (a gotcha), an
elaboration error will occur because the signal at the top level is a
different size than the block1 port. The . will not infer connections
that do not match in size.

The . method will allow unconnected ports, such as the byte_en port in
the example above. Was this port left unconnected on purpose, or is it
another typo in the netlist? To catch all the size mismatches & unconnected
ports, using the .* shortcut is the best solution.

module top;
wire [7:0] data;
wire [7:0] address;

block1 b1 (.*, // implicit port connection
.address(address[3:0]), // explicit connection mismatch
.byte_en() ); // explicit unconnected port
endmodule: top

module block1 (input [7:0] data,
input [3:0] address,
input [3:0] byte_en);
...
endmodule: block1

The .* shortcut requires explicitly listing all unconnected ports and all
the signals with different sizes.


4.9 Back-driven input ports

Gotcha: Verilog allows input ports to be used as outputs.

One of the surprising gotchas in Verilog is that a module input port can be
used as an output. If a designer mistakenly assigns a value to a signal
declared as an input port, there will not be any warnings or errors.
Instead, Verilog simply treats the input port as if it were a bidirectional
inout port. The Verilog Language Reference Manual refers to this a port
coercion. In this paper, we refer to an input port being used as an output
as a back-driven port.

The following example illustrates this surprising gotcha:

module top;
wire w1;
backdrive bd(.a(w1)); // instance of a module with back-driven port
endmodule

module backdrive(input wire a); // "a" will be coerced to be an
output
wire b;
assign a = b; // GOTCHA! the intent was to have b = a, not a = b;
endmodule

Even though signal a is an input to module backdrive, it can still be
assigned a value within backdrive. This has the effect of a having two
drivers wired together. This is legal because, in Verilog, ports are
treated as continuous assignments. The code above is equivalent to:

module top;
wire w1;
wire a, b;
assign a = w1; // same as connecting "w1" to input port "a"
assign a = b; // a second continuous assignment to "a"
endmodule

How to avoid this gotcha: With System Verilog, input ports can be connected
to variables, instead of the wire type. System Verilog restricts variables
to only allow a single source. This is different than a wire type, where
multiple drivers are permitted (whether intentional, or not). In the
preceding example, if "a" had been declared as a logic type instead of a
wire type, the assignment of a = b would be a syntax error, because it would
represent a second source for "a". The authors recommend that all module
inputs and outputs be declared as variable types, unless it is intended to
have multiple drivers on the port (e.g. a bidirectional data bus).