QRZ.COM
ad: TinyPaddle-1
ad: L-giga
ad: L-HROutlet
ad: l-rl
ad: Left-2
ad: chuckmartin-2
ad: Left-3
ad: RigCables-1
K5LBJ USA flag USA

Login is required for additional detail.

QSL: QRZ Logbook, Paper QSL.

Email: Login required to view

Page managed by KJ5OAE Lookups: 53406

 
    		Primary Image for K5LBJ
    ' + ''; idocument.open(); // idocument.innerHtml = content; idocument.write(content); // idocument.write(''); // idocument.write(""); // idocument.write(""); // idocument.write(""); // idocument.write(""); idocument.close(); var lazyLoader = { "timer": null, "checkVisible": function (elm, evalType) { evalType = evalType || "visible"; var vpH = jQuery(window).height(); // Viewport Height var st = jQuery(window).scrollTop(); // Scroll Top var y = jQuery(elm).offset().top; var elementHeight = jQuery(elm).height(); var imageTop = jQuery(elm).offset().top; imageTop = imageTop + jQuery('#biodata').offset().top; var imageBottom = imageTop + jQuery(elm).height(); if ( imageBottom > st && imageTop < (st + vpH) ) { return true; } if ( imageBottom > st && imageBottom < (st + vpH) ) { return true; } return false; }, "loadImages": function () { var x = jQuery('#biodata')[0]; if ( x.contentDocument ) { x=x.contentDocument; } else if (x.contentWindow) { // for IE 5.5, 6 and 7: x = x.contentWindow.document; } var imgs = jQuery(x).find("img[data-loading=lazy], input[data-loading=lazy]").get(); var loadable = []; var i; var img; for (i = 0; i < imgs.length; i += 1) { img = imgs[i]; if (img.getAttribute("data-loading") === "lazy") { // if ( lazyLoader.checkVisible(img, "visible") && jQuery(img).is(":visible") ) { if ( lazyLoader.checkVisible(img, "visible") ) { loadable.push(img); } } } for (i = 0; i < loadable.length; i +=1) { img = loadable[i]; img.removeAttribute("data-loading"); img.setAttribute("src", img.getAttribute("data-src")); img.removeAttribute("data-src"); } }, 'triggerLoad' : function() { clearTimeout( lazyLoader.timer ); lazyLoader.timer = setTimeout( function() { lazyLoader.loadImages(); },10); } }; jQuery(document).on("ready", function() { lazyLoader.triggerLoad(); }); jQuery(window).on("resize scroll touchmove", function() { lazyLoader.triggerLoad(); }); document.getElementById('biodata').contentWindow.location.hash = ''; if (document.getElementById('biodata').contentWindow.addEventListener) { document.getElementById('biodata').contentWindow.addEventListener('hashchange', function() { fakeScroll() }); } jQuery('.action-render-').contents().find('body').css('padding', '0px'); jQuery('.action-render-').contents().find('body').css('margin', '0px'); jQuery('.action-render-').contents().find('body').append( jQuery('
    ') ); jQuery('.action-render-').contents().find('#biodata').html( Base64.decode("<p><span style="font-family:Verdana,Geneva,sans-serif">(<em>QSL Information</em>) Note: K5LBJ moved to a new campus.  </span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif">(<em>QRZ Logbook Information</em>) Note: If you wish to confirm a QSO via QRZ Logbook, please send us a message with ALL of the necessary details (Callsign, Time, Frequency, Mode, Etc.). Since we&#39;ve been around for a while and only recently started logging in QRZ logbook, we don&#39;t have the information to confirm QSOs made before the 2023 Texas QSO Party. Thanks for your patience.</span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif">Please <strong><span style="color:#ff0000">send all QSL correspondence to the address below (same as FCC database)</span></strong>:</span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif">K5LBJ, LASA High School<br>
Amateur Radio Club<br>
1012 Arthur Stiles Road<br>
Austin, Texas 78721</span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif">We will return QSL cards and confirm contacts via QRZ Logbook/LoTW. </span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif">--------------------------------------------------------------------------------------------</span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">When the club was formed, LBJ High hosted an advanced academic program called the <a href="http://www.lasahighschool.com/" target="_blank">Liberal Arts &amp; Science Academy </a>(LASA). In 2007, LASA became its own high school co-located on the LBJ campus. While celebrating its 10th anniversary in 2014, the decision was made by club members to officially change the name of the club to reflect its operation as a part of the Liberal Arts &amp; Science Academy High School.</span></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">As such, in April 2014, K5LBJ became the <strong>&quot;LASA&quot;</strong> High School Amateur Radio Club.  We continue to be proud of our callsign which represents our club&#39;s heritage and Texas roots.  Whether operating as LBJ or LASA High, we are K5LBJ.  Ultimately, we just want to be a leader in assisting new Hams to learn the excitement of the hobby.</span></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">Originally issued <strong>KE5BBZ</strong>, the LBJ High School Amateur Radio Club was formed in April 2004. (The Founding Students were Noah Kalish, KD5VDO, David Broockman, KD5ZNC.) At that time, we also became a member of ARRL&#39;s &quot;Big Project&quot;, now known as the Education &amp; Technology Program (<a href="http://www.arrl.org/education-technology-program" target="_blank">ETP</a>).</span></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">Over time, the Amateur Radio club provided an avenue to form an Amateur Radio class at LASA. Over the years, students are guided by their teacher, <strong>Ronny Risinger</strong>, <a href="http://www.qrz.com/db/kc5ees" target="_blank">KC5EES</a>, and our beloved Elmer, <strong>Joe Fisher</strong>, <a href="http://www.qrz.com/db/k5ejl" target="_blank">K5EJL</a>. Many students have learned about this uniquely fun and important service through the club.</span></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">The club competes in the Spring/Fall &quot;School Club Roundup&quot; where schools are challenged to make as many contacts as possible in 24 hours throughout a week.  K5LBJ is proud to have placed 1st in the High School division in 2006, 2010, 2014, 2017, and 2019.   </span></span></p>

<p><span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif">The club is currently led by Lucas KI5ZWV, Seth KJ5EBW (presidents), KJ5OAE, KJ5QPM, and KJ5QPJ (officers), with James KI5UXW acting as an advisor.</span></span></p>

<p><br>
<span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif"><u><strong>2025-2026 School Year</strong></u></span></span></p>

<hr>
<p><span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif"><strong>Joe Fisher III, K5EJL</strong></span></span></p>

<p><span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif">On April 16th, 2026, our beloved mentor, Mr. Fisher, became a silent key. He had volunteered with K5LBJ for 20+ years, coming to our school almost every day to inspire a new generation of hams. He was a crucial teacher, organizer, and storyteller. Mr. Fisher made a positive impact on everyone who knew him. His effect on the club is indubitable, and he will be missed. You can read his full obituary <a href="https://www.dignitymemorial.com/obituaries/austin-tx/joe-fisher-12837607">here</a>.</span></span></p>

<hr>
<p><span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif">The club has grown lots this year, with 5 new certifications so far, and more to come. </span></span></p>

<p><span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif"><strong>Parks on the Air</strong></span></span></p>

<p><span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif">We’ve activated<strong> US-3499 (Enchanted Rock State Park)</strong> together (twice!). See pictures below.</span></span></p>

<table border="1" cellpadding="1" cellspacing="1" style="width:500px">
	<tbody>
		<tr>
			<td>
			<p><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/er1.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:333px; width:500px"></p>

			<p><span style="font-family:Verdana,Geneva,sans-serif">L-R: Seth (KJ5EBW), Lucas (KI5ZWV), Tejas (KJ5OAE), James (KI5UXW), Edward (KJ5INU), Liam, Maverick, &amp; Fred (N1FUR). As you may be able to infer, the sun was very bright on that day.</span></p>
			</td>
			<td><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/er2.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:333px; width:500px"></td>
		</tr>
		<tr>
			<td><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/er4.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:375px; width:249px"></td>
			<td><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/er5.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:375px; width:500px"></td>
		</tr>
	</tbody>
</table>

<p><span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif">Additionally, over the summer we got together to activate<strong> US-3038, McKinney Falls State Park</strong>, right by Austin.</span></span></p>

<p><span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif"><strong>Contesting</strong></span></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif">We had two main contests over the school year: the School Club Roundup (SCR) and the North American QSO Party (NAQP).</span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u>SCR</u>: In the fall, after a large influx of new interest in the club at the beginning of the school year, rapid training was undergone. We ended up making 3rd in the nation!</span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif">The spring semester was hectic for a lot of us, so we weren&#39;t able to focus on contesting. However, we still made sure to be innovative. We successfully made contacts with voice and data modes, with two of those being SSTV contacts, for the first time in the club&#39;s new chapter.</span></p>

<table border="1" cellpadding="1" cellspacing="1" style="width:500px">
	<tbody>
		<tr>
			<td>
			<p><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/seth-fred-sstv.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:572px; width:669px"></p>

			<p><span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif">Seth and Fred&#39;s contact with XE2UD over SSTV</span></span></p>
			</td>
		</tr>
	</tbody>
</table>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u>NAQP</u>: We were invited to the K5TR station to operate during the contest. We had an amazing time with a beautiful rig!</span></p>

<p><span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif"><strong>Projects</strong></span></span></p>

<p><u><span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif">1. Summer Cleanup</span></span></u></p>

<p><span style="font-family:Verdana,Geneva,sans-serif">As perhaps the most monumental project of the year, we came to school over the summer and did a well-overdue (~5 years?) re-organization and cleanup of the amateur radio equipment the club has accumulated over the past 20+ years.</span></p>

<p><u><span style="font-family:Verdana,Geneva,sans-serif">2. Antennas</span></u></p>

<p><span style="font-family:Verdana,Geneva,sans-serif">We got three new antennas over the year: a quadrifilar helix antenna for satellite reception, a 2m/70cm dipole, and lastly a 10/20/40m fan dipole for HF.</span></p>

<p><u><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">3. &quot;LASA High School High Altitude Experiment&quot;</span></span></u></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">As a collaboration with the aerospace and electronics organizations at our school, we started designing a high altitude balloon capable of long-range UHF propagation. Unfortunately, we weren&#39;t able to launch it during the school year due to logistical issues. However, we are on track to launch it soon!</span></span></p>

<p><br>
<span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif"><u><strong>2024-2025 School Year</strong></u><br>
The club did a POTA activation at Pedernales State Park/US-3048. In addition, we got more people certified, and tried out some hydrogen-line radio astronomy.</span></span></p>

<p><br>
<span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif"><u><strong>2023-2024 School Year</strong></u><br>
This year, the radio and astronomy clubs were under joint-leadership. The club set up some stations during observation nights and introduced more people to ham radio with the addition of 5 new members. The club attended the Texas QSO party and experimented with more antennas on the roof.</span></span></p>

<p> </p>

<p><span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif"><u><strong>2022-2023 School Year</strong></u></span></span></p>

<p><span style="font-size:16px"><span style="font-family:Verdana,Geneva,sans-serif">Beginning a new chapter in K5LBJ&#39;s history, the LASA High School Amateur Radio Club formed its first independent school club. Until now, the K5LBJ club was the amateur radio elective class. Because of the well-deserved retirement of our club sponsor (KC5EES) after 26 years teaching in Austin Independent School District, KI5UXW (who had previously taken the class during the 2021-2022 school year) was appointed as president of K5LBJ to gather support and interest to create a hearty ham crew. By the end of the school year (and counting the part of the summer before Field Day), the K5LBJ club had 14 members, eight of whom were licensed (five extras, two generals, and a technican)! Over the course of the 2022-2023 School Year, club members built 40m CW Transcievers from kits, learned how to read schematics and replicate circuits on trainer boards, set-up  equipment to run FT8, built dipole antennas from spare coax and copper wire, competed in October and February&#39;s School Club Round-up (we placed fourth both times) as well as Winter Field Day with N5OAK and Field Day with W5KA.</span></span></p>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2021-2022 School Year</span></strong></u></span></p>

<p class="MsoNoSpacing"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px"><span style="background-color:white">The LASA High School Amateur Radio Club, K5LBJ, celebrated another major milestone on 12-10-2021. During the Amateur Radio elective class, three and half months after she made the first HF Voice contact in the class, Helen Bigge made<span style="color:#ff0000"> the first K5LBJ radio contact using Morse Code from the new LASA campus</span> . She &quot;spoke&quot; with Kelly, <a href="https://www.qrz.com/lookup/ke4mac" target="_blank">KE4MAC</a>, in central North Carolina (1,150 miles away)!</span></span></span></p>

<p class="MsoNoSpacing"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px"><span style="background-color:white">Photos below commemorate that great day. <em>(Click image to enlarge.)</em></span></span></span></p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:400px">
	<tbody>
		<tr>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_CW_Contact_01.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_CW_Contact_01.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:636px; width:400px"></a></span></td>
		</tr>
	</tbody>
</table>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:1200px">
	<tbody>
		<tr>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_CW_Contact_02.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_CW_Contact_02.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:189px; width:400px"></a></span></td>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_CW_Contact_03.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_CW_Contact_03.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:189px; width:400px"></a></span></td>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_CW_Contact_04_png.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_CW_Contact_04_png.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:225px; width:400px"></a></span></td>
		</tr>
		<tr>
			<td style="text-align:center; vertical-align:middle">
			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif">Helen Bigge makes first CW contact from new LASA HS campus.  She is operating from the Amateur Radio elective class classroom.</span></p>
			</td>
			<td style="text-align:center; vertical-align:middle">
			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif">K5LBJ Elmer, Joe Fisher (K5EJL), supervises Helen&#39;s CW contact.  Mr. Fisher has volunteered with K5LBJ since 2004!</span></p>
			</td>
			<td style="text-align:center; vertical-align:middle">
			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif">Screenshot of QRZ map showing the 1,150 miles between K5LBJ and KE4MAC.</span></p>
			</td>
		</tr>
	</tbody>
</table>

<p class="MsoNoSpacing"> </p>

<p class="MsoNoSpacing"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">Students enrolled in the Amateur Radio elective class <span style="color:#ff0000">continue to learn basic electronics</span>.  <a href="https://www.arrl.org/files/file/ETP/A%20One%20Hour%20No%20Solder%20CPO%20ver%202_2.pdf" target="_blank">The &quot;Oscillator Circuit&quot;</a> continues to be a lot of fun and enables students to begin learning about discreet component function and circuit design.</span></span></p>

<p class="MsoNoSpacing"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">Photos below show students working together to build their circuits.  The excitement of hearing &quot;first beep&quot; is real!  <em>(Click on image to enlarge.)</em></span></span></p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="height:200px; width:1200px">
	<tbody>
		<tr>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_oscillator_01.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_oscillator_01.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:189px; width:400px"></a></span></td>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_oscillator_02.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_oscillator_02.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:189px; width:400px"></a></span></td>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_oscillator_03.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_oscillator_03.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:189px; width:400px"></a></span></td>
		</tr>
	</tbody>
</table>

<p class="MsoNoSpacing"> </p>

<p class="MsoNoSpacing"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px"><span style="background-color:white">The <a href="https://contests.arrl.org/scrscores.php?eid=8&amp;iid=996" target="_blank">Fall 2021 &quot;School Club Roundup&quot;</a> signaled a return of K5LBJ to compete for the first time in a year and a half.  The campus move necessitated improvised operations from our new “ham shack,” but students had fun.  Operating for about 12 hours, <span style="color:#ff0000">students made 427 contacts during the week, including 47 states and 4 DX countries (plus 3 more Canadian provinces)</span>.  The inaugural “new campus” K5LBJ crew did a great job representing LASA HS on a national and international stage.</span></span></span></p>

<p class="MsoNoSpacing"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px"><span style="background-color:white">Photos below shows K5LBJ in action during the Fall 2021 &quot;School Club Roundup.&quot; <em>(Click on image to enlarge.)</em></span></span></span></p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:1200px">
	<tbody>
		<tr>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_oct_scr_001.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_oct_scr_001.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:189px; width:400px"></a></span></td>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_oct_scr_002.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_oct_scr_002.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:244px; width:400px"></a></span></td>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_oct_scr_003.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_oct_scr_003.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:189px; width:400px"></a></span></td>
		</tr>
	</tbody>
</table>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:1500px">
	<tbody>
		<tr>
			<td style="vertical-align:middle; width:400px"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_oct_scr_004.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_oct_scr_004.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:845px; width:400px"></a></span></td>
			<td style="vertical-align:middle; width:700px"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_oct_scr_005.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_oct_scr_005.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:331px; width:700px"></a></span></td>
			<td style="vertical-align:middle; width:400px"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_oct_scr_006.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_oct_scr_006.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:844px; width:400px"></a></span></td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">During September 2021, K5LBJ was busy <span style="color:#ff0000">preparing the new &quot;Radio Room&quot; and erecting an HF antenna</span> (vertical with ground radials) on the roof of the building.<br>
Photos below show club members doing the work to get K5LBJ back &quot;On the Air.&quot; <em> (Click image to enlarge.)</em></span></span></p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="height:602px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_ant_raising_03.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_ant_raising_03.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:600px; width:284px"></a></span></td>
		</tr>
	</tbody>
</table>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:1202px">
	<tbody>
		<tr>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_ant_raising_02.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_ant_raising_02.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:284px; width:600px"></a></span></td>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/2021_ant_raising_01.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_ant_raising_01.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:284px; width:600px"></a></span></td>
		</tr>
		<tr>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif">Members of K5LBJ raise the rooftop vertical reminiscent of the famous &quot;Raising of the flag&quot; photo from Iowa Jima.</span></td>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif">Members of K5LBJ on the roof where the club&#39;s vertical antenna is mounted.  Several students can be seen holding ground radial wires which are laid out on the roof.  </span></td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">The 2021-2022 school year was an exciting one for K5LBJ and LASA High School.  First, school re-opened in person (masked)!  So, it was great for students to see each other once again.  Secondly, <span style="color:#ff0000">LASA High moved to a new campus</span>.  This necessitated, of course, moving all of K5LBJ&#39;s antennas and forming a new &quot;Shack&quot; for the Club.  This task fell most directly upon members of the Amateur Radio elective class of Fall 2021.  They valiantly raised antennas and installed radios/tuners/amplifiers/coax/computers/etc.  </span></span></p>

<p> </p>

<table align="center" border="3" cellpadding="1" cellspacing="1" style="width:800px">
	<tbody>
		<tr>
			<td style="width:281px"><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_vertical.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:600px; width:281px">  </span></td>
			<td style="vertical-align:top">
			<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:14.0pt"><span style="background-color:white"><span style="line-height:200%"><span style="color:#050505">K5LBJ celebrated a major milestone on 8-25-2021. During the Amateur Radio elective class, </span><span style="color:#ff0000">Helen Bigge made the first K5LBJ radio contact from our new campus</span><span style="color:#050505">. She spoke with Chuck, <a href="https://www.qrz.com/lookup/wd9bb" target="_blank">WD9BB</a>, in Clinton, Wisconsin (960 miles away). Way to go, Helen!</span></span></span></span></span></p>

			<p> </p>

			<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:14.0pt"><span style="background-color:white"><span style="line-height:200%"><span style="color:#050505">The contact was made using a mag-mount whip vertical affixed to the metal roof over the classroom (shown in lower-right of photo at left).  Later, when in the Trustee&#39;s classrom, K5LBJ would begin using the Cushcraft vertical  installed on the roof (shown in tripod in photo at left).</span></span></span></span></span></p>
			</td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2020-2021 School Year</span></strong></u></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">From March 13, 2020, and lasting for another year and a half, <span style="color:#ff0000">K5LBJ was off the air due to COVID-19</span>.  Finally, in Fall 2021, LASA High School re-opened (fully masked, but in-person).  At that time, K5LBJ re-formed and resumed operation.</span></span></p>

<table align="center" border="0" cellpadding="1" cellspacing="1" style="height:600px; width:1200px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_coronavirus.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:466px; width:833px"></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2021_coronavirus_schools_closed.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:438px; width:800px"></span></td>
		</tr>
	</tbody>
</table>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2019-2020 School Year</span></strong></u></span></p>

<table align="center" border="5" cellpadding="1" cellspacing="1" style="width:1000px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/9_scr_1st_place_team_jan_15_2020.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:474px; width:1000px"></span></td>
		</tr>
		<tr>
			<td style="text-align:center">
			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif"><span style="color:#ff0000; font-size:16px; text-align:center">1st Place in High School Division</span><br>
			<span style="color:#ff0000; font-size:16px; text-align:center">(October 2019 -- School Club Roundup)</span></span></p>

			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif"><span style="text-align:center">K5LBJ &#39;s winning team (L-R): Christian (C.J.), Owen (KI5HWF), Davis, Marco (holding 1st place certificate), Kyle (KI5KDM, Club President), Kenechi (K.C.), West, and Wyatt.</span></span></p>
			</td>
		</tr>
	</tbody>
</table>

<p> </p>

<table align="center" border="5" cellpadding="2" cellspacing="2" style="width:1000px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/k5lbj_fall_2019.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:561px; width:1000px"></span></td>
		</tr>
		<tr>
			<td style="text-align:center; vertical-align:top">
			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif">K5LBJ Club members, Fall 2019 (L-R): Christian (C.J.), Davis, Wyatt, Kenechi (K.C.), Abraham, and Owen (KI5HWF).</span></p>
			</td>
		</tr>
	</tbody>
</table>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px; text-align:justify">In the Fall 2019 School Club Roundup, K5LBJ&#39;s student operators made 605 contacts with 48 states, 5 Canadian provinces, 16 countries, and 34 schools. This outstanding effort earned them the </span><span style="color:#ff0000; font-size:16px; text-align:justify">#1 ranking in the High School category in the <a href="https://contests.arrl.org/scrscores.php?iid=692" target="_blank">October 2019 School Club Roundup</a> contest</span><span style="font-size:16px; text-align:justify">.  K5LBJ has competed in the &quot;School Club Roundup&quot; since 2005, and has been fortunate enough to capture 1st place in the high school division in 2006, 2010, 2014, 2017, and 2019 (1st place in both Spring and Fall contests). </span></span></p>

<table align="center" border="3" cellpadding="0" cellspacing="0" style="width:1000px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/arco_op_davis_logging_10_22_2019.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/arco_op_davis_logging_10_22_2019.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:262px; width:500px"></a></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/k5lbj_kyle_ki5dkm_fall_2019.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/k5lbj_kyle_ki5dkm_fall_2019.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:280px; width:500px"></a></span></td>
		</tr>
		<tr>
			<td style="text-align:center; vertical-align:top">
			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif">Marco operates K5LBJ while Davis logs.<br>
			(October 2019 -- School Club Roundup)<br>
			<em><span style="font-size:10px">(Click Image to Enlarge) </span></em></span></p>
			</td>
			<td style="vertical-align:top"><br>
			<span style="font-family:Verdana,Geneva,sans-serif">Kyle, KI5DKM, is Club President of K5LBJ (2019-2020).<br>
			<br>
			<em><span style="font-size:10px">(Click Image to Enlarge) </span></em></span></td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2018-2019 School Year</span></strong></u></span></p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:1000px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/k5lbj_spring_2019.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:750px; width:1000px"></span></td>
		</tr>
		<tr>
			<td>
			<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px"><span style="text-align:center">The LASA Amateur Radio Club -- Spring 2019 </span></span></span></p>

			<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px"><span style="color:#ff0000; text-align:center">1st Place in High School Division<br>
			(February 2019 -- School Club Roundup)</span></span></span></p>

			<div><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">Front Row:  Vishwa (KI5DZZ), Rishi (KI5CVH), Carl (KI5DDJ), David (KI5EIG), and Marc</span></span></div>

			<div><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">Back Row:  Jack (KI5EXG), Spencer (KI5EKY), Kyle (KI5DKM), Rogan (KI5ELA), Mason (KI5DZX), Ted (KE5EDT), and Tyler (KI5DVH)</span></span></div>

			<div><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">Not Pictured:  Eric (K5FCN)</span></span></div>
			</td>
		</tr>
	</tbody>
</table>

<table align="center" border="0" cellpadding="5" cellspacing="5" style="width:1000px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/se_manual_kyla_hayworth_dec_2018.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="border-style:solid; border-width:2px; height:660px; width:500px"></span></td>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><span style="text-align:justify"><span style="color:#ff0000">K5LBJ members are proud to grace the cover of the ARRL&#39;s 4th edition of the Technician Class &quot;Ham Radio License Manual.&quot;</span>  Shown on the cover are May 2018 LASA graduates, Kyla Hayworth (KG5SVF), and Reed Hanson (KG5SVG).   The photo was taken while they were operating in the February 2017 &quot;School Club Roundup&quot; as they led K5LBJ to a 1st place finish in the high school category.</span></span></td>
		</tr>
	</tbody>
</table>

<p><span style="font-family:Verdana,Geneva,sans-serif">The Spring 2019 Amateur Radio class had fun playing with Slow Scan TV (SSTV) by using tape-measure antennas and HTs.  Students used Android software on their phones (SSTV Encoder to send/Robot36 to decode) to generate/decode the SSTV audio.</span></p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:1000px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/DSC_7727.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:467px; width:700px"></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/DSC_7729.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:200px; width:300px"></span></td>
		</tr>
		<tr>
			<td style="vertical-align:top"><span style="font-family:Verdana,Geneva,sans-serif">Spring, 2019, members of K5LBJ after succesfully transmitting/decoding an image via SSTV.</span></td>
			<td style="vertical-align:top"><span style="font-family:Verdana,Geneva,sans-serif">SSTV image original (left) and received (right).</span></td>
		</tr>
	</tbody>
</table>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px; text-align:justify">The 2018-2019 school year welcomed another chance to compete in the &quot;School Club Roundup&quot; competition.  During the February, 2019, &quot;School Club Roundup,&quot; 16 students from K5LBJ operated.  Together, they made 623 phone contacts, 2 CW contacts (one with K3FBI), and 13 digital contacts (PSK31) in 47 states, 8 countries, and 6 Canadian provinces.  This was the <span style="color:#ff0000">first ever &quot;School Club Roundup&quot; where students made contacts using three different modes</span>.  </span><span style="background-color:#ffffff; font-size:16px; text-align:justify">The students&#39; hard work and determination in spite of poor band conditions allowed them to be </span><span style="background-color:#ffffff; color:#ff0000; font-size:16px; text-align:justify">#1 in the High School category in the <a href="http://contests.arrl.org/scrscores.php?iid=595" target="_blank">Spring 2019 &quot;School Club Roundup</a>.&quot;</span></span></p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:1000px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/DSC_7738.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:334px; width:500px"></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/DSC_7757.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:334px; width:500px"></span></td>
		</tr>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif">K5LBJ member, Jack, operates during the February, 2019 &quot;School Club Roundup&quot; while David logs his contacts.</span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif">2018-2019 K5LBJ President, Sankarsh (aka &quot;Bob&quot; on the air), KG5VKF, operates during the February, 2019 &quot;School Club Roundup&quot; while Rishi (aka &quot;Jeff&quot; on the air), KI5CVH, logs his contacts.</span></td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">The <span style="color:#ff0000">October, 2018, &quot;School Club Roundup&quot;</span> showed what a  small group of students (led by Esteban, KG5WJX, Sankarsh, KG5VKF, and John, KG5WHM) could do.  Together, they <span style="color:#ff0000">made 708 contacts</span> in 44 states, 13 countries, and 6 Canadian provinces.  As band conditions were &quot;lousy to bad,&quot; students were happy with this performance.</span></span></p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:1000px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/20181019_151215.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:375px; width:500px"></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/esteban_scr_oct_2018.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:453px; width:600px"></span></td>
		</tr>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif">Esteban, KG5WJX, operates during October 2018 &quot;School Club Roundup,&quot; while Sankarsh, KG5VKF, logs contacts.</span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif">Esteban, KGWJX, operates during October 2018 &quot;School Club Roundup,&quot; while K5LBJ Trustee, Ronny Risinger, KC5EES, logs contacts.</span></td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif">The <span style="color:#ff0000">K5LBJ &quot;Radio Room&quot; as of February, 2019.</span></span></p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:1000px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/DSC_7740.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/DSC_7740.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:223px; width:334px"></a></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/DSC_7742.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/DSC_7742.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:222px; width:333px"></a></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/DSC_7743.jpg" target="_blank"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/DSC_7743.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:222px; width:333px"></a></span></td>
		</tr>
		<tr>
			<td style="text-align:justify; vertical-align:top">
			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif">The main operating bench of K5LBJ.  We proudly display many of the great QSL cards that we receive.</span></p>

			<address><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:11px">(Click Image to Enlarge)</span></span></address>
			</td>
			<td style="text-align:justify; vertical-align:top">
			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif">View from the door of the &quot;Radio Room.&quot;  Along the right wall, you can see our Flex3000 and &quot;Satellite Station&quot; radio (Icom 910H). All radios can be connected to any antenna on the roof via the &quot;patch panel&quot; in the left corner.</span></p>

			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:11px"><em>(Click Image to Enlarge)</em></span></span></p>
			</td>
			<td style="text-align:justify; vertical-align:top">
			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif">View showing main bench of left, and SDR (FlexRadio) and &quot;Satellite Station&quot; on the right.</span></p>

			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:11px"><em>(Click Image to Enlarge)</em></span></span></p>
			</td>
		</tr>
	</tbody>
</table>

<p> </p>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2017-2018 School Year</span></strong></u></span></p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:500px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/ST_August_2017_sora_sunby_kg5spq.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:513px; width:1000px"></span></td>
		</tr>
		<tr>
			<td style="text-align:justify; vertical-align:top">
			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px"><span style="background-color:#ffffff; color:#1d2129">The August 2017 issue of QST features Sora, KG5SPQ, (far right photo) in a &quot;Get On the Air&quot; ad campaign. </span><br>
			She was a 2016-2018 LASA High School Amateur Radio Club member.</span></span></p>
			</td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif">In the Fall 2017 School Club Roundup, K5LBJ&#39;s student operators made 920 contacts with 48 states, 4 Canadian provinces, 12 countries, and 52 schools. Students had a great time, as usual, and one even used <span style="background-color:#ffffff; color:#212121">a Java program that read in callsigns from an SCRLog export and fed them to Callook to translate the callsigns to coordinates (U.S. only) and a format that could be easily read by GIS software (i.e. QGIS).  He then put the graphics together on the GIMP photo editor.  Thus, this </span><span style="color:#ff0000"><span style="background-color:#ffffff">student produced the awesome map below plotting our Fall 2017 School Club Roundup Contacts</span></span><span style="background-color:#ffffff; color:#212121">.</span></span></p>

<table align="center" border="1" cellpadding="5" cellspacing="5" style="width:500px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/019.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="border-style:solid; border-width:3px; height:375px; width:500px"></span></td>
		</tr>
		<tr>
			<td>
			<p><span style="font-family:Verdana,Geneva,sans-serif">Students operating during <span style="color:#ff0000">Fall 2017 &quot;School Club Roundup.</span><span style="color:#ff0000">&quot;  </span> (L-R) Michael (AG5NX), Harrison (KG5WHG), and Ayush (KG5WRJ).</span></p>
			</td>
		</tr>
	</tbody>
</table>

<p> </p>

<table align="center" border="3" cellpadding="1" cellspacing="1" style="width:800px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/map_harrison_tran_k5lbj_oct_2017.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:600px; width:800px"></span></td>
		</tr>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif">Map of K5LBJ Contacts During Fall 2017 &quot;School Club Roundup&quot;<br>
			-- Map Produced by Harrison (KG5WHG)</span></td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="text-align:justify">In <span style="color:#ff0000">Spring 2018, K5LBJ facilitated a direct contact between the International Space Station and Salado Intermediate School</span>.  Club members, John (KG5WHM) and Sankarsh (KG5VKF), helped transport/setup the Club&#39;s satellite equipment in the teacher&#39;s classroom and later upon the roof of the school.  On April 17, 2018, about 600 people in the Salado School cafeteria enjoyed almost 10 minutes of direct communication with an astronaut in space thanks to K5LBJ&#39;s satellite tracking/communication station.</span></span></p>

<table border="3" cellpadding="1" cellspacing="1" style="width:500px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/20180417_125258.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:376px; width:500px"></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/20180413_150633.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:376px; width:500px"></span></td>
		</tr>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><span style="text-align:justify">Club members, John (KG5WHM</span><span style="text-align:justify">) and Sankarsh (KG5VKF</span><span style="text-align:justify">) installing K5LBJ&#39;s</span><span style="text-align:justify"> </span><span style="text-align:justify">satellite equipment on the roof of Salado Intermediate School.</span></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif">K5LBJ Trustee, Ronny Risinger (KC5EES) and Club Elmer, Joe Fisher (K5EJL) installing K5LBJ&#39;s satellite equipment on the roof of Salado Intermediate.  Because the roof was slanted, the Club made a platform that could be adjusted to level the antenna mast.</span></td>
		</tr>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/20180407_124520.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:376px; width:500px"></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/risinger_ariss_contact_4_17_2018.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:290px; width:500px"></span></td>
		</tr>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif">(L-R) Salado Intermediate teachers Laura Tomlin and Colleen Gilchrest who arranged the contact with the International Space Station via ARISS, along with K5LBJ club members, John (KG5WHM) and Sankarsh (KG5VKF).  K5LBJ&#39;s satellite radio and computer control are shown in the background.</span></td>
			<td style="vertical-align:top"><span style="font-family:Verdana,Geneva,sans-serif">K5LBJ Trustee, Ronny Risinger (KC5EES), watches as &quot;first contact&quot; is made with the International Space Station.</span></td>
		</tr>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/lado_iss_mentors_photo_4_17_2018.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:409px; width:500px"></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/iss_qsl_salado_school.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:658px; width:500px"></span></td>
		</tr>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif">The &quot;post contact&quot; photo of the mentors that helped make the successful contact with the International Space Station possible.  Salado Intermediate School cafeteria (4-17-2018).</span></td>
			<td style="vertical-align:top"><span style="font-family:Verdana,Geneva,sans-serif">QSL card commemorating the successful contact between the International Space Station and Salado Intermediate School on April 17, 2018.</span><br>
			 </td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2016-2017 School Year</span></strong></u></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/k5lbj_spring_2017.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="border-style:solid; border-width:2px; float:left; height:525px; margin:5px; text-align:center; width:700px"></span></p>

<p> </p>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px"><span style="text-align:center">The LASA Amateur Radio Club -- Spring 2017 </span></span></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px"><span style="color:#ff0000; text-align:center">1st Place in High School Division<br>
(February 2017 -- School Club Roundup)</span></span></span></p>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">In the Spring 2017 School Club Roundup, K5LBJ&#39;s student operators made 863 contacts with 46 states, 6 Canadian provinces, 18 countries, and 45 schools. This outstanding effort earned them the <span style="color:#ff0000">#1 ranking in the High School category in the <a href="https://www.b4h.net/arrlscr/scr_scores201702.php" target="_blank">Spring 2017 School Club Roundup</a> contest</span>.  </span></span></p>

<table align="center" border="5" cellpadding="1" cellspacing="1" style="width:500px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/feb_2017_scr_01.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="border-style:solid; border-width:5px; height:413px; margin:5px; width:550px"></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/feb_2017_scr_02.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="border-style:solid; border-width:5px; height:413px; margin:5px; width:550px"></span></td>
		</tr>
		<tr>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">Travis, KG5SHT, takes the mic while Reed, KG5SVG, handles logging detail during the Feb. 2017 &quot;School Club Roundup.&quot;  Together, these two young men made over 300 contacts. </span></span></td>
			<td style="vertical-align:top"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">Lillian, KG5SYW, operates the radio while Sora, KG5SPQ, has fun logging.  The YLs (including Kyla, KG5SVF, not pictured) logged about 320 QSOs during the Feb. 2017 &quot;School Club Roundup.&quot;  Great job, ladies!  </span></span><br>
			 </td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2015-2016 School Year</span></strong></u></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">In Spring 2016, students turned their attention to <a href="http://funcube.org.uk/" target="_blank">FUNcube</a> (AO-73).  They began in earnest to receive telemetry data and send it to the satellite&#39;s administrators.  Of course, students were captivated by the &quot;Fitter&quot; (FUNcube Twitter) messaged relayed by the cubesat.  With an e-mail, students were happy to soon see the <span style="color:#ff0000">LASA Jaguars being recognized worldwide via a FUNcube Fitter message</span>.</span></span></p>

<p> </p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:540px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/funcube.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:132px; width:534px"></span></td>
		</tr>
	</tbody>
</table>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:610px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/fitter_message.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:42px; width:608px"></span></td>
		</tr>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif">The above message was received via the FUNCube satellite on January 14, 2016 by K5LBJ.</span></td>
		</tr>
	</tbody>
</table>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px"><span style="color:#ff0000">During the Spring 2016 School Club Roundup, K5LBJ&#39;s student operators made 915 contacts</span> with 48 states, 5 Canadian provinces, 10 countries, and 41 schools.  But, just as important as running up the QSO count, good operating manners are practiced by K5LBJ.  Rebecca (&quot;Becks&quot;), KG5NZW, one of K5LBJ&#39;s outstanding YL operators, was heard by an Official Observer doing a great job of running stations.  It made her (and the Club&#39;s day) to <span style="color:#ff0000">receive a postcard on February 17, 2016, from the Official Observer recognizing K5LBJ&#39;s &quot;EXCELLENT radio signal quality/operating procedure as a fine example for all radio amateurs.&quot; </span></span></span></p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:500px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/od_operator_report_feb2016_front.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="border-style:solid; border-width:2px; height:415px; width:600px"></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/ood_operator_report_feb2016_back.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="border-style:solid; border-width:2px; height:335px; width:500px"></span></td>
		</tr>
		<tr>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif">&quot;Good Operator Report&quot; received from an Official Observer (Feb. 2016)</span></td>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif">Front of Postcard explains the Official Observer program.</span><br>
			 </td>
		</tr>
	</tbody>
</table>

<table align="center" border="2" cellpadding="1" cellspacing="1" style="width:500px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://cdn-bio.qrz.com/j/k5lbj/spring_2016_class_funcube.JPG"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/spring_2016_class_funcube.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="border-style:solid; border-width:2px; height:450px; margin:5px; width:600px"></a></span></td>
		</tr>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif">The LASA Amateur Radio Club -- Spring 2016 </span></td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2014-2015 School Year</span></strong></u></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">During the Fall 2014 School Club Roundup, K5LBJ&#39;s student operators made 959 contacts (40 of which were CW) with 48 states, 7 Canadian provinces, 49 countries, and 47 schools. This outstanding effort earned them the <span style="color:#ff0000">#1 ranking in the High School category in the <a href="https://www.b4h.net/arrlscr/scr_scores201410.php" target="_blank">Fall 2014 School Club Roundup</a> contest</span>. SCR is the students&#39; favorite activity of the year, and the October 2014 contest will be remembered as one for the ages.  Ten meters was &quot;wide open.&quot;</span></span></p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:800px">
	<tbody>
		<tr>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/IMG_1276.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:300px; width:400px"></span></td>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/IMG_1279.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:300px; width:400px"></span></td>
		</tr>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif">  <span style="font-size:16px">Jacob, KF5UVN, Club President of K5LBJ for 2014-2015, works the October 2014 &quot;School Club Roundup,&quot; while Mirah assists with catching the call to log it.</span></span></td>
			<td style="text-align:center; vertical-align:middle">
			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif">  <span style="font-size:16px">Demaree came by AFTER schoool AFTER dance practice to work a few stations during the October 2014 &quot;School Club Roundup.&quot;  LASA students are very dedicated.</span></span></p>
			</td>
		</tr>
	</tbody>
</table>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">K5LBJ&#39;s satellite tracking/communication station brought new excitement to our club in February 2015.  On Feb. 23rd/24th, the Russians on board the International Space Station were beaming Slow-Scan TV (SSTV) images to Earth.  The images were in celebration of what would have been Yuri Gagarin&#39;s 80th birthday.  The <span style="color:#ff0000">LASA High School Amateur Radio Club received some great images from SPACE! </span></span></span></p>

<table align="center" border="5" cellpadding="1" cellspacing="1" style="width:800px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2015_02_22_11_15_55.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:310px; width:400px"></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/2015_02_23_18_34_37.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:310px; width:400px"></span></td>
		</tr>
		<tr>
			<td colspan="2"><span style="font-family:Verdana,Geneva,sans-serif">SSTV images received by K5LBJ from the Int&#39;l Space Station (Feb.23/24, 2015).</span><br>
			 </td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2013-2014 School Year</span></strong></u></span></p>

<table align="left" border="0" cellpadding="1" cellspacing="10" style="width:700px">
	<tbody>
		<tr>
			<td>
			<p><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/137_rotated.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:226px; margin:10px; width:300px"><br>
			<span style="font-size:16px">The above code oscillator circuit was constructed by Jacob, KF5UVN, in Spring 2013. Jacob would soon go on to become very proficient at CW. He even purchased a &#39;Bug&#39; and now runs 20 wpm+. The photo at right shows Jacob operating during the October 2013 &quot;School Club Roundup&quot;.</span></span></p>
			</td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/173.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:452px; width:600px"></span><br>
			 </td>
		</tr>
	</tbody>
</table>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<table align="left" border="0" cellpadding="1" cellspacing="20" style="width:700px">
	<tbody>
		<tr>
			<td style="height:6px; text-align:center">
			<p style="text-align:left"><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/k5lbj_2014_cropped.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:541px; width:700px"><span style="font-size:16px">The K5LBJ &quot;Satellite Crew.&quot;  These students completed the satellite tracking/communication station during the Spring 2014 semester</span></span></p>
			</td>
		</tr>
	</tbody>
</table>

<p> </p>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">In Fall 2013, we were fortunate to receive grants to install a complete satellite station (A+ Credit Union provided financial support for the tower and rotators, while the Dayton Amateur Radio Association (DARA) funded coax, and the ARRL ETP program provided the computer interface.  Finally, the Austin Amateur Radio Club (AARC) funded an Icom 910H radio for satellite work.)  During Spring 2014, students assembled the EL/AZ rotator, tripods, building cables, and installed the computer interface to prepare us for working satellites, including the ISS.  On September 19, 2014, K5LBJ mades its <span style="color:#ff0000">first solo satellite contacts</span> through SO-50 (W5PFG, N8RO, NX9B, and WI9I).  After a few weeks of working with packet software, on October 14, 2014, K5LBJ successfully <span style="color:#ff0000">digipeated its first message through the Int&#39;l Space Station</span> (acknowledged by XE1MEX).</span></span></p>

<p> </p>

<p> </p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="height:334px; width:800px">
	<tbody>
		<tr>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/ss_packet_qso_xe1mex_oct_14_2014.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:270px; width:400px"></span></td>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/t_digipeated_ariss_net_us_mexico.JPG?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:273px; width:400px"></span></td>
		</tr>
		<tr>
			<td style="vertical-align:top"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">  A screen capture image of the UISS log showing the Oct. 14, 2014, K5LBJ message being digipeated via ISS.</span></span></td>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px"> The ARISS.net map showing stations whose signal digipeated via ISS.  K5LBJ is the &quot;little, red school&quot; in TX.  XE1MEX acknowledged the message and is also shown.</span></span></td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2012-2013 School Year</span></strong></u></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px"><span style="text-align:justify">In Fall 2012, students decided to participate in the November Phone Sweepstakes contest.  They made 307 contacts with 81 of 83 sections.  Thus,</span><span style="color:#ff0000; text-align:justify"> in the November 2012 Phone Sweepstakes contest, K5LBJ placed 1st among schools in the West Gulf Division</span><span style="text-align:justify">.  This garnered K5LBJ its first ever piece of &quot;walnut&quot; for the wall. </span></span></span></p>

<table align="left" border="0" cellpadding="1" cellspacing="10" style="width:900px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/033.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="float:left; height:452px; margin:20px; text-align:justify; width:600px"></span></td>
			<td style="width:200px"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px"><span style="text-align:justify">Our February 2013  &quot;School Club Roundup&quot; operators included Elliott, AF5HH, and Makala, KF5TGG, working as a great team.</span></span></span></td>
		</tr>
	</tbody>
</table>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2011-2012 School Year</span></strong></u></span></p>

<table align="left" border="0" cellpadding="1" cellspacing="1" style="width:900px">
	<tbody>
		<tr>
			<td style="vertical-align:middle"><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">In January 2012, K5LBJ was fortunate to host Nobel Prize winner and Amateur Radio operator, Joe Taylor, K1JT.</span></span></td>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/084.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:468px; margin:20px; width:700px"></span><br>
			 </td>
		</tr>
	</tbody>
</table>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2010-2011 School Year</span></strong></u></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/039.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="float:left; height:307px; margin:20px; width:409px"></span></p>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">We really enjoy the homebrew aspect of Amateur Radio. Our Spring 2011 project was to build a portable, HF vertical antenna. Inspired by the &#39;Minuteman 20,&#39; LASA students set to work. Using PVC conduit for supports and coil forms and stereo wire for ground radials, they built a fine antenna. The goal was to build an antenna that would would operate on 17/20/40 meters. In its first test, the vertical reached Germany (5385 miles) and Sommerville, TX (64 miles). Student success!</span></span></p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2009-2010 School Year</span></strong></u></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px; text-align:justify">Our club was also featured on the cover of the September, 2010, edition of &quot;Monitoring Times&quot; magazine.</span></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px; text-align:justify">During the Fall 2010 School Club Roundup, K5LBJ&#39;s 13 student operators made 577 contacts with 47 states, 5 Canadian provinces, 13 countries, and 33 schools. This outstanding effort earned them the </span><span style="color:#ff0000; font-size:16px; text-align:justify">#1 ranking in the High School category in the Fall 2010 School Club Roundup contest</span><span style="font-size:16px; text-align:justify">.</span></span></p>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2008-2009 School Year</span></strong></u></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px; text-align:justify">On October 19, 2008, our club was privileged to make contact with Richard Garriott, W5KWQ, while he was onboard the International Space Station. Many thanks go out to Mr. Garriott, NASA, and the many people involved in ARISS.</span></span></p>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><u><strong><span style="font-size:16px">2006-2007 School Year</span></strong></u></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">We have enjoyed competing in the School Club Roundup contest. We were proud to be <span style="color:#ff0000">#1 in the High School category in 2006</span>.</span></span></p>

<p> </p>

<table align="center" border="5" cellpadding="1" cellspacing="1" style="width:800px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><strong>Equipment at K5LBJ</strong></span></td>
		</tr>
		<tr>
			<td>
			<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">At present, we have a &quot;Radio Room&quot; which has an Icom 706MkIIg as the primary HF rig.  The radio can run through either an AT-180 automatic antenna tuner (100 watt operation) or an MFJ-998 automatic antenna tuner linked to an Ameritron ALS-600 Solid State Amp (600 watt operation).  Our &quot;B&quot; operator station has a Flex-3000 Software Defined Radio for HF operation, and this table also has our &quot;satellite station&quot; using an Icom-910H transceiver interfacing with a Dell computer to compute Doppler shift and drive our satellite antennas via interface to Yaesu G-5500.</span></span></p>

			<p><span style="font-family:Verdana,Geneva,sans-serif"><span style="font-size:16px">In Fall 2018, the antenna farm includes a Cushcraft HF vertical antenna, a Gap Challenger (homebrewed) HF vertical, a G5RV dipole (mounted between push-up masts), and a Cushcraft VHF/UHF Yagi (in tripod with rotator). For satellite operation, we have a small tower outfitted with a Yaesu G-5500 el/az rotator to aim 2m/440 cross-polarized yagi antennas.  In addition, we have a helical antenna mounted for reception of the NOAA Weather Satellites (each day we capture NOAA-15 images and display them on a large computer screen in the school hallway).  </span><span style="font-size:16px; text-align:justify">All of our antennas are located on the roof of our school.</span><span style="font-size:16px">  </span><br>
			<span style="font-size:16px">All radios in the &quot;Radio Room&quot; can be connected to any antenna via a patch panel.</span><br>
			<br>
			<span style="font-size:16px; text-align:justify">We also have a &quot;Classroom Station&quot; which has an ICOM 706MkIIG running through an MFJ Versatuner II. </span></span></p>
			</td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif">---------------------------------------------------------------------------------------------------------------------------------</span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif">Students usually operate before school (7:30-8:30 a.m. CST) or during lunch (normally 11:40 a.m. - 12:40 p.m. CST). If you would like to <span style="color:#ff0000">arrange a sked</span>, e-mail club Trustee, Ronny Risinger, at ronny dot risinger at austinisd dot org.<br>
<br>
If you make a contact with us, please QSL. We love to look at them and be reminded of all the wonderful places/people we&#39;ve made contact with.</span></p>

<p> </p>

<table align="center" border="1" cellpadding="1" cellspacing="1" style="width:500px">
	<tbody>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif"><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/j/k5lbj/122.jpg?p=79ae83c0e8a803b8ee6e8cd7c0645590" style="height:533px; width:708px"></span></td>
		</tr>
		<tr>
			<td><span style="font-family:Verdana,Geneva,sans-serif">The 2013-2014 members of K5LBJ stand upon the school&#39;s roof which is emblazoned with the club callsign.</span></td>
		</tr>
	</tbody>
</table>

<p> </p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://info.flagcounter.com/w9Lj"><img alt="Flag Counter" src="https://s10.flagcounter.com/count2_US/w9Lj/bg_FFFFFF/txt_000000/border_CCCCCC/columns_8/maxflags_50/viewers_0/labels_1/pageviews_0/flags_0/percent_0/"></a></span></p>

<p><span style="font-family:Verdana,Geneva,sans-serif"><a href="https://info.flagcounter.com/xdgr"><img alt="Flag Counter" src="https://s04.flagcounter.com/count2/xdgr/bg_FFFFFF/txt_000000/border_CCCCCC/columns_8/maxflags_50/viewers_DX+Visitors/labels_1/pageviews_0/flags_0/percent_0/"></a></span></p>

<div> </div>

<div> </div>

<div> </div>
") ); jQuery('.action-render-').contents().find('#biodata a').each(function() { var attr = jQuery(this).attr('href'); if (typeof attr !== typeof undefined && attr !== false) { if (attr.indexOf("#") != 0 ) { // if ( ! this.hasAttribute('target') ) { if ( jQuery(this).attr('target') == undefined ) { jQuery(this).attr('target', '_top'); } jQuery(this).attr('href', jQuery(this).attr('href') ); } else { // jQuery(this).attr('target', '_parent'); } } }); function youtube_parser(url){ var regExp = /.*(?:youtu.be\/|v\/|u\/w\/|embed\/|watch\?v=)([^#\&\?]*).*/; var match = url.match(regExp); return (match&&match[1].length==11)? match[1] : false; } var iframes = jQuery('.action-render-').contents().find('iframe'); jQuery.each( iframes, function(k,v) { var yt_url = jQuery(v).attr('src'); if ( !yt_url ) { return true; } var yt_img_url = "//img.youtube.com/vi/" + youtube_parser(yt_url) + "/mqdefault.jpg"; var yt_width = jQuery(v).attr('width'); var yt_height = jQuery(v).attr('height'); if ( yt_url.indexOf('youtu') !== -1 ) { jQuery(v).after("" + "" + "" + "
    " + "
    " + "    "); jQuery(v).remove(); } if ( jQuery(v).attr('data-refresh') >= 1 ) { if ( jQuery(v).attr('data-refresh') <= 30 ) { jQuery(v).attr('data-refresh', 30) } setInterval( function() { jQuery(v).attr('src', jQuery(v).attr('src')); } , jQuery(v).attr('data-refresh')*1000); } }); // Inject CSS jQuery('.action-render-').contents().find('head').append( jQuery('